diff options
Diffstat (limited to 'src/common/unzip.c')
-rw-r--r-- | src/common/unzip.c | 671 |
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 | */ |
338 | static int | 340 | static int |
339 | read_byte_from_ffd (const struct FileFuncDefs *ffd, | 341 | read_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 | */ |
360 | static int | 362 | static int |
361 | read_short_from_ffd (const struct FileFuncDefs *ffd, | 363 | read_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 | */ |
389 | static int | 391 | static int |
390 | read_long_from_ffd (const struct FileFuncDefs *ffd, | 392 | read_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 | */ |
438 | static int | 440 | static int |
439 | EXTRACTOR_common_unzip_string_file_name_compare (const char* fileName1, | 441 | EXTRACTOR_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 | */ |
513 | static void | 515 | static void |
514 | dos_date_to_tmu_date (uLong ulDosDate, | 516 | dos_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 | */ |
544 | static int | 546 | static int |
545 | get_current_file_info (struct EXTRACTOR_UnzipFile *file, | 547 | get_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) | |||
818 | int | 822 | int |
819 | EXTRACTOR_common_unzip_close_current_file (struct EXTRACTOR_UnzipFile *file) | 823 | EXTRACTOR_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 | */ |
869 | int | 873 | int |
870 | EXTRACTOR_common_unzip_get_global_comment (struct EXTRACTOR_UnzipFile *file, | 874 | EXTRACTOR_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 | */ |
903 | int | 907 | int |
904 | EXTRACTOR_common_unzip_get_current_file_info (struct EXTRACTOR_UnzipFile * file, | 908 | EXTRACTOR_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 | */ |
961 | int | 968 | int |
962 | EXTRACTOR_common_unzip_go_find_local_file (struct EXTRACTOR_UnzipFile *file, | 969 | EXTRACTOR_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 | */ |
1028 | ssize_t | 1037 | ssize_t |
1029 | EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file, | 1038 | EXTRACTOR_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 | */ |
1163 | static int | 1172 | static int |
1164 | parse_current_file_coherency_header (struct EXTRACTOR_UnzipFile *file, | 1173 | parse_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 | */ |
1338 | static uLong | 1352 | static uLong |
1339 | ec_read_file_func (voidpf opaque, | 1353 | ec_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 | */ |
1386 | static long | 1400 | static long |
1387 | ec_seek_file_func (voidpf opaque, | 1401 | ec_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 */ |