source: s10k/CommonLibs/zlib-1.2.8/contrib/minizip/zip.h @ 1096

Last change on this file since 1096 was 1096, checked in by s10k, 22 months ago

Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)

File size: 15.0 KB
Line 
1/* zip.h -- IO on .zip files using zlib
2   Version 1.1, February 14h, 2010
3   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
4
5         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
6
7         Modifications for Zip64 support
8         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
9
10         For more info read MiniZip_info.txt
11
12         ---------------------------------------------------------------------------
13
14   Condition of use and distribution are the same than zlib :
15
16  This software is provided 'as-is', without any express or implied
17  warranty.  In no event will the authors be held liable for any damages
18  arising from the use of this software.
19
20  Permission is granted to anyone to use this software for any purpose,
21  including commercial applications, and to alter it and redistribute it
22  freely, subject to the following restrictions:
23
24  1. The origin of this software must not be misrepresented; you must not
25     claim that you wrote the original software. If you use this software
26     in a product, an acknowledgment in the product documentation would be
27     appreciated but is not required.
28  2. Altered source versions must be plainly marked as such, and must not be
29     misrepresented as being the original software.
30  3. This notice may not be removed or altered from any source distribution.
31
32        ---------------------------------------------------------------------------
33
34        Changes
35
36        See header of zip.h
37
38*/
39
40#ifndef _zip12_H
41#define _zip12_H
42
43#ifdef __cplusplus
44extern "C" {
45#endif
46
47//#define HAVE_BZIP2
48
49#ifndef _ZLIB_H
50#include "zlib.h"
51#endif
52
53#ifndef _ZLIBIOAPI_H
54#include "ioapi.h"
55#endif
56
57#ifdef HAVE_BZIP2
58#include "bzlib.h"
59#endif
60
61#define Z_BZIP2ED 12
62
63#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
64/* like the STRICT of WIN32, we define a pointer that cannot be converted
65    from (void*) without cast */
66typedef struct TagzipFile__ { int unused; } zipFile__;
67typedef zipFile__ *zipFile;
68#else
69typedef voidp zipFile;
70#endif
71
72#define ZIP_OK                          (0)
73#define ZIP_EOF                         (0)
74#define ZIP_ERRNO                       (Z_ERRNO)
75#define ZIP_PARAMERROR                  (-102)
76#define ZIP_BADZIPFILE                  (-103)
77#define ZIP_INTERNALERROR               (-104)
78
79#ifndef DEF_MEM_LEVEL
80#  if MAX_MEM_LEVEL >= 8
81#    define DEF_MEM_LEVEL 8
82#  else
83#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
84#  endif
85#endif
86/* default memLevel */
87
88/* tm_zip contain date/time info */
89typedef struct tm_zip_s
90{
91    uInt tm_sec;            /* seconds after the minute - [0,59] */
92    uInt tm_min;            /* minutes after the hour - [0,59] */
93    uInt tm_hour;           /* hours since midnight - [0,23] */
94    uInt tm_mday;           /* day of the month - [1,31] */
95    uInt tm_mon;            /* months since January - [0,11] */
96    uInt tm_year;           /* years - [1980..2044] */
97} tm_zip;
98
99typedef struct
100{
101    tm_zip      tmz_date;       /* date in understandable format           */
102    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
103/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
104
105    uLong       internal_fa;    /* internal file attributes        2 bytes */
106    uLong       external_fa;    /* external file attributes        4 bytes */
107} zip_fileinfo;
108
109typedef const char* zipcharpc;
110
111
112#define APPEND_STATUS_CREATE        (0)
113#define APPEND_STATUS_CREATEAFTER   (1)
114#define APPEND_STATUS_ADDINZIP      (2)
115
116extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
117extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
118/*
119  Create a zipfile.
120     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
121       an Unix computer "zlib/zlib113.zip".
122     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
123       will be created at the end of the file.
124         (useful if the file contain a self extractor code)
125     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
126       add files in existing zip (be sure you don't add file that doesn't exist)
127     If the zipfile cannot be opened, the return value is NULL.
128     Else, the return value is a zipFile Handle, usable with other function
129       of this zip package.
130*/
131
132/* Note : there is no delete function into a zipfile.
133   If you want delete file into a zipfile, you must open a zipfile, and create another
134   Of couse, you can use RAW reading and writing to copy the file you did not want delte
135*/
136
137extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
138                                   int append,
139                                   zipcharpc* globalcomment,
140                                   zlib_filefunc_def* pzlib_filefunc_def));
141
142extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
143                                   int append,
144                                   zipcharpc* globalcomment,
145                                   zlib_filefunc64_def* pzlib_filefunc_def));
146
147extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
148                       const char* filename,
149                       const zip_fileinfo* zipfi,
150                       const void* extrafield_local,
151                       uInt size_extrafield_local,
152                       const void* extrafield_global,
153                       uInt size_extrafield_global,
154                       const char* comment,
155                       int method,
156                       int level));
157
158extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
159                       const char* filename,
160                       const zip_fileinfo* zipfi,
161                       const void* extrafield_local,
162                       uInt size_extrafield_local,
163                       const void* extrafield_global,
164                       uInt size_extrafield_global,
165                       const char* comment,
166                       int method,
167                       int level,
168                       int zip64));
169
170/*
171  Open a file in the ZIP for writing.
172  filename : the filename in zip (if NULL, '-' without quote will be used
173  *zipfi contain supplemental information
174  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
175    contains the extrafield data the the local header
176  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
177    contains the extrafield data the the local header
178  if comment != NULL, comment contain the comment string
179  method contain the compression method (0 for store, Z_DEFLATED for deflate)
180  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
181  zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
182                    this MUST be '1' if the uncompressed size is >= 0xffffffff.
183
184*/
185
186
187extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
188                                            const char* filename,
189                                            const zip_fileinfo* zipfi,
190                                            const void* extrafield_local,
191                                            uInt size_extrafield_local,
192                                            const void* extrafield_global,
193                                            uInt size_extrafield_global,
194                                            const char* comment,
195                                            int method,
196                                            int level,
197                                            int raw));
198
199
200extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
201                                            const char* filename,
202                                            const zip_fileinfo* zipfi,
203                                            const void* extrafield_local,
204                                            uInt size_extrafield_local,
205                                            const void* extrafield_global,
206                                            uInt size_extrafield_global,
207                                            const char* comment,
208                                            int method,
209                                            int level,
210                                            int raw,
211                                            int zip64));
212/*
213  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
214 */
215
216extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
217                                            const char* filename,
218                                            const zip_fileinfo* zipfi,
219                                            const void* extrafield_local,
220                                            uInt size_extrafield_local,
221                                            const void* extrafield_global,
222                                            uInt size_extrafield_global,
223                                            const char* comment,
224                                            int method,
225                                            int level,
226                                            int raw,
227                                            int windowBits,
228                                            int memLevel,
229                                            int strategy,
230                                            const char* password,
231                                            uLong crcForCrypting));
232
233extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
234                                            const char* filename,
235                                            const zip_fileinfo* zipfi,
236                                            const void* extrafield_local,
237                                            uInt size_extrafield_local,
238                                            const void* extrafield_global,
239                                            uInt size_extrafield_global,
240                                            const char* comment,
241                                            int method,
242                                            int level,
243                                            int raw,
244                                            int windowBits,
245                                            int memLevel,
246                                            int strategy,
247                                            const char* password,
248                                            uLong crcForCrypting,
249                                            int zip64
250                                            ));
251
252/*
253  Same than zipOpenNewFileInZip2, except
254    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
255    password : crypting password (NULL for no crypting)
256    crcForCrypting : crc of file to compress (needed for crypting)
257 */
258
259extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
260                                            const char* filename,
261                                            const zip_fileinfo* zipfi,
262                                            const void* extrafield_local,
263                                            uInt size_extrafield_local,
264                                            const void* extrafield_global,
265                                            uInt size_extrafield_global,
266                                            const char* comment,
267                                            int method,
268                                            int level,
269                                            int raw,
270                                            int windowBits,
271                                            int memLevel,
272                                            int strategy,
273                                            const char* password,
274                                            uLong crcForCrypting,
275                                            uLong versionMadeBy,
276                                            uLong flagBase
277                                            ));
278
279
280extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
281                                            const char* filename,
282                                            const zip_fileinfo* zipfi,
283                                            const void* extrafield_local,
284                                            uInt size_extrafield_local,
285                                            const void* extrafield_global,
286                                            uInt size_extrafield_global,
287                                            const char* comment,
288                                            int method,
289                                            int level,
290                                            int raw,
291                                            int windowBits,
292                                            int memLevel,
293                                            int strategy,
294                                            const char* password,
295                                            uLong crcForCrypting,
296                                            uLong versionMadeBy,
297                                            uLong flagBase,
298                                            int zip64
299                                            ));
300/*
301  Same than zipOpenNewFileInZip4, except
302    versionMadeBy : value for Version made by field
303    flag : value for flag field (compression level info will be added)
304 */
305
306
307extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
308                       const void* buf,
309                       unsigned len));
310/*
311  Write data in the zipfile
312*/
313
314extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
315/*
316  Close the current file in the zipfile
317*/
318
319extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
320                                            uLong uncompressed_size,
321                                            uLong crc32));
322
323extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
324                                            ZPOS64_T uncompressed_size,
325                                            uLong crc32));
326
327/*
328  Close the current file in the zipfile, for file opened with
329    parameter raw=1 in zipOpenNewFileInZip2
330  uncompressed_size and crc32 are value for the uncompressed size
331*/
332
333extern int ZEXPORT zipClose OF((zipFile file,
334                const char* global_comment));
335/*
336  Close the zipfile
337*/
338
339
340extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
341/*
342  zipRemoveExtraInfoBlock -  Added by Mathias Svensson
343
344  Remove extra information block from a extra information data for the local file header or central directory header
345
346  It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
347
348  0x0001 is the signature header for the ZIP64 extra information blocks
349
350  usage.
351                        Remove ZIP64 Extra information from a central director extra field data
352              zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
353
354                        Remove ZIP64 Extra information from a Local File Header extra field data
355        zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
356*/
357
358#ifdef __cplusplus
359}
360#endif
361
362#endif /* _zip64_H */
Note: See TracBrowser for help on using the repository browser.