1 /* zip.c -- IO on .zip files using zlib 2 Version 1.1, February 14h, 2010 3 part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) 4 5 Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) 6 7 Modifications for Zip64 support 8 Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) 9 10 For more info read MiniZip_info.txt 11 12 Changes 13 Oct-2009 - Mathias Svensson - Remove old C style function prototypes 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. 16 Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data 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. 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 21 22 */ 23 24 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <stdint.h> 29 #include <time.h> 30 #include "zlib.h" 31 #include "zip.h" 32 33 #ifdef STDC 34 # include <stddef.h> 35 #endif 36 #ifdef NO_ERRNO_H 37 extern int errno; 38 #else 39 # include <errno.h> 40 #endif 41 42 43 #ifndef local 44 # define local static 45 #endif 46 /* compile with -Dlocal if your debugger can't find static symbols */ 47 48 #ifndef VERSIONMADEBY 49 # define VERSIONMADEBY (0x0) /* platform dependent */ 50 #endif 51 52 #ifndef Z_BUFSIZE 53 #define Z_BUFSIZE (64*1024) //(16384) 54 #endif 55 56 #ifndef Z_MAXFILENAMEINZIP 57 #define Z_MAXFILENAMEINZIP (256) 58 #endif 59 60 #ifndef ALLOC 61 # define ALLOC(size) (malloc(size)) 62 #endif 63 64 /* 65 #define SIZECENTRALDIRITEM (0x2e) 66 #define SIZEZIPLOCALHEADER (0x1e) 67 */ 68 69 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ 70 71 72 // NOT sure that this work on ALL platform 73 #define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32)) 74 75 #ifndef SEEK_CUR 76 #define SEEK_CUR 1 77 #endif 78 79 #ifndef SEEK_END 80 #define SEEK_END 2 81 #endif 82 83 #ifndef SEEK_SET 84 #define SEEK_SET 0 85 #endif 86 87 #ifndef DEF_MEM_LEVEL 88 #if MAX_MEM_LEVEL >= 8 89 # define DEF_MEM_LEVEL 8 90 #else 91 # define DEF_MEM_LEVEL MAX_MEM_LEVEL 92 #endif 93 #endif 94 const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; 95 96 97 #define SIZEDATA_INDATABLOCK (4096-(4*4)) 98 99 #define LOCALHEADERMAGIC (0x04034b50) 100 #define CENTRALHEADERMAGIC (0x02014b50) 101 #define ENDHEADERMAGIC (0x06054b50) 102 #define ZIP64ENDHEADERMAGIC (0x6064b50) 103 #define ZIP64ENDLOCHEADERMAGIC (0x7064b50) 104 105 #define FLAG_LOCALHEADER_OFFSET (0x06) 106 #define CRC_LOCALHEADER_OFFSET (0x0e) 107 108 #define SIZECENTRALHEADER (0x2e) /* 46 */ 109 110 typedef struct linkedlist_datablock_internal_s 111 { 112 struct linkedlist_datablock_internal_s* next_datablock; 113 uLong avail_in_this_block; 114 uLong filled_in_this_block; 115 uLong unused; /* for future use and alignment */ 116 unsigned char data[SIZEDATA_INDATABLOCK]; 117 } linkedlist_datablock_internal; 118 119 typedef struct linkedlist_data_s 120 { 121 linkedlist_datablock_internal* first_block; 122 linkedlist_datablock_internal* last_block; 123 } linkedlist_data; 124 125 126 typedef struct 127 { 128 z_stream stream; /* zLib stream structure for inflate */ 129 #ifdef HAVE_BZIP2 130 bz_stream bstream; /* bzLib stream structure for bziped */ 131 #endif 132 133 int stream_initialised; /* 1 is stream is initialised */ 134 uInt pos_in_buffered_data; /* last written byte in buffered_data */ 135 136 ZPOS64_T pos_local_header; /* offset of the local header of the file 137 currently writing */ 138 char* central_header; /* central header data for the current file */ 139 uLong size_centralExtra; 140 uLong size_centralheader; /* size of the central header for cur file */ 141 uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */ 142 uLong flag; /* flag of the file currently writing */ 143 144 int method; /* compression method of file currently wr.*/ 145 int raw; /* 1 for directly writing raw data */ 146 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ 147 uLong dosDate; 148 uLong crc32; 149 int encrypt; 150 int zip64; /* Add ZIP64 extended information in the extra field */ 151 ZPOS64_T pos_zip64extrainfo; 152 ZPOS64_T totalCompressedData; 153 ZPOS64_T totalUncompressedData; 154 #ifndef NOCRYPT 155 unsigned long keys[3]; /* keys defining the pseudo-random sequence */ 156 const z_crc_t* pcrc_32_tab; 157 unsigned crypt_header_size; 158 #endif 159 } curfile64_info; 160 161 typedef struct 162 { 163 zlib_filefunc64_32_def z_filefunc; 164 voidpf filestream; /* io structure of the zipfile */ 165 linkedlist_data central_dir;/* datablock with central dir in construction*/ 166 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ 167 curfile64_info ci; /* info on the file currently writing */ 168 169 ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ 170 ZPOS64_T add_position_when_writing_offset; 171 ZPOS64_T number_entry; 172 173 #ifndef NO_ADDFILEINEXISTINGZIP 174 char *globalcomment; 175 #endif 176 177 } zip64_internal; 178 179 180 #ifndef NOCRYPT 181 #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED 182 #include "crypt.h" 183 #endif 184 185 local linkedlist_datablock_internal* allocate_new_datablock(void) { 186 linkedlist_datablock_internal* ldi; 187 ldi = (linkedlist_datablock_internal*) 188 ALLOC(sizeof(linkedlist_datablock_internal)); 189 if (ldi!=NULL) 190 { 191 ldi->next_datablock = NULL ; 192 ldi->filled_in_this_block = 0 ; 193 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; 194 } 195 return ldi; 196 } 197 198 local void free_datablock(linkedlist_datablock_internal* ldi) { 199 while (ldi!=NULL) 200 { 201 linkedlist_datablock_internal* ldinext = ldi->next_datablock; 202 free(ldi); 203 ldi = ldinext; 204 } 205 } 206 207 local void init_linkedlist(linkedlist_data* ll) { 208 ll->first_block = ll->last_block = NULL; 209 } 210 211 local void free_linkedlist(linkedlist_data* ll) { 212 free_datablock(ll->first_block); 213 ll->first_block = ll->last_block = NULL; 214 } 215 216 217 local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) { 218 linkedlist_datablock_internal* ldi; 219 const unsigned char* from_copy; 220 221 if (ll==NULL) 222 return ZIP_INTERNALERROR; 223 224 if (ll->last_block == NULL) 225 { 226 ll->first_block = ll->last_block = allocate_new_datablock(); 227 if (ll->first_block == NULL) 228 return ZIP_INTERNALERROR; 229 } 230 231 ldi = ll->last_block; 232 from_copy = (const unsigned char*)buf; 233 234 while (len>0) 235 { 236 uInt copy_this; 237 uInt i; 238 unsigned char* to_copy; 239 240 if (ldi->avail_in_this_block==0) 241 { 242 ldi->next_datablock = allocate_new_datablock(); 243 if (ldi->next_datablock == NULL) 244 return ZIP_INTERNALERROR; 245 ldi = ldi->next_datablock ; 246 ll->last_block = ldi; 247 } 248 249 if (ldi->avail_in_this_block < len) 250 copy_this = (uInt)ldi->avail_in_this_block; 251 else 252 copy_this = (uInt)len; 253 254 to_copy = &(ldi->data[ldi->filled_in_this_block]); 255 256 for (i=0;i<copy_this;i++) 257 *(to_copy+i)=*(from_copy+i); 258 259 ldi->filled_in_this_block += copy_this; 260 ldi->avail_in_this_block -= copy_this; 261 from_copy += copy_this ; 262 len -= copy_this; 263 } 264 return ZIP_OK; 265 } 266 267 268 269 /****************************************************************************/ 270 271 #ifndef NO_ADDFILEINEXISTINGZIP 272 /* =========================================================================== 273 Inputs a long in LSB order to the given file 274 nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) 275 */ 276 277 local int zip64local_putValue(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) { 278 unsigned char buf[8]; 279 int n; 280 for (n = 0; n < nbByte; n++) 281 { 282 buf[n] = (unsigned char)(x & 0xff); 283 x >>= 8; 284 } 285 if (x != 0) 286 { /* data overflow - hack for ZIP64 (X Roche) */ 287 for (n = 0; n < nbByte; n++) 288 { 289 buf[n] = 0xff; 290 } 291 } 292 293 if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,(uLong)nbByte)!=(uLong)nbByte) 294 return ZIP_ERRNO; 295 else 296 return ZIP_OK; 297 } 298 299 local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) { 300 unsigned char* buf=(unsigned char*)dest; 301 int n; 302 for (n = 0; n < nbByte; n++) { 303 buf[n] = (unsigned char)(x & 0xff); 304 x >>= 8; 305 } 306 307 if (x != 0) 308 { /* data overflow - hack for ZIP64 */ 309 for (n = 0; n < nbByte; n++) 310 { 311 buf[n] = 0xff; 312 } 313 } 314 } 315 316 /****************************************************************************/ 317 318 319 local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) { 320 uLong year = (uLong)ptm->tm_year; 321 if (year>=1980) 322 year-=1980; 323 else if (year>=80) 324 year-=80; 325 return 326 (uLong) (((uLong)(ptm->tm_mday) + (32 * (uLong)(ptm->tm_mon+1)) + (512 * year)) << 16) | 327 (((uLong)ptm->tm_sec/2) + (32 * (uLong)ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); 328 } 329 330 331 /****************************************************************************/ 332 333 local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int* pi) { 334 unsigned char c; 335 int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1); 336 if (err==1) 337 { 338 *pi = (int)c; 339 return ZIP_OK; 340 } 341 else 342 { 343 if (ZERROR64(*pzlib_filefunc_def,filestream)) 344 return ZIP_ERRNO; 345 else 346 return ZIP_EOF; 347 } 348 } 349 350 351 /* =========================================================================== 352 Reads a long in LSB order from the given gz_stream. Sets 353 */ 354 local int zip64local_getShort(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) { 355 uLong x ; 356 int i = 0; 357 int err; 358 359 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 360 x = (uLong)i; 361 362 if (err==ZIP_OK) 363 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 364 x += ((uLong)i)<<8; 365 366 if (err==ZIP_OK) 367 *pX = x; 368 else 369 *pX = 0; 370 return err; 371 } 372 373 local int zip64local_getLong(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) { 374 uLong x ; 375 int i = 0; 376 int err; 377 378 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 379 x = (uLong)i; 380 381 if (err==ZIP_OK) 382 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 383 x += ((uLong)i)<<8; 384 385 if (err==ZIP_OK) 386 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 387 x += ((uLong)i)<<16; 388 389 if (err==ZIP_OK) 390 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 391 x += ((uLong)i)<<24; 392 393 if (err==ZIP_OK) 394 *pX = x; 395 else 396 *pX = 0; 397 return err; 398 } 399 400 401 local int zip64local_getLong64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) { 402 ZPOS64_T x; 403 int i = 0; 404 int err; 405 406 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 407 x = (ZPOS64_T)i; 408 409 if (err==ZIP_OK) 410 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 411 x += ((ZPOS64_T)i)<<8; 412 413 if (err==ZIP_OK) 414 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 415 x += ((ZPOS64_T)i)<<16; 416 417 if (err==ZIP_OK) 418 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 419 x += ((ZPOS64_T)i)<<24; 420 421 if (err==ZIP_OK) 422 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 423 x += ((ZPOS64_T)i)<<32; 424 425 if (err==ZIP_OK) 426 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 427 x += ((ZPOS64_T)i)<<40; 428 429 if (err==ZIP_OK) 430 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 431 x += ((ZPOS64_T)i)<<48; 432 433 if (err==ZIP_OK) 434 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); 435 x += ((ZPOS64_T)i)<<56; 436 437 if (err==ZIP_OK) 438 *pX = x; 439 else 440 *pX = 0; 441 442 return err; 443 } 444 445 #ifndef BUFREADCOMMENT 446 #define BUFREADCOMMENT (0x400) 447 #endif 448 /* 449 Locate the Central directory of a zipfile (at the end, just before 450 the global comment) 451 */ 452 local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) { 453 unsigned char* buf; 454 ZPOS64_T uSizeFile; 455 ZPOS64_T uBackRead; 456 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ 457 ZPOS64_T uPosFound=0; 458 459 if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) 460 return 0; 461 462 463 uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); 464 465 if (uMaxBack>uSizeFile) 466 uMaxBack = uSizeFile; 467 468 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); 469 if (buf==NULL) 470 return 0; 471 472 uBackRead = 4; 473 while (uBackRead<uMaxBack) 474 { 475 uLong uReadSize; 476 ZPOS64_T uReadPos ; 477 int i; 478 if (uBackRead+BUFREADCOMMENT>uMaxBack) 479 uBackRead = uMaxBack; 480 else 481 uBackRead+=BUFREADCOMMENT; 482 uReadPos = uSizeFile-uBackRead ; 483 484 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 485 (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); 486 if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) 487 break; 488 489 if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) 490 break; 491 492 for (i=(int)uReadSize-3; (i--)>0;) 493 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 494 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) 495 { 496 uPosFound = uReadPos+(unsigned)i; 497 break; 498 } 499 500 if (uPosFound!=0) 501 break; 502 } 503 free(buf); 504 return uPosFound; 505 } 506 507 /* 508 Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before 509 the global comment) 510 */ 511 local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) { 512 unsigned char* buf; 513 ZPOS64_T uSizeFile; 514 ZPOS64_T uBackRead; 515 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ 516 ZPOS64_T uPosFound=0; 517 uLong uL; 518 ZPOS64_T relativeOffset; 519 520 if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) 521 return 0; 522 523 uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); 524 525 if (uMaxBack>uSizeFile) 526 uMaxBack = uSizeFile; 527 528 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); 529 if (buf==NULL) 530 return 0; 531 532 uBackRead = 4; 533 while (uBackRead<uMaxBack) 534 { 535 uLong uReadSize; 536 ZPOS64_T uReadPos; 537 int i; 538 if (uBackRead+BUFREADCOMMENT>uMaxBack) 539 uBackRead = uMaxBack; 540 else 541 uBackRead+=BUFREADCOMMENT; 542 uReadPos = uSizeFile-uBackRead ; 543 544 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 545 (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); 546 if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) 547 break; 548 549 if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) 550 break; 551 552 for (i=(int)uReadSize-3; (i--)>0;) 553 { 554 // Signature "0x07064b50" Zip64 end of central directory locater 555 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) 556 { 557 uPosFound = uReadPos+(unsigned)i; 558 break; 559 } 560 } 561 562 if (uPosFound!=0) 563 break; 564 } 565 566 free(buf); 567 if (uPosFound == 0) 568 return 0; 569 570 /* Zip64 end of central directory locator */ 571 if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0) 572 return 0; 573 574 /* the signature, already checked */ 575 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) 576 return 0; 577 578 /* number of the disk with the start of the zip64 end of central directory */ 579 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) 580 return 0; 581 if (uL != 0) 582 return 0; 583 584 /* relative offset of the zip64 end of central directory record */ 585 if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK) 586 return 0; 587 588 /* total number of disks */ 589 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) 590 return 0; 591 if (uL != 1) 592 return 0; 593 594 /* Goto Zip64 end of central directory record */ 595 if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0) 596 return 0; 597 598 /* the signature */ 599 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) 600 return 0; 601 602 if (uL != 0x06064b50) // signature of 'Zip64 end of central directory' 603 return 0; 604 605 return relativeOffset; 606 } 607 608 local int LoadCentralDirectoryRecord(zip64_internal* pziinit) { 609 int err=ZIP_OK; 610 ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 611 612 ZPOS64_T size_central_dir; /* size of the central directory */ 613 ZPOS64_T offset_central_dir; /* offset of start of central directory */ 614 ZPOS64_T central_pos; 615 uLong uL; 616 617 uLong number_disk; /* number of the current disk, used for 618 spanning ZIP, unsupported, always 0*/ 619 uLong number_disk_with_CD; /* number of the disk with central dir, used 620 for spanning ZIP, unsupported, always 0*/ 621 ZPOS64_T number_entry; 622 ZPOS64_T number_entry_CD; /* total number of entries in 623 the central dir 624 (same than number_entry on nospan) */ 625 uLong VersionMadeBy; 626 uLong VersionNeeded; 627 uLong size_comment; 628 629 int hasZIP64Record = 0; 630 631 // check first if we find a ZIP64 record 632 central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream); 633 if(central_pos > 0) 634 { 635 hasZIP64Record = 1; 636 } 637 else if(central_pos == 0) 638 { 639 central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream); 640 } 641 642 /* disable to allow appending to empty ZIP archive 643 if (central_pos==0) 644 err=ZIP_ERRNO; 645 */ 646 647 if(hasZIP64Record) 648 { 649 ZPOS64_T sizeEndOfCentralDirectory; 650 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) 651 err=ZIP_ERRNO; 652 653 /* the signature, already checked */ 654 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) 655 err=ZIP_ERRNO; 656 657 /* size of zip64 end of central directory record */ 658 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK) 659 err=ZIP_ERRNO; 660 661 /* version made by */ 662 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK) 663 err=ZIP_ERRNO; 664 665 /* version needed to extract */ 666 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK) 667 err=ZIP_ERRNO; 668 669 /* number of this disk */ 670 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) 671 err=ZIP_ERRNO; 672 673 /* number of the disk with the start of the central directory */ 674 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) 675 err=ZIP_ERRNO; 676 677 /* total number of entries in the central directory on this disk */ 678 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK) 679 err=ZIP_ERRNO; 680 681 /* total number of entries in the central directory */ 682 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK) 683 err=ZIP_ERRNO; 684 685 if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) 686 err=ZIP_BADZIPFILE; 687 688 /* size of the central directory */ 689 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK) 690 err=ZIP_ERRNO; 691 692 /* offset of start of central directory with respect to the 693 starting disk number */ 694 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK) 695 err=ZIP_ERRNO; 696 697 // TODO.. 698 // read the comment from the standard central header. 699 size_comment = 0; 700 } 701 else 702 { 703 // Read End of central Directory info 704 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) 705 err=ZIP_ERRNO; 706 707 /* the signature, already checked */ 708 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) 709 err=ZIP_ERRNO; 710 711 /* number of this disk */ 712 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) 713 err=ZIP_ERRNO; 714 715 /* number of the disk with the start of the central directory */ 716 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) 717 err=ZIP_ERRNO; 718 719 /* total number of entries in the central dir on this disk */ 720 number_entry = 0; 721 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) 722 err=ZIP_ERRNO; 723 else 724 number_entry = uL; 725 726 /* total number of entries in the central dir */ 727 number_entry_CD = 0; 728 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) 729 err=ZIP_ERRNO; 730 else 731 number_entry_CD = uL; 732 733 if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) 734 err=ZIP_BADZIPFILE; 735 736 /* size of the central directory */ 737 size_central_dir = 0; 738 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) 739 err=ZIP_ERRNO; 740 else 741 size_central_dir = uL; 742 743 /* offset of start of central directory with respect to the starting disk number */ 744 offset_central_dir = 0; 745 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) 746 err=ZIP_ERRNO; 747 else 748 offset_central_dir = uL; 749 750 751 /* zipfile global comment length */ 752 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK) 753 err=ZIP_ERRNO; 754 } 755 756 if ((central_pos<offset_central_dir+size_central_dir) && 757 (err==ZIP_OK)) 758 err=ZIP_BADZIPFILE; 759 760 if (err!=ZIP_OK) 761 { 762 ZCLOSE64(pziinit->z_filefunc, pziinit->filestream); 763 return ZIP_ERRNO; 764 } 765 766 if (size_comment>0) 767 { 768 pziinit->globalcomment = (char*)ALLOC(size_comment+1); 769 if (pziinit->globalcomment) 770 { 771 size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment); 772 pziinit->globalcomment[size_comment]=0; 773 } 774 } 775 776 byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir); 777 pziinit->add_position_when_writing_offset = byte_before_the_zipfile; 778 779 { 780 ZPOS64_T size_central_dir_to_read = size_central_dir; 781 size_t buf_size = SIZEDATA_INDATABLOCK; 782 void* buf_read = (void*)ALLOC(buf_size); 783 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) 784 err=ZIP_ERRNO; 785 786 while ((size_central_dir_to_read>0) && (err==ZIP_OK)) 787 { 788 ZPOS64_T read_this = SIZEDATA_INDATABLOCK; 789 if (read_this > size_central_dir_to_read) 790 read_this = size_central_dir_to_read; 791 792 if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this) 793 err=ZIP_ERRNO; 794 795 if (err==ZIP_OK) 796 err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this); 797 798 size_central_dir_to_read-=read_this; 799 } 800 free(buf_read); 801 } 802 pziinit->begin_pos = byte_before_the_zipfile; 803 pziinit->number_entry = number_entry_CD; 804 805 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0) 806 err=ZIP_ERRNO; 807 808 return err; 809 } 810 811 812 #endif /* !NO_ADDFILEINEXISTINGZIP*/ 813 814 815 /************************************************************/ 816 extern zipFile ZEXPORT zipOpen3(const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) { 817 zip64_internal ziinit; 818 zip64_internal* zi; 819 int err=ZIP_OK; 820 821 ziinit.z_filefunc.zseek32_file = NULL; 822 ziinit.z_filefunc.ztell32_file = NULL; 823 if (pzlib_filefunc64_32_def==NULL) 824 fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); 825 else 826 ziinit.z_filefunc = *pzlib_filefunc64_32_def; 827 828 ziinit.filestream = ZOPEN64(ziinit.z_filefunc, 829 pathname, 830 (append == APPEND_STATUS_CREATE) ? 831 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : 832 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); 833 834 if (ziinit.filestream == NULL) 835 return NULL; 836 837 if (append == APPEND_STATUS_CREATEAFTER) 838 ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END); 839 840 ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream); 841 ziinit.in_opened_file_inzip = 0; 842 ziinit.ci.stream_initialised = 0; 843 ziinit.number_entry = 0; 844 ziinit.add_position_when_writing_offset = 0; 845 init_linkedlist(&(ziinit.central_dir)); 846 847 848 849 zi = (zip64_internal*)ALLOC(sizeof(zip64_internal)); 850 if (zi==NULL) 851 { 852 ZCLOSE64(ziinit.z_filefunc,ziinit.filestream); 853 return NULL; 854 } 855 856 /* now we add file in a zipfile */ 857 # ifndef NO_ADDFILEINEXISTINGZIP 858 ziinit.globalcomment = NULL; 859 if (append == APPEND_STATUS_ADDINZIP) 860 { 861 // Read and Cache Central Directory Records 862 err = LoadCentralDirectoryRecord(&ziinit); 863 } 864 865 if (globalcomment) 866 { 867 *globalcomment = ziinit.globalcomment; 868 } 869 # endif /* !NO_ADDFILEINEXISTINGZIP*/ 870 871 if (err != ZIP_OK) 872 { 873 # ifndef NO_ADDFILEINEXISTINGZIP 874 free(ziinit.globalcomment); 875 # endif /* !NO_ADDFILEINEXISTINGZIP*/ 876 free(zi); 877 return NULL; 878 } 879 else 880 { 881 *zi = ziinit; 882 return (zipFile)zi; 883 } 884 } 885 886 extern zipFile ZEXPORT zipOpen2(const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def) { 887 if (pzlib_filefunc32_def != NULL) 888 { 889 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; 890 fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); 891 return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); 892 } 893 else 894 return zipOpen3(pathname, append, globalcomment, NULL); 895 } 896 897 extern zipFile ZEXPORT zipOpen2_64(const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def) { 898 if (pzlib_filefunc_def != NULL) 899 { 900 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; 901 zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; 902 zlib_filefunc64_32_def_fill.ztell32_file = NULL; 903 zlib_filefunc64_32_def_fill.zseek32_file = NULL; 904 return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); 905 } 906 else 907 return zipOpen3(pathname, append, globalcomment, NULL); 908 } 909 910 911 912 extern zipFile ZEXPORT zipOpen(const char* pathname, int append) { 913 return zipOpen3((const void*)pathname,append,NULL,NULL); 914 } 915 916 extern zipFile ZEXPORT zipOpen64(const void* pathname, int append) { 917 return zipOpen3(pathname,append,NULL,NULL); 918 } 919 920 local int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) { 921 /* write the local header */ 922 int err; 923 uInt size_filename = (uInt)strlen(filename); 924 uInt size_extrafield = size_extrafield_local; 925 926 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4); 927 928 if (err==ZIP_OK) 929 { 930 if(zi->ci.zip64) 931 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */ 932 else 933 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ 934 } 935 936 if (err==ZIP_OK) 937 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); 938 939 if (err==ZIP_OK) 940 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); 941 942 if (err==ZIP_OK) 943 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); 944 945 // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later 946 if (err==ZIP_OK) 947 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ 948 if (err==ZIP_OK) 949 { 950 if(zi->ci.zip64) 951 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */ 952 else 953 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ 954 } 955 if (err==ZIP_OK) 956 { 957 if(zi->ci.zip64) 958 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */ 959 else 960 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ 961 } 962 963 if (err==ZIP_OK) 964 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); 965 966 if(zi->ci.zip64) 967 { 968 size_extrafield += 20; 969 } 970 971 if (err==ZIP_OK) 972 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2); 973 974 if ((err==ZIP_OK) && (size_filename > 0)) 975 { 976 if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) 977 err = ZIP_ERRNO; 978 } 979 980 if ((err==ZIP_OK) && (size_extrafield_local > 0)) 981 { 982 if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) 983 err = ZIP_ERRNO; 984 } 985 986 987 if ((err==ZIP_OK) && (zi->ci.zip64)) 988 { 989 // write the Zip64 extended info 990 short HeaderID = 1; 991 short DataSize = 16; 992 ZPOS64_T CompressedSize = 0; 993 ZPOS64_T UncompressedSize = 0; 994 995 // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) 996 zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); 997 998 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)HeaderID,2); 999 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)DataSize,2); 1000 1001 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); 1002 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); 1003 } 1004 1005 return err; 1006 } 1007 1008 /* 1009 NOTE. 1010 When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped 1011 before calling this function it can be done with zipRemoveExtraInfoBlock 1012 1013 It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize 1014 unnecessary allocations. 1015 */ 1016 extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1017 const void* extrafield_local, uInt size_extrafield_local, 1018 const void* extrafield_global, uInt size_extrafield_global, 1019 const char* comment, int method, int level, int raw, 1020 int windowBits,int memLevel, int strategy, 1021 const char* password, uLong crcForCrypting, 1022 uLong versionMadeBy, uLong flagBase, int zip64) { 1023 zip64_internal* zi; 1024 uInt size_filename; 1025 uInt size_comment; 1026 uInt i; 1027 int err = ZIP_OK; 1028 1029 # ifdef NOCRYPT 1030 (crcForCrypting); 1031 if (password != NULL) 1032 return ZIP_PARAMERROR; 1033 # endif 1034 1035 if (file == NULL) 1036 return ZIP_PARAMERROR; 1037 1038 #ifdef HAVE_BZIP2 1039 if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED)) 1040 return ZIP_PARAMERROR; 1041 #else 1042 if ((method!=0) && (method!=Z_DEFLATED)) 1043 return ZIP_PARAMERROR; 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; 1056 1057 zi = (zip64_internal*)file; 1058 1059 if (zi->in_opened_file_inzip == 1) 1060 { 1061 err = zipCloseFileInZip (file); 1062 if (err != ZIP_OK) 1063 return err; 1064 } 1065 1066 if (filename==NULL) 1067 filename="-"; 1068 1069 if (comment==NULL) 1070 size_comment = 0; 1071 else 1072 size_comment = (uInt)strlen(comment); 1073 1074 size_filename = (uInt)strlen(filename); 1075 1076 if (zipfi == NULL) 1077 zi->ci.dosDate = 0; 1078 else 1079 { 1080 if (zipfi->dosDate != 0) 1081 zi->ci.dosDate = zipfi->dosDate; 1082 else 1083 zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date); 1084 } 1085 1086 zi->ci.flag = flagBase; 1087 if ((level==8) || (level==9)) 1088 zi->ci.flag |= 2; 1089 if (level==2) 1090 zi->ci.flag |= 4; 1091 if (level==1) 1092 zi->ci.flag |= 6; 1093 if (password != NULL) 1094 zi->ci.flag |= 1; 1095 1096 zi->ci.crc32 = 0; 1097 zi->ci.method = method; 1098 zi->ci.encrypt = 0; 1099 zi->ci.stream_initialised = 0; 1100 zi->ci.pos_in_buffered_data = 0; 1101 zi->ci.raw = raw; 1102 zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream); 1103 1104 zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment; 1105 zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data 1106 1107 zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree); 1108 1109 zi->ci.size_centralExtra = size_extrafield_global; 1110 zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); 1111 /* version info */ 1112 zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2); 1113 zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); 1114 zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); 1115 zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); 1116 zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); 1117 zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ 1118 zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ 1119 zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ 1120 zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); 1121 zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); 1122 zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); 1123 zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ 1124 1125 if (zipfi==NULL) 1126 zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); 1127 else 1128 zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); 1129 1130 if (zipfi==NULL) 1131 zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); 1132 else 1133 zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); 1134 1135 if(zi->ci.pos_local_header >= 0xffffffff) 1136 zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4); 1137 else 1138 zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writing_offset,4); 1139 1140 for (i=0;i<size_filename;i++) 1141 *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); 1142 1143 for (i=0;i<size_extrafield_global;i++) 1144 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = 1145 *(((const char*)extrafield_global)+i); 1146 1147 for (i=0;i<size_comment;i++) 1148 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ 1149 size_extrafield_global+i) = *(comment+i); 1150 if (zi->ci.central_header == NULL) 1151 return ZIP_INTERNALERROR; 1152 1153 zi->ci.zip64 = zip64; 1154 zi->ci.totalCompressedData = 0; 1155 zi->ci.totalUncompressedData = 0; 1156 zi->ci.pos_zip64extrainfo = 0; 1157 1158 err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local); 1159 1160 #ifdef HAVE_BZIP2 1161 zi->ci.bstream.avail_in = (uInt)0; 1162 zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; 1163 zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; 1164 zi->ci.bstream.total_in_hi32 = 0; 1165 zi->ci.bstream.total_in_lo32 = 0; 1166 zi->ci.bstream.total_out_hi32 = 0; 1167 zi->ci.bstream.total_out_lo32 = 0; 1168 #endif 1169 1170 zi->ci.stream.avail_in = (uInt)0; 1171 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 1172 zi->ci.stream.next_out = zi->ci.buffered_data; 1173 zi->ci.stream.total_in = 0; 1174 zi->ci.stream.total_out = 0; 1175 zi->ci.stream.data_type = Z_BINARY; 1176 1177 #ifdef HAVE_BZIP2 1178 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) 1179 #else 1180 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1181 #endif 1182 { 1183 if(zi->ci.method == Z_DEFLATED) 1184 { 1185 zi->ci.stream.zalloc = (alloc_func)0; 1186 zi->ci.stream.zfree = (free_func)0; 1187 zi->ci.stream.opaque = (voidpf)0; 1188 1189 if (windowBits>0) 1190 windowBits = -windowBits; 1191 1192 err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); 1193 1194 if (err==Z_OK) 1195 zi->ci.stream_initialised = Z_DEFLATED; 1196 } 1197 else if(zi->ci.method == Z_BZIP2ED) 1198 { 1199 #ifdef HAVE_BZIP2 1200 // Init BZip stuff here 1201 zi->ci.bstream.bzalloc = 0; 1202 zi->ci.bstream.bzfree = 0; 1203 zi->ci.bstream.opaque = (voidpf)0; 1204 1205 err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35); 1206 if(err == BZ_OK) 1207 zi->ci.stream_initialised = Z_BZIP2ED; 1208 #endif 1209 } 1210 1211 } 1212 1213 # ifndef NOCRYPT 1214 zi->ci.crypt_header_size = 0; 1215 if ((err==Z_OK) && (password != NULL)) 1216 { 1217 unsigned char bufHead[RAND_HEAD_LEN]; 1218 unsigned int sizeHead; 1219 zi->ci.encrypt = 1; 1220 zi->ci.pcrc_32_tab = get_crc_table(); 1221 /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ 1222 1223 sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); 1224 zi->ci.crypt_header_size = sizeHead; 1225 1226 if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) 1227 err = ZIP_ERRNO; 1228 } 1229 # endif 1230 1231 if (err==Z_OK) 1232 zi->in_opened_file_inzip = 1; 1233 return err; 1234 } 1235 1236 extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1237 const void* extrafield_local, uInt size_extrafield_local, 1238 const void* extrafield_global, uInt size_extrafield_global, 1239 const char* comment, int method, int level, int raw, 1240 int windowBits,int memLevel, int strategy, 1241 const char* password, uLong crcForCrypting, 1242 uLong versionMadeBy, uLong flagBase) { 1243 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1244 extrafield_local, size_extrafield_local, 1245 extrafield_global, size_extrafield_global, 1246 comment, method, level, raw, 1247 windowBits, memLevel, strategy, 1248 password, crcForCrypting, versionMadeBy, flagBase, 0); 1249 } 1250 1251 extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1252 const void* extrafield_local, uInt size_extrafield_local, 1253 const void* extrafield_global, uInt size_extrafield_global, 1254 const char* comment, int method, int level, int raw, 1255 int windowBits,int memLevel, int strategy, 1256 const char* password, uLong crcForCrypting) { 1257 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1258 extrafield_local, size_extrafield_local, 1259 extrafield_global, size_extrafield_global, 1260 comment, method, level, raw, 1261 windowBits, memLevel, strategy, 1262 password, crcForCrypting, VERSIONMADEBY, 0, 0); 1263 } 1264 1265 extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1266 const void* extrafield_local, uInt size_extrafield_local, 1267 const void* extrafield_global, uInt size_extrafield_global, 1268 const char* comment, int method, int level, int raw, 1269 int windowBits,int memLevel, int strategy, 1270 const char* password, uLong crcForCrypting, int zip64) { 1271 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1272 extrafield_local, size_extrafield_local, 1273 extrafield_global, size_extrafield_global, 1274 comment, method, level, raw, 1275 windowBits, memLevel, strategy, 1276 password, crcForCrypting, VERSIONMADEBY, 0, zip64); 1277 } 1278 1279 extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1280 const void* extrafield_local, uInt size_extrafield_local, 1281 const void* extrafield_global, uInt size_extrafield_global, 1282 const char* comment, int method, int level, int raw) { 1283 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1284 extrafield_local, size_extrafield_local, 1285 extrafield_global, size_extrafield_global, 1286 comment, method, level, raw, 1287 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1288 NULL, 0, VERSIONMADEBY, 0, 0); 1289 } 1290 1291 extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1292 const void* extrafield_local, uInt size_extrafield_local, 1293 const void* extrafield_global, uInt size_extrafield_global, 1294 const char* comment, int method, int level, int raw, int zip64) { 1295 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1296 extrafield_local, size_extrafield_local, 1297 extrafield_global, size_extrafield_global, 1298 comment, method, level, raw, 1299 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1300 NULL, 0, VERSIONMADEBY, 0, zip64); 1301 } 1302 1303 extern int ZEXPORT zipOpenNewFileInZip64(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1304 const void* extrafield_local, uInt size_extrafield_local, 1305 const void*extrafield_global, uInt size_extrafield_global, 1306 const char* comment, int method, int level, int zip64) { 1307 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1308 extrafield_local, size_extrafield_local, 1309 extrafield_global, size_extrafield_global, 1310 comment, method, level, 0, 1311 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1312 NULL, 0, VERSIONMADEBY, 0, zip64); 1313 } 1314 1315 extern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char* filename, const zip_fileinfo* zipfi, 1316 const void* extrafield_local, uInt size_extrafield_local, 1317 const void*extrafield_global, uInt size_extrafield_global, 1318 const char* comment, int method, int level) { 1319 return zipOpenNewFileInZip4_64(file, filename, zipfi, 1320 extrafield_local, size_extrafield_local, 1321 extrafield_global, size_extrafield_global, 1322 comment, method, level, 0, 1323 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 1324 NULL, 0, VERSIONMADEBY, 0, 0); 1325 } 1326 1327 local int zip64FlushWriteBuffer(zip64_internal* zi) { 1328 int err=ZIP_OK; 1329 1330 if (zi->ci.encrypt != 0) 1331 { 1332 #ifndef NOCRYPT 1333 uInt i; 1334 int t; 1335 for (i=0;i<zi->ci.pos_in_buffered_data;i++) 1336 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t); 1337 #endif 1338 } 1339 1340 if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data) 1341 err = ZIP_ERRNO; 1342 1343 zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data; 1344 1345 #ifdef HAVE_BZIP2 1346 if(zi->ci.method == Z_BZIP2ED) 1347 { 1348 zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32; 1349 zi->ci.bstream.total_in_lo32 = 0; 1350 zi->ci.bstream.total_in_hi32 = 0; 1351 } 1352 else 1353 #endif 1354 { 1355 zi->ci.totalUncompressedData += zi->ci.stream.total_in; 1356 zi->ci.stream.total_in = 0; 1357 } 1358 1359 1360 zi->ci.pos_in_buffered_data = 0; 1361 1362 return err; 1363 } 1364 1365 extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void* buf, unsigned int len) { 1366 zip64_internal* zi; 1367 int err=ZIP_OK; 1368 1369 if (file == NULL) 1370 return ZIP_PARAMERROR; 1371 zi = (zip64_internal*)file; 1372 1373 if (zi->in_opened_file_inzip == 0) 1374 return ZIP_PARAMERROR; 1375 1376 zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len); 1377 1378 #ifdef HAVE_BZIP2 1379 if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw)) 1380 { 1381 zi->ci.bstream.next_in = (void*)buf; 1382 zi->ci.bstream.avail_in = len; 1383 err = BZ_RUN_OK; 1384 1385 while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0)) 1386 { 1387 if (zi->ci.bstream.avail_out == 0) 1388 { 1389 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) 1390 err = ZIP_ERRNO; 1391 zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; 1392 zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; 1393 } 1394 1395 1396 if(err != BZ_RUN_OK) 1397 break; 1398 1399 if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) 1400 { 1401 uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32; 1402 // uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32; 1403 err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN); 1404 1405 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ; 1406 } 1407 } 1408 1409 if(err == BZ_RUN_OK) 1410 err = ZIP_OK; 1411 } 1412 else 1413 #endif 1414 { 1415 zi->ci.stream.next_in = (Bytef*)(uintptr_t)buf; 1416 zi->ci.stream.avail_in = len; 1417 1418 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) 1419 { 1420 if (zi->ci.stream.avail_out == 0) 1421 { 1422 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) 1423 err = ZIP_ERRNO; 1424 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 1425 zi->ci.stream.next_out = zi->ci.buffered_data; 1426 } 1427 1428 1429 if(err != ZIP_OK) 1430 break; 1431 1432 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1433 { 1434 uLong uTotalOutBefore = zi->ci.stream.total_out; 1435 err=deflate(&zi->ci.stream, Z_NO_FLUSH); 1436 1437 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 1438 } 1439 else 1440 { 1441 uInt copy_this,i; 1442 if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) 1443 copy_this = zi->ci.stream.avail_in; 1444 else 1445 copy_this = zi->ci.stream.avail_out; 1446 1447 for (i = 0; i < copy_this; i++) 1448 *(((char*)zi->ci.stream.next_out)+i) = 1449 *(((const char*)zi->ci.stream.next_in)+i); 1450 { 1451 zi->ci.stream.avail_in -= copy_this; 1452 zi->ci.stream.avail_out-= copy_this; 1453 zi->ci.stream.next_in+= copy_this; 1454 zi->ci.stream.next_out+= copy_this; 1455 zi->ci.stream.total_in+= copy_this; 1456 zi->ci.stream.total_out+= copy_this; 1457 zi->ci.pos_in_buffered_data += copy_this; 1458 } 1459 } 1460 }// while(...) 1461 } 1462 1463 return err; 1464 } 1465 1466 extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uLong uncompressed_size, uLong crc32) { 1467 return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32); 1468 } 1469 1470 extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_size, uLong crc32) { 1471 zip64_internal* zi; 1472 ZPOS64_T compressed_size; 1473 uLong invalidValue = 0xffffffff; 1474 unsigned datasize = 0; 1475 int err=ZIP_OK; 1476 1477 if (file == NULL) 1478 return ZIP_PARAMERROR; 1479 zi = (zip64_internal*)file; 1480 1481 if (zi->in_opened_file_inzip == 0) 1482 return ZIP_PARAMERROR; 1483 zi->ci.stream.avail_in = 0; 1484 1485 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1486 { 1487 while (err==ZIP_OK) 1488 { 1489 uLong uTotalOutBefore; 1490 if (zi->ci.stream.avail_out == 0) 1491 { 1492 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) 1493 err = ZIP_ERRNO; 1494 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 1495 zi->ci.stream.next_out = zi->ci.buffered_data; 1496 } 1497 uTotalOutBefore = zi->ci.stream.total_out; 1498 err=deflate(&zi->ci.stream, Z_FINISH); 1499 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 1500 } 1501 } 1502 else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) 1503 { 1504 #ifdef HAVE_BZIP2 1505 err = BZ_FINISH_OK; 1506 while (err==BZ_FINISH_OK) 1507 { 1508 uLong uTotalOutBefore; 1509 if (zi->ci.bstream.avail_out == 0) 1510 { 1511 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) 1512 err = ZIP_ERRNO; 1513 zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; 1514 zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; 1515 } 1516 uTotalOutBefore = zi->ci.bstream.total_out_lo32; 1517 err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH); 1518 if(err == BZ_STREAM_END) 1519 err = Z_STREAM_END; 1520 1521 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore); 1522 } 1523 1524 if(err == BZ_FINISH_OK) 1525 err = ZIP_OK; 1526 #endif 1527 } 1528 1529 if (err==Z_STREAM_END) 1530 err=ZIP_OK; /* this is normal */ 1531 1532 if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) 1533 { 1534 if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO) 1535 err = ZIP_ERRNO; 1536 } 1537 1538 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1539 { 1540 int tmp_err = deflateEnd(&zi->ci.stream); 1541 if (err == ZIP_OK) 1542 err = tmp_err; 1543 zi->ci.stream_initialised = 0; 1544 } 1545 #ifdef HAVE_BZIP2 1546 else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) 1547 { 1548 int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream); 1549 if (err==ZIP_OK) 1550 err = tmperr; 1551 zi->ci.stream_initialised = 0; 1552 } 1553 #endif 1554 1555 if (!zi->ci.raw) 1556 { 1557 crc32 = (uLong)zi->ci.crc32; 1558 uncompressed_size = zi->ci.totalUncompressedData; 1559 } 1560 compressed_size = zi->ci.totalCompressedData; 1561 1562 # ifndef NOCRYPT 1563 compressed_size += zi->ci.crypt_header_size; 1564 # endif 1565 1566 // update Current Item crc and sizes, 1567 if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff) 1568 { 1569 /*version Made by*/ 1570 zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2); 1571 /*version needed*/ 1572 zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2); 1573 1574 } 1575 1576 zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ 1577 1578 1579 if(compressed_size >= 0xffffffff) 1580 zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/ 1581 else 1582 zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/ 1583 1584 /// set internal file attributes field 1585 if (zi->ci.stream.data_type == Z_ASCII) 1586 zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); 1587 1588 if(uncompressed_size >= 0xffffffff) 1589 zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/ 1590 else 1591 zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/ 1592 1593 // Add ZIP64 extra info field for uncompressed size 1594 if(uncompressed_size >= 0xffffffff) 1595 datasize += 8; 1596 1597 // Add ZIP64 extra info field for compressed size 1598 if(compressed_size >= 0xffffffff) 1599 datasize += 8; 1600 1601 // Add ZIP64 extra info field for relative offset to local file header of current file 1602 if(zi->ci.pos_local_header >= 0xffffffff) 1603 datasize += 8; 1604 1605 if(datasize > 0) 1606 { 1607 char* p = NULL; 1608 1609 if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree) 1610 { 1611 // we cannot write more data to the buffer that we have room for. 1612 return ZIP_BADZIPFILE; 1613 } 1614 1615 p = zi->ci.central_header + zi->ci.size_centralheader; 1616 1617 // Add Extra Information Header for 'ZIP64 information' 1618 zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID 1619 p += 2; 1620 zip64local_putValue_inmemory(p, datasize, 2); // DataSize 1621 p += 2; 1622 1623 if(uncompressed_size >= 0xffffffff) 1624 { 1625 zip64local_putValue_inmemory(p, uncompressed_size, 8); 1626 p += 8; 1627 } 1628 1629 if(compressed_size >= 0xffffffff) 1630 { 1631 zip64local_putValue_inmemory(p, compressed_size, 8); 1632 p += 8; 1633 } 1634 1635 if(zi->ci.pos_local_header >= 0xffffffff) 1636 { 1637 zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8); 1638 p += 8; 1639 } 1640 1641 // Update how much extra free space we got in the memory buffer 1642 // and increase the centralheader size so the new ZIP64 fields are included 1643 // ( 4 below is the size of HeaderID and DataSize field ) 1644 zi->ci.size_centralExtraFree -= datasize + 4; 1645 zi->ci.size_centralheader += datasize + 4; 1646 1647 // Update the extra info size field 1648 zi->ci.size_centralExtra += datasize + 4; 1649 zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2); 1650 } 1651 1652 if (err==ZIP_OK) 1653 err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader); 1654 1655 free(zi->ci.central_header); 1656 1657 if (err==ZIP_OK) 1658 { 1659 // Update the LocalFileHeader with the new values. 1660 1661 ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); 1662 1663 if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) 1664 err = ZIP_ERRNO; 1665 1666 if (err==ZIP_OK) 1667 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ 1668 1669 if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff ) 1670 { 1671 if(zi->ci.pos_zip64extrainfo > 0) 1672 { 1673 // Update the size in the ZIP64 extended field. 1674 if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0) 1675 err = ZIP_ERRNO; 1676 1677 if (err==ZIP_OK) /* compressed size, unknown */ 1678 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8); 1679 1680 if (err==ZIP_OK) /* uncompressed size, unknown */ 1681 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8); 1682 } 1683 else 1684 err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal 1685 } 1686 else 1687 { 1688 if (err==ZIP_OK) /* compressed size, unknown */ 1689 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); 1690 1691 if (err==ZIP_OK) /* uncompressed size, unknown */ 1692 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); 1693 } 1694 1695 if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) 1696 err = ZIP_ERRNO; 1697 } 1698 1699 zi->number_entry ++; 1700 zi->in_opened_file_inzip = 0; 1701 1702 return err; 1703 } 1704 1705 extern int ZEXPORT zipCloseFileInZip(zipFile file) { 1706 return zipCloseFileInZipRaw (file,0,0); 1707 } 1708 1709 local int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) { 1710 int err = ZIP_OK; 1711 ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset; 1712 1713 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4); 1714 1715 /*num disks*/ 1716 if (err==ZIP_OK) /* number of the disk with the start of the central directory */ 1717 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); 1718 1719 /*relative offset*/ 1720 if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */ 1721 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8); 1722 1723 /*total disks*/ /* Do not support spawning of disk so always say 1 here*/ 1724 if (err==ZIP_OK) /* number of the disk with the start of the central directory */ 1725 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4); 1726 1727 return err; 1728 } 1729 1730 local int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) { 1731 int err = ZIP_OK; 1732 1733 uLong Zip64DataSize = 44; 1734 1735 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4); 1736 1737 if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */ 1738 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ? 1739 1740 if (err==ZIP_OK) /* version made by */ 1741 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); 1742 1743 if (err==ZIP_OK) /* version needed */ 1744 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); 1745 1746 if (err==ZIP_OK) /* number of this disk */ 1747 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); 1748 1749 if (err==ZIP_OK) /* number of the disk with the start of the central directory */ 1750 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); 1751 1752 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ 1753 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); 1754 1755 if (err==ZIP_OK) /* total number of entries in the central dir */ 1756 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); 1757 1758 if (err==ZIP_OK) /* size of the central directory */ 1759 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8); 1760 1761 if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ 1762 { 1763 ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset; 1764 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8); 1765 } 1766 return err; 1767 } 1768 1769 local int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) { 1770 int err = ZIP_OK; 1771 1772 /*signature*/ 1773 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); 1774 1775 if (err==ZIP_OK) /* number of this disk */ 1776 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); 1777 1778 if (err==ZIP_OK) /* number of the disk with the start of the central directory */ 1779 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); 1780 1781 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ 1782 { 1783 { 1784 if(zi->number_entry >= 0xFFFF) 1785 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record 1786 else 1787 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); 1788 } 1789 } 1790 1791 if (err==ZIP_OK) /* total number of entries in the central dir */ 1792 { 1793 if(zi->number_entry >= 0xFFFF) 1794 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record 1795 else 1796 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); 1797 } 1798 1799 if (err==ZIP_OK) /* size of the central directory */ 1800 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); 1801 1802 if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ 1803 { 1804 ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset; 1805 if(pos >= 0xffffffff) 1806 { 1807 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4); 1808 } 1809 else 1810 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writing_offset),4); 1811 } 1812 1813 return err; 1814 } 1815 1816 local int Write_GlobalComment(zip64_internal* zi, const char* global_comment) { 1817 int err = ZIP_OK; 1818 uInt size_global_comment = 0; 1819 1820 if(global_comment != NULL) 1821 size_global_comment = (uInt)strlen(global_comment); 1822 1823 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); 1824 1825 if (err == ZIP_OK && size_global_comment > 0) 1826 { 1827 if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment) 1828 err = ZIP_ERRNO; 1829 } 1830 return err; 1831 } 1832 1833 extern int ZEXPORT zipClose(zipFile file, const char* global_comment) { 1834 zip64_internal* zi; 1835 int err = 0; 1836 uLong size_centraldir = 0; 1837 ZPOS64_T centraldir_pos_inzip; 1838 ZPOS64_T pos; 1839 1840 if (file == NULL) 1841 return ZIP_PARAMERROR; 1842 1843 zi = (zip64_internal*)file; 1844 1845 if (zi->in_opened_file_inzip == 1) 1846 { 1847 err = zipCloseFileInZip (file); 1848 } 1849 1850 #ifndef NO_ADDFILEINEXISTINGZIP 1851 if (global_comment==NULL) 1852 global_comment = zi->globalcomment; 1853 #endif 1854 1855 centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); 1856 1857 if (err==ZIP_OK) 1858 { 1859 linkedlist_datablock_internal* ldi = zi->central_dir.first_block; 1860 while (ldi!=NULL) 1861 { 1862 if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) 1863 { 1864 if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block) 1865 err = ZIP_ERRNO; 1866 } 1867 1868 size_centraldir += ldi->filled_in_this_block; 1869 ldi = ldi->next_datablock; 1870 } 1871 } 1872 free_linkedlist(&(zi->central_dir)); 1873 1874 pos = centraldir_pos_inzip - zi->add_position_when_writing_offset; 1875 if(pos >= 0xffffffff || zi->number_entry >= 0xFFFF) 1876 { 1877 ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream); 1878 Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); 1879 1880 Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos); 1881 } 1882 1883 if (err==ZIP_OK) 1884 err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); 1885 1886 if(err == ZIP_OK) 1887 err = Write_GlobalComment(zi, global_comment); 1888 1889 if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0) 1890 if (err == ZIP_OK) 1891 err = ZIP_ERRNO; 1892 1893 #ifndef NO_ADDFILEINEXISTINGZIP 1894 free(zi->globalcomment); 1895 #endif 1896 free(zi); 1897 1898 return err; 1899 } 1900 1901 extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHeader) { 1902 char* p = pData; 1903 int size = 0; 1904 char* pNewHeader; 1905 char* pTmp; 1906 short header; 1907 short dataSize; 1908 1909 int retVal = ZIP_OK; 1910 1911 if(pData == NULL || dataLen == NULL || *dataLen < 4) 1912 return ZIP_PARAMERROR; 1913 1914 pNewHeader = (char*)ALLOC((unsigned)*dataLen); 1915 pTmp = pNewHeader; 1916 1917 while(p < (pData + *dataLen)) 1918 { 1919 header = *(short*)p; 1920 dataSize = *(((short*)p)+1); 1921 1922 if( header == sHeader ) // Header found. 1923 { 1924 p += dataSize + 4; // skip it. do not copy to temp buffer 1925 } 1926 else 1927 { 1928 // Extra Info block should not be removed, So copy it to the temp buffer. 1929 memcpy(pTmp, p, dataSize + 4); 1930 p += dataSize + 4; 1931 size += dataSize + 4; 1932 } 1933 1934 } 1935 1936 if(size < *dataLen) 1937 { 1938 // clean old extra info block. 1939 memset(pData,0, *dataLen); 1940 1941 // copy the new extra info block over the old 1942 if(size > 0) 1943 memcpy(pData, pNewHeader, size); 1944 1945 // set the new extra info size 1946 *dataLen = size; 1947 1948 retVal = ZIP_OK; 1949 } 1950 else 1951 retVal = ZIP_ERRNO; 1952 1953 free(pNewHeader); 1954 1955 return retVal; 1956 } 1957
Indexes created Sun Sep 21 16:09:51 GMT 2025