Mercurial > hg > orthanc

comparison OrthancFramework/Resources/ThirdParty/minizip/zip.c @ 5428:8174e45f48d8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Upgraded minizip library to stay away from CVE-2023-45853
author Alain Mazy <am@osimis.io>
date Fri, 17 Nov 2023 08:58:40 +0100
parents d25f4c0fa160
children
comparison
equal deleted inserted replaced
5427:111e21b4f8bc 5428:8174e45f48d8
12 Changes 12 Changes
13 Oct-2009 - Mathias Svensson - Remove old C style function prototypes 13 Oct-2009 - Mathias Svensson - Remove old C style function prototypes
14 Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives 14 Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
15 Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions. 15 Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions.
16 Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data 16 Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data
17 It is used when recreting zip archive with RAW when deleting items from a zip. 17 It is used when recreating zip archive with RAW when deleting items from a zip.
18 ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to be removed. 18 ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to be removed.
19 Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required) 19 Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required)
20 Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer 20 Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
21 21
22 */ 22 */
23 23
24 24
25 #include <stdio.h> 25 #include <stdio.h>
26 #include <stdlib.h> 26 #include <stdlib.h>
27 #include <string.h> 27 #include <string.h>
28 #include <stdint.h>
28 #include <time.h> 29 #include <time.h>
29 #include "zlib.h" 30 #include "zlib.h"
30 #include "zip.h" 31 #include "zip.h"
31 32
32 #ifdef STDC 33 #ifdef STDC
33 # include <stddef.h> 34 # include <stddef.h>
34 # include <string.h>
35 # include <stdlib.h>
36 #endif 35 #endif
37 #ifdef NO_ERRNO_H 36 #ifdef NO_ERRNO_H
38 extern int errno; 37 extern int errno;
39 #else 38 #else
40 # include <errno.h> 39 # include <errno.h>
45 # define local static 44 # define local static
46 #endif 45 #endif
47 /* compile with -Dlocal if your debugger can't find static symbols */ 46 /* compile with -Dlocal if your debugger can't find static symbols */
48 47
49 #ifndef VERSIONMADEBY 48 #ifndef VERSIONMADEBY
50 # define VERSIONMADEBY (0x0) /* platform depedent */ 49 # define VERSIONMADEBY (0x0) /* platform dependent */
51 #endif 50 #endif
52 51
53 #ifndef Z_BUFSIZE 52 #ifndef Z_BUFSIZE
54 #define Z_BUFSIZE (64*1024) //(16384) 53 #define Z_BUFSIZE (64*1024) //(16384)
55 #endif 54 #endif
58 #define Z_MAXFILENAMEINZIP (256) 57 #define Z_MAXFILENAMEINZIP (256)
59 #endif 58 #endif
60 59
61 #ifndef ALLOC 60 #ifndef ALLOC
62 # define ALLOC(size) (malloc(size)) 61 # define ALLOC(size) (malloc(size))
63 #endif
64 #ifndef TRYFREE
65 # define TRYFREE(p) {if (p) free(p);}
66 #endif 62 #endif
67 63
68 /* 64 /*
69 #define SIZECENTRALDIRITEM (0x2e) 65 #define SIZECENTRALDIRITEM (0x2e)
70 #define SIZEZIPLOCALHEADER (0x1e) 66 #define SIZEZIPLOCALHEADER (0x1e)
136 132
137 int stream_initialised; /* 1 is stream is initialised */ 133 int stream_initialised; /* 1 is stream is initialised */
138 uInt pos_in_buffered_data; /* last written byte in buffered_data */ 134 uInt pos_in_buffered_data; /* last written byte in buffered_data */
139 135
140 ZPOS64_T pos_local_header; /* offset of the local header of the file 136 ZPOS64_T pos_local_header; /* offset of the local header of the file
141 currenty writing */ 137 currently writing */
142 char* central_header; /* central header data for the current file */ 138 char* central_header; /* central header data for the current file */
143 uLong size_centralExtra; 139 uLong size_centralExtra;
144 uLong size_centralheader; /* size of the central header for cur file */ 140 uLong size_centralheader; /* size of the central header for cur file */
145 uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */ 141 uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */
146 uLong flag; /* flag of the file currently writing */ 142 uLong flag; /* flag of the file currently writing */
147 143
148 int method; /* compression method of file currenty wr.*/ 144 int method; /* compression method of file currently wr.*/
149 int raw; /* 1 for directly writing raw data */ 145 int raw; /* 1 for directly writing raw data */
150 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ 146 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
151 uLong dosDate; 147 uLong dosDate;
152 uLong crc32; 148 uLong crc32;
153 int encrypt; 149 int encrypt;
154 int zip64; /* Add ZIP64 extened information in the extra field */ 150 int zip64; /* Add ZIP64 extended information in the extra field */
155 ZPOS64_T pos_zip64extrainfo; 151 ZPOS64_T pos_zip64extrainfo;
156 ZPOS64_T totalCompressedData; 152 ZPOS64_T totalCompressedData;
157 ZPOS64_T totalUncompressedData; 153 ZPOS64_T totalUncompressedData;
158 #ifndef NOCRYPT 154 #ifndef NOCRYPT
159 unsigned long keys[3]; /* keys defining the pseudo-random sequence */ 155 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
160 const z_crc_t* pcrc_32_tab; 156 const z_crc_t* pcrc_32_tab;
161 int crypt_header_size; 157 unsigned crypt_header_size;
162 #endif 158 #endif
163 } curfile64_info; 159 } curfile64_info;
164 160
165 typedef struct 161 typedef struct
166 { 162 {
167 zlib_filefunc64_32_def z_filefunc; 163 zlib_filefunc64_32_def z_filefunc;
168 voidpf filestream; /* io structore of the zipfile */ 164 voidpf filestream; /* io structure of the zipfile */
169 linkedlist_data central_dir;/* datablock with central dir in construction*/ 165 linkedlist_data central_dir;/* datablock with central dir in construction*/
170 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ 166 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
171 curfile64_info ci; /* info on the file curretly writing */ 167 curfile64_info ci; /* info on the file currently writing */
172 168
173 ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ 169 ZPOS64_T begin_pos; /* position of the beginning of the zipfile */
174 ZPOS64_T add_position_when_writing_offset; 170 ZPOS64_T add_position_when_writing_offset;
175 ZPOS64_T number_entry; 171 ZPOS64_T number_entry;
176 172
184 #ifndef NOCRYPT 180 #ifndef NOCRYPT
185 #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED 181 #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
186 #include "crypt.h" 182 #include "crypt.h"
187 #endif 183 #endif
188 184
189 local linkedlist_datablock_internal* allocate_new_datablock() 185 local linkedlist_datablock_internal* allocate_new_datablock(void) {
190 {
191 linkedlist_datablock_internal* ldi; 186 linkedlist_datablock_internal* ldi;
192 ldi = (linkedlist_datablock_internal*) 187 ldi = (linkedlist_datablock_internal*)
193 ALLOC(sizeof(linkedlist_datablock_internal)); 188 ALLOC(sizeof(linkedlist_datablock_internal));
194 if (ldi!=NULL) 189 if (ldi!=NULL)
195 { 190 {
198 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; 193 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
199 } 194 }
200 return ldi; 195 return ldi;
201 } 196 }
202 197
203 local void free_datablock(linkedlist_datablock_internal* ldi) 198 local void free_datablock(linkedlist_datablock_internal* ldi) {
204 {
205 while (ldi!=NULL) 199 while (ldi!=NULL)
206 { 200 {
207 linkedlist_datablock_internal* ldinext = ldi->next_datablock; 201 linkedlist_datablock_internal* ldinext = ldi->next_datablock;
208 TRYFREE(ldi); 202 free(ldi);
209 ldi = ldinext; 203 ldi = ldinext;
210 } 204 }
211 } 205 }
212 206
213 local void init_linkedlist(linkedlist_data* ll) 207 local void init_linkedlist(linkedlist_data* ll) {
214 {
215 ll->first_block = ll->last_block = NULL; 208 ll->first_block = ll->last_block = NULL;
216 } 209 }
217 210
218 local void free_linkedlist(linkedlist_data* ll) 211 local void free_linkedlist(linkedlist_data* ll) {
219 {
220 free_datablock(ll->first_block); 212 free_datablock(ll->first_block);
221 ll->first_block = ll->last_block = NULL; 213 ll->first_block = ll->last_block = NULL;
222 } 214 }
223 215
224 216
225 local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) 217 local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) {
226 {
227 linkedlist_datablock_internal* ldi; 218 linkedlist_datablock_internal* ldi;
228 const unsigned char* from_copy; 219 const unsigned char* from_copy;
229 220
230 if (ll==NULL) 221 if (ll==NULL)
231 return ZIP_INTERNALERROR; 222 return ZIP_INTERNALERROR;
236 if (ll->first_block == NULL) 227 if (ll->first_block == NULL)
237 return ZIP_INTERNALERROR; 228 return ZIP_INTERNALERROR;
238 } 229 }
239 230
240 ldi = ll->last_block; 231 ldi = ll->last_block;
241 from_copy = (unsigned char*)buf; 232 from_copy = (const unsigned char*)buf;
242 233
243 while (len>0) 234 while (len>0)
244 { 235 {
245 uInt copy_this; 236 uInt copy_this;
246 uInt i; 237 uInt i;
281 /* =========================================================================== 272 /* ===========================================================================
282 Inputs a long in LSB order to the given file 273 Inputs a long in LSB order to the given file
283 nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) 274 nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)
284 */ 275 */
285 276
286 local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)); 277 local int zip64local_putValue(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) {
287 local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)
288 {
289 unsigned char buf[8]; 278 unsigned char buf[8];
290 int n; 279 int n;
291 for (n = 0; n < nbByte; n++) 280 for (n = 0; n < nbByte; n++)
292 { 281 {
293 buf[n] = (unsigned char)(x & 0xff); 282 buf[n] = (unsigned char)(x & 0xff);
299 { 288 {
300 buf[n] = 0xff; 289 buf[n] = 0xff;
301 } 290 }
302 } 291 }
303 292
304 if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) 293 if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,(uLong)nbByte)!=(uLong)nbByte)
305 return ZIP_ERRNO; 294 return ZIP_ERRNO;
306 else 295 else
307 return ZIP_OK; 296 return ZIP_OK;
308 } 297 }
309 298
310 local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte)); 299 local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) {
311 local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)
312 {
313 unsigned char* buf=(unsigned char*)dest; 300 unsigned char* buf=(unsigned char*)dest;
314 int n; 301 int n;
315 for (n = 0; n < nbByte; n++) { 302 for (n = 0; n < nbByte; n++) {
316 buf[n] = (unsigned char)(x & 0xff); 303 buf[n] = (unsigned char)(x & 0xff);
317 x >>= 8; 304 x >>= 8;
327 } 314 }
328 315
329 /****************************************************************************/ 316 /****************************************************************************/
330 317
331 318
332 local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) 319 local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) {
333 {
334 uLong year = (uLong)ptm->tm_year; 320 uLong year = (uLong)ptm->tm_year;
335 if (year>=1980) 321 if (year>=1980)
336 year-=1980; 322 year-=1980;
337 else if (year>=80) 323 else if (year>=80)
338 year-=80; 324 year-=80;
339 return 325 return
340 (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | 326 (uLong) (((uLong)(ptm->tm_mday) + (32 * (uLong)(ptm->tm_mon+1)) + (512 * year)) << 16) |
341 ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); 327 (((uLong)ptm->tm_sec/2) + (32 * (uLong)ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
342 } 328 }
343 329
344 330
345 /****************************************************************************/ 331 /****************************************************************************/
346 332
347 local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)); 333 local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int* pi) {
348
349 local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)
350 {
351 unsigned char c; 334 unsigned char c;
352 int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1); 335 int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
353 if (err==1) 336 if (err==1)
354 { 337 {
355 *pi = (int)c; 338 *pi = (int)c;
366 349
367 350
368 /* =========================================================================== 351 /* ===========================================================================
369 Reads a long in LSB order from the given gz_stream. Sets 352 Reads a long in LSB order from the given gz_stream. Sets
370 */ 353 */
371 local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); 354 local int zip64local_getShort(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) {
372
373 local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
374 {
375 uLong x ; 355 uLong x ;
376 int i = 0; 356 int i = 0;
377 int err; 357 int err;
378 358
379 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 359 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
388 else 368 else
389 *pX = 0; 369 *pX = 0;
390 return err; 370 return err;
391 } 371 }
392 372
393 local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); 373 local int zip64local_getLong(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) {
394
395 local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
396 {
397 uLong x ; 374 uLong x ;
398 int i = 0; 375 int i = 0;
399 int err; 376 int err;
400 377
401 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 378 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
418 else 395 else
419 *pX = 0; 396 *pX = 0;
420 return err; 397 return err;
421 } 398 }
422 399
423 local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)); 400
424 401 local int zip64local_getLong64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) {
425
426 local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
427 {
428 ZPOS64_T x; 402 ZPOS64_T x;
429 int i = 0; 403 int i = 0;
430 int err; 404 int err;
431 405
432 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 406 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
473 #endif 447 #endif
474 /* 448 /*
475 Locate the Central directory of a zipfile (at the end, just before 449 Locate the Central directory of a zipfile (at the end, just before
476 the global comment) 450 the global comment)
477 */ 451 */
478 local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); 452 local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) {
479
480 local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
481 {
482 unsigned char* buf; 453 unsigned char* buf;
483 ZPOS64_T uSizeFile; 454 ZPOS64_T uSizeFile;
484 ZPOS64_T uBackRead; 455 ZPOS64_T uBackRead;
485 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ 456 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
486 ZPOS64_T uPosFound=0; 457 ZPOS64_T uPosFound=0;
520 491
521 for (i=(int)uReadSize-3; (i--)>0;) 492 for (i=(int)uReadSize-3; (i--)>0;)
522 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 493 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
523 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) 494 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
524 { 495 {
525 uPosFound = uReadPos+i; 496 uPosFound = uReadPos+(unsigned)i;
526 break; 497 break;
527 } 498 }
528 499
529 if (uPosFound!=0) 500 if (uPosFound!=0)
530 break; 501 break;
531 } 502 }
532 TRYFREE(buf); 503 free(buf);
533 return uPosFound; 504 return uPosFound;
534 } 505 }
535 506
536 /* 507 /*
537 Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before 508 Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
538 the global comment) 509 the global comment)
539 */ 510 */
540 local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); 511 local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) {
541
542 local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
543 {
544 unsigned char* buf; 512 unsigned char* buf;
545 ZPOS64_T uSizeFile; 513 ZPOS64_T uSizeFile;
546 ZPOS64_T uBackRead; 514 ZPOS64_T uBackRead;
547 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ 515 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
548 ZPOS64_T uPosFound=0; 516 ZPOS64_T uPosFound=0;
584 for (i=(int)uReadSize-3; (i--)>0;) 552 for (i=(int)uReadSize-3; (i--)>0;)
585 { 553 {
586 // Signature "0x07064b50" Zip64 end of central directory locater 554 // Signature "0x07064b50" Zip64 end of central directory locater
587 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) 555 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
588 { 556 {
589 uPosFound = uReadPos+i; 557 uPosFound = uReadPos+(unsigned)i;
590 break; 558 break;
591 } 559 }
592 } 560 }
593 561
594 if (uPosFound!=0) 562 if (uPosFound!=0)
595 break; 563 break;
596 } 564 }
597 565
598 TRYFREE(buf); 566 free(buf);
599 if (uPosFound == 0) 567 if (uPosFound == 0)
600 return 0; 568 return 0;
601 569
602 /* Zip64 end of central directory locator */ 570 /* Zip64 end of central directory locator */
603 if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0) 571 if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
635 return 0; 603 return 0;
636 604
637 return relativeOffset; 605 return relativeOffset;
638 } 606 }
639 607
640 int LoadCentralDirectoryRecord(zip64_internal* pziinit) 608 local int LoadCentralDirectoryRecord(zip64_internal* pziinit) {
641 {
642 int err=ZIP_OK; 609 int err=ZIP_OK;
643 ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 610 ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
644 611
645 ZPOS64_T size_central_dir; /* size of the central directory */ 612 ZPOS64_T size_central_dir; /* size of the central directory */
646 ZPOS64_T offset_central_dir; /* offset of start of central directory */ 613 ZPOS64_T offset_central_dir; /* offset of start of central directory */
647 ZPOS64_T central_pos; 614 ZPOS64_T central_pos;
648 uLong uL; 615 uLong uL;
649 616
650 uLong number_disk; /* number of the current dist, used for 617 uLong number_disk; /* number of the current disk, used for
651 spaning ZIP, unsupported, always 0*/ 618 spanning ZIP, unsupported, always 0*/
652 uLong number_disk_with_CD; /* number the the disk with central dir, used 619 uLong number_disk_with_CD; /* number of the disk with central dir, used
653 for spaning ZIP, unsupported, always 0*/ 620 for spanning ZIP, unsupported, always 0*/
654 ZPOS64_T number_entry; 621 ZPOS64_T number_entry;
655 ZPOS64_T number_entry_CD; /* total number of entries in 622 ZPOS64_T number_entry_CD; /* total number of entries in
656 the central dir 623 the central dir
657 (same than number_entry on nospan) */ 624 (same than number_entry on nospan) */
658 uLong VersionMadeBy; 625 uLong VersionMadeBy;
828 if (err==ZIP_OK) 795 if (err==ZIP_OK)
829 err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this); 796 err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
830 797
831 size_central_dir_to_read-=read_this; 798 size_central_dir_to_read-=read_this;
832 } 799 }
833 TRYFREE(buf_read); 800 free(buf_read);
834 } 801 }
835 pziinit->begin_pos = byte_before_the_zipfile; 802 pziinit->begin_pos = byte_before_the_zipfile;
836 pziinit->number_entry = number_entry_CD; 803 pziinit->number_entry = number_entry_CD;
837 804
838 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0) 805 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
844 811
845 #endif /* !NO_ADDFILEINEXISTINGZIP*/ 812 #endif /* !NO_ADDFILEINEXISTINGZIP*/
846 813
847 814
848 /************************************************************/ 815 /************************************************************/
849 extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) 816 extern zipFile ZEXPORT zipOpen3(const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) {
850 {
851 zip64_internal ziinit; 817 zip64_internal ziinit;
852 zip64_internal* zi; 818 zip64_internal* zi;
853 int err=ZIP_OK; 819 int err=ZIP_OK;
854 820
855 ziinit.z_filefunc.zseek32_file = NULL; 821 ziinit.z_filefunc.zseek32_file = NULL;
903 # endif /* !NO_ADDFILEINEXISTINGZIP*/ 869 # endif /* !NO_ADDFILEINEXISTINGZIP*/
904 870
905 if (err != ZIP_OK) 871 if (err != ZIP_OK)
906 { 872 {
907 # ifndef NO_ADDFILEINEXISTINGZIP 873 # ifndef NO_ADDFILEINEXISTINGZIP
908 TRYFREE(ziinit.globalcomment); 874 free(ziinit.globalcomment);
909 # endif /* !NO_ADDFILEINEXISTINGZIP*/ 875 # endif /* !NO_ADDFILEINEXISTINGZIP*/
910 TRYFREE(zi); 876 free(zi);
911 return NULL; 877 return NULL;
912 } 878 }
913 else 879 else
914 { 880 {
915 *zi = ziinit; 881 *zi = ziinit;
916 return (zipFile)zi; 882 return (zipFile)zi;
917 } 883 }
918 } 884 }
919 885
920 extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def) 886 extern zipFile ZEXPORT zipOpen2(const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def) {
921 {
922 if (pzlib_filefunc32_def != NULL) 887 if (pzlib_filefunc32_def != NULL)
923 { 888 {
924 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; 889 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
925 fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); 890 fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
926 return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); 891 return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
927 } 892 }
928 else 893 else
929 return zipOpen3(pathname, append, globalcomment, NULL); 894 return zipOpen3(pathname, append, globalcomment, NULL);
930 } 895 }
931 896
932 extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def) 897 extern zipFile ZEXPORT zipOpen2_64(const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def) {
933 {
934 if (pzlib_filefunc_def != NULL) 898 if (pzlib_filefunc_def != NULL)
935 { 899 {
936 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; 900 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
937 zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; 901 zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
938 zlib_filefunc64_32_def_fill.ztell32_file = NULL; 902 zlib_filefunc64_32_def_fill.ztell32_file = NULL;
943 return zipOpen3(pathname, append, globalcomment, NULL); 907 return zipOpen3(pathname, append, globalcomment, NULL);
944 } 908 }
945 909
946 910
947 911
948 extern zipFile ZEXPORT zipOpen (const char* pathname, int append) 912 extern zipFile ZEXPORT zipOpen(const char* pathname, int append) {
949 {
950 return zipOpen3((const void*)pathname,append,NULL,NULL); 913 return zipOpen3((const void*)pathname,append,NULL,NULL);
951 } 914 }
952 915
953 extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append) 916 extern zipFile ZEXPORT zipOpen64(const void* pathname, int append) {
954 {
955 return zipOpen3(pathname,append,NULL,NULL); 917 return zipOpen3(pathname,append,NULL,NULL);
956 } 918 }
957 919
958 int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) 920 local int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) {
959 {
960 /* write the local header */ 921 /* write the local header */
961 int err; 922 int err;
962 uInt size_filename = (uInt)strlen(filename); 923 uInt size_filename = (uInt)strlen(filename);
963 uInt size_extrafield = size_extrafield_local; 924 uInt size_extrafield = size_extrafield_local;
964 925
1032 ZPOS64_T UncompressedSize = 0; 993 ZPOS64_T UncompressedSize = 0;
1033 994
1034 // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) 995 // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
1035 zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); 996 zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
1036 997
1037 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2); 998 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)HeaderID,2);
1038 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2); 999 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)DataSize,2);
1039 1000
1040 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); 1001 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
1041 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); 1002 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
1042 } 1003 }
1043 1004
1050 before calling this function it can be done with zipRemoveExtraInfoBlock 1011 before calling this function it can be done with zipRemoveExtraInfoBlock
1051 1012
1052 It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize 1013 It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize
1053 unnecessary allocations. 1014 unnecessary allocations.
1054 */ 1015 */
1055 extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, 1016 extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1056 const void* extrafield_local, uInt size_extrafield_local, 1017 const void* extrafield_local, uInt size_extrafield_local,
1057 const void* extrafield_global, uInt size_extrafield_global, 1018 const void* extrafield_global, uInt size_extrafield_global,
1058 const char* comment, int method, int level, int raw, 1019 const char* comment, int method, int level, int raw,
1059 int windowBits,int memLevel, int strategy, 1020 int windowBits,int memLevel, int strategy,
1060 const char* password, uLong crcForCrypting, 1021 const char* password, uLong crcForCrypting,
1061 uLong versionMadeBy, uLong flagBase, int zip64) 1022 uLong versionMadeBy, uLong flagBase, int zip64) {
1062 {
1063 zip64_internal* zi; 1023 zip64_internal* zi;
1064 uInt size_filename; 1024 uInt size_filename;
1065 uInt size_comment; 1025 uInt size_comment;
1066 uInt i; 1026 uInt i;
1067 int err = ZIP_OK; 1027 int err = ZIP_OK;
1080 return ZIP_PARAMERROR; 1040 return ZIP_PARAMERROR;
1081 #else 1041 #else
1082 if ((method!=0) && (method!=Z_DEFLATED)) 1042 if ((method!=0) && (method!=Z_DEFLATED))
1083 return ZIP_PARAMERROR; 1043 return ZIP_PARAMERROR;
1084 #endif 1044 #endif
1045
1046 // The filename and comment length must fit in 16 bits.
1047 if ((filename!=NULL) && (strlen(filename)>0xffff))
1048 return ZIP_PARAMERROR;
1049 if ((comment!=NULL) && (strlen(comment)>0xffff))
1050 return ZIP_PARAMERROR;
1051 // The extra field length must fit in 16 bits. If the member also requires
1052 // a Zip64 extra block, that will also need to fit within that 16-bit
1053 // length, but that will be checked for later.
1054 if ((size_extrafield_local>0xffff) || (size_extrafield_global>0xffff))
1055 return ZIP_PARAMERROR;
1085 1056
1086 zi = (zip64_internal*)file; 1057 zi = (zip64_internal*)file;
1087 1058
1088 if (zi->in_opened_file_inzip == 1) 1059 if (zi->in_opened_file_inzip == 1)
1089 { 1060 {
1260 if (err==Z_OK) 1231 if (err==Z_OK)
1261 zi->in_opened_file_inzip = 1; 1232 zi->in_opened_file_inzip = 1;
1262 return err; 1233 return err;
1263 } 1234 }
1264 1235
1265 extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi, 1236 extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1266 const void* extrafield_local, uInt size_extrafield_local, 1237 const void* extrafield_local, uInt size_extrafield_local,
1267 const void* extrafield_global, uInt size_extrafield_global, 1238 const void* extrafield_global, uInt size_extrafield_global,
1268 const char* comment, int method, int level, int raw, 1239 const char* comment, int method, int level, int raw,
1269 int windowBits,int memLevel, int strategy, 1240 int windowBits,int memLevel, int strategy,
1270 const char* password, uLong crcForCrypting, 1241 const char* password, uLong crcForCrypting,
1271 uLong versionMadeBy, uLong flagBase) 1242 uLong versionMadeBy, uLong flagBase) {
1272 { 1243 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1273 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1244 extrafield_local, size_extrafield_local,
1274 extrafield_local, size_extrafield_local, 1245 extrafield_global, size_extrafield_global,
1275 extrafield_global, size_extrafield_global, 1246 comment, method, level, raw,
1276 comment, method, level, raw, 1247 windowBits, memLevel, strategy,
1277 windowBits, memLevel, strategy, 1248 password, crcForCrypting, versionMadeBy, flagBase, 0);
1278 password, crcForCrypting, versionMadeBy, flagBase, 0); 1249 }
1279 } 1250
1280 1251 extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1281 extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi, 1252 const void* extrafield_local, uInt size_extrafield_local,
1282 const void* extrafield_local, uInt size_extrafield_local, 1253 const void* extrafield_global, uInt size_extrafield_global,
1283 const void* extrafield_global, uInt size_extrafield_global, 1254 const char* comment, int method, int level, int raw,
1284 const char* comment, int method, int level, int raw, 1255 int windowBits,int memLevel, int strategy,
1285 int windowBits,int memLevel, int strategy, 1256 const char* password, uLong crcForCrypting) {
1286 const char* password, uLong crcForCrypting) 1257 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1287 { 1258 extrafield_local, size_extrafield_local,
1288 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1259 extrafield_global, size_extrafield_global,
1289 extrafield_local, size_extrafield_local, 1260 comment, method, level, raw,
1290 extrafield_global, size_extrafield_global, 1261 windowBits, memLevel, strategy,
1291 comment, method, level, raw, 1262 password, crcForCrypting, VERSIONMADEBY, 0, 0);
1292 windowBits, memLevel, strategy,
1293 password, crcForCrypting, VERSIONMADEBY, 0, 0);
1294 } 1263 }
1295 1264
1296 extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1265 extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1297 const void* extrafield_local, uInt size_extrafield_local, 1266 const void* extrafield_local, uInt size_extrafield_local,
1298 const void* extrafield_global, uInt size_extrafield_global, 1267 const void* extrafield_global, uInt size_extrafield_global,
1299 const char* comment, int method, int level, int raw, 1268 const char* comment, int method, int level, int raw,
1300 int windowBits,int memLevel, int strategy, 1269 int windowBits,int memLevel, int strategy,
1301 const char* password, uLong crcForCrypting, int zip64) 1270 const char* password, uLong crcForCrypting, int zip64) {
1302 { 1271 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1303 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1272 extrafield_local, size_extrafield_local,
1304 extrafield_local, size_extrafield_local, 1273 extrafield_global, size_extrafield_global,
1305 extrafield_global, size_extrafield_global, 1274 comment, method, level, raw,
1306 comment, method, level, raw, 1275 windowBits, memLevel, strategy,
1307 windowBits, memLevel, strategy, 1276 password, crcForCrypting, VERSIONMADEBY, 0, zip64);
1308 password, crcForCrypting, VERSIONMADEBY, 0, zip64);
1309 } 1277 }
1310 1278
1311 extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1279 extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1312 const void* extrafield_local, uInt size_extrafield_local, 1280 const void* extrafield_local, uInt size_extrafield_local,
1313 const void* extrafield_global, uInt size_extrafield_global, 1281 const void* extrafield_global, uInt size_extrafield_global,
1314 const char* comment, int method, int level, int raw) 1282 const char* comment, int method, int level, int raw) {
1315 { 1283 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1316 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1284 extrafield_local, size_extrafield_local,
1317 extrafield_local, size_extrafield_local, 1285 extrafield_global, size_extrafield_global,
1318 extrafield_global, size_extrafield_global, 1286 comment, method, level, raw,
1319 comment, method, level, raw, 1287 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1320 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1288 NULL, 0, VERSIONMADEBY, 0, 0);
1321 NULL, 0, VERSIONMADEBY, 0, 0);
1322 } 1289 }
1323 1290
1324 extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1291 extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1325 const void* extrafield_local, uInt size_extrafield_local, 1292 const void* extrafield_local, uInt size_extrafield_local,
1326 const void* extrafield_global, uInt size_extrafield_global, 1293 const void* extrafield_global, uInt size_extrafield_global,
1327 const char* comment, int method, int level, int raw, int zip64) 1294 const char* comment, int method, int level, int raw, int zip64) {
1328 { 1295 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1329 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1296 extrafield_local, size_extrafield_local,
1330 extrafield_local, size_extrafield_local, 1297 extrafield_global, size_extrafield_global,
1331 extrafield_global, size_extrafield_global, 1298 comment, method, level, raw,
1332 comment, method, level, raw, 1299 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1333 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1300 NULL, 0, VERSIONMADEBY, 0, zip64);
1334 NULL, 0, VERSIONMADEBY, 0, zip64); 1301 }
1335 } 1302
1336 1303 extern int ZEXPORT zipOpenNewFileInZip64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1337 extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, 1304 const void* extrafield_local, uInt size_extrafield_local,
1338 const void* extrafield_local, uInt size_extrafield_local, 1305 const void*extrafield_global, uInt size_extrafield_global,
1339 const void*extrafield_global, uInt size_extrafield_global, 1306 const char* comment, int method, int level, int zip64) {
1340 const char* comment, int method, int level, int zip64) 1307 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1341 { 1308 extrafield_local, size_extrafield_local,
1342 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1309 extrafield_global, size_extrafield_global,
1343 extrafield_local, size_extrafield_local, 1310 comment, method, level, 0,
1344 extrafield_global, size_extrafield_global, 1311 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1345 comment, method, level, 0, 1312 NULL, 0, VERSIONMADEBY, 0, zip64);
1346 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1313 }
1347 NULL, 0, VERSIONMADEBY, 0, zip64); 1314
1348 } 1315 extern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1349 1316 const void* extrafield_local, uInt size_extrafield_local,
1350 extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi, 1317 const void*extrafield_global, uInt size_extrafield_global,
1351 const void* extrafield_local, uInt size_extrafield_local, 1318 const char* comment, int method, int level) {
1352 const void*extrafield_global, uInt size_extrafield_global, 1319 return zipOpenNewFileInZip4_64(file, filename, zipfi,
1353 const char* comment, int method, int level) 1320 extrafield_local, size_extrafield_local,
1354 { 1321 extrafield_global, size_extrafield_global,
1355 return zipOpenNewFileInZip4_64 (file, filename, zipfi, 1322 comment, method, level, 0,
1356 extrafield_local, size_extrafield_local, 1323 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1357 extrafield_global, size_extrafield_global, 1324 NULL, 0, VERSIONMADEBY, 0, 0);
1358 comment, method, level, 0, 1325 }
1359 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1326
1360 NULL, 0, VERSIONMADEBY, 0, 0); 1327 local int zip64FlushWriteBuffer(zip64_internal* zi) {
1361 }
1362
1363 local int zip64FlushWriteBuffer(zip64_internal* zi)
1364 {
1365 int err=ZIP_OK; 1328 int err=ZIP_OK;
1366 1329
1367 if (zi->ci.encrypt != 0) 1330 if (zi->ci.encrypt != 0)
1368 { 1331 {
1369 #ifndef NOCRYPT 1332 #ifndef NOCRYPT
1397 zi->ci.pos_in_buffered_data = 0; 1360 zi->ci.pos_in_buffered_data = 0;
1398 1361
1399 return err; 1362 return err;
1400 } 1363 }
1401 1364
1402 extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len) 1365 extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void* buf, unsigned int len) {
1403 {
1404 zip64_internal* zi; 1366 zip64_internal* zi;
1405 int err=ZIP_OK; 1367 int err=ZIP_OK;
1406 1368
1407 if (file == NULL) 1369 if (file == NULL)
1408 return ZIP_PARAMERROR; 1370 return ZIP_PARAMERROR;
1448 err = ZIP_OK; 1410 err = ZIP_OK;
1449 } 1411 }
1450 else 1412 else
1451 #endif 1413 #endif
1452 { 1414 {
1453 zi->ci.stream.next_in = (Bytef*)buf; 1415 zi->ci.stream.next_in = (Bytef*)(uintptr_t)buf;
1454 zi->ci.stream.avail_in = len; 1416 zi->ci.stream.avail_in = len;
1455 1417
1456 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) 1418 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
1457 { 1419 {
1458 if (zi->ci.stream.avail_out == 0) 1420 if (zi->ci.stream.avail_out == 0)
1469 1431
1470 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1432 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1471 { 1433 {
1472 uLong uTotalOutBefore = zi->ci.stream.total_out; 1434 uLong uTotalOutBefore = zi->ci.stream.total_out;
1473 err=deflate(&zi->ci.stream, Z_NO_FLUSH); 1435 err=deflate(&zi->ci.stream, Z_NO_FLUSH);
1474 if(uTotalOutBefore > zi->ci.stream.total_out)
1475 {
1476 int bBreak = 0;
1477 bBreak++;
1478 }
1479 1436
1480 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 1437 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1481 } 1438 }
1482 else 1439 else
1483 { 1440 {
1504 } 1461 }
1505 1462
1506 return err; 1463 return err;
1507 } 1464 }
1508 1465
1509 extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32) 1466 extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uLong uncompressed_size, uLong crc32) {
1510 {
1511 return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32); 1467 return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
1512 } 1468 }
1513 1469
1514 extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32) 1470 extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_size, uLong crc32) {
1515 {
1516 zip64_internal* zi; 1471 zip64_internal* zi;
1517 ZPOS64_T compressed_size; 1472 ZPOS64_T compressed_size;
1518 uLong invalidValue = 0xffffffff; 1473 uLong invalidValue = 0xffffffff;
1519 short datasize = 0; 1474 unsigned datasize = 0;
1520 int err=ZIP_OK; 1475 int err=ZIP_OK;
1521 1476
1522 if (file == NULL) 1477 if (file == NULL)
1523 return ZIP_PARAMERROR; 1478 return ZIP_PARAMERROR;
1524 zi = (zip64_internal*)file; 1479 zi = (zip64_internal*)file;
1745 zi->in_opened_file_inzip = 0; 1700 zi->in_opened_file_inzip = 0;
1746 1701
1747 return err; 1702 return err;
1748 } 1703 }
1749 1704
1750 extern int ZEXPORT zipCloseFileInZip (zipFile file) 1705 extern int ZEXPORT zipCloseFileInZip(zipFile file) {
1751 {
1752 return zipCloseFileInZipRaw (file,0,0); 1706 return zipCloseFileInZipRaw (file,0,0);
1753 } 1707 }
1754 1708
1755 int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) 1709 local int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) {
1756 {
1757 int err = ZIP_OK; 1710 int err = ZIP_OK;
1758 ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset; 1711 ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset;
1759 1712
1760 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4); 1713 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
1761 1714
1772 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4); 1725 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
1773 1726
1774 return err; 1727 return err;
1775 } 1728 }
1776 1729
1777 int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) 1730 local int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) {
1778 {
1779 int err = ZIP_OK; 1731 int err = ZIP_OK;
1780 1732
1781 uLong Zip64DataSize = 44; 1733 uLong Zip64DataSize = 44;
1782 1734
1783 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4); 1735 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
1811 ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset; 1763 ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
1812 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8); 1764 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
1813 } 1765 }
1814 return err; 1766 return err;
1815 } 1767 }
1816 int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) 1768
1817 { 1769 local int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) {
1818 int err = ZIP_OK; 1770 int err = ZIP_OK;
1819 1771
1820 /*signature*/ 1772 /*signature*/
1821 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); 1773 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1822 1774
1859 } 1811 }
1860 1812
1861 return err; 1813 return err;
1862 } 1814 }
1863 1815
1864 int Write_GlobalComment(zip64_internal* zi, const char* global_comment) 1816 local int Write_GlobalComment(zip64_internal* zi, const char* global_comment) {
1865 {
1866 int err = ZIP_OK; 1817 int err = ZIP_OK;
1867 uInt size_global_comment = 0; 1818 uInt size_global_comment = 0;
1868 1819
1869 if(global_comment != NULL) 1820 if(global_comment != NULL)
1870 size_global_comment = (uInt)strlen(global_comment); 1821 size_global_comment = (uInt)strlen(global_comment);
1877 err = ZIP_ERRNO; 1828 err = ZIP_ERRNO;
1878 } 1829 }
1879 return err; 1830 return err;
1880 } 1831 }
1881 1832
1882 extern int ZEXPORT zipClose (zipFile file, const char* global_comment) 1833 extern int ZEXPORT zipClose(zipFile file, const char* global_comment) {
1883 {
1884 zip64_internal* zi; 1834 zip64_internal* zi;
1885 int err = 0; 1835 int err = 0;
1886 uLong size_centraldir = 0; 1836 uLong size_centraldir = 0;
1887 ZPOS64_T centraldir_pos_inzip; 1837 ZPOS64_T centraldir_pos_inzip;
1888 ZPOS64_T pos; 1838 ZPOS64_T pos;
1920 } 1870 }
1921 } 1871 }
1922 free_linkedlist(&(zi->central_dir)); 1872 free_linkedlist(&(zi->central_dir));
1923 1873
1924 pos = centraldir_pos_inzip - zi->add_position_when_writing_offset; 1874 pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
1925 if(pos >= 0xffffffff || zi->number_entry > 0xFFFF) 1875 if(pos >= 0xffffffff || zi->number_entry >= 0xFFFF)
1926 { 1876 {
1927 ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream); 1877 ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
1928 Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); 1878 Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
1929 1879
1930 Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos); 1880 Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
1939 if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0) 1889 if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
1940 if (err == ZIP_OK) 1890 if (err == ZIP_OK)
1941 err = ZIP_ERRNO; 1891 err = ZIP_ERRNO;
1942 1892
1943 #ifndef NO_ADDFILEINEXISTINGZIP 1893 #ifndef NO_ADDFILEINEXISTINGZIP
1944 TRYFREE(zi->globalcomment); 1894 free(zi->globalcomment);
1945 #endif 1895 #endif
1946 TRYFREE(zi); 1896 free(zi);
1947 1897
1948 return err; 1898 return err;
1949 } 1899 }
1950 1900
1951 extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader) 1901 extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHeader) {
1952 {
1953 char* p = pData; 1902 char* p = pData;
1954 int size = 0; 1903 int size = 0;
1955 char* pNewHeader; 1904 char* pNewHeader;
1956 char* pTmp; 1905 char* pTmp;
1957 short header; 1906 short header;
1958 short dataSize; 1907 short dataSize;
1959 1908
1960 int retVal = ZIP_OK; 1909 int retVal = ZIP_OK;
1961 1910
1962 if(pData == NULL || *dataLen < 4) 1911 if(pData == NULL || dataLen == NULL || *dataLen < 4)
1963 return ZIP_PARAMERROR; 1912 return ZIP_PARAMERROR;
1964 1913
1965 pNewHeader = (char*)ALLOC(*dataLen); 1914 pNewHeader = (char*)ALLOC((unsigned)*dataLen);
1966 pTmp = pNewHeader; 1915 pTmp = pNewHeader;
1967 1916
1968 while(p < (pData + *dataLen)) 1917 while(p < (pData + *dataLen))
1969 { 1918 {
1970 header = *(short*)p; 1919 header = *(short*)p;
1999 retVal = ZIP_OK; 1948 retVal = ZIP_OK;
2000 } 1949 }
2001 else 1950 else
2002 retVal = ZIP_ERRNO; 1951 retVal = ZIP_ERRNO;
2003 1952
2004 TRYFREE(pNewHeader); 1953 free(pNewHeader);
2005 1954
2006 return retVal; 1955 return retVal;
2007 } 1956 }