[pcsx_rearmed.git] / deps / libchdr / deps / zlib-1.2.13 / contrib / minizip / zip.h

/* zip.h -- IO on .zip files using zlib
   Version 1.1, February 14h, 2010
   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )

         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )

         Modifications for Zip64 support
         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )

         For more info read MiniZip_info.txt

         ---------------------------------------------------------------------------

   Condition of use and distribution are the same than zlib :

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

        ---------------------------------------------------------------------------

        Changes

        See header of zip.h

*/

#ifndef _zip12_H
#define _zip12_H

#ifdef __cplusplus
extern "C" {
#endif

//#define HAVE_BZIP2

#ifndef _ZLIB_H
#include "zlib.h"
#endif

#ifndef _ZLIBIOAPI_H
#include "ioapi.h"
#endif

#ifdef HAVE_BZIP2
#include "bzlib.h"
#endif

#define Z_BZIP2ED 12

#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted
    from (void*) without cast */
typedef struct TagzipFile__ { int unused; } zipFile__;
typedef zipFile__ *zipFile;
#else
typedef voidp zipFile;
#endif

#define ZIP_OK                          (0)
#define ZIP_EOF                         (0)
#define ZIP_ERRNO                       (Z_ERRNO)
#define ZIP_PARAMERROR                  (-102)
#define ZIP_BADZIPFILE                  (-103)
#define ZIP_INTERNALERROR               (-104)

#ifndef DEF_MEM_LEVEL
#  if MAX_MEM_LEVEL >= 8
#    define DEF_MEM_LEVEL 8
#  else
#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
#  endif
#endif
/* default memLevel */

/* tm_zip contain date/time info */
typedef struct tm_zip_s
{
    int tm_sec;             /* seconds after the minute - [0,59] */
    int tm_min;             /* minutes after the hour - [0,59] */
    int tm_hour;            /* hours since midnight - [0,23] */
    int tm_mday;            /* day of the month - [1,31] */
    int tm_mon;             /* months since January - [0,11] */
    int tm_year;            /* years - [1980..2044] */
} tm_zip;

typedef struct
{
    tm_zip      tmz_date;       /* date in understandable format           */
    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */

    uLong       internal_fa;    /* internal file attributes        2 bytes */
    uLong       external_fa;    /* external file attributes        4 bytes */
} zip_fileinfo;

typedef const char* zipcharpc;


#define APPEND_STATUS_CREATE        (0)
#define APPEND_STATUS_CREATEAFTER   (1)
#define APPEND_STATUS_ADDINZIP      (2)

extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
/*
  Create a zipfile.
     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
       an Unix computer "zlib/zlib113.zip".
     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
       will be created at the end of the file.
         (useful if the file contain a self extractor code)
     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
       add files in existing zip (be sure you don't add file that doesn't exist)
     If the zipfile cannot be opened, the return value is NULL.
     Else, the return value is a zipFile Handle, usable with other function
       of this zip package.
*/

/* Note : there is no delete function into a zipfile.
   If you want delete file into a zipfile, you must open a zipfile, and create another
   Of couse, you can use RAW reading and writing to copy the file you did not want delte
*/

extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
                                   int append,
                                   zipcharpc* globalcomment,
                                   zlib_filefunc_def* pzlib_filefunc_def));

extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
                                   int append,
                                   zipcharpc* globalcomment,
                                   zlib_filefunc64_def* pzlib_filefunc_def));

extern zipFile ZEXPORT zipOpen3 OF((const void *pathname,
                                    int append,
                                    zipcharpc* globalcomment,
                                    zlib_filefunc64_32_def* pzlib_filefunc64_32_def));

extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
                       const char* filename,
                       const zip_fileinfo* zipfi,
                       const void* extrafield_local,
                       uInt size_extrafield_local,
                       const void* extrafield_global,
                       uInt size_extrafield_global,
                       const char* comment,
                       int method,
                       int level));

extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
                       const char* filename,
                       const zip_fileinfo* zipfi,
                       const void* extrafield_local,
                       uInt size_extrafield_local,
                       const void* extrafield_global,
                       uInt size_extrafield_global,
                       const char* comment,
                       int method,
                       int level,
                       int zip64));

/*
  Open a file in the ZIP for writing.
  filename : the filename in zip (if NULL, '-' without quote will be used
  *zipfi contain supplemental information
  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
    contains the extrafield data the the local header
  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
    contains the extrafield data the the local header
  if comment != NULL, comment contain the comment string
  method contain the compression method (0 for store, Z_DEFLATED for deflate)
  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
  zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
                    this MUST be '1' if the uncompressed size is >= 0xffffffff.

*/


extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
                                            const char* filename,
                                            const zip_fileinfo* zipfi,
                                            const void* extrafield_local,
                                            uInt size_extrafield_local,
                                            const void* extrafield_global,
                                            uInt size_extrafield_global,
                                            const char* comment,
                                            int method,
                                            int level,
                                            int raw));


extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
                                            const char* filename,
                                            const zip_fileinfo* zipfi,
                                            const void* extrafield_local,
                                            uInt size_extrafield_local,
                                            const void* extrafield_global,
                                            uInt size_extrafield_global,
                                            const char* comment,
                                            int method,
                                            int level,
                                            int raw,
                                            int zip64));
/*
  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
 */

extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
                                            const char* filename,
                                            const zip_fileinfo* zipfi,
                                            const void* extrafield_local,
                                            uInt size_extrafield_local,
                                            const void* extrafield_global,
                                            uInt size_extrafield_global,
                                            const char* comment,
                                            int method,
                                            int level,
                                            int raw,
                                            int windowBits,
                                            int memLevel,
                                            int strategy,
                                            const char* password,
                                            uLong crcForCrypting));

extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
                                            const char* filename,
                                            const zip_fileinfo* zipfi,
                                            const void* extrafield_local,
                                            uInt size_extrafield_local,
                                            const void* extrafield_global,
                                            uInt size_extrafield_global,
                                            const char* comment,
                                            int method,
                                            int level,
                                            int raw,
                                            int windowBits,
                                            int memLevel,
                                            int strategy,
                                            const char* password,
                                            uLong crcForCrypting,
                                            int zip64
                                            ));

/*
  Same than zipOpenNewFileInZip2, except
    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
    password : crypting password (NULL for no crypting)
    crcForCrypting : crc of file to compress (needed for crypting)
 */

extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
                                            const char* filename,
                                            const zip_fileinfo* zipfi,
                                            const void* extrafield_local,
                                            uInt size_extrafield_local,
                                            const void* extrafield_global,
                                            uInt size_extrafield_global,
                                            const char* comment,
                                            int method,
                                            int level,
                                            int raw,
                                            int windowBits,
                                            int memLevel,
                                            int strategy,
                                            const char* password,
                                            uLong crcForCrypting,
                                            uLong versionMadeBy,
                                            uLong flagBase
                                            ));


extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
                                            const char* filename,
                                            const zip_fileinfo* zipfi,
                                            const void* extrafield_local,
                                            uInt size_extrafield_local,
                                            const void* extrafield_global,
                                            uInt size_extrafield_global,
                                            const char* comment,
                                            int method,
                                            int level,
                                            int raw,
                                            int windowBits,
                                            int memLevel,
                                            int strategy,
                                            const char* password,
                                            uLong crcForCrypting,
                                            uLong versionMadeBy,
                                            uLong flagBase,
                                            int zip64
                                            ));
/*
  Same than zipOpenNewFileInZip4, except
    versionMadeBy : value for Version made by field
    flag : value for flag field (compression level info will be added)
 */


extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
                       const void* buf,
                       unsigned len));
/*
  Write data in the zipfile
*/

extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
/*
  Close the current file in the zipfile
*/

extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
                                            uLong uncompressed_size,
                                            uLong crc32));

extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
                                            ZPOS64_T uncompressed_size,
                                            uLong crc32));

/*
  Close the current file in the zipfile, for file opened with
    parameter raw=1 in zipOpenNewFileInZip2
  uncompressed_size and crc32 are value for the uncompressed size
*/

extern int ZEXPORT zipClose OF((zipFile file,
                const char* global_comment));
/*
  Close the zipfile
*/


extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
/*
  zipRemoveExtraInfoBlock -  Added by Mathias Svensson

  Remove extra information block from a extra information data for the local file header or central directory header

  It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.

  0x0001 is the signature header for the ZIP64 extra information blocks

  usage.
                        Remove ZIP64 Extra information from a central director extra field data
              zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);

                        Remove ZIP64 Extra information from a Local File Header extra field data
        zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
*/

#ifdef __cplusplus
}
#endif

