summaryrefslogtreecommitdiff
path: root/contrib/minizip/zip.c
diff options
context:
space:
mode:
authorMark Adler <madler@alumni.caltech.edu>2011-09-09 23:24:43 -0700
committerMark Adler <madler@alumni.caltech.edu>2011-09-09 23:24:43 -0700
commit6b8233bfe00e79134cb1b84fc49d4f750a797f79 (patch)
treeca2b03b0169568681dc3d9c823e9f0bc4417d6b5 /contrib/minizip/zip.c
parent0484693e1723bbab791c56f95597bd7dbe867d03 (diff)
downloadzlib-1.2.2.3.tar.gz
zlib-1.2.2.3.tar.bz2
zlib-1.2.2.3.zip
zlib 1.2.2.3v1.2.2.3
Diffstat (limited to 'contrib/minizip/zip.c')
-rw-r--r--contrib/minizip/zip.c2407
1 files changed, 1219 insertions, 1188 deletions
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}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-17 03:11:21 +0000