]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | |
44 | extern "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 */ | |
66 | typedef struct TagzipFile__ { int unused; } zipFile__; | |
67 | typedef zipFile__ *zipFile; | |
68 | #else | |
69 | typedef 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 */ | |
89 | typedef 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 | ||
99 | typedef 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 | ||
109 | typedef const char* zipcharpc; | |
110 | ||
111 | ||
112 | #define APPEND_STATUS_CREATE (0) | |
113 | #define APPEND_STATUS_CREATEAFTER (1) | |
114 | #define APPEND_STATUS_ADDINZIP (2) | |
115 | ||
116 | extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); | |
117 | extern 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 | ||
137 | extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, | |
138 | int append, | |
139 | zipcharpc* globalcomment, | |
140 | zlib_filefunc_def* pzlib_filefunc_def)); | |
141 | ||
142 | extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, | |
143 | int append, | |
144 | zipcharpc* globalcomment, | |
145 | zlib_filefunc64_def* pzlib_filefunc_def)); | |
146 | ||
147 | extern 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 | ||
158 | extern 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 | ||
187 | extern 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 | ||
200 | extern 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 | ||
216 | extern 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 | ||
233 | extern 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 | ||
259 | extern 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 | ||
280 | extern 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 | ||
307 | extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, | |
308 | const void* buf, | |
309 | unsigned len)); | |
310 | /* | |
311 | Write data in the zipfile | |
312 | */ | |
313 | ||
314 | extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); | |
315 | /* | |
316 | Close the current file in the zipfile | |
317 | */ | |
318 | ||
319 | extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, | |
320 | uLong uncompressed_size, | |
321 | uLong crc32)); | |
322 | ||
323 | extern 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 | ||
333 | extern int ZEXPORT zipClose OF((zipFile file, | |
334 | const char* global_comment)); | |
335 | /* | |
336 | Close the zipfile | |
337 | */ | |
338 | ||
339 | ||
340 | extern 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 */ |