diff options
author | Christian Grothoff <christian@grothoff.org> | 2012-08-13 08:35:11 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2012-08-13 08:35:11 +0000 |
commit | d491e2066f59c74df2b3b8ac4d5450210826618f (patch) | |
tree | febded193ba93ec4082b620a524eecb9b192f297 | |
parent | 89871324067d30a1e613b472365a1ffc94538260 (diff) | |
download | libextractor-d491e2066f59c74df2b3b8ac4d5450210826618f.tar.gz libextractor-d491e2066f59c74df2b3b8ac4d5450210826618f.zip |
wip unzip
-rw-r--r-- | src/common/unzip.c | 748 |
1 files changed, 370 insertions, 378 deletions
diff --git a/src/common/unzip.c b/src/common/unzip.c index a6de272..144c5ac 100644 --- a/src/common/unzip.c +++ b/src/common/unzip.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of libextractor. | 2 | This file is part of libextractor. |
3 | (C) 2004, 2008 Vidyut Samanta and Christian Grothoff | 3 | (C) 2004, 2008, 2012 Vidyut Samanta and Christian Grothoff |
4 | 4 | ||
5 | libextractor is free software; you can redistribute it and/or modify | 5 | libextractor is free software; you can redistribute it and/or modify |
6 | it under the terms of the GNU General Public License as published | 6 | it under the terms of the GNU General Public License as published |
@@ -34,7 +34,6 @@ | |||
34 | #define CASESENSITIVITY (0) | 34 | #define CASESENSITIVITY (0) |
35 | #define MAXFILENAME (256) | 35 | #define MAXFILENAME (256) |
36 | 36 | ||
37 | |||
38 | #ifndef UNZ_BUFSIZE | 37 | #ifndef UNZ_BUFSIZE |
39 | #define UNZ_BUFSIZE (16384) | 38 | #define UNZ_BUFSIZE (16384) |
40 | #endif | 39 | #endif |
@@ -43,7 +42,6 @@ | |||
43 | #define UNZ_MAXFILENAMEINZIP (256) | 42 | #define UNZ_MAXFILENAMEINZIP (256) |
44 | #endif | 43 | #endif |
45 | 44 | ||
46 | |||
47 | #define SIZECENTRALDIRITEM (0x2e) | 45 | #define SIZECENTRALDIRITEM (0x2e) |
48 | #define SIZEZIPLOCALHEADER (0x1e) | 46 | #define SIZEZIPLOCALHEADER (0x1e) |
49 | 47 | ||
@@ -75,16 +73,6 @@ struct EXTRACTOR_UnzipFileFuncDefs | |||
75 | }; | 73 | }; |
76 | 74 | ||
77 | 75 | ||
78 | #define ZLIB_FILEFUNC_SEEK_CUR (1) | ||
79 | #define ZLIB_FILEFUNC_SEEK_END (2) | ||
80 | #define ZLIB_FILEFUNC_SEEK_SET (0) | ||
81 | |||
82 | #define ZLIB_FILEFUNC_MODE_READ (1) | ||
83 | #define ZLIB_FILEFUNC_MODE_WRITE (2) | ||
84 | #define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) | ||
85 | #define ZLIB_FILEFUNC_MODE_EXISTING (4) | ||
86 | #define ZLIB_FILEFUNC_MODE_CREATE (8) | ||
87 | |||
88 | /** | 76 | /** |
89 | * Macro to read using filefunc API. | 77 | * Macro to read using filefunc API. |
90 | * | 78 | * |
@@ -313,7 +301,7 @@ unzlocal_getByte (const struct EXTRACTOR_UnzipFileFuncDefs* pzlib_filefunc_def, | |||
313 | 301 | ||
314 | if (1 != ZREAD (*pzlib_filefunc_def, &c, 1)) | 302 | if (1 != ZREAD (*pzlib_filefunc_def, &c, 1)) |
315 | return EXTRACTOR_UNZIP_EOF; | 303 | return EXTRACTOR_UNZIP_EOF; |
316 | *pi = (int)c; | 304 | *pi = (int) c; |
317 | return EXTRACTOR_UNZIP_OK; | 305 | return EXTRACTOR_UNZIP_OK; |
318 | } | 306 | } |
319 | 307 | ||
@@ -349,7 +337,7 @@ unzlocal_getLong (const struct EXTRACTOR_UnzipFileFuncDefs* pzlib_filefunc_def, | |||
349 | *pX = 0; | 337 | *pX = 0; |
350 | if (EXTRACTOR_UNZIP_OK != (err = unzlocal_getByte (pzlib_filefunc_def, &i))) | 338 | if (EXTRACTOR_UNZIP_OK != (err = unzlocal_getByte (pzlib_filefunc_def, &i))) |
351 | return err; | 339 | return err; |
352 | x = (uLong)i; | 340 | x = (uLong) i; |
353 | if (EXTRACTOR_UNZIP_OK != (err = unzlocal_getByte (pzlib_filefunc_def, &i))) | 341 | if (EXTRACTOR_UNZIP_OK != (err = unzlocal_getByte (pzlib_filefunc_def, &i))) |
354 | return err; | 342 | return err; |
355 | x += ((uLong) i) << 8; | 343 | x += ((uLong) i) << 8; |
@@ -404,64 +392,69 @@ EXTRACTOR_common_unzip_string_file_name_compare (const char* fileName1, | |||
404 | #define BUFREADCOMMENT (0x400) | 392 | #define BUFREADCOMMENT (0x400) |
405 | #endif | 393 | #endif |
406 | 394 | ||
395 | |||
407 | /** | 396 | /** |
408 | * | 397 | * |
409 | */ | 398 | */ |
410 | static uLong | 399 | static uLong |
411 | unzlocal_SearchCentralDir (const struct EXTRACTOR_UnzipFileFuncDefs* pzlib_filefunc_def) | 400 | unzlocal_SearchCentralDir (const struct EXTRACTOR_UnzipFileFuncDefs* pzlib_filefunc_def) |
412 | { | 401 | { |
413 | unsigned char* buf; | 402 | unsigned char *buf; |
414 | uLong uSizeFile; | 403 | uLong uSizeFile; |
415 | uLong uBackRead; | 404 | uLong uBackRead; |
416 | uLong uMaxBack=0xffff; /* maximum size of global comment */ | 405 | uLong uMaxBack = 0xffff; /* maximum size of global comment */ |
417 | uLong uPosFound=0; | 406 | uLong uPosFound = 0; |
418 | 407 | ||
419 | if (0 != ZSEEK (*pzlib_filefunc_def, 0, ZLIB_FILEFUNC_SEEK_END)) | 408 | if (0 != ZSEEK (*pzlib_filefunc_def, 0, SEEK_END)) |
420 | return 0; | 409 | return 0; |
421 | uSizeFile = ZTELL (*pzlib_filefunc_def); | 410 | uSizeFile = ZTELL (*pzlib_filefunc_def); |
422 | 411 | ||
423 | if (uMaxBack > uSizeFile) | 412 | if (uMaxBack > uSizeFile) |
424 | uMaxBack = uSizeFile; | 413 | uMaxBack = uSizeFile; |
425 | 414 | ||
426 | if (NULL == (buf = malloc(BUFREADCOMMENT+4))) | 415 | if (NULL == (buf = malloc(BUFREADCOMMENT + 4))) |
427 | return 0; | 416 | return 0; |
428 | 417 | ||
429 | uBackRead = 4; | 418 | uBackRead = 4; |
430 | while (uBackRead<uMaxBack) | 419 | while (uBackRead < uMaxBack) |
431 | { | 420 | { |
432 | uLong uReadSize; | 421 | uLong uReadSize; |
433 | uLong uReadPos; | 422 | uLong uReadPos; |
434 | int i; | 423 | int i; |
435 | 424 | ||
436 | if (uBackRead+BUFREADCOMMENT>uMaxBack) | 425 | if (uBackRead + BUFREADCOMMENT > uMaxBack) |
437 | uBackRead = uMaxBack; | 426 | uBackRead = uMaxBack; |
438 | else | 427 | else |
439 | uBackRead+=BUFREADCOMMENT; | 428 | uBackRead += BUFREADCOMMENT; |
440 | uReadPos = uSizeFile-uBackRead ; | 429 | uReadPos = uSizeFile - uBackRead; |
441 | 430 | ||
442 | uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? | 431 | uReadSize = ((BUFREADCOMMENT + 4) < (uSizeFile - uReadPos)) |
443 | (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); | 432 | ? (BUFREADCOMMENT + 4) |
444 | if (0 != ZSEEK (*pzlib_filefunc_def, uReadPos, ZLIB_FILEFUNC_SEEK_SET)) | 433 | : (uSizeFile - uReadPos); |
434 | if (0 != ZSEEK (*pzlib_filefunc_def, uReadPos, SEEK_SET)) | ||
445 | break; | 435 | break; |
446 | 436 | ||
447 | if (ZREAD (*pzlib_filefunc_def, buf, uReadSize)!=uReadSize) | 437 | if (ZREAD (*pzlib_filefunc_def, buf, uReadSize) != uReadSize) |
448 | break; | 438 | break; |
449 | 439 | ||
450 | for (i=(int)uReadSize-3; (i--)>0;) | 440 | i = (int) uReadSize - 3; |
451 | if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && | 441 | while (i-- > 0) |
452 | ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) | 442 | if ( (0x50 == (*(buf+i))) && |
443 | (0x4b == (*(buf+i+1))) && | ||
444 | (0x05 == (*(buf+i+2))) && | ||
445 | (0x06 == (*(buf+i+3))) ) | ||
453 | { | 446 | { |
454 | uPosFound = uReadPos+i; | 447 | uPosFound = uReadPos + i; |
455 | break; | 448 | break; |
456 | } | 449 | } |
457 | |||
458 | if (0 != uPosFound) | 450 | if (0 != uPosFound) |
459 | break; | 451 | break; |
460 | } | 452 | } |
461 | free(buf); | 453 | free (buf); |
462 | return uPosFound; | 454 | return uPosFound; |
463 | } | 455 | } |
464 | 456 | ||
457 | |||
465 | /** | 458 | /** |
466 | * Translate date/time from Dos format to struct | 459 | * Translate date/time from Dos format to struct |
467 | * EXTRACTOR_UnzipDateTimeInfo (readable more easilty) | 460 | * EXTRACTOR_UnzipDateTimeInfo (readable more easilty) |
@@ -472,17 +465,16 @@ unzlocal_DosDateToTmuDate (uLong ulDosDate, | |||
472 | { | 465 | { |
473 | uLong uDate; | 466 | uLong uDate; |
474 | 467 | ||
475 | uDate = (uLong)(ulDosDate>>16); | 468 | uDate = (uLong) (ulDosDate >> 16); |
476 | ptm->tm_mday = (uInt)(uDate&0x1f); | 469 | ptm->tm_mday = (uInt) (uDate & 0x1f); |
477 | ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1); | 470 | ptm->tm_mon = (uInt) ((((uDate) & 0x1E0) / 0x20) - 1); |
478 | ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980); | 471 | ptm->tm_year = (uInt) (((uDate & 0x0FE00) / 0x0200) + 1980); |
479 | ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); | 472 | ptm->tm_hour = (uInt) ((ulDosDate & 0xF800) / 0x800); |
480 | ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20); | 473 | ptm->tm_min = (uInt) ((ulDosDate & 0x7E0) / 0x20); |
481 | ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)); | 474 | ptm->tm_sec = (uInt) (2 * (ulDosDate & 0x1f)); |
482 | } | 475 | } |
483 | 476 | ||
484 | 477 | ||
485 | |||
486 | static int | 478 | static int |
487 | unzlocal_GetCurrentFileInfoInternal (struct EXTRACTOR_UnzipFile *s, | 479 | unzlocal_GetCurrentFileInfoInternal (struct EXTRACTOR_UnzipFile *s, |
488 | struct EXTRACTOR_UnzipFileInfo *pfile_info, | 480 | struct EXTRACTOR_UnzipFileInfo *pfile_info, |
@@ -496,19 +488,19 @@ unzlocal_GetCurrentFileInfoInternal (struct EXTRACTOR_UnzipFile *s, | |||
496 | { | 488 | { |
497 | struct EXTRACTOR_UnzipFileInfo file_info; | 489 | struct EXTRACTOR_UnzipFileInfo file_info; |
498 | struct UnzipFileInfoInternal file_info_internal; | 490 | struct UnzipFileInfoInternal file_info_internal; |
499 | int err=EXTRACTOR_UNZIP_OK; | 491 | int err = EXTRACTOR_UNZIP_OK; |
500 | uLong uMagic; | 492 | uLong uMagic; |
501 | long lSeek = 0; | 493 | long lSeek = 0; |
502 | 494 | ||
503 | if (NULL == s) | 495 | if (s == NULL) |
504 | return EXTRACTOR_UNZIP_PARAMERROR; | 496 | return EXTRACTOR_UNZIP_PARAMERROR; |
505 | if (0 != ZSEEK (s->z_filefunc, | 497 | if (0 != ZSEEK (s->z_filefunc, |
506 | s->pos_in_central_dir + s->byte_before_the_zipfile, | 498 | s->pos_in_central_dir + s->byte_before_the_zipfile, |
507 | ZLIB_FILEFUNC_SEEK_SET)) | 499 | SEEK_SET)) |
508 | err = EXTRACTOR_UNZIP_ERRNO; | 500 | err = EXTRACTOR_UNZIP_ERRNO; |
509 | 501 | ||
510 | /* we check the magic */ | 502 | /* we check the magic */ |
511 | if (err==EXTRACTOR_UNZIP_OK) | 503 | if (EXTRACTOR_UNZIP_OK == err) |
512 | { | 504 | { |
513 | if (unzlocal_getLong(&s->z_filefunc, &uMagic) != EXTRACTOR_UNZIP_OK) | 505 | if (unzlocal_getLong(&s->z_filefunc, &uMagic) != EXTRACTOR_UNZIP_OK) |
514 | err=EXTRACTOR_UNZIP_ERRNO; | 506 | err=EXTRACTOR_UNZIP_ERRNO; |
@@ -559,42 +551,43 @@ unzlocal_GetCurrentFileInfoInternal (struct EXTRACTOR_UnzipFile *s, | |||
559 | if (unzlocal_getLong(&s->z_filefunc, &file_info.external_fa) != EXTRACTOR_UNZIP_OK) | 551 | if (unzlocal_getLong(&s->z_filefunc, &file_info.external_fa) != EXTRACTOR_UNZIP_OK) |
560 | err=EXTRACTOR_UNZIP_ERRNO; | 552 | err=EXTRACTOR_UNZIP_ERRNO; |
561 | 553 | ||
562 | if (unzlocal_getLong(&s->z_filefunc, &file_info_internal.offset_curfile) != EXTRACTOR_UNZIP_OK) | 554 | if (unzlocal_getLong (&s->z_filefunc, |
563 | err=EXTRACTOR_UNZIP_ERRNO; | 555 | &file_info_internal.offset_curfile) != EXTRACTOR_UNZIP_OK) |
556 | err = EXTRACTOR_UNZIP_ERRNO; | ||
564 | 557 | ||
565 | lSeek+=file_info.size_filename; | 558 | lSeek += file_info.size_filename; |
566 | if ((err==EXTRACTOR_UNZIP_OK) && (szFileName!=NULL)) | 559 | if ((err==EXTRACTOR_UNZIP_OK) && (szFileName!=NULL)) |
567 | { | 560 | { |
568 | uLong uSizeRead; | 561 | uLong uSizeRead; |
569 | if (file_info.size_filename<fileNameBufferSize) | 562 | if (file_info.size_filename < fileNameBufferSize) |
570 | { | 563 | { |
571 | *(szFileName+file_info.size_filename)='\0'; | 564 | *(szFileName+file_info.size_filename) = '\0'; |
572 | uSizeRead = file_info.size_filename; | 565 | uSizeRead = file_info.size_filename; |
573 | } | 566 | } |
574 | else | 567 | else |
575 | uSizeRead = fileNameBufferSize; | 568 | uSizeRead = fileNameBufferSize; |
576 | 569 | ||
577 | if ((file_info.size_filename>0) && (fileNameBufferSize>0)) | 570 | if ((file_info.size_filename > 0) && (fileNameBufferSize > 0)) |
578 | if (ZREAD(s->z_filefunc, szFileName, uSizeRead)!=uSizeRead) | 571 | if (ZREAD(s->z_filefunc, szFileName, uSizeRead) != uSizeRead) |
579 | err=EXTRACTOR_UNZIP_ERRNO; | 572 | err = EXTRACTOR_UNZIP_ERRNO; |
580 | lSeek -= uSizeRead; | 573 | lSeek -= uSizeRead; |
581 | } | 574 | } |
582 | 575 | ||
583 | 576 | ||
584 | if ((err==EXTRACTOR_UNZIP_OK) && (extraField!=NULL)) | 577 | if ((err==EXTRACTOR_UNZIP_OK) && (extraField!=NULL)) |
585 | { | 578 | { |
586 | uLong uSizeRead ; | 579 | uLong uSizeRead; |
587 | if (file_info.size_file_extra<extraFieldBufferSize) | 580 | if (file_info.size_file_extra<extraFieldBufferSize) |
588 | uSizeRead = file_info.size_file_extra; | 581 | uSizeRead = file_info.size_file_extra; |
589 | else | 582 | else |
590 | uSizeRead = extraFieldBufferSize; | 583 | uSizeRead = extraFieldBufferSize; |
591 | 584 | ||
592 | if (lSeek!=0) | 585 | if (0 != lSeek) |
593 | { | 586 | { |
594 | if (ZSEEK(s->z_filefunc, lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) | 587 | if (0 == ZSEEK (s->z_filefunc, lSeek, SEEK_CUR)) |
595 | lSeek=0; | 588 | lSeek = 0; |
596 | else | 589 | else |
597 | err=EXTRACTOR_UNZIP_ERRNO; | 590 | err = EXTRACTOR_UNZIP_ERRNO; |
598 | } | 591 | } |
599 | if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) | 592 | if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) |
600 | if (ZREAD(s->z_filefunc, extraField,uSizeRead)!=uSizeRead) | 593 | if (ZREAD(s->z_filefunc, extraField,uSizeRead)!=uSizeRead) |
@@ -618,7 +611,7 @@ unzlocal_GetCurrentFileInfoInternal (struct EXTRACTOR_UnzipFile *s, | |||
618 | 611 | ||
619 | if (lSeek!=0) | 612 | if (lSeek!=0) |
620 | { | 613 | { |
621 | if (ZSEEK(s->z_filefunc, lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) | 614 | if (ZSEEK(s->z_filefunc, lSeek, SEEK_CUR)==0) |
622 | lSeek=0; | 615 | lSeek=0; |
623 | else | 616 | else |
624 | err=EXTRACTOR_UNZIP_ERRNO; | 617 | err=EXTRACTOR_UNZIP_ERRNO; |
@@ -696,7 +689,7 @@ EXTRACTOR_common_unzip_open2 (struct EXTRACTOR_UnzipFileFuncDefs *pzlib_filefunc | |||
696 | err=EXTRACTOR_UNZIP_ERRNO; | 689 | err=EXTRACTOR_UNZIP_ERRNO; |
697 | 690 | ||
698 | if (ZSEEK(us.z_filefunc, | 691 | if (ZSEEK(us.z_filefunc, |
699 | central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) | 692 | central_pos, SEEK_SET)!=0) |
700 | err=EXTRACTOR_UNZIP_ERRNO; | 693 | err=EXTRACTOR_UNZIP_ERRNO; |
701 | 694 | ||
702 | /* the signature, already checked */ | 695 | /* the signature, already checked */ |
@@ -907,59 +900,55 @@ EXTRACTOR_common_unzip_go_find_local_file (struct EXTRACTOR_UnzipFile *file, | |||
907 | const char *szFileName, | 900 | const char *szFileName, |
908 | int iCaseSensitivity) | 901 | int iCaseSensitivity) |
909 | { | 902 | { |
910 | struct EXTRACTOR_UnzipFile* s; | 903 | int err; |
911 | int err; | 904 | /* We remember the 'current' position in the file so that we can jump |
912 | 905 | * back there if we fail. | |
913 | /* We remember the 'current' position in the file so that we can jump | 906 | */ |
914 | * back there if we fail. | 907 | struct EXTRACTOR_UnzipFileInfo cur_file_infoSaved; |
915 | */ | 908 | struct UnzipFileInfoInternal cur_file_info_internalSaved; |
916 | struct EXTRACTOR_UnzipFileInfo cur_file_infoSaved; | 909 | uLong num_fileSaved; |
917 | struct UnzipFileInfoInternal cur_file_info_internalSaved; | 910 | uLong pos_in_central_dirSaved; |
918 | uLong num_fileSaved; | 911 | |
919 | uLong pos_in_central_dirSaved; | 912 | if (NULL == file) |
920 | 913 | return EXTRACTOR_UNZIP_PARAMERROR; | |
921 | 914 | if (strlen (szFileName) >= UNZ_MAXFILENAMEINZIP) | |
922 | if (file==NULL) | 915 | return EXTRACTOR_UNZIP_PARAMERROR; |
923 | return EXTRACTOR_UNZIP_PARAMERROR; | 916 | if (! file->current_file_ok) |
924 | 917 | return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE; | |
925 | if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) | 918 | |
926 | return EXTRACTOR_UNZIP_PARAMERROR; | 919 | /* Save the current state */ |
927 | 920 | num_fileSaved = file->num_file; | |
928 | s=(struct EXTRACTOR_UnzipFile*)file; | 921 | pos_in_central_dirSaved = file->pos_in_central_dir; |
929 | if (!s->current_file_ok) | 922 | cur_file_infoSaved = file->cur_file_info; |
930 | return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE; | 923 | cur_file_info_internalSaved = file->cur_file_info_internal; |
931 | 924 | err = EXTRACTOR_common_unzip_go_to_first_file (file); | |
932 | /* Save the current state */ | 925 | |
933 | num_fileSaved = s->num_file; | 926 | while (EXTRACTOR_UNZIP_OK == err) |
934 | pos_in_central_dirSaved = s->pos_in_central_dir; | ||
935 | cur_file_infoSaved = s->cur_file_info; | ||
936 | cur_file_info_internalSaved = s->cur_file_info_internal; | ||
937 | |||
938 | err = EXTRACTOR_common_unzip_go_to_first_file(file); | ||
939 | |||
940 | while (err == EXTRACTOR_UNZIP_OK) | ||
941 | { | 927 | { |
942 | char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; | 928 | char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; |
943 | err = EXTRACTOR_common_unzip_get_current_file_info(file,NULL, | 929 | |
944 | szCurrentFileName,sizeof(szCurrentFileName)-1, | 930 | err = EXTRACTOR_common_unzip_get_current_file_info (file, NULL, |
945 | NULL,0,NULL,0); | 931 | szCurrentFileName, sizeof (szCurrentFileName) - 1, |
946 | if (err == EXTRACTOR_UNZIP_OK) | 932 | NULL, 0, NULL, 0); |
933 | if (EXTRACTOR_UNZIP_OK == err) | ||
947 | { | 934 | { |
948 | if (EXTRACTOR_common_unzip_string_file_name_compare(szCurrentFileName, | 935 | if (0 == |
949 | szFileName,iCaseSensitivity)==0) | 936 | EXTRACTOR_common_unzip_string_file_name_compare (szCurrentFileName, |
950 | return EXTRACTOR_UNZIP_OK; | 937 | szFileName, |
951 | err = EXTRACTOR_common_unzip_go_to_next_file(file); | 938 | iCaseSensitivity)) |
939 | return EXTRACTOR_UNZIP_OK; | ||
940 | err = EXTRACTOR_common_unzip_go_to_next_file (file); | ||
952 | } | 941 | } |
953 | } | 942 | } |
954 | 943 | ||
955 | /* We failed, so restore the state of the 'current file' to where we | 944 | /* We failed, so restore the state of the 'current file' to where we |
956 | * were. | 945 | * were. |
957 | */ | 946 | */ |
958 | s->num_file = num_fileSaved ; | 947 | file->num_file = num_fileSaved; |
959 | s->pos_in_central_dir = pos_in_central_dirSaved ; | 948 | file->pos_in_central_dir = pos_in_central_dirSaved; |
960 | s->cur_file_info = cur_file_infoSaved; | 949 | file->cur_file_info = cur_file_infoSaved; |
961 | s->cur_file_info_internal = cur_file_info_internalSaved; | 950 | file->cur_file_info_internal = cur_file_info_internalSaved; |
962 | return err; | 951 | return err; |
963 | } | 952 | } |
964 | 953 | ||
965 | 954 | ||
@@ -978,83 +967,75 @@ EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file, | |||
978 | void *buf, | 967 | void *buf, |
979 | size_t len) | 968 | size_t len) |
980 | { | 969 | { |
981 | int err=EXTRACTOR_UNZIP_OK; | 970 | int err = EXTRACTOR_UNZIP_OK; |
982 | uInt iRead = 0; | 971 | uInt iRead = 0; |
983 | struct EXTRACTOR_UnzipFile* s; | 972 | struct FileInZipReadInfo* pfile_in_zip_read_info; |
984 | struct FileInZipReadInfo* pfile_in_zip_read_info; | ||
985 | if (file==NULL) | ||
986 | return EXTRACTOR_UNZIP_PARAMERROR; | ||
987 | s=(struct EXTRACTOR_UnzipFile*)file; | ||
988 | pfile_in_zip_read_info=s->pfile_in_zip_read; | ||
989 | |||
990 | if (pfile_in_zip_read_info==NULL) | ||
991 | return EXTRACTOR_UNZIP_PARAMERROR; | ||
992 | |||
993 | |||
994 | if ((pfile_in_zip_read_info->read_buffer == NULL)) | ||
995 | return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE; | ||
996 | if (len==0) | ||
997 | return 0; | ||
998 | |||
999 | pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; | ||
1000 | |||
1001 | pfile_in_zip_read_info->stream.avail_out = (uInt)len; | ||
1002 | 973 | ||
1003 | if (len>pfile_in_zip_read_info->rest_read_uncompressed) | 974 | if (NULL == file) |
1004 | pfile_in_zip_read_info->stream.avail_out = | 975 | return EXTRACTOR_UNZIP_PARAMERROR; |
1005 | (uInt)pfile_in_zip_read_info->rest_read_uncompressed; | 976 | if (NULL == (pfile_in_zip_read_info = file->pfile_in_zip_read)) |
977 | return EXTRACTOR_UNZIP_PARAMERROR; | ||
978 | if (NULL == pfile_in_zip_read_info->read_buffer) | ||
979 | return EXTRACTOR_UNZIP_END_OF_LIST_OF_FILE; | ||
980 | if (0 == len) | ||
981 | return 0; | ||
1006 | 982 | ||
1007 | while (pfile_in_zip_read_info->stream.avail_out>0) | 983 | pfile_in_zip_read_info->stream.next_out = (Bytef*) buf; |
984 | pfile_in_zip_read_info->stream.avail_out = (uInt) len; | ||
985 | if (len > pfile_in_zip_read_info->rest_read_uncompressed) | ||
986 | pfile_in_zip_read_info->stream.avail_out = | ||
987 | (uInt) pfile_in_zip_read_info->rest_read_uncompressed; | ||
988 | |||
989 | while (pfile_in_zip_read_info->stream.avail_out > 0) | ||
1008 | { | 990 | { |
1009 | if ((pfile_in_zip_read_info->stream.avail_in==0) && | 991 | if ( (0 == pfile_in_zip_read_info->stream.avail_in) && |
1010 | (pfile_in_zip_read_info->rest_read_compressed>0)) | 992 | (pfile_in_zip_read_info->rest_read_compressed>0) ) |
1011 | { | 993 | { |
1012 | uInt uReadThis = UNZ_BUFSIZE; | 994 | uInt uReadThis = UNZ_BUFSIZE; |
1013 | if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) | 995 | if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) |
1014 | uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; | 996 | uReadThis = (uInt) pfile_in_zip_read_info->rest_read_compressed; |
1015 | if (uReadThis == 0) | 997 | if (0 == uReadThis) |
1016 | return EXTRACTOR_UNZIP_EOF; | 998 | return EXTRACTOR_UNZIP_EOF; |
1017 | if (ZSEEK(pfile_in_zip_read_info->z_filefunc, | 999 | if (0 != |
1018 | pfile_in_zip_read_info->pos_in_zipfile + | 1000 | ZSEEK (pfile_in_zip_read_info->z_filefunc, |
1019 | pfile_in_zip_read_info->byte_before_the_zipfile, | 1001 | pfile_in_zip_read_info->pos_in_zipfile + |
1020 | ZLIB_FILEFUNC_SEEK_SET)!=0) | 1002 | pfile_in_zip_read_info->byte_before_the_zipfile, |
1021 | return EXTRACTOR_UNZIP_ERRNO; | 1003 | SEEK_SET)) |
1022 | if (ZREAD(pfile_in_zip_read_info->z_filefunc, | 1004 | return EXTRACTOR_UNZIP_ERRNO; |
1023 | pfile_in_zip_read_info->read_buffer, | 1005 | if (ZREAD (pfile_in_zip_read_info->z_filefunc, |
1024 | uReadThis)!=uReadThis) | 1006 | pfile_in_zip_read_info->read_buffer, |
1025 | return EXTRACTOR_UNZIP_ERRNO; | 1007 | uReadThis) != uReadThis) |
1026 | 1008 | return EXTRACTOR_UNZIP_ERRNO; | |
1027 | 1009 | ||
1028 | pfile_in_zip_read_info->pos_in_zipfile += uReadThis; | 1010 | pfile_in_zip_read_info->pos_in_zipfile += uReadThis; |
1029 | 1011 | pfile_in_zip_read_info->rest_read_compressed-=uReadThis; | |
1030 | pfile_in_zip_read_info->rest_read_compressed-=uReadThis; | 1012 | pfile_in_zip_read_info->stream.next_in = |
1031 | 1013 | (Bytef*)pfile_in_zip_read_info->read_buffer; | |
1032 | pfile_in_zip_read_info->stream.next_in = | 1014 | pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; |
1033 | (Bytef*)pfile_in_zip_read_info->read_buffer; | ||
1034 | pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; | ||
1035 | } | 1015 | } |
1036 | 1016 | ||
1037 | if (pfile_in_zip_read_info->compression_method==0) | 1017 | if (pfile_in_zip_read_info->compression_method==0) |
1038 | { | 1018 | { |
1039 | uInt uDoCopy,i ; | 1019 | uInt uDoCopy; |
1040 | 1020 | uInt i; | |
1021 | |||
1041 | if ((pfile_in_zip_read_info->stream.avail_in == 0) && | 1022 | if ((pfile_in_zip_read_info->stream.avail_in == 0) && |
1042 | (pfile_in_zip_read_info->rest_read_compressed == 0)) | 1023 | (pfile_in_zip_read_info->rest_read_compressed == 0)) |
1043 | return (iRead==0) ? EXTRACTOR_UNZIP_EOF : iRead; | 1024 | return (iRead==0) ? EXTRACTOR_UNZIP_EOF : iRead; |
1044 | 1025 | ||
1045 | if (pfile_in_zip_read_info->stream.avail_out < | 1026 | if (pfile_in_zip_read_info->stream.avail_out < |
1046 | pfile_in_zip_read_info->stream.avail_in) | 1027 | pfile_in_zip_read_info->stream.avail_in) |
1047 | uDoCopy = pfile_in_zip_read_info->stream.avail_out ; | 1028 | uDoCopy = pfile_in_zip_read_info->stream.avail_out ; |
1048 | else | 1029 | else |
1049 | uDoCopy = pfile_in_zip_read_info->stream.avail_in ; | 1030 | uDoCopy = pfile_in_zip_read_info->stream.avail_in ; |
1050 | 1031 | ||
1051 | for (i=0;i<uDoCopy;i++) | 1032 | for (i=0;i<uDoCopy;i++) |
1052 | *(pfile_in_zip_read_info->stream.next_out+i) = | 1033 | *(pfile_in_zip_read_info->stream.next_out+i) = |
1053 | *(pfile_in_zip_read_info->stream.next_in+i); | 1034 | *(pfile_in_zip_read_info->stream.next_in+i); |
1054 | 1035 | ||
1055 | pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, | 1036 | pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, |
1056 | pfile_in_zip_read_info->stream.next_out, | 1037 | pfile_in_zip_read_info->stream.next_out, |
1057 | uDoCopy); | 1038 | uDoCopy); |
1058 | pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; | 1039 | pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; |
1059 | pfile_in_zip_read_info->stream.avail_in -= uDoCopy; | 1040 | pfile_in_zip_read_info->stream.avail_in -= uDoCopy; |
1060 | pfile_in_zip_read_info->stream.avail_out -= uDoCopy; | 1041 | pfile_in_zip_read_info->stream.avail_out -= uDoCopy; |
@@ -1062,130 +1043,151 @@ EXTRACTOR_common_unzip_read_current_file (struct EXTRACTOR_UnzipFile *file, | |||
1062 | pfile_in_zip_read_info->stream.next_in += uDoCopy; | 1043 | pfile_in_zip_read_info->stream.next_in += uDoCopy; |
1063 | pfile_in_zip_read_info->stream.total_out += uDoCopy; | 1044 | pfile_in_zip_read_info->stream.total_out += uDoCopy; |
1064 | iRead += uDoCopy; | 1045 | iRead += uDoCopy; |
1065 | } | 1046 | } |
1066 | else | 1047 | else |
1067 | { | 1048 | { |
1068 | uLong uTotalOutBefore,uTotalOutAfter; | 1049 | uLong uTotalOutBefore; |
1050 | uLong uTotalOutAfter; | ||
1069 | const Bytef *bufBefore; | 1051 | const Bytef *bufBefore; |
1070 | uLong uOutThis; | 1052 | uLong uOutThis; |
1071 | int flush=Z_SYNC_FLUSH; | 1053 | int flush = Z_SYNC_FLUSH; |
1072 | 1054 | ||
1073 | uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; | 1055 | uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; |
1074 | bufBefore = pfile_in_zip_read_info->stream.next_out; | 1056 | bufBefore = pfile_in_zip_read_info->stream.next_out; |
1075 | 1057 | ||
1076 | /* | 1058 | /* |
1077 | if ((pfile_in_zip_read_info->rest_read_uncompressed == | 1059 | if ((pfile_in_zip_read_info->rest_read_uncompressed == |
1078 | pfile_in_zip_read_info->stream.avail_out) && | 1060 | pfile_in_zip_read_info->stream.avail_out) && |
1079 | (pfile_in_zip_read_info->rest_read_compressed == 0)) | 1061 | (pfile_in_zip_read_info->rest_read_compressed == 0)) |
1080 | flush = Z_FINISH; | 1062 | flush = Z_FINISH; |
1081 | */ | 1063 | */ |
1082 | err=inflate(&pfile_in_zip_read_info->stream,flush); | 1064 | err = inflate(&pfile_in_zip_read_info->stream,flush); |
1083 | 1065 | ||
1084 | uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; | 1066 | uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; |
1085 | uOutThis = uTotalOutAfter-uTotalOutBefore; | 1067 | uOutThis = uTotalOutAfter-uTotalOutBefore; |
1086 | 1068 | ||
1087 | pfile_in_zip_read_info->crc32 = | 1069 | pfile_in_zip_read_info->crc32 = |
1088 | crc32(pfile_in_zip_read_info->crc32,bufBefore, | 1070 | crc32(pfile_in_zip_read_info->crc32,bufBefore, |
1089 | (uInt)(uOutThis)); | 1071 | (uInt)(uOutThis)); |
1090 | 1072 | ||
1091 | pfile_in_zip_read_info->rest_read_uncompressed -= | 1073 | pfile_in_zip_read_info->rest_read_uncompressed -= |
1092 | uOutThis; | 1074 | uOutThis; |
1093 | 1075 | ||
1094 | iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); | 1076 | iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); |
1095 | 1077 | ||
1096 | if (err==Z_STREAM_END) | 1078 | if (Z_STREAM_END == err) |
1097 | return (iRead==0) ? EXTRACTOR_UNZIP_EOF : iRead; | 1079 | return (0 == iRead) ? EXTRACTOR_UNZIP_EOF : iRead; |
1098 | if (err!=Z_OK) | 1080 | if (Z_OK != err) |
1099 | break; | 1081 | break; |
1100 | } | 1082 | } |
1101 | } | 1083 | } |
1102 | 1084 | ||
1103 | if (err==Z_OK) | 1085 | if (Z_OK == err) |
1104 | return iRead; | 1086 | return iRead; |
1105 | return err; | 1087 | return err; |
1106 | } | 1088 | } |
1107 | 1089 | ||
1108 | /* | 1090 | |
1109 | Read the local header of the current zipfile | 1091 | /** |
1110 | Check the coherency of the local header and info in the end of central | 1092 | * Read the local header of the current zipfile |
1111 | directory about this file | 1093 | * Check the coherency of the local header and info in the end of central |
1112 | store in *piSizeVar the size of extra info in local header | 1094 | * directory about this file |
1113 | (filename and size of extra field data) | 1095 | * store in *piSizeVar the size of extra info in local header |
1114 | */ | 1096 | * (filename and size of extra field data) |
1097 | */ | ||
1115 | static int | 1098 | static int |
1116 | unzlocal_CheckCurrentFileCoherencyHeader (struct EXTRACTOR_UnzipFile* s, | 1099 | unzlocal_CheckCurrentFileCoherencyHeader (struct EXTRACTOR_UnzipFile *file, |
1117 | uInt* piSizeVar, | 1100 | uInt *piSizeVar, |
1118 | uLong *poffset_local_extrafield, | 1101 | uLong *poffset_local_extrafield, |
1119 | uInt *psize_local_extrafield) | 1102 | uInt *psize_local_extrafield) |
1120 | { | 1103 | { |
1121 | uLong uMagic,uData,uFlags; | 1104 | uLong uMagic; |
1122 | uLong size_filename; | 1105 | uLong uData; |
1123 | uLong size_extra_field; | 1106 | uLong uFlags; |
1124 | int err = EXTRACTOR_UNZIP_OK; | 1107 | uLong size_filename; |
1125 | 1108 | uLong size_extra_field; | |
1126 | *piSizeVar = 0; | 1109 | int err = EXTRACTOR_UNZIP_OK; |
1127 | *poffset_local_extrafield = 0; | ||
1128 | *psize_local_extrafield = 0; | ||
1129 | |||
1130 | if (ZSEEK(s->z_filefunc, s->cur_file_info_internal.offset_curfile + | ||
1131 | s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
1132 | return EXTRACTOR_UNZIP_ERRNO; | ||
1133 | if (unzlocal_getLong(&s->z_filefunc,&uMagic) != EXTRACTOR_UNZIP_OK) | ||
1134 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1135 | else if (uMagic!=0x04034b50) | ||
1136 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1137 | if (unzlocal_getShort(&s->z_filefunc,&uData) != EXTRACTOR_UNZIP_OK) | ||
1138 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1139 | if (unzlocal_getShort(&s->z_filefunc,&uFlags) != EXTRACTOR_UNZIP_OK) | ||
1140 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1141 | |||
1142 | if (unzlocal_getShort(&s->z_filefunc,&uData) != EXTRACTOR_UNZIP_OK) | ||
1143 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1144 | else if ((err==EXTRACTOR_UNZIP_OK) && (uData!=s->cur_file_info.compression_method)) | ||
1145 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1146 | |||
1147 | if ((err==EXTRACTOR_UNZIP_OK) && (s->cur_file_info.compression_method!=0) && | ||
1148 | (s->cur_file_info.compression_method!=Z_DEFLATED)) | ||
1149 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1150 | |||
1151 | if (unzlocal_getLong(&s->z_filefunc,&uData) != EXTRACTOR_UNZIP_OK) /* date/time */ | ||
1152 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1153 | |||
1154 | if (unzlocal_getLong(&s->z_filefunc,&uData) != EXTRACTOR_UNZIP_OK) /* crc */ | ||
1155 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1156 | else if ((err==EXTRACTOR_UNZIP_OK) && (uData!=s->cur_file_info.crc) && | ||
1157 | ((uFlags & 8)==0)) | ||
1158 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1159 | |||
1160 | if (unzlocal_getLong(&s->z_filefunc,&uData) != EXTRACTOR_UNZIP_OK) /* size compr */ | ||
1161 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1162 | else if ((err==EXTRACTOR_UNZIP_OK) && (uData!=s->cur_file_info.compressed_size) && | ||
1163 | ((uFlags & 8)==0)) | ||
1164 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1165 | |||
1166 | if (unzlocal_getLong(&s->z_filefunc,&uData) != EXTRACTOR_UNZIP_OK) /* size uncompr */ | ||
1167 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1168 | else if ((err==EXTRACTOR_UNZIP_OK) && (uData!=s->cur_file_info.uncompressed_size) && | ||
1169 | ((uFlags & 8)==0)) | ||
1170 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1171 | |||
1172 | |||
1173 | if (unzlocal_getShort(&s->z_filefunc,&size_filename) != EXTRACTOR_UNZIP_OK) | ||
1174 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1175 | else if ((err==EXTRACTOR_UNZIP_OK) && (size_filename!=s->cur_file_info.size_filename)) | ||
1176 | err=EXTRACTOR_UNZIP_BADZIPFILE; | ||
1177 | |||
1178 | *piSizeVar += (uInt)size_filename; | ||
1179 | |||
1180 | if (unzlocal_getShort(&s->z_filefunc,&size_extra_field) != EXTRACTOR_UNZIP_OK) | ||
1181 | err=EXTRACTOR_UNZIP_ERRNO; | ||
1182 | *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + | ||
1183 | SIZEZIPLOCALHEADER + size_filename; | ||
1184 | *psize_local_extrafield = (uInt)size_extra_field; | ||
1185 | |||
1186 | *piSizeVar += (uInt)size_extra_field; | ||
1187 | 1110 | ||
1188 | return err; | 1111 | *piSizeVar = 0; |
1112 | *poffset_local_extrafield = 0; | ||
1113 | *psize_local_extrafield = 0; | ||
1114 | |||
1115 | if (0 != ZSEEK (file->z_filefunc, | ||
1116 | file->cur_file_info_internal.offset_curfile + | ||
1117 | file->byte_before_the_zipfile, | ||
1118 | SEEK_SET)) | ||
1119 | return EXTRACTOR_UNZIP_ERRNO; | ||
1120 | if (EXTRACTOR_UNZIP_OK != | ||
1121 | unzlocal_getLong (&file->z_filefunc, | ||
1122 | &uMagic)) | ||
1123 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1124 | else if (0x04034b50 != uMagic) | ||
1125 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1126 | if ( (EXTRACTOR_UNZIP_OK != | ||
1127 | unzlocal_getShort (&file->z_filefunc, &uData)) || | ||
1128 | (EXTRACTOR_UNZIP_OK != | ||
1129 | unzlocal_getShort (&file->z_filefunc, &uFlags)) ) | ||
1130 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1131 | |||
1132 | if (EXTRACTOR_UNZIP_OK != unzlocal_getShort (&file->z_filefunc, &uData)) | ||
1133 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1134 | else if ((EXTRACTOR_UNZIP_OK == err) && | ||
1135 | (uData != file->cur_file_info.compression_method)) | ||
1136 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1137 | |||
1138 | if ( (EXTRACTOR_UNZIP_OK == err) && | ||
1139 | (0 != file->cur_file_info.compression_method) && | ||
1140 | (Z_DEFLATED != file->cur_file_info.compression_method) ) | ||
1141 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1142 | |||
1143 | if (EXTRACTOR_UNZIP_OK != | ||
1144 | unzlocal_getLong (&file->z_filefunc, &uData)) /* date/time */ | ||
1145 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1146 | |||
1147 | if (EXTRACTOR_UNZIP_OK != | ||
1148 | unzlocal_getLong (&file->z_filefunc, &uData)) /* crc */ | ||
1149 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1150 | else if ( (EXTRACTOR_UNZIP_OK == err) && | ||
1151 | (uData != file->cur_file_info.crc) && | ||
1152 | (0 == (uFlags & 8)) ) | ||
1153 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1154 | |||
1155 | if (EXTRACTOR_UNZIP_OK != | ||
1156 | unzlocal_getLong(&file->z_filefunc, &uData)) /* size compr */ | ||
1157 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1158 | else if ( (EXTRACTOR_UNZIP_OK == err) && | ||
1159 | (uData != file->cur_file_info.compressed_size) && | ||
1160 | (0 == (uFlags & 8)) ) | ||
1161 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1162 | |||
1163 | if (EXTRACTOR_UNZIP_OK != | ||
1164 | unzlocal_getLong (&file->z_filefunc, | ||
1165 | &uData)) /* size uncompr */ | ||
1166 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1167 | else if ( (EXTRACTOR_UNZIP_OK == err) && | ||
1168 | (uData != file->cur_file_info.uncompressed_size) && | ||
1169 | (0 == (uFlags & 8))) | ||
1170 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1171 | |||
1172 | if (EXTRACTOR_UNZIP_OK != | ||
1173 | unzlocal_getShort (&file->z_filefunc, &size_filename)) | ||
1174 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1175 | else if ( (EXTRACTOR_UNZIP_OK == err) && | ||
1176 | (size_filename != file->cur_file_info.size_filename) ) | ||
1177 | err = EXTRACTOR_UNZIP_BADZIPFILE; | ||
1178 | |||
1179 | *piSizeVar += (uInt) size_filename; | ||
1180 | |||
1181 | if (EXTRACTOR_UNZIP_OK != | ||
1182 | unzlocal_getShort (&file->z_filefunc, | ||
1183 | &size_extra_field)) | ||
1184 | err = EXTRACTOR_UNZIP_ERRNO; | ||
1185 | *poffset_local_extrafield = file->cur_file_info_internal.offset_curfile + | ||
1186 | SIZEZIPLOCALHEADER + size_filename; | ||
1187 | *psize_local_extrafield = (uInt) size_extra_field; | ||
1188 | *piSizeVar += (uInt)size_extra_field; | ||
1189 | |||
1190 | return err; | ||
1189 | } | 1191 | } |
1190 | 1192 | ||
1191 | 1193 | ||
@@ -1198,129 +1200,119 @@ unzlocal_CheckCurrentFileCoherencyHeader (struct EXTRACTOR_UnzipFile* s, | |||
1198 | int | 1200 | int |
1199 | EXTRACTOR_common_unzip_open_current_file (struct EXTRACTOR_UnzipFile *file) | 1201 | EXTRACTOR_common_unzip_open_current_file (struct EXTRACTOR_UnzipFile *file) |
1200 | { | 1202 | { |
1201 | int err=EXTRACTOR_UNZIP_OK; | 1203 | int err = EXTRACTOR_UNZIP_OK; |
1202 | uInt iSizeVar; | 1204 | uInt iSizeVar; |
1203 | struct EXTRACTOR_UnzipFile* s; | 1205 | struct FileInZipReadInfo *pfile_in_zip_read_info; |
1204 | struct FileInZipReadInfo* pfile_in_zip_read_info; | 1206 | uLong offset_local_extrafield; /* offset of the local extra field */ |
1205 | uLong offset_local_extrafield; /* offset of the local extra field */ | 1207 | uInt size_local_extrafield; /* size of the local extra field */ |
1206 | uInt size_local_extrafield; /* size of the local extra field */ | 1208 | |
1207 | 1209 | if (NULL == file) | |
1208 | if (file==NULL) | 1210 | return EXTRACTOR_UNZIP_PARAMERROR; |
1209 | return EXTRACTOR_UNZIP_PARAMERROR; | 1211 | if (! file->current_file_ok) |
1210 | s=(struct EXTRACTOR_UnzipFile*)file; | 1212 | return EXTRACTOR_UNZIP_PARAMERROR; |
1211 | if (!s->current_file_ok) | 1213 | if (NULL != file->pfile_in_zip_read) |
1212 | return EXTRACTOR_UNZIP_PARAMERROR; | 1214 | EXTRACTOR_common_unzip_close_current_file (file); |
1213 | 1215 | if (EXTRACTOR_UNZIP_OK != | |
1214 | if (s->pfile_in_zip_read != NULL) | 1216 | unzlocal_CheckCurrentFileCoherencyHeader (file, |
1215 | EXTRACTOR_common_unzip_close_current_file(file); | 1217 | &iSizeVar, |
1216 | if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, | 1218 | &offset_local_extrafield, |
1217 | &offset_local_extrafield,&size_local_extrafield)!=EXTRACTOR_UNZIP_OK) | 1219 | &size_local_extrafield)) |
1218 | return EXTRACTOR_UNZIP_BADZIPFILE; | 1220 | return EXTRACTOR_UNZIP_BADZIPFILE; |
1219 | 1221 | if (NULL == (pfile_in_zip_read_info = malloc(sizeof(struct FileInZipReadInfo)))) | |
1220 | pfile_in_zip_read_info = (struct FileInZipReadInfo*) | 1222 | return EXTRACTOR_UNZIP_INTERNALERROR; |
1221 | malloc(sizeof(struct FileInZipReadInfo)); | 1223 | if (NULL == (pfile_in_zip_read_info->read_buffer = malloc(UNZ_BUFSIZE))) |
1222 | if (pfile_in_zip_read_info==NULL) | 1224 | { |
1223 | return EXTRACTOR_UNZIP_INTERNALERROR; | 1225 | free (pfile_in_zip_read_info); |
1224 | 1226 | return EXTRACTOR_UNZIP_INTERNALERROR; | |
1225 | pfile_in_zip_read_info->read_buffer=(char*)malloc(UNZ_BUFSIZE); | 1227 | } |
1226 | pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; | 1228 | pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; |
1227 | pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; | 1229 | pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; |
1228 | pfile_in_zip_read_info->pos_local_extrafield=0; | 1230 | pfile_in_zip_read_info->pos_local_extrafield = 0; |
1229 | 1231 | pfile_in_zip_read_info->stream_initialised = 0; | |
1230 | if (pfile_in_zip_read_info->read_buffer==NULL) | 1232 | |
1231 | { | 1233 | if ( (0 != file->cur_file_info.compression_method) && |
1232 | free(pfile_in_zip_read_info); | 1234 | (Z_DEFLATED != file->cur_file_info.compression_method) ) |
1233 | return EXTRACTOR_UNZIP_INTERNALERROR; | 1235 | err = EXTRACTOR_UNZIP_BADZIPFILE; |
1234 | } | 1236 | |
1235 | 1237 | pfile_in_zip_read_info->crc32_wait = file->cur_file_info.crc; | |
1236 | pfile_in_zip_read_info->stream_initialised=0; | 1238 | pfile_in_zip_read_info->crc32 = 0; |
1237 | 1239 | pfile_in_zip_read_info->compression_method = file->cur_file_info.compression_method; | |
1238 | if ((s->cur_file_info.compression_method!=0) && | 1240 | pfile_in_zip_read_info->z_filefunc = file->z_filefunc; |
1239 | (s->cur_file_info.compression_method!=Z_DEFLATED)) | 1241 | pfile_in_zip_read_info->byte_before_the_zipfile = file->byte_before_the_zipfile; |
1240 | err=EXTRACTOR_UNZIP_BADZIPFILE; | 1242 | pfile_in_zip_read_info->stream.total_out = 0; |
1241 | 1243 | ||
1242 | pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; | 1244 | if (file->cur_file_info.compression_method==Z_DEFLATED) |
1243 | pfile_in_zip_read_info->crc32=0; | ||
1244 | pfile_in_zip_read_info->compression_method = | ||
1245 | s->cur_file_info.compression_method; | ||
1246 | pfile_in_zip_read_info->z_filefunc=s->z_filefunc; | ||
1247 | pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; | ||
1248 | |||
1249 | pfile_in_zip_read_info->stream.total_out = 0; | ||
1250 | |||
1251 | if (s->cur_file_info.compression_method==Z_DEFLATED) | ||
1252 | { | 1245 | { |
1253 | pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; | 1246 | pfile_in_zip_read_info->stream.zalloc = (alloc_func) NULL; |
1254 | pfile_in_zip_read_info->stream.zfree = (free_func)0; | 1247 | pfile_in_zip_read_info->stream.zfree = (free_func) NULL; |
1255 | pfile_in_zip_read_info->stream.opaque = (voidpf)0; | 1248 | pfile_in_zip_read_info->stream.opaque = NULL; |
1256 | pfile_in_zip_read_info->stream.next_in = (voidpf)0; | 1249 | pfile_in_zip_read_info->stream.next_in = NULL; |
1257 | pfile_in_zip_read_info->stream.avail_in = 0; | 1250 | pfile_in_zip_read_info->stream.avail_in = 0; |
1258 | 1251 | if (Z_OK != (err = inflateInit2 (&pfile_in_zip_read_info->stream, -MAX_WBITS))) | |
1259 | err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); | ||
1260 | if (err == Z_OK) | ||
1261 | { | ||
1262 | pfile_in_zip_read_info->stream_initialised=1; | ||
1263 | } | ||
1264 | else | ||
1265 | { | 1252 | { |
1266 | free (pfile_in_zip_read_info->read_buffer); | 1253 | free (pfile_in_zip_read_info->read_buffer); |
1267 | free (pfile_in_zip_read_info); | 1254 | free (pfile_in_zip_read_info); |
1268 | return err; | 1255 | return err; |
1269 | } | 1256 | } |
1270 | /* windowBits is passed < 0 to tell that there is no zlib header. | 1257 | pfile_in_zip_read_info->stream_initialised = 1; |
1271 | * Note that in this case inflate *requires* an extra "dummy" byte | 1258 | /* windowBits is passed < 0 to tell that there is no zlib header. |
1272 | * after the compressed stream in order to complete decompression and | 1259 | * Note that in this case inflate *requires* an extra "dummy" byte |
1273 | * return Z_STREAM_END. | 1260 | * after the compressed stream in order to complete decompression and |
1274 | * In unzip, i don't wait absolutely Z_STREAM_END because I known the | 1261 | * return Z_STREAM_END. |
1275 | * size of both compressed and uncompressed data | 1262 | * In unzip, i don't wait absolutely Z_STREAM_END because I known the |
1276 | */ | 1263 | * size of both compressed and uncompressed data |
1264 | */ | ||
1277 | } | 1265 | } |
1278 | pfile_in_zip_read_info->rest_read_compressed = | 1266 | pfile_in_zip_read_info->rest_read_compressed = file->cur_file_info.compressed_size; |
1279 | s->cur_file_info.compressed_size ; | 1267 | pfile_in_zip_read_info->rest_read_uncompressed = file->cur_file_info.uncompressed_size; |
1280 | pfile_in_zip_read_info->rest_read_uncompressed = | 1268 | pfile_in_zip_read_info->pos_in_zipfile = |
1281 | s->cur_file_info.uncompressed_size ; | 1269 | file->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + |
1282 | 1270 | iSizeVar; | |
1283 | 1271 | pfile_in_zip_read_info->stream.avail_in = 0; | |
1284 | pfile_in_zip_read_info->pos_in_zipfile = | 1272 | file->pfile_in_zip_read = pfile_in_zip_read_info; |
1285 | s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + | 1273 | |
1286 | iSizeVar; | 1274 | return EXTRACTOR_UNZIP_OK; |
1287 | |||
1288 | pfile_in_zip_read_info->stream.avail_in = (uInt)0; | ||
1289 | |||
1290 | s->pfile_in_zip_read = pfile_in_zip_read_info; | ||
1291 | |||
1292 | return EXTRACTOR_UNZIP_OK; | ||
1293 | } | 1275 | } |
1294 | 1276 | ||
1295 | 1277 | ||
1296 | static uLong | 1278 | static uLong |
1297 | EXTRACTOR_common_unzip_zlib_read_file_func (voidpf opaque, | 1279 | ec_read_file_func (voidpf opaque, |
1298 | void* buf, | 1280 | void* buf, |
1299 | uLong size) | 1281 | uLong size) |
1300 | { | 1282 | { |
1301 | struct EXTRACTOR_ExtractContext *ec = opaque; | 1283 | struct EXTRACTOR_ExtractContext *ec = opaque; |
1302 | 1284 | void *ptr; | |
1303 | return -1; | 1285 | ssize_t ret; |
1286 | |||
1287 | ret = ec->read (ec->cls, | ||
1288 | &ptr, | ||
1289 | size); | ||
1290 | if (ret > 0) | ||
1291 | memcpy (buf, ptr, ret); | ||
1292 | // FIXME: partial reads are not allowed, need to possibly read more | ||
1293 | return ret; | ||
1304 | } | 1294 | } |
1305 | 1295 | ||
1306 | 1296 | ||
1307 | static long | 1297 | static long |
1308 | EXTRACTOR_common_unzip_zlib_tell_file_func (voidpf opaque) | 1298 | ec_tell_file_func (voidpf opaque) |
1309 | { | 1299 | { |
1310 | struct EXTRACTOR_ExtractContext *ec = opaque; | 1300 | struct EXTRACTOR_ExtractContext *ec = opaque; |
1311 | 1301 | ||
1312 | return -1; | 1302 | return ec->seek (ec->cls, 0, SEEK_CUR); |
1313 | } | 1303 | } |
1314 | 1304 | ||
1315 | 1305 | ||
1316 | static long | 1306 | static long |
1317 | EXTRACTOR_common_unzip_zlib_seek_file_func (voidpf opaque, | 1307 | ec_seek_file_func (voidpf opaque, |
1318 | uLong offset, | 1308 | uLong offset, |
1319 | int origin) | 1309 | int origin) |
1320 | { | 1310 | { |
1321 | struct EXTRACTOR_ExtractContext *ec = opaque; | 1311 | struct EXTRACTOR_ExtractContext *ec = opaque; |
1322 | 1312 | ||
1323 | return -1; | 1313 | if (-1 == ec->seek (ec->cls, offset, origin)) |
1314 | return EXTRACTOR_UNZIP_INTERNALERROR; | ||
1315 | return EXTRACTOR_UNZIP_OK; | ||
1324 | } | 1316 | } |
1325 | 1317 | ||
1326 | 1318 | ||
@@ -1336,9 +1328,9 @@ EXTRACTOR_common_unzip_open (struct EXTRACTOR_ExtractContext *ec) | |||
1336 | { | 1328 | { |
1337 | struct EXTRACTOR_UnzipFileFuncDefs io; | 1329 | struct EXTRACTOR_UnzipFileFuncDefs io; |
1338 | 1330 | ||
1339 | io.zread_file = &EXTRACTOR_common_unzip_zlib_read_file_func; | 1331 | io.zread_file = &ec_read_file_func; |
1340 | io.ztell_file = &EXTRACTOR_common_unzip_zlib_tell_file_func; | 1332 | io.ztell_file = &ec_tell_file_func; |
1341 | io.zseek_file = &EXTRACTOR_common_unzip_zlib_seek_file_func; | 1333 | io.zseek_file = &ec_seek_file_func; |
1342 | io.opaque = ec; | 1334 | io.opaque = ec; |
1343 | 1335 | ||
1344 | return EXTRACTOR_common_unzip_open2 (&io); | 1336 | return EXTRACTOR_common_unzip_open2 (&io); |