aboutsummaryrefslogtreecommitdiff
path: root/src/common/unzip.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/common/unzip.c')
-rw-r--r--src/common/unzip.c671
1 files changed, 343 insertions, 328 deletions
diff --git a/src/common/unzip.c b/src/common/unzip.c
index 46683f0..a469a5b 100644
--- a/src/common/unzip.c
+++ b/src/common/unzip.c
@@ -87,7 +87,7 @@ struct FileFuncDefs
87 /** 87 /**
88 * Callback for reading 'size' bytes from the ZIP archive into buf. 88 * Callback for reading 'size' bytes from the ZIP archive into buf.
89 */ 89 */
90 uLong (*zread_file) (voidpf opaque, void* buf, uLong size); 90 uLong (*zread_file) (voidpf opaque, void*buf, uLong size);
91 91
92 /** 92 /**
93 * Callback to obtain the current read offset in the ZIP archive. 93 * Callback to obtain the current read offset in the ZIP archive.
@@ -114,7 +114,8 @@ struct FileFuncDefs
114 * @param size number of bytes to read 114 * @param size number of bytes to read
115 * @return number of bytes copied to buf 115 * @return number of bytes copied to buf
116 */ 116 */
117#define ZREAD(filefunc,buf,size) ((*((filefunc).zread_file)) ((filefunc).opaque, buf, size)) 117#define ZREAD(filefunc,buf,size) ((*((filefunc).zread_file))((filefunc).opaque, \
118 buf, size))
118 119
119/** 120/**
120 * Macro to obtain current offset in file using filefunc API. 121 * Macro to obtain current offset in file using filefunc API.
@@ -122,7 +123,7 @@ struct FileFuncDefs
122 * @param filefunc filefunc struct 123 * @param filefunc filefunc struct
123 * @return current offset in file 124 * @return current offset in file
124 */ 125 */
125#define ZTELL(filefunc) ((*((filefunc).ztell_file)) ((filefunc).opaque)) 126#define ZTELL(filefunc) ((*((filefunc).ztell_file))((filefunc).opaque))
126 127
127/** 128/**
128 * Macro to seek using filefunc API. 129 * Macro to seek using filefunc API.
@@ -132,7 +133,8 @@ struct FileFuncDefs
132 * @param mode seek mode 133 * @param mode seek mode
133 * @return 0 on success 134 * @return 0 on success
134 */ 135 */
135#define ZSEEK(filefunc,pos,mode) ((*((filefunc).zseek_file)) ((filefunc).opaque, pos, mode)) 136#define ZSEEK(filefunc,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque, \
137 pos, mode))
136 138
137 139
138/** 140/**
@@ -208,7 +210,7 @@ struct FileInZipReadInfo
208 /** 210 /**
209 * size of the local extra field 211 * size of the local extra field
210 */ 212 */
211 uInt size_local_extrafield; 213 uInt size_local_extrafield;
212 214
213 /** 215 /**
214 * position in the local extra field in read 216 * position in the local extra field in read
@@ -337,7 +339,7 @@ struct EXTRACTOR_UnzipFile
337 */ 339 */
338static int 340static int
339read_byte_from_ffd (const struct FileFuncDefs *ffd, 341read_byte_from_ffd (const struct FileFuncDefs *ffd,
340 int *pi) 342 int *pi)
341{ 343{
342 unsigned char c; 344 unsigned char c;
343 345
@@ -359,7 +361,7 @@ read_byte_from_ffd (const struct FileFuncDefs *ffd,
359 */ 361 */
360static int 362static int
361read_short_from_ffd (const struct FileFuncDefs *ffd, 363read_short_from_ffd (const struct FileFuncDefs *ffd,
362 uLong *pX) 364 uLong *pX)
363{ 365{
364 uLong x; 366 uLong x;
365 int i; 367 int i;
@@ -388,7 +390,7 @@ read_short_from_ffd (const struct FileFuncDefs *ffd,
388 */ 390 */
389static int 391static int
390read_long_from_ffd (const struct FileFuncDefs *ffd, 392read_long_from_ffd (const struct FileFuncDefs *ffd,
391 uLong *pX) 393 uLong *pX)
392{ 394{
393 uLong x; 395 uLong x;
394 int i; 396 int i;
@@ -413,7 +415,7 @@ read_long_from_ffd (const struct FileFuncDefs *ffd,
413 415
414 416
415#ifndef CASESENSITIVITYDEFAULT_NO 417#ifndef CASESENSITIVITYDEFAULT_NO
416#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) 418#if ! defined(unix) && ! defined(CASESENSITIVITYDEFAULT_YES)
417#define CASESENSITIVITYDEFAULT_NO 419#define CASESENSITIVITYDEFAULT_NO
418#endif 420#endif
419#endif 421#endif
@@ -436,14 +438,14 @@ read_long_from_ffd (const struct FileFuncDefs *ffd,
436 * @return 0 if names are equal 438 * @return 0 if names are equal
437 */ 439 */
438static int 440static int
439EXTRACTOR_common_unzip_string_file_name_compare (const char* fileName1, 441EXTRACTOR_common_unzip_string_file_name_compare (const char*fileName1,
440 const char* fileName2, 442 const char*fileName2,
441 int iCaseSensitivity) 443 int iCaseSensitivity)
442{ 444{
443 if (0 == iCaseSensitivity) 445 if (0 == iCaseSensitivity)
444 iCaseSensitivity = CASESENSITIVITYDEFAULTVALUE; 446 iCaseSensitivity = CASESENSITIVITYDEFAULTVALUE;
445 if (1 == iCaseSensitivity) 447 if (1 == iCaseSensitivity)
446 return strcmp(fileName1, fileName2); 448 return strcmp (fileName1, fileName2);
447 return strcasecmp (fileName1, fileName2); 449 return strcasecmp (fileName1, fileName2);
448} 450}
449 451
@@ -474,31 +476,31 @@ locate_central_directory (const struct FileFuncDefs *ffd)
474 uMaxBack = uSizeFile; 476 uMaxBack = uSizeFile;
475 uBackRead = 4; 477 uBackRead = 4;
476 while (uBackRead < uMaxBack) 478 while (uBackRead < uMaxBack)
477 { 479 {
478 uLong uReadSize; 480 uLong uReadSize;
479 uLong uReadPos; 481 uLong uReadPos;
480 int i; 482 int i;
481 483
482 if (uBackRead + BUFREADCOMMENT > uMaxBack) 484 if (uBackRead + BUFREADCOMMENT > uMaxBack)
483 uBackRead = uMaxBack; 485 uBackRead = uMaxBack;
484 else 486 else
485 uBackRead += BUFREADCOMMENT; 487 uBackRead += BUFREADCOMMENT;
486 uReadPos = uSizeFile - uBackRead; 488 uReadPos = uSizeFile - uBackRead;
487 uReadSize = ((BUFREADCOMMENT + 4) < (uSizeFile - uReadPos)) 489 uReadSize = ((BUFREADCOMMENT + 4) < (uSizeFile - uReadPos))
488 ? (BUFREADCOMMENT + 4) 490 ? (BUFREADCOMMENT + 4)
489 : (uSizeFile - uReadPos); 491 : (uSizeFile - uReadPos);
490 if (0 != ZSEEK (*ffd, uReadPos, SEEK_SET)) 492 if (0 != ZSEEK (*ffd, uReadPos, SEEK_SET))
491 break; 493 break;
492 if (ZREAD (*ffd, buf, uReadSize) != uReadSize) 494 if (ZREAD (*ffd, buf, uReadSize) != uReadSize)
493 break; 495 break;
494 i = (int) uReadSize - 3; 496 i = (int) uReadSize - 3;
495 while (i-- > 0) 497 while (i-- > 0)
496 if ( (0x50 == (*(buf+i))) && 498 if ( (0x50 == (*(buf + i))) &&
497 (0x4b == (*(buf+i+1))) && 499 (0x4b == (*(buf + i + 1))) &&
498 (0x05 == (*(buf+i+2))) && 500 (0x05 == (*(buf + i + 2))) &&
499 (0x06 == (*(buf+i+3))) ) 501 (0x06 == (*(buf + i + 3))) )
500 return uReadPos + i; 502 return uReadPos + i;
501 } 503 }
502 return 0; 504 return 0;
503} 505}
504 506
@@ -512,7 +514,7 @@ locate_central_directory (const struct FileFuncDefs *ffd)
512 */ 514 */
513static void 515static void
514dos_date_to_tmu_date (uLong ulDosDate, 516dos_date_to_tmu_date (uLong ulDosDate,
515 struct EXTRACTOR_UnzipDateTimeInfo* ptm) 517 struct EXTRACTOR_UnzipDateTimeInfo*ptm)
516{ 518{
517 uLong uDate; 519 uLong uDate;
518 520
@@ -543,14 +545,14 @@ dos_date_to_tmu_date (uLong ulDosDate,
543 */ 545 */
544static int 546static int
545get_current_file_info (struct EXTRACTOR_UnzipFile *file, 547get_current_file_info (struct EXTRACTOR_UnzipFile *file,
546 struct EXTRACTOR_UnzipFileInfo *pfile_info, 548 struct EXTRACTOR_UnzipFileInfo *pfile_info,
547 struct UnzipFileInfoInternal *pfile_info_internal, 549 struct UnzipFileInfoInternal *pfile_info_internal,
548 char *szFileName, 550 char *szFileName,
549 uLong fileNameBufferSize, 551 uLong fileNameBufferSize,
550 void *extraField, 552 void *extraField,
551 uLong extraFieldBufferSize, 553 uLong extraFieldBufferSize,
552 char *szComment, 554 char *szComment,
553 uLong commentBufferSize) 555 uLong commentBufferSize)
554{ 556{
555 struct EXTRACTOR_UnzipFileInfo file_info; 557 struct EXTRACTOR_UnzipFileInfo file_info;
556 struct UnzipFileInfoInternal file_info_internal; 558 struct UnzipFileInfoInternal file_info_internal;
@@ -560,128 +562,130 @@ get_current_file_info (struct EXTRACTOR_UnzipFile *file,
560 if (NULL == file) 562 if (NULL == file)
561 return EXTRACTOR_UNZIP_PARAMERROR; 563 return EXTRACTOR_UNZIP_PARAMERROR;
562 if (0 != ZSEEK (file->z_filefunc, 564 if (0 != ZSEEK (file->z_filefunc,
563 file->pos_in_central_dir + file->byte_before_the_zipfile, 565 file->pos_in_central_dir + file->byte_before_the_zipfile,
564 SEEK_SET)) 566 SEEK_SET))
565 return EXTRACTOR_UNZIP_ERRNO; 567 return EXTRACTOR_UNZIP_ERRNO;
566 568
567 /* we check the magic */ 569 /* we check the magic */
568 if (EXTRACTOR_UNZIP_OK != 570 if (EXTRACTOR_UNZIP_OK !=
569 read_long_from_ffd(&file->z_filefunc, &uMagic)) 571 read_long_from_ffd (&file->z_filefunc, &uMagic))
570 return EXTRACTOR_UNZIP_ERRNO; 572 return EXTRACTOR_UNZIP_ERRNO;
571 if (0x02014b50 != uMagic) 573 if (0x02014b50 != uMagic)
572 return EXTRACTOR_UNZIP_BADZIPFILE; 574 return EXTRACTOR_UNZIP_BADZIPFILE;
573 575
574 if ( (EXTRACTOR_UNZIP_OK != 576 if ( (EXTRACTOR_UNZIP_OK !=
575 read_short_from_ffd (&file->z_filefunc, &file_info.version)) || 577 read_short_from_ffd (&file->z_filefunc, &file_info.version)) ||
576 (EXTRACTOR_UNZIP_OK != 578 (EXTRACTOR_UNZIP_OK !=
577 read_short_from_ffd (&file->z_filefunc, &file_info.version_needed)) || 579 read_short_from_ffd (&file->z_filefunc, &file_info.version_needed)) ||
578 (EXTRACTOR_UNZIP_OK != 580 (EXTRACTOR_UNZIP_OK !=
579 read_short_from_ffd (&file->z_filefunc, &file_info.flag)) || 581 read_short_from_ffd (&file->z_filefunc, &file_info.flag)) ||
580 (EXTRACTOR_UNZIP_OK != 582 (EXTRACTOR_UNZIP_OK !=
581 read_short_from_ffd (&file->z_filefunc, &file_info.compression_method)) || 583 read_short_from_ffd (&file->z_filefunc,
584 &file_info.compression_method)) ||
582 (EXTRACTOR_UNZIP_OK != 585 (EXTRACTOR_UNZIP_OK !=
583 read_long_from_ffd (&file->z_filefunc, &file_info.dosDate)) ) 586 read_long_from_ffd (&file->z_filefunc, &file_info.dosDate)) )
584 return EXTRACTOR_UNZIP_ERRNO; 587 return EXTRACTOR_UNZIP_ERRNO;
585 dos_date_to_tmu_date (file_info.dosDate, 588 dos_date_to_tmu_date (file_info.dosDate,
586 &file_info.tmu_date); 589 &file_info.tmu_date);
587 if ( (EXTRACTOR_UNZIP_OK != 590 if ( (EXTRACTOR_UNZIP_OK !=
588 read_long_from_ffd(&file->z_filefunc, &file_info.crc)) || 591 read_long_from_ffd (&file->z_filefunc, &file_info.crc)) ||
589 (EXTRACTOR_UNZIP_OK != 592 (EXTRACTOR_UNZIP_OK !=
590 read_long_from_ffd(&file->z_filefunc, &file_info.compressed_size)) || 593 read_long_from_ffd (&file->z_filefunc, &file_info.compressed_size)) ||
591 (EXTRACTOR_UNZIP_OK != 594 (EXTRACTOR_UNZIP_OK !=
592 read_long_from_ffd(&file->z_filefunc, &file_info.uncompressed_size)) || 595 read_long_from_ffd (&file->z_filefunc, &file_info.uncompressed_size)) ||
593 (EXTRACTOR_UNZIP_OK != 596 (EXTRACTOR_UNZIP_OK !=
594 read_short_from_ffd(&file->z_filefunc, &file_info.size_filename)) || 597 read_short_from_ffd (&file->z_filefunc, &file_info.size_filename)) ||
595 (EXTRACTOR_UNZIP_OK != 598 (EXTRACTOR_UNZIP_OK !=
596 read_short_from_ffd(&file->z_filefunc, &file_info.size_file_extra)) || 599 read_short_from_ffd (&file->z_filefunc, &file_info.size_file_extra)) ||
597 (EXTRACTOR_UNZIP_OK != 600 (EXTRACTOR_UNZIP_OK !=
598 read_short_from_ffd(&file->z_filefunc, &file_info.size_file_comment)) || 601 read_short_from_ffd (&file->z_filefunc,
602 &file_info.size_file_comment)) ||
599 (EXTRACTOR_UNZIP_OK != 603 (EXTRACTOR_UNZIP_OK !=
600 read_short_from_ffd(&file->z_filefunc, &file_info.disk_num_start)) || 604 read_short_from_ffd (&file->z_filefunc, &file_info.disk_num_start)) ||
601 (EXTRACTOR_UNZIP_OK != 605 (EXTRACTOR_UNZIP_OK !=
602 read_short_from_ffd(&file->z_filefunc, &file_info.internal_fa)) || 606 read_short_from_ffd (&file->z_filefunc, &file_info.internal_fa)) ||
603 (EXTRACTOR_UNZIP_OK != 607 (EXTRACTOR_UNZIP_OK !=
604 read_long_from_ffd(&file->z_filefunc, &file_info.external_fa)) || 608 read_long_from_ffd (&file->z_filefunc, &file_info.external_fa)) ||
605 (EXTRACTOR_UNZIP_OK != 609 (EXTRACTOR_UNZIP_OK !=
606 read_long_from_ffd (&file->z_filefunc, 610 read_long_from_ffd (&file->z_filefunc,
607 &file_info_internal.offset_curfile)) ) 611 &file_info_internal.offset_curfile)) )
608 return EXTRACTOR_UNZIP_ERRNO; 612 return EXTRACTOR_UNZIP_ERRNO;
609 613
610 lSeek += file_info.size_filename; 614 lSeek += file_info.size_filename;
611 if (NULL != szFileName) 615 if (NULL != szFileName)
612 { 616 {
613 uLong uSizeRead; 617 uLong uSizeRead;
614 618
615 if (file_info.size_filename < fileNameBufferSize) 619 if (file_info.size_filename < fileNameBufferSize)
616 { 620 {
617 *(szFileName + file_info.size_filename) = '\0'; 621 *(szFileName + file_info.size_filename) = '\0';
618 uSizeRead = file_info.size_filename; 622 uSizeRead = file_info.size_filename;
619 }
620 else
621 uSizeRead = fileNameBufferSize;
622
623 if ( (file_info.size_filename > 0) &&
624 (fileNameBufferSize > 0) )
625 if (ZREAD(file->z_filefunc, szFileName, uSizeRead) != uSizeRead)
626 return EXTRACTOR_UNZIP_ERRNO;
627 lSeek -= uSizeRead;
628 } 623 }
624 else
625 uSizeRead = fileNameBufferSize;
626
627 if ( (file_info.size_filename > 0) &&
628 (fileNameBufferSize > 0) )
629 if (ZREAD (file->z_filefunc, szFileName, uSizeRead) != uSizeRead)
630 return EXTRACTOR_UNZIP_ERRNO;
631 lSeek -= uSizeRead;
632 }
629 633
630 if (NULL != extraField) 634 if (NULL != extraField)
631 { 635 {
632 uLong uSizeRead; 636 uLong uSizeRead;
637
638 if (file_info.size_file_extra<extraFieldBufferSize)
639 uSizeRead = file_info.size_file_extra;
640 else
641 uSizeRead = extraFieldBufferSize;
633 642
634 if (file_info.size_file_extra<extraFieldBufferSize) 643 if (0 != lSeek)
635 uSizeRead = file_info.size_file_extra; 644 {
645 if (0 == ZSEEK (file->z_filefunc, lSeek, SEEK_CUR))
646 lSeek = 0;
636 else 647 else
637 uSizeRead = extraFieldBufferSize; 648 return EXTRACTOR_UNZIP_ERRNO;
638
639 if (0 != lSeek)
640 {
641 if (0 == ZSEEK (file->z_filefunc, lSeek, SEEK_CUR))
642 lSeek = 0;
643 else
644 return EXTRACTOR_UNZIP_ERRNO;
645 }
646 if ( (file_info.size_file_extra > 0) &&
647 (extraFieldBufferSize > 0) &&
648 (ZREAD (file->z_filefunc,
649 extraField,
650 uSizeRead) != uSizeRead) )
651 return EXTRACTOR_UNZIP_ERRNO;
652 lSeek += file_info.size_file_extra - uSizeRead;
653 } 649 }
650 if ( (file_info.size_file_extra > 0) &&
651 (extraFieldBufferSize > 0) &&
652 (ZREAD (file->z_filefunc,
653 extraField,
654 uSizeRead) != uSizeRead) )
655 return EXTRACTOR_UNZIP_ERRNO;
656 lSeek += file_info.size_file_extra - uSizeRead;
657 }
654 else 658 else
655 lSeek += file_info.size_file_extra; 659 lSeek += file_info.size_file_extra;
656 660
657 if (NULL != szComment) 661 if (NULL != szComment)
662 {
663 uLong uSizeRead;
664
665 if (file_info.size_file_comment < commentBufferSize)
658 { 666 {
659 uLong uSizeRead; 667 *(szComment + file_info.size_file_comment) = '\0';
668 uSizeRead = file_info.size_file_comment;
669 }
670 else
671 {
672 *(szComment + commentBufferSize - 1) = '\0';
673 uSizeRead = commentBufferSize - 1;
674 }
660 675
661 if (file_info.size_file_comment < commentBufferSize) 676 if (0 != lSeek)
662 { 677 {
663 *(szComment+file_info.size_file_comment) = '\0'; 678 if (0 == ZSEEK (file->z_filefunc, lSeek, SEEK_CUR))
664 uSizeRead = file_info.size_file_comment; 679 lSeek = 0;
665 }
666 else 680 else
667 { 681 return EXTRACTOR_UNZIP_ERRNO;
668 *(szComment+commentBufferSize - 1) = '\0';
669 uSizeRead = commentBufferSize - 1;
670 }
671
672 if (0 != lSeek)
673 {
674 if (0 == ZSEEK (file->z_filefunc, lSeek, SEEK_CUR))
675 lSeek = 0;
676 else
677 return EXTRACTOR_UNZIP_ERRNO;
678 }
679 if ( (file_info.size_file_comment > 0) &&
680 (commentBufferSize > 0) &&
681 (ZREAD (file->z_filefunc, szComment, uSizeRead) != uSizeRead) )
682 return EXTRACTOR_UNZIP_ERRNO;
683 lSeek += file_info.size_file_comment - uSizeRead;
684 } 682 }
683 if ( (file_info.size_file_comment > 0) &&
684 (commentBufferSize > 0) &&
685 (ZREAD (file->z_filefunc, szComment, uSizeRead) != uSizeRead) )
686 return EXTRACTOR_UNZIP_ERRNO;
687 lSeek += file_info.size_file_comment - uSizeRead;
688 }
685 else 689 else
686 lSeek += file_info.size_file_comment; 690 lSeek += file_info.size_file_comment;
687 691
@@ -709,9 +713,9 @@ EXTRACTOR_common_unzip_go_to_first_file (struct EXTRACTOR_UnzipFile *file)
709 file->pos_in_central_dir = file->offset_central_dir; 713 file->pos_in_central_dir = file->offset_central_dir;
710 file->num_file = 0; 714 file->num_file = 0;
711 err = get_current_file_info (file, 715 err = get_current_file_info (file,
712 &file->cur_file_info, 716 &file->cur_file_info,
713 &file->cur_file_info_internal, 717 &file->cur_file_info_internal,
714 NULL, 0, NULL, 0, NULL, 0); 718 NULL, 0, NULL, 0, NULL, 0);
715 file->current_file_ok = (EXTRACTOR_UNZIP_OK == err); 719 file->current_file_ok = (EXTRACTOR_UNZIP_OK == err);
716 return err; 720 return err;
717} 721}
@@ -731,12 +735,12 @@ unzip_open_using_ffd (struct FileFuncDefs *ffd)
731 uLong central_pos; 735 uLong central_pos;
732 uLong uL; 736 uLong uL;
733 uLong number_disk; /* number of the current dist, used for 737 uLong number_disk; /* number of the current dist, used for
734 spaning ZIP, unsupported, always 0*/ 738 spaning ZIP, unsupported, always 0*/
735 uLong number_disk_with_CD; /* number of the disk with central dir, used 739 uLong number_disk_with_CD; /* number of the disk with central dir, used
736 for spaning ZIP, unsupported, always 0*/ 740 for spaning ZIP, unsupported, always 0*/
737 uLong number_entry_CD; /* total number of entries in 741 uLong number_entry_CD; /* total number of entries in
738 the central dir 742 the central dir
739 (same than number_entry on nospan) */ 743 (same than number_entry on nospan) */
740 744
741 memset (&us, 0, sizeof(us)); 745 memset (&us, 0, sizeof(us));
742 us.z_filefunc = *ffd; 746 us.z_filefunc = *ffd;
@@ -744,7 +748,7 @@ unzip_open_using_ffd (struct FileFuncDefs *ffd)
744 if (0 == central_pos) 748 if (0 == central_pos)
745 return NULL; 749 return NULL;
746 if (0 != ZSEEK (us.z_filefunc, 750 if (0 != ZSEEK (us.z_filefunc,
747 central_pos, SEEK_SET)) 751 central_pos, SEEK_SET))
748 return NULL; 752 return NULL;
749 753
750 /* the signature, already checked */ 754 /* the signature, already checked */
@@ -796,8 +800,8 @@ unzip_open_using_ffd (struct FileFuncDefs *ffd)
796 if ((central_pos < us.offset_central_dir + us.size_central_dir)) 800 if ((central_pos < us.offset_central_dir + us.size_central_dir))
797 return NULL; 801 return NULL;
798 802
799 us.byte_before_the_zipfile = central_pos - 803 us.byte_before_the_zipfile = central_pos
800 (us.offset_central_dir + us.size_central_dir); 804 - (us.offset_central_dir + us.size_central_dir);
801 us.central_pos = central_pos; 805 us.central_pos = central_pos;
802 us.pfile_in_zip_read = NULL; 806 us.pfile_in_zip_read = NULL;
803 us.encrypted = 0; 807 us.encrypted = 0;
@@ -818,7 +822,7 @@ unzip_open_using_ffd (struct FileFuncDefs *ffd)
818int 822int
819EXTRACTOR_common_unzip_close_current_file (struct EXTRACTOR_UnzipFile *file) 823EXTRACTOR_common_unzip_close_current_file (struct EXTRACTOR_UnzipFile *file)
820{ 824{
821 struct FileInZipReadInfo* pfile_in_zip_read_info; 825 struct FileInZipReadInfo*pfile_in_zip_read_info;
822 int err = EXTRACTOR_UNZIP_OK; 826 int err = EXTRACTOR_UNZIP_OK;
823 827
824 if (NULL == file) 828 if (NULL == file)
@@ -868,8 +872,8 @@ EXTRACTOR_common_unzip_close (struct EXTRACTOR_UnzipFile *file)
868 */ 872 */
869int 873int
870EXTRACTOR_common_unzip_get_global_comment (struct EXTRACTOR_UnzipFile *file, 874EXTRACTOR_common_unzip_get_global_comment (struct EXTRACTOR_UnzipFile *file,
871 char *comment, 875 char *comment,
872 size_t comment_len) 876 size_t comment_len)
873{ 877{
874 if (NULL == file) 878 if (NULL == file)
875 return EXTRACTOR_UNZIP_PARAMERROR; 879 return EXTRACTOR_UNZIP_PARAMERROR;
@@ -901,19 +905,20 @@ EXTRACTOR_common_unzip_get_global_comment (struct EXTRACTOR_UnzipFile *file,
901 * @return #EXTRACTOR_UNZIP_OK if there is no problem. 905 * @return #EXTRACTOR_UNZIP_OK if there is no problem.
902 */ 906 */
903int 907int
904EXTRACTOR_common_unzip_get_current_file_info (struct EXTRACTOR_UnzipFile * file, 908EXTRACTOR_common_unzip_get_current_file_info (struct EXTRACTOR_UnzipFile *file,
905 struct EXTRACTOR_UnzipFileInfo *pfile_info, 909 struct EXTRACTOR_UnzipFileInfo *
906 char *szFileName, 910 pfile_info,
907 uLong fileNameBufferSize, 911 char *szFileName,
908 void *extraField, 912 uLong fileNameBufferSize,
909 uLong extraFieldBufferSize, 913 void *extraField,
910 char *szComment, 914 uLong extraFieldBufferSize,
911 uLong commentBufferSize) 915 char *szComment,
916 uLong commentBufferSize)
912{ 917{
913 return get_current_file_info (file, pfile_info, NULL, 918 return get_current_file_info (file, pfile_info, NULL,
914 szFileName, fileNameBufferSize, 919 szFileName, fileNameBufferSize,
915 extraField, extraFieldBufferSize, 920 extraField, extraFieldBufferSize,
916 szComment, commentBufferSize); 921 szComment, commentBufferSize);
917} 922}
918 923
919 924
@@ -935,13 +940,15 @@ EXTRACTOR_common_unzip_go_to_next_file (struct EXTRACTOR_UnzipFile *file)
935 return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE; 940 return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE;
936 if (file->num_file + 1 == file->gi.number_entry) 941 if (file->num_file + 1 == file->gi.number_entry)
937 return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE; 942 return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE;
938 file->pos_in_central_dir += SIZECENTRALDIRITEM + file->cur_file_info.size_filename + 943 file->pos_in_central_dir += SIZECENTRALDIRITEM
939 file->cur_file_info.size_file_extra + file->cur_file_info.size_file_comment; 944 + file->cur_file_info.size_filename
945 + file->cur_file_info.size_file_extra
946 + file->cur_file_info.size_file_comment;
940 file->num_file++; 947 file->num_file++;
941 err = get_current_file_info (file, 948 err = get_current_file_info (file,
942 &file->cur_file_info, 949 &file->cur_file_info,
943 &file->cur_file_info_internal, 950 &file->cur_file_info_internal,
944 NULL, 0, NULL, 0, NULL, 0); 951 NULL, 0, NULL, 0, NULL, 0);
945 file->current_file_ok = (EXTRACTOR_UNZIP_OK == err); 952 file->current_file_ok = (EXTRACTOR_UNZIP_OK == err);
946 return err; 953 return err;
947} 954}
@@ -960,8 +967,8 @@ EXTRACTOR_common_unzip_go_to_next_file (struct EXTRACTOR_UnzipFile *file)
960 */ 967 */
961int 968int
962EXTRACTOR_common_unzip_go_find_local_file (struct EXTRACTOR_UnzipFile *file, 969EXTRACTOR_common_unzip_go_find_local_file (struct EXTRACTOR_UnzipFile *file,
963 const char *szFileName, 970 const char *szFileName,
964 int iCaseSensitivity) 971 int iCaseSensitivity)
965{ 972{
966 int err; 973 int err;
967 /* We remember the 'current' position in the file so that we can jump 974 /* We remember the 'current' position in the file so that we can jump
@@ -987,22 +994,24 @@ EXTRACTOR_common_unzip_go_find_local_file (struct EXTRACTOR_UnzipFile *file,
987 err = EXTRACTOR_common_unzip_go_to_first_file (file); 994 err = EXTRACTOR_common_unzip_go_to_first_file (file);
988 995
989 while (EXTRACTOR_UNZIP_OK == err) 996 while (EXTRACTOR_UNZIP_OK == err)
990 { 997 {
991 char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1]; 998 char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1];
992 999
993 if (EXTRACTOR_UNZIP_OK != 1000 if (EXTRACTOR_UNZIP_OK !=
994 (err = EXTRACTOR_common_unzip_get_current_file_info (file, NULL, 1001 (err = EXTRACTOR_common_unzip_get_current_file_info (file, NULL,
995 szCurrentFileName, 1002 szCurrentFileName,
996 sizeof (szCurrentFileName) - 1, 1003 sizeof (
997 NULL, 0, NULL, 0))) 1004 szCurrentFileName)
998 break; 1005 - 1,
999 if (0 == 1006 NULL, 0, NULL, 0)))
1000 EXTRACTOR_common_unzip_string_file_name_compare (szCurrentFileName, 1007 break;
1001 szFileName, 1008 if (0 ==
1002 iCaseSensitivity)) 1009 EXTRACTOR_common_unzip_string_file_name_compare (szCurrentFileName,
1003 return EXTRACTOR_UNZIP_OK; 1010 szFileName,
1004 err = EXTRACTOR_common_unzip_go_to_next_file (file); 1011 iCaseSensitivity))
1005 } 1012 return EXTRACTOR_UNZIP_OK;
1013 err = EXTRACTOR_common_unzip_go_to_next_file (file);
1014 }
1006 1015
1007 /* We failed, so restore the state of the 'current file' to where we 1016 /* We failed, so restore the state of the 'current file' to where we
1008 * were. 1017 * were.
@@ -1027,8 +1036,8 @@ EXTRACTOR_common_unzip_go_find_local_file (struct EXTRACTOR_UnzipFile *file,
1027 */ 1036 */
1028ssize_t 1037ssize_t
1029EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file, 1038EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file,
1030 void *buf, 1039 void *buf,
1031 size_t len) 1040 size_t len)
1032{ 1041{
1033 int err = EXTRACTOR_UNZIP_OK; 1042 int err = EXTRACTOR_UNZIP_OK;
1034 uInt iRead = 0; 1043 uInt iRead = 0;
@@ -1050,97 +1059,97 @@ EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file,
1050 (uInt) pfile_in_zip_read_info->rest_read_uncompressed; 1059 (uInt) pfile_in_zip_read_info->rest_read_uncompressed;
1051 1060
1052 while (pfile_in_zip_read_info->stream.avail_out > 0) 1061 while (pfile_in_zip_read_info->stream.avail_out > 0)
1062 {
1063 if ( (0 == pfile_in_zip_read_info->stream.avail_in) &&
1064 (pfile_in_zip_read_info->rest_read_compressed > 0) )
1053 { 1065 {
1066 uInt uReadThis = UNZ_BUFSIZE;
1067 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1068 uReadThis = (uInt) pfile_in_zip_read_info->rest_read_compressed;
1069 if (0 == uReadThis)
1070 return EXTRACTOR_UNZIP_EOF;
1071 if (0 !=
1072 ZSEEK (pfile_in_zip_read_info->z_filefunc,
1073 pfile_in_zip_read_info->pos_in_zipfile
1074 + pfile_in_zip_read_info->byte_before_the_zipfile,
1075 SEEK_SET))
1076 return EXTRACTOR_UNZIP_ERRNO;
1077 if (ZREAD (pfile_in_zip_read_info->z_filefunc,
1078 pfile_in_zip_read_info->read_buffer,
1079 uReadThis) != uReadThis)
1080 return EXTRACTOR_UNZIP_ERRNO;
1081
1082 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1083 pfile_in_zip_read_info->rest_read_compressed -= uReadThis;
1084 pfile_in_zip_read_info->stream.next_in =
1085 (Bytef *) pfile_in_zip_read_info->read_buffer;
1086 pfile_in_zip_read_info->stream.avail_in = (uInt) uReadThis;
1087 }
1088
1089 if (0 == pfile_in_zip_read_info->compression_method)
1090 {
1091 uInt uDoCopy;
1092
1054 if ( (0 == pfile_in_zip_read_info->stream.avail_in) && 1093 if ( (0 == pfile_in_zip_read_info->stream.avail_in) &&
1055 (pfile_in_zip_read_info->rest_read_compressed > 0) ) 1094 (0 == pfile_in_zip_read_info->rest_read_compressed) )
1056 { 1095 return (0 == iRead) ? EXTRACTOR_UNZIP_EOF : iRead;
1057 uInt uReadThis = UNZ_BUFSIZE; 1096
1058 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) 1097 if (pfile_in_zip_read_info->stream.avail_out <
1059 uReadThis = (uInt) pfile_in_zip_read_info->rest_read_compressed; 1098 pfile_in_zip_read_info->stream.avail_in)
1060 if (0 == uReadThis) 1099 uDoCopy = pfile_in_zip_read_info->stream.avail_out;
1061 return EXTRACTOR_UNZIP_EOF;
1062 if (0 !=
1063 ZSEEK (pfile_in_zip_read_info->z_filefunc,
1064 pfile_in_zip_read_info->pos_in_zipfile +
1065 pfile_in_zip_read_info->byte_before_the_zipfile,
1066 SEEK_SET))
1067 return EXTRACTOR_UNZIP_ERRNO;
1068 if (ZREAD (pfile_in_zip_read_info->z_filefunc,
1069 pfile_in_zip_read_info->read_buffer,
1070 uReadThis) != uReadThis)
1071 return EXTRACTOR_UNZIP_ERRNO;
1072
1073 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1074 pfile_in_zip_read_info->rest_read_compressed -= uReadThis;
1075 pfile_in_zip_read_info->stream.next_in =
1076 (Bytef *) pfile_in_zip_read_info->read_buffer;
1077 pfile_in_zip_read_info->stream.avail_in = (uInt) uReadThis;
1078 }
1079
1080 if (0 == pfile_in_zip_read_info->compression_method)
1081 {
1082 uInt uDoCopy;
1083
1084 if ( (0 == pfile_in_zip_read_info->stream.avail_in) &&
1085 (0 == pfile_in_zip_read_info->rest_read_compressed) )
1086 return (0 == iRead) ? EXTRACTOR_UNZIP_EOF : iRead;
1087
1088 if (pfile_in_zip_read_info->stream.avail_out <
1089 pfile_in_zip_read_info->stream.avail_in)
1090 uDoCopy = pfile_in_zip_read_info->stream.avail_out;
1091 else
1092 uDoCopy = pfile_in_zip_read_info->stream.avail_in;
1093 memcpy (pfile_in_zip_read_info->stream.next_out,
1094 pfile_in_zip_read_info->stream.next_in,
1095 uDoCopy);
1096 pfile_in_zip_read_info->crc32 = crc32 (pfile_in_zip_read_info->crc32,
1097 pfile_in_zip_read_info->stream.next_out,
1098 uDoCopy);
1099 pfile_in_zip_read_info->rest_read_uncompressed -= uDoCopy;
1100 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1101 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1102 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1103 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1104 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1105 iRead += uDoCopy;
1106 }
1107 else 1100 else
1108 { 1101 uDoCopy = pfile_in_zip_read_info->stream.avail_in;
1109 uLong uTotalOutBefore; 1102 memcpy (pfile_in_zip_read_info->stream.next_out,
1110 uLong uTotalOutAfter; 1103 pfile_in_zip_read_info->stream.next_in,
1111 const Bytef *bufBefore; 1104 uDoCopy);
1112 uLong uOutThis; 1105 pfile_in_zip_read_info->crc32 = crc32 (pfile_in_zip_read_info->crc32,
1113 int flush = Z_SYNC_FLUSH; 1106 pfile_in_zip_read_info->stream.
1114 1107 next_out,
1115 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; 1108 uDoCopy);
1116 bufBefore = pfile_in_zip_read_info->stream.next_out; 1109 pfile_in_zip_read_info->rest_read_uncompressed -= uDoCopy;
1117 1110 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1118 /* 1111 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1119 if ((pfile_in_zip_read_info->rest_read_uncompressed == 1112 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1120 pfile_in_zip_read_info->stream.avail_out) && 1113 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1121 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1114 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1122 flush = Z_FINISH; 1115 iRead += uDoCopy;
1123 */ 1116 }
1124 err = inflate (&pfile_in_zip_read_info->stream, flush); 1117 else
1125 1118 {
1126 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; 1119 uLong uTotalOutBefore;
1127 uOutThis = uTotalOutAfter-uTotalOutBefore; 1120 uLong uTotalOutAfter;
1128 1121 const Bytef *bufBefore;
1129 pfile_in_zip_read_info->crc32 = 1122 uLong uOutThis;
1130 crc32 (pfile_in_zip_read_info->crc32, bufBefore, 1123 int flush = Z_SYNC_FLUSH;
1131 (uInt) (uOutThis)); 1124
1132 1125 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1133 pfile_in_zip_read_info->rest_read_uncompressed -= 1126 bufBefore = pfile_in_zip_read_info->stream.next_out;
1134 uOutThis; 1127
1135 1128 /*
1136 iRead += (uInt) (uTotalOutAfter - uTotalOutBefore); 1129 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1137 1130 pfile_in_zip_read_info->stream.avail_out) &&
1138 if (Z_STREAM_END == err) 1131 (pfile_in_zip_read_info->rest_read_compressed == 0))
1139 return (0 == iRead) ? EXTRACTOR_UNZIP_EOF : iRead; 1132 flush = Z_FINISH;
1140 if (Z_OK != err) 1133 */err = inflate (&pfile_in_zip_read_info->stream, flush);
1141 break; 1134
1142 } 1135 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1136 uOutThis = uTotalOutAfter - uTotalOutBefore;
1137
1138 pfile_in_zip_read_info->crc32 =
1139 crc32 (pfile_in_zip_read_info->crc32, bufBefore,
1140 (uInt) (uOutThis));
1141
1142 pfile_in_zip_read_info->rest_read_uncompressed -=
1143 uOutThis;
1144
1145 iRead += (uInt) (uTotalOutAfter - uTotalOutBefore);
1146
1147 if (Z_STREAM_END == err)
1148 return (0 == iRead) ? EXTRACTOR_UNZIP_EOF : iRead;
1149 if (Z_OK != err)
1150 break;
1143 } 1151 }
1152 }
1144 1153
1145 if (Z_OK == err) 1154 if (Z_OK == err)
1146 return iRead; 1155 return iRead;
@@ -1162,9 +1171,9 @@ EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file,
1162 */ 1171 */
1163static int 1172static int
1164parse_current_file_coherency_header (struct EXTRACTOR_UnzipFile *file, 1173parse_current_file_coherency_header (struct EXTRACTOR_UnzipFile *file,
1165 uInt *piSizeVar, 1174 uInt *piSizeVar,
1166 uLong *poffset_local_extrafield, 1175 uLong *poffset_local_extrafield,
1167 uInt *psize_local_extrafield) 1176 uInt *psize_local_extrafield)
1168{ 1177{
1169 uLong uMagic; 1178 uLong uMagic;
1170 uLong uData; 1179 uLong uData;
@@ -1177,20 +1186,20 @@ parse_current_file_coherency_header (struct EXTRACTOR_UnzipFile *file,
1177 *psize_local_extrafield = 0; 1186 *psize_local_extrafield = 0;
1178 1187
1179 if (0 != ZSEEK (file->z_filefunc, 1188 if (0 != ZSEEK (file->z_filefunc,
1180 file->cur_file_info_internal.offset_curfile + 1189 file->cur_file_info_internal.offset_curfile
1181 file->byte_before_the_zipfile, 1190 + file->byte_before_the_zipfile,
1182 SEEK_SET)) 1191 SEEK_SET))
1183 return EXTRACTOR_UNZIP_ERRNO; 1192 return EXTRACTOR_UNZIP_ERRNO;
1184 if (EXTRACTOR_UNZIP_OK != 1193 if (EXTRACTOR_UNZIP_OK !=
1185 read_long_from_ffd (&file->z_filefunc, 1194 read_long_from_ffd (&file->z_filefunc,
1186 &uMagic)) 1195 &uMagic))
1187 return EXTRACTOR_UNZIP_ERRNO; 1196 return EXTRACTOR_UNZIP_ERRNO;
1188 if (0x04034b50 != uMagic) 1197 if (0x04034b50 != uMagic)
1189 return EXTRACTOR_UNZIP_BADZIPFILE; 1198 return EXTRACTOR_UNZIP_BADZIPFILE;
1190 if ( (EXTRACTOR_UNZIP_OK != 1199 if ( (EXTRACTOR_UNZIP_OK !=
1191 read_short_from_ffd (&file->z_filefunc, &uData)) || 1200 read_short_from_ffd (&file->z_filefunc, &uData)) ||
1192 (EXTRACTOR_UNZIP_OK != 1201 (EXTRACTOR_UNZIP_OK !=
1193 read_short_from_ffd (&file->z_filefunc, &uFlags)) ) 1202 read_short_from_ffd (&file->z_filefunc, &uFlags)) )
1194 return EXTRACTOR_UNZIP_ERRNO; 1203 return EXTRACTOR_UNZIP_ERRNO;
1195 if (EXTRACTOR_UNZIP_OK != read_short_from_ffd (&file->z_filefunc, &uData)) 1204 if (EXTRACTOR_UNZIP_OK != read_short_from_ffd (&file->z_filefunc, &uData))
1196 return EXTRACTOR_UNZIP_ERRNO; 1205 return EXTRACTOR_UNZIP_ERRNO;
@@ -1209,14 +1218,14 @@ parse_current_file_coherency_header (struct EXTRACTOR_UnzipFile *file,
1209 (0 == (uFlags & 8)) ) 1218 (0 == (uFlags & 8)) )
1210 return EXTRACTOR_UNZIP_BADZIPFILE; 1219 return EXTRACTOR_UNZIP_BADZIPFILE;
1211 if (EXTRACTOR_UNZIP_OK != 1220 if (EXTRACTOR_UNZIP_OK !=
1212 read_long_from_ffd(&file->z_filefunc, &uData)) /* size compr */ 1221 read_long_from_ffd (&file->z_filefunc, &uData)) /* size compr */
1213 return EXTRACTOR_UNZIP_ERRNO; 1222 return EXTRACTOR_UNZIP_ERRNO;
1214 if ( (uData != file->cur_file_info.compressed_size) && 1223 if ( (uData != file->cur_file_info.compressed_size) &&
1215 (0 == (uFlags & 8)) ) 1224 (0 == (uFlags & 8)) )
1216 return EXTRACTOR_UNZIP_BADZIPFILE; 1225 return EXTRACTOR_UNZIP_BADZIPFILE;
1217 if (EXTRACTOR_UNZIP_OK != 1226 if (EXTRACTOR_UNZIP_OK !=
1218 read_long_from_ffd (&file->z_filefunc, 1227 read_long_from_ffd (&file->z_filefunc,
1219 &uData)) /* size uncompr */ 1228 &uData)) /* size uncompr */
1220 return EXTRACTOR_UNZIP_ERRNO; 1229 return EXTRACTOR_UNZIP_ERRNO;
1221 if ( (uData != file->cur_file_info.uncompressed_size) && 1230 if ( (uData != file->cur_file_info.uncompressed_size) &&
1222 (0 == (uFlags & 8))) 1231 (0 == (uFlags & 8)))
@@ -1229,12 +1238,12 @@ parse_current_file_coherency_header (struct EXTRACTOR_UnzipFile *file,
1229 *piSizeVar += (uInt) size_filename; 1238 *piSizeVar += (uInt) size_filename;
1230 if (EXTRACTOR_UNZIP_OK != 1239 if (EXTRACTOR_UNZIP_OK !=
1231 read_short_from_ffd (&file->z_filefunc, 1240 read_short_from_ffd (&file->z_filefunc,
1232 &size_extra_field)) 1241 &size_extra_field))
1233 return EXTRACTOR_UNZIP_ERRNO; 1242 return EXTRACTOR_UNZIP_ERRNO;
1234 *poffset_local_extrafield = file->cur_file_info_internal.offset_curfile + 1243 *poffset_local_extrafield = file->cur_file_info_internal.offset_curfile
1235 SIZEZIPLOCALHEADER + size_filename; 1244 + SIZEZIPLOCALHEADER + size_filename;
1236 *psize_local_extrafield = (uInt) size_extra_field; 1245 *psize_local_extrafield = (uInt) size_extra_field;
1237 *piSizeVar += (uInt)size_extra_field; 1246 *piSizeVar += (uInt) size_extra_field;
1238 1247
1239 return EXTRACTOR_UNZIP_OK; 1248 return EXTRACTOR_UNZIP_OK;
1240} 1249}
@@ -1253,7 +1262,7 @@ EXTRACTOR_common_unzip_open_current_file (struct EXTRACTOR_UnzipFile *file)
1253 uInt iSizeVar; 1262 uInt iSizeVar;
1254 struct FileInZipReadInfo *pfile_in_zip_read_info; 1263 struct FileInZipReadInfo *pfile_in_zip_read_info;
1255 uLong offset_local_extrafield; /* offset of the local extra field */ 1264 uLong offset_local_extrafield; /* offset of the local extra field */
1256 uInt size_local_extrafield; /* size of the local extra field */ 1265 uInt size_local_extrafield; /* size of the local extra field */
1257 1266
1258 if (NULL == file) 1267 if (NULL == file)
1259 return EXTRACTOR_UNZIP_PARAMERROR; 1268 return EXTRACTOR_UNZIP_PARAMERROR;
@@ -1263,17 +1272,18 @@ EXTRACTOR_common_unzip_open_current_file (struct EXTRACTOR_UnzipFile *file)
1263 EXTRACTOR_common_unzip_close_current_file (file); 1272 EXTRACTOR_common_unzip_close_current_file (file);
1264 if (EXTRACTOR_UNZIP_OK != 1273 if (EXTRACTOR_UNZIP_OK !=
1265 parse_current_file_coherency_header (file, 1274 parse_current_file_coherency_header (file,
1266 &iSizeVar, 1275 &iSizeVar,
1267 &offset_local_extrafield, 1276 &offset_local_extrafield,
1268 &size_local_extrafield)) 1277 &size_local_extrafield))
1269 return EXTRACTOR_UNZIP_BADZIPFILE; 1278 return EXTRACTOR_UNZIP_BADZIPFILE;
1270 if (NULL == (pfile_in_zip_read_info = malloc (sizeof(struct FileInZipReadInfo)))) 1279 if (NULL == (pfile_in_zip_read_info = malloc (sizeof(struct
1280 FileInZipReadInfo))))
1271 return EXTRACTOR_UNZIP_INTERNALERROR; 1281 return EXTRACTOR_UNZIP_INTERNALERROR;
1272 if (NULL == (pfile_in_zip_read_info->read_buffer = malloc (UNZ_BUFSIZE))) 1282 if (NULL == (pfile_in_zip_read_info->read_buffer = malloc (UNZ_BUFSIZE)))
1273 { 1283 {
1274 free (pfile_in_zip_read_info); 1284 free (pfile_in_zip_read_info);
1275 return EXTRACTOR_UNZIP_INTERNALERROR; 1285 return EXTRACTOR_UNZIP_INTERNALERROR;
1276 } 1286 }
1277 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; 1287 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1278 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; 1288 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1279 pfile_in_zip_read_info->pos_local_extrafield = 0; 1289 pfile_in_zip_read_info->pos_local_extrafield = 0;
@@ -1281,45 +1291,49 @@ EXTRACTOR_common_unzip_open_current_file (struct EXTRACTOR_UnzipFile *file)
1281 1291
1282 if ( (0 != file->cur_file_info.compression_method) && 1292 if ( (0 != file->cur_file_info.compression_method) &&
1283 (Z_DEFLATED != file->cur_file_info.compression_method) ) 1293 (Z_DEFLATED != file->cur_file_info.compression_method) )
1284 { 1294 {
1285 // err = EXTRACTOR_UNZIP_BADZIPFILE; 1295 // err = EXTRACTOR_UNZIP_BADZIPFILE;
1286 // FIXME: we don't do anything with this 'err' code. 1296 // FIXME: we don't do anything with this 'err' code.
1287 // Can this happen? Should we abort in this case? 1297 // Can this happen? Should we abort in this case?
1288 } 1298 }
1289 1299
1290 pfile_in_zip_read_info->crc32_wait = file->cur_file_info.crc; 1300 pfile_in_zip_read_info->crc32_wait = file->cur_file_info.crc;
1291 pfile_in_zip_read_info->crc32 = 0; 1301 pfile_in_zip_read_info->crc32 = 0;
1292 pfile_in_zip_read_info->compression_method = file->cur_file_info.compression_method; 1302 pfile_in_zip_read_info->compression_method =
1303 file->cur_file_info.compression_method;
1293 pfile_in_zip_read_info->z_filefunc = file->z_filefunc; 1304 pfile_in_zip_read_info->z_filefunc = file->z_filefunc;
1294 pfile_in_zip_read_info->byte_before_the_zipfile = file->byte_before_the_zipfile; 1305 pfile_in_zip_read_info->byte_before_the_zipfile =
1306 file->byte_before_the_zipfile;
1295 pfile_in_zip_read_info->stream.total_out = 0; 1307 pfile_in_zip_read_info->stream.total_out = 0;
1296 if (Z_DEFLATED == file->cur_file_info.compression_method) 1308 if (Z_DEFLATED == file->cur_file_info.compression_method)
1309 {
1310 pfile_in_zip_read_info->stream.zalloc = (alloc_func) NULL;
1311 pfile_in_zip_read_info->stream.zfree = (free_func) NULL;
1312 pfile_in_zip_read_info->stream.opaque = NULL;
1313 pfile_in_zip_read_info->stream.next_in = NULL;
1314 pfile_in_zip_read_info->stream.avail_in = 0;
1315 if (Z_OK != (err = inflateInit2 (&pfile_in_zip_read_info->stream,
1316 -MAX_WBITS)))
1297 { 1317 {
1298 pfile_in_zip_read_info->stream.zalloc = (alloc_func) NULL; 1318 free (pfile_in_zip_read_info->read_buffer);
1299 pfile_in_zip_read_info->stream.zfree = (free_func) NULL; 1319 free (pfile_in_zip_read_info);
1300 pfile_in_zip_read_info->stream.opaque = NULL; 1320 return err;
1301 pfile_in_zip_read_info->stream.next_in = NULL;
1302 pfile_in_zip_read_info->stream.avail_in = 0;
1303 if (Z_OK != (err = inflateInit2 (&pfile_in_zip_read_info->stream, -MAX_WBITS)))
1304 {
1305 free (pfile_in_zip_read_info->read_buffer);
1306 free (pfile_in_zip_read_info);
1307 return err;
1308 }
1309 pfile_in_zip_read_info->stream_initialised = 1;
1310 /* windowBits is passed < 0 to tell that there is no zlib header.
1311 * Note that in this case inflate *requires* an extra "dummy" byte
1312 * after the compressed stream in order to complete decompression and
1313 * return Z_STREAM_END.
1314 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1315 * size of both compressed and uncompressed data
1316 */
1317 } 1321 }
1318 pfile_in_zip_read_info->rest_read_compressed = file->cur_file_info.compressed_size; 1322 pfile_in_zip_read_info->stream_initialised = 1;
1319 pfile_in_zip_read_info->rest_read_uncompressed = file->cur_file_info.uncompressed_size; 1323 /* windowBits is passed < 0 to tell that there is no zlib header.
1324 * Note that in this case inflate *requires* an extra "dummy" byte
1325 * after the compressed stream in order to complete decompression and
1326 * return Z_STREAM_END.
1327 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1328 * size of both compressed and uncompressed data
1329 */}
1330 pfile_in_zip_read_info->rest_read_compressed =
1331 file->cur_file_info.compressed_size;
1332 pfile_in_zip_read_info->rest_read_uncompressed =
1333 file->cur_file_info.uncompressed_size;
1320 pfile_in_zip_read_info->pos_in_zipfile = 1334 pfile_in_zip_read_info->pos_in_zipfile =
1321 file->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 1335 file->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER
1322 iSizeVar; 1336 + iSizeVar;
1323 pfile_in_zip_read_info->stream.avail_in = 0; 1337 pfile_in_zip_read_info->stream.avail_in = 0;
1324 file->pfile_in_zip_read = pfile_in_zip_read_info; 1338 file->pfile_in_zip_read = pfile_in_zip_read_info;
1325 return EXTRACTOR_UNZIP_OK; 1339 return EXTRACTOR_UNZIP_OK;
@@ -1337,8 +1351,8 @@ EXTRACTOR_common_unzip_open_current_file (struct EXTRACTOR_UnzipFile *file)
1337 */ 1351 */
1338static uLong 1352static uLong
1339ec_read_file_func (voidpf opaque, 1353ec_read_file_func (voidpf opaque,
1340 void* buf, 1354 void*buf,
1341 uLong size) 1355 uLong size)
1342{ 1356{
1343 struct EXTRACTOR_ExtractContext *ec = opaque; 1357 struct EXTRACTOR_ExtractContext *ec = opaque;
1344 void *ptr; 1358 void *ptr;
@@ -1347,15 +1361,15 @@ ec_read_file_func (voidpf opaque,
1347 1361
1348 done = 0; 1362 done = 0;
1349 while (done < size) 1363 while (done < size)
1350 { 1364 {
1351 ret = ec->read (ec->cls, 1365 ret = ec->read (ec->cls,
1352 &ptr, 1366 &ptr,
1353 size - done); 1367 size - done);
1354 if (ret <= 0) 1368 if (ret <= 0)
1355 return done; 1369 return done;
1356 memcpy (buf + done, ptr, ret); 1370 memcpy (buf + done, ptr, ret);
1357 done += ret; 1371 done += ret;
1358 } 1372 }
1359 return done; 1373 return done;
1360} 1374}
1361 1375
@@ -1385,8 +1399,8 @@ ec_tell_file_func (voidpf opaque)
1385 */ 1399 */
1386static long 1400static long
1387ec_seek_file_func (voidpf opaque, 1401ec_seek_file_func (voidpf opaque,
1388 uLong offset, 1402 uLong offset,
1389 int origin) 1403 int origin)
1390{ 1404{
1391 struct EXTRACTOR_ExtractContext *ec = opaque; 1405 struct EXTRACTOR_ExtractContext *ec = opaque;
1392 1406
@@ -1416,4 +1430,5 @@ EXTRACTOR_common_unzip_open (struct EXTRACTOR_ExtractContext *ec)
1416 return unzip_open_using_ffd (&ffd); 1430 return unzip_open_using_ffd (&ffd);
1417} 1431}
1418 1432
1433
1419/* end of unzip.c */ 1434/* end of unzip.c */