#endif /* _zip64_H */
Commit	Line	Data
9e052883	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	int tm_sec; /* seconds after the minute - [0,59] */
92	int tm_min; /* minutes after the hour - [0,59] */
93	int tm_hour; /* hours since midnight - [0,23] */
94	int tm_mday; /* day of the month - [1,31] */
95	int tm_mon; /* months since January - [0,11] */
96	int 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 zipFile ZEXPORT zipOpen3 OF((const void *pathname,
148	int append,
149	zipcharpc* globalcomment,
150	zlib_filefunc64_32_def* pzlib_filefunc64_32_def));
151
152	extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
153	const char* filename,
154	const zip_fileinfo* zipfi,
155	const void* extrafield_local,
156	uInt size_extrafield_local,
157	const void* extrafield_global,
158	uInt size_extrafield_global,
159	const char* comment,
160	int method,
161	int level));
162
163	extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
164	const char* filename,
165	const zip_fileinfo* zipfi,
166	const void* extrafield_local,
167	uInt size_extrafield_local,
168	const void* extrafield_global,
169	uInt size_extrafield_global,
170	const char* comment,
171	int method,
172	int level,
173	int zip64));
174
175	/*
176	Open a file in the ZIP for writing.
177	filename : the filename in zip (if NULL, '-' without quote will be used
178	*zipfi contain supplemental information
179	if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
180	contains the extrafield data the the local header
181	if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
182	contains the extrafield data the the local header
183	if comment != NULL, comment contain the comment string
184	method contain the compression method (0 for store, Z_DEFLATED for deflate)
185	level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
186	zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
187	this MUST be '1' if the uncompressed size is >= 0xffffffff.
188
189	*/
190
191
192	extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
193	const char* filename,
194	const zip_fileinfo* zipfi,
195	const void* extrafield_local,
196	uInt size_extrafield_local,
197	const void* extrafield_global,
198	uInt size_extrafield_global,
199	const char* comment,
200	int method,
201	int level,
202	int raw));
203
204
205	extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
206	const char* filename,
207	const zip_fileinfo* zipfi,
208	const void* extrafield_local,
209	uInt size_extrafield_local,
210	const void* extrafield_global,
211	uInt size_extrafield_global,
212	const char* comment,
213	int method,
214	int level,
215	int raw,
216	int zip64));
217	/*
218	Same than zipOpenNewFileInZip, except if raw=1, we write raw file
219	*/
220
221	extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
222	const char* filename,
223	const zip_fileinfo* zipfi,
224	const void* extrafield_local,
225	uInt size_extrafield_local,
226	const void* extrafield_global,
227	uInt size_extrafield_global,
228	const char* comment,
229	int method,
230	int level,
231	int raw,
232	int windowBits,
233	int memLevel,
234	int strategy,
235	const char* password,
236	uLong crcForCrypting));
237
238	extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
239	const char* filename,
240	const zip_fileinfo* zipfi,
241	const void* extrafield_local,
242	uInt size_extrafield_local,
243	const void* extrafield_global,
244	uInt size_extrafield_global,
245	const char* comment,
246	int method,
247	int level,
248	int raw,
249	int windowBits,
250	int memLevel,
251	int strategy,
252	const char* password,
253	uLong crcForCrypting,
254	int zip64
255	));
256
257	/*
258	Same than zipOpenNewFileInZip2, except
259	windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
260	password : crypting password (NULL for no crypting)
261	crcForCrypting : crc of file to compress (needed for crypting)
262	*/
263
264	extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
265	const char* filename,
266	const zip_fileinfo* zipfi,
267	const void* extrafield_local,
268	uInt size_extrafield_local,
269	const void* extrafield_global,
270	uInt size_extrafield_global,
271	const char* comment,
272	int method,
273	int level,
274	int raw,
275	int windowBits,
276	int memLevel,
277	int strategy,
278	const char* password,
279	uLong crcForCrypting,
280	uLong versionMadeBy,
281	uLong flagBase
282	));
283
284
285	extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
286	const char* filename,
287	const zip_fileinfo* zipfi,
288	const void* extrafield_local,
289	uInt size_extrafield_local,
290	const void* extrafield_global,
291	uInt size_extrafield_global,
292	const char* comment,
293	int method,
294	int level,
295	int raw,
296	int windowBits,
297	int memLevel,
298	int strategy,
299	const char* password,
300	uLong crcForCrypting,
301	uLong versionMadeBy,
302	uLong flagBase,
303	int zip64
304	));
305	/*
306	Same than zipOpenNewFileInZip4, except
307	versionMadeBy : value for Version made by field
308	flag : value for flag field (compression level info will be added)
309	*/
310
311
312	extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
313	const void* buf,
314	unsigned len));
315	/*
316	Write data in the zipfile
317	*/
318
319	extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
320	/*
321	Close the current file in the zipfile
322	*/
323
324	extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
325	uLong uncompressed_size,
326	uLong crc32));
327
328	extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
329	ZPOS64_T uncompressed_size,
330	uLong crc32));
331
332	/*
333	Close the current file in the zipfile, for file opened with
334	parameter raw=1 in zipOpenNewFileInZip2
335	uncompressed_size and crc32 are value for the uncompressed size
336	*/
337
338	extern int ZEXPORT zipClose OF((zipFile file,
339	const char* global_comment));
340	/*
341	Close the zipfile
342	*/
343
344
345	extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
346	/*
347	zipRemoveExtraInfoBlock - Added by Mathias Svensson
348
349	Remove extra information block from a extra information data for the local file header or central directory header
350
351	It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
352
353	0x0001 is the signature header for the ZIP64 extra information blocks
354
355	usage.
356	Remove ZIP64 Extra information from a central director extra field data
357	zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
358
359	Remove ZIP64 Extra information from a Local File Header extra field data
360	zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
361	*/
362
363	#ifdef __cplusplus
364	}
365	#endif
366
367	#endif /* _zip64_H */