← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to win32/3rdparty/zlib/contrib/minizip/zip.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
win32/3rdparty/zlib/contrib/minizip/zip.h
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 */