summaryrefslogtreecommitdiff
path: root/contrib/minizip
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/minizip')
-rw-r--r--contrib/minizip/ChangeLogUnzip130
-rw-r--r--contrib/minizip/Makefile50
-rw-r--r--contrib/minizip/crypt.h264
-rw-r--r--contrib/minizip/ioapi.c354
-rw-r--r--contrib/minizip/ioapi.h150
-rw-r--r--contrib/minizip/iowin32.c540
-rw-r--r--contrib/minizip/iowin32.h42
-rw-r--r--contrib/minizip/miniunz.c1170
-rw-r--r--contrib/minizip/minizip.c840
-rw-r--r--contrib/minizip/mztools.c562
-rw-r--r--contrib/minizip/mztools.h62
-rw-r--r--contrib/minizip/unzip.c3193
-rw-r--r--contrib/minizip/unzip.h706
-rw-r--r--contrib/minizip/zip.c2407
-rw-r--r--contrib/minizip/zip.h469
15 files changed, 5490 insertions, 5449 deletions
diff --git a/contrib/minizip/ChangeLogUnzip b/contrib/minizip/ChangeLogUnzip
index 4be4d16..e62af14 100644
--- a/contrib/minizip/ChangeLogUnzip
+++ b/contrib/minizip/ChangeLogUnzip
@@ -1,63 +1,67 @@
1Change in 1.01b (20 may 04) 1Change in 1.01e (12 feb 05)
2- Integrate patch from Debian package (submited by Mark Brown) 2- Fix in zipOpen2 for globalcomment (Rolf Kalbermatter)
3- Add tools mztools from Xavier Roche 3- Fix possible memory leak in unzip.c (Zoran Stevanovic)
4 4
5Change in 1.01 (8 may 04) 5Change in 1.01b (20 may 04)
6- fix buffer overrun risk in unzip.c (Xavier Roche) 6- Integrate patch from Debian package (submited by Mark Brown)
7- fix a minor buffer insecurity in minizip.c (Mike Whittaker) 7- Add tools mztools from Xavier Roche
8 8
9Change in 1.00: (10 sept 03) 9Change in 1.01 (8 may 04)
10- rename to 1.00 10- fix buffer overrun risk in unzip.c (Xavier Roche)
11- cosmetic code change 11- fix a minor buffer insecurity in minizip.c (Mike Whittaker)
12 12
13Change in 0.22: (19 May 03) 13Change in 1.00: (10 sept 03)
14- crypting support (unless you define NOCRYPT) 14- rename to 1.00
15- append file in existing zipfile 15- cosmetic code change
16 16
17Change in 0.21: (10 Mar 03) 17Change in 0.22: (19 May 03)
18- bug fixes 18- crypting support (unless you define NOCRYPT)
19 19- append file in existing zipfile
20Change in 0.17: (27 Jan 02) 20
21- bug fixes 21Change in 0.21: (10 Mar 03)
22 22- bug fixes
23Change in 0.16: (19 Jan 02) 23
24- Support of ioapi for virtualize zip file access 24Change in 0.17: (27 Jan 02)
25 25- bug fixes
26Change in 0.15: (19 Mar 98) 26
27- fix memory leak in minizip.c 27Change in 0.16: (19 Jan 02)
28 28- Support of ioapi for virtualize zip file access
29Change in 0.14: (10 Mar 98) 29
30- fix bugs in minizip.c sample for zipping big file 30Change in 0.15: (19 Mar 98)
31- fix problem in month in date handling 31- fix memory leak in minizip.c
32- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for 32
33 comment handling 33Change in 0.14: (10 Mar 98)
34 34- fix bugs in minizip.c sample for zipping big file
35Change in 0.13: (6 Mar 98) 35- fix problem in month in date handling
36- fix bugs in zip.c 36- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
37- add real minizip sample 37 comment handling
38 38
39Change in 0.12: (4 Mar 98) 39Change in 0.13: (6 Mar 98)
40- add zip.c and zip.h for creates .zip file 40- fix bugs in zip.c
41- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly) 41- add real minizip sample
42- fix miniunz.c for file without specific record for directory 42
43 43Change in 0.12: (4 Mar 98)
44Change in 0.11: (3 Mar 98) 44- add zip.c and zip.h for creates .zip file
45- fix bug in unzGetCurrentFileInfo for get extra field and comment 45- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
46- enhance miniunz sample, remove the bad unztst.c sample 46- fix miniunz.c for file without specific record for directory
47 47
48Change in 0.10: (2 Mar 98) 48Change in 0.11: (3 Mar 98)
49- fix bug in unzReadCurrentFile 49- fix bug in unzGetCurrentFileInfo for get extra field and comment
50- rename unzip* to unz* function and structure 50- enhance miniunz sample, remove the bad unztst.c sample
51- remove Windows-like hungary notation variable name 51
52- modify some structure in unzip.h 52Change in 0.10: (2 Mar 98)
53- add somes comment in source 53- fix bug in unzReadCurrentFile
54- remove unzipGetcCurrentFile function 54- rename unzip* to unz* function and structure
55- replace ZUNZEXPORT by ZEXPORT 55- remove Windows-like hungary notation variable name
56- add unzGetLocalExtrafield for get the local extrafield info 56- modify some structure in unzip.h
57- add a new sample, miniunz.c 57- add somes comment in source
58 58- remove unzipGetcCurrentFile function
59Change in 0.4: (25 Feb 98) 59- replace ZUNZEXPORT by ZEXPORT
60- suppress the type unzipFileInZip. 60- add unzGetLocalExtrafield for get the local extrafield info
61 Only on file in the zipfile can be open at the same time 61- add a new sample, miniunz.c
62- fix somes typo in code 62
63- added tm_unz structure in unzip_file_info (date/time in readable format) 63Change in 0.4: (25 Feb 98)
64- suppress the type unzipFileInZip.
65 Only on file in the zipfile can be open at the same time
66- fix somes typo in code
67- added tm_unz structure in unzip_file_info (date/time in readable format)
diff --git a/contrib/minizip/Makefile b/contrib/minizip/Makefile
index 84eaad2..fbba3ac 100644
--- a/contrib/minizip/Makefile
+++ b/contrib/minizip/Makefile
@@ -1,25 +1,25 @@
1CC=cc 1CC=cc
2CFLAGS=-O -I../.. 2CFLAGS=-O -I../..
3 3
4UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a 4UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
5ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a 5ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
6 6
7.c.o: 7.c.o:
8 $(CC) -c $(CFLAGS) $*.c 8 $(CC) -c $(CFLAGS) $*.c
9 9
10all: miniunz minizip 10all: miniunz minizip
11 11
12miniunz: $(UNZ_OBJS) 12miniunz: $(UNZ_OBJS)
13 $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS) 13 $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
14 14
15minizip: $(ZIP_OBJS) 15minizip: $(ZIP_OBJS)
16 $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS) 16 $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
17 17
18test: miniunz minizip 18test: miniunz minizip
19 ./minizip test readme.txt 19 ./minizip test readme.txt
20 ./miniunz -l test.zip 20 ./miniunz -l test.zip
21 mv readme.txt readme.old 21 mv readme.txt readme.old
22 ./miniunz test.zip 22 ./miniunz test.zip
23 23
24clean: 24clean:
25 /bin/rm -f *.o *~ minizip miniunz 25 /bin/rm -f *.o *~ minizip miniunz
diff --git a/contrib/minizip/crypt.h b/contrib/minizip/crypt.h
index 7f8a634..f14a628 100644
--- a/contrib/minizip/crypt.h
+++ b/contrib/minizip/crypt.h
@@ -1,132 +1,132 @@
1/* crypt.h -- base code for crypt/uncrypt ZIPfile 1/* crypt.h -- base code for crypt/uncrypt ZIPfile
2 2
3 3
4 Version 1.01, May 8th, 2004 4 Version 1.01e, February 12th, 2005
5 5
6 Copyright (C) 1998-2004 Gilles Vollant 6 Copyright (C) 1998-2005 Gilles Vollant
7 7
8 This code is a modified version of crypting code in Infozip distribution 8 This code is a modified version of crypting code in Infozip distribution
9 9
10 The encryption/decryption parts of this source code (as opposed to the 10 The encryption/decryption parts of this source code (as opposed to the
11 non-echoing password parts) were originally written in Europe. The 11 non-echoing password parts) were originally written in Europe. The
12 whole source package can be freely distributed, including from the USA. 12 whole source package can be freely distributed, including from the USA.
13 (Prior to January 2000, re-export from the US was a violation of US law.) 13 (Prior to January 2000, re-export from the US was a violation of US law.)
14 14
15 This encryption code is a direct transcription of the algorithm from 15 This encryption code is a direct transcription of the algorithm from
16 Roger Schlafly, described by Phil Katz in the file appnote.txt. This 16 Roger Schlafly, described by Phil Katz in the file appnote.txt. This
17 file (appnote.txt) is distributed with the PKZIP program (even in the 17 file (appnote.txt) is distributed with the PKZIP program (even in the
18 version without encryption capabilities). 18 version without encryption capabilities).
19 19
20 If you don't need crypting in your application, just define symbols 20 If you don't need crypting in your application, just define symbols
21 NOCRYPT and NOUNCRYPT. 21 NOCRYPT and NOUNCRYPT.
22 22
23 This code support the "Traditional PKWARE Encryption". 23 This code support the "Traditional PKWARE Encryption".
24 24
25 The new AES encryption added on Zip format by Winzip (see the page 25 The new AES encryption added on Zip format by Winzip (see the page
26 http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong 26 http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
27 Encryption is not supported. 27 Encryption is not supported.
28*/ 28*/
29 29
30#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) 30#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
31 31
32/*********************************************************************** 32/***********************************************************************
33 * Return the next byte in the pseudo-random sequence 33 * Return the next byte in the pseudo-random sequence
34 */ 34 */
35static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) 35static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
36{ 36{
37 unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an 37 unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
38 * unpredictable manner on 16-bit systems; not a problem 38 * unpredictable manner on 16-bit systems; not a problem
39 * with any known compiler so far, though */ 39 * with any known compiler so far, though */
40 40
41 temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; 41 temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
42 return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); 42 return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
43} 43}
44 44
45/*********************************************************************** 45/***********************************************************************
46 * Update the encryption keys with the next byte of plain text 46 * Update the encryption keys with the next byte of plain text
47 */ 47 */
48static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) 48static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
49{ 49{
50 (*(pkeys+0)) = CRC32((*(pkeys+0)), c); 50 (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
51 (*(pkeys+1)) += (*(pkeys+0)) & 0xff; 51 (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
52 (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; 52 (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
53 { 53 {
54 register int keyshift = (int)((*(pkeys+1)) >> 24); 54 register int keyshift = (int)((*(pkeys+1)) >> 24);
55 (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); 55 (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
56 } 56 }
57 return c; 57 return c;
58} 58}
59 59
60 60
61/*********************************************************************** 61/***********************************************************************
62 * Initialize the encryption keys and the random header according to 62 * Initialize the encryption keys and the random header according to
63 * the given password. 63 * the given password.
64 */ 64 */
65static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) 65static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
66{ 66{
67 *(pkeys+0) = 305419896L; 67 *(pkeys+0) = 305419896L;
68 *(pkeys+1) = 591751049L; 68 *(pkeys+1) = 591751049L;
69 *(pkeys+2) = 878082192L; 69 *(pkeys+2) = 878082192L;
70 while (*passwd != '\0') { 70 while (*passwd != '\0') {
71 update_keys(pkeys,pcrc_32_tab,(int)*passwd); 71 update_keys(pkeys,pcrc_32_tab,(int)*passwd);
72 passwd++; 72 passwd++;
73 } 73 }
74} 74}
75 75
76#define zdecode(pkeys,pcrc_32_tab,c) \ 76#define zdecode(pkeys,pcrc_32_tab,c) \
77 (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) 77 (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
78 78
79#define zencode(pkeys,pcrc_32_tab,c,t) \ 79#define zencode(pkeys,pcrc_32_tab,c,t) \
80 (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) 80 (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
81 81
82#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED 82#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
83 83
84#define RAND_HEAD_LEN 12 84#define RAND_HEAD_LEN 12
85 /* "last resort" source for second part of crypt seed pattern */ 85 /* "last resort" source for second part of crypt seed pattern */
86# ifndef ZCR_SEED2 86# ifndef ZCR_SEED2
87# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ 87# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
88# endif 88# endif
89 89
90static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) 90static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
91 const char *passwd; /* password string */ 91 const char *passwd; /* password string */
92 unsigned char *buf; /* where to write header */ 92 unsigned char *buf; /* where to write header */
93 int bufSize; 93 int bufSize;
94 unsigned long* pkeys; 94 unsigned long* pkeys;
95 const unsigned long* pcrc_32_tab; 95 const unsigned long* pcrc_32_tab;
96 unsigned long crcForCrypting; 96 unsigned long crcForCrypting;
97{ 97{
98 int n; /* index in random header */ 98 int n; /* index in random header */
99 int t; /* temporary */ 99 int t; /* temporary */
100 int c; /* random byte */ 100 int c; /* random byte */
101 unsigned char header[RAND_HEAD_LEN-2]; /* random header */ 101 unsigned char header[RAND_HEAD_LEN-2]; /* random header */
102 static unsigned calls = 0; /* ensure different random header each time */ 102 static unsigned calls = 0; /* ensure different random header each time */
103 103
104 if (bufSize<RAND_HEAD_LEN) 104 if (bufSize<RAND_HEAD_LEN)
105 return 0; 105 return 0;
106 106
107 /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the 107 /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
108 * output of rand() to get less predictability, since rand() is 108 * output of rand() to get less predictability, since rand() is
109 * often poorly implemented. 109 * often poorly implemented.
110 */ 110 */
111 if (++calls == 1) 111 if (++calls == 1)
112 { 112 {
113 srand((unsigned)(time(NULL) ^ ZCR_SEED2)); 113 srand((unsigned)(time(NULL) ^ ZCR_SEED2));
114 } 114 }
115 init_keys(passwd, pkeys, pcrc_32_tab); 115 init_keys(passwd, pkeys, pcrc_32_tab);
116 for (n = 0; n < RAND_HEAD_LEN-2; n++) 116 for (n = 0; n < RAND_HEAD_LEN-2; n++)
117 { 117 {
118 c = (rand() >> 7) & 0xff; 118 c = (rand() >> 7) & 0xff;
119 header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); 119 header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
120 } 120 }
121 /* Encrypt random header (last two bytes is high word of crc) */ 121 /* Encrypt random header (last two bytes is high word of crc) */
122 init_keys(passwd, pkeys, pcrc_32_tab); 122 init_keys(passwd, pkeys, pcrc_32_tab);
123 for (n = 0; n < RAND_HEAD_LEN-2; n++) 123 for (n = 0; n < RAND_HEAD_LEN-2; n++)
124 { 124 {
125 buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); 125 buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
126 } 126 }
127 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); 127 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
128 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); 128 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
129 return n; 129 return n;
130} 130}
131 131
132#endif 132#endif
diff --git a/contrib/minizip/ioapi.c b/contrib/minizip/ioapi.c
index c9e69f2..7f20c18 100644
--- a/contrib/minizip/ioapi.c
+++ b/contrib/minizip/ioapi.c
@@ -1,177 +1,177 @@
1/* ioapi.c -- IO base function header for compress/uncompress .zip 1/* ioapi.c -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 3
4 Version 1.01, May 8th, 2004 4 Version 1.01e, February 12th, 2005
5 5
6 Copyright (C) 1998-2004 Gilles Vollant 6 Copyright (C) 1998-2005 Gilles Vollant
7*/ 7*/
8 8
9#include <stdio.h> 9#include <stdio.h>
10#include <stdlib.h> 10#include <stdlib.h>
11#include <string.h> 11#include <string.h>
12 12
13#include "zlib.h" 13#include "zlib.h"
14#include "ioapi.h" 14#include "ioapi.h"
15 15
16 16
17 17
18/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ 18/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
19 19
20#ifndef SEEK_CUR 20#ifndef SEEK_CUR
21#define SEEK_CUR 1 21#define SEEK_CUR 1
22#endif 22#endif
23 23
24#ifndef SEEK_END 24#ifndef SEEK_END
25#define SEEK_END 2 25#define SEEK_END 2
26#endif 26#endif
27 27
28#ifndef SEEK_SET 28#ifndef SEEK_SET
29#define SEEK_SET 0 29#define SEEK_SET 0
30#endif 30#endif
31 31
32voidpf ZCALLBACK fopen_file_func OF(( 32voidpf ZCALLBACK fopen_file_func OF((
33 voidpf opaque, 33 voidpf opaque,
34 const char* filename, 34 const char* filename,
35 int mode)); 35 int mode));
36 36
37uLong ZCALLBACK fread_file_func OF(( 37uLong ZCALLBACK fread_file_func OF((
38 voidpf opaque, 38 voidpf opaque,
39 voidpf stream, 39 voidpf stream,
40 void* buf, 40 void* buf,
41 uLong size)); 41 uLong size));
42 42
43uLong ZCALLBACK fwrite_file_func OF(( 43uLong ZCALLBACK fwrite_file_func OF((
44 voidpf opaque, 44 voidpf opaque,
45 voidpf stream, 45 voidpf stream,
46 const void* buf, 46 const void* buf,
47 uLong size)); 47 uLong size));
48 48
49long ZCALLBACK ftell_file_func OF(( 49long ZCALLBACK ftell_file_func OF((
50 voidpf opaque, 50 voidpf opaque,
51 voidpf stream)); 51 voidpf stream));
52 52
53long ZCALLBACK fseek_file_func OF(( 53long ZCALLBACK fseek_file_func OF((
54 voidpf opaque, 54 voidpf opaque,
55 voidpf stream, 55 voidpf stream,
56 uLong offset, 56 uLong offset,
57 int origin)); 57 int origin));
58 58
59int ZCALLBACK fclose_file_func OF(( 59int ZCALLBACK fclose_file_func OF((
60 voidpf opaque, 60 voidpf opaque,
61 voidpf stream)); 61 voidpf stream));
62 62
63int ZCALLBACK ferror_file_func OF(( 63int ZCALLBACK ferror_file_func OF((
64 voidpf opaque, 64 voidpf opaque,
65 voidpf stream)); 65 voidpf stream));
66 66
67 67
68voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) 68voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
69 voidpf opaque; 69 voidpf opaque;
70 const char* filename; 70 const char* filename;
71 int mode; 71 int mode;
72{ 72{
73 FILE* file = NULL; 73 FILE* file = NULL;
74 const char* mode_fopen = NULL; 74 const char* mode_fopen = NULL;
75 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) 75 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
76 mode_fopen = "rb"; 76 mode_fopen = "rb";
77 else 77 else
78 if (mode & ZLIB_FILEFUNC_MODE_EXISTING) 78 if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
79 mode_fopen = "r+b"; 79 mode_fopen = "r+b";
80 else 80 else
81 if (mode & ZLIB_FILEFUNC_MODE_CREATE) 81 if (mode & ZLIB_FILEFUNC_MODE_CREATE)
82 mode_fopen = "wb"; 82 mode_fopen = "wb";
83 83
84 if ((filename!=NULL) && (mode_fopen != NULL)) 84 if ((filename!=NULL) && (mode_fopen != NULL))
85 file = fopen(filename, mode_fopen); 85 file = fopen(filename, mode_fopen);
86 return file; 86 return file;
87} 87}
88 88
89 89
90uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) 90uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
91 voidpf opaque; 91 voidpf opaque;
92 voidpf stream; 92 voidpf stream;
93 void* buf; 93 void* buf;
94 uLong size; 94 uLong size;
95{ 95{
96 uLong ret; 96 uLong ret;
97 ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); 97 ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
98 return ret; 98 return ret;
99} 99}
100 100
101 101
102uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) 102uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
103 voidpf opaque; 103 voidpf opaque;
104 voidpf stream; 104 voidpf stream;
105 const void* buf; 105 const void* buf;
106 uLong size; 106 uLong size;
107{ 107{
108 uLong ret; 108 uLong ret;
109 ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); 109 ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
110 return ret; 110 return ret;
111} 111}
112 112
113long ZCALLBACK ftell_file_func (opaque, stream) 113long ZCALLBACK ftell_file_func (opaque, stream)
114 voidpf opaque; 114 voidpf opaque;
115 voidpf stream; 115 voidpf stream;
116{ 116{
117 long ret; 117 long ret;
118 ret = ftell((FILE *)stream); 118 ret = ftell((FILE *)stream);
119 return ret; 119 return ret;
120} 120}
121 121
122long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) 122long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
123 voidpf opaque; 123 voidpf opaque;
124 voidpf stream; 124 voidpf stream;
125 uLong offset; 125 uLong offset;
126 int origin; 126 int origin;
127{ 127{
128 int fseek_origin=0; 128 int fseek_origin=0;
129 long ret; 129 long ret;
130 switch (origin) 130 switch (origin)
131 { 131 {
132 case ZLIB_FILEFUNC_SEEK_CUR : 132 case ZLIB_FILEFUNC_SEEK_CUR :
133 fseek_origin = SEEK_CUR; 133 fseek_origin = SEEK_CUR;
134 break; 134 break;
135 case ZLIB_FILEFUNC_SEEK_END : 135 case ZLIB_FILEFUNC_SEEK_END :
136 fseek_origin = SEEK_END; 136 fseek_origin = SEEK_END;
137 break; 137 break;
138 case ZLIB_FILEFUNC_SEEK_SET : 138 case ZLIB_FILEFUNC_SEEK_SET :
139 fseek_origin = SEEK_SET; 139 fseek_origin = SEEK_SET;
140 break; 140 break;
141 default: return -1; 141 default: return -1;
142 } 142 }
143 ret = 0; 143 ret = 0;
144 fseek((FILE *)stream, offset, fseek_origin); 144 fseek((FILE *)stream, offset, fseek_origin);
145 return ret; 145 return ret;
146} 146}
147 147
148int ZCALLBACK fclose_file_func (opaque, stream) 148int ZCALLBACK fclose_file_func (opaque, stream)
149 voidpf opaque; 149 voidpf opaque;
150 voidpf stream; 150 voidpf stream;
151{ 151{
152 int ret; 152 int ret;
153 ret = fclose((FILE *)stream); 153 ret = fclose((FILE *)stream);
154 return ret; 154 return ret;
155} 155}
156 156
157int ZCALLBACK ferror_file_func (opaque, stream) 157int ZCALLBACK ferror_file_func (opaque, stream)
158 voidpf opaque; 158 voidpf opaque;
159 voidpf stream; 159 voidpf stream;
160{ 160{
161 int ret; 161 int ret;
162 ret = ferror((FILE *)stream); 162 ret = ferror((FILE *)stream);
163 return ret; 163 return ret;
164} 164}
165 165
166void fill_fopen_filefunc (pzlib_filefunc_def) 166void fill_fopen_filefunc (pzlib_filefunc_def)
167 zlib_filefunc_def* pzlib_filefunc_def; 167 zlib_filefunc_def* pzlib_filefunc_def;
168{ 168{
169 pzlib_filefunc_def->zopen_file = fopen_file_func; 169 pzlib_filefunc_def->zopen_file = fopen_file_func;
170 pzlib_filefunc_def->zread_file = fread_file_func; 170 pzlib_filefunc_def->zread_file = fread_file_func;
171 pzlib_filefunc_def->zwrite_file = fwrite_file_func; 171 pzlib_filefunc_def->zwrite_file = fwrite_file_func;
172 pzlib_filefunc_def->ztell_file = ftell_file_func; 172 pzlib_filefunc_def->ztell_file = ftell_file_func;
173 pzlib_filefunc_def->zseek_file = fseek_file_func; 173 pzlib_filefunc_def->zseek_file = fseek_file_func;
174 pzlib_filefunc_def->zclose_file = fclose_file_func; 174 pzlib_filefunc_def->zclose_file = fclose_file_func;
175 pzlib_filefunc_def->zerror_file = ferror_file_func; 175 pzlib_filefunc_def->zerror_file = ferror_file_func;
176 pzlib_filefunc_def->opaque = NULL; 176 pzlib_filefunc_def->opaque = NULL;
177} 177}
diff --git a/contrib/minizip/ioapi.h b/contrib/minizip/ioapi.h
index b761161..e73a3b2 100644
--- a/contrib/minizip/ioapi.h
+++ b/contrib/minizip/ioapi.h
@@ -1,75 +1,75 @@
1/* ioapi.h -- IO base function header for compress/uncompress .zip 1/* ioapi.h -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 3
4 Version 1.01, May 8th, 2004 4 Version 1.01e, February 12th, 2005
5 5
6 Copyright (C) 1998-2004 Gilles Vollant 6 Copyright (C) 1998-2005 Gilles Vollant
7*/ 7*/
8 8
9#ifndef _ZLIBIOAPI_H 9#ifndef _ZLIBIOAPI_H
10#define _ZLIBIOAPI_H 10#define _ZLIBIOAPI_H
11 11
12 12
13#define ZLIB_FILEFUNC_SEEK_CUR (1) 13#define ZLIB_FILEFUNC_SEEK_CUR (1)
14#define ZLIB_FILEFUNC_SEEK_END (2) 14#define ZLIB_FILEFUNC_SEEK_END (2)
15#define ZLIB_FILEFUNC_SEEK_SET (0) 15#define ZLIB_FILEFUNC_SEEK_SET (0)
16 16
17#define ZLIB_FILEFUNC_MODE_READ (1) 17#define ZLIB_FILEFUNC_MODE_READ (1)
18#define ZLIB_FILEFUNC_MODE_WRITE (2) 18#define ZLIB_FILEFUNC_MODE_WRITE (2)
19#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) 19#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
20 20
21#define ZLIB_FILEFUNC_MODE_EXISTING (4) 21#define ZLIB_FILEFUNC_MODE_EXISTING (4)
22#define ZLIB_FILEFUNC_MODE_CREATE (8) 22#define ZLIB_FILEFUNC_MODE_CREATE (8)
23 23
24 24
25#ifndef ZCALLBACK 25#ifndef ZCALLBACK
26 26
27#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) 27#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
28#define ZCALLBACK CALLBACK 28#define ZCALLBACK CALLBACK
29#else 29#else
30#define ZCALLBACK 30#define ZCALLBACK
31#endif 31#endif
32#endif 32#endif
33 33
34#ifdef __cplusplus 34#ifdef __cplusplus
35extern "C" { 35extern "C" {
36#endif 36#endif
37 37
38typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); 38typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
39typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); 39typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
40typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); 40typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
41typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); 41typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
42typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); 42typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
43typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); 43typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
44typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); 44typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
45 45
46typedef struct zlib_filefunc_def_s 46typedef struct zlib_filefunc_def_s
47{ 47{
48 open_file_func zopen_file; 48 open_file_func zopen_file;
49 read_file_func zread_file; 49 read_file_func zread_file;
50 write_file_func zwrite_file; 50 write_file_func zwrite_file;
51 tell_file_func ztell_file; 51 tell_file_func ztell_file;
52 seek_file_func zseek_file; 52 seek_file_func zseek_file;
53 close_file_func zclose_file; 53 close_file_func zclose_file;
54 testerror_file_func zerror_file; 54 testerror_file_func zerror_file;
55 voidpf opaque; 55 voidpf opaque;
56} zlib_filefunc_def; 56} zlib_filefunc_def;
57 57
58 58
59 59
60void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); 60void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
61 61
62#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) 62#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
63#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) 63#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
64#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) 64#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
65#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) 65#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
66#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) 66#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
67#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) 67#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
68 68
69 69
70#ifdef __cplusplus 70#ifdef __cplusplus
71} 71}
72#endif 72#endif
73 73
74#endif 74#endif
75 75
diff --git a/contrib/minizip/iowin32.c b/contrib/minizip/iowin32.c
index 940dc0b..694bc03 100644
--- a/contrib/minizip/iowin32.c
+++ b/contrib/minizip/iowin32.c
@@ -1,270 +1,270 @@
1/* iowin32.c -- IO base function header for compress/uncompress .zip 1/* iowin32.c -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 This IO API version uses the Win32 API (for Microsoft Windows) 3 This IO API version uses the Win32 API (for Microsoft Windows)
4 4
5 Version 1.01, May 8th, 2004 5 Version 1.01e, February 12th, 2005
6 6
7 Copyright (C) 1998-2004 Gilles Vollant 7 Copyright (C) 1998-2005 Gilles Vollant
8*/ 8*/
9 9
10#include <stdlib.h> 10#include <stdlib.h>
11 11
12#include "zlib.h" 12#include "zlib.h"
13#include "ioapi.h" 13#include "ioapi.h"
14#include "iowin32.h" 14#include "iowin32.h"
15 15
16#ifndef INVALID_HANDLE_VALUE 16#ifndef INVALID_HANDLE_VALUE
17#define INVALID_HANDLE_VALUE (0xFFFFFFFF) 17#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
18#endif 18#endif
19 19
20#ifndef INVALID_SET_FILE_POINTER 20#ifndef INVALID_SET_FILE_POINTER
21#define INVALID_SET_FILE_POINTER ((DWORD)-1) 21#define INVALID_SET_FILE_POINTER ((DWORD)-1)
22#endif 22#endif
23 23
24voidpf ZCALLBACK win32_open_file_func OF(( 24voidpf ZCALLBACK win32_open_file_func OF((
25 voidpf opaque, 25 voidpf opaque,
26 const char* filename, 26 const char* filename,
27 int mode)); 27 int mode));
28 28
29uLong ZCALLBACK win32_read_file_func OF(( 29uLong ZCALLBACK win32_read_file_func OF((
30 voidpf opaque, 30 voidpf opaque,
31 voidpf stream, 31 voidpf stream,
32 void* buf, 32 void* buf,
33 uLong size)); 33 uLong size));
34 34
35uLong ZCALLBACK win32_write_file_func OF(( 35uLong ZCALLBACK win32_write_file_func OF((
36 voidpf opaque, 36 voidpf opaque,
37 voidpf stream, 37 voidpf stream,
38 const void* buf, 38 const void* buf,
39 uLong size)); 39 uLong size));
40 40
41long ZCALLBACK win32_tell_file_func OF(( 41long ZCALLBACK win32_tell_file_func OF((
42 voidpf opaque, 42 voidpf opaque,
43 voidpf stream)); 43 voidpf stream));
44 44
45long ZCALLBACK win32_seek_file_func OF(( 45long ZCALLBACK win32_seek_file_func OF((
46 voidpf opaque, 46 voidpf opaque,
47 voidpf stream, 47 voidpf stream,
48 uLong offset, 48 uLong offset,
49 int origin)); 49 int origin));
50 50
51int ZCALLBACK win32_close_file_func OF(( 51int ZCALLBACK win32_close_file_func OF((
52 voidpf opaque, 52 voidpf opaque,
53 voidpf stream)); 53 voidpf stream));
54 54
55int ZCALLBACK win32_error_file_func OF(( 55int ZCALLBACK win32_error_file_func OF((
56 voidpf opaque, 56 voidpf opaque,
57 voidpf stream)); 57 voidpf stream));
58 58
59typedef struct 59typedef struct
60{ 60{
61 HANDLE hf; 61 HANDLE hf;
62 int error; 62 int error;
63} WIN32FILE_IOWIN; 63} WIN32FILE_IOWIN;
64 64
65voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) 65voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
66 voidpf opaque; 66 voidpf opaque;
67 const char* filename; 67 const char* filename;
68 int mode; 68 int mode;
69{ 69{
70 const char* mode_fopen = NULL; 70 const char* mode_fopen = NULL;
71 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; 71 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
72 HANDLE hFile = 0; 72 HANDLE hFile = 0;
73 voidpf ret=NULL; 73 voidpf ret=NULL;
74 74
75 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; 75 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
76 76
77 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) 77 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
78 { 78 {
79 dwDesiredAccess = GENERIC_READ; 79 dwDesiredAccess = GENERIC_READ;
80 dwCreationDisposition = OPEN_EXISTING; 80 dwCreationDisposition = OPEN_EXISTING;
81 dwShareMode = FILE_SHARE_READ; 81 dwShareMode = FILE_SHARE_READ;
82 } 82 }
83 else 83 else
84 if (mode & ZLIB_FILEFUNC_MODE_EXISTING) 84 if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
85 { 85 {
86 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; 86 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
87 dwCreationDisposition = OPEN_EXISTING; 87 dwCreationDisposition = OPEN_EXISTING;
88 } 88 }
89 else 89 else
90 if (mode & ZLIB_FILEFUNC_MODE_CREATE) 90 if (mode & ZLIB_FILEFUNC_MODE_CREATE)
91 { 91 {
92 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; 92 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
93 dwCreationDisposition = CREATE_ALWAYS; 93 dwCreationDisposition = CREATE_ALWAYS;
94 } 94 }
95 95
96 if ((filename!=NULL) && (dwDesiredAccess != 0)) 96 if ((filename!=NULL) && (dwDesiredAccess != 0))
97 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, 97 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
98 dwCreationDisposition, dwFlagsAndAttributes, NULL); 98 dwCreationDisposition, dwFlagsAndAttributes, NULL);
99 99
100 if (hFile == INVALID_HANDLE_VALUE) 100 if (hFile == INVALID_HANDLE_VALUE)
101 hFile = NULL; 101 hFile = NULL;
102 102
103 if (hFile != NULL) 103 if (hFile != NULL)
104 { 104 {
105 WIN32FILE_IOWIN w32fiow; 105 WIN32FILE_IOWIN w32fiow;
106 w32fiow.hf = hFile; 106 w32fiow.hf = hFile;
107 w32fiow.error = 0; 107 w32fiow.error = 0;
108 ret = malloc(sizeof(WIN32FILE_IOWIN)); 108 ret = malloc(sizeof(WIN32FILE_IOWIN));
109 if (ret==NULL) 109 if (ret==NULL)
110 CloseHandle(hFile); 110 CloseHandle(hFile);
111 else *((WIN32FILE_IOWIN*)ret) = w32fiow; 111 else *((WIN32FILE_IOWIN*)ret) = w32fiow;
112 } 112 }
113 return ret; 113 return ret;
114} 114}
115 115
116 116
117uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) 117uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
118 voidpf opaque; 118 voidpf opaque;
119 voidpf stream; 119 voidpf stream;
120 void* buf; 120 void* buf;
121 uLong size; 121 uLong size;
122{ 122{
123 uLong ret=0; 123 uLong ret=0;
124 HANDLE hFile = NULL; 124 HANDLE hFile = NULL;
125 if (stream!=NULL) 125 if (stream!=NULL)
126 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 126 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
127 if (hFile != NULL) 127 if (hFile != NULL)
128 if (!ReadFile(hFile, buf, size, &ret, NULL)) 128 if (!ReadFile(hFile, buf, size, &ret, NULL))
129 { 129 {
130 DWORD dwErr = GetLastError(); 130 DWORD dwErr = GetLastError();
131 if (dwErr == ERROR_HANDLE_EOF) 131 if (dwErr == ERROR_HANDLE_EOF)
132 dwErr = 0; 132 dwErr = 0;
133 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 133 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
134 } 134 }
135 135
136 return ret; 136 return ret;
137} 137}
138 138
139 139
140uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) 140uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
141 voidpf opaque; 141 voidpf opaque;
142 voidpf stream; 142 voidpf stream;
143 const void* buf; 143 const void* buf;
144 uLong size; 144 uLong size;
145{ 145{
146 uLong ret=0; 146 uLong ret=0;
147 HANDLE hFile = NULL; 147 HANDLE hFile = NULL;
148 if (stream!=NULL) 148 if (stream!=NULL)
149 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 149 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
150 150
151 if (hFile !=NULL) 151 if (hFile !=NULL)
152 if (!WriteFile(hFile, buf, size, &ret, NULL)) 152 if (!WriteFile(hFile, buf, size, &ret, NULL))
153 { 153 {
154 DWORD dwErr = GetLastError(); 154 DWORD dwErr = GetLastError();
155 if (dwErr == ERROR_HANDLE_EOF) 155 if (dwErr == ERROR_HANDLE_EOF)
156 dwErr = 0; 156 dwErr = 0;
157 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 157 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
158 } 158 }
159 159
160 return ret; 160 return ret;
161} 161}
162 162
163long ZCALLBACK win32_tell_file_func (opaque, stream) 163long ZCALLBACK win32_tell_file_func (opaque, stream)
164 voidpf opaque; 164 voidpf opaque;
165 voidpf stream; 165 voidpf stream;
166{ 166{
167 long ret=-1; 167 long ret=-1;
168 HANDLE hFile = NULL; 168 HANDLE hFile = NULL;
169 if (stream!=NULL) 169 if (stream!=NULL)
170 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 170 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
171 if (hFile != NULL) 171 if (hFile != NULL)
172 { 172 {
173 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); 173 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
174 if (dwSet == INVALID_SET_FILE_POINTER) 174 if (dwSet == INVALID_SET_FILE_POINTER)
175 { 175 {
176 DWORD dwErr = GetLastError(); 176 DWORD dwErr = GetLastError();
177 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 177 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
178 ret = -1; 178 ret = -1;
179 } 179 }
180 else 180 else
181 ret=(long)dwSet; 181 ret=(long)dwSet;
182 } 182 }
183 return ret; 183 return ret;
184} 184}
185 185
186long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) 186long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
187 voidpf opaque; 187 voidpf opaque;
188 voidpf stream; 188 voidpf stream;
189 uLong offset; 189 uLong offset;
190 int origin; 190 int origin;
191{ 191{
192 DWORD dwMoveMethod=0xFFFFFFFF; 192 DWORD dwMoveMethod=0xFFFFFFFF;
193 HANDLE hFile = NULL; 193 HANDLE hFile = NULL;
194 194
195 long ret=-1; 195 long ret=-1;
196 if (stream!=NULL) 196 if (stream!=NULL)
197 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 197 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
198 switch (origin) 198 switch (origin)
199 { 199 {
200 case ZLIB_FILEFUNC_SEEK_CUR : 200 case ZLIB_FILEFUNC_SEEK_CUR :
201 dwMoveMethod = FILE_CURRENT; 201 dwMoveMethod = FILE_CURRENT;
202 break; 202 break;
203 case ZLIB_FILEFUNC_SEEK_END : 203 case ZLIB_FILEFUNC_SEEK_END :
204 dwMoveMethod = FILE_END; 204 dwMoveMethod = FILE_END;
205 break; 205 break;
206 case ZLIB_FILEFUNC_SEEK_SET : 206 case ZLIB_FILEFUNC_SEEK_SET :
207 dwMoveMethod = FILE_BEGIN; 207 dwMoveMethod = FILE_BEGIN;
208 break; 208 break;
209 default: return -1; 209 default: return -1;
210 } 210 }
211 211
212 if (hFile != NULL) 212 if (hFile != NULL)
213 { 213 {
214 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); 214 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
215 if (dwSet == INVALID_SET_FILE_POINTER) 215 if (dwSet == INVALID_SET_FILE_POINTER)
216 { 216 {
217 DWORD dwErr = GetLastError(); 217 DWORD dwErr = GetLastError();
218 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 218 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
219 ret = -1; 219 ret = -1;
220 } 220 }
221 else 221 else
222 ret=0; 222 ret=0;
223 } 223 }
224 return ret; 224 return ret;
225} 225}
226 226
227int ZCALLBACK win32_close_file_func (opaque, stream) 227int ZCALLBACK win32_close_file_func (opaque, stream)
228 voidpf opaque; 228 voidpf opaque;
229 voidpf stream; 229 voidpf stream;
230{ 230{
231 int ret=-1; 231 int ret=-1;
232 232
233 if (stream!=NULL) 233 if (stream!=NULL)
234 { 234 {
235 HANDLE hFile; 235 HANDLE hFile;
236 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 236 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
237 if (hFile != NULL) 237 if (hFile != NULL)
238 { 238 {
239 CloseHandle(hFile); 239 CloseHandle(hFile);
240 ret=0; 240 ret=0;
241 } 241 }
242 free(stream); 242 free(stream);
243 } 243 }
244 return ret; 244 return ret;
245} 245}
246 246
247int ZCALLBACK win32_error_file_func (opaque, stream) 247int ZCALLBACK win32_error_file_func (opaque, stream)
248 voidpf opaque; 248 voidpf opaque;
249 voidpf stream; 249 voidpf stream;
250{ 250{
251 int ret=-1; 251 int ret=-1;
252 if (stream!=NULL) 252 if (stream!=NULL)
253 { 253 {
254 ret = ((WIN32FILE_IOWIN*)stream) -> error; 254 ret = ((WIN32FILE_IOWIN*)stream) -> error;
255 } 255 }
256 return ret; 256 return ret;
257} 257}
258 258
259void fill_win32_filefunc (pzlib_filefunc_def) 259void fill_win32_filefunc (pzlib_filefunc_def)
260 zlib_filefunc_def* pzlib_filefunc_def; 260 zlib_filefunc_def* pzlib_filefunc_def;
261{ 261{
262 pzlib_filefunc_def->zopen_file = win32_open_file_func; 262 pzlib_filefunc_def->zopen_file = win32_open_file_func;
263 pzlib_filefunc_def->zread_file = win32_read_file_func; 263 pzlib_filefunc_def->zread_file = win32_read_file_func;
264 pzlib_filefunc_def->zwrite_file = win32_write_file_func; 264 pzlib_filefunc_def->zwrite_file = win32_write_file_func;
265 pzlib_filefunc_def->ztell_file = win32_tell_file_func; 265 pzlib_filefunc_def->ztell_file = win32_tell_file_func;
266 pzlib_filefunc_def->zseek_file = win32_seek_file_func; 266 pzlib_filefunc_def->zseek_file = win32_seek_file_func;
267 pzlib_filefunc_def->zclose_file = win32_close_file_func; 267 pzlib_filefunc_def->zclose_file = win32_close_file_func;
268 pzlib_filefunc_def->zerror_file = win32_error_file_func; 268 pzlib_filefunc_def->zerror_file = win32_error_file_func;
269 pzlib_filefunc_def->opaque=NULL; 269 pzlib_filefunc_def->opaque=NULL;
270} 270}
diff --git a/contrib/minizip/iowin32.h b/contrib/minizip/iowin32.h
index 8774fe7..e9c5f8b 100644
--- a/contrib/minizip/iowin32.h
+++ b/contrib/minizip/iowin32.h
@@ -1,21 +1,21 @@
1/* iowin32.h -- IO base function header for compress/uncompress .zip 1/* iowin32.h -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 This IO API version uses the Win32 API (for Microsoft Windows) 3 This IO API version uses the Win32 API (for Microsoft Windows)
4 4
5 Version 1.01, May 8th, 2004 5 Version 1.01e, February 12th, 2005
6 6
7 Copyright (C) 1998-2004 Gilles Vollant 7 Copyright (C) 1998-2005 Gilles Vollant
8*/ 8*/
9 9
10#include <windows.h> 10#include <windows.h>
11 11
12 12
13#ifdef __cplusplus 13#ifdef __cplusplus
14extern "C" { 14extern "C" {
15#endif 15#endif
16 16
17void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); 17void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
18 18
19#ifdef __cplusplus 19#ifdef __cplusplus
20} 20}
21#endif 21#endif
diff --git a/contrib/minizip/miniunz.c b/contrib/minizip/miniunz.c
index a6b06a2..82d8702 100644
--- a/contrib/minizip/miniunz.c
+++ b/contrib/minizip/miniunz.c
@@ -1,585 +1,585 @@
1/* 1/*
2 miniunz.c 2 miniunz.c
3 Version 1.01b, May 30th, 2004 3 Version 1.01e, February 12th, 2005
4 4
5 Copyright (C) 1998-2004 Gilles Vollant 5 Copyright (C) 1998-2005 Gilles Vollant
6*/ 6*/
7 7
8 8
9#include <stdio.h> 9#include <stdio.h>
10#include <stdlib.h> 10#include <stdlib.h>
11#include <string.h> 11#include <string.h>
12#include <time.h> 12#include <time.h>
13#include <errno.h> 13#include <errno.h>
14#include <fcntl.h> 14#include <fcntl.h>
15 15
16#ifdef unix 16#ifdef unix
17# include <unistd.h> 17# include <unistd.h>
18# include <utime.h> 18# include <utime.h>
19#else 19#else
20# include <direct.h> 20# include <direct.h>
21# include <io.h> 21# include <io.h>
22#endif 22#endif
23 23
24#include "unzip.h" 24#include "unzip.h"
25 25
26#define CASESENSITIVITY (0) 26#define CASESENSITIVITY (0)
27#define WRITEBUFFERSIZE (8192) 27#define WRITEBUFFERSIZE (8192)
28#define MAXFILENAME (256) 28#define MAXFILENAME (256)
29 29
30#ifdef WIN32 30#ifdef WIN32
31#define USEWIN32IOAPI 31#define USEWIN32IOAPI
32#include "iowin32.h" 32#include "iowin32.h"
33#endif 33#endif
34/* 34/*
35 mini unzip, demo of unzip package 35 mini unzip, demo of unzip package
36 36
37 usage : 37 usage :
38 Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir] 38 Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir]
39 39
40 list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT 40 list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
41 if it exists 41 if it exists
42*/ 42*/
43 43
44 44
45/* change_file_date : change the date/time of a file 45/* change_file_date : change the date/time of a file
46 filename : the filename of the file where date/time must be modified 46 filename : the filename of the file where date/time must be modified
47 dosdate : the new date at the MSDos format (4 bytes) 47 dosdate : the new date at the MSDos format (4 bytes)
48 tmu_date : the SAME new date at the tm_unz format */ 48 tmu_date : the SAME new date at the tm_unz format */
49void change_file_date(filename,dosdate,tmu_date) 49void change_file_date(filename,dosdate,tmu_date)
50 const char *filename; 50 const char *filename;
51 uLong dosdate; 51 uLong dosdate;
52 tm_unz tmu_date; 52 tm_unz tmu_date;
53{ 53{
54#ifdef WIN32 54#ifdef WIN32
55 HANDLE hFile; 55 HANDLE hFile;
56 FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite; 56 FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
57 57
58 hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE, 58 hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE,
59 0,NULL,OPEN_EXISTING,0,NULL); 59 0,NULL,OPEN_EXISTING,0,NULL);
60 GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite); 60 GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
61 DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal); 61 DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
62 LocalFileTimeToFileTime(&ftLocal,&ftm); 62 LocalFileTimeToFileTime(&ftLocal,&ftm);
63 SetFileTime(hFile,&ftm,&ftLastAcc,&ftm); 63 SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
64 CloseHandle(hFile); 64 CloseHandle(hFile);
65#else 65#else
66#ifdef unix 66#ifdef unix
67 struct utimbuf ut; 67 struct utimbuf ut;
68 struct tm newdate; 68 struct tm newdate;
69 newdate.tm_sec = tmu_date.tm_sec; 69 newdate.tm_sec = tmu_date.tm_sec;
70 newdate.tm_min=tmu_date.tm_min; 70 newdate.tm_min=tmu_date.tm_min;
71 newdate.tm_hour=tmu_date.tm_hour; 71 newdate.tm_hour=tmu_date.tm_hour;
72 newdate.tm_mday=tmu_date.tm_mday; 72 newdate.tm_mday=tmu_date.tm_mday;
73 newdate.tm_mon=tmu_date.tm_mon; 73 newdate.tm_mon=tmu_date.tm_mon;
74 if (tmu_date.tm_year > 1900) 74 if (tmu_date.tm_year > 1900)
75 newdate.tm_year=tmu_date.tm_year - 1900; 75 newdate.tm_year=tmu_date.tm_year - 1900;
76 else 76 else
77 newdate.tm_year=tmu_date.tm_year ; 77 newdate.tm_year=tmu_date.tm_year ;
78 newdate.tm_isdst=-1; 78 newdate.tm_isdst=-1;
79 79
80 ut.actime=ut.modtime=mktime(&newdate); 80 ut.actime=ut.modtime=mktime(&newdate);
81 utime(filename,&ut); 81 utime(filename,&ut);
82#endif 82#endif
83#endif 83#endif
84} 84}
85 85
86 86
87/* mymkdir and change_file_date are not 100 % portable 87/* mymkdir and change_file_date are not 100 % portable
88 As I don't know well Unix, I wait feedback for the unix portion */ 88 As I don't know well Unix, I wait feedback for the unix portion */
89 89
90int mymkdir(dirname) 90int mymkdir(dirname)
91 const char* dirname; 91 const char* dirname;
92{ 92{
93 int ret=0; 93 int ret=0;
94#ifdef WIN32 94#ifdef WIN32
95 ret = mkdir(dirname); 95 ret = mkdir(dirname);
96#else 96#else
97#ifdef unix 97#ifdef unix
98 ret = mkdir (dirname,0775); 98 ret = mkdir (dirname,0775);
99#endif 99#endif
100#endif 100#endif
101 return ret; 101 return ret;
102} 102}
103 103
104int makedir (newdir) 104int makedir (newdir)
105 char *newdir; 105 char *newdir;
106{ 106{
107 char *buffer ; 107 char *buffer ;
108 char *p; 108 char *p;
109 int len = (int)strlen(newdir); 109 int len = (int)strlen(newdir);
110 110
111 if (len <= 0) 111 if (len <= 0)
112 return 0; 112 return 0;
113 113
114 buffer = (char*)malloc(len+1); 114 buffer = (char*)malloc(len+1);
115 strcpy(buffer,newdir); 115 strcpy(buffer,newdir);
116 116
117 if (buffer[len-1] == '/') { 117 if (buffer[len-1] == '/') {
118 buffer[len-1] = '\0'; 118 buffer[len-1] = '\0';
119 } 119 }
120 if (mymkdir(buffer) == 0) 120 if (mymkdir(buffer) == 0)
121 { 121 {
122 free(buffer); 122 free(buffer);
123 return 1; 123 return 1;
124 } 124 }
125 125
126 p = buffer+1; 126 p = buffer+1;
127 while (1) 127 while (1)
128 { 128 {
129 char hold; 129 char hold;
130 130
131 while(*p && *p != '\\' && *p != '/') 131 while(*p && *p != '\\' && *p != '/')
132 p++; 132 p++;
133 hold = *p; 133 hold = *p;
134 *p = 0; 134 *p = 0;
135 if ((mymkdir(buffer) == -1) && (errno == ENOENT)) 135 if ((mymkdir(buffer) == -1) && (errno == ENOENT))
136 { 136 {
137 printf("couldn't create directory %s\n",buffer); 137 printf("couldn't create directory %s\n",buffer);
138 free(buffer); 138 free(buffer);
139 return 0; 139 return 0;
140 } 140 }
141 if (hold == 0) 141 if (hold == 0)
142 break; 142 break;
143 *p++ = hold; 143 *p++ = hold;
144 } 144 }
145 free(buffer); 145 free(buffer);
146 return 1; 146 return 1;
147} 147}
148 148
149void do_banner() 149void do_banner()
150{ 150{
151 printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n"); 151 printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n");
152 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); 152 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
153} 153}
154 154
155void do_help() 155void do_help()
156{ 156{
157 printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \ 157 printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \
158 " -e Extract without pathname (junk paths)\n" \ 158 " -e Extract without pathname (junk paths)\n" \
159 " -x Extract with pathname\n" \ 159 " -x Extract with pathname\n" \
160 " -v list files\n" \ 160 " -v list files\n" \
161 " -l list files\n" \ 161 " -l list files\n" \
162 " -d directory to extract into\n" \ 162 " -d directory to extract into\n" \
163 " -o overwrite files without prompting\n" \ 163 " -o overwrite files without prompting\n" \
164 " -p extract crypted file using password\n\n"); 164 " -p extract crypted file using password\n\n");
165} 165}
166 166
167 167
168int do_list(uf) 168int do_list(uf)
169 unzFile uf; 169 unzFile uf;
170{ 170{
171 uLong i; 171 uLong i;
172 unz_global_info gi; 172 unz_global_info gi;
173 int err; 173 int err;
174 174
175 err = unzGetGlobalInfo (uf,&gi); 175 err = unzGetGlobalInfo (uf,&gi);
176 if (err!=UNZ_OK) 176 if (err!=UNZ_OK)
177 printf("error %d with zipfile in unzGetGlobalInfo \n",err); 177 printf("error %d with zipfile in unzGetGlobalInfo \n",err);
178 printf(" Length Method Size Ratio Date Time CRC-32 Name\n"); 178 printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
179 printf(" ------ ------ ---- ----- ---- ---- ------ ----\n"); 179 printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
180 for (i=0;i<gi.number_entry;i++) 180 for (i=0;i<gi.number_entry;i++)
181 { 181 {
182 char filename_inzip[256]; 182 char filename_inzip[256];
183 unz_file_info file_info; 183 unz_file_info file_info;
184 uLong ratio=0; 184 uLong ratio=0;
185 const char *string_method; 185 const char *string_method;
186 char charCrypt=' '; 186 char charCrypt=' ';
187 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); 187 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
188 if (err!=UNZ_OK) 188 if (err!=UNZ_OK)
189 { 189 {
190 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); 190 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
191 break; 191 break;
192 } 192 }
193 if (file_info.uncompressed_size>0) 193 if (file_info.uncompressed_size>0)
194 ratio = (file_info.compressed_size*100)/file_info.uncompressed_size; 194 ratio = (file_info.compressed_size*100)/file_info.uncompressed_size;
195 195
196 /* display a '*' if the file is crypted */ 196 /* display a '*' if the file is crypted */
197 if ((file_info.flag & 1) != 0) 197 if ((file_info.flag & 1) != 0)
198 charCrypt='*'; 198 charCrypt='*';
199 199
200 if (file_info.compression_method==0) 200 if (file_info.compression_method==0)
201 string_method="Stored"; 201 string_method="Stored";
202 else 202 else
203 if (file_info.compression_method==Z_DEFLATED) 203 if (file_info.compression_method==Z_DEFLATED)
204 { 204 {
205 uInt iLevel=(uInt)((file_info.flag & 0x6)/2); 205 uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
206 if (iLevel==0) 206 if (iLevel==0)
207 string_method="Defl:N"; 207 string_method="Defl:N";
208 else if (iLevel==1) 208 else if (iLevel==1)
209 string_method="Defl:X"; 209 string_method="Defl:X";
210 else if ((iLevel==2) || (iLevel==3)) 210 else if ((iLevel==2) || (iLevel==3))
211 string_method="Defl:F"; /* 2:fast , 3 : extra fast*/ 211 string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
212 } 212 }
213 else 213 else
214 string_method="Unkn. "; 214 string_method="Unkn. ";
215 215
216 printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n", 216 printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n",
217 file_info.uncompressed_size,string_method, 217 file_info.uncompressed_size,string_method,
218 charCrypt, 218 charCrypt,
219 file_info.compressed_size, 219 file_info.compressed_size,
220 ratio, 220 ratio,
221 (uLong)file_info.tmu_date.tm_mon + 1, 221 (uLong)file_info.tmu_date.tm_mon + 1,
222 (uLong)file_info.tmu_date.tm_mday, 222 (uLong)file_info.tmu_date.tm_mday,
223 (uLong)file_info.tmu_date.tm_year % 100, 223 (uLong)file_info.tmu_date.tm_year % 100,
224 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min, 224 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
225 (uLong)file_info.crc,filename_inzip); 225 (uLong)file_info.crc,filename_inzip);
226 if ((i+1)<gi.number_entry) 226 if ((i+1)<gi.number_entry)
227 { 227 {
228 err = unzGoToNextFile(uf); 228 err = unzGoToNextFile(uf);
229 if (err!=UNZ_OK) 229 if (err!=UNZ_OK)
230 { 230 {
231 printf("error %d with zipfile in unzGoToNextFile\n",err); 231 printf("error %d with zipfile in unzGoToNextFile\n",err);
232 break; 232 break;
233 } 233 }
234 } 234 }
235 } 235 }
236 236
237 return 0; 237 return 0;
238} 238}
239 239
240 240
241int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password) 241int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
242 unzFile uf; 242 unzFile uf;
243 const int* popt_extract_without_path; 243 const int* popt_extract_without_path;
244 int* popt_overwrite; 244 int* popt_overwrite;
245 const char* password; 245 const char* password;
246{ 246{
247 char filename_inzip[256]; 247 char filename_inzip[256];
248 char* filename_withoutpath; 248 char* filename_withoutpath;
249 char* p; 249 char* p;
250 int err=UNZ_OK; 250 int err=UNZ_OK;
251 FILE *fout=NULL; 251 FILE *fout=NULL;
252 void* buf; 252 void* buf;
253 uInt size_buf; 253 uInt size_buf;
254 254
255 unz_file_info file_info; 255 unz_file_info file_info;
256 uLong ratio=0; 256 uLong ratio=0;
257 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); 257 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
258 258
259 if (err!=UNZ_OK) 259 if (err!=UNZ_OK)
260 { 260 {
261 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); 261 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
262 return err; 262 return err;
263 } 263 }
264 264
265 size_buf = WRITEBUFFERSIZE; 265 size_buf = WRITEBUFFERSIZE;
266 buf = (void*)malloc(size_buf); 266 buf = (void*)malloc(size_buf);
267 if (buf==NULL) 267 if (buf==NULL)
268 { 268 {
269 printf("Error allocating memory\n"); 269 printf("Error allocating memory\n");
270 return UNZ_INTERNALERROR; 270 return UNZ_INTERNALERROR;
271 } 271 }
272 272
273 p = filename_withoutpath = filename_inzip; 273 p = filename_withoutpath = filename_inzip;
274 while ((*p) != '\0') 274 while ((*p) != '\0')
275 { 275 {
276 if (((*p)=='/') || ((*p)=='\\')) 276 if (((*p)=='/') || ((*p)=='\\'))
277 filename_withoutpath = p+1; 277 filename_withoutpath = p+1;
278 p++; 278 p++;
279 } 279 }
280 280
281 if ((*filename_withoutpath)=='\0') 281 if ((*filename_withoutpath)=='\0')
282 { 282 {
283 if ((*popt_extract_without_path)==0) 283 if ((*popt_extract_without_path)==0)
284 { 284 {
285 printf("creating directory: %s\n",filename_inzip); 285 printf("creating directory: %s\n",filename_inzip);
286 mymkdir(filename_inzip); 286 mymkdir(filename_inzip);
287 } 287 }
288 } 288 }
289 else 289 else
290 { 290 {
291 const char* write_filename; 291 const char* write_filename;
292 int skip=0; 292 int skip=0;
293 293
294 if ((*popt_extract_without_path)==0) 294 if ((*popt_extract_without_path)==0)
295 write_filename = filename_inzip; 295 write_filename = filename_inzip;
296 else 296 else
297 write_filename = filename_withoutpath; 297 write_filename = filename_withoutpath;
298 298
299 err = unzOpenCurrentFilePassword(uf,password); 299 err = unzOpenCurrentFilePassword(uf,password);
300 if (err!=UNZ_OK) 300 if (err!=UNZ_OK)
301 { 301 {
302 printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err); 302 printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
303 } 303 }
304 304
305 if (((*popt_overwrite)==0) && (err==UNZ_OK)) 305 if (((*popt_overwrite)==0) && (err==UNZ_OK))
306 { 306 {
307 char rep=0; 307 char rep=0;
308 FILE* ftestexist; 308 FILE* ftestexist;
309 ftestexist = fopen(write_filename,"rb"); 309 ftestexist = fopen(write_filename,"rb");
310 if (ftestexist!=NULL) 310 if (ftestexist!=NULL)
311 { 311 {
312 fclose(ftestexist); 312 fclose(ftestexist);
313 do 313 do
314 { 314 {
315 char answer[128]; 315 char answer[128];
316 int ret; 316 int ret;
317 317
318 printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename); 318 printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
319 ret = scanf("%1s",answer); 319 ret = scanf("%1s",answer);
320 if (ret != 1) 320 if (ret != 1)
321 { 321 {
322 exit(EXIT_FAILURE); 322 exit(EXIT_FAILURE);
323 } 323 }
324 rep = answer[0] ; 324 rep = answer[0] ;
325 if ((rep>='a') && (rep<='z')) 325 if ((rep>='a') && (rep<='z'))
326 rep -= 0x20; 326 rep -= 0x20;
327 } 327 }
328 while ((rep!='Y') && (rep!='N') && (rep!='A')); 328 while ((rep!='Y') && (rep!='N') && (rep!='A'));
329 } 329 }
330 330
331 if (rep == 'N') 331 if (rep == 'N')
332 skip = 1; 332 skip = 1;
333 333
334 if (rep == 'A') 334 if (rep == 'A')
335 *popt_overwrite=1; 335 *popt_overwrite=1;
336 } 336 }
337 337
338 if ((skip==0) && (err==UNZ_OK)) 338 if ((skip==0) && (err==UNZ_OK))
339 { 339 {
340 fout=fopen(write_filename,"wb"); 340 fout=fopen(write_filename,"wb");
341 341
342 /* some zipfile don't contain directory alone before file */ 342 /* some zipfile don't contain directory alone before file */
343 if ((fout==NULL) && ((*popt_extract_without_path)==0) && 343 if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
344 (filename_withoutpath!=(char*)filename_inzip)) 344 (filename_withoutpath!=(char*)filename_inzip))
345 { 345 {
346 char c=*(filename_withoutpath-1); 346 char c=*(filename_withoutpath-1);
347 *(filename_withoutpath-1)='\0'; 347 *(filename_withoutpath-1)='\0';
348 makedir(write_filename); 348 makedir(write_filename);
349 *(filename_withoutpath-1)=c; 349 *(filename_withoutpath-1)=c;
350 fout=fopen(write_filename,"wb"); 350 fout=fopen(write_filename,"wb");
351 } 351 }
352 352
353 if (fout==NULL) 353 if (fout==NULL)
354 { 354 {
355 printf("error opening %s\n",write_filename); 355 printf("error opening %s\n",write_filename);
356 } 356 }
357 } 357 }
358 358
359 if (fout!=NULL) 359 if (fout!=NULL)
360 { 360 {
361 printf(" extracting: %s\n",write_filename); 361 printf(" extracting: %s\n",write_filename);
362 362
363 do 363 do
364 { 364 {
365 err = unzReadCurrentFile(uf,buf,size_buf); 365 err = unzReadCurrentFile(uf,buf,size_buf);
366 if (err<0) 366 if (err<0)
367 { 367 {
368 printf("error %d with zipfile in unzReadCurrentFile\n",err); 368 printf("error %d with zipfile in unzReadCurrentFile\n",err);
369 break; 369 break;
370 } 370 }
371 if (err>0) 371 if (err>0)
372 if (fwrite(buf,err,1,fout)!=1) 372 if (fwrite(buf,err,1,fout)!=1)
373 { 373 {
374 printf("error in writing extracted file\n"); 374 printf("error in writing extracted file\n");
375 err=UNZ_ERRNO; 375 err=UNZ_ERRNO;
376 break; 376 break;
377 } 377 }
378 } 378 }
379 while (err>0); 379 while (err>0);
380 if (fout) 380 if (fout)
381 fclose(fout); 381 fclose(fout);
382 382
383 if (err==0) 383 if (err==0)
384 change_file_date(write_filename,file_info.dosDate, 384 change_file_date(write_filename,file_info.dosDate,
385 file_info.tmu_date); 385 file_info.tmu_date);
386 } 386 }
387 387
388 if (err==UNZ_OK) 388 if (err==UNZ_OK)
389 { 389 {
390 err = unzCloseCurrentFile (uf); 390 err = unzCloseCurrentFile (uf);
391 if (err!=UNZ_OK) 391 if (err!=UNZ_OK)
392 { 392 {
393 printf("error %d with zipfile in unzCloseCurrentFile\n",err); 393 printf("error %d with zipfile in unzCloseCurrentFile\n",err);
394 } 394 }
395 } 395 }
396 else 396 else
397 unzCloseCurrentFile(uf); /* don't lose the error */ 397 unzCloseCurrentFile(uf); /* don't lose the error */
398 } 398 }
399 399
400 free(buf); 400 free(buf);
401 return err; 401 return err;
402} 402}
403 403
404 404
405int do_extract(uf,opt_extract_without_path,opt_overwrite,password) 405int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
406 unzFile uf; 406 unzFile uf;
407 int opt_extract_without_path; 407 int opt_extract_without_path;
408 int opt_overwrite; 408 int opt_overwrite;
409 const char* password; 409 const char* password;
410{ 410{
411 uLong i; 411 uLong i;
412 unz_global_info gi; 412 unz_global_info gi;
413 int err; 413 int err;
414 FILE* fout=NULL; 414 FILE* fout=NULL;
415 415
416 err = unzGetGlobalInfo (uf,&gi); 416 err = unzGetGlobalInfo (uf,&gi);
417 if (err!=UNZ_OK) 417 if (err!=UNZ_OK)
418 printf("error %d with zipfile in unzGetGlobalInfo \n",err); 418 printf("error %d with zipfile in unzGetGlobalInfo \n",err);
419 419
420 for (i=0;i<gi.number_entry;i++) 420 for (i=0;i<gi.number_entry;i++)
421 { 421 {
422 if (do_extract_currentfile(uf,&opt_extract_without_path, 422 if (do_extract_currentfile(uf,&opt_extract_without_path,
423 &opt_overwrite, 423 &opt_overwrite,
424 password) != UNZ_OK) 424 password) != UNZ_OK)
425 break; 425 break;
426 426
427 if ((i+1)<gi.number_entry) 427 if ((i+1)<gi.number_entry)
428 { 428 {
429 err = unzGoToNextFile(uf); 429 err = unzGoToNextFile(uf);
430 if (err!=UNZ_OK) 430 if (err!=UNZ_OK)
431 { 431 {
432 printf("error %d with zipfile in unzGoToNextFile\n",err); 432 printf("error %d with zipfile in unzGoToNextFile\n",err);
433 break; 433 break;
434 } 434 }
435 } 435 }
436 } 436 }
437 437
438 return 0; 438 return 0;
439} 439}
440 440
441int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password) 441int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
442 unzFile uf; 442 unzFile uf;
443 const char* filename; 443 const char* filename;
444 int opt_extract_without_path; 444 int opt_extract_without_path;
445 int opt_overwrite; 445 int opt_overwrite;
446 const char* password; 446 const char* password;
447{ 447{
448 int err = UNZ_OK; 448 int err = UNZ_OK;
449 if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) 449 if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
450 { 450 {
451 printf("file %s not found in the zipfile\n",filename); 451 printf("file %s not found in the zipfile\n",filename);
452 return 2; 452 return 2;
453 } 453 }
454 454
455 if (do_extract_currentfile(uf,&opt_extract_without_path, 455 if (do_extract_currentfile(uf,&opt_extract_without_path,
456 &opt_overwrite, 456 &opt_overwrite,
457 password) == UNZ_OK) 457 password) == UNZ_OK)
458 return 0; 458 return 0;
459 else 459 else
460 return 1; 460 return 1;
461} 461}
462 462
463 463
464int main(argc,argv) 464int main(argc,argv)
465 int argc; 465 int argc;
466 char *argv[]; 466 char *argv[];
467{ 467{
468 const char *zipfilename=NULL; 468 const char *zipfilename=NULL;
469 const char *filename_to_extract=NULL; 469 const char *filename_to_extract=NULL;
470 const char *password=NULL; 470 const char *password=NULL;
471 char filename_try[MAXFILENAME+16] = ""; 471 char filename_try[MAXFILENAME+16] = "";
472 int i; 472 int i;
473 int opt_do_list=0; 473 int opt_do_list=0;
474 int opt_do_extract=1; 474 int opt_do_extract=1;
475 int opt_do_extract_withoutpath=0; 475 int opt_do_extract_withoutpath=0;
476 int opt_overwrite=0; 476 int opt_overwrite=0;
477 int opt_extractdir=0; 477 int opt_extractdir=0;
478 const char *dirname=NULL; 478 const char *dirname=NULL;
479 unzFile uf=NULL; 479 unzFile uf=NULL;
480 480
481 do_banner(); 481 do_banner();
482 if (argc==1) 482 if (argc==1)
483 { 483 {
484 do_help(); 484 do_help();
485 return 0; 485 return 0;
486 } 486 }
487 else 487 else
488 { 488 {
489 for (i=1;i<argc;i++) 489 for (i=1;i<argc;i++)
490 { 490 {
491 if ((*argv[i])=='-') 491 if ((*argv[i])=='-')
492 { 492 {
493 const char *p=argv[i]+1; 493 const char *p=argv[i]+1;
494 494
495 while ((*p)!='\0') 495 while ((*p)!='\0')
496 { 496 {
497 char c=*(p++);; 497 char c=*(p++);;
498 if ((c=='l') || (c=='L')) 498 if ((c=='l') || (c=='L'))
499 opt_do_list = 1; 499 opt_do_list = 1;
500 if ((c=='v') || (c=='V')) 500 if ((c=='v') || (c=='V'))
501 opt_do_list = 1; 501 opt_do_list = 1;
502 if ((c=='x') || (c=='X')) 502 if ((c=='x') || (c=='X'))
503 opt_do_extract = 1; 503 opt_do_extract = 1;
504 if ((c=='e') || (c=='E')) 504 if ((c=='e') || (c=='E'))
505 opt_do_extract = opt_do_extract_withoutpath = 1; 505 opt_do_extract = opt_do_extract_withoutpath = 1;
506 if ((c=='o') || (c=='O')) 506 if ((c=='o') || (c=='O'))
507 opt_overwrite=1; 507 opt_overwrite=1;
508 if ((c=='d') || (c=='D')) 508 if ((c=='d') || (c=='D'))
509 { 509 {
510 opt_extractdir=1; 510 opt_extractdir=1;
511 dirname=argv[i+1]; 511 dirname=argv[i+1];
512 } 512 }
513 513
514 if (((c=='p') || (c=='P')) && (i+1<argc)) 514 if (((c=='p') || (c=='P')) && (i+1<argc))
515 { 515 {
516 password=argv[i+1]; 516 password=argv[i+1];
517 i++; 517 i++;
518 } 518 }
519 } 519 }
520 } 520 }
521 else 521 else
522 { 522 {
523 if (zipfilename == NULL) 523 if (zipfilename == NULL)
524 zipfilename = argv[i]; 524 zipfilename = argv[i];
525 else if ((filename_to_extract==NULL) && (!opt_extractdir)) 525 else if ((filename_to_extract==NULL) && (!opt_extractdir))
526 filename_to_extract = argv[i] ; 526 filename_to_extract = argv[i] ;
527 } 527 }
528 } 528 }
529 } 529 }
530 530
531 if (zipfilename!=NULL) 531 if (zipfilename!=NULL)
532 { 532 {
533 533
534# ifdef USEWIN32IOAPI 534# ifdef USEWIN32IOAPI
535 zlib_filefunc_def ffunc; 535 zlib_filefunc_def ffunc;
536# endif 536# endif
537 537
538 strncpy(filename_try, zipfilename,MAXFILENAME-1); 538 strncpy(filename_try, zipfilename,MAXFILENAME-1);
539 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 539 /* strncpy doesnt append the trailing NULL, of the string is too long. */
540 filename_try[ MAXFILENAME ] = '\0'; 540 filename_try[ MAXFILENAME ] = '\0';
541 541
542# ifdef USEWIN32IOAPI 542# ifdef USEWIN32IOAPI
543 fill_win32_filefunc(&ffunc); 543 fill_win32_filefunc(&ffunc);
544 uf = unzOpen2(zipfilename,&ffunc); 544 uf = unzOpen2(zipfilename,&ffunc);
545# else 545# else
546 uf = unzOpen(zipfilename); 546 uf = unzOpen(zipfilename);
547# endif 547# endif
548 if (uf==NULL) 548 if (uf==NULL)
549 { 549 {
550 strcat(filename_try,".zip"); 550 strcat(filename_try,".zip");
551# ifdef USEWIN32IOAPI 551# ifdef USEWIN32IOAPI
552 uf = unzOpen2(filename_try,&ffunc); 552 uf = unzOpen2(filename_try,&ffunc);
553# else 553# else
554 uf = unzOpen(filename_try); 554 uf = unzOpen(filename_try);
555# endif 555# endif
556 } 556 }
557 } 557 }
558 558
559 if (uf==NULL) 559 if (uf==NULL)
560 { 560 {
561 printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename); 561 printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
562 return 1; 562 return 1;
563 } 563 }
564 printf("%s opened\n",filename_try); 564 printf("%s opened\n",filename_try);
565 565
566 if (opt_do_list==1) 566 if (opt_do_list==1)
567 return do_list(uf); 567 return do_list(uf);
568 else if (opt_do_extract==1) 568 else if (opt_do_extract==1)
569 { 569 {
570 if (opt_extractdir && chdir(dirname)) 570 if (opt_extractdir && chdir(dirname))
571 { 571 {
572 printf("Error changing into %s, aborting\n", dirname); 572 printf("Error changing into %s, aborting\n", dirname);
573 exit(-1); 573 exit(-1);
574 } 574 }
575 575
576 if (filename_to_extract == NULL) 576 if (filename_to_extract == NULL)
577 return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password); 577 return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password);
578 else 578 else
579 return do_extract_onefile(uf,filename_to_extract, 579 return do_extract_onefile(uf,filename_to_extract,
580 opt_do_extract_withoutpath,opt_overwrite,password); 580 opt_do_extract_withoutpath,opt_overwrite,password);
581 } 581 }
582 unzCloseCurrentFile(uf); 582 unzCloseCurrentFile(uf);
583 583
584 return 0; 584 return 0;
585} 585}
diff --git a/contrib/minizip/minizip.c b/contrib/minizip/minizip.c
index 918c322..70fee02 100644
--- a/contrib/minizip/minizip.c
+++ b/contrib/minizip/minizip.c
@@ -1,420 +1,420 @@
1/* 1/*
2 minizip.c 2 minizip.c
3 Version 1.01b, May 30th, 2004 3 Version 1.01e, February 12th, 2005
4 4
5 Copyright (C) 1998-2004 Gilles Vollant 5 Copyright (C) 1998-2005 Gilles Vollant
6*/ 6*/
7 7
8#include <stdio.h> 8#include <stdio.h>
9#include <stdlib.h> 9#include <stdlib.h>
10#include <string.h> 10#include <string.h>
11#include <time.h> 11#include <time.h>
12#include <errno.h> 12#include <errno.h>
13#include <fcntl.h> 13#include <fcntl.h>
14 14
15#ifdef unix 15#ifdef unix
16# include <unistd.h> 16# include <unistd.h>
17# include <utime.h> 17# include <utime.h>
18# include <sys/types.h> 18# include <sys/types.h>
19# include <sys/stat.h> 19# include <sys/stat.h>
20#else 20#else
21# include <direct.h> 21# include <direct.h>
22# include <io.h> 22# include <io.h>
23#endif 23#endif
24 24
25#include "zip.h" 25#include "zip.h"
26 26
27#ifdef WIN32 27#ifdef WIN32
28#define USEWIN32IOAPI 28#define USEWIN32IOAPI
29#include "iowin32.h" 29#include "iowin32.h"
30#endif 30#endif
31 31
32 32
33 33
34#define WRITEBUFFERSIZE (16384) 34#define WRITEBUFFERSIZE (16384)
35#define MAXFILENAME (256) 35#define MAXFILENAME (256)
36 36
37#ifdef WIN32 37#ifdef WIN32
38uLong filetime(f, tmzip, dt) 38uLong filetime(f, tmzip, dt)
39 char *f; /* name of file to get info on */ 39 char *f; /* name of file to get info on */
40 tm_zip *tmzip; /* return value: access, modific. and creation times */ 40 tm_zip *tmzip; /* return value: access, modific. and creation times */
41 uLong *dt; /* dostime */ 41 uLong *dt; /* dostime */
42{ 42{
43 int ret = 0; 43 int ret = 0;
44 { 44 {
45 FILETIME ftLocal; 45 FILETIME ftLocal;
46 HANDLE hFind; 46 HANDLE hFind;
47 WIN32_FIND_DATA ff32; 47 WIN32_FIND_DATA ff32;
48 48
49 hFind = FindFirstFile(f,&ff32); 49 hFind = FindFirstFile(f,&ff32);
50 if (hFind != INVALID_HANDLE_VALUE) 50 if (hFind != INVALID_HANDLE_VALUE)
51 { 51 {
52 FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal); 52 FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
53 FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0); 53 FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
54 FindClose(hFind); 54 FindClose(hFind);
55 ret = 1; 55 ret = 1;
56 } 56 }
57 } 57 }
58 return ret; 58 return ret;
59} 59}
60#else 60#else
61#ifdef unix 61#ifdef unix
62uLong filetime(f, tmzip, dt) 62uLong filetime(f, tmzip, dt)
63 char *f; /* name of file to get info on */ 63 char *f; /* name of file to get info on */
64 tm_zip *tmzip; /* return value: access, modific. and creation times */ 64 tm_zip *tmzip; /* return value: access, modific. and creation times */
65 uLong *dt; /* dostime */ 65 uLong *dt; /* dostime */
66{ 66{
67 int ret=0; 67 int ret=0;
68 struct stat s; /* results of stat() */ 68 struct stat s; /* results of stat() */
69 struct tm* filedate; 69 struct tm* filedate;
70 time_t tm_t=0; 70 time_t tm_t=0;
71 71
72 if (strcmp(f,"-")!=0) 72 if (strcmp(f,"-")!=0)
73 { 73 {
74 char name[MAXFILENAME+1]; 74 char name[MAXFILENAME+1];
75 int len = strlen(f); 75 int len = strlen(f);
76 if (len > MAXFILENAME) 76 if (len > MAXFILENAME)
77 len = MAXFILENAME; 77 len = MAXFILENAME;
78 78
79 strncpy(name, f,MAXFILENAME-1); 79 strncpy(name, f,MAXFILENAME-1);
80 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 80 /* strncpy doesnt append the trailing NULL, of the string is too long. */
81 name[ MAXFILENAME ] = '\0'; 81 name[ MAXFILENAME ] = '\0';
82 82
83 if (name[len - 1] == '/') 83 if (name[len - 1] == '/')
84 name[len - 1] = '\0'; 84 name[len - 1] = '\0';
85 /* not all systems allow stat'ing a file with / appended */ 85 /* not all systems allow stat'ing a file with / appended */
86 if (stat(name,&s)==0) 86 if (stat(name,&s)==0)
87 { 87 {
88 tm_t = s.st_mtime; 88 tm_t = s.st_mtime;
89 ret = 1; 89 ret = 1;
90 } 90 }
91 } 91 }
92 filedate = localtime(&tm_t); 92 filedate = localtime(&tm_t);
93 93
94 tmzip->tm_sec = filedate->tm_sec; 94 tmzip->tm_sec = filedate->tm_sec;
95 tmzip->tm_min = filedate->tm_min; 95 tmzip->tm_min = filedate->tm_min;
96 tmzip->tm_hour = filedate->tm_hour; 96 tmzip->tm_hour = filedate->tm_hour;
97 tmzip->tm_mday = filedate->tm_mday; 97 tmzip->tm_mday = filedate->tm_mday;
98 tmzip->tm_mon = filedate->tm_mon ; 98 tmzip->tm_mon = filedate->tm_mon ;
99 tmzip->tm_year = filedate->tm_year; 99 tmzip->tm_year = filedate->tm_year;
100 100
101 return ret; 101 return ret;
102} 102}
103#else 103#else
104uLong filetime(f, tmzip, dt) 104uLong filetime(f, tmzip, dt)
105 char *f; /* name of file to get info on */ 105 char *f; /* name of file to get info on */
106 tm_zip *tmzip; /* return value: access, modific. and creation times */ 106 tm_zip *tmzip; /* return value: access, modific. and creation times */
107 uLong *dt; /* dostime */ 107 uLong *dt; /* dostime */
108{ 108{
109 return 0; 109 return 0;
110} 110}
111#endif 111#endif
112#endif 112#endif
113 113
114 114
115 115
116 116
117int check_exist_file(filename) 117int check_exist_file(filename)
118 const char* filename; 118 const char* filename;
119{ 119{
120 FILE* ftestexist; 120 FILE* ftestexist;
121 int ret = 1; 121 int ret = 1;
122 ftestexist = fopen(filename,"rb"); 122 ftestexist = fopen(filename,"rb");
123 if (ftestexist==NULL) 123 if (ftestexist==NULL)
124 ret = 0; 124 ret = 0;
125 else 125 else
126 fclose(ftestexist); 126 fclose(ftestexist);
127 return ret; 127 return ret;
128} 128}
129 129
130void do_banner() 130void do_banner()
131{ 131{
132 printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n"); 132 printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n");
133 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); 133 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
134} 134}
135 135
136void do_help() 136void do_help()
137{ 137{
138 printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \ 138 printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
139 " -o Overwrite existing file.zip\n" \ 139 " -o Overwrite existing file.zip\n" \
140 " -a Append to existing file.zip\n" \ 140 " -a Append to existing file.zip\n" \
141 " -0 Store only\n" \ 141 " -0 Store only\n" \
142 " -1 Compress faster\n" \ 142 " -1 Compress faster\n" \
143 " -9 Compress better\n\n"); 143 " -9 Compress better\n\n");
144} 144}
145 145
146/* calculate the CRC32 of a file, 146/* calculate the CRC32 of a file,
147 because to encrypt a file, we need known the CRC32 of the file before */ 147 because to encrypt a file, we need known the CRC32 of the file before */
148int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) 148int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
149{ 149{
150 unsigned long calculate_crc=0; 150 unsigned long calculate_crc=0;
151 int err=ZIP_OK; 151 int err=ZIP_OK;
152 FILE * fin = fopen(filenameinzip,"rb"); 152 FILE * fin = fopen(filenameinzip,"rb");
153 unsigned long size_read = 0; 153 unsigned long size_read = 0;
154 unsigned long total_read = 0; 154 unsigned long total_read = 0;
155 if (fin==NULL) 155 if (fin==NULL)
156 { 156 {
157 err = ZIP_ERRNO; 157 err = ZIP_ERRNO;
158 } 158 }
159 159
160 if (err == ZIP_OK) 160 if (err == ZIP_OK)
161 do 161 do
162 { 162 {
163 err = ZIP_OK; 163 err = ZIP_OK;
164 size_read = (int)fread(buf,1,size_buf,fin); 164 size_read = (int)fread(buf,1,size_buf,fin);
165 if (size_read < size_buf) 165 if (size_read < size_buf)
166 if (feof(fin)==0) 166 if (feof(fin)==0)
167 { 167 {
168 printf("error in reading %s\n",filenameinzip); 168 printf("error in reading %s\n",filenameinzip);
169 err = ZIP_ERRNO; 169 err = ZIP_ERRNO;
170 } 170 }
171 171
172 if (size_read>0) 172 if (size_read>0)
173 calculate_crc = crc32(calculate_crc,buf,size_read); 173 calculate_crc = crc32(calculate_crc,buf,size_read);
174 total_read += size_read; 174 total_read += size_read;
175 175
176 } while ((err == ZIP_OK) && (size_read>0)); 176 } while ((err == ZIP_OK) && (size_read>0));
177 177
178 if (fin) 178 if (fin)
179 fclose(fin); 179 fclose(fin);
180 180
181 *result_crc=calculate_crc; 181 *result_crc=calculate_crc;
182 printf("file %s crc %x\n",filenameinzip,calculate_crc); 182 printf("file %s crc %x\n",filenameinzip,calculate_crc);
183 return err; 183 return err;
184} 184}
185 185
186int main(argc,argv) 186int main(argc,argv)
187 int argc; 187 int argc;
188 char *argv[]; 188 char *argv[];
189{ 189{
190 int i; 190 int i;
191 int opt_overwrite=0; 191 int opt_overwrite=0;
192 int opt_compress_level=Z_DEFAULT_COMPRESSION; 192 int opt_compress_level=Z_DEFAULT_COMPRESSION;
193 int zipfilenamearg = 0; 193 int zipfilenamearg = 0;
194 char filename_try[MAXFILENAME+16]; 194 char filename_try[MAXFILENAME+16];
195 int zipok; 195 int zipok;
196 int err=0; 196 int err=0;
197 int size_buf=0; 197 int size_buf=0;
198 void* buf=NULL; 198 void* buf=NULL;
199 const char* password=NULL; 199 const char* password=NULL;
200 200
201 201
202 do_banner(); 202 do_banner();
203 if (argc==1) 203 if (argc==1)
204 { 204 {
205 do_help(); 205 do_help();
206 return 0; 206 return 0;
207 } 207 }
208 else 208 else
209 { 209 {
210 for (i=1;i<argc;i++) 210 for (i=1;i<argc;i++)
211 { 211 {
212 if ((*argv[i])=='-') 212 if ((*argv[i])=='-')
213 { 213 {
214 const char *p=argv[i]+1; 214 const char *p=argv[i]+1;
215 215
216 while ((*p)!='\0') 216 while ((*p)!='\0')
217 { 217 {
218 char c=*(p++);; 218 char c=*(p++);;
219 if ((c=='o') || (c=='O')) 219 if ((c=='o') || (c=='O'))
220 opt_overwrite = 1; 220 opt_overwrite = 1;
221 if ((c=='a') || (c=='A')) 221 if ((c=='a') || (c=='A'))
222 opt_overwrite = 2; 222 opt_overwrite = 2;
223 if ((c>='0') && (c<='9')) 223 if ((c>='0') && (c<='9'))
224 opt_compress_level = c-'0'; 224 opt_compress_level = c-'0';
225 225
226 if (((c=='p') || (c=='P')) && (i+1<argc)) 226 if (((c=='p') || (c=='P')) && (i+1<argc))
227 { 227 {
228 password=argv[i+1]; 228 password=argv[i+1];
229 i++; 229 i++;
230 } 230 }
231 } 231 }
232 } 232 }
233 else 233 else
234 if (zipfilenamearg == 0) 234 if (zipfilenamearg == 0)
235 zipfilenamearg = i ; 235 zipfilenamearg = i ;
236 } 236 }
237 } 237 }
238 238
239 size_buf = WRITEBUFFERSIZE; 239 size_buf = WRITEBUFFERSIZE;
240 buf = (void*)malloc(size_buf); 240 buf = (void*)malloc(size_buf);
241 if (buf==NULL) 241 if (buf==NULL)
242 { 242 {
243 printf("Error allocating memory\n"); 243 printf("Error allocating memory\n");
244 return ZIP_INTERNALERROR; 244 return ZIP_INTERNALERROR;
245 } 245 }
246 246
247 if (zipfilenamearg==0) 247 if (zipfilenamearg==0)
248 zipok=0; 248 zipok=0;
249 else 249 else
250 { 250 {
251 int i,len; 251 int i,len;
252 int dot_found=0; 252 int dot_found=0;
253 253
254 zipok = 1 ; 254 zipok = 1 ;
255 strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); 255 strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
256 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 256 /* strncpy doesnt append the trailing NULL, of the string is too long. */
257 filename_try[ MAXFILENAME ] = '\0'; 257 filename_try[ MAXFILENAME ] = '\0';
258 258
259 len=(int)strlen(filename_try); 259 len=(int)strlen(filename_try);
260 for (i=0;i<len;i++) 260 for (i=0;i<len;i++)
261 if (filename_try[i]=='.') 261 if (filename_try[i]=='.')
262 dot_found=1; 262 dot_found=1;
263 263
264 if (dot_found==0) 264 if (dot_found==0)
265 strcat(filename_try,".zip"); 265 strcat(filename_try,".zip");
266 266
267 if (opt_overwrite==2) 267 if (opt_overwrite==2)
268 { 268 {
269 /* if the file don't exist, we not append file */ 269 /* if the file don't exist, we not append file */
270 if (check_exist_file(filename_try)==0) 270 if (check_exist_file(filename_try)==0)
271 opt_overwrite=1; 271 opt_overwrite=1;
272 } 272 }
273 else 273 else
274 if (opt_overwrite==0) 274 if (opt_overwrite==0)
275 if (check_exist_file(filename_try)!=0) 275 if (check_exist_file(filename_try)!=0)
276 { 276 {
277 char rep=0; 277 char rep=0;
278 do 278 do
279 { 279 {
280 char answer[128]; 280 char answer[128];
281 int ret; 281 int ret;
282 printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); 282 printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
283 ret = scanf("%1s",answer); 283 ret = scanf("%1s",answer);
284 if (ret != 1) 284 if (ret != 1)
285 { 285 {
286 exit(EXIT_FAILURE); 286 exit(EXIT_FAILURE);
287 } 287 }
288 rep = answer[0] ; 288 rep = answer[0] ;
289 if ((rep>='a') && (rep<='z')) 289 if ((rep>='a') && (rep<='z'))
290 rep -= 0x20; 290 rep -= 0x20;
291 } 291 }
292 while ((rep!='Y') && (rep!='N') && (rep!='A')); 292 while ((rep!='Y') && (rep!='N') && (rep!='A'));
293 if (rep=='N') 293 if (rep=='N')
294 zipok = 0; 294 zipok = 0;
295 if (rep=='A') 295 if (rep=='A')
296 opt_overwrite = 2; 296 opt_overwrite = 2;
297 } 297 }
298 } 298 }
299 299
300 if (zipok==1) 300 if (zipok==1)
301 { 301 {
302 zipFile zf; 302 zipFile zf;
303 int errclose; 303 int errclose;
304# ifdef USEWIN32IOAPI 304# ifdef USEWIN32IOAPI
305 zlib_filefunc_def ffunc; 305 zlib_filefunc_def ffunc;
306 fill_win32_filefunc(&ffunc); 306 fill_win32_filefunc(&ffunc);
307 zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); 307 zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
308# else 308# else
309 zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0); 309 zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
310# endif 310# endif
311 311
312 if (zf == NULL) 312 if (zf == NULL)
313 { 313 {
314 printf("error opening %s\n",filename_try); 314 printf("error opening %s\n",filename_try);
315 err= ZIP_ERRNO; 315 err= ZIP_ERRNO;
316 } 316 }
317 else 317 else
318 printf("creating %s\n",filename_try); 318 printf("creating %s\n",filename_try);
319 319
320 for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) 320 for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
321 { 321 {
322 if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) && 322 if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
323 ((argv[i][1]=='o') || (argv[i][1]=='O') || 323 ((argv[i][1]=='o') || (argv[i][1]=='O') ||
324 (argv[i][1]=='a') || (argv[i][1]=='A') || 324 (argv[i][1]=='a') || (argv[i][1]=='A') ||
325 (argv[i][1]=='p') || (argv[i][1]=='P') || 325 (argv[i][1]=='p') || (argv[i][1]=='P') ||
326 ((argv[i][1]>='0') || (argv[i][1]<='9'))) && 326 ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
327 (strlen(argv[i]) == 2))) 327 (strlen(argv[i]) == 2)))
328 { 328 {
329 FILE * fin; 329 FILE * fin;
330 int size_read; 330 int size_read;
331 const char* filenameinzip = argv[i]; 331 const char* filenameinzip = argv[i];
332 zip_fileinfo zi; 332 zip_fileinfo zi;
333 unsigned long crcFile=0; 333 unsigned long crcFile=0;
334 334
335 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = 335 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
336 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; 336 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
337 zi.dosDate = 0; 337 zi.dosDate = 0;
338 zi.internal_fa = 0; 338 zi.internal_fa = 0;
339 zi.external_fa = 0; 339 zi.external_fa = 0;
340 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); 340 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
341 341
342/* 342/*
343 err = zipOpenNewFileInZip(zf,filenameinzip,&zi, 343 err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
344 NULL,0,NULL,0,NULL / * comment * /, 344 NULL,0,NULL,0,NULL / * comment * /,
345 (opt_compress_level != 0) ? Z_DEFLATED : 0, 345 (opt_compress_level != 0) ? Z_DEFLATED : 0,
346 opt_compress_level); 346 opt_compress_level);
347*/ 347*/
348 if ((password != NULL) && (err==ZIP_OK)) 348 if ((password != NULL) && (err==ZIP_OK))
349 err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); 349 err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
350 350
351 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi, 351 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
352 NULL,0,NULL,0,NULL /* comment*/, 352 NULL,0,NULL,0,NULL /* comment*/,
353 (opt_compress_level != 0) ? Z_DEFLATED : 0, 353 (opt_compress_level != 0) ? Z_DEFLATED : 0,
354 opt_compress_level,0, 354 opt_compress_level,0,
355 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ 355 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
356 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 356 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
357 password,crcFile); 357 password,crcFile);
358 358
359 if (err != ZIP_OK) 359 if (err != ZIP_OK)
360 printf("error in opening %s in zipfile\n",filenameinzip); 360 printf("error in opening %s in zipfile\n",filenameinzip);
361 else 361 else
362 { 362 {
363 fin = fopen(filenameinzip,"rb"); 363 fin = fopen(filenameinzip,"rb");
364 if (fin==NULL) 364 if (fin==NULL)
365 { 365 {
366 err=ZIP_ERRNO; 366 err=ZIP_ERRNO;
367 printf("error in opening %s for reading\n",filenameinzip); 367 printf("error in opening %s for reading\n",filenameinzip);
368 } 368 }
369 } 369 }
370 370
371 if (err == ZIP_OK) 371 if (err == ZIP_OK)
372 do 372 do
373 { 373 {
374 err = ZIP_OK; 374 err = ZIP_OK;
375 size_read = (int)fread(buf,1,size_buf,fin); 375 size_read = (int)fread(buf,1,size_buf,fin);
376 if (size_read < size_buf) 376 if (size_read < size_buf)
377 if (feof(fin)==0) 377 if (feof(fin)==0)
378 { 378 {
379 printf("error in reading %s\n",filenameinzip); 379 printf("error in reading %s\n",filenameinzip);
380 err = ZIP_ERRNO; 380 err = ZIP_ERRNO;
381 } 381 }
382 382
383 if (size_read>0) 383 if (size_read>0)
384 { 384 {
385 err = zipWriteInFileInZip (zf,buf,size_read); 385 err = zipWriteInFileInZip (zf,buf,size_read);
386 if (err<0) 386 if (err<0)
387 { 387 {
388 printf("error in writing %s in the zipfile\n", 388 printf("error in writing %s in the zipfile\n",
389 filenameinzip); 389 filenameinzip);
390 } 390 }
391 391
392 } 392 }
393 } while ((err == ZIP_OK) && (size_read>0)); 393 } while ((err == ZIP_OK) && (size_read>0));
394 394
395 if (fin) 395 if (fin)
396 fclose(fin); 396 fclose(fin);
397 397
398 if (err<0) 398 if (err<0)
399 err=ZIP_ERRNO; 399 err=ZIP_ERRNO;
400 else 400 else
401 { 401 {
402 err = zipCloseFileInZip(zf); 402 err = zipCloseFileInZip(zf);
403 if (err!=ZIP_OK) 403 if (err!=ZIP_OK)
404 printf("error in closing %s in the zipfile\n", 404 printf("error in closing %s in the zipfile\n",
405 filenameinzip); 405 filenameinzip);
406 } 406 }
407 } 407 }
408 } 408 }
409 errclose = zipClose(zf,NULL); 409 errclose = zipClose(zf,NULL);
410 if (errclose != ZIP_OK) 410 if (errclose != ZIP_OK)
411 printf("error in closing %s\n",filename_try); 411 printf("error in closing %s\n",filename_try);
412 } 412 }
413 else 413 else
414 { 414 {
415 do_help(); 415 do_help();
416 } 416 }
417 417
418 free(buf); 418 free(buf);
419 return 0; 419 return 0;
420} 420}
diff --git a/contrib/minizip/mztools.c b/contrib/minizip/mztools.c
index c1266bc..bc5c798 100644
--- a/contrib/minizip/mztools.c
+++ b/contrib/minizip/mztools.c
@@ -1,281 +1,281 @@
1/* 1/*
2 Additional tools for Minizip 2 Additional tools for Minizip
3 Code: Xavier Roche '2004 3 Code: Xavier Roche '2004
4 License: Same as ZLIB (www.gzip.org) 4 License: Same as ZLIB (www.gzip.org)
5*/ 5*/
6 6
7/* Code */ 7/* Code */
8#include <stdio.h> 8#include <stdio.h>
9#include <stdlib.h> 9#include <stdlib.h>
10#include <string.h> 10#include <string.h>
11#include "zlib.h" 11#include "zlib.h"
12#include "unzip.h" 12#include "unzip.h"
13 13
14#define READ_8(adr) ((unsigned char)*(adr)) 14#define READ_8(adr) ((unsigned char)*(adr))
15#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) 15#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
16#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) 16#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
17 17
18#define WRITE_8(buff, n) do { \ 18#define WRITE_8(buff, n) do { \
19 *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \ 19 *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
20} while(0) 20} while(0)
21#define WRITE_16(buff, n) do { \ 21#define WRITE_16(buff, n) do { \
22 WRITE_8((unsigned char*)(buff), n); \ 22 WRITE_8((unsigned char*)(buff), n); \
23 WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \ 23 WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
24} while(0) 24} while(0)
25#define WRITE_32(buff, n) do { \ 25#define WRITE_32(buff, n) do { \
26 WRITE_16((unsigned char*)(buff), (n) & 0xffff); \ 26 WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
27 WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \ 27 WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
28} while(0) 28} while(0)
29 29
30extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) 30extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
31const char* file; 31const char* file;
32const char* fileOut; 32const char* fileOut;
33const char* fileOutTmp; 33const char* fileOutTmp;
34uLong* nRecovered; 34uLong* nRecovered;
35uLong* bytesRecovered; 35uLong* bytesRecovered;
36{ 36{
37 int err = Z_OK; 37 int err = Z_OK;
38 FILE* fpZip = fopen(file, "rb"); 38 FILE* fpZip = fopen(file, "rb");
39 FILE* fpOut = fopen(fileOut, "wb"); 39 FILE* fpOut = fopen(fileOut, "wb");
40 FILE* fpOutCD = fopen(fileOutTmp, "wb"); 40 FILE* fpOutCD = fopen(fileOutTmp, "wb");
41 if (fpZip != NULL && fpOut != NULL) { 41 if (fpZip != NULL && fpOut != NULL) {
42 int entries = 0; 42 int entries = 0;
43 uLong totalBytes = 0; 43 uLong totalBytes = 0;
44 char header[30]; 44 char header[30];
45 char filename[256]; 45 char filename[256];
46 char extra[1024]; 46 char extra[1024];
47 int offset = 0; 47 int offset = 0;
48 int offsetCD = 0; 48 int offsetCD = 0;
49 while ( fread(header, 1, 30, fpZip) == 30 ) { 49 while ( fread(header, 1, 30, fpZip) == 30 ) {
50 int currentOffset = offset; 50 int currentOffset = offset;
51 51
52 /* File entry */ 52 /* File entry */
53 if (READ_32(header) == 0x04034b50) { 53 if (READ_32(header) == 0x04034b50) {
54 unsigned int version = READ_16(header + 4); 54 unsigned int version = READ_16(header + 4);
55 unsigned int gpflag = READ_16(header + 6); 55 unsigned int gpflag = READ_16(header + 6);
56 unsigned int method = READ_16(header + 8); 56 unsigned int method = READ_16(header + 8);
57 unsigned int filetime = READ_16(header + 10); 57 unsigned int filetime = READ_16(header + 10);
58 unsigned int filedate = READ_16(header + 12); 58 unsigned int filedate = READ_16(header + 12);
59 unsigned int crc = READ_32(header + 14); /* crc */ 59 unsigned int crc = READ_32(header + 14); /* crc */
60 unsigned int cpsize = READ_32(header + 18); /* compressed size */ 60 unsigned int cpsize = READ_32(header + 18); /* compressed size */
61 unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ 61 unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
62 unsigned int fnsize = READ_16(header + 26); /* file name length */ 62 unsigned int fnsize = READ_16(header + 26); /* file name length */
63 unsigned int extsize = READ_16(header + 28); /* extra field length */ 63 unsigned int extsize = READ_16(header + 28); /* extra field length */
64 filename[0] = extra[0] = '\0'; 64 filename[0] = extra[0] = '\0';
65 65
66 /* Header */ 66 /* Header */
67 if (fwrite(header, 1, 30, fpOut) == 30) { 67 if (fwrite(header, 1, 30, fpOut) == 30) {
68 offset += 30; 68 offset += 30;
69 } else { 69 } else {
70 err = Z_ERRNO; 70 err = Z_ERRNO;
71 break; 71 break;
72 } 72 }
73 73
74 /* Filename */ 74 /* Filename */
75 if (fnsize > 0) { 75 if (fnsize > 0) {
76 if (fread(filename, 1, fnsize, fpZip) == fnsize) { 76 if (fread(filename, 1, fnsize, fpZip) == fnsize) {
77 if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { 77 if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
78 offset += fnsize; 78 offset += fnsize;
79 } else { 79 } else {
80 err = Z_ERRNO; 80 err = Z_ERRNO;
81 break; 81 break;
82 } 82 }
83 } else { 83 } else {
84 err = Z_ERRNO; 84 err = Z_ERRNO;
85 break; 85 break;
86 } 86 }
87 } else { 87 } else {
88 err = Z_STREAM_ERROR; 88 err = Z_STREAM_ERROR;
89 break; 89 break;
90 } 90 }
91 91
92 /* Extra field */ 92 /* Extra field */
93 if (extsize > 0) { 93 if (extsize > 0) {
94 if (fread(extra, 1, extsize, fpZip) == extsize) { 94 if (fread(extra, 1, extsize, fpZip) == extsize) {
95 if (fwrite(extra, 1, extsize, fpOut) == extsize) { 95 if (fwrite(extra, 1, extsize, fpOut) == extsize) {
96 offset += extsize; 96 offset += extsize;
97 } else { 97 } else {
98 err = Z_ERRNO; 98 err = Z_ERRNO;
99 break; 99 break;
100 } 100 }
101 } else { 101 } else {
102 err = Z_ERRNO; 102 err = Z_ERRNO;
103 break; 103 break;
104 } 104 }
105 } 105 }
106 106
107 /* Data */ 107 /* Data */
108 { 108 {
109 int dataSize = cpsize; 109 int dataSize = cpsize;
110 if (dataSize == 0) { 110 if (dataSize == 0) {
111 dataSize = uncpsize; 111 dataSize = uncpsize;
112 } 112 }
113 if (dataSize > 0) { 113 if (dataSize > 0) {
114 char* data = malloc(dataSize); 114 char* data = malloc(dataSize);
115 if (data != NULL) { 115 if (data != NULL) {
116 if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { 116 if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
117 if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { 117 if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
118 offset += dataSize; 118 offset += dataSize;
119 totalBytes += dataSize; 119 totalBytes += dataSize;
120 } else { 120 } else {
121 err = Z_ERRNO; 121 err = Z_ERRNO;
122 } 122 }
123 } else { 123 } else {
124 err = Z_ERRNO; 124 err = Z_ERRNO;
125 } 125 }
126 free(data); 126 free(data);
127 if (err != Z_OK) { 127 if (err != Z_OK) {
128 break; 128 break;
129 } 129 }
130 } else { 130 } else {
131 err = Z_MEM_ERROR; 131 err = Z_MEM_ERROR;
132 break; 132 break;
133 } 133 }
134 } 134 }
135 } 135 }
136 136
137 /* Central directory entry */ 137 /* Central directory entry */
138 { 138 {
139 char header[46]; 139 char header[46];
140 char* comment = ""; 140 char* comment = "";
141 int comsize = (int) strlen(comment); 141 int comsize = (int) strlen(comment);
142 WRITE_32(header, 0x02014b50); 142 WRITE_32(header, 0x02014b50);
143 WRITE_16(header + 4, version); 143 WRITE_16(header + 4, version);
144 WRITE_16(header + 6, version); 144 WRITE_16(header + 6, version);
145 WRITE_16(header + 8, gpflag); 145 WRITE_16(header + 8, gpflag);
146 WRITE_16(header + 10, method); 146 WRITE_16(header + 10, method);
147 WRITE_16(header + 12, filetime); 147 WRITE_16(header + 12, filetime);
148 WRITE_16(header + 14, filedate); 148 WRITE_16(header + 14, filedate);
149 WRITE_32(header + 16, crc); 149 WRITE_32(header + 16, crc);
150 WRITE_32(header + 20, cpsize); 150 WRITE_32(header + 20, cpsize);
151 WRITE_32(header + 24, uncpsize); 151 WRITE_32(header + 24, uncpsize);
152 WRITE_16(header + 28, fnsize); 152 WRITE_16(header + 28, fnsize);
153 WRITE_16(header + 30, extsize); 153 WRITE_16(header + 30, extsize);
154 WRITE_16(header + 32, comsize); 154 WRITE_16(header + 32, comsize);
155 WRITE_16(header + 34, 0); /* disk # */ 155 WRITE_16(header + 34, 0); /* disk # */
156 WRITE_16(header + 36, 0); /* int attrb */ 156 WRITE_16(header + 36, 0); /* int attrb */
157 WRITE_32(header + 38, 0); /* ext attrb */ 157 WRITE_32(header + 38, 0); /* ext attrb */
158 WRITE_32(header + 42, currentOffset); 158 WRITE_32(header + 42, currentOffset);
159 /* Header */ 159 /* Header */
160 if (fwrite(header, 1, 46, fpOutCD) == 46) { 160 if (fwrite(header, 1, 46, fpOutCD) == 46) {
161 offsetCD += 46; 161 offsetCD += 46;
162 162
163 /* Filename */ 163 /* Filename */
164 if (fnsize > 0) { 164 if (fnsize > 0) {
165 if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { 165 if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
166 offsetCD += fnsize; 166 offsetCD += fnsize;
167 } else { 167 } else {
168 err = Z_ERRNO; 168 err = Z_ERRNO;
169 break; 169 break;
170 } 170 }
171 } else { 171 } else {
172 err = Z_STREAM_ERROR; 172 err = Z_STREAM_ERROR;
173 break; 173 break;
174 } 174 }
175 175
176 /* Extra field */ 176 /* Extra field */
177 if (extsize > 0) { 177 if (extsize > 0) {
178 if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { 178 if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
179 offsetCD += extsize; 179 offsetCD += extsize;
180 } else { 180 } else {
181 err = Z_ERRNO; 181 err = Z_ERRNO;
182 break; 182 break;
183 } 183 }
184 } 184 }
185 185
186 /* Comment field */ 186 /* Comment field */
187 if (comsize > 0) { 187 if (comsize > 0) {
188 if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { 188 if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
189 offsetCD += comsize; 189 offsetCD += comsize;
190 } else { 190 } else {
191 err = Z_ERRNO; 191 err = Z_ERRNO;
192 break; 192 break;
193 } 193 }
194 } 194 }
195 195
196 196
197 } else { 197 } else {
198 err = Z_ERRNO; 198 err = Z_ERRNO;
199 break; 199 break;
200 } 200 }
201 } 201 }
202 202
203 /* Success */ 203 /* Success */
204 entries++; 204 entries++;
205 205
206 } else { 206 } else {
207 break; 207 break;
208 } 208 }
209 } 209 }
210 210
211 /* Final central directory */ 211 /* Final central directory */
212 { 212 {
213 int entriesZip = entries; 213 int entriesZip = entries;
214 char header[22]; 214 char header[22];
215 char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools"; 215 char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
216 int comsize = (int) strlen(comment); 216 int comsize = (int) strlen(comment);
217 if (entriesZip > 0xffff) { 217 if (entriesZip > 0xffff) {
218 entriesZip = 0xffff; 218 entriesZip = 0xffff;
219 } 219 }
220 WRITE_32(header, 0x06054b50); 220 WRITE_32(header, 0x06054b50);
221 WRITE_16(header + 4, 0); /* disk # */ 221 WRITE_16(header + 4, 0); /* disk # */
222 WRITE_16(header + 6, 0); /* disk # */ 222 WRITE_16(header + 6, 0); /* disk # */
223 WRITE_16(header + 8, entriesZip); /* hack */ 223 WRITE_16(header + 8, entriesZip); /* hack */
224 WRITE_16(header + 10, entriesZip); /* hack */ 224 WRITE_16(header + 10, entriesZip); /* hack */
225 WRITE_32(header + 12, offsetCD); /* size of CD */ 225 WRITE_32(header + 12, offsetCD); /* size of CD */
226 WRITE_32(header + 16, offset); /* offset to CD */ 226 WRITE_32(header + 16, offset); /* offset to CD */
227 WRITE_16(header + 20, comsize); /* comment */ 227 WRITE_16(header + 20, comsize); /* comment */
228 228
229 /* Header */ 229 /* Header */
230 if (fwrite(header, 1, 22, fpOutCD) == 22) { 230 if (fwrite(header, 1, 22, fpOutCD) == 22) {
231 231
232 /* Comment field */ 232 /* Comment field */
233 if (comsize > 0) { 233 if (comsize > 0) {
234 if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { 234 if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
235 err = Z_ERRNO; 235 err = Z_ERRNO;
236 } 236 }
237 } 237 }
238 238
239 } else { 239 } else {
240 err = Z_ERRNO; 240 err = Z_ERRNO;
241 } 241 }
242 } 242 }
243 243
244 /* Final merge (file + central directory) */ 244 /* Final merge (file + central directory) */
245 fclose(fpOutCD); 245 fclose(fpOutCD);
246 if (err == Z_OK) { 246 if (err == Z_OK) {
247 fpOutCD = fopen(fileOutTmp, "rb"); 247 fpOutCD = fopen(fileOutTmp, "rb");
248 if (fpOutCD != NULL) { 248 if (fpOutCD != NULL) {
249 int nRead; 249 int nRead;
250 char buffer[8192]; 250 char buffer[8192];
251 while ( (nRead = fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { 251 while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
252 if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { 252 if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
253 err = Z_ERRNO; 253 err = Z_ERRNO;
254 break; 254 break;
255 } 255 }
256 } 256 }
257 fclose(fpOutCD); 257 fclose(fpOutCD);
258 } 258 }
259 } 259 }
260 260
261 /* Close */ 261 /* Close */
262 fclose(fpZip); 262 fclose(fpZip);
263 fclose(fpOut); 263 fclose(fpOut);
264 264
265 /* Wipe temporary file */ 265 /* Wipe temporary file */
266 (void)remove(fileOutTmp); 266 (void)remove(fileOutTmp);
267 267
268 /* Number of recovered entries */ 268 /* Number of recovered entries */
269 if (err == Z_OK) { 269 if (err == Z_OK) {
270 if (nRecovered != NULL) { 270 if (nRecovered != NULL) {
271 *nRecovered = entries; 271 *nRecovered = entries;
272 } 272 }
273 if (bytesRecovered != NULL) { 273 if (bytesRecovered != NULL) {
274 *bytesRecovered = totalBytes; 274 *bytesRecovered = totalBytes;
275 } 275 }
276 } 276 }
277 } else { 277 } else {
278 err = Z_STREAM_ERROR; 278 err = Z_STREAM_ERROR;
279 } 279 }
280 return err; 280 return err;
281} 281}
diff --git a/contrib/minizip/mztools.h b/contrib/minizip/mztools.h
index 88b3459..82d1597 100644
--- a/contrib/minizip/mztools.h
+++ b/contrib/minizip/mztools.h
@@ -1,31 +1,31 @@
1/* 1/*
2 Additional tools for Minizip 2 Additional tools for Minizip
3 Code: Xavier Roche '2004 3 Code: Xavier Roche '2004
4 License: Same as ZLIB (www.gzip.org) 4 License: Same as ZLIB (www.gzip.org)
5*/ 5*/
6 6
7#ifndef _zip_tools_H 7#ifndef _zip_tools_H
8#define _zip_tools_H 8#define _zip_tools_H
9 9
10#ifdef __cplusplus 10#ifdef __cplusplus
11extern "C" { 11extern "C" {
12#endif 12#endif
13 13
14#ifndef _ZLIB_H 14#ifndef _ZLIB_H
15#include "zlib.h" 15#include "zlib.h"
16#endif 16#endif
17 17
18#include "unzip.h" 18#include "unzip.h"
19 19
20/* Repair a ZIP file (missing central directory) 20/* Repair a ZIP file (missing central directory)
21 file: file to recover 21 file: file to recover
22 fileOut: output file after recovery 22 fileOut: output file after recovery
23 fileOutTmp: temporary file name used for recovery 23 fileOutTmp: temporary file name used for recovery
24*/ 24*/
25extern int ZEXPORT unzRepair(const char* file, 25extern int ZEXPORT unzRepair(const char* file,
26 const char* fileOut, 26 const char* fileOut,
27 const char* fileOutTmp, 27 const char* fileOutTmp,
28 uLong* nRecovered, 28 uLong* nRecovered,
29 uLong* bytesRecovered); 29 uLong* bytesRecovered);
30 30
31#endif 31#endif
diff --git a/contrib/minizip/unzip.c b/contrib/minizip/unzip.c
index e14de9e..3a70629 100644
--- a/contrib/minizip/unzip.c
+++ b/contrib/minizip/unzip.c
@@ -1,1595 +1,1598 @@
1/* unzip.c -- IO for uncompress .zip files using zlib 1/* unzip.c -- IO for uncompress .zip files using zlib
2 Version 1.01d, September 22th, 2004 2 Version 1.01e, February 12th, 2005
3 3
4 Copyright (C) 1998-2004 Gilles Vollant 4 Copyright (C) 1998-2005 Gilles Vollant
5 5
6 Read unzip.h for more info 6 Read unzip.h for more info
7*/ 7*/
8 8
9/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of 9/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
10compatibility with older software. The following is from the original crypt.c. Code 10compatibility with older software. The following is from the original crypt.c. Code
11woven in by Terry Thorsen 1/2003. 11woven in by Terry Thorsen 1/2003.
12*/ 12*/
13/* 13/*
14 Copyright (c) 1990-2000 Info-ZIP. All rights reserved. 14 Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
15 15
16 See the accompanying file LICENSE, version 2000-Apr-09 or later 16 See the accompanying file LICENSE, version 2000-Apr-09 or later
17 (the contents of which are also included in zip.h) for terms of use. 17 (the contents of which are also included in zip.h) for terms of use.
18 If, for some reason, all these files are missing, the Info-ZIP license 18 If, for some reason, all these files are missing, the Info-ZIP license
19 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html 19 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
20*/ 20*/
21/* 21/*
22 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h] 22 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
23 23
24 The encryption/decryption parts of this source code (as opposed to the 24 The encryption/decryption parts of this source code (as opposed to the
25 non-echoing password parts) were originally written in Europe. The 25 non-echoing password parts) were originally written in Europe. The
26 whole source package can be freely distributed, including from the USA. 26 whole source package can be freely distributed, including from the USA.
27 (Prior to January 2000, re-export from the US was a violation of US law.) 27 (Prior to January 2000, re-export from the US was a violation of US law.)
28 */ 28 */
29 29
30/* 30/*
31 This encryption code is a direct transcription of the algorithm from 31 This encryption code is a direct transcription of the algorithm from
32 Roger Schlafly, described by Phil Katz in the file appnote.txt. This 32 Roger Schlafly, described by Phil Katz in the file appnote.txt. This
33 file (appnote.txt) is distributed with the PKZIP program (even in the 33 file (appnote.txt) is distributed with the PKZIP program (even in the
34 version without encryption capabilities). 34 version without encryption capabilities).
35 */ 35 */
36 36
37 37
38#include <stdio.h> 38#include <stdio.h>
39#include <stdlib.h> 39#include <stdlib.h>
40#include <string.h> 40#include <string.h>
41#include "zlib.h" 41#include "zlib.h"
42#include "unzip.h" 42#include "unzip.h"
43 43
44#ifdef STDC 44#ifdef STDC
45# include <stddef.h> 45# include <stddef.h>
46# include <string.h> 46# include <string.h>
47# include <stdlib.h> 47# include <stdlib.h>
48#endif 48#endif
49#ifdef NO_ERRNO_H 49#ifdef NO_ERRNO_H
50 extern int errno; 50 extern int errno;
51#else 51#else
52# include <errno.h> 52# include <errno.h>
53#endif 53#endif
54 54
55 55
56#ifndef local 56#ifndef local
57# define local static 57# define local static
58#endif 58#endif
59/* compile with -Dlocal if your debugger can't find static symbols */ 59/* compile with -Dlocal if your debugger can't find static symbols */
60 60
61 61
62#ifndef CASESENSITIVITYDEFAULT_NO 62#ifndef CASESENSITIVITYDEFAULT_NO
63# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) 63# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
64# define CASESENSITIVITYDEFAULT_NO 64# define CASESENSITIVITYDEFAULT_NO
65# endif 65# endif
66#endif 66#endif
67 67
68 68
69#ifndef UNZ_BUFSIZE 69#ifndef UNZ_BUFSIZE
70#define UNZ_BUFSIZE (16384) 70#define UNZ_BUFSIZE (16384)
71#endif 71#endif
72 72
73#ifndef UNZ_MAXFILENAMEINZIP 73#ifndef UNZ_MAXFILENAMEINZIP
74#define UNZ_MAXFILENAMEINZIP (256) 74#define UNZ_MAXFILENAMEINZIP (256)
75#endif 75#endif
76 76
77#ifndef ALLOC 77#ifndef ALLOC
78# define ALLOC(size) (malloc(size)) 78# define ALLOC(size) (malloc(size))
79#endif 79#endif
80#ifndef TRYFREE 80#ifndef TRYFREE
81# define TRYFREE(p) {if (p) free(p);} 81# define TRYFREE(p) {if (p) free(p);}
82#endif 82#endif
83 83
84#define SIZECENTRALDIRITEM (0x2e) 84#define SIZECENTRALDIRITEM (0x2e)
85#define SIZEZIPLOCALHEADER (0x1e) 85#define SIZEZIPLOCALHEADER (0x1e)
86 86
87 87
88 88
89 89
90const char unz_copyright[] = 90const char unz_copyright[] =
91 " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; 91 " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
92 92
93/* unz_file_info_interntal contain internal info about a file in zipfile*/ 93/* unz_file_info_interntal contain internal info about a file in zipfile*/
94typedef struct unz_file_info_internal_s 94typedef struct unz_file_info_internal_s
95{ 95{
96 uLong offset_curfile;/* relative offset of local header 4 bytes */ 96 uLong offset_curfile;/* relative offset of local header 4 bytes */
97} unz_file_info_internal; 97} unz_file_info_internal;
98 98
99 99
100/* file_in_zip_read_info_s contain internal information about a file in zipfile, 100/* file_in_zip_read_info_s contain internal information about a file in zipfile,
101 when reading and decompress it */ 101 when reading and decompress it */
102typedef struct 102typedef struct
103{ 103{
104 char *read_buffer; /* internal buffer for compressed data */ 104 char *read_buffer; /* internal buffer for compressed data */
105 z_stream stream; /* zLib stream structure for inflate */ 105 z_stream stream; /* zLib stream structure for inflate */
106 106
107 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/ 107 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
108 uLong stream_initialised; /* flag set if stream structure is initialised*/ 108 uLong stream_initialised; /* flag set if stream structure is initialised*/
109 109
110 uLong offset_local_extrafield;/* offset of the local extra field */ 110 uLong offset_local_extrafield;/* offset of the local extra field */
111 uInt size_local_extrafield;/* size of the local extra field */ 111 uInt size_local_extrafield;/* size of the local extra field */
112 uLong pos_local_extrafield; /* position in the local extra field in read*/ 112 uLong pos_local_extrafield; /* position in the local extra field in read*/
113 113
114 uLong crc32; /* crc32 of all data uncompressed */ 114 uLong crc32; /* crc32 of all data uncompressed */
115 uLong crc32_wait; /* crc32 we must obtain after decompress all */ 115 uLong crc32_wait; /* crc32 we must obtain after decompress all */
116 uLong rest_read_compressed; /* number of byte to be decompressed */ 116 uLong rest_read_compressed; /* number of byte to be decompressed */
117 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/ 117 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
118 zlib_filefunc_def z_filefunc; 118 zlib_filefunc_def z_filefunc;
119 voidpf filestream; /* io structore of the zipfile */ 119 voidpf filestream; /* io structore of the zipfile */
120 uLong compression_method; /* compression method (0==store) */ 120 uLong compression_method; /* compression method (0==store) */
121 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 121 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
122 int raw; 122 int raw;
123} file_in_zip_read_info_s; 123} file_in_zip_read_info_s;
124 124
125 125
126/* unz_s contain internal information about the zipfile 126/* unz_s contain internal information about the zipfile
127*/ 127*/
128typedef struct 128typedef struct
129{ 129{
130 zlib_filefunc_def z_filefunc; 130 zlib_filefunc_def z_filefunc;
131 voidpf filestream; /* io structore of the zipfile */ 131 voidpf filestream; /* io structore of the zipfile */
132 unz_global_info gi; /* public global information */ 132 unz_global_info gi; /* public global information */
133 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 133 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
134 uLong num_file; /* number of the current file in the zipfile*/ 134 uLong num_file; /* number of the current file in the zipfile*/
135 uLong pos_in_central_dir; /* pos of the current file in the central dir*/ 135 uLong pos_in_central_dir; /* pos of the current file in the central dir*/
136 uLong current_file_ok; /* flag about the usability of the current file*/ 136 uLong current_file_ok; /* flag about the usability of the current file*/
137 uLong central_pos; /* position of the beginning of the central dir*/ 137 uLong central_pos; /* position of the beginning of the central dir*/
138 138
139 uLong size_central_dir; /* size of the central directory */ 139 uLong size_central_dir; /* size of the central directory */
140 uLong offset_central_dir; /* offset of start of central directory with 140 uLong offset_central_dir; /* offset of start of central directory with
141 respect to the starting disk number */ 141 respect to the starting disk number */
142 142
143 unz_file_info cur_file_info; /* public info about the current file in zip*/ 143 unz_file_info cur_file_info; /* public info about the current file in zip*/
144 unz_file_info_internal cur_file_info_internal; /* private info about it*/ 144 unz_file_info_internal cur_file_info_internal; /* private info about it*/
145 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current 145 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
146 file if we are decompressing it */ 146 file if we are decompressing it */
147 int encrypted; 147 int encrypted;
148# ifndef NOUNCRYPT 148# ifndef NOUNCRYPT
149 unsigned long keys[3]; /* keys defining the pseudo-random sequence */ 149 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
150 const unsigned long* pcrc_32_tab; 150 const unsigned long* pcrc_32_tab;
151# endif 151# endif
152} unz_s; 152} unz_s;
153 153
154 154
155#ifndef NOUNCRYPT 155#ifndef NOUNCRYPT
156#include "crypt.h" 156#include "crypt.h"
157#endif 157#endif
158 158
159/* =========================================================================== 159/* ===========================================================================
160 Read a byte from a gz_stream; update next_in and avail_in. Return EOF 160 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
161 for end of file. 161 for end of file.
162 IN assertion: the stream s has been sucessfully opened for reading. 162 IN assertion: the stream s has been sucessfully opened for reading.
163*/ 163*/
164 164
165 165
166local int unzlocal_getByte OF(( 166local int unzlocal_getByte OF((
167 const zlib_filefunc_def* pzlib_filefunc_def, 167 const zlib_filefunc_def* pzlib_filefunc_def,
168 voidpf filestream, 168 voidpf filestream,
169 int *pi)); 169 int *pi));
170 170
171local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi) 171local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
172 const zlib_filefunc_def* pzlib_filefunc_def; 172 const zlib_filefunc_def* pzlib_filefunc_def;
173 voidpf filestream; 173 voidpf filestream;
174 int *pi; 174 int *pi;
175{ 175{
176 unsigned char c; 176 unsigned char c;
177 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); 177 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
178 if (err==1) 178 if (err==1)
179 { 179 {
180 *pi = (int)c; 180 *pi = (int)c;
181 return UNZ_OK; 181 return UNZ_OK;
182 } 182 }
183 else 183 else
184 { 184 {
185 if (ZERROR(*pzlib_filefunc_def,filestream)) 185 if (ZERROR(*pzlib_filefunc_def,filestream))
186 return UNZ_ERRNO; 186 return UNZ_ERRNO;
187 else 187 else
188 return UNZ_EOF; 188 return UNZ_EOF;
189 } 189 }
190} 190}
191 191
192 192
193/* =========================================================================== 193/* ===========================================================================
194 Reads a long in LSB order from the given gz_stream. Sets 194 Reads a long in LSB order from the given gz_stream. Sets
195*/ 195*/
196local int unzlocal_getShort OF(( 196local int unzlocal_getShort OF((
197 const zlib_filefunc_def* pzlib_filefunc_def, 197 const zlib_filefunc_def* pzlib_filefunc_def,
198 voidpf filestream, 198 voidpf filestream,
199 uLong *pX)); 199 uLong *pX));
200 200
201local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX) 201local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
202 const zlib_filefunc_def* pzlib_filefunc_def; 202 const zlib_filefunc_def* pzlib_filefunc_def;
203 voidpf filestream; 203 voidpf filestream;
204 uLong *pX; 204 uLong *pX;
205{ 205{
206 uLong x ; 206 uLong x ;
207 int i; 207 int i;
208 int err; 208 int err;
209 209
210 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 210 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
211 x = (uLong)i; 211 x = (uLong)i;
212 212
213 if (err==UNZ_OK) 213 if (err==UNZ_OK)
214 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 214 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
215 x += ((uLong)i)<<8; 215 x += ((uLong)i)<<8;
216 216
217 if (err==UNZ_OK) 217 if (err==UNZ_OK)
218 *pX = x; 218 *pX = x;
219 else 219 else
220 *pX = 0; 220 *pX = 0;
221 return err; 221 return err;
222} 222}
223 223
224local int unzlocal_getLong OF(( 224local int unzlocal_getLong OF((
225 const zlib_filefunc_def* pzlib_filefunc_def, 225 const zlib_filefunc_def* pzlib_filefunc_def,
226 voidpf filestream, 226 voidpf filestream,
227 uLong *pX)); 227 uLong *pX));
228 228
229local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX) 229local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
230 const zlib_filefunc_def* pzlib_filefunc_def; 230 const zlib_filefunc_def* pzlib_filefunc_def;
231 voidpf filestream; 231 voidpf filestream;
232 uLong *pX; 232 uLong *pX;
233{ 233{
234 uLong x ; 234 uLong x ;
235 int i; 235 int i;
236 int err; 236 int err;
237 237
238 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 238 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
239 x = (uLong)i; 239 x = (uLong)i;
240 240
241 if (err==UNZ_OK) 241 if (err==UNZ_OK)
242 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 242 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
243 x += ((uLong)i)<<8; 243 x += ((uLong)i)<<8;
244 244
245 if (err==UNZ_OK) 245 if (err==UNZ_OK)
246 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 246 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
247 x += ((uLong)i)<<16; 247 x += ((uLong)i)<<16;
248 248
249 if (err==UNZ_OK) 249 if (err==UNZ_OK)
250 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 250 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
251 x += ((uLong)i)<<24; 251 x += ((uLong)i)<<24;
252 252
253 if (err==UNZ_OK) 253 if (err==UNZ_OK)
254 *pX = x; 254 *pX = x;
255 else 255 else
256 *pX = 0; 256 *pX = 0;
257 return err; 257 return err;
258} 258}
259 259
260 260
261/* My own strcmpi / strcasecmp */ 261/* My own strcmpi / strcasecmp */
262local int strcmpcasenosensitive_internal (fileName1,fileName2) 262local int strcmpcasenosensitive_internal (fileName1,fileName2)
263 const char* fileName1; 263 const char* fileName1;
264 const char* fileName2; 264 const char* fileName2;
265{ 265{
266 for (;;) 266 for (;;)
267 { 267 {
268 char c1=*(fileName1++); 268 char c1=*(fileName1++);
269 char c2=*(fileName2++); 269 char c2=*(fileName2++);
270 if ((c1>='a') && (c1<='z')) 270 if ((c1>='a') && (c1<='z'))
271 c1 -= 0x20; 271 c1 -= 0x20;
272 if ((c2>='a') && (c2<='z')) 272 if ((c2>='a') && (c2<='z'))
273 c2 -= 0x20; 273 c2 -= 0x20;
274 if (c1=='\0') 274 if (c1=='\0')
275 return ((c2=='\0') ? 0 : -1); 275 return ((c2=='\0') ? 0 : -1);
276 if (c2=='\0') 276 if (c2=='\0')
277 return 1; 277 return 1;
278 if (c1<c2) 278 if (c1<c2)
279 return -1; 279 return -1;
280 if (c1>c2) 280 if (c1>c2)
281 return 1; 281 return 1;
282 } 282 }
283} 283}
284 284
285 285
286#ifdef CASESENSITIVITYDEFAULT_NO 286#ifdef CASESENSITIVITYDEFAULT_NO
287#define CASESENSITIVITYDEFAULTVALUE 2 287#define CASESENSITIVITYDEFAULTVALUE 2
288#else 288#else
289#define CASESENSITIVITYDEFAULTVALUE 1 289#define CASESENSITIVITYDEFAULTVALUE 1
290#endif 290#endif
291 291
292#ifndef STRCMPCASENOSENTIVEFUNCTION 292#ifndef STRCMPCASENOSENTIVEFUNCTION
293#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal 293#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
294#endif 294#endif
295 295
296/* 296/*
297 Compare two filename (fileName1,fileName2). 297 Compare two filename (fileName1,fileName2).
298 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) 298 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
299 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi 299 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
300 or strcasecmp) 300 or strcasecmp)
301 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system 301 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
302 (like 1 on Unix, 2 on Windows) 302 (like 1 on Unix, 2 on Windows)
303 303
304*/ 304*/
305extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity) 305extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
306 const char* fileName1; 306 const char* fileName1;
307 const char* fileName2; 307 const char* fileName2;
308 int iCaseSensitivity; 308 int iCaseSensitivity;
309{ 309{
310 if (iCaseSensitivity==0) 310 if (iCaseSensitivity==0)
311 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE; 311 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
312 312
313 if (iCaseSensitivity==1) 313 if (iCaseSensitivity==1)
314 return strcmp(fileName1,fileName2); 314 return strcmp(fileName1,fileName2);
315 315
316 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2); 316 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
317} 317}
318 318
319#ifndef BUFREADCOMMENT 319#ifndef BUFREADCOMMENT
320#define BUFREADCOMMENT (0x400) 320#define BUFREADCOMMENT (0x400)
321#endif 321#endif
322 322
323/* 323/*
324 Locate the Central directory of a zipfile (at the end, just before 324 Locate the Central directory of a zipfile (at the end, just before
325 the global comment) 325 the global comment)
326*/ 326*/
327local uLong unzlocal_SearchCentralDir OF(( 327local uLong unzlocal_SearchCentralDir OF((
328 const zlib_filefunc_def* pzlib_filefunc_def, 328 const zlib_filefunc_def* pzlib_filefunc_def,
329 voidpf filestream)); 329 voidpf filestream));
330 330
331local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream) 331local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
332 const zlib_filefunc_def* pzlib_filefunc_def; 332 const zlib_filefunc_def* pzlib_filefunc_def;
333 voidpf filestream; 333 voidpf filestream;
334{ 334{
335 unsigned char* buf; 335 unsigned char* buf;
336 uLong uSizeFile; 336 uLong uSizeFile;
337 uLong uBackRead; 337 uLong uBackRead;
338 uLong uMaxBack=0xffff; /* maximum size of global comment */ 338 uLong uMaxBack=0xffff; /* maximum size of global comment */
339 uLong uPosFound=0; 339 uLong uPosFound=0;
340 340
341 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) 341 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
342 return 0; 342 return 0;
343 343
344 344
345 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); 345 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
346 346
347 if (uMaxBack>uSizeFile) 347 if (uMaxBack>uSizeFile)
348 uMaxBack = uSizeFile; 348 uMaxBack = uSizeFile;
349 349
350 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); 350 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
351 if (buf==NULL) 351 if (buf==NULL)
352 return 0; 352 return 0;
353 353
354 uBackRead = 4; 354 uBackRead = 4;
355 while (uBackRead<uMaxBack) 355 while (uBackRead<uMaxBack)
356 { 356 {
357 uLong uReadSize,uReadPos ; 357 uLong uReadSize,uReadPos ;
358 int i; 358 int i;
359 if (uBackRead+BUFREADCOMMENT>uMaxBack) 359 if (uBackRead+BUFREADCOMMENT>uMaxBack)
360 uBackRead = uMaxBack; 360 uBackRead = uMaxBack;
361 else 361 else
362 uBackRead+=BUFREADCOMMENT; 362 uBackRead+=BUFREADCOMMENT;
363 uReadPos = uSizeFile-uBackRead ; 363 uReadPos = uSizeFile-uBackRead ;
364 364
365 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 365 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
366 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); 366 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
367 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) 367 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
368 break; 368 break;
369 369
370 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) 370 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
371 break; 371 break;
372 372
373 for (i=(int)uReadSize-3; (i--)>0;) 373 for (i=(int)uReadSize-3; (i--)>0;)
374 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 374 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
375 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) 375 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
376 { 376 {
377 uPosFound = uReadPos+i; 377 uPosFound = uReadPos+i;
378 break; 378 break;
379 } 379 }
380 380
381 if (uPosFound!=0) 381 if (uPosFound!=0)
382 break; 382 break;
383 } 383 }
384 TRYFREE(buf); 384 TRYFREE(buf);
385 return uPosFound; 385 return uPosFound;
386} 386}
387 387
388/* 388/*
389 Open a Zip file. path contain the full pathname (by example, 389 Open a Zip file. path contain the full pathname (by example,
390 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer 390 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
391 "zlib/zlib114.zip". 391 "zlib/zlib114.zip".
392 If the zipfile cannot be opened (file doesn't exist or in not valid), the 392 If the zipfile cannot be opened (file doesn't exist or in not valid), the
393 return value is NULL. 393 return value is NULL.
394 Else, the return value is a unzFile Handle, usable with other function 394 Else, the return value is a unzFile Handle, usable with other function
395 of this unzip package. 395 of this unzip package.
396*/ 396*/
397extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def) 397extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
398 const char *path; 398 const char *path;
399 zlib_filefunc_def* pzlib_filefunc_def; 399 zlib_filefunc_def* pzlib_filefunc_def;
400{ 400{
401 unz_s us; 401 unz_s us;
402 unz_s *s; 402 unz_s *s;
403 uLong central_pos,uL; 403 uLong central_pos,uL;
404 404
405 uLong number_disk; /* number of the current dist, used for 405 uLong number_disk; /* number of the current dist, used for
406 spaning ZIP, unsupported, always 0*/ 406 spaning ZIP, unsupported, always 0*/
407 uLong number_disk_with_CD; /* number the the disk with central dir, used 407 uLong number_disk_with_CD; /* number the the disk with central dir, used
408 for spaning ZIP, unsupported, always 0*/ 408 for spaning ZIP, unsupported, always 0*/
409 uLong number_entry_CD; /* total number of entries in 409 uLong number_entry_CD; /* total number of entries in
410 the central dir 410 the central dir
411 (same than number_entry on nospan) */ 411 (same than number_entry on nospan) */
412 412
413 int err=UNZ_OK; 413 int err=UNZ_OK;
414 414
415 if (unz_copyright[0]!=' ') 415 if (unz_copyright[0]!=' ')
416 return NULL; 416 return NULL;
417 417
418 if (pzlib_filefunc_def==NULL) 418 if (pzlib_filefunc_def==NULL)
419 fill_fopen_filefunc(&us.z_filefunc); 419 fill_fopen_filefunc(&us.z_filefunc);
420 else 420 else
421 us.z_filefunc = *pzlib_filefunc_def; 421 us.z_filefunc = *pzlib_filefunc_def;
422 422
423 us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque, 423 us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
424 path, 424 path,
425 ZLIB_FILEFUNC_MODE_READ | 425 ZLIB_FILEFUNC_MODE_READ |
426 ZLIB_FILEFUNC_MODE_EXISTING); 426 ZLIB_FILEFUNC_MODE_EXISTING);
427 if (us.filestream==NULL) 427 if (us.filestream==NULL)
428 return NULL; 428 return NULL;
429 429
430 central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream); 430 central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
431 if (central_pos==0) 431 if (central_pos==0)
432 err=UNZ_ERRNO; 432 err=UNZ_ERRNO;
433 433
434 if (ZSEEK(us.z_filefunc, us.filestream, 434 if (ZSEEK(us.z_filefunc, us.filestream,
435 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) 435 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
436 err=UNZ_ERRNO; 436 err=UNZ_ERRNO;
437 437
438 /* the signature, already checked */ 438 /* the signature, already checked */
439 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) 439 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
440 err=UNZ_ERRNO; 440 err=UNZ_ERRNO;
441 441
442 /* number of this disk */ 442 /* number of this disk */
443 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK) 443 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
444 err=UNZ_ERRNO; 444 err=UNZ_ERRNO;
445 445
446 /* number of the disk with the start of the central directory */ 446 /* number of the disk with the start of the central directory */
447 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK) 447 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
448 err=UNZ_ERRNO; 448 err=UNZ_ERRNO;
449 449
450 /* total number of entries in the central dir on this disk */ 450 /* total number of entries in the central dir on this disk */
451 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK) 451 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
452 err=UNZ_ERRNO; 452 err=UNZ_ERRNO;
453 453
454 /* total number of entries in the central dir */ 454 /* total number of entries in the central dir */
455 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK) 455 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
456 err=UNZ_ERRNO; 456 err=UNZ_ERRNO;
457 457
458 if ((number_entry_CD!=us.gi.number_entry) || 458 if ((number_entry_CD!=us.gi.number_entry) ||
459 (number_disk_with_CD!=0) || 459 (number_disk_with_CD!=0) ||
460 (number_disk!=0)) 460 (number_disk!=0))
461 err=UNZ_BADZIPFILE; 461 err=UNZ_BADZIPFILE;
462 462
463 /* size of the central directory */ 463 /* size of the central directory */
464 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK) 464 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
465 err=UNZ_ERRNO; 465 err=UNZ_ERRNO;
466 466
467 /* offset of start of central directory with respect to the 467 /* offset of start of central directory with respect to the
468 starting disk number */ 468 starting disk number */
469 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK) 469 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
470 err=UNZ_ERRNO; 470 err=UNZ_ERRNO;
471 471
472 /* zipfile comment length */ 472 /* zipfile comment length */
473 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK) 473 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
474 err=UNZ_ERRNO; 474 err=UNZ_ERRNO;
475 475
476 if ((central_pos<us.offset_central_dir+us.size_central_dir) && 476 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
477 (err==UNZ_OK)) 477 (err==UNZ_OK))
478 err=UNZ_BADZIPFILE; 478 err=UNZ_BADZIPFILE;
479 479
480 if (err!=UNZ_OK) 480 if (err!=UNZ_OK)
481 { 481 {
482 ZCLOSE(us.z_filefunc, us.filestream); 482 ZCLOSE(us.z_filefunc, us.filestream);
483 return NULL; 483 return NULL;
484 } 484 }
485 485
486 us.byte_before_the_zipfile = central_pos - 486 us.byte_before_the_zipfile = central_pos -
487 (us.offset_central_dir+us.size_central_dir); 487 (us.offset_central_dir+us.size_central_dir);
488 us.central_pos = central_pos; 488 us.central_pos = central_pos;
489 us.pfile_in_zip_read = NULL; 489 us.pfile_in_zip_read = NULL;
490 us.encrypted = 0; 490 us.encrypted = 0;
491 491
492 492
493 s=(unz_s*)ALLOC(sizeof(unz_s)); 493 s=(unz_s*)ALLOC(sizeof(unz_s));
494 *s=us; 494 *s=us;
495 unzGoToFirstFile((unzFile)s); 495 unzGoToFirstFile((unzFile)s);
496 return (unzFile)s; 496 return (unzFile)s;
497} 497}
498 498
499 499
500extern unzFile ZEXPORT unzOpen (path) 500extern unzFile ZEXPORT unzOpen (path)
501 const char *path; 501 const char *path;
502{ 502{
503 return unzOpen2(path, NULL); 503 return unzOpen2(path, NULL);
504} 504}
505 505
506/* 506/*
507 Close a ZipFile opened with unzipOpen. 507 Close a ZipFile opened with unzipOpen.
508 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later), 508 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
509 these files MUST be closed with unzipCloseCurrentFile before call unzipClose. 509 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
510 return UNZ_OK if there is no problem. */ 510 return UNZ_OK if there is no problem. */
511extern int ZEXPORT unzClose (file) 511extern int ZEXPORT unzClose (file)
512 unzFile file; 512 unzFile file;
513{ 513{
514 unz_s* s; 514 unz_s* s;
515 if (file==NULL) 515 if (file==NULL)
516 return UNZ_PARAMERROR; 516 return UNZ_PARAMERROR;
517 s=(unz_s*)file; 517 s=(unz_s*)file;
518 518
519 if (s->pfile_in_zip_read!=NULL) 519 if (s->pfile_in_zip_read!=NULL)
520 unzCloseCurrentFile(file); 520 unzCloseCurrentFile(file);
521 521
522 ZCLOSE(s->z_filefunc, s->filestream); 522 ZCLOSE(s->z_filefunc, s->filestream);
523 TRYFREE(s); 523 TRYFREE(s);
524 return UNZ_OK; 524 return UNZ_OK;
525} 525}
526 526
527 527
528/* 528/*
529 Write info about the ZipFile in the *pglobal_info structure. 529 Write info about the ZipFile in the *pglobal_info structure.
530 No preparation of the structure is needed 530 No preparation of the structure is needed
531 return UNZ_OK if there is no problem. */ 531 return UNZ_OK if there is no problem. */
532extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info) 532extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
533 unzFile file; 533 unzFile file;
534 unz_global_info *pglobal_info; 534 unz_global_info *pglobal_info;
535{ 535{
536 unz_s* s; 536 unz_s* s;
537 if (file==NULL) 537 if (file==NULL)
538 return UNZ_PARAMERROR; 538 return UNZ_PARAMERROR;
539 s=(unz_s*)file; 539 s=(unz_s*)file;
540 *pglobal_info=s->gi; 540 *pglobal_info=s->gi;
541 return UNZ_OK; 541 return UNZ_OK;
542} 542}
543 543
544 544
545/* 545/*
546 Translate date/time from Dos format to tm_unz (readable more easilty) 546 Translate date/time from Dos format to tm_unz (readable more easilty)
547*/ 547*/
548local void unzlocal_DosDateToTmuDate (ulDosDate, ptm) 548local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
549 uLong ulDosDate; 549 uLong ulDosDate;
550 tm_unz* ptm; 550 tm_unz* ptm;
551{ 551{
552 uLong uDate; 552 uLong uDate;
553 uDate = (uLong)(ulDosDate>>16); 553 uDate = (uLong)(ulDosDate>>16);
554 ptm->tm_mday = (uInt)(uDate&0x1f) ; 554 ptm->tm_mday = (uInt)(uDate&0x1f) ;
555 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; 555 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
556 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; 556 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
557 557
558 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); 558 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
559 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; 559 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
560 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; 560 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
561} 561}
562 562
563/* 563/*
564 Get Info about the current file in the zipfile, with internal only info 564 Get Info about the current file in the zipfile, with internal only info
565*/ 565*/
566local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file, 566local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
567 unz_file_info *pfile_info, 567 unz_file_info *pfile_info,
568 unz_file_info_internal 568 unz_file_info_internal
569 *pfile_info_internal, 569 *pfile_info_internal,
570 char *szFileName, 570 char *szFileName,
571 uLong fileNameBufferSize, 571 uLong fileNameBufferSize,
572 void *extraField, 572 void *extraField,
573 uLong extraFieldBufferSize, 573 uLong extraFieldBufferSize,
574 char *szComment, 574 char *szComment,
575 uLong commentBufferSize)); 575 uLong commentBufferSize));
576 576
577local int unzlocal_GetCurrentFileInfoInternal (file, 577local int unzlocal_GetCurrentFileInfoInternal (file,
578 pfile_info, 578 pfile_info,
579 pfile_info_internal, 579 pfile_info_internal,
580 szFileName, fileNameBufferSize, 580 szFileName, fileNameBufferSize,
581 extraField, extraFieldBufferSize, 581 extraField, extraFieldBufferSize,
582 szComment, commentBufferSize) 582 szComment, commentBufferSize)
583 unzFile file; 583 unzFile file;
584 unz_file_info *pfile_info; 584 unz_file_info *pfile_info;
585 unz_file_info_internal *pfile_info_internal; 585 unz_file_info_internal *pfile_info_internal;
586 char *szFileName; 586 char *szFileName;
587 uLong fileNameBufferSize; 587 uLong fileNameBufferSize;
588 void *extraField; 588 void *extraField;
589 uLong extraFieldBufferSize; 589 uLong extraFieldBufferSize;
590 char *szComment; 590 char *szComment;
591 uLong commentBufferSize; 591 uLong commentBufferSize;
592{ 592{
593 unz_s* s; 593 unz_s* s;
594 unz_file_info file_info; 594 unz_file_info file_info;
595 unz_file_info_internal file_info_internal; 595 unz_file_info_internal file_info_internal;
596 int err=UNZ_OK; 596 int err=UNZ_OK;
597 uLong uMagic; 597 uLong uMagic;
598 long lSeek=0; 598 long lSeek=0;
599 599
600 if (file==NULL) 600 if (file==NULL)
601 return UNZ_PARAMERROR; 601 return UNZ_PARAMERROR;
602 s=(unz_s*)file; 602 s=(unz_s*)file;
603 if (ZSEEK(s->z_filefunc, s->filestream, 603 if (ZSEEK(s->z_filefunc, s->filestream,
604 s->pos_in_central_dir+s->byte_before_the_zipfile, 604 s->pos_in_central_dir+s->byte_before_the_zipfile,
605 ZLIB_FILEFUNC_SEEK_SET)!=0) 605 ZLIB_FILEFUNC_SEEK_SET)!=0)
606 err=UNZ_ERRNO; 606 err=UNZ_ERRNO;
607 607
608 608
609 /* we check the magic */ 609 /* we check the magic */
610 if (err==UNZ_OK) 610 if (err==UNZ_OK)
611 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) 611 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
612 err=UNZ_ERRNO; 612 err=UNZ_ERRNO;
613 else if (uMagic!=0x02014b50) 613 else if (uMagic!=0x02014b50)
614 err=UNZ_BADZIPFILE; 614 err=UNZ_BADZIPFILE;
615 615
616 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK) 616 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
617 err=UNZ_ERRNO; 617 err=UNZ_ERRNO;
618 618
619 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK) 619 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
620 err=UNZ_ERRNO; 620 err=UNZ_ERRNO;
621 621
622 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK) 622 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
623 err=UNZ_ERRNO; 623 err=UNZ_ERRNO;
624 624
625 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK) 625 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
626 err=UNZ_ERRNO; 626 err=UNZ_ERRNO;
627 627
628 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK) 628 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
629 err=UNZ_ERRNO; 629 err=UNZ_ERRNO;
630 630
631 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date); 631 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
632 632
633 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK) 633 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
634 err=UNZ_ERRNO; 634 err=UNZ_ERRNO;
635 635
636 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) 636 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
637 err=UNZ_ERRNO; 637 err=UNZ_ERRNO;
638 638
639 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) 639 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
640 err=UNZ_ERRNO; 640 err=UNZ_ERRNO;
641 641
642 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK) 642 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
643 err=UNZ_ERRNO; 643 err=UNZ_ERRNO;
644 644
645 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK) 645 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
646 err=UNZ_ERRNO; 646 err=UNZ_ERRNO;
647 647
648 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK) 648 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
649 err=UNZ_ERRNO; 649 err=UNZ_ERRNO;
650 650
651 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK) 651 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
652 err=UNZ_ERRNO; 652 err=UNZ_ERRNO;
653 653
654 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK) 654 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
655 err=UNZ_ERRNO; 655 err=UNZ_ERRNO;
656 656
657 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK) 657 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
658 err=UNZ_ERRNO; 658 err=UNZ_ERRNO;
659 659
660 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK) 660 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
661 err=UNZ_ERRNO; 661 err=UNZ_ERRNO;
662 662
663 lSeek+=file_info.size_filename; 663 lSeek+=file_info.size_filename;
664 if ((err==UNZ_OK) && (szFileName!=NULL)) 664 if ((err==UNZ_OK) && (szFileName!=NULL))
665 { 665 {
666 uLong uSizeRead ; 666 uLong uSizeRead ;
667 if (file_info.size_filename<fileNameBufferSize) 667 if (file_info.size_filename<fileNameBufferSize)
668 { 668 {
669 *(szFileName+file_info.size_filename)='\0'; 669 *(szFileName+file_info.size_filename)='\0';
670 uSizeRead = file_info.size_filename; 670 uSizeRead = file_info.size_filename;
671 } 671 }
672 else 672 else
673 uSizeRead = fileNameBufferSize; 673 uSizeRead = fileNameBufferSize;
674 674
675 if ((file_info.size_filename>0) && (fileNameBufferSize>0)) 675 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
676 if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead) 676 if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
677 err=UNZ_ERRNO; 677 err=UNZ_ERRNO;
678 lSeek -= uSizeRead; 678 lSeek -= uSizeRead;
679 } 679 }
680 680
681 681
682 if ((err==UNZ_OK) && (extraField!=NULL)) 682 if ((err==UNZ_OK) && (extraField!=NULL))
683 { 683 {
684 uLong uSizeRead ; 684 uLong uSizeRead ;
685 if (file_info.size_file_extra<extraFieldBufferSize) 685 if (file_info.size_file_extra<extraFieldBufferSize)
686 uSizeRead = file_info.size_file_extra; 686 uSizeRead = file_info.size_file_extra;
687 else 687 else
688 uSizeRead = extraFieldBufferSize; 688 uSizeRead = extraFieldBufferSize;
689 689
690 if (lSeek!=0) 690 if (lSeek!=0)
691 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) 691 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
692 lSeek=0; 692 lSeek=0;
693 else 693 else
694 err=UNZ_ERRNO; 694 err=UNZ_ERRNO;
695 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) 695 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
696 if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead) 696 if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
697 err=UNZ_ERRNO; 697 err=UNZ_ERRNO;
698 lSeek += file_info.size_file_extra - uSizeRead; 698 lSeek += file_info.size_file_extra - uSizeRead;
699 } 699 }
700 else 700 else
701 lSeek+=file_info.size_file_extra; 701 lSeek+=file_info.size_file_extra;
702 702
703 703
704 if ((err==UNZ_OK) && (szComment!=NULL)) 704 if ((err==UNZ_OK) && (szComment!=NULL))
705 { 705 {
706 uLong uSizeRead ; 706 uLong uSizeRead ;
707 if (file_info.size_file_comment<commentBufferSize) 707 if (file_info.size_file_comment<commentBufferSize)
708 { 708 {
709 *(szComment+file_info.size_file_comment)='\0'; 709 *(szComment+file_info.size_file_comment)='\0';
710 uSizeRead = file_info.size_file_comment; 710 uSizeRead = file_info.size_file_comment;
711 } 711 }
712 else 712 else
713 uSizeRead = commentBufferSize; 713 uSizeRead = commentBufferSize;
714 714
715 if (lSeek!=0) 715 if (lSeek!=0)
716 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) 716 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
717 lSeek=0; 717 lSeek=0;
718 else 718 else
719 err=UNZ_ERRNO; 719 err=UNZ_ERRNO;
720 if ((file_info.size_file_comment>0) && (commentBufferSize>0)) 720 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
721 if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead) 721 if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
722 err=UNZ_ERRNO; 722 err=UNZ_ERRNO;
723 lSeek+=file_info.size_file_comment - uSizeRead; 723 lSeek+=file_info.size_file_comment - uSizeRead;
724 } 724 }
725 else 725 else
726 lSeek+=file_info.size_file_comment; 726 lSeek+=file_info.size_file_comment;
727 727
728 if ((err==UNZ_OK) && (pfile_info!=NULL)) 728 if ((err==UNZ_OK) && (pfile_info!=NULL))
729 *pfile_info=file_info; 729 *pfile_info=file_info;
730 730
731 if ((err==UNZ_OK) && (pfile_info_internal!=NULL)) 731 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
732 *pfile_info_internal=file_info_internal; 732 *pfile_info_internal=file_info_internal;
733 733
734 return err; 734 return err;
735} 735}
736 736
737 737
738 738
739/* 739/*
740 Write info about the ZipFile in the *pglobal_info structure. 740 Write info about the ZipFile in the *pglobal_info structure.
741 No preparation of the structure is needed 741 No preparation of the structure is needed
742 return UNZ_OK if there is no problem. 742 return UNZ_OK if there is no problem.
743*/ 743*/
744extern int ZEXPORT unzGetCurrentFileInfo (file, 744extern int ZEXPORT unzGetCurrentFileInfo (file,
745 pfile_info, 745 pfile_info,
746 szFileName, fileNameBufferSize, 746 szFileName, fileNameBufferSize,
747 extraField, extraFieldBufferSize, 747 extraField, extraFieldBufferSize,
748 szComment, commentBufferSize) 748 szComment, commentBufferSize)
749 unzFile file; 749 unzFile file;
750 unz_file_info *pfile_info; 750 unz_file_info *pfile_info;
751 char *szFileName; 751 char *szFileName;
752 uLong fileNameBufferSize; 752 uLong fileNameBufferSize;
753 void *extraField; 753 void *extraField;
754 uLong extraFieldBufferSize; 754 uLong extraFieldBufferSize;
755 char *szComment; 755 char *szComment;
756 uLong commentBufferSize; 756 uLong commentBufferSize;
757{ 757{
758 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL, 758 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
759 szFileName,fileNameBufferSize, 759 szFileName,fileNameBufferSize,
760 extraField,extraFieldBufferSize, 760 extraField,extraFieldBufferSize,
761 szComment,commentBufferSize); 761 szComment,commentBufferSize);
762} 762}
763 763
764/* 764/*
765 Set the current file of the zipfile to the first file. 765 Set the current file of the zipfile to the first file.
766 return UNZ_OK if there is no problem 766 return UNZ_OK if there is no problem
767*/ 767*/
768extern int ZEXPORT unzGoToFirstFile (file) 768extern int ZEXPORT unzGoToFirstFile (file)
769 unzFile file; 769 unzFile file;
770{ 770{
771 int err=UNZ_OK; 771 int err=UNZ_OK;
772 unz_s* s; 772 unz_s* s;
773 if (file==NULL) 773 if (file==NULL)
774 return UNZ_PARAMERROR; 774 return UNZ_PARAMERROR;
775 s=(unz_s*)file; 775 s=(unz_s*)file;
776 s->pos_in_central_dir=s->offset_central_dir; 776 s->pos_in_central_dir=s->offset_central_dir;
777 s->num_file=0; 777 s->num_file=0;
778 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 778 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
779 &s->cur_file_info_internal, 779 &s->cur_file_info_internal,
780 NULL,0,NULL,0,NULL,0); 780 NULL,0,NULL,0,NULL,0);
781 s->current_file_ok = (err == UNZ_OK); 781 s->current_file_ok = (err == UNZ_OK);
782 return err; 782 return err;
783} 783}
784 784
785/* 785/*
786 Set the current file of the zipfile to the next file. 786 Set the current file of the zipfile to the next file.
787 return UNZ_OK if there is no problem 787 return UNZ_OK if there is no problem
788 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. 788 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
789*/ 789*/
790extern int ZEXPORT unzGoToNextFile (file) 790extern int ZEXPORT unzGoToNextFile (file)
791 unzFile file; 791 unzFile file;
792{ 792{
793 unz_s* s; 793 unz_s* s;
794 int err; 794 int err;
795 795
796 if (file==NULL) 796 if (file==NULL)
797 return UNZ_PARAMERROR; 797 return UNZ_PARAMERROR;
798 s=(unz_s*)file; 798 s=(unz_s*)file;
799 if (!s->current_file_ok) 799 if (!s->current_file_ok)
800 return UNZ_END_OF_LIST_OF_FILE; 800 return UNZ_END_OF_LIST_OF_FILE;
801 if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */ 801 if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
802 if (s->num_file+1==s->gi.number_entry) 802 if (s->num_file+1==s->gi.number_entry)
803 return UNZ_END_OF_LIST_OF_FILE; 803 return UNZ_END_OF_LIST_OF_FILE;
804 804
805 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + 805 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
806 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ; 806 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
807 s->num_file++; 807 s->num_file++;
808 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 808 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
809 &s->cur_file_info_internal, 809 &s->cur_file_info_internal,
810 NULL,0,NULL,0,NULL,0); 810 NULL,0,NULL,0,NULL,0);
811 s->current_file_ok = (err == UNZ_OK); 811 s->current_file_ok = (err == UNZ_OK);
812 return err; 812 return err;
813} 813}
814 814
815 815
816/* 816/*
817 Try locate the file szFileName in the zipfile. 817 Try locate the file szFileName in the zipfile.
818 For the iCaseSensitivity signification, see unzipStringFileNameCompare 818 For the iCaseSensitivity signification, see unzipStringFileNameCompare
819 819
820 return value : 820 return value :
821 UNZ_OK if the file is found. It becomes the current file. 821 UNZ_OK if the file is found. It becomes the current file.
822 UNZ_END_OF_LIST_OF_FILE if the file is not found 822 UNZ_END_OF_LIST_OF_FILE if the file is not found
823*/ 823*/
824extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity) 824extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
825 unzFile file; 825 unzFile file;
826 const char *szFileName; 826 const char *szFileName;
827 int iCaseSensitivity; 827 int iCaseSensitivity;
828{ 828{
829 unz_s* s; 829 unz_s* s;
830 int err; 830 int err;
831 831
832 /* We remember the 'current' position in the file so that we can jump 832 /* We remember the 'current' position in the file so that we can jump
833 * back there if we fail. 833 * back there if we fail.
834 */ 834 */
835 unz_file_info cur_file_infoSaved; 835 unz_file_info cur_file_infoSaved;
836 unz_file_info_internal cur_file_info_internalSaved; 836 unz_file_info_internal cur_file_info_internalSaved;
837 uLong num_fileSaved; 837 uLong num_fileSaved;
838 uLong pos_in_central_dirSaved; 838 uLong pos_in_central_dirSaved;
839 839
840 840
841 if (file==NULL) 841 if (file==NULL)
842 return UNZ_PARAMERROR; 842 return UNZ_PARAMERROR;
843 843
844 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) 844 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
845 return UNZ_PARAMERROR; 845 return UNZ_PARAMERROR;
846 846
847 s=(unz_s*)file; 847 s=(unz_s*)file;
848 if (!s->current_file_ok) 848 if (!s->current_file_ok)
849 return UNZ_END_OF_LIST_OF_FILE; 849 return UNZ_END_OF_LIST_OF_FILE;
850 850
851 /* Save the current state */ 851 /* Save the current state */
852 num_fileSaved = s->num_file; 852 num_fileSaved = s->num_file;
853 pos_in_central_dirSaved = s->pos_in_central_dir; 853 pos_in_central_dirSaved = s->pos_in_central_dir;
854 cur_file_infoSaved = s->cur_file_info; 854 cur_file_infoSaved = s->cur_file_info;
855 cur_file_info_internalSaved = s->cur_file_info_internal; 855 cur_file_info_internalSaved = s->cur_file_info_internal;
856 856
857 err = unzGoToFirstFile(file); 857 err = unzGoToFirstFile(file);
858 858
859 while (err == UNZ_OK) 859 while (err == UNZ_OK)
860 { 860 {
861 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; 861 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
862 err = unzGetCurrentFileInfo(file,NULL, 862 err = unzGetCurrentFileInfo(file,NULL,
863 szCurrentFileName,sizeof(szCurrentFileName)-1, 863 szCurrentFileName,sizeof(szCurrentFileName)-1,
864 NULL,0,NULL,0); 864 NULL,0,NULL,0);
865 if (err == UNZ_OK) 865 if (err == UNZ_OK)
866 { 866 {
867 if (unzStringFileNameCompare(szCurrentFileName, 867 if (unzStringFileNameCompare(szCurrentFileName,
868 szFileName,iCaseSensitivity)==0) 868 szFileName,iCaseSensitivity)==0)
869 return UNZ_OK; 869 return UNZ_OK;
870 err = unzGoToNextFile(file); 870 err = unzGoToNextFile(file);
871 } 871 }
872 } 872 }
873 873
874 /* We failed, so restore the state of the 'current file' to where we 874 /* We failed, so restore the state of the 'current file' to where we
875 * were. 875 * were.
876 */ 876 */
877 s->num_file = num_fileSaved ; 877 s->num_file = num_fileSaved ;
878 s->pos_in_central_dir = pos_in_central_dirSaved ; 878 s->pos_in_central_dir = pos_in_central_dirSaved ;
879 s->cur_file_info = cur_file_infoSaved; 879 s->cur_file_info = cur_file_infoSaved;
880 s->cur_file_info_internal = cur_file_info_internalSaved; 880 s->cur_file_info_internal = cur_file_info_internalSaved;
881 return err; 881 return err;
882} 882}
883 883
884 884
885/* 885/*
886/////////////////////////////////////////// 886///////////////////////////////////////////
887// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net) 887// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
888// I need random access 888// I need random access
889// 889//
890// Further optimization could be realized by adding an ability 890// Further optimization could be realized by adding an ability
891// to cache the directory in memory. The goal being a single 891// to cache the directory in memory. The goal being a single
892// comprehensive file read to put the file I need in a memory. 892// comprehensive file read to put the file I need in a memory.
893*/ 893*/
894 894
895/* 895/*
896typedef struct unz_file_pos_s 896typedef struct unz_file_pos_s
897{ 897{
898 uLong pos_in_zip_directory; // offset in file 898 uLong pos_in_zip_directory; // offset in file
899 uLong num_of_file; // # of file 899 uLong num_of_file; // # of file
900} unz_file_pos; 900} unz_file_pos;
901*/ 901*/
902 902
903extern int ZEXPORT unzGetFilePos(file, file_pos) 903extern int ZEXPORT unzGetFilePos(file, file_pos)
904 unzFile file; 904 unzFile file;
905 unz_file_pos* file_pos; 905 unz_file_pos* file_pos;
906{ 906{
907 unz_s* s; 907 unz_s* s;
908 908
909 if (file==NULL || file_pos==NULL) 909 if (file==NULL || file_pos==NULL)
910 return UNZ_PARAMERROR; 910 return UNZ_PARAMERROR;
911 s=(unz_s*)file; 911 s=(unz_s*)file;
912 if (!s->current_file_ok) 912 if (!s->current_file_ok)
913 return UNZ_END_OF_LIST_OF_FILE; 913 return UNZ_END_OF_LIST_OF_FILE;
914 914
915 file_pos->pos_in_zip_directory = s->pos_in_central_dir; 915 file_pos->pos_in_zip_directory = s->pos_in_central_dir;
916 file_pos->num_of_file = s->num_file; 916 file_pos->num_of_file = s->num_file;
917 917
918 return UNZ_OK; 918 return UNZ_OK;
919} 919}
920 920
921extern int ZEXPORT unzGoToFilePos(file, file_pos) 921extern int ZEXPORT unzGoToFilePos(file, file_pos)
922 unzFile file; 922 unzFile file;
923 unz_file_pos* file_pos; 923 unz_file_pos* file_pos;
924{ 924{
925 unz_s* s; 925 unz_s* s;
926 int err; 926 int err;
927 927
928 if (file==NULL || file_pos==NULL) 928 if (file==NULL || file_pos==NULL)
929 return UNZ_PARAMERROR; 929 return UNZ_PARAMERROR;
930 s=(unz_s*)file; 930 s=(unz_s*)file;
931 931
932 /* jump to the right spot */ 932 /* jump to the right spot */
933 s->pos_in_central_dir = file_pos->pos_in_zip_directory; 933 s->pos_in_central_dir = file_pos->pos_in_zip_directory;
934 s->num_file = file_pos->num_of_file; 934 s->num_file = file_pos->num_of_file;
935 935
936 /* set the current file */ 936 /* set the current file */
937 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 937 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
938 &s->cur_file_info_internal, 938 &s->cur_file_info_internal,
939 NULL,0,NULL,0,NULL,0); 939 NULL,0,NULL,0,NULL,0);
940 /* return results */ 940 /* return results */
941 s->current_file_ok = (err == UNZ_OK); 941 s->current_file_ok = (err == UNZ_OK);
942 return err; 942 return err;
943} 943}
944 944
945/* 945/*
946// Unzip Helper Functions - should be here? 946// Unzip Helper Functions - should be here?
947/////////////////////////////////////////// 947///////////////////////////////////////////
948*/ 948*/
949 949
950/* 950/*
951 Read the local header of the current zipfile 951 Read the local header of the current zipfile
952 Check the coherency of the local header and info in the end of central 952 Check the coherency of the local header and info in the end of central
953 directory about this file 953 directory about this file
954 store in *piSizeVar the size of extra info in local header 954 store in *piSizeVar the size of extra info in local header
955 (filename and size of extra field data) 955 (filename and size of extra field data)
956*/ 956*/
957local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, 957local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
958 poffset_local_extrafield, 958 poffset_local_extrafield,
959 psize_local_extrafield) 959 psize_local_extrafield)
960 unz_s* s; 960 unz_s* s;
961 uInt* piSizeVar; 961 uInt* piSizeVar;
962 uLong *poffset_local_extrafield; 962 uLong *poffset_local_extrafield;
963 uInt *psize_local_extrafield; 963 uInt *psize_local_extrafield;
964{ 964{
965 uLong uMagic,uData,uFlags; 965 uLong uMagic,uData,uFlags;
966 uLong size_filename; 966 uLong size_filename;
967 uLong size_extra_field; 967 uLong size_extra_field;
968 int err=UNZ_OK; 968 int err=UNZ_OK;
969 969
970 *piSizeVar = 0; 970 *piSizeVar = 0;
971 *poffset_local_extrafield = 0; 971 *poffset_local_extrafield = 0;
972 *psize_local_extrafield = 0; 972 *psize_local_extrafield = 0;
973 973
974 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile + 974 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
975 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) 975 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
976 return UNZ_ERRNO; 976 return UNZ_ERRNO;
977 977
978 978
979 if (err==UNZ_OK) 979 if (err==UNZ_OK)
980 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) 980 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
981 err=UNZ_ERRNO; 981 err=UNZ_ERRNO;
982 else if (uMagic!=0x04034b50) 982 else if (uMagic!=0x04034b50)
983 err=UNZ_BADZIPFILE; 983 err=UNZ_BADZIPFILE;
984 984
985 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) 985 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
986 err=UNZ_ERRNO; 986 err=UNZ_ERRNO;
987/* 987/*
988 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) 988 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
989 err=UNZ_BADZIPFILE; 989 err=UNZ_BADZIPFILE;
990*/ 990*/
991 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK) 991 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
992 err=UNZ_ERRNO; 992 err=UNZ_ERRNO;
993 993
994 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) 994 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
995 err=UNZ_ERRNO; 995 err=UNZ_ERRNO;
996 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) 996 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
997 err=UNZ_BADZIPFILE; 997 err=UNZ_BADZIPFILE;
998 998
999 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && 999 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1000 (s->cur_file_info.compression_method!=Z_DEFLATED)) 1000 (s->cur_file_info.compression_method!=Z_DEFLATED))
1001 err=UNZ_BADZIPFILE; 1001 err=UNZ_BADZIPFILE;
1002 1002
1003 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */ 1003 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
1004 err=UNZ_ERRNO; 1004 err=UNZ_ERRNO;
1005 1005
1006 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */ 1006 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
1007 err=UNZ_ERRNO; 1007 err=UNZ_ERRNO;
1008 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && 1008 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
1009 ((uFlags & 8)==0)) 1009 ((uFlags & 8)==0))
1010 err=UNZ_BADZIPFILE; 1010 err=UNZ_BADZIPFILE;
1011 1011
1012 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */ 1012 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
1013 err=UNZ_ERRNO; 1013 err=UNZ_ERRNO;
1014 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && 1014 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
1015 ((uFlags & 8)==0)) 1015 ((uFlags & 8)==0))
1016 err=UNZ_BADZIPFILE; 1016 err=UNZ_BADZIPFILE;
1017 1017
1018 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */ 1018 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1019 err=UNZ_ERRNO; 1019 err=UNZ_ERRNO;
1020 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 1020 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
1021 ((uFlags & 8)==0)) 1021 ((uFlags & 8)==0))
1022 err=UNZ_BADZIPFILE; 1022 err=UNZ_BADZIPFILE;
1023 1023
1024 1024
1025 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK) 1025 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1026 err=UNZ_ERRNO; 1026 err=UNZ_ERRNO;
1027 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) 1027 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1028 err=UNZ_BADZIPFILE; 1028 err=UNZ_BADZIPFILE;
1029 1029
1030 *piSizeVar += (uInt)size_filename; 1030 *piSizeVar += (uInt)size_filename;
1031 1031
1032 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK) 1032 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1033 err=UNZ_ERRNO; 1033 err=UNZ_ERRNO;
1034 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + 1034 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1035 SIZEZIPLOCALHEADER + size_filename; 1035 SIZEZIPLOCALHEADER + size_filename;
1036 *psize_local_extrafield = (uInt)size_extra_field; 1036 *psize_local_extrafield = (uInt)size_extra_field;
1037 1037
1038 *piSizeVar += (uInt)size_extra_field; 1038 *piSizeVar += (uInt)size_extra_field;
1039 1039
1040 return err; 1040 return err;
1041} 1041}
1042 1042
1043/* 1043/*
1044 Open for reading data the current file in the zipfile. 1044 Open for reading data the current file in the zipfile.
1045 If there is no error and the file is opened, the return value is UNZ_OK. 1045 If there is no error and the file is opened, the return value is UNZ_OK.
1046*/ 1046*/
1047extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password) 1047extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
1048 unzFile file; 1048 unzFile file;
1049 int* method; 1049 int* method;
1050 int* level; 1050 int* level;
1051 int raw; 1051 int raw;
1052 const char* password; 1052 const char* password;
1053{ 1053{
1054 int err=UNZ_OK; 1054 int err=UNZ_OK;
1055 uInt iSizeVar; 1055 uInt iSizeVar;
1056 unz_s* s; 1056 unz_s* s;
1057 file_in_zip_read_info_s* pfile_in_zip_read_info; 1057 file_in_zip_read_info_s* pfile_in_zip_read_info;
1058 uLong offset_local_extrafield; /* offset of the local extra field */ 1058 uLong offset_local_extrafield; /* offset of the local extra field */
1059 uInt size_local_extrafield; /* size of the local extra field */ 1059 uInt size_local_extrafield; /* size of the local extra field */
1060# ifndef NOUNCRYPT 1060# ifndef NOUNCRYPT
1061 char source[12]; 1061 char source[12];
1062# else 1062# else
1063 if (password != NULL) 1063 if (password != NULL)
1064 return UNZ_PARAMERROR; 1064 return UNZ_PARAMERROR;
1065# endif 1065# endif
1066 1066
1067 if (file==NULL) 1067 if (file==NULL)
1068 return UNZ_PARAMERROR; 1068 return UNZ_PARAMERROR;
1069 s=(unz_s*)file; 1069 s=(unz_s*)file;
1070 if (!s->current_file_ok) 1070 if (!s->current_file_ok)
1071 return UNZ_PARAMERROR; 1071 return UNZ_PARAMERROR;
1072 1072
1073 if (s->pfile_in_zip_read != NULL) 1073 if (s->pfile_in_zip_read != NULL)
1074 unzCloseCurrentFile(file); 1074 unzCloseCurrentFile(file);
1075 1075
1076 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, 1076 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
1077 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) 1077 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1078 return UNZ_BADZIPFILE; 1078 return UNZ_BADZIPFILE;
1079 1079
1080 pfile_in_zip_read_info = (file_in_zip_read_info_s*) 1080 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
1081 ALLOC(sizeof(file_in_zip_read_info_s)); 1081 ALLOC(sizeof(file_in_zip_read_info_s));
1082 if (pfile_in_zip_read_info==NULL) 1082 if (pfile_in_zip_read_info==NULL)
1083 return UNZ_INTERNALERROR; 1083 return UNZ_INTERNALERROR;
1084 1084
1085 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); 1085 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1086 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; 1086 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1087 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; 1087 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1088 pfile_in_zip_read_info->pos_local_extrafield=0; 1088 pfile_in_zip_read_info->pos_local_extrafield=0;
1089 pfile_in_zip_read_info->raw=raw; 1089 pfile_in_zip_read_info->raw=raw;
1090 1090
1091 if (pfile_in_zip_read_info->read_buffer==NULL) 1091 if (pfile_in_zip_read_info->read_buffer==NULL)
1092 { 1092 {
1093 TRYFREE(pfile_in_zip_read_info); 1093 TRYFREE(pfile_in_zip_read_info);
1094 return UNZ_INTERNALERROR; 1094 return UNZ_INTERNALERROR;
1095 } 1095 }
1096 1096
1097 pfile_in_zip_read_info->stream_initialised=0; 1097 pfile_in_zip_read_info->stream_initialised=0;
1098 1098
1099 if (method!=NULL) 1099 if (method!=NULL)
1100 *method = (int)s->cur_file_info.compression_method; 1100 *method = (int)s->cur_file_info.compression_method;
1101 1101
1102 if (level!=NULL) 1102 if (level!=NULL)
1103 { 1103 {
1104 *level = 6; 1104 *level = 6;
1105 switch (s->cur_file_info.flag & 0x06) 1105 switch (s->cur_file_info.flag & 0x06)
1106 { 1106 {
1107 case 6 : *level = 1; break; 1107 case 6 : *level = 1; break;
1108 case 4 : *level = 2; break; 1108 case 4 : *level = 2; break;
1109 case 2 : *level = 9; break; 1109 case 2 : *level = 9; break;
1110 } 1110 }
1111 } 1111 }
1112 1112
1113 if ((s->cur_file_info.compression_method!=0) && 1113 if ((s->cur_file_info.compression_method!=0) &&
1114 (s->cur_file_info.compression_method!=Z_DEFLATED)) 1114 (s->cur_file_info.compression_method!=Z_DEFLATED))
1115 err=UNZ_BADZIPFILE; 1115 err=UNZ_BADZIPFILE;
1116 1116
1117 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; 1117 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1118 pfile_in_zip_read_info->crc32=0; 1118 pfile_in_zip_read_info->crc32=0;
1119 pfile_in_zip_read_info->compression_method = 1119 pfile_in_zip_read_info->compression_method =
1120 s->cur_file_info.compression_method; 1120 s->cur_file_info.compression_method;
1121 pfile_in_zip_read_info->filestream=s->filestream; 1121 pfile_in_zip_read_info->filestream=s->filestream;
1122 pfile_in_zip_read_info->z_filefunc=s->z_filefunc; 1122 pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1123 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; 1123 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1124 1124
1125 pfile_in_zip_read_info->stream.total_out = 0; 1125 pfile_in_zip_read_info->stream.total_out = 0;
1126 1126
1127 if ((s->cur_file_info.compression_method==Z_DEFLATED) && 1127 if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
1128 (!raw)) 1128 (!raw))
1129 { 1129 {
1130 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; 1130 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1131 pfile_in_zip_read_info->stream.zfree = (free_func)0; 1131 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1132 pfile_in_zip_read_info->stream.opaque = (voidpf)0; 1132 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1133 pfile_in_zip_read_info->stream.next_in = (voidpf)0; 1133 pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1134 pfile_in_zip_read_info->stream.avail_in = 0; 1134 pfile_in_zip_read_info->stream.avail_in = 0;
1135 1135
1136 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); 1136 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1137 if (err == Z_OK) 1137 if (err == Z_OK)
1138 pfile_in_zip_read_info->stream_initialised=1; 1138 pfile_in_zip_read_info->stream_initialised=1;
1139 else 1139 else
1140 return err; 1140 {
1141 /* windowBits is passed < 0 to tell that there is no zlib header. 1141 TRYFREE(pfile_in_zip_read_info);
1142 * Note that in this case inflate *requires* an extra "dummy" byte 1142 return err;
1143 * after the compressed stream in order to complete decompression and 1143 }
1144 * return Z_STREAM_END. 1144 /* windowBits is passed < 0 to tell that there is no zlib header.
1145 * In unzip, i don't wait absolutely Z_STREAM_END because I known the 1145 * Note that in this case inflate *requires* an extra "dummy" byte
1146 * size of both compressed and uncompressed data 1146 * after the compressed stream in order to complete decompression and
1147 */ 1147 * return Z_STREAM_END.
1148 } 1148 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1149 pfile_in_zip_read_info->rest_read_compressed = 1149 * size of both compressed and uncompressed data
1150 s->cur_file_info.compressed_size ; 1150 */
1151 pfile_in_zip_read_info->rest_read_uncompressed = 1151 }
1152 s->cur_file_info.uncompressed_size ; 1152 pfile_in_zip_read_info->rest_read_compressed =
1153 1153 s->cur_file_info.compressed_size ;
1154 1154 pfile_in_zip_read_info->rest_read_uncompressed =
1155 pfile_in_zip_read_info->pos_in_zipfile = 1155 s->cur_file_info.uncompressed_size ;
1156 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 1156
1157 iSizeVar; 1157
1158 1158 pfile_in_zip_read_info->pos_in_zipfile =
1159 pfile_in_zip_read_info->stream.avail_in = (uInt)0; 1159 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1160 1160 iSizeVar;
1161 s->pfile_in_zip_read = pfile_in_zip_read_info; 1161
1162 1162 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1163# ifndef NOUNCRYPT 1163
1164 if (password != NULL) 1164 s->pfile_in_zip_read = pfile_in_zip_read_info;
1165 { 1165
1166 int i; 1166# ifndef NOUNCRYPT
1167 s->pcrc_32_tab = get_crc_table(); 1167 if (password != NULL)
1168 init_keys(password,s->keys,s->pcrc_32_tab); 1168 {
1169 if (ZSEEK(s->z_filefunc, s->filestream, 1169 int i;
1170 s->pfile_in_zip_read->pos_in_zipfile + 1170 s->pcrc_32_tab = get_crc_table();
1171 s->pfile_in_zip_read->byte_before_the_zipfile, 1171 init_keys(password,s->keys,s->pcrc_32_tab);
1172 SEEK_SET)!=0) 1172 if (ZSEEK(s->z_filefunc, s->filestream,
1173 return UNZ_INTERNALERROR; 1173 s->pfile_in_zip_read->pos_in_zipfile +
1174 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) 1174 s->pfile_in_zip_read->byte_before_the_zipfile,
1175 return UNZ_INTERNALERROR; 1175 SEEK_SET)!=0)
1176 1176 return UNZ_INTERNALERROR;
1177 for (i = 0; i<12; i++) 1177 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
1178 zdecode(s->keys,s->pcrc_32_tab,source[i]); 1178 return UNZ_INTERNALERROR;
1179 1179
1180 s->pfile_in_zip_read->pos_in_zipfile+=12; 1180 for (i = 0; i<12; i++)
1181 s->encrypted=1; 1181 zdecode(s->keys,s->pcrc_32_tab,source[i]);
1182 } 1182
1183# endif 1183 s->pfile_in_zip_read->pos_in_zipfile+=12;
1184 1184 s->encrypted=1;
1185 1185 }
1186 return UNZ_OK; 1186# endif
1187} 1187
1188 1188
1189extern int ZEXPORT unzOpenCurrentFile (file) 1189 return UNZ_OK;
1190 unzFile file; 1190}
1191{ 1191
1192 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); 1192extern int ZEXPORT unzOpenCurrentFile (file)
1193} 1193 unzFile file;
1194 1194{
1195extern int ZEXPORT unzOpenCurrentFilePassword (file, password) 1195 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1196 unzFile file; 1196}
1197 const char* password; 1197
1198{ 1198extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
1199 return unzOpenCurrentFile3(file, NULL, NULL, 0, password); 1199 unzFile file;
1200} 1200 const char* password;
1201 1201{
1202extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw) 1202 return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1203 unzFile file; 1203}
1204 int* method; 1204
1205 int* level; 1205extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
1206 int raw; 1206 unzFile file;
1207{ 1207 int* method;
1208 return unzOpenCurrentFile3(file, method, level, raw, NULL); 1208 int* level;
1209} 1209 int raw;
1210 1210{
1211/* 1211 return unzOpenCurrentFile3(file, method, level, raw, NULL);
1212 Read bytes from the current file. 1212}
1213 buf contain buffer where data must be copied 1213
1214 len the size of buf. 1214/*
1215 1215 Read bytes from the current file.
1216 return the number of byte copied if somes bytes are copied 1216 buf contain buffer where data must be copied
1217 return 0 if the end of file was reached 1217 len the size of buf.
1218 return <0 with error code if there is an error 1218
1219 (UNZ_ERRNO for IO error, or zLib error for uncompress error) 1219 return the number of byte copied if somes bytes are copied
1220*/ 1220 return 0 if the end of file was reached
1221extern int ZEXPORT unzReadCurrentFile (file, buf, len) 1221 return <0 with error code if there is an error
1222 unzFile file; 1222 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1223 voidp buf; 1223*/
1224 unsigned len; 1224extern int ZEXPORT unzReadCurrentFile (file, buf, len)
1225{ 1225 unzFile file;
1226 int err=UNZ_OK; 1226 voidp buf;
1227 uInt iRead = 0; 1227 unsigned len;
1228 unz_s* s; 1228{
1229 file_in_zip_read_info_s* pfile_in_zip_read_info; 1229 int err=UNZ_OK;
1230 if (file==NULL) 1230 uInt iRead = 0;
1231 return UNZ_PARAMERROR; 1231 unz_s* s;
1232 s=(unz_s*)file; 1232 file_in_zip_read_info_s* pfile_in_zip_read_info;
1233 pfile_in_zip_read_info=s->pfile_in_zip_read; 1233 if (file==NULL)
1234 1234 return UNZ_PARAMERROR;
1235 if (pfile_in_zip_read_info==NULL) 1235 s=(unz_s*)file;
1236 return UNZ_PARAMERROR; 1236 pfile_in_zip_read_info=s->pfile_in_zip_read;
1237 1237
1238 1238 if (pfile_in_zip_read_info==NULL)
1239 if ((pfile_in_zip_read_info->read_buffer == NULL)) 1239 return UNZ_PARAMERROR;
1240 return UNZ_END_OF_LIST_OF_FILE; 1240
1241 if (len==0) 1241
1242 return 0; 1242 if ((pfile_in_zip_read_info->read_buffer == NULL))
1243 1243 return UNZ_END_OF_LIST_OF_FILE;
1244 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; 1244 if (len==0)
1245 1245 return 0;
1246 pfile_in_zip_read_info->stream.avail_out = (uInt)len; 1246
1247 1247 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1248 if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && 1248
1249 (!(pfile_in_zip_read_info->raw))) 1249 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1250 pfile_in_zip_read_info->stream.avail_out = 1250
1251 (uInt)pfile_in_zip_read_info->rest_read_uncompressed; 1251 if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
1252 1252 (!(pfile_in_zip_read_info->raw)))
1253 if ((len>pfile_in_zip_read_info->rest_read_compressed+ 1253 pfile_in_zip_read_info->stream.avail_out =
1254 pfile_in_zip_read_info->stream.avail_in) && 1254 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1255 (pfile_in_zip_read_info->raw)) 1255
1256 pfile_in_zip_read_info->stream.avail_out = 1256 if ((len>pfile_in_zip_read_info->rest_read_compressed+
1257 (uInt)pfile_in_zip_read_info->rest_read_compressed+ 1257 pfile_in_zip_read_info->stream.avail_in) &&
1258 pfile_in_zip_read_info->stream.avail_in; 1258 (pfile_in_zip_read_info->raw))
1259 1259 pfile_in_zip_read_info->stream.avail_out =
1260 while (pfile_in_zip_read_info->stream.avail_out>0) 1260 (uInt)pfile_in_zip_read_info->rest_read_compressed+
1261 { 1261 pfile_in_zip_read_info->stream.avail_in;
1262 if ((pfile_in_zip_read_info->stream.avail_in==0) && 1262
1263 (pfile_in_zip_read_info->rest_read_compressed>0)) 1263 while (pfile_in_zip_read_info->stream.avail_out>0)
1264 { 1264 {
1265 uInt uReadThis = UNZ_BUFSIZE; 1265 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1266 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) 1266 (pfile_in_zip_read_info->rest_read_compressed>0))
1267 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; 1267 {
1268 if (uReadThis == 0) 1268 uInt uReadThis = UNZ_BUFSIZE;
1269 return UNZ_EOF; 1269 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1270 if (ZSEEK(pfile_in_zip_read_info->z_filefunc, 1270 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1271 pfile_in_zip_read_info->filestream, 1271 if (uReadThis == 0)
1272 pfile_in_zip_read_info->pos_in_zipfile + 1272 return UNZ_EOF;
1273 pfile_in_zip_read_info->byte_before_the_zipfile, 1273 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1274 ZLIB_FILEFUNC_SEEK_SET)!=0) 1274 pfile_in_zip_read_info->filestream,
1275 return UNZ_ERRNO; 1275 pfile_in_zip_read_info->pos_in_zipfile +
1276 if (ZREAD(pfile_in_zip_read_info->z_filefunc, 1276 pfile_in_zip_read_info->byte_before_the_zipfile,
1277 pfile_in_zip_read_info->filestream, 1277 ZLIB_FILEFUNC_SEEK_SET)!=0)
1278 pfile_in_zip_read_info->read_buffer, 1278 return UNZ_ERRNO;
1279 uReadThis)!=uReadThis) 1279 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1280 return UNZ_ERRNO; 1280 pfile_in_zip_read_info->filestream,
1281 1281 pfile_in_zip_read_info->read_buffer,
1282 1282 uReadThis)!=uReadThis)
1283# ifndef NOUNCRYPT 1283 return UNZ_ERRNO;
1284 if(s->encrypted) 1284
1285 { 1285
1286 uInt i; 1286# ifndef NOUNCRYPT
1287 for(i=0;i<uReadThis;i++) 1287 if(s->encrypted)
1288 pfile_in_zip_read_info->read_buffer[i] = 1288 {
1289 zdecode(s->keys,s->pcrc_32_tab, 1289 uInt i;
1290 pfile_in_zip_read_info->read_buffer[i]); 1290 for(i=0;i<uReadThis;i++)
1291 } 1291 pfile_in_zip_read_info->read_buffer[i] =
1292# endif 1292 zdecode(s->keys,s->pcrc_32_tab,
1293 1293 pfile_in_zip_read_info->read_buffer[i]);
1294 1294 }
1295 pfile_in_zip_read_info->pos_in_zipfile += uReadThis; 1295# endif
1296 1296
1297 pfile_in_zip_read_info->rest_read_compressed-=uReadThis; 1297
1298 1298 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1299 pfile_in_zip_read_info->stream.next_in = 1299
1300 (Bytef*)pfile_in_zip_read_info->read_buffer; 1300 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1301 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; 1301
1302 } 1302 pfile_in_zip_read_info->stream.next_in =
1303 1303 (Bytef*)pfile_in_zip_read_info->read_buffer;
1304 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) 1304 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1305 { 1305 }
1306 uInt uDoCopy,i ; 1306
1307 1307 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1308 if ((pfile_in_zip_read_info->stream.avail_in == 0) && 1308 {
1309 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1309 uInt uDoCopy,i ;
1310 return (iRead==0) ? UNZ_EOF : iRead; 1310
1311 1311 if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1312 if (pfile_in_zip_read_info->stream.avail_out < 1312 (pfile_in_zip_read_info->rest_read_compressed == 0))
1313 pfile_in_zip_read_info->stream.avail_in) 1313 return (iRead==0) ? UNZ_EOF : iRead;
1314 uDoCopy = pfile_in_zip_read_info->stream.avail_out ; 1314
1315 else 1315 if (pfile_in_zip_read_info->stream.avail_out <
1316 uDoCopy = pfile_in_zip_read_info->stream.avail_in ; 1316 pfile_in_zip_read_info->stream.avail_in)
1317 1317 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1318 for (i=0;i<uDoCopy;i++) 1318 else
1319 *(pfile_in_zip_read_info->stream.next_out+i) = 1319 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1320 *(pfile_in_zip_read_info->stream.next_in+i); 1320
1321 1321 for (i=0;i<uDoCopy;i++)
1322 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, 1322 *(pfile_in_zip_read_info->stream.next_out+i) =
1323 pfile_in_zip_read_info->stream.next_out, 1323 *(pfile_in_zip_read_info->stream.next_in+i);
1324 uDoCopy); 1324
1325 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; 1325 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1326 pfile_in_zip_read_info->stream.avail_in -= uDoCopy; 1326 pfile_in_zip_read_info->stream.next_out,
1327 pfile_in_zip_read_info->stream.avail_out -= uDoCopy; 1327 uDoCopy);
1328 pfile_in_zip_read_info->stream.next_out += uDoCopy; 1328 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1329 pfile_in_zip_read_info->stream.next_in += uDoCopy; 1329 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1330 pfile_in_zip_read_info->stream.total_out += uDoCopy; 1330 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1331 iRead += uDoCopy; 1331 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1332 } 1332 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1333 else 1333 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1334 { 1334 iRead += uDoCopy;
1335 uLong uTotalOutBefore,uTotalOutAfter; 1335 }
1336 const Bytef *bufBefore; 1336 else
1337 uLong uOutThis; 1337 {
1338 int flush=Z_SYNC_FLUSH; 1338 uLong uTotalOutBefore,uTotalOutAfter;
1339 1339 const Bytef *bufBefore;
1340 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; 1340 uLong uOutThis;
1341 bufBefore = pfile_in_zip_read_info->stream.next_out; 1341 int flush=Z_SYNC_FLUSH;
1342 1342
1343 /* 1343 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1344 if ((pfile_in_zip_read_info->rest_read_uncompressed == 1344 bufBefore = pfile_in_zip_read_info->stream.next_out;
1345 pfile_in_zip_read_info->stream.avail_out) && 1345
1346 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1346 /*
1347 flush = Z_FINISH; 1347 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1348 */ 1348 pfile_in_zip_read_info->stream.avail_out) &&
1349 err=inflate(&pfile_in_zip_read_info->stream,flush); 1349 (pfile_in_zip_read_info->rest_read_compressed == 0))
1350 1350 flush = Z_FINISH;
1351 if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) 1351 */
1352 err = Z_DATA_ERROR; 1352 err=inflate(&pfile_in_zip_read_info->stream,flush);
1353 1353
1354 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; 1354 if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
1355 uOutThis = uTotalOutAfter-uTotalOutBefore; 1355 err = Z_DATA_ERROR;
1356 1356
1357 pfile_in_zip_read_info->crc32 = 1357 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1358 crc32(pfile_in_zip_read_info->crc32,bufBefore, 1358 uOutThis = uTotalOutAfter-uTotalOutBefore;
1359 (uInt)(uOutThis)); 1359
1360 1360 pfile_in_zip_read_info->crc32 =
1361 pfile_in_zip_read_info->rest_read_uncompressed -= 1361 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1362 uOutThis; 1362 (uInt)(uOutThis));
1363 1363
1364 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); 1364 pfile_in_zip_read_info->rest_read_uncompressed -=
1365 1365 uOutThis;
1366 if (err==Z_STREAM_END) 1366
1367 return (iRead==0) ? UNZ_EOF : iRead; 1367 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1368 if (err!=Z_OK) 1368
1369 break; 1369 if (err==Z_STREAM_END)
1370 } 1370 return (iRead==0) ? UNZ_EOF : iRead;
1371 } 1371 if (err!=Z_OK)
1372 1372 break;
1373 if (err==Z_OK) 1373 }
1374 return iRead; 1374 }
1375 return err; 1375
1376} 1376 if (err==Z_OK)
1377 1377 return iRead;
1378 1378 return err;
1379/* 1379}
1380 Give the current position in uncompressed data 1380
1381*/ 1381
1382extern z_off_t ZEXPORT unztell (file) 1382/*
1383 unzFile file; 1383 Give the current position in uncompressed data
1384{ 1384*/
1385 unz_s* s; 1385extern z_off_t ZEXPORT unztell (file)
1386 file_in_zip_read_info_s* pfile_in_zip_read_info; 1386 unzFile file;
1387 if (file==NULL) 1387{
1388 return UNZ_PARAMERROR; 1388 unz_s* s;
1389 s=(unz_s*)file; 1389 file_in_zip_read_info_s* pfile_in_zip_read_info;
1390 pfile_in_zip_read_info=s->pfile_in_zip_read; 1390 if (file==NULL)
1391 1391 return UNZ_PARAMERROR;
1392 if (pfile_in_zip_read_info==NULL) 1392 s=(unz_s*)file;
1393 return UNZ_PARAMERROR; 1393 pfile_in_zip_read_info=s->pfile_in_zip_read;
1394 1394
1395 return (z_off_t)pfile_in_zip_read_info->stream.total_out; 1395 if (pfile_in_zip_read_info==NULL)
1396} 1396 return UNZ_PARAMERROR;
1397 1397
1398 1398 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1399/* 1399}
1400 return 1 if the end of file was reached, 0 elsewhere 1400
1401*/ 1401
1402extern int ZEXPORT unzeof (file) 1402/*
1403 unzFile file; 1403 return 1 if the end of file was reached, 0 elsewhere
1404{ 1404*/
1405 unz_s* s; 1405extern int ZEXPORT unzeof (file)
1406 file_in_zip_read_info_s* pfile_in_zip_read_info; 1406 unzFile file;
1407 if (file==NULL) 1407{
1408 return UNZ_PARAMERROR; 1408 unz_s* s;
1409 s=(unz_s*)file; 1409 file_in_zip_read_info_s* pfile_in_zip_read_info;
1410 pfile_in_zip_read_info=s->pfile_in_zip_read; 1410 if (file==NULL)
1411 1411 return UNZ_PARAMERROR;
1412 if (pfile_in_zip_read_info==NULL) 1412 s=(unz_s*)file;
1413 return UNZ_PARAMERROR; 1413 pfile_in_zip_read_info=s->pfile_in_zip_read;
1414 1414
1415 if (pfile_in_zip_read_info->rest_read_uncompressed == 0) 1415 if (pfile_in_zip_read_info==NULL)
1416 return 1; 1416 return UNZ_PARAMERROR;
1417 else 1417
1418 return 0; 1418 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1419} 1419 return 1;
1420 1420 else
1421 1421 return 0;
1422 1422}
1423/* 1423
1424 Read extra field from the current file (opened by unzOpenCurrentFile) 1424
1425 This is the local-header version of the extra field (sometimes, there is 1425
1426 more info in the local-header version than in the central-header) 1426/*
1427 1427 Read extra field from the current file (opened by unzOpenCurrentFile)
1428 if buf==NULL, it return the size of the local extra field that can be read 1428 This is the local-header version of the extra field (sometimes, there is
1429 1429 more info in the local-header version than in the central-header)
1430 if buf!=NULL, len is the size of the buffer, the extra header is copied in 1430
1431 buf. 1431 if buf==NULL, it return the size of the local extra field that can be read
1432 the return value is the number of bytes copied in buf, or (if <0) 1432
1433 the error code 1433 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1434*/ 1434 buf.
1435extern int ZEXPORT unzGetLocalExtrafield (file,buf,len) 1435 the return value is the number of bytes copied in buf, or (if <0)
1436 unzFile file; 1436 the error code
1437 voidp buf; 1437*/
1438 unsigned len; 1438extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1439{ 1439 unzFile file;
1440 unz_s* s; 1440 voidp buf;
1441 file_in_zip_read_info_s* pfile_in_zip_read_info; 1441 unsigned len;
1442 uInt read_now; 1442{
1443 uLong size_to_read; 1443 unz_s* s;
1444 1444 file_in_zip_read_info_s* pfile_in_zip_read_info;
1445 if (file==NULL) 1445 uInt read_now;
1446 return UNZ_PARAMERROR; 1446 uLong size_to_read;
1447 s=(unz_s*)file; 1447
1448 pfile_in_zip_read_info=s->pfile_in_zip_read; 1448 if (file==NULL)
1449 1449 return UNZ_PARAMERROR;
1450 if (pfile_in_zip_read_info==NULL) 1450 s=(unz_s*)file;
1451 return UNZ_PARAMERROR; 1451 pfile_in_zip_read_info=s->pfile_in_zip_read;
1452 1452
1453 size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 1453 if (pfile_in_zip_read_info==NULL)
1454 pfile_in_zip_read_info->pos_local_extrafield); 1454 return UNZ_PARAMERROR;
1455 1455
1456 if (buf==NULL) 1456 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1457 return (int)size_to_read; 1457 pfile_in_zip_read_info->pos_local_extrafield);
1458 1458
1459 if (len>size_to_read) 1459 if (buf==NULL)
1460 read_now = (uInt)size_to_read; 1460 return (int)size_to_read;
1461 else 1461
1462 read_now = (uInt)len ; 1462 if (len>size_to_read)
1463 1463 read_now = (uInt)size_to_read;
1464 if (read_now==0) 1464 else
1465 return 0; 1465 read_now = (uInt)len ;
1466 1466
1467 if (ZSEEK(pfile_in_zip_read_info->z_filefunc, 1467 if (read_now==0)
1468 pfile_in_zip_read_info->filestream, 1468 return 0;
1469 pfile_in_zip_read_info->offset_local_extrafield + 1469
1470 pfile_in_zip_read_info->pos_local_extrafield, 1470 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1471 ZLIB_FILEFUNC_SEEK_SET)!=0) 1471 pfile_in_zip_read_info->filestream,
1472 return UNZ_ERRNO; 1472 pfile_in_zip_read_info->offset_local_extrafield +
1473 1473 pfile_in_zip_read_info->pos_local_extrafield,
1474 if (ZREAD(pfile_in_zip_read_info->z_filefunc, 1474 ZLIB_FILEFUNC_SEEK_SET)!=0)
1475 pfile_in_zip_read_info->filestream, 1475 return UNZ_ERRNO;
1476 buf,read_now)!=read_now) 1476
1477 return UNZ_ERRNO; 1477 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1478 1478 pfile_in_zip_read_info->filestream,
1479 return (int)read_now; 1479 buf,read_now)!=read_now)
1480} 1480 return UNZ_ERRNO;
1481 1481
1482/* 1482 return (int)read_now;
1483 Close the file in zip opened with unzipOpenCurrentFile 1483}
1484 Return UNZ_CRCERROR if all the file was read but the CRC is not good 1484
1485*/ 1485/*
1486extern int ZEXPORT unzCloseCurrentFile (file) 1486 Close the file in zip opened with unzipOpenCurrentFile
1487 unzFile file; 1487 Return UNZ_CRCERROR if all the file was read but the CRC is not good
1488{ 1488*/
1489 int err=UNZ_OK; 1489extern int ZEXPORT unzCloseCurrentFile (file)
1490 1490 unzFile file;
1491 unz_s* s; 1491{
1492 file_in_zip_read_info_s* pfile_in_zip_read_info; 1492 int err=UNZ_OK;
1493 if (file==NULL) 1493
1494 return UNZ_PARAMERROR; 1494 unz_s* s;
1495 s=(unz_s*)file; 1495 file_in_zip_read_info_s* pfile_in_zip_read_info;
1496 pfile_in_zip_read_info=s->pfile_in_zip_read; 1496 if (file==NULL)
1497 1497 return UNZ_PARAMERROR;
1498 if (pfile_in_zip_read_info==NULL) 1498 s=(unz_s*)file;
1499 return UNZ_PARAMERROR; 1499 pfile_in_zip_read_info=s->pfile_in_zip_read;
1500 1500
1501 1501 if (pfile_in_zip_read_info==NULL)
1502 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && 1502 return UNZ_PARAMERROR;
1503 (!pfile_in_zip_read_info->raw)) 1503
1504 { 1504
1505 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) 1505 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
1506 err=UNZ_CRCERROR; 1506 (!pfile_in_zip_read_info->raw))
1507 } 1507 {
1508 1508 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1509 1509 err=UNZ_CRCERROR;
1510 TRYFREE(pfile_in_zip_read_info->read_buffer); 1510 }
1511 pfile_in_zip_read_info->read_buffer = NULL; 1511
1512 if (pfile_in_zip_read_info->stream_initialised) 1512
1513 inflateEnd(&pfile_in_zip_read_info->stream); 1513 TRYFREE(pfile_in_zip_read_info->read_buffer);
1514 1514 pfile_in_zip_read_info->read_buffer = NULL;
1515 pfile_in_zip_read_info->stream_initialised = 0; 1515 if (pfile_in_zip_read_info->stream_initialised)
1516 TRYFREE(pfile_in_zip_read_info); 1516 inflateEnd(&pfile_in_zip_read_info->stream);
1517 1517
1518 s->pfile_in_zip_read=NULL; 1518 pfile_in_zip_read_info->stream_initialised = 0;
1519 1519 TRYFREE(pfile_in_zip_read_info);
1520 return err; 1520
1521} 1521 s->pfile_in_zip_read=NULL;
1522 1522
1523 1523 return err;
1524/* 1524}
1525 Get the global comment string of the ZipFile, in the szComment buffer. 1525
1526 uSizeBuf is the size of the szComment buffer. 1526
1527 return the number of byte copied or an error code <0 1527/*
1528*/ 1528 Get the global comment string of the ZipFile, in the szComment buffer.
1529extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf) 1529 uSizeBuf is the size of the szComment buffer.
1530 unzFile file; 1530 return the number of byte copied or an error code <0
1531 char *szComment; 1531*/
1532 uLong uSizeBuf; 1532extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1533{ 1533 unzFile file;
1534 int err=UNZ_OK; 1534 char *szComment;
1535 unz_s* s; 1535 uLong uSizeBuf;
1536 uLong uReadThis ; 1536{
1537 if (file==NULL) 1537 int err=UNZ_OK;
1538 return UNZ_PARAMERROR; 1538 unz_s* s;
1539 s=(unz_s*)file; 1539 uLong uReadThis ;
1540 1540 if (file==NULL)
1541 uReadThis = uSizeBuf; 1541 return UNZ_PARAMERROR;
1542 if (uReadThis>s->gi.size_comment) 1542 s=(unz_s*)file;
1543 uReadThis = s->gi.size_comment; 1543
1544 1544 uReadThis = uSizeBuf;
1545 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) 1545 if (uReadThis>s->gi.size_comment)
1546 return UNZ_ERRNO; 1546 uReadThis = s->gi.size_comment;
1547 1547
1548 if (uReadThis>0) 1548 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
1549 { 1549 return UNZ_ERRNO;
1550 *szComment='\0'; 1550
1551 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) 1551 if (uReadThis>0)
1552 return UNZ_ERRNO; 1552 {
1553 } 1553 *szComment='\0';
1554 1554 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
1555 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) 1555 return UNZ_ERRNO;
1556 *(szComment+s->gi.size_comment)='\0'; 1556 }
1557 return (int)uReadThis; 1557
1558} 1558 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1559 1559 *(szComment+s->gi.size_comment)='\0';
1560/* Additions by RX '2004 */ 1560 return (int)uReadThis;
1561extern uLong ZEXPORT unzGetOffset (file) 1561}
1562 unzFile file; 1562
1563{ 1563/* Additions by RX '2004 */
1564 unz_s* s; 1564extern uLong ZEXPORT unzGetOffset (file)
1565 1565 unzFile file;
1566 if (file==NULL) 1566{
1567 return UNZ_PARAMERROR; 1567 unz_s* s;
1568 s=(unz_s*)file; 1568
1569 if (!s->current_file_ok) 1569 if (file==NULL)
1570 return 0; 1570 return UNZ_PARAMERROR;
1571 if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) 1571 s=(unz_s*)file;
1572 if (s->num_file==s->gi.number_entry) 1572 if (!s->current_file_ok)
1573 return 0; 1573 return 0;
1574 return s->pos_in_central_dir; 1574 if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
1575} 1575 if (s->num_file==s->gi.number_entry)
1576 1576 return 0;
1577extern int ZEXPORT unzSetOffset (file, pos) 1577 return s->pos_in_central_dir;
1578 unzFile file; 1578}
1579 uLong pos; 1579
1580{ 1580extern int ZEXPORT unzSetOffset (file, pos)
1581 unz_s* s; 1581 unzFile file;
1582 int err; 1582 uLong pos;
1583 1583{
1584 if (file==NULL) 1584 unz_s* s;
1585 return UNZ_PARAMERROR; 1585 int err;
1586 s=(unz_s*)file; 1586
1587 1587 if (file==NULL)
1588 s->pos_in_central_dir = pos; 1588 return UNZ_PARAMERROR;
1589 s->num_file = s->gi.number_entry; /* hack */ 1589 s=(unz_s*)file;
1590 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 1590
1591 &s->cur_file_info_internal, 1591 s->pos_in_central_dir = pos;
1592 NULL,0,NULL,0,NULL,0); 1592 s->num_file = s->gi.number_entry; /* hack */
1593 s->current_file_ok = (err == UNZ_OK); 1593 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1594 return err; 1594 &s->cur_file_info_internal,
1595} 1595 NULL,0,NULL,0,NULL,0);
1596 s->current_file_ok = (err == UNZ_OK);
1597 return err;
1598}
diff --git a/contrib/minizip/unzip.h b/contrib/minizip/unzip.h
index 0c7c6f1..c3206a0 100644
--- a/contrib/minizip/unzip.h
+++ b/contrib/minizip/unzip.h
@@ -1,352 +1,354 @@
1/* unzip.h -- IO for uncompress .zip files using zlib 1/* unzip.h -- IO for uncompress .zip files using zlib
2 Version 1.01, May 8th, 2004 2 Version 1.01e, February 12th, 2005
3 3
4 Copyright (C) 1998-2004 Gilles Vollant 4 Copyright (C) 1998-2005 Gilles Vollant
5 5
6 This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g 6 This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
7 WinZip, InfoZip tools and compatible. 7 WinZip, InfoZip tools and compatible.
8 Encryption and multi volume ZipFile (span) are not supported. 8
9 Old compressions used by old PKZip 1.x are not supported 9 Multi volume ZipFile (span) are not supported.
10 10 Encryption compatible with pkzip 2.04g only supported
11 11 Old compressions used by old PKZip 1.x are not supported
12 I WAIT FEEDBACK at mail info@winimage.com 12
13 Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution 13
14 14 I WAIT FEEDBACK at mail info@winimage.com
15 Condition of use and distribution are the same than zlib : 15 Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
16 16
17 This software is provided 'as-is', without any express or implied 17 Condition of use and distribution are the same than zlib :
18 warranty. In no event will the authors be held liable for any damages 18
19 arising from the use of this software. 19 This software is provided 'as-is', without any express or implied
20 20 warranty. In no event will the authors be held liable for any damages
21 Permission is granted to anyone to use this software for any purpose, 21 arising from the use of this software.
22 including commercial applications, and to alter it and redistribute it 22
23 freely, subject to the following restrictions: 23 Permission is granted to anyone to use this software for any purpose,
24 24 including commercial applications, and to alter it and redistribute it
25 1. The origin of this software must not be misrepresented; you must not 25 freely, subject to the following restrictions:
26 claim that you wrote the original software. If you use this software 26
27 in a product, an acknowledgment in the product documentation would be 27 1. The origin of this software must not be misrepresented; you must not
28 appreciated but is not required. 28 claim that you wrote the original software. If you use this software
29 2. Altered source versions must be plainly marked as such, and must not be 29 in a product, an acknowledgment in the product documentation would be
30 misrepresented as being the original software. 30 appreciated but is not required.
31 3. This notice may not be removed or altered from any source distribution. 31 2. Altered source versions must be plainly marked as such, and must not be
32 32 misrepresented as being the original software.
33 33 3. This notice may not be removed or altered from any source distribution.
34*/ 34
35 35
36/* for more info about .ZIP format, see 36*/
37 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip 37
38 http://www.info-zip.org/pub/infozip/doc/ 38/* for more info about .ZIP format, see
39 PkWare has also a specification at : 39 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
40 ftp://ftp.pkware.com/probdesc.zip 40 http://www.info-zip.org/pub/infozip/doc/
41*/ 41 PkWare has also a specification at :
42 42 ftp://ftp.pkware.com/probdesc.zip
43#ifndef _unz_H 43*/
44#define _unz_H 44
45 45#ifndef _unz_H
46#ifdef __cplusplus 46#define _unz_H
47extern "C" { 47
48#endif 48#ifdef __cplusplus
49 49extern "C" {
50#ifndef _ZLIB_H 50#endif
51#include "zlib.h" 51
52#endif 52#ifndef _ZLIB_H
53 53#include "zlib.h"
54#ifndef _ZLIBIOAPI_H 54#endif
55#include "ioapi.h" 55
56#endif 56#ifndef _ZLIBIOAPI_H
57 57#include "ioapi.h"
58#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) 58#endif
59/* like the STRICT of WIN32, we define a pointer that cannot be converted 59
60 from (void*) without cast */ 60#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
61typedef struct TagunzFile__ { int unused; } unzFile__; 61/* like the STRICT of WIN32, we define a pointer that cannot be converted
62typedef unzFile__ *unzFile; 62 from (void*) without cast */
63#else 63typedef struct TagunzFile__ { int unused; } unzFile__;
64typedef voidp unzFile; 64typedef unzFile__ *unzFile;
65#endif 65#else
66 66typedef voidp unzFile;
67 67#endif
68#define UNZ_OK (0) 68
69#define UNZ_END_OF_LIST_OF_FILE (-100) 69
70#define UNZ_ERRNO (Z_ERRNO) 70#define UNZ_OK (0)
71#define UNZ_EOF (0) 71#define UNZ_END_OF_LIST_OF_FILE (-100)
72#define UNZ_PARAMERROR (-102) 72#define UNZ_ERRNO (Z_ERRNO)
73#define UNZ_BADZIPFILE (-103) 73#define UNZ_EOF (0)
74#define UNZ_INTERNALERROR (-104) 74#define UNZ_PARAMERROR (-102)
75#define UNZ_CRCERROR (-105) 75#define UNZ_BADZIPFILE (-103)
76 76#define UNZ_INTERNALERROR (-104)
77/* tm_unz contain date/time info */ 77#define UNZ_CRCERROR (-105)
78typedef struct tm_unz_s 78
79{ 79/* tm_unz contain date/time info */
80 uInt tm_sec; /* seconds after the minute - [0,59] */ 80typedef struct tm_unz_s
81 uInt tm_min; /* minutes after the hour - [0,59] */ 81{
82 uInt tm_hour; /* hours since midnight - [0,23] */ 82 uInt tm_sec; /* seconds after the minute - [0,59] */
83 uInt tm_mday; /* day of the month - [1,31] */ 83 uInt tm_min; /* minutes after the hour - [0,59] */
84 uInt tm_mon; /* months since January - [0,11] */ 84 uInt tm_hour; /* hours since midnight - [0,23] */
85 uInt tm_year; /* years - [1980..2044] */ 85 uInt tm_mday; /* day of the month - [1,31] */
86} tm_unz; 86 uInt tm_mon; /* months since January - [0,11] */
87 87 uInt tm_year; /* years - [1980..2044] */
88/* unz_global_info structure contain global data about the ZIPfile 88} tm_unz;
89 These data comes from the end of central dir */ 89
90typedef struct unz_global_info_s 90/* unz_global_info structure contain global data about the ZIPfile
91{ 91 These data comes from the end of central dir */
92 uLong number_entry; /* total number of entries in 92typedef struct unz_global_info_s
93 the central dir on this disk */ 93{
94 uLong size_comment; /* size of the global comment of the zipfile */ 94 uLong number_entry; /* total number of entries in
95} unz_global_info; 95 the central dir on this disk */
96 96 uLong size_comment; /* size of the global comment of the zipfile */
97 97} unz_global_info;
98/* unz_file_info contain information about a file in the zipfile */ 98
99typedef struct unz_file_info_s 99
100{ 100/* unz_file_info contain information about a file in the zipfile */
101 uLong version; /* version made by 2 bytes */ 101typedef struct unz_file_info_s
102 uLong version_needed; /* version needed to extract 2 bytes */ 102{
103 uLong flag; /* general purpose bit flag 2 bytes */ 103 uLong version; /* version made by 2 bytes */
104 uLong compression_method; /* compression method 2 bytes */ 104 uLong version_needed; /* version needed to extract 2 bytes */
105 uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ 105 uLong flag; /* general purpose bit flag 2 bytes */
106 uLong crc; /* crc-32 4 bytes */ 106 uLong compression_method; /* compression method 2 bytes */
107 uLong compressed_size; /* compressed size 4 bytes */ 107 uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
108 uLong uncompressed_size; /* uncompressed size 4 bytes */ 108 uLong crc; /* crc-32 4 bytes */
109 uLong size_filename; /* filename length 2 bytes */ 109 uLong compressed_size; /* compressed size 4 bytes */
110 uLong size_file_extra; /* extra field length 2 bytes */ 110 uLong uncompressed_size; /* uncompressed size 4 bytes */
111 uLong size_file_comment; /* file comment length 2 bytes */ 111 uLong size_filename; /* filename length 2 bytes */
112 112 uLong size_file_extra; /* extra field length 2 bytes */
113 uLong disk_num_start; /* disk number start 2 bytes */ 113 uLong size_file_comment; /* file comment length 2 bytes */
114 uLong internal_fa; /* internal file attributes 2 bytes */ 114
115 uLong external_fa; /* external file attributes 4 bytes */ 115 uLong disk_num_start; /* disk number start 2 bytes */
116 116 uLong internal_fa; /* internal file attributes 2 bytes */
117 tm_unz tmu_date; 117 uLong external_fa; /* external file attributes 4 bytes */
118} unz_file_info; 118
119 119 tm_unz tmu_date;
120extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, 120} unz_file_info;
121 const char* fileName2, 121
122 int iCaseSensitivity)); 122extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
123/* 123 const char* fileName2,
124 Compare two filename (fileName1,fileName2). 124 int iCaseSensitivity));
125 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) 125/*
126 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi 126 Compare two filename (fileName1,fileName2).
127 or strcasecmp) 127 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
128 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system 128 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
129 (like 1 on Unix, 2 on Windows) 129 or strcasecmp)
130*/ 130 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
131 131 (like 1 on Unix, 2 on Windows)
132 132*/
133extern unzFile ZEXPORT unzOpen OF((const char *path)); 133
134/* 134
135 Open a Zip file. path contain the full pathname (by example, 135extern unzFile ZEXPORT unzOpen OF((const char *path));
136 on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer 136/*
137 "zlib/zlib113.zip". 137 Open a Zip file. path contain the full pathname (by example,
138 If the zipfile cannot be opened (file don't exist or in not valid), the 138 on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
139 return value is NULL. 139 "zlib/zlib113.zip".
140 Else, the return value is a unzFile Handle, usable with other function 140 If the zipfile cannot be opened (file don't exist or in not valid), the
141 of this unzip package. 141 return value is NULL.
142*/ 142 Else, the return value is a unzFile Handle, usable with other function
143 143 of this unzip package.
144extern unzFile ZEXPORT unzOpen2 OF((const char *path, 144*/
145 zlib_filefunc_def* pzlib_filefunc_def)); 145
146/* 146extern unzFile ZEXPORT unzOpen2 OF((const char *path,
147 Open a Zip file, like unzOpen, but provide a set of file low level API 147 zlib_filefunc_def* pzlib_filefunc_def));
148 for read/write the zip file (see ioapi.h) 148/*
149*/ 149 Open a Zip file, like unzOpen, but provide a set of file low level API
150 150 for read/write the zip file (see ioapi.h)
151extern int ZEXPORT unzClose OF((unzFile file)); 151*/
152/* 152
153 Close a ZipFile opened with unzipOpen. 153extern int ZEXPORT unzClose OF((unzFile file));
154 If there is files inside the .Zip opened with unzOpenCurrentFile (see later), 154/*
155 these files MUST be closed with unzipCloseCurrentFile before call unzipClose. 155 Close a ZipFile opened with unzipOpen.
156 return UNZ_OK if there is no problem. */ 156 If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
157 157 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
158extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, 158 return UNZ_OK if there is no problem. */
159 unz_global_info *pglobal_info)); 159
160/* 160extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
161 Write info about the ZipFile in the *pglobal_info structure. 161 unz_global_info *pglobal_info));
162 No preparation of the structure is needed 162/*
163 return UNZ_OK if there is no problem. */ 163 Write info about the ZipFile in the *pglobal_info structure.
164 164 No preparation of the structure is needed
165 165 return UNZ_OK if there is no problem. */
166extern int ZEXPORT unzGetGlobalComment OF((unzFile file, 166
167 char *szComment, 167
168 uLong uSizeBuf)); 168extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
169/* 169 char *szComment,
170 Get the global comment string of the ZipFile, in the szComment buffer. 170 uLong uSizeBuf));
171 uSizeBuf is the size of the szComment buffer. 171/*
172 return the number of byte copied or an error code <0 172 Get the global comment string of the ZipFile, in the szComment buffer.
173*/ 173 uSizeBuf is the size of the szComment buffer.
174 174 return the number of byte copied or an error code <0
175 175*/
176/***************************************************************************/ 176
177/* Unzip package allow you browse the directory of the zipfile */ 177
178 178/***************************************************************************/
179extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); 179/* Unzip package allow you browse the directory of the zipfile */
180/* 180
181 Set the current file of the zipfile to the first file. 181extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
182 return UNZ_OK if there is no problem 182/*
183*/ 183 Set the current file of the zipfile to the first file.
184 184 return UNZ_OK if there is no problem
185extern int ZEXPORT unzGoToNextFile OF((unzFile file)); 185*/
186/* 186
187 Set the current file of the zipfile to the next file. 187extern int ZEXPORT unzGoToNextFile OF((unzFile file));
188 return UNZ_OK if there is no problem 188/*
189 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. 189 Set the current file of the zipfile to the next file.
190*/ 190 return UNZ_OK if there is no problem
191 191 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
192extern int ZEXPORT unzLocateFile OF((unzFile file, 192*/
193 const char *szFileName, 193
194 int iCaseSensitivity)); 194extern int ZEXPORT unzLocateFile OF((unzFile file,
195/* 195 const char *szFileName,
196 Try locate the file szFileName in the zipfile. 196 int iCaseSensitivity));
197 For the iCaseSensitivity signification, see unzStringFileNameCompare 197/*
198 198 Try locate the file szFileName in the zipfile.
199 return value : 199 For the iCaseSensitivity signification, see unzStringFileNameCompare
200 UNZ_OK if the file is found. It becomes the current file. 200
201 UNZ_END_OF_LIST_OF_FILE if the file is not found 201 return value :
202*/ 202 UNZ_OK if the file is found. It becomes the current file.
203 203 UNZ_END_OF_LIST_OF_FILE if the file is not found
204 204*/
205/* ****************************************** */ 205
206/* Ryan supplied functions */ 206
207/* unz_file_info contain information about a file in the zipfile */ 207/* ****************************************** */
208typedef struct unz_file_pos_s 208/* Ryan supplied functions */
209{ 209/* unz_file_info contain information about a file in the zipfile */
210 uLong pos_in_zip_directory; /* offset in zip file directory */ 210typedef struct unz_file_pos_s
211 uLong num_of_file; /* # of file */ 211{
212} unz_file_pos; 212 uLong pos_in_zip_directory; /* offset in zip file directory */
213 213 uLong num_of_file; /* # of file */
214extern int ZEXPORT unzGetFilePos( 214} unz_file_pos;
215 unzFile file, 215
216 unz_file_pos* file_pos); 216extern int ZEXPORT unzGetFilePos(
217 217 unzFile file,
218extern int ZEXPORT unzGoToFilePos( 218 unz_file_pos* file_pos);
219 unzFile file, 219
220 unz_file_pos* file_pos); 220extern int ZEXPORT unzGoToFilePos(
221 221 unzFile file,
222/* ****************************************** */ 222 unz_file_pos* file_pos);
223 223
224extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, 224/* ****************************************** */
225 unz_file_info *pfile_info, 225
226 char *szFileName, 226extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
227 uLong fileNameBufferSize, 227 unz_file_info *pfile_info,
228 void *extraField, 228 char *szFileName,
229 uLong extraFieldBufferSize, 229 uLong fileNameBufferSize,
230 char *szComment, 230 void *extraField,
231 uLong commentBufferSize)); 231 uLong extraFieldBufferSize,
232/* 232 char *szComment,
233 Get Info about the current file 233 uLong commentBufferSize));
234 if pfile_info!=NULL, the *pfile_info structure will contain somes info about 234/*
235 the current file 235 Get Info about the current file
236 if szFileName!=NULL, the filemane string will be copied in szFileName 236 if pfile_info!=NULL, the *pfile_info structure will contain somes info about
237 (fileNameBufferSize is the size of the buffer) 237 the current file
238 if extraField!=NULL, the extra field information will be copied in extraField 238 if szFileName!=NULL, the filemane string will be copied in szFileName
239 (extraFieldBufferSize is the size of the buffer). 239 (fileNameBufferSize is the size of the buffer)
240 This is the Central-header version of the extra field 240 if extraField!=NULL, the extra field information will be copied in extraField
241 if szComment!=NULL, the comment string of the file will be copied in szComment 241 (extraFieldBufferSize is the size of the buffer).
242 (commentBufferSize is the size of the buffer) 242 This is the Central-header version of the extra field
243*/ 243 if szComment!=NULL, the comment string of the file will be copied in szComment
244 244 (commentBufferSize is the size of the buffer)
245/***************************************************************************/ 245*/
246/* for reading the content of the current zipfile, you can open it, read data 246
247 from it, and close it (you can close it before reading all the file) 247/***************************************************************************/
248 */ 248/* for reading the content of the current zipfile, you can open it, read data
249 249 from it, and close it (you can close it before reading all the file)
250extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); 250 */
251/* 251
252 Open for reading data the current file in the zipfile. 252extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
253 If there is no error, the return value is UNZ_OK. 253/*
254*/ 254 Open for reading data the current file in the zipfile.
255 255 If there is no error, the return value is UNZ_OK.
256extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, 256*/
257 const char* password)); 257
258/* 258extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
259 Open for reading data the current file in the zipfile. 259 const char* password));
260 password is a crypting password 260/*
261 If there is no error, the return value is UNZ_OK. 261 Open for reading data the current file in the zipfile.
262*/ 262 password is a crypting password
263 263 If there is no error, the return value is UNZ_OK.
264extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, 264*/
265 int* method, 265
266 int* level, 266extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
267 int raw)); 267 int* method,
268/* 268 int* level,
269 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) 269 int raw));
270 if raw==1 270/*
271 *method will receive method of compression, *level will receive level of 271 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
272 compression 272 if raw==1
273 note : you can set level parameter as NULL (if you did not want known level, 273 *method will receive method of compression, *level will receive level of
274 but you CANNOT set method parameter as NULL 274 compression
275*/ 275 note : you can set level parameter as NULL (if you did not want known level,
276 276 but you CANNOT set method parameter as NULL
277extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, 277*/
278 int* method, 278
279 int* level, 279extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
280 int raw, 280 int* method,
281 const char* password)); 281 int* level,
282/* 282 int raw,
283 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) 283 const char* password));
284 if raw==1 284/*
285 *method will receive method of compression, *level will receive level of 285 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
286 compression 286 if raw==1
287 note : you can set level parameter as NULL (if you did not want known level, 287 *method will receive method of compression, *level will receive level of
288 but you CANNOT set method parameter as NULL 288 compression
289*/ 289 note : you can set level parameter as NULL (if you did not want known level,
290 290 but you CANNOT set method parameter as NULL
291 291*/
292extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); 292
293/* 293
294 Close the file in zip opened with unzOpenCurrentFile 294extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
295 Return UNZ_CRCERROR if all the file was read but the CRC is not good 295/*
296*/ 296 Close the file in zip opened with unzOpenCurrentFile
297 297 Return UNZ_CRCERROR if all the file was read but the CRC is not good
298extern int ZEXPORT unzReadCurrentFile OF((unzFile file, 298*/
299 voidp buf, 299
300 unsigned len)); 300extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
301/* 301 voidp buf,
302 Read bytes from the current file (opened by unzOpenCurrentFile) 302 unsigned len));
303 buf contain buffer where data must be copied 303/*
304 len the size of buf. 304 Read bytes from the current file (opened by unzOpenCurrentFile)
305 305 buf contain buffer where data must be copied
306 return the number of byte copied if somes bytes are copied 306 len the size of buf.
307 return 0 if the end of file was reached 307
308 return <0 with error code if there is an error 308 return the number of byte copied if somes bytes are copied
309 (UNZ_ERRNO for IO error, or zLib error for uncompress error) 309 return 0 if the end of file was reached
310*/ 310 return <0 with error code if there is an error
311 311 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
312extern z_off_t ZEXPORT unztell OF((unzFile file)); 312*/
313/* 313
314 Give the current position in uncompressed data 314extern z_off_t ZEXPORT unztell OF((unzFile file));
315*/ 315/*
316 316 Give the current position in uncompressed data
317extern int ZEXPORT unzeof OF((unzFile file)); 317*/
318/* 318
319 return 1 if the end of file was reached, 0 elsewhere 319extern int ZEXPORT unzeof OF((unzFile file));
320*/ 320/*
321 321 return 1 if the end of file was reached, 0 elsewhere
322extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, 322*/
323 voidp buf, 323
324 unsigned len)); 324extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
325/* 325 voidp buf,
326 Read extra field from the current file (opened by unzOpenCurrentFile) 326 unsigned len));
327 This is the local-header version of the extra field (sometimes, there is 327/*
328 more info in the local-header version than in the central-header) 328 Read extra field from the current file (opened by unzOpenCurrentFile)
329 329 This is the local-header version of the extra field (sometimes, there is
330 if buf==NULL, it return the size of the local extra field 330 more info in the local-header version than in the central-header)
331 331
332 if buf!=NULL, len is the size of the buffer, the extra header is copied in 332 if buf==NULL, it return the size of the local extra field
333 buf. 333
334 the return value is the number of bytes copied in buf, or (if <0) 334 if buf!=NULL, len is the size of the buffer, the extra header is copied in
335 the error code 335 buf.
336*/ 336 the return value is the number of bytes copied in buf, or (if <0)
337 337 the error code
338/***************************************************************************/ 338*/
339 339
340/* Get the current file offset */ 340/***************************************************************************/
341extern uLong ZEXPORT unzGetOffset (unzFile file); 341
342 342/* Get the current file offset */
343/* Set the current file offset */ 343extern uLong ZEXPORT unzGetOffset (unzFile file);
344extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); 344
345 345/* Set the current file offset */
346 346extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
347 347
348#ifdef __cplusplus 348
349} 349
350#endif 350#ifdef __cplusplus
351 351}
352#endif /* _unz_H */ 352#endif
353
354#endif /* _unz_H */
diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
index 2ccd7fd..400e2ba 100644
--- a/contrib/minizip/zip.c
+++ b/contrib/minizip/zip.c
@@ -1,1188 +1,1219 @@
1/* zip.c -- IO on .zip files using zlib 1/* zip.c -- IO on .zip files using zlib
2 Version 1.01, May 8th, 2004 2 Version 1.01e, February 12th, 2005
3 3
4 Copyright (C) 1998-2004 Gilles Vollant 4 27 Dec 2004 Rolf Kalbermatter
5 5 Modification to zipOpen2 to support globalComment retrieval.
6 Read zip.h for more info 6
7*/ 7 Copyright (C) 1998-2005 Gilles Vollant
8 8
9 9 Read zip.h for more info
10#include <stdio.h> 10*/
11#include <stdlib.h> 11
12#include <string.h> 12
13#include <time.h> 13#include <stdio.h>
14#include "zlib.h" 14#include <stdlib.h>
15#include "zip.h" 15#include <string.h>
16 16#include <time.h>
17#ifdef STDC 17#include "zlib.h"
18# include <stddef.h> 18#include "zip.h"
19# include <string.h> 19
20# include <stdlib.h> 20#ifdef STDC
21#endif 21# include <stddef.h>
22#ifdef NO_ERRNO_H 22# include <string.h>
23 extern int errno; 23# include <stdlib.h>
24#else 24#endif
25# include <errno.h> 25#ifdef NO_ERRNO_H
26#endif 26 extern int errno;
27 27#else
28 28# include <errno.h>
29#ifndef local 29#endif
30# define local static 30
31#endif 31
32/* compile with -Dlocal if your debugger can't find static symbols */ 32#ifndef local
33 33# define local static
34#ifndef VERSIONMADEBY 34#endif
35# define VERSIONMADEBY (0x0) /* platform depedent */ 35/* compile with -Dlocal if your debugger can't find static symbols */
36#endif 36
37 37#ifndef VERSIONMADEBY
38#ifndef Z_BUFSIZE 38# define VERSIONMADEBY (0x0) /* platform depedent */
39#define Z_BUFSIZE (16384) 39#endif
40#endif 40
41 41#ifndef Z_BUFSIZE
42#ifndef Z_MAXFILENAMEINZIP 42#define Z_BUFSIZE (16384)
43#define Z_MAXFILENAMEINZIP (256) 43#endif
44#endif 44
45 45#ifndef Z_MAXFILENAMEINZIP
46#ifndef ALLOC 46#define Z_MAXFILENAMEINZIP (256)
47# define ALLOC(size) (malloc(size)) 47#endif
48#endif 48
49#ifndef TRYFREE 49#ifndef ALLOC
50# define TRYFREE(p) {if (p) free(p);} 50# define ALLOC(size) (malloc(size))
51#endif 51#endif
52 52#ifndef TRYFREE
53/* 53# define TRYFREE(p) {if (p) free(p);}
54#define SIZECENTRALDIRITEM (0x2e) 54#endif
55#define SIZEZIPLOCALHEADER (0x1e) 55
56*/ 56/*
57 57#define SIZECENTRALDIRITEM (0x2e)
58/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ 58#define SIZEZIPLOCALHEADER (0x1e)
59 59*/
60#ifndef SEEK_CUR 60
61#define SEEK_CUR 1 61/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
62#endif 62
63 63#ifndef SEEK_CUR
64#ifndef SEEK_END 64#define SEEK_CUR 1
65#define SEEK_END 2 65#endif
66#endif 66
67 67#ifndef SEEK_END
68#ifndef SEEK_SET 68#define SEEK_END 2
69#define SEEK_SET 0 69#endif
70#endif 70
71 71#ifndef SEEK_SET
72#ifndef DEF_MEM_LEVEL 72#define SEEK_SET 0
73#if MAX_MEM_LEVEL >= 8 73#endif
74# define DEF_MEM_LEVEL 8 74
75#else 75#ifndef DEF_MEM_LEVEL
76# define DEF_MEM_LEVEL MAX_MEM_LEVEL 76#if MAX_MEM_LEVEL >= 8
77#endif 77# define DEF_MEM_LEVEL 8
78#endif 78#else
79const char zip_copyright[] = 79# define DEF_MEM_LEVEL MAX_MEM_LEVEL
80 " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; 80#endif
81 81#endif
82 82const char zip_copyright[] =
83#define SIZEDATA_INDATABLOCK (4096-(4*4)) 83 " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
84 84
85#define LOCALHEADERMAGIC (0x04034b50) 85
86#define CENTRALHEADERMAGIC (0x02014b50) 86#define SIZEDATA_INDATABLOCK (4096-(4*4))
87#define ENDHEADERMAGIC (0x06054b50) 87
88 88#define LOCALHEADERMAGIC (0x04034b50)
89#define FLAG_LOCALHEADER_OFFSET (0x06) 89#define CENTRALHEADERMAGIC (0x02014b50)
90#define CRC_LOCALHEADER_OFFSET (0x0e) 90#define ENDHEADERMAGIC (0x06054b50)
91 91
92#define SIZECENTRALHEADER (0x2e) /* 46 */ 92#define FLAG_LOCALHEADER_OFFSET (0x06)
93 93#define CRC_LOCALHEADER_OFFSET (0x0e)
94typedef struct linkedlist_datablock_internal_s 94
95{ 95#define SIZECENTRALHEADER (0x2e) /* 46 */
96 struct linkedlist_datablock_internal_s* next_datablock; 96
97 uLong avail_in_this_block; 97typedef struct linkedlist_datablock_internal_s
98 uLong filled_in_this_block; 98{
99 uLong unused; /* for future use and alignement */ 99 struct linkedlist_datablock_internal_s* next_datablock;
100 unsigned char data[SIZEDATA_INDATABLOCK]; 100 uLong avail_in_this_block;
101} linkedlist_datablock_internal; 101 uLong filled_in_this_block;
102 102 uLong unused; /* for future use and alignement */
103typedef struct linkedlist_data_s 103 unsigned char data[SIZEDATA_INDATABLOCK];
104{ 104} linkedlist_datablock_internal;
105 linkedlist_datablock_internal* first_block; 105
106 linkedlist_datablock_internal* last_block; 106typedef struct linkedlist_data_s
107} linkedlist_data; 107{
108 108 linkedlist_datablock_internal* first_block;
109 109 linkedlist_datablock_internal* last_block;
110typedef struct 110} linkedlist_data;
111{ 111
112 z_stream stream; /* zLib stream structure for inflate */ 112
113 int stream_initialised; /* 1 is stream is initialised */ 113typedef struct
114 uInt pos_in_buffered_data; /* last written byte in buffered_data */ 114{
115 115 z_stream stream; /* zLib stream structure for inflate */
116 uLong pos_local_header; /* offset of the local header of the file 116 int stream_initialised; /* 1 is stream is initialised */
117 currenty writing */ 117 uInt pos_in_buffered_data; /* last written byte in buffered_data */
118 char* central_header; /* central header data for the current file */ 118
119 uLong size_centralheader; /* size of the central header for cur file */ 119 uLong pos_local_header; /* offset of the local header of the file
120 uLong flag; /* flag of the file currently writing */ 120 currenty writing */
121 121 char* central_header; /* central header data for the current file */
122 int method; /* compression method of file currenty wr.*/ 122 uLong size_centralheader; /* size of the central header for cur file */
123 int raw; /* 1 for directly writing raw data */ 123 uLong flag; /* flag of the file currently writing */
124 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ 124
125 uLong dosDate; 125 int method; /* compression method of file currenty wr.*/
126 uLong crc32; 126 int raw; /* 1 for directly writing raw data */
127 int encrypt; 127 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
128#ifndef NOCRYPT 128 uLong dosDate;
129 unsigned long keys[3]; /* keys defining the pseudo-random sequence */ 129 uLong crc32;
130 const unsigned long* pcrc_32_tab; 130 int encrypt;
131 int crypt_header_size; 131#ifndef NOCRYPT
132#endif 132 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
133} curfile_info; 133 const unsigned long* pcrc_32_tab;
134 134 int crypt_header_size;
135typedef struct 135#endif
136{ 136} curfile_info;
137 zlib_filefunc_def z_filefunc; 137
138 voidpf filestream; /* io structore of the zipfile */ 138typedef struct
139 linkedlist_data central_dir;/* datablock with central dir in construction*/ 139{
140 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ 140 zlib_filefunc_def z_filefunc;
141 curfile_info ci; /* info on the file curretly writing */ 141 voidpf filestream; /* io structore of the zipfile */
142 142 linkedlist_data central_dir;/* datablock with central dir in construction*/
143 uLong begin_pos; /* position of the beginning of the zipfile */ 143 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
144 uLong add_position_when_writting_offset; 144 curfile_info ci; /* info on the file curretly writing */
145 uLong number_entry; 145
146} zip_internal; 146 uLong begin_pos; /* position of the beginning of the zipfile */
147 147 uLong add_position_when_writting_offset;
148 148 uLong number_entry;
149 149#ifndef NO_ADDFILEINEXISTINGZIP
150#ifndef NOCRYPT 150 char *globalcomment;
151#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED 151#endif
152#include "crypt.h" 152} zip_internal;
153#endif 153
154 154
155local linkedlist_datablock_internal* allocate_new_datablock() 155
156{ 156#ifndef NOCRYPT
157 linkedlist_datablock_internal* ldi; 157#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
158 ldi = (linkedlist_datablock_internal*) 158#include "crypt.h"
159 ALLOC(sizeof(linkedlist_datablock_internal)); 159#endif
160 if (ldi!=NULL) 160
161 { 161local linkedlist_datablock_internal* allocate_new_datablock()
162 ldi->next_datablock = NULL ; 162{
163 ldi->filled_in_this_block = 0 ; 163 linkedlist_datablock_internal* ldi;
164 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; 164 ldi = (linkedlist_datablock_internal*)
165 } 165 ALLOC(sizeof(linkedlist_datablock_internal));
166 return ldi; 166 if (ldi!=NULL)
167} 167 {
168 168 ldi->next_datablock = NULL ;
169local void free_datablock(ldi) 169 ldi->filled_in_this_block = 0 ;
170 linkedlist_datablock_internal* ldi; 170 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
171{ 171 }
172 while (ldi!=NULL) 172 return ldi;
173 { 173}
174 linkedlist_datablock_internal* ldinext = ldi->next_datablock; 174
175 TRYFREE(ldi); 175local void free_datablock(ldi)
176 ldi = ldinext; 176 linkedlist_datablock_internal* ldi;
177 } 177{
178} 178 while (ldi!=NULL)
179 179 {
180local void init_linkedlist(ll) 180 linkedlist_datablock_internal* ldinext = ldi->next_datablock;
181 linkedlist_data* ll; 181 TRYFREE(ldi);
182{ 182 ldi = ldinext;
183 ll->first_block = ll->last_block = NULL; 183 }
184} 184}
185 185
186local void free_linkedlist(ll) 186local void init_linkedlist(ll)
187 linkedlist_data* ll; 187 linkedlist_data* ll;
188{ 188{
189 free_datablock(ll->first_block); 189 ll->first_block = ll->last_block = NULL;
190 ll->first_block = ll->last_block = NULL; 190}
191} 191
192 192local void free_linkedlist(ll)
193 193 linkedlist_data* ll;
194local int add_data_in_datablock(ll,buf,len) 194{
195 linkedlist_data* ll; 195 free_datablock(ll->first_block);
196 const void* buf; 196 ll->first_block = ll->last_block = NULL;
197 uLong len; 197}
198{ 198
199 linkedlist_datablock_internal* ldi; 199
200 const unsigned char* from_copy; 200local int add_data_in_datablock(ll,buf,len)
201 201 linkedlist_data* ll;
202 if (ll==NULL) 202 const void* buf;
203 return ZIP_INTERNALERROR; 203 uLong len;
204 204{
205 if (ll->last_block == NULL) 205 linkedlist_datablock_internal* ldi;
206 { 206 const unsigned char* from_copy;
207 ll->first_block = ll->last_block = allocate_new_datablock(); 207
208 if (ll->first_block == NULL) 208 if (ll==NULL)
209 return ZIP_INTERNALERROR; 209 return ZIP_INTERNALERROR;
210 } 210
211 211 if (ll->last_block == NULL)
212 ldi = ll->last_block; 212 {
213 from_copy = (unsigned char*)buf; 213 ll->first_block = ll->last_block = allocate_new_datablock();
214 214 if (ll->first_block == NULL)
215 while (len>0) 215 return ZIP_INTERNALERROR;
216 { 216 }
217 uInt copy_this; 217
218 uInt i; 218 ldi = ll->last_block;
219 unsigned char* to_copy; 219 from_copy = (unsigned char*)buf;
220 220
221 if (ldi->avail_in_this_block==0) 221 while (len>0)
222 { 222 {
223 ldi->next_datablock = allocate_new_datablock(); 223 uInt copy_this;
224 if (ldi->next_datablock == NULL) 224 uInt i;
225 return ZIP_INTERNALERROR; 225 unsigned char* to_copy;
226 ldi = ldi->next_datablock ; 226
227 ll->last_block = ldi; 227 if (ldi->avail_in_this_block==0)
228 } 228 {
229 229 ldi->next_datablock = allocate_new_datablock();
230 if (ldi->avail_in_this_block < len) 230 if (ldi->next_datablock == NULL)
231 copy_this = (uInt)ldi->avail_in_this_block; 231 return ZIP_INTERNALERROR;
232 else 232 ldi = ldi->next_datablock ;
233 copy_this = (uInt)len; 233 ll->last_block = ldi;
234 234 }
235 to_copy = &(ldi->data[ldi->filled_in_this_block]); 235
236 236 if (ldi->avail_in_this_block < len)
237 for (i=0;i<copy_this;i++) 237 copy_this = (uInt)ldi->avail_in_this_block;
238 *(to_copy+i)=*(from_copy+i); 238 else
239 239 copy_this = (uInt)len;
240 ldi->filled_in_this_block += copy_this; 240
241 ldi->avail_in_this_block -= copy_this; 241 to_copy = &(ldi->data[ldi->filled_in_this_block]);
242 from_copy += copy_this ; 242
243 len -= copy_this; 243 for (i=0;i<copy_this;i++)
244 } 244 *(to_copy+i)=*(from_copy+i);
245 return ZIP_OK; 245
246} 246 ldi->filled_in_this_block += copy_this;
247 247 ldi->avail_in_this_block -= copy_this;
248 248 from_copy += copy_this ;
249 249 len -= copy_this;
250/****************************************************************************/ 250 }
251 251 return ZIP_OK;
252#ifndef NO_ADDFILEINEXISTINGZIP 252}
253/* =========================================================================== 253
254 Inputs a long in LSB order to the given file 254
255 nbByte == 1, 2 or 4 (byte, short or long) 255
256*/ 256/****************************************************************************/
257 257
258local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def, 258#ifndef NO_ADDFILEINEXISTINGZIP
259 voidpf filestream, uLong x, int nbByte)); 259/* ===========================================================================
260local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte) 260 Inputs a long in LSB order to the given file
261 const zlib_filefunc_def* pzlib_filefunc_def; 261 nbByte == 1, 2 or 4 (byte, short or long)
262 voidpf filestream; 262*/
263 uLong x; 263
264 int nbByte; 264local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
265{ 265 voidpf filestream, uLong x, int nbByte));
266 unsigned char buf[4]; 266local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
267 int n; 267 const zlib_filefunc_def* pzlib_filefunc_def;
268 for (n = 0; n < nbByte; n++) 268 voidpf filestream;
269 { 269 uLong x;
270 buf[n] = (unsigned char)(x & 0xff); 270 int nbByte;
271 x >>= 8; 271{
272 } 272 unsigned char buf[4];
273 if (x != 0) 273 int n;
274 { /* data overflow - hack for ZIP64 (X Roche) */ 274 for (n = 0; n < nbByte; n++)
275 for (n = 0; n < nbByte; n++) 275 {
276 { 276 buf[n] = (unsigned char)(x & 0xff);
277 buf[n] = 0xff; 277 x >>= 8;
278 } 278 }
279 } 279 if (x != 0)
280 280 { /* data overflow - hack for ZIP64 (X Roche) */
281 if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) 281 for (n = 0; n < nbByte; n++)
282 return ZIP_ERRNO; 282 {
283 else 283 buf[n] = 0xff;
284 return ZIP_OK; 284 }
285} 285 }
286 286
287local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte)); 287 if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
288local void ziplocal_putValue_inmemory (dest, x, nbByte) 288 return ZIP_ERRNO;
289 void* dest; 289 else
290 uLong x; 290 return ZIP_OK;
291 int nbByte; 291}
292{ 292
293 unsigned char* buf=(unsigned char*)dest; 293local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
294 int n; 294local void ziplocal_putValue_inmemory (dest, x, nbByte)
295 for (n = 0; n < nbByte; n++) { 295 void* dest;
296 buf[n] = (unsigned char)(x & 0xff); 296 uLong x;
297 x >>= 8; 297 int nbByte;
298 } 298{
299 299 unsigned char* buf=(unsigned char*)dest;
300 if (x != 0) 300 int n;
301 { /* data overflow - hack for ZIP64 */ 301 for (n = 0; n < nbByte; n++) {
302 for (n = 0; n < nbByte; n++) 302 buf[n] = (unsigned char)(x & 0xff);
303 { 303 x >>= 8;
304 buf[n] = 0xff; 304 }
305 } 305
306 } 306 if (x != 0)
307} 307 { /* data overflow - hack for ZIP64 */
308 308 for (n = 0; n < nbByte; n++)
309/****************************************************************************/ 309 {
310 310 buf[n] = 0xff;
311 311 }
312local uLong ziplocal_TmzDateToDosDate(ptm,dosDate) 312 }
313 const tm_zip* ptm; 313}
314 uLong dosDate; 314
315{ 315/****************************************************************************/
316 uLong year = (uLong)ptm->tm_year; 316
317 if (year>1980) 317
318 year-=1980; 318local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
319 else if (year>80) 319 const tm_zip* ptm;
320 year-=80; 320 uLong dosDate;
321 return 321{
322 (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | 322 uLong year = (uLong)ptm->tm_year;
323 ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); 323 if (year>1980)
324} 324 year-=1980;
325 325 else if (year>80)
326 326 year-=80;
327/****************************************************************************/ 327 return
328 328 (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
329local int ziplocal_getByte OF(( 329 ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
330 const zlib_filefunc_def* pzlib_filefunc_def, 330}
331 voidpf filestream, 331
332 int *pi)); 332
333 333/****************************************************************************/
334local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi) 334
335 const zlib_filefunc_def* pzlib_filefunc_def; 335local int ziplocal_getByte OF((
336 voidpf filestream; 336 const zlib_filefunc_def* pzlib_filefunc_def,
337 int *pi; 337 voidpf filestream,
338{ 338 int *pi));
339 unsigned char c; 339
340 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); 340local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
341 if (err==1) 341 const zlib_filefunc_def* pzlib_filefunc_def;
342 { 342 voidpf filestream;
343 *pi = (int)c; 343 int *pi;
344 return ZIP_OK; 344{
345 } 345 unsigned char c;
346 else 346 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
347 { 347 if (err==1)
348 if (ZERROR(*pzlib_filefunc_def,filestream)) 348 {
349 return ZIP_ERRNO; 349 *pi = (int)c;
350 else 350 return ZIP_OK;
351 return ZIP_EOF; 351 }
352 } 352 else
353} 353 {
354 354 if (ZERROR(*pzlib_filefunc_def,filestream))
355 355 return ZIP_ERRNO;
356/* =========================================================================== 356 else
357 Reads a long in LSB order from the given gz_stream. Sets 357 return ZIP_EOF;
358*/ 358 }
359local int ziplocal_getShort OF(( 359}
360 const zlib_filefunc_def* pzlib_filefunc_def, 360
361 voidpf filestream, 361
362 uLong *pX)); 362/* ===========================================================================
363 363 Reads a long in LSB order from the given gz_stream. Sets
364local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX) 364*/
365 const zlib_filefunc_def* pzlib_filefunc_def; 365local int ziplocal_getShort OF((
366 voidpf filestream; 366 const zlib_filefunc_def* pzlib_filefunc_def,
367 uLong *pX; 367 voidpf filestream,
368{ 368 uLong *pX));
369 uLong x ; 369
370 int i; 370local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
371 int err; 371 const zlib_filefunc_def* pzlib_filefunc_def;
372 372 voidpf filestream;
373 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 373 uLong *pX;
374 x = (uLong)i; 374{
375 375 uLong x ;
376 if (err==ZIP_OK) 376 int i;
377 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 377 int err;
378 x += ((uLong)i)<<8; 378
379 379 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
380 if (err==ZIP_OK) 380 x = (uLong)i;
381 *pX = x; 381
382 else 382 if (err==ZIP_OK)
383 *pX = 0; 383 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
384 return err; 384 x += ((uLong)i)<<8;
385} 385
386 386 if (err==ZIP_OK)
387local int ziplocal_getLong OF(( 387 *pX = x;
388 const zlib_filefunc_def* pzlib_filefunc_def, 388 else
389 voidpf filestream, 389 *pX = 0;
390 uLong *pX)); 390 return err;
391 391}
392local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX) 392
393 const zlib_filefunc_def* pzlib_filefunc_def; 393local int ziplocal_getLong OF((
394 voidpf filestream; 394 const zlib_filefunc_def* pzlib_filefunc_def,
395 uLong *pX; 395 voidpf filestream,
396{ 396 uLong *pX));
397 uLong x ; 397
398 int i; 398local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
399 int err; 399 const zlib_filefunc_def* pzlib_filefunc_def;
400 400 voidpf filestream;
401 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 401 uLong *pX;
402 x = (uLong)i; 402{
403 403 uLong x ;
404 if (err==ZIP_OK) 404 int i;
405 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 405 int err;
406 x += ((uLong)i)<<8; 406
407 407 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
408 if (err==ZIP_OK) 408 x = (uLong)i;
409 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 409
410 x += ((uLong)i)<<16; 410 if (err==ZIP_OK)
411 411 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
412 if (err==ZIP_OK) 412 x += ((uLong)i)<<8;
413 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 413
414 x += ((uLong)i)<<24; 414 if (err==ZIP_OK)
415 415 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
416 if (err==ZIP_OK) 416 x += ((uLong)i)<<16;
417 *pX = x; 417
418 else 418 if (err==ZIP_OK)
419 *pX = 0; 419 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
420 return err; 420 x += ((uLong)i)<<24;
421} 421
422 422 if (err==ZIP_OK)
423#ifndef BUFREADCOMMENT 423 *pX = x;
424#define BUFREADCOMMENT (0x400) 424 else
425#endif 425 *pX = 0;
426/* 426 return err;
427 Locate the Central directory of a zipfile (at the end, just before 427}
428 the global comment) 428
429*/ 429#ifndef BUFREADCOMMENT
430local uLong ziplocal_SearchCentralDir OF(( 430#define BUFREADCOMMENT (0x400)
431 const zlib_filefunc_def* pzlib_filefunc_def, 431#endif
432 voidpf filestream)); 432/*
433 433 Locate the Central directory of a zipfile (at the end, just before
434local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream) 434 the global comment)
435 const zlib_filefunc_def* pzlib_filefunc_def; 435*/
436 voidpf filestream; 436local uLong ziplocal_SearchCentralDir OF((
437{ 437 const zlib_filefunc_def* pzlib_filefunc_def,
438 unsigned char* buf; 438 voidpf filestream));
439 uLong uSizeFile; 439
440 uLong uBackRead; 440local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
441 uLong uMaxBack=0xffff; /* maximum size of global comment */ 441 const zlib_filefunc_def* pzlib_filefunc_def;
442 uLong uPosFound=0; 442 voidpf filestream;
443 443{
444 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) 444 unsigned char* buf;
445 return 0; 445 uLong uSizeFile;
446 446 uLong uBackRead;
447 447 uLong uMaxBack=0xffff; /* maximum size of global comment */
448 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); 448 uLong uPosFound=0;
449 449
450 if (uMaxBack>uSizeFile) 450 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
451 uMaxBack = uSizeFile; 451 return 0;
452 452
453 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); 453
454 if (buf==NULL) 454 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
455 return 0; 455
456 456 if (uMaxBack>uSizeFile)
457 uBackRead = 4; 457 uMaxBack = uSizeFile;
458 while (uBackRead<uMaxBack) 458
459 { 459 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
460 uLong uReadSize,uReadPos ; 460 if (buf==NULL)
461 int i; 461 return 0;
462 if (uBackRead+BUFREADCOMMENT>uMaxBack) 462
463 uBackRead = uMaxBack; 463 uBackRead = 4;
464 else 464 while (uBackRead<uMaxBack)
465 uBackRead+=BUFREADCOMMENT; 465 {
466 uReadPos = uSizeFile-uBackRead ; 466 uLong uReadSize,uReadPos ;
467 467 int i;
468 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 468 if (uBackRead+BUFREADCOMMENT>uMaxBack)
469 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); 469 uBackRead = uMaxBack;
470 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) 470 else
471 break; 471 uBackRead+=BUFREADCOMMENT;
472 472 uReadPos = uSizeFile-uBackRead ;
473 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) 473
474 break; 474 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
475 475 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
476 for (i=(int)uReadSize-3; (i--)>0;) 476 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
477 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 477 break;
478 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) 478
479 { 479 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
480 uPosFound = uReadPos+i; 480 break;
481 break; 481
482 } 482 for (i=(int)uReadSize-3; (i--)>0;)
483 483 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
484 if (uPosFound!=0) 484 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
485 break; 485 {
486 } 486 uPosFound = uReadPos+i;
487 TRYFREE(buf); 487 break;
488 return uPosFound; 488 }
489} 489
490#endif /* !NO_ADDFILEINEXISTINGZIP*/ 490 if (uPosFound!=0)
491 491 break;
492/************************************************************/ 492 }
493extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def) 493 TRYFREE(buf);
494 const char *pathname; 494 return uPosFound;
495 int append; 495}
496 zipcharpc* globalcomment; 496#endif /* !NO_ADDFILEINEXISTINGZIP*/
497 zlib_filefunc_def* pzlib_filefunc_def; 497
498{ 498/************************************************************/
499 zip_internal ziinit; 499extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
500 zip_internal* zi; 500 const char *pathname;
501 int err=ZIP_OK; 501 int append;
502 502 zipcharpc* globalcomment;
503 503 zlib_filefunc_def* pzlib_filefunc_def;
504 if (pzlib_filefunc_def==NULL) 504{
505 fill_fopen_filefunc(&ziinit.z_filefunc); 505 zip_internal ziinit;
506 else 506 zip_internal* zi;
507 ziinit.z_filefunc = *pzlib_filefunc_def; 507 int err=ZIP_OK;
508 508
509 ziinit.filestream = (*(ziinit.z_filefunc.zopen_file)) 509
510 (ziinit.z_filefunc.opaque, 510 if (pzlib_filefunc_def==NULL)
511 pathname, 511 fill_fopen_filefunc(&ziinit.z_filefunc);
512 (append == APPEND_STATUS_CREATE) ? 512 else
513 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : 513 ziinit.z_filefunc = *pzlib_filefunc_def;
514 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); 514
515 515 ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
516 if (ziinit.filestream == NULL) 516 (ziinit.z_filefunc.opaque,
517 return NULL; 517 pathname,
518 ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream); 518 (append == APPEND_STATUS_CREATE) ?
519 ziinit.in_opened_file_inzip = 0; 519 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
520 ziinit.ci.stream_initialised = 0; 520 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
521 ziinit.number_entry = 0; 521
522 ziinit.add_position_when_writting_offset = 0; 522 if (ziinit.filestream == NULL)
523 init_linkedlist(&(ziinit.central_dir)); 523 return NULL;
524 524 ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
525 525 ziinit.in_opened_file_inzip = 0;
526 zi = (zip_internal*)ALLOC(sizeof(zip_internal)); 526 ziinit.ci.stream_initialised = 0;
527 if (zi==NULL) 527 ziinit.number_entry = 0;
528 { 528 ziinit.add_position_when_writting_offset = 0;
529 ZCLOSE(ziinit.z_filefunc,ziinit.filestream); 529 init_linkedlist(&(ziinit.central_dir));
530 return NULL; 530
531 } 531
532 532 zi = (zip_internal*)ALLOC(sizeof(zip_internal));
533 /* now we add file in a zipfile */ 533 if (zi==NULL)
534# ifndef NO_ADDFILEINEXISTINGZIP 534 {
535 if (append == APPEND_STATUS_ADDINZIP) 535 ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
536 { 536 return NULL;
537 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 537 }
538 538
539 uLong size_central_dir; /* size of the central directory */ 539 /* now we add file in a zipfile */
540 uLong offset_central_dir; /* offset of start of central directory */ 540# ifndef NO_ADDFILEINEXISTINGZIP
541 uLong central_pos,uL; 541 ziinit.globalcomment = NULL;
542 542 if (append == APPEND_STATUS_ADDINZIP)
543 uLong number_disk; /* number of the current dist, used for 543 {
544 spaning ZIP, unsupported, always 0*/ 544 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
545 uLong number_disk_with_CD; /* number the the disk with central dir, used 545
546 for spaning ZIP, unsupported, always 0*/ 546 uLong size_central_dir; /* size of the central directory */
547 uLong number_entry; 547 uLong offset_central_dir; /* offset of start of central directory */
548 uLong number_entry_CD; /* total number of entries in 548 uLong central_pos,uL;
549 the central dir 549
550 (same than number_entry on nospan) */ 550 uLong number_disk; /* number of the current dist, used for
551 uLong size_comment; 551 spaning ZIP, unsupported, always 0*/
552 552 uLong number_disk_with_CD; /* number the the disk with central dir, used
553 central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream); 553 for spaning ZIP, unsupported, always 0*/
554 if (central_pos==0) 554 uLong number_entry;
555 err=ZIP_ERRNO; 555 uLong number_entry_CD; /* total number of entries in
556 556 the central dir
557 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, 557 (same than number_entry on nospan) */
558 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) 558 uLong size_comment;
559 err=ZIP_ERRNO; 559
560 560 central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
561 /* the signature, already checked */ 561 if (central_pos==0)
562 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK) 562 err=ZIP_ERRNO;
563 err=ZIP_ERRNO; 563
564 564 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
565 /* number of this disk */ 565 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
566 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK) 566 err=ZIP_ERRNO;
567 err=ZIP_ERRNO; 567
568 568 /* the signature, already checked */
569 /* number of the disk with the start of the central directory */ 569 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
570 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK) 570 err=ZIP_ERRNO;
571 err=ZIP_ERRNO; 571
572 572 /* number of this disk */
573 /* total number of entries in the central dir on this disk */ 573 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
574 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK) 574 err=ZIP_ERRNO;
575 err=ZIP_ERRNO; 575
576 576 /* number of the disk with the start of the central directory */
577 /* total number of entries in the central dir */ 577 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
578 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK) 578 err=ZIP_ERRNO;
579 err=ZIP_ERRNO; 579
580 580 /* total number of entries in the central dir on this disk */
581 if ((number_entry_CD!=number_entry) || 581 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
582 (number_disk_with_CD!=0) || 582 err=ZIP_ERRNO;
583 (number_disk!=0)) 583
584 err=ZIP_BADZIPFILE; 584 /* total number of entries in the central dir */
585 585 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
586 /* size of the central directory */ 586 err=ZIP_ERRNO;
587 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK) 587
588 err=ZIP_ERRNO; 588 if ((number_entry_CD!=number_entry) ||
589 589 (number_disk_with_CD!=0) ||
590 /* offset of start of central directory with respect to the 590 (number_disk!=0))
591 starting disk number */ 591 err=ZIP_BADZIPFILE;
592 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK) 592
593 err=ZIP_ERRNO; 593 /* size of the central directory */
594 594 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
595 /* zipfile comment length */ 595 err=ZIP_ERRNO;
596 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK) 596
597 err=ZIP_ERRNO; 597 /* offset of start of central directory with respect to the
598 598 starting disk number */
599 if ((central_pos<offset_central_dir+size_central_dir) && 599 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
600 (err==ZIP_OK)) 600 err=ZIP_ERRNO;
601 err=ZIP_BADZIPFILE; 601
602 602 /* zipfile global comment length */
603 if (err!=ZIP_OK) 603 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
604 { 604 err=ZIP_ERRNO;
605 ZCLOSE(ziinit.z_filefunc, ziinit.filestream); 605
606 return NULL; 606 if ((central_pos<offset_central_dir+size_central_dir) &&
607 } 607 (err==ZIP_OK))
608 608 err=ZIP_BADZIPFILE;
609 byte_before_the_zipfile = central_pos - 609
610 (offset_central_dir+size_central_dir); 610 if (err!=ZIP_OK)
611 ziinit.add_position_when_writting_offset = byte_before_the_zipfile ; 611 {
612 612 ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
613 { 613 return NULL;
614 uLong size_central_dir_to_read = size_central_dir; 614 }
615 size_t buf_size = SIZEDATA_INDATABLOCK; 615
616 void* buf_read = (void*)ALLOC(buf_size); 616 if (size_comment>0)
617 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, 617 {
618 offset_central_dir + byte_before_the_zipfile, 618 ziinit.globalcomment = ALLOC(size_comment+1);
619 ZLIB_FILEFUNC_SEEK_SET) != 0) 619 if (ziinit.globalcomment)
620 err=ZIP_ERRNO; 620 {
621 621 size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
622 while ((size_central_dir_to_read>0) && (err==ZIP_OK)) 622 ziinit.globalcomment[size_comment]=0;
623 { 623 }
624 uLong read_this = SIZEDATA_INDATABLOCK; 624 }
625 if (read_this > size_central_dir_to_read) 625
626 read_this = size_central_dir_to_read; 626 byte_before_the_zipfile = central_pos -
627 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this) 627 (offset_central_dir+size_central_dir);
628 err=ZIP_ERRNO; 628 ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
629 629
630 if (err==ZIP_OK) 630 {
631 err = add_data_in_datablock(&ziinit.central_dir,buf_read, 631 uLong size_central_dir_to_read = size_central_dir;
632 (uLong)read_this); 632 size_t buf_size = SIZEDATA_INDATABLOCK;
633 size_central_dir_to_read-=read_this; 633 void* buf_read = (void*)ALLOC(buf_size);
634 } 634 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
635 TRYFREE(buf_read); 635 offset_central_dir + byte_before_the_zipfile,
636 } 636 ZLIB_FILEFUNC_SEEK_SET) != 0)
637 ziinit.begin_pos = byte_before_the_zipfile; 637 err=ZIP_ERRNO;
638 ziinit.number_entry = number_entry_CD; 638
639 639 while ((size_central_dir_to_read>0) && (err==ZIP_OK))
640 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, 640 {
641 offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) 641 uLong read_this = SIZEDATA_INDATABLOCK;
642 err=ZIP_ERRNO; 642 if (read_this > size_central_dir_to_read)
643 } 643 read_this = size_central_dir_to_read;
644# endif /* !NO_ADDFILEINEXISTINGZIP*/ 644 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
645 645 err=ZIP_ERRNO;
646 if (err != ZIP_OK) 646
647 { 647 if (err==ZIP_OK)
648 TRYFREE(zi); 648 err = add_data_in_datablock(&ziinit.central_dir,buf_read,
649 return NULL; 649 (uLong)read_this);
650 } 650 size_central_dir_to_read-=read_this;
651 else 651 }
652 { 652 TRYFREE(buf_read);
653 *zi = ziinit; 653 }
654 return (zipFile)zi; 654 ziinit.begin_pos = byte_before_the_zipfile;
655 } 655 ziinit.number_entry = number_entry_CD;
656} 656
657 657 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
658extern zipFile ZEXPORT zipOpen (pathname, append) 658 offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
659 const char *pathname; 659 err=ZIP_ERRNO;
660 int append; 660 }
661{ 661
662 return zipOpen2(pathname,append,NULL,NULL); 662 if (globalcomment)
663} 663 {
664 664 *globalcomment = ziinit.globalcomment;
665extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, 665 }
666 extrafield_local, size_extrafield_local, 666# endif /* !NO_ADDFILEINEXISTINGZIP*/
667 extrafield_global, size_extrafield_global, 667
668 comment, method, level, raw, 668 if (err != ZIP_OK)
669 windowBits, memLevel, strategy, 669 {
670 password, crcForCrypting) 670# ifndef NO_ADDFILEINEXISTINGZIP
671 zipFile file; 671 TRYFREE(ziinit.globalcomment);
672 const char* filename; 672# endif /* !NO_ADDFILEINEXISTINGZIP*/
673 const zip_fileinfo* zipfi; 673 TRYFREE(zi);
674 const void* extrafield_local; 674 return NULL;
675 uInt size_extrafield_local; 675 }
676 const void* extrafield_global; 676 else
677 uInt size_extrafield_global; 677 {
678 const char* comment; 678 *zi = ziinit;
679 int method; 679 return (zipFile)zi;
680 int level; 680 }
681 int raw; 681}
682 int windowBits; 682
683 int memLevel; 683extern zipFile ZEXPORT zipOpen (pathname, append)
684 int strategy; 684 const char *pathname;
685 const char* password; 685 int append;
686 uLong crcForCrypting; 686{
687{ 687 return zipOpen2(pathname,append,NULL,NULL);
688 zip_internal* zi; 688}
689 uInt size_filename; 689
690 uInt size_comment; 690extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
691 uInt i; 691 extrafield_local, size_extrafield_local,
692 int err = ZIP_OK; 692 extrafield_global, size_extrafield_global,
693 693 comment, method, level, raw,
694# ifdef NOCRYPT 694 windowBits, memLevel, strategy,
695 if (password != NULL) 695 password, crcForCrypting)
696 return ZIP_PARAMERROR; 696 zipFile file;
697# endif 697 const char* filename;
698 698 const zip_fileinfo* zipfi;
699 if (file == NULL) 699 const void* extrafield_local;
700 return ZIP_PARAMERROR; 700 uInt size_extrafield_local;
701 if ((method!=0) && (method!=Z_DEFLATED)) 701 const void* extrafield_global;
702 return ZIP_PARAMERROR; 702 uInt size_extrafield_global;
703 703 const char* comment;
704 zi = (zip_internal*)file; 704 int method;
705 705 int level;
706 if (zi->in_opened_file_inzip == 1) 706 int raw;
707 { 707 int windowBits;
708 err = zipCloseFileInZip (file); 708 int memLevel;
709 if (err != ZIP_OK) 709 int strategy;
710 return err; 710 const char* password;
711 } 711 uLong crcForCrypting;
712 712{
713 713 zip_internal* zi;
714 if (filename==NULL) 714 uInt size_filename;
715 filename="-"; 715 uInt size_comment;
716 716 uInt i;
717 if (comment==NULL) 717 int err = ZIP_OK;
718 size_comment = 0; 718
719 else 719# ifdef NOCRYPT
720 size_comment = (uInt)strlen(comment); 720 if (password != NULL)
721 721 return ZIP_PARAMERROR;
722 size_filename = (uInt)strlen(filename); 722# endif
723 723
724 if (zipfi == NULL) 724 if (file == NULL)
725 zi->ci.dosDate = 0; 725 return ZIP_PARAMERROR;
726 else 726 if ((method!=0) && (method!=Z_DEFLATED))
727 { 727 return ZIP_PARAMERROR;
728 if (zipfi->dosDate != 0) 728
729 zi->ci.dosDate = zipfi->dosDate; 729 zi = (zip_internal*)file;
730 else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); 730
731 } 731 if (zi->in_opened_file_inzip == 1)
732 732 {
733 zi->ci.flag = 0; 733 err = zipCloseFileInZip (file);
734 if ((level==8) || (level==9)) 734 if (err != ZIP_OK)
735 zi->ci.flag |= 2; 735 return err;
736 if ((level==2)) 736 }
737 zi->ci.flag |= 4; 737
738 if ((level==1)) 738
739 zi->ci.flag |= 6; 739 if (filename==NULL)
740 if (password != NULL) 740 filename="-";
741 zi->ci.flag |= 1; 741
742 742 if (comment==NULL)
743 zi->ci.crc32 = 0; 743 size_comment = 0;
744 zi->ci.method = method; 744 else
745 zi->ci.encrypt = 0; 745 size_comment = (uInt)strlen(comment);
746 zi->ci.stream_initialised = 0; 746
747 zi->ci.pos_in_buffered_data = 0; 747 size_filename = (uInt)strlen(filename);
748 zi->ci.raw = raw; 748
749 zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; 749 if (zipfi == NULL)
750 zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + 750 zi->ci.dosDate = 0;
751 size_extrafield_global + size_comment; 751 else
752 zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); 752 {
753 753 if (zipfi->dosDate != 0)
754 ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); 754 zi->ci.dosDate = zipfi->dosDate;
755 /* version info */ 755 else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
756 ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); 756 }
757 ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); 757
758 ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); 758 zi->ci.flag = 0;
759 ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); 759 if ((level==8) || (level==9))
760 ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); 760 zi->ci.flag |= 2;
761 ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ 761 if ((level==2))
762 ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ 762 zi->ci.flag |= 4;
763 ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ 763 if ((level==1))
764 ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); 764 zi->ci.flag |= 6;
765 ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); 765 if (password != NULL)
766 ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); 766 zi->ci.flag |= 1;
767 ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ 767
768 768 zi->ci.crc32 = 0;
769 if (zipfi==NULL) 769 zi->ci.method = method;
770 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); 770 zi->ci.encrypt = 0;
771 else 771 zi->ci.stream_initialised = 0;
772 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); 772 zi->ci.pos_in_buffered_data = 0;
773 773 zi->ci.raw = raw;
774 if (zipfi==NULL) 774 zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
775 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); 775 zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
776 else 776 size_extrafield_global + size_comment;
777 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); 777 zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
778 778
779 ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); 779 ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
780 780 /* version info */
781 for (i=0;i<size_filename;i++) 781 ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
782 *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); 782 ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
783 783 ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
784 for (i=0;i<size_extrafield_global;i++) 784 ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
785 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = 785 ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
786 *(((const char*)extrafield_global)+i); 786 ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
787 787 ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
788 for (i=0;i<size_comment;i++) 788 ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
789 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ 789 ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
790 size_extrafield_global+i) = *(comment+i); 790 ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
791 if (zi->ci.central_header == NULL) 791 ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
792 return ZIP_INTERNALERROR; 792 ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
793 793
794 /* write the local header */ 794 if (zipfi==NULL)
795 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); 795 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
796 796 else
797 if (err==ZIP_OK) 797 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
798 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ 798
799 if (err==ZIP_OK) 799 if (zipfi==NULL)
800 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); 800 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
801 801 else
802 if (err==ZIP_OK) 802 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
803 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); 803
804 804 ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
805 if (err==ZIP_OK) 805
806 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); 806 for (i=0;i<size_filename;i++)
807 807 *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
808 if (err==ZIP_OK) 808
809 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ 809 for (i=0;i<size_extrafield_global;i++)
810 if (err==ZIP_OK) 810 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
811 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ 811 *(((const char*)extrafield_global)+i);
812 if (err==ZIP_OK) 812
813 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ 813 for (i=0;i<size_comment;i++)
814 814 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
815 if (err==ZIP_OK) 815 size_extrafield_global+i) = *(comment+i);
816 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); 816 if (zi->ci.central_header == NULL)
817 817 return ZIP_INTERNALERROR;
818 if (err==ZIP_OK) 818
819 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); 819 /* write the local header */
820 820 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
821 if ((err==ZIP_OK) && (size_filename>0)) 821
822 if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) 822 if (err==ZIP_OK)
823 err = ZIP_ERRNO; 823 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
824 824 if (err==ZIP_OK)
825 if ((err==ZIP_OK) && (size_extrafield_local>0)) 825 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
826 if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) 826
827 !=size_extrafield_local) 827 if (err==ZIP_OK)
828 err = ZIP_ERRNO; 828 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
829 829
830 zi->ci.stream.avail_in = (uInt)0; 830 if (err==ZIP_OK)
831 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 831 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
832 zi->ci.stream.next_out = zi->ci.buffered_data; 832
833 zi->ci.stream.total_in = 0; 833 if (err==ZIP_OK)
834 zi->ci.stream.total_out = 0; 834 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
835 835 if (err==ZIP_OK)
836 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 836 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
837 { 837 if (err==ZIP_OK)
838 zi->ci.stream.zalloc = (alloc_func)0; 838 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
839 zi->ci.stream.zfree = (free_func)0; 839
840 zi->ci.stream.opaque = (voidpf)0; 840 if (err==ZIP_OK)
841 841 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
842 if (windowBits>0) 842
843 windowBits = -windowBits; 843 if (err==ZIP_OK)
844 844 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
845 err = deflateInit2(&zi->ci.stream, level, 845
846 Z_DEFLATED, windowBits, memLevel, strategy); 846 if ((err==ZIP_OK) && (size_filename>0))
847 847 if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
848 if (err==Z_OK) 848 err = ZIP_ERRNO;
849 zi->ci.stream_initialised = 1; 849
850 } 850 if ((err==ZIP_OK) && (size_extrafield_local>0))
851# ifndef NOCRYPT 851 if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
852 zi->ci.crypt_header_size = 0; 852 !=size_extrafield_local)
853 if ((err==Z_OK) && (password != NULL)) 853 err = ZIP_ERRNO;
854 { 854
855 unsigned char bufHead[RAND_HEAD_LEN]; 855 zi->ci.stream.avail_in = (uInt)0;
856 unsigned int sizeHead; 856 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
857 zi->ci.encrypt = 1; 857 zi->ci.stream.next_out = zi->ci.buffered_data;
858 zi->ci.pcrc_32_tab = get_crc_table(); 858 zi->ci.stream.total_in = 0;
859 /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ 859 zi->ci.stream.total_out = 0;
860 860
861 sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); 861 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
862 zi->ci.crypt_header_size = sizeHead; 862 {
863 863 zi->ci.stream.zalloc = (alloc_func)0;
864 if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) 864 zi->ci.stream.zfree = (free_func)0;
865 err = ZIP_ERRNO; 865 zi->ci.stream.opaque = (voidpf)0;
866 } 866
867# endif 867 if (windowBits>0)
868 868 windowBits = -windowBits;
869 if (err==Z_OK) 869
870 zi->in_opened_file_inzip = 1; 870 err = deflateInit2(&zi->ci.stream, level,
871 return err; 871 Z_DEFLATED, windowBits, memLevel, strategy);
872} 872
873 873 if (err==Z_OK)
874extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, 874 zi->ci.stream_initialised = 1;
875 extrafield_local, size_extrafield_local, 875 }
876 extrafield_global, size_extrafield_global, 876# ifndef NOCRYPT
877 comment, method, level, raw) 877 zi->ci.crypt_header_size = 0;
878 zipFile file; 878 if ((err==Z_OK) && (password != NULL))
879 const char* filename; 879 {
880 const zip_fileinfo* zipfi; 880 unsigned char bufHead[RAND_HEAD_LEN];
881 const void* extrafield_local; 881 unsigned int sizeHead;
882 uInt size_extrafield_local; 882 zi->ci.encrypt = 1;
883 const void* extrafield_global; 883 zi->ci.pcrc_32_tab = get_crc_table();
884 uInt size_extrafield_global; 884 /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
885 const char* comment; 885
886 int method; 886 sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
887 int level; 887 zi->ci.crypt_header_size = sizeHead;
888 int raw; 888
889{ 889 if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
890 return zipOpenNewFileInZip3 (file, filename, zipfi, 890 err = ZIP_ERRNO;
891 extrafield_local, size_extrafield_local, 891 }
892 extrafield_global, size_extrafield_global, 892# endif
893 comment, method, level, raw, 893
894 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 894 if (err==Z_OK)
895 NULL, 0); 895 zi->in_opened_file_inzip = 1;
896} 896 return err;
897 897}
898extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, 898
899 extrafield_local, size_extrafield_local, 899extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
900 extrafield_global, size_extrafield_global, 900 extrafield_local, size_extrafield_local,
901 comment, method, level) 901 extrafield_global, size_extrafield_global,
902 zipFile file; 902 comment, method, level, raw)
903 const char* filename; 903 zipFile file;
904 const zip_fileinfo* zipfi; 904 const char* filename;
905 const void* extrafield_local; 905 const zip_fileinfo* zipfi;
906 uInt size_extrafield_local; 906 const void* extrafield_local;
907 const void* extrafield_global; 907 uInt size_extrafield_local;
908 uInt size_extrafield_global; 908 const void* extrafield_global;
909 const char* comment; 909 uInt size_extrafield_global;
910 int method; 910 const char* comment;
911 int level; 911 int method;
912{ 912 int level;
913 return zipOpenNewFileInZip2 (file, filename, zipfi, 913 int raw;
914 extrafield_local, size_extrafield_local, 914{
915 extrafield_global, size_extrafield_global, 915 return zipOpenNewFileInZip3 (file, filename, zipfi,
916 comment, method, level, 0); 916 extrafield_local, size_extrafield_local,
917} 917 extrafield_global, size_extrafield_global,
918 918 comment, method, level, raw,
919local int zipFlushWriteBuffer(zi) 919 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
920 zip_internal* zi; 920 NULL, 0);
921{ 921}
922 int err=ZIP_OK; 922
923 923extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
924 if (zi->ci.encrypt != 0) 924 extrafield_local, size_extrafield_local,
925 { 925 extrafield_global, size_extrafield_global,
926#ifndef NOCRYPT 926 comment, method, level)
927 uInt i; 927 zipFile file;
928 int t; 928 const char* filename;
929 for (i=0;i<zi->ci.pos_in_buffered_data;i++) 929 const zip_fileinfo* zipfi;
930 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, 930 const void* extrafield_local;
931 zi->ci.buffered_data[i],t); 931 uInt size_extrafield_local;
932#endif 932 const void* extrafield_global;
933 } 933 uInt size_extrafield_global;
934 if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) 934 const char* comment;
935 !=zi->ci.pos_in_buffered_data) 935 int method;
936 err = ZIP_ERRNO; 936 int level;
937 zi->ci.pos_in_buffered_data = 0; 937{
938 return err; 938 return zipOpenNewFileInZip2 (file, filename, zipfi,
939} 939 extrafield_local, size_extrafield_local,
940 940 extrafield_global, size_extrafield_global,
941extern int ZEXPORT zipWriteInFileInZip (file, buf, len) 941 comment, method, level, 0);
942 zipFile file; 942}
943 const void* buf; 943
944 unsigned len; 944local int zipFlushWriteBuffer(zi)
945{ 945 zip_internal* zi;
946 zip_internal* zi; 946{
947 int err=ZIP_OK; 947 int err=ZIP_OK;
948 948
949 if (file == NULL) 949 if (zi->ci.encrypt != 0)
950 return ZIP_PARAMERROR; 950 {
951 zi = (zip_internal*)file; 951#ifndef NOCRYPT
952 952 uInt i;
953 if (zi->in_opened_file_inzip == 0) 953 int t;
954 return ZIP_PARAMERROR; 954 for (i=0;i<zi->ci.pos_in_buffered_data;i++)
955 955 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
956 zi->ci.stream.next_in = (void*)buf; 956 zi->ci.buffered_data[i],t);
957 zi->ci.stream.avail_in = len; 957#endif
958 zi->ci.crc32 = crc32(zi->ci.crc32,buf,len); 958 }
959 959 if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
960 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) 960 !=zi->ci.pos_in_buffered_data)
961 { 961 err = ZIP_ERRNO;
962 if (zi->ci.stream.avail_out == 0) 962 zi->ci.pos_in_buffered_data = 0;
963 { 963 return err;
964 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) 964}
965 err = ZIP_ERRNO; 965
966 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 966extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
967 zi->ci.stream.next_out = zi->ci.buffered_data; 967 zipFile file;
968 } 968 const void* buf;
969 969 unsigned len;
970 970{
971 if(err != ZIP_OK) 971 zip_internal* zi;
972 break; 972 int err=ZIP_OK;
973 973
974 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 974 if (file == NULL)
975 { 975 return ZIP_PARAMERROR;
976 uLong uTotalOutBefore = zi->ci.stream.total_out; 976 zi = (zip_internal*)file;
977 err=deflate(&zi->ci.stream, Z_NO_FLUSH); 977
978 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 978 if (zi->in_opened_file_inzip == 0)
979 979 return ZIP_PARAMERROR;
980 } 980
981 else 981 zi->ci.stream.next_in = (void*)buf;
982 { 982 zi->ci.stream.avail_in = len;
983 uInt copy_this,i; 983 zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
984 if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) 984
985 copy_this = zi->ci.stream.avail_in; 985 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
986 else 986 {
987 copy_this = zi->ci.stream.avail_out; 987 if (zi->ci.stream.avail_out == 0)
988 for (i=0;i<copy_this;i++) 988 {
989 *(((char*)zi->ci.stream.next_out)+i) = 989 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
990 *(((const char*)zi->ci.stream.next_in)+i); 990 err = ZIP_ERRNO;
991 { 991 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
992 zi->ci.stream.avail_in -= copy_this; 992 zi->ci.stream.next_out = zi->ci.buffered_data;
993 zi->ci.stream.avail_out-= copy_this; 993 }
994 zi->ci.stream.next_in+= copy_this; 994
995 zi->ci.stream.next_out+= copy_this; 995
996 zi->ci.stream.total_in+= copy_this; 996 if(err != ZIP_OK)
997 zi->ci.stream.total_out+= copy_this; 997 break;
998 zi->ci.pos_in_buffered_data += copy_this; 998
999 } 999 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1000 } 1000 {
1001 } 1001 uLong uTotalOutBefore = zi->ci.stream.total_out;
1002 1002 err=deflate(&zi->ci.stream, Z_NO_FLUSH);
1003 return err; 1003 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1004} 1004
1005 1005 }
1006extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32) 1006 else
1007 zipFile file; 1007 {
1008 uLong uncompressed_size; 1008 uInt copy_this,i;
1009 uLong crc32; 1009 if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
1010{ 1010 copy_this = zi->ci.stream.avail_in;
1011 zip_internal* zi; 1011 else
1012 uLong compressed_size; 1012 copy_this = zi->ci.stream.avail_out;
1013 int err=ZIP_OK; 1013 for (i=0;i<copy_this;i++)
1014 1014 *(((char*)zi->ci.stream.next_out)+i) =
1015 if (file == NULL) 1015 *(((const char*)zi->ci.stream.next_in)+i);
1016 return ZIP_PARAMERROR; 1016 {
1017 zi = (zip_internal*)file; 1017 zi->ci.stream.avail_in -= copy_this;
1018 1018 zi->ci.stream.avail_out-= copy_this;
1019 if (zi->in_opened_file_inzip == 0) 1019 zi->ci.stream.next_in+= copy_this;
1020 return ZIP_PARAMERROR; 1020 zi->ci.stream.next_out+= copy_this;
1021 zi->ci.stream.avail_in = 0; 1021 zi->ci.stream.total_in+= copy_this;
1022 1022 zi->ci.stream.total_out+= copy_this;
1023 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1023 zi->ci.pos_in_buffered_data += copy_this;
1024 while (err==ZIP_OK) 1024 }
1025 { 1025 }
1026 uLong uTotalOutBefore; 1026 }
1027 if (zi->ci.stream.avail_out == 0) 1027
1028 { 1028 return err;
1029 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) 1029}
1030 err = ZIP_ERRNO; 1030
1031 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 1031extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
1032 zi->ci.stream.next_out = zi->ci.buffered_data; 1032 zipFile file;
1033 } 1033 uLong uncompressed_size;
1034 uTotalOutBefore = zi->ci.stream.total_out; 1034 uLong crc32;
1035 err=deflate(&zi->ci.stream, Z_FINISH); 1035{
1036 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 1036 zip_internal* zi;
1037 } 1037 uLong compressed_size;
1038 1038 int err=ZIP_OK;
1039 if (err==Z_STREAM_END) 1039
1040 err=ZIP_OK; /* this is normal */ 1040 if (file == NULL)
1041 1041 return ZIP_PARAMERROR;
1042 if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) 1042 zi = (zip_internal*)file;
1043 if (zipFlushWriteBuffer(zi)==ZIP_ERRNO) 1043
1044 err = ZIP_ERRNO; 1044 if (zi->in_opened_file_inzip == 0)
1045 1045 return ZIP_PARAMERROR;
1046 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1046 zi->ci.stream.avail_in = 0;
1047 { 1047
1048 err=deflateEnd(&zi->ci.stream); 1048 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1049 zi->ci.stream_initialised = 0; 1049 while (err==ZIP_OK)
1050 } 1050 {
1051 1051 uLong uTotalOutBefore;
1052 if (!zi->ci.raw) 1052 if (zi->ci.stream.avail_out == 0)
1053 { 1053 {
1054 crc32 = (uLong)zi->ci.crc32; 1054 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
1055 uncompressed_size = (uLong)zi->ci.stream.total_in; 1055 err = ZIP_ERRNO;
1056 } 1056 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1057 compressed_size = (uLong)zi->ci.stream.total_out; 1057 zi->ci.stream.next_out = zi->ci.buffered_data;
1058# ifndef NOCRYPT 1058 }
1059 compressed_size += zi->ci.crypt_header_size; 1059 uTotalOutBefore = zi->ci.stream.total_out;
1060# endif 1060 err=deflate(&zi->ci.stream, Z_FINISH);
1061 1061 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1062 ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ 1062 }
1063 ziplocal_putValue_inmemory(zi->ci.central_header+20, 1063
1064 compressed_size,4); /*compr size*/ 1064 if (err==Z_STREAM_END)
1065 if (zi->ci.stream.data_type == Z_ASCII) 1065 err=ZIP_OK; /* this is normal */
1066 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); 1066
1067 ziplocal_putValue_inmemory(zi->ci.central_header+24, 1067 if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
1068 uncompressed_size,4); /*uncompr size*/ 1068 if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
1069 1069 err = ZIP_ERRNO;
1070 if (err==ZIP_OK) 1070
1071 err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header, 1071 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1072 (uLong)zi->ci.size_centralheader); 1072 {
1073 free(zi->ci.central_header); 1073 err=deflateEnd(&zi->ci.stream);
1074 1074 zi->ci.stream_initialised = 0;
1075 if (err==ZIP_OK) 1075 }
1076 { 1076
1077 long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); 1077 if (!zi->ci.raw)
1078 if (ZSEEK(zi->z_filefunc,zi->filestream, 1078 {
1079 zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) 1079 crc32 = (uLong)zi->ci.crc32;
1080 err = ZIP_ERRNO; 1080 uncompressed_size = (uLong)zi->ci.stream.total_in;
1081 1081 }
1082 if (err==ZIP_OK) 1082 compressed_size = (uLong)zi->ci.stream.total_out;
1083 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ 1083# ifndef NOCRYPT
1084 1084 compressed_size += zi->ci.crypt_header_size;
1085 if (err==ZIP_OK) /* compressed size, unknown */ 1085# endif
1086 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); 1086
1087 1087 ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
1088 if (err==ZIP_OK) /* uncompressed size, unknown */ 1088 ziplocal_putValue_inmemory(zi->ci.central_header+20,
1089 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); 1089 compressed_size,4); /*compr size*/
1090 1090 if (zi->ci.stream.data_type == Z_ASCII)
1091 if (ZSEEK(zi->z_filefunc,zi->filestream, 1091 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
1092 cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) 1092 ziplocal_putValue_inmemory(zi->ci.central_header+24,
1093 err = ZIP_ERRNO; 1093 uncompressed_size,4); /*uncompr size*/
1094 } 1094
1095 1095 if (err==ZIP_OK)
1096 zi->number_entry ++; 1096 err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
1097 zi->in_opened_file_inzip = 0; 1097 (uLong)zi->ci.size_centralheader);
1098 1098 free(zi->ci.central_header);
1099 return err; 1099
1100} 1100 if (err==ZIP_OK)
1101 1101 {
1102extern int ZEXPORT zipCloseFileInZip (file) 1102 long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1103 zipFile file; 1103 if (ZSEEK(zi->z_filefunc,zi->filestream,
1104{ 1104 zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
1105 return zipCloseFileInZipRaw (file,0,0); 1105 err = ZIP_ERRNO;
1106} 1106
1107 1107 if (err==ZIP_OK)
1108extern int ZEXPORT zipClose (file, global_comment) 1108 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
1109 zipFile file; 1109
1110 const char* global_comment; 1110 if (err==ZIP_OK) /* compressed size, unknown */
1111{ 1111 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
1112 zip_internal* zi; 1112
1113 int err = 0; 1113 if (err==ZIP_OK) /* uncompressed size, unknown */
1114 uLong size_centraldir = 0; 1114 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
1115 uLong centraldir_pos_inzip ; 1115
1116 uInt size_global_comment; 1116 if (ZSEEK(zi->z_filefunc,zi->filestream,
1117 if (file == NULL) 1117 cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
1118 return ZIP_PARAMERROR; 1118 err = ZIP_ERRNO;
1119 zi = (zip_internal*)file; 1119 }
1120 1120
1121 if (zi->in_opened_file_inzip == 1) 1121 zi->number_entry ++;
1122 { 1122 zi->in_opened_file_inzip = 0;
1123 err = zipCloseFileInZip (file); 1123
1124 } 1124 return err;
1125 1125}
1126 if (global_comment==NULL) 1126
1127 size_global_comment = 0; 1127extern int ZEXPORT zipCloseFileInZip (file)
1128 else 1128 zipFile file;
1129 size_global_comment = (uInt)strlen(global_comment); 1129{
1130 1130 return zipCloseFileInZipRaw (file,0,0);
1131 1131}
1132 centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); 1132
1133 if (err==ZIP_OK) 1133extern int ZEXPORT zipClose (file, global_comment)
1134 { 1134 zipFile file;
1135 linkedlist_datablock_internal* ldi = zi->central_dir.first_block ; 1135 const char* global_comment;
1136 while (ldi!=NULL) 1136{
1137 { 1137 zip_internal* zi;
1138 if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) 1138 int err = 0;
1139 if (ZWRITE(zi->z_filefunc,zi->filestream, 1139 uLong size_centraldir = 0;
1140 ldi->data,ldi->filled_in_this_block) 1140 uLong centraldir_pos_inzip;
1141 !=ldi->filled_in_this_block ) 1141 uInt size_global_comment;
1142 err = ZIP_ERRNO; 1142 if (file == NULL)
1143 1143 return ZIP_PARAMERROR;
1144 size_centraldir += ldi->filled_in_this_block; 1144 zi = (zip_internal*)file;
1145 ldi = ldi->next_datablock; 1145
1146 } 1146 if (zi->in_opened_file_inzip == 1)
1147 } 1147 {
1148 free_datablock(zi->central_dir.first_block); 1148 err = zipCloseFileInZip (file);
1149 1149 }
1150 if (err==ZIP_OK) /* Magic End */ 1150
1151 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); 1151#ifndef NO_ADDFILEINEXISTINGZIP
1152 1152 if (global_comment==NULL)
1153 if (err==ZIP_OK) /* number of this disk */ 1153 global_comment = zi->globalcomment;
1154 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); 1154#endif
1155 1155 if (global_comment==NULL)
1156 if (err==ZIP_OK) /* number of the disk with the start of the central directory */ 1156 size_global_comment = 0;
1157 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); 1157 else
1158 1158 size_global_comment = (uInt)strlen(global_comment);
1159 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ 1159
1160 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); 1160 centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1161 1161 if (err==ZIP_OK)
1162 if (err==ZIP_OK) /* total number of entries in the central dir */ 1162 {
1163 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); 1163 linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
1164 1164 while (ldi!=NULL)
1165 if (err==ZIP_OK) /* size of the central directory */ 1165 {
1166 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); 1166 if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
1167 1167 if (ZWRITE(zi->z_filefunc,zi->filestream,
1168 if (err==ZIP_OK) /* offset of start of central directory with respect to the 1168 ldi->data,ldi->filled_in_this_block)
1169 starting disk number */ 1169 !=ldi->filled_in_this_block )
1170 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream, 1170 err = ZIP_ERRNO;
1171 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); 1171
1172 1172 size_centraldir += ldi->filled_in_this_block;
1173 if (err==ZIP_OK) /* zipfile comment length */ 1173 ldi = ldi->next_datablock;
1174 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); 1174 }
1175 1175 }
1176 if ((err==ZIP_OK) && (size_global_comment>0)) 1176 free_datablock(zi->central_dir.first_block);
1177 if (ZWRITE(zi->z_filefunc,zi->filestream, 1177
1178 global_comment,size_global_comment) != size_global_comment) 1178 if (err==ZIP_OK) /* Magic End */
1179 err = ZIP_ERRNO; 1179 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1180 1180
1181 if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0) 1181 if (err==ZIP_OK) /* number of this disk */
1182 if (err == ZIP_OK) 1182 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1183 err = ZIP_ERRNO; 1183
1184 1184 if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1185 TRYFREE(zi); 1185 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1186 1186
1187 return err; 1187 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1188} 1188 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1189
1190 if (err==ZIP_OK) /* total number of entries in the central dir */
1191 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1192
1193 if (err==ZIP_OK) /* size of the central directory */
1194 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
1195
1196 if (err==ZIP_OK) /* offset of start of central directory with respect to the
1197 starting disk number */
1198 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
1199 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
1200
1201 if (err==ZIP_OK) /* zipfile comment length */
1202 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
1203
1204 if ((err==ZIP_OK) && (size_global_comment>0))
1205 if (ZWRITE(zi->z_filefunc,zi->filestream,
1206 global_comment,size_global_comment) != size_global_comment)
1207 err = ZIP_ERRNO;
1208
1209 if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
1210 if (err == ZIP_OK)
1211 err = ZIP_ERRNO;
1212
1213#ifndef NO_ADDFILEINEXISTINGZIP
1214 TRYFREE(zi->globalcomment);
1215#endif
1216 TRYFREE(zi);
1217
1218 return err;
1219}
diff --git a/contrib/minizip/zip.h b/contrib/minizip/zip.h
index d5112c4..cd38b67 100644
--- a/contrib/minizip/zip.h
+++ b/contrib/minizip/zip.h
@@ -1,234 +1,235 @@
1/* zip.h -- IO for compress .zip files using zlib 1/* zip.h -- IO for compress .zip files using zlib
2 Version 1.01, May 8th, 2004 2 Version 1.01e, February 12th, 2005
3 3
4 Copyright (C) 1998-2004 Gilles Vollant 4 Copyright (C) 1998-2005 Gilles Vollant
5 5
6 This unzip package allow creates .ZIP file, compatible with PKZip 2.04g 6 This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
7 WinZip, InfoZip tools and compatible. 7 WinZip, InfoZip tools and compatible.
8 Encryption and multi volume ZipFile (span) are not supported. 8 Multi volume ZipFile (span) are not supported.
9 Old compressions used by old PKZip 1.x are not supported 9 Encryption compatible with pkzip 2.04g only supported
10 10 Old compressions used by old PKZip 1.x are not supported
11 For uncompress .zip file, look at unzip.h 11
12 12 For uncompress .zip file, look at unzip.h
13 13
14 I WAIT FEEDBACK at mail info@winimage.com 14
15 Visit also http://www.winimage.com/zLibDll/unzip.html for evolution 15 I WAIT FEEDBACK at mail info@winimage.com
16 16 Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
17 Condition of use and distribution are the same than zlib : 17
18 18 Condition of use and distribution are the same than zlib :
19 This software is provided 'as-is', without any express or implied 19
20 warranty. In no event will the authors be held liable for any damages 20 This software is provided 'as-is', without any express or implied
21 arising from the use of this software. 21 warranty. In no event will the authors be held liable for any damages
22 22 arising from the use of this software.
23 Permission is granted to anyone to use this software for any purpose, 23
24 including commercial applications, and to alter it and redistribute it 24 Permission is granted to anyone to use this software for any purpose,
25 freely, subject to the following restrictions: 25 including commercial applications, and to alter it and redistribute it
26 26 freely, subject to the following restrictions:
27 1. The origin of this software must not be misrepresented; you must not 27
28 claim that you wrote the original software. If you use this software 28 1. The origin of this software must not be misrepresented; you must not
29 in a product, an acknowledgment in the product documentation would be 29 claim that you wrote the original software. If you use this software
30 appreciated but is not required. 30 in a product, an acknowledgment in the product documentation would be
31 2. Altered source versions must be plainly marked as such, and must not be 31 appreciated but is not required.
32 misrepresented as being the original software. 32 2. Altered source versions must be plainly marked as such, and must not be
33 3. This notice may not be removed or altered from any source distribution. 33 misrepresented as being the original software.
34 34 3. This notice may not be removed or altered from any source distribution.
35 35
36*/ 36
37 37*/
38/* for more info about .ZIP format, see 38
39 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip 39/* for more info about .ZIP format, see
40 http://www.info-zip.org/pub/infozip/doc/ 40 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
41 PkWare has also a specification at : 41 http://www.info-zip.org/pub/infozip/doc/
42 ftp://ftp.pkware.com/probdesc.zip 42 PkWare has also a specification at :
43*/ 43 ftp://ftp.pkware.com/probdesc.zip
44 44*/
45#ifndef _zip_H 45
46#define _zip_H 46#ifndef _zip_H
47 47#define _zip_H
48#ifdef __cplusplus 48
49extern "C" { 49#ifdef __cplusplus
50#endif 50extern "C" {
51 51#endif
52#ifndef _ZLIB_H 52
53#include "zlib.h" 53#ifndef _ZLIB_H
54#endif 54#include "zlib.h"
55 55#endif
56#ifndef _ZLIBIOAPI_H 56
57#include "ioapi.h" 57#ifndef _ZLIBIOAPI_H
58#endif 58#include "ioapi.h"
59 59#endif
60#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) 60
61/* like the STRICT of WIN32, we define a pointer that cannot be converted 61#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
62 from (void*) without cast */ 62/* like the STRICT of WIN32, we define a pointer that cannot be converted
63typedef struct TagzipFile__ { int unused; } zipFile__; 63 from (void*) without cast */
64typedef zipFile__ *zipFile; 64typedef struct TagzipFile__ { int unused; } zipFile__;
65#else 65typedef zipFile__ *zipFile;
66typedef voidp zipFile; 66#else
67#endif 67typedef voidp zipFile;
68 68#endif
69#define ZIP_OK (0) 69
70#define ZIP_EOF (0) 70#define ZIP_OK (0)
71#define ZIP_ERRNO (Z_ERRNO) 71#define ZIP_EOF (0)
72#define ZIP_PARAMERROR (-102) 72#define ZIP_ERRNO (Z_ERRNO)
73#define ZIP_BADZIPFILE (-103) 73#define ZIP_PARAMERROR (-102)
74#define ZIP_INTERNALERROR (-104) 74#define ZIP_BADZIPFILE (-103)
75 75#define ZIP_INTERNALERROR (-104)
76#ifndef DEF_MEM_LEVEL 76
77# if MAX_MEM_LEVEL >= 8 77#ifndef DEF_MEM_LEVEL
78# define DEF_MEM_LEVEL 8 78# if MAX_MEM_LEVEL >= 8
79# else 79# define DEF_MEM_LEVEL 8
80# define DEF_MEM_LEVEL MAX_MEM_LEVEL 80# else
81# endif 81# define DEF_MEM_LEVEL MAX_MEM_LEVEL
82#endif 82# endif
83/* default memLevel */ 83#endif
84 84/* default memLevel */
85/* tm_zip contain date/time info */ 85
86typedef struct tm_zip_s 86/* tm_zip contain date/time info */
87{ 87typedef struct tm_zip_s
88 uInt tm_sec; /* seconds after the minute - [0,59] */ 88{
89 uInt tm_min; /* minutes after the hour - [0,59] */ 89 uInt tm_sec; /* seconds after the minute - [0,59] */
90 uInt tm_hour; /* hours since midnight - [0,23] */ 90 uInt tm_min; /* minutes after the hour - [0,59] */
91 uInt tm_mday; /* day of the month - [1,31] */ 91 uInt tm_hour; /* hours since midnight - [0,23] */
92 uInt tm_mon; /* months since January - [0,11] */ 92 uInt tm_mday; /* day of the month - [1,31] */
93 uInt tm_year; /* years - [1980..2044] */ 93 uInt tm_mon; /* months since January - [0,11] */
94} tm_zip; 94 uInt tm_year; /* years - [1980..2044] */
95 95} tm_zip;
96typedef struct 96
97{ 97typedef struct
98 tm_zip tmz_date; /* date in understandable format */ 98{
99 uLong dosDate; /* if dos_date == 0, tmu_date is used */ 99 tm_zip tmz_date; /* date in understandable format */
100/* uLong flag; */ /* general purpose bit flag 2 bytes */ 100 uLong dosDate; /* if dos_date == 0, tmu_date is used */
101 101/* uLong flag; */ /* general purpose bit flag 2 bytes */
102 uLong internal_fa; /* internal file attributes 2 bytes */ 102
103 uLong external_fa; /* external file attributes 4 bytes */ 103 uLong internal_fa; /* internal file attributes 2 bytes */
104} zip_fileinfo; 104 uLong external_fa; /* external file attributes 4 bytes */
105 105} zip_fileinfo;
106typedef const char* zipcharpc; 106
107 107typedef const char* zipcharpc;
108 108
109#define APPEND_STATUS_CREATE (0) 109
110#define APPEND_STATUS_CREATEAFTER (1) 110#define APPEND_STATUS_CREATE (0)
111#define APPEND_STATUS_ADDINZIP (2) 111#define APPEND_STATUS_CREATEAFTER (1)
112 112#define APPEND_STATUS_ADDINZIP (2)
113extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); 113
114/* 114extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
115 Create a zipfile. 115/*
116 pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on 116 Create a zipfile.
117 an Unix computer "zlib/zlib113.zip". 117 pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
118 if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip 118 an Unix computer "zlib/zlib113.zip".
119 will be created at the end of the file. 119 if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
120 (useful if the file contain a self extractor code) 120 will be created at the end of the file.
121 if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will 121 (useful if the file contain a self extractor code)
122 add files in existing zip (be sure you don't add file that doesn't exist) 122 if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
123 If the zipfile cannot be opened, the return value is NULL. 123 add files in existing zip (be sure you don't add file that doesn't exist)
124 Else, the return value is a zipFile Handle, usable with other function 124 If the zipfile cannot be opened, the return value is NULL.
125 of this zip package. 125 Else, the return value is a zipFile Handle, usable with other function
126*/ 126 of this zip package.
127 127*/
128/* Note : there is no delete function into a zipfile. 128
129 If you want delete file into a zipfile, you must open a zipfile, and create another 129/* Note : there is no delete function into a zipfile.
130 Of couse, you can use RAW reading and writing to copy the file you did not want delte 130 If you want delete file into a zipfile, you must open a zipfile, and create another
131*/ 131 Of couse, you can use RAW reading and writing to copy the file you did not want delte
132 132*/
133extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, 133
134 int append, 134extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
135 zipcharpc* globalcomment, 135 int append,
136 zlib_filefunc_def* pzlib_filefunc_def)); 136 zipcharpc* globalcomment,
137 137 zlib_filefunc_def* pzlib_filefunc_def));
138extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, 138
139 const char* filename, 139extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
140 const zip_fileinfo* zipfi, 140 const char* filename,
141 const void* extrafield_local, 141 const zip_fileinfo* zipfi,
142 uInt size_extrafield_local, 142 const void* extrafield_local,
143 const void* extrafield_global, 143 uInt size_extrafield_local,
144 uInt size_extrafield_global, 144 const void* extrafield_global,
145 const char* comment, 145 uInt size_extrafield_global,
146 int method, 146 const char* comment,
147 int level)); 147 int method,
148/* 148 int level));
149 Open a file in the ZIP for writing. 149/*
150 filename : the filename in zip (if NULL, '-' without quote will be used 150 Open a file in the ZIP for writing.
151 *zipfi contain supplemental information 151 filename : the filename in zip (if NULL, '-' without quote will be used
152 if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local 152 *zipfi contain supplemental information
153 contains the extrafield data the the local header 153 if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
154 if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global 154 contains the extrafield data the the local header
155 contains the extrafield data the the local header 155 if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
156 if comment != NULL, comment contain the comment string 156 contains the extrafield data the the local header
157 method contain the compression method (0 for store, Z_DEFLATED for deflate) 157 if comment != NULL, comment contain the comment string
158 level contain the level of compression (can be Z_DEFAULT_COMPRESSION) 158 method contain the compression method (0 for store, Z_DEFLATED for deflate)
159*/ 159 level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
160 160*/
161 161
162extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, 162
163 const char* filename, 163extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
164 const zip_fileinfo* zipfi, 164 const char* filename,
165 const void* extrafield_local, 165 const zip_fileinfo* zipfi,
166 uInt size_extrafield_local, 166 const void* extrafield_local,
167 const void* extrafield_global, 167 uInt size_extrafield_local,
168 uInt size_extrafield_global, 168 const void* extrafield_global,
169 const char* comment, 169 uInt size_extrafield_global,
170 int method, 170 const char* comment,
171 int level, 171 int method,
172 int raw)); 172 int level,
173 173 int raw));
174/* 174
175 Same than zipOpenNewFileInZip, except if raw=1, we write raw file 175/*
176 */ 176 Same than zipOpenNewFileInZip, except if raw=1, we write raw file
177 177 */
178extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, 178
179 const char* filename, 179extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
180 const zip_fileinfo* zipfi, 180 const char* filename,
181 const void* extrafield_local, 181 const zip_fileinfo* zipfi,
182 uInt size_extrafield_local, 182 const void* extrafield_local,
183 const void* extrafield_global, 183 uInt size_extrafield_local,
184 uInt size_extrafield_global, 184 const void* extrafield_global,
185 const char* comment, 185 uInt size_extrafield_global,
186 int method, 186 const char* comment,
187 int level, 187 int method,
188 int raw, 188 int level,
189 int windowBits, 189 int raw,
190 int memLevel, 190 int windowBits,
191 int strategy, 191 int memLevel,
192 const char* password, 192 int strategy,
193 uLong crcForCtypting)); 193 const char* password,
194 194 uLong crcForCtypting));
195/* 195
196 Same than zipOpenNewFileInZip2, except 196/*
197 windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 197 Same than zipOpenNewFileInZip2, except
198 password : crypting password (NULL for no crypting) 198 windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
199 crcForCtypting : crc of file to compress (needed for crypting) 199 password : crypting password (NULL for no crypting)
200 */ 200 crcForCtypting : crc of file to compress (needed for crypting)
201 201 */
202 202
203extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, 203
204 const void* buf, 204extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
205 unsigned len)); 205 const void* buf,
206/* 206 unsigned len));
207 Write data in the zipfile 207/*
208*/ 208 Write data in the zipfile
209 209*/
210extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); 210
211/* 211extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
212 Close the current file in the zipfile 212/*
213*/ 213 Close the current file in the zipfile
214 214*/
215extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, 215
216 uLong uncompressed_size, 216extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
217 uLong crc32)); 217 uLong uncompressed_size,
218/* 218 uLong crc32));
219 Close the current file in the zipfile, for fiel opened with 219/*
220 parameter raw=1 in zipOpenNewFileInZip2 220 Close the current file in the zipfile, for fiel opened with
221 uncompressed_size and crc32 are value for the uncompressed size 221 parameter raw=1 in zipOpenNewFileInZip2
222*/ 222 uncompressed_size and crc32 are value for the uncompressed size
223 223*/
224extern int ZEXPORT zipClose OF((zipFile file, 224
225 const char* global_comment)); 225extern int ZEXPORT zipClose OF((zipFile file,
226/* 226 const char* global_comment));
227 Close the zipfile 227/*
228*/ 228 Close the zipfile
229 229*/
230#ifdef __cplusplus 230
231} 231#ifdef __cplusplus
232#endif 232}
233 233#endif
234#endif /* _zip_H */ 234
235#endif /* _zip_H */
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-17 04:47:32 +0000