1 /*- 2 * Copyright (c) 2011 Michihiro NAKAJIMA 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "archive_platform.h" 27 __FBSDID("$FreeBSD$"); 28 29 #ifdef HAVE_ERRNO_H 30 #include <errno.h> 31 #endif 32 #ifdef HAVE_STDLIB_H 33 #include <stdlib.h> 34 #endif 35 #ifdef HAVE_BZLIB_H 36 #include <bzlib.h> 37 #endif 38 #ifdef HAVE_LZMA_H 39 #include <lzma.h> 40 #endif 41 #ifdef HAVE_ZLIB_H 42 #include <zlib.h> 43 #endif 44 45 #include "archive.h" 46 #include "archive_entry.h" 47 #include "archive_entry_locale.h" 48 #include "archive_ppmd7_private.h" 49 #include "archive_private.h" 50 #include "archive_read_private.h" 51 #include "archive_endian.h" 52 53 #ifndef HAVE_ZLIB_H 54 #include "archive_crc32.h" 55 #endif 56 57 #define _7ZIP_SIGNATURE "7z\xBC\xAF\x27\x1C" 58 #define SFX_MIN_ADDR 0x27000 59 #define SFX_MAX_ADDR 0x60000 60 61 62 /* 63 * Codec ID 64 */ 65 #define _7Z_COPY 0 66 #define _7Z_LZMA 0x030101 67 #define _7Z_LZMA2 0x21 68 #define _7Z_DEFLATE 0x040108 69 #define _7Z_BZ2 0x040202 70 #define _7Z_PPMD 0x030401 71 #define _7Z_DELTA 0x03 72 #define _7Z_CRYPTO_MAIN_ZIP 0x06F10101 /* Main Zip crypto algo */ 73 #define _7Z_CRYPTO_RAR_29 0x06F10303 /* Rar29 AES-128 + (modified SHA-1) */ 74 #define _7Z_CRYPTO_AES_256_SHA_256 0x06F10701 /* AES-256 + SHA-256 */ 75 76 77 #define _7Z_X86 0x03030103 78 #define _7Z_X86_BCJ2 0x0303011B 79 #define _7Z_POWERPC 0x03030205 80 #define _7Z_IA64 0x03030401 81 #define _7Z_ARM 0x03030501 82 #define _7Z_ARMTHUMB 0x03030701 83 #define _7Z_SPARC 0x03030805 84 85 /* 86 * 7-Zip header property IDs. 87 */ 88 #define kEnd 0x00 89 #define kHeader 0x01 90 #define kArchiveProperties 0x02 91 #define kAdditionalStreamsInfo 0x03 92 #define kMainStreamsInfo 0x04 93 #define kFilesInfo 0x05 94 #define kPackInfo 0x06 95 #define kUnPackInfo 0x07 96 #define kSubStreamsInfo 0x08 97 #define kSize 0x09 98 #define kCRC 0x0A 99 #define kFolder 0x0B 100 #define kCodersUnPackSize 0x0C 101 #define kNumUnPackStream 0x0D 102 #define kEmptyStream 0x0E 103 #define kEmptyFile 0x0F 104 #define kAnti 0x10 105 #define kName 0x11 106 #define kCTime 0x12 107 #define kATime 0x13 108 #define kMTime 0x14 109 #define kAttributes 0x15 110 #define kEncodedHeader 0x17 111 #define kDummy 0x19 112 113 struct _7z_digests { 114 unsigned char *defineds; 115 uint32_t *digests; 116 }; 117 118 119 struct _7z_folder { 120 uint64_t numCoders; 121 struct _7z_coder { 122 unsigned long codec; 123 uint64_t numInStreams; 124 uint64_t numOutStreams; 125 uint64_t propertiesSize; 126 unsigned char *properties; 127 } *coders; 128 uint64_t numBindPairs; 129 struct { 130 uint64_t inIndex; 131 uint64_t outIndex; 132 } *bindPairs; 133 uint64_t numPackedStreams; 134 uint64_t *packedStreams; 135 uint64_t numInStreams; 136 uint64_t numOutStreams; 137 uint64_t *unPackSize; 138 unsigned char digest_defined; 139 uint32_t digest; 140 uint64_t numUnpackStreams; 141 uint32_t packIndex; 142 /* Unoperated bytes. */ 143 uint64_t skipped_bytes; 144 }; 145 146 struct _7z_coders_info { 147 uint64_t numFolders; 148 struct _7z_folder *folders; 149 uint64_t dataStreamIndex; 150 }; 151 152 struct _7z_pack_info { 153 uint64_t pos; 154 uint64_t numPackStreams; 155 uint64_t *sizes; 156 struct _7z_digests digest; 157 /* Calculated from pos and numPackStreams. */ 158 uint64_t *positions; 159 }; 160 161 struct _7z_substream_info { 162 size_t unpack_streams; 163 uint64_t *unpackSizes; 164 unsigned char *digestsDefined; 165 uint32_t *digests; 166 }; 167 168 struct _7z_stream_info { 169 struct _7z_pack_info pi; 170 struct _7z_coders_info ci; 171 struct _7z_substream_info ss; 172 }; 173 174 struct _7z_header_info { 175 uint64_t dataIndex; 176 177 unsigned char *emptyStreamBools; 178 unsigned char *emptyFileBools; 179 unsigned char *antiBools; 180 unsigned char *attrBools; 181 }; 182 183 struct _7zip_entry { 184 size_t name_len; 185 unsigned char *utf16name; 186 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG) 187 const wchar_t *wname; 188 #endif 189 uint32_t folderIndex; 190 uint32_t ssIndex; 191 unsigned flg; 192 #define MTIME_IS_SET (1<<0) 193 #define ATIME_IS_SET (1<<1) 194 #define CTIME_IS_SET (1<<2) 195 #define CRC32_IS_SET (1<<3) 196 #define HAS_STREAM (1<<4) 197 198 time_t mtime; 199 time_t atime; 200 time_t ctime; 201 long mtime_ns; 202 long atime_ns; 203 long ctime_ns; 204 uint32_t mode; 205 uint32_t attr; 206 }; 207 208 struct _7zip { 209 /* Structural information about the archive. */ 210 struct _7z_stream_info si; 211 212 int header_is_being_read; 213 int header_is_encoded; 214 uint64_t header_bytes_remaining; 215 unsigned long header_crc32; 216 /* Header offset to check that reading points of the file contents 217 * will not exceed the header. */ 218 uint64_t header_offset; 219 /* Base offset of the archive file for a seek in case reading SFX. */ 220 uint64_t seek_base; 221 222 /* List of entries */ 223 size_t entries_remaining; 224 uint64_t numFiles; 225 struct _7zip_entry *entries; 226 struct _7zip_entry *entry; 227 unsigned char *entry_names; 228 229 /* entry_bytes_remaining is the number of bytes we expect. */ 230 int64_t entry_offset; 231 uint64_t entry_bytes_remaining; 232 233 /* Running CRC32 of the decompressed data */ 234 unsigned long entry_crc32; 235 236 /* Flags to mark progress of decompression. */ 237 char end_of_entry; 238 239 /* Uncompressed buffer control. */ 240 #define UBUFF_SIZE (64 * 1024) 241 unsigned char *uncompressed_buffer; 242 unsigned char *uncompressed_buffer_pointer; 243 size_t uncompressed_buffer_size; 244 size_t uncompressed_buffer_bytes_remaining; 245 246 /* Offset of the compressed data. */ 247 int64_t stream_offset; 248 249 /* 250 * Decompressing control data. 251 */ 252 unsigned folder_index; 253 uint64_t folder_outbytes_remaining; 254 unsigned pack_stream_index; 255 unsigned pack_stream_remaining; 256 uint64_t pack_stream_inbytes_remaining; 257 size_t pack_stream_bytes_unconsumed; 258 259 /* The codec information of a folder. */ 260 unsigned long codec; 261 unsigned long codec2; 262 263 /* 264 * Decompressor controllers. 265 */ 266 /* Decoding LZMA1 and LZMA2 data. */ 267 #ifdef HAVE_LZMA_H 268 lzma_stream lzstream; 269 int lzstream_valid; 270 #endif 271 /* Decoding bzip2 data. */ 272 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR) 273 bz_stream bzstream; 274 int bzstream_valid; 275 #endif 276 /* Decoding deflate data. */ 277 #ifdef HAVE_ZLIB_H 278 z_stream stream; 279 int stream_valid; 280 #endif 281 /* Decoding PPMd data. */ 282 int ppmd7_stat; 283 CPpmd7 ppmd7_context; 284 CPpmd7z_RangeDec range_dec; 285 IByteIn bytein; 286 struct { 287 const unsigned char *next_in; 288 int64_t avail_in; 289 int64_t total_in; 290 unsigned char *next_out; 291 int64_t avail_out; 292 int64_t total_out; 293 int overconsumed; 294 } ppstream; 295 int ppmd7_valid; 296 297 /* Decoding BCJ and BCJ2 data. */ 298 uint32_t bcj_state; 299 size_t odd_bcj_size; 300 unsigned char odd_bcj[4]; 301 /* Decoding BCJ data. */ 302 size_t bcj_prevPosT; 303 uint32_t bcj_prevMask; 304 uint32_t bcj_ip; 305 306 /* Decoding BCJ2 data. */ 307 size_t main_stream_bytes_remaining; 308 unsigned char *sub_stream_buff[3]; 309 size_t sub_stream_size[3]; 310 size_t sub_stream_bytes_remaining[3]; 311 unsigned char *tmp_stream_buff; 312 size_t tmp_stream_buff_size; 313 size_t tmp_stream_bytes_avail; 314 size_t tmp_stream_bytes_remaining; 315 #ifdef _LZMA_PROB32 316 #define CProb uint32_t 317 #else 318 #define CProb uint16_t 319 #endif 320 CProb bcj2_p[256 + 2]; 321 uint8_t bcj2_prevByte; 322 uint32_t bcj2_range; 323 uint32_t bcj2_code; 324 uint64_t bcj2_outPos; 325 326 /* Filename character-set conversion data. */ 327 struct archive_string_conv *sconv; 328 329 char format_name[64]; 330 331 /* Custom value that is non-zero if this archive contains encrypted entries. */ 332 int has_encrypted_entries; 333 }; 334 335 /* Maximum entry size. This limitation prevents reading intentional 336 * corrupted 7-zip files on assuming there are not so many entries in 337 * the files. */ 338 #define UMAX_ENTRY ARCHIVE_LITERAL_ULL(100000000) 339 340 static int archive_read_format_7zip_has_encrypted_entries(struct archive_read *); 341 static int archive_read_support_format_7zip_capabilities(struct archive_read *a); 342 static int archive_read_format_7zip_bid(struct archive_read *, int); 343 static int archive_read_format_7zip_cleanup(struct archive_read *); 344 static int archive_read_format_7zip_read_data(struct archive_read *, 345 const void **, size_t *, int64_t *); 346 static int archive_read_format_7zip_read_data_skip(struct archive_read *); 347 static int archive_read_format_7zip_read_header(struct archive_read *, 348 struct archive_entry *); 349 static int check_7zip_header_in_sfx(const char *); 350 static unsigned long decode_codec_id(const unsigned char *, size_t); 351 static int decode_encoded_header_info(struct archive_read *, 352 struct _7z_stream_info *); 353 static int decompress(struct archive_read *, struct _7zip *, 354 void *, size_t *, const void *, size_t *); 355 static ssize_t extract_pack_stream(struct archive_read *, size_t); 356 static void fileTimeToUtc(uint64_t, time_t *, long *); 357 static uint64_t folder_uncompressed_size(struct _7z_folder *); 358 static void free_CodersInfo(struct _7z_coders_info *); 359 static void free_Digest(struct _7z_digests *); 360 static void free_Folder(struct _7z_folder *); 361 static void free_Header(struct _7z_header_info *); 362 static void free_PackInfo(struct _7z_pack_info *); 363 static void free_StreamsInfo(struct _7z_stream_info *); 364 static void free_SubStreamsInfo(struct _7z_substream_info *); 365 static int free_decompression(struct archive_read *, struct _7zip *); 366 static ssize_t get_uncompressed_data(struct archive_read *, const void **, 367 size_t, size_t); 368 static const unsigned char * header_bytes(struct archive_read *, size_t); 369 static int init_decompression(struct archive_read *, struct _7zip *, 370 const struct _7z_coder *, const struct _7z_coder *); 371 static int parse_7zip_uint64(struct archive_read *, uint64_t *); 372 static int read_Bools(struct archive_read *, unsigned char *, size_t); 373 static int read_CodersInfo(struct archive_read *, 374 struct _7z_coders_info *); 375 static int read_Digests(struct archive_read *, struct _7z_digests *, 376 size_t); 377 static int read_Folder(struct archive_read *, struct _7z_folder *); 378 static int read_Header(struct archive_read *, struct _7z_header_info *, 379 int); 380 static int read_PackInfo(struct archive_read *, struct _7z_pack_info *); 381 static int read_StreamsInfo(struct archive_read *, 382 struct _7z_stream_info *); 383 static int read_SubStreamsInfo(struct archive_read *, 384 struct _7z_substream_info *, struct _7z_folder *, size_t); 385 static int read_Times(struct archive_read *, struct _7z_header_info *, 386 int); 387 static void read_consume(struct archive_read *); 388 static ssize_t read_stream(struct archive_read *, const void **, size_t, 389 size_t); 390 static int seek_pack(struct archive_read *); 391 static int64_t skip_stream(struct archive_read *, size_t); 392 static int skip_sfx(struct archive_read *, ssize_t); 393 static int slurp_central_directory(struct archive_read *, struct _7zip *, 394 struct _7z_header_info *); 395 static int setup_decode_folder(struct archive_read *, struct _7z_folder *, 396 int); 397 static void x86_Init(struct _7zip *); 398 static size_t x86_Convert(struct _7zip *, uint8_t *, size_t); 399 static ssize_t Bcj2_Decode(struct _7zip *, uint8_t *, size_t); 400 401 402 int 403 archive_read_support_format_7zip(struct archive *_a) 404 { 405 struct archive_read *a = (struct archive_read *)_a; 406 struct _7zip *zip; 407 int r; 408 409 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 410 ARCHIVE_STATE_NEW, "archive_read_support_format_7zip"); 411 412 zip = calloc(1, sizeof(*zip)); 413 if (zip == NULL) { 414 archive_set_error(&a->archive, ENOMEM, 415 "Can't allocate 7zip data"); 416 return (ARCHIVE_FATAL); 417 } 418 419 /* 420 * Until enough data has been read, we cannot tell about 421 * any encrypted entries yet. 422 */ 423 zip->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 424 425 426 r = __archive_read_register_format(a, 427 zip, 428 "7zip", 429 archive_read_format_7zip_bid, 430 NULL, 431 archive_read_format_7zip_read_header, 432 archive_read_format_7zip_read_data, 433 archive_read_format_7zip_read_data_skip, 434 NULL, 435 archive_read_format_7zip_cleanup, 436 archive_read_support_format_7zip_capabilities, 437 archive_read_format_7zip_has_encrypted_entries); 438 439 if (r != ARCHIVE_OK) 440 free(zip); 441 return (ARCHIVE_OK); 442 } 443 444 static int 445 archive_read_support_format_7zip_capabilities(struct archive_read * a) 446 { 447 (void)a; /* UNUSED */ 448 return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | 449 ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); 450 } 451 452 453 static int 454 archive_read_format_7zip_has_encrypted_entries(struct archive_read *_a) 455 { 456 if (_a && _a->format) { 457 struct _7zip * zip = (struct _7zip *)_a->format->data; 458 if (zip) { 459 return zip->has_encrypted_entries; 460 } 461 } 462 return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 463 } 464 465 static int 466 archive_read_format_7zip_bid(struct archive_read *a, int best_bid) 467 { 468 const char *p; 469 470 /* If someone has already bid more than 32, then avoid 471 trashing the look-ahead buffers with a seek. */ 472 if (best_bid > 32) 473 return (-1); 474 475 if ((p = __archive_read_ahead(a, 6, NULL)) == NULL) 476 return (0); 477 478 /* If first six bytes are the 7-Zip signature, 479 * return the bid right now. */ 480 if (memcmp(p, _7ZIP_SIGNATURE, 6) == 0) 481 return (48); 482 483 /* 484 * It may a 7-Zip SFX archive file. If first two bytes are 485 * 'M' and 'Z' available on Windows or first four bytes are 486 * "\x7F\x45LF" available on posix like system, seek the 7-Zip 487 * signature. Although we will perform a seek when reading 488 * a header, what we do not use __archive_read_seek() here is 489 * due to a bidding performance. 490 */ 491 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) { 492 ssize_t offset = SFX_MIN_ADDR; 493 ssize_t window = 4096; 494 ssize_t bytes_avail; 495 while (offset + window <= (SFX_MAX_ADDR)) { 496 const char *buff = __archive_read_ahead(a, 497 offset + window, &bytes_avail); 498 if (buff == NULL) { 499 /* Remaining bytes are less than window. */ 500 window >>= 1; 501 if (window < 0x40) 502 return (0); 503 continue; 504 } 505 p = buff + offset; 506 while (p + 32 < buff + bytes_avail) { 507 int step = check_7zip_header_in_sfx(p); 508 if (step == 0) 509 return (48); 510 p += step; 511 } 512 offset = p - buff; 513 } 514 } 515 return (0); 516 } 517 518 static int 519 check_7zip_header_in_sfx(const char *p) 520 { 521 switch ((unsigned char)p[5]) { 522 case 0x1C: 523 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0) 524 return (6); 525 /* 526 * Test the CRC because its extraction code has 7-Zip 527 * Magic Code, so we should do this in order not to 528 * make a mis-detection. 529 */ 530 if (crc32(0, (const unsigned char *)p + 12, 20) 531 != archive_le32dec(p + 8)) 532 return (6); 533 /* Hit the header! */ 534 return (0); 535 case 0x37: return (5); 536 case 0x7A: return (4); 537 case 0xBC: return (3); 538 case 0xAF: return (2); 539 case 0x27: return (1); 540 default: return (6); 541 } 542 } 543 544 static int 545 skip_sfx(struct archive_read *a, ssize_t bytes_avail) 546 { 547 const void *h; 548 const char *p, *q; 549 size_t skip, offset; 550 ssize_t bytes, window; 551 552 /* 553 * If bytes_avail > SFX_MIN_ADDR we do not have to call 554 * __archive_read_seek() at this time since we have 555 * already had enough data. 556 */ 557 if (bytes_avail > SFX_MIN_ADDR) 558 __archive_read_consume(a, SFX_MIN_ADDR); 559 else if (__archive_read_seek(a, SFX_MIN_ADDR, SEEK_SET) < 0) 560 return (ARCHIVE_FATAL); 561 562 offset = 0; 563 window = 1; 564 while (offset + window <= SFX_MAX_ADDR - SFX_MIN_ADDR) { 565 h = __archive_read_ahead(a, window, &bytes); 566 if (h == NULL) { 567 /* Remaining bytes are less than window. */ 568 window >>= 1; 569 if (window < 0x40) 570 goto fatal; 571 continue; 572 } 573 if (bytes < 6) { 574 /* This case might happen when window == 1. */ 575 window = 4096; 576 continue; 577 } 578 p = (const char *)h; 579 q = p + bytes; 580 581 /* 582 * Scan ahead until we find something that looks 583 * like the 7-Zip header. 584 */ 585 while (p + 32 < q) { 586 int step = check_7zip_header_in_sfx(p); 587 if (step == 0) { 588 struct _7zip *zip = 589 (struct _7zip *)a->format->data; 590 skip = p - (const char *)h; 591 __archive_read_consume(a, skip); 592 zip->seek_base = SFX_MIN_ADDR + offset + skip; 593 return (ARCHIVE_OK); 594 } 595 p += step; 596 } 597 skip = p - (const char *)h; 598 __archive_read_consume(a, skip); 599 offset += skip; 600 if (window == 1) 601 window = 4096; 602 } 603 fatal: 604 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 605 "Couldn't find out 7-Zip header"); 606 return (ARCHIVE_FATAL); 607 } 608 609 static int 610 archive_read_format_7zip_read_header(struct archive_read *a, 611 struct archive_entry *entry) 612 { 613 struct _7zip *zip = (struct _7zip *)a->format->data; 614 struct _7zip_entry *zip_entry; 615 int r, ret = ARCHIVE_OK; 616 struct _7z_folder *folder = 0; 617 uint64_t fidx = 0; 618 619 /* 620 * It should be sufficient to call archive_read_next_header() for 621 * a reader to determine if an entry is encrypted or not. If the 622 * encryption of an entry is only detectable when calling 623 * archive_read_data(), so be it. We'll do the same check there 624 * as well. 625 */ 626 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 627 zip->has_encrypted_entries = 0; 628 } 629 630 a->archive.archive_format = ARCHIVE_FORMAT_7ZIP; 631 if (a->archive.archive_format_name == NULL) 632 a->archive.archive_format_name = "7-Zip"; 633 634 if (zip->entries == NULL) { 635 struct _7z_header_info header; 636 637 memset(&header, 0, sizeof(header)); 638 r = slurp_central_directory(a, zip, &header); 639 free_Header(&header); 640 if (r != ARCHIVE_OK) 641 return (r); 642 zip->entries_remaining = (size_t)zip->numFiles; 643 zip->entry = zip->entries; 644 } else { 645 ++zip->entry; 646 } 647 zip_entry = zip->entry; 648 649 if (zip->entries_remaining <= 0 || zip_entry == NULL) 650 return ARCHIVE_EOF; 651 --zip->entries_remaining; 652 653 zip->entry_offset = 0; 654 zip->end_of_entry = 0; 655 zip->entry_crc32 = crc32(0, NULL, 0); 656 657 /* Setup a string conversion for a filename. */ 658 if (zip->sconv == NULL) { 659 zip->sconv = archive_string_conversion_from_charset( 660 &a->archive, "UTF-16LE", 1); 661 if (zip->sconv == NULL) 662 return (ARCHIVE_FATAL); 663 } 664 665 /* Figure out if the entry is encrypted by looking at the folder 666 that is associated to the current 7zip entry. If the folder 667 has a coder with a _7Z_CRYPTO codec then the folder is encrypted. 668 Hence the entry must also be encrypted. */ 669 if (zip_entry && zip_entry->folderIndex < zip->si.ci.numFolders) { 670 folder = &(zip->si.ci.folders[zip_entry->folderIndex]); 671 for (fidx=0; folder && fidx<folder->numCoders; fidx++) { 672 switch(folder->coders[fidx].codec) { 673 case _7Z_CRYPTO_MAIN_ZIP: 674 case _7Z_CRYPTO_RAR_29: 675 case _7Z_CRYPTO_AES_256_SHA_256: { 676 archive_entry_set_is_data_encrypted(entry, 1); 677 zip->has_encrypted_entries = 1; 678 break; 679 } 680 } 681 } 682 } 683 684 /* Now that we've checked for encryption, if there were still no 685 * encrypted entries found we can say for sure that there are none. 686 */ 687 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 688 zip->has_encrypted_entries = 0; 689 } 690 691 if (archive_entry_copy_pathname_l(entry, 692 (const char *)zip_entry->utf16name, 693 zip_entry->name_len, zip->sconv) != 0) { 694 if (errno == ENOMEM) { 695 archive_set_error(&a->archive, ENOMEM, 696 "Can't allocate memory for Pathname"); 697 return (ARCHIVE_FATAL); 698 } 699 archive_set_error(&a->archive, 700 ARCHIVE_ERRNO_FILE_FORMAT, 701 "Pathname cannot be converted " 702 "from %s to current locale.", 703 archive_string_conversion_charset_name(zip->sconv)); 704 ret = ARCHIVE_WARN; 705 } 706 707 /* Populate some additional entry fields: */ 708 archive_entry_set_mode(entry, zip_entry->mode); 709 if (zip_entry->flg & MTIME_IS_SET) 710 archive_entry_set_mtime(entry, zip_entry->mtime, 711 zip_entry->mtime_ns); 712 if (zip_entry->flg & CTIME_IS_SET) 713 archive_entry_set_ctime(entry, zip_entry->ctime, 714 zip_entry->ctime_ns); 715 if (zip_entry->flg & ATIME_IS_SET) 716 archive_entry_set_atime(entry, zip_entry->atime, 717 zip_entry->atime_ns); 718 if (zip_entry->ssIndex != (uint32_t)-1) { 719 zip->entry_bytes_remaining = 720 zip->si.ss.unpackSizes[zip_entry->ssIndex]; 721 archive_entry_set_size(entry, zip->entry_bytes_remaining); 722 } else { 723 zip->entry_bytes_remaining = 0; 724 archive_entry_set_size(entry, 0); 725 } 726 727 /* If there's no body, force read_data() to return EOF immediately. */ 728 if (zip->entry_bytes_remaining < 1) 729 zip->end_of_entry = 1; 730 731 if ((zip_entry->mode & AE_IFMT) == AE_IFLNK) { 732 unsigned char *symname = NULL; 733 size_t symsize = 0; 734 735 /* 736 * Symbolic-name is recorded as its contents. We have to 737 * read the contents at this time. 738 */ 739 while (zip->entry_bytes_remaining > 0) { 740 const void *buff; 741 unsigned char *mem; 742 size_t size; 743 int64_t offset; 744 745 r = archive_read_format_7zip_read_data(a, &buff, 746 &size, &offset); 747 if (r < ARCHIVE_WARN) { 748 free(symname); 749 return (r); 750 } 751 mem = realloc(symname, symsize + size + 1); 752 if (mem == NULL) { 753 free(symname); 754 archive_set_error(&a->archive, ENOMEM, 755 "Can't allocate memory for Symname"); 756 return (ARCHIVE_FATAL); 757 } 758 symname = mem; 759 memcpy(symname+symsize, buff, size); 760 symsize += size; 761 } 762 if (symsize == 0) { 763 /* If there is no symname, handle it as a regular 764 * file. */ 765 zip_entry->mode &= ~AE_IFMT; 766 zip_entry->mode |= AE_IFREG; 767 archive_entry_set_mode(entry, zip_entry->mode); 768 } else { 769 symname[symsize] = '\0'; 770 archive_entry_copy_symlink(entry, 771 (const char *)symname); 772 } 773 free(symname); 774 archive_entry_set_size(entry, 0); 775 } 776 777 /* Set up a more descriptive format name. */ 778 sprintf(zip->format_name, "7-Zip"); 779 a->archive.archive_format_name = zip->format_name; 780 781 return (ret); 782 } 783 784 static int 785 archive_read_format_7zip_read_data(struct archive_read *a, 786 const void **buff, size_t *size, int64_t *offset) 787 { 788 struct _7zip *zip; 789 ssize_t bytes; 790 int ret = ARCHIVE_OK; 791 792 zip = (struct _7zip *)(a->format->data); 793 794 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 795 zip->has_encrypted_entries = 0; 796 } 797 798 if (zip->pack_stream_bytes_unconsumed) 799 read_consume(a); 800 801 *offset = zip->entry_offset; 802 *size = 0; 803 *buff = NULL; 804 /* 805 * If we hit end-of-entry last time, clean up and return 806 * ARCHIVE_EOF this time. 807 */ 808 if (zip->end_of_entry) 809 return (ARCHIVE_EOF); 810 811 bytes = read_stream(a, buff, 812 (size_t)zip->entry_bytes_remaining, 0); 813 if (bytes < 0) 814 return ((int)bytes); 815 if (bytes == 0) { 816 archive_set_error(&a->archive, 817 ARCHIVE_ERRNO_FILE_FORMAT, 818 "Truncated 7-Zip file body"); 819 return (ARCHIVE_FATAL); 820 } 821 zip->entry_bytes_remaining -= bytes; 822 if (zip->entry_bytes_remaining == 0) 823 zip->end_of_entry = 1; 824 825 /* Update checksum */ 826 if ((zip->entry->flg & CRC32_IS_SET) && bytes) 827 zip->entry_crc32 = crc32(zip->entry_crc32, *buff, 828 (unsigned)bytes); 829 830 /* If we hit the end, swallow any end-of-data marker. */ 831 if (zip->end_of_entry) { 832 /* Check computed CRC against file contents. */ 833 if ((zip->entry->flg & CRC32_IS_SET) && 834 zip->si.ss.digests[zip->entry->ssIndex] != 835 zip->entry_crc32) { 836 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 837 "7-Zip bad CRC: 0x%lx should be 0x%lx", 838 (unsigned long)zip->entry_crc32, 839 (unsigned long)zip->si.ss.digests[ 840 zip->entry->ssIndex]); 841 ret = ARCHIVE_WARN; 842 } 843 } 844 845 *size = bytes; 846 *offset = zip->entry_offset; 847 zip->entry_offset += bytes; 848 849 return (ret); 850 } 851 852 static int 853 archive_read_format_7zip_read_data_skip(struct archive_read *a) 854 { 855 struct _7zip *zip; 856 int64_t bytes_skipped; 857 858 zip = (struct _7zip *)(a->format->data); 859 860 if (zip->pack_stream_bytes_unconsumed) 861 read_consume(a); 862 863 /* If we've already read to end of data, we're done. */ 864 if (zip->end_of_entry) 865 return (ARCHIVE_OK); 866 867 /* 868 * If the length is at the beginning, we can skip the 869 * compressed data much more quickly. 870 */ 871 bytes_skipped = skip_stream(a, (size_t)zip->entry_bytes_remaining); 872 if (bytes_skipped < 0) 873 return (ARCHIVE_FATAL); 874 zip->entry_bytes_remaining = 0; 875 876 /* This entry is finished and done. */ 877 zip->end_of_entry = 1; 878 return (ARCHIVE_OK); 879 } 880 881 static int 882 archive_read_format_7zip_cleanup(struct archive_read *a) 883 { 884 struct _7zip *zip; 885 886 zip = (struct _7zip *)(a->format->data); 887 free_StreamsInfo(&(zip->si)); 888 free(zip->entries); 889 free(zip->entry_names); 890 free_decompression(a, zip); 891 free(zip->uncompressed_buffer); 892 free(zip->sub_stream_buff[0]); 893 free(zip->sub_stream_buff[1]); 894 free(zip->sub_stream_buff[2]); 895 free(zip->tmp_stream_buff); 896 free(zip); 897 (a->format->data) = NULL; 898 return (ARCHIVE_OK); 899 } 900 901 static void 902 read_consume(struct archive_read *a) 903 { 904 struct _7zip *zip = (struct _7zip *)a->format->data; 905 906 if (zip->pack_stream_bytes_unconsumed) { 907 __archive_read_consume(a, zip->pack_stream_bytes_unconsumed); 908 zip->stream_offset += zip->pack_stream_bytes_unconsumed; 909 zip->pack_stream_bytes_unconsumed = 0; 910 } 911 } 912 913 #ifdef HAVE_LZMA_H 914 915 /* 916 * Set an error code and choose an error message for liblzma. 917 */ 918 static void 919 set_error(struct archive_read *a, int ret) 920 { 921 922 switch (ret) { 923 case LZMA_STREAM_END: /* Found end of stream. */ 924 case LZMA_OK: /* Decompressor made some progress. */ 925 break; 926 case LZMA_MEM_ERROR: 927 archive_set_error(&a->archive, ENOMEM, 928 "Lzma library error: Cannot allocate memory"); 929 break; 930 case LZMA_MEMLIMIT_ERROR: 931 archive_set_error(&a->archive, ENOMEM, 932 "Lzma library error: Out of memory"); 933 break; 934 case LZMA_FORMAT_ERROR: 935 archive_set_error(&a->archive, 936 ARCHIVE_ERRNO_MISC, 937 "Lzma library error: format not recognized"); 938 break; 939 case LZMA_OPTIONS_ERROR: 940 archive_set_error(&a->archive, 941 ARCHIVE_ERRNO_MISC, 942 "Lzma library error: Invalid options"); 943 break; 944 case LZMA_DATA_ERROR: 945 archive_set_error(&a->archive, 946 ARCHIVE_ERRNO_MISC, 947 "Lzma library error: Corrupted input data"); 948 break; 949 case LZMA_BUF_ERROR: 950 archive_set_error(&a->archive, 951 ARCHIVE_ERRNO_MISC, 952 "Lzma library error: No progress is possible"); 953 break; 954 default: 955 /* Return an error. */ 956 archive_set_error(&a->archive, 957 ARCHIVE_ERRNO_MISC, 958 "Lzma decompression failed: Unknown error"); 959 break; 960 } 961 } 962 963 #endif 964 965 static unsigned long 966 decode_codec_id(const unsigned char *codecId, size_t id_size) 967 { 968 unsigned i; 969 unsigned long id = 0; 970 971 for (i = 0; i < id_size; i++) { 972 id <<= 8; 973 id += codecId[i]; 974 } 975 return (id); 976 } 977 978 static void * 979 ppmd_alloc(void *p, size_t size) 980 { 981 (void)p; 982 return malloc(size); 983 } 984 static void 985 ppmd_free(void *p, void *address) 986 { 987 (void)p; 988 free(address); 989 } 990 static Byte 991 ppmd_read(void *p) 992 { 993 struct archive_read *a = ((IByteIn*)p)->a; 994 struct _7zip *zip = (struct _7zip *)(a->format->data); 995 Byte b; 996 997 if (zip->ppstream.avail_in == 0) { 998 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 999 "Truncated RAR file data"); 1000 zip->ppstream.overconsumed = 1; 1001 return (0); 1002 } 1003 b = *zip->ppstream.next_in++; 1004 zip->ppstream.avail_in--; 1005 zip->ppstream.total_in++; 1006 return (b); 1007 } 1008 1009 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free }; 1010 1011 static int 1012 init_decompression(struct archive_read *a, struct _7zip *zip, 1013 const struct _7z_coder *coder1, const struct _7z_coder *coder2) 1014 { 1015 int r; 1016 1017 zip->codec = coder1->codec; 1018 zip->codec2 = -1; 1019 1020 switch (zip->codec) { 1021 case _7Z_COPY: 1022 case _7Z_BZ2: 1023 case _7Z_DEFLATE: 1024 case _7Z_PPMD: 1025 if (coder2 != NULL) { 1026 if (coder2->codec != _7Z_X86 && 1027 coder2->codec != _7Z_X86_BCJ2) { 1028 archive_set_error(&a->archive, 1029 ARCHIVE_ERRNO_MISC, 1030 "Unsupported filter %lx for %lx", 1031 coder2->codec, coder1->codec); 1032 return (ARCHIVE_FAILED); 1033 } 1034 zip->codec2 = coder2->codec; 1035 zip->bcj_state = 0; 1036 if (coder2->codec == _7Z_X86) 1037 x86_Init(zip); 1038 } 1039 break; 1040 default: 1041 break; 1042 } 1043 1044 switch (zip->codec) { 1045 case _7Z_COPY: 1046 break; 1047 1048 case _7Z_LZMA: case _7Z_LZMA2: 1049 #ifdef HAVE_LZMA_H 1050 #if LZMA_VERSION_MAJOR >= 5 1051 /* Effectively disable the limiter. */ 1052 #define LZMA_MEMLIMIT UINT64_MAX 1053 #else 1054 /* NOTE: This needs to check memory size which running system has. */ 1055 #define LZMA_MEMLIMIT (1U << 30) 1056 #endif 1057 { 1058 lzma_options_delta delta_opt; 1059 lzma_filter filters[LZMA_FILTERS_MAX], *ff; 1060 int fi = 0; 1061 1062 if (zip->lzstream_valid) { 1063 lzma_end(&(zip->lzstream)); 1064 zip->lzstream_valid = 0; 1065 } 1066 1067 /* 1068 * NOTE: liblzma incompletely handle the BCJ+LZMA compressed 1069 * data made by 7-Zip because 7-Zip does not add End-Of- 1070 * Payload Marker(EOPM) at the end of LZMA compressed data, 1071 * and so liblzma cannot know the end of the compressed data 1072 * without EOPM. So consequently liblzma will not return last 1073 * three or four bytes of uncompressed data because 1074 * LZMA_FILTER_X86 filter does not handle input data if its 1075 * data size is less than five bytes. If liblzma detect EOPM 1076 * or know the uncompressed data size, liblzma will flush out 1077 * the remaining that three or four bytes of uncompressed 1078 * data. That is why we have to use our converting program 1079 * for BCJ+LZMA. If we were able to tell the uncompressed 1080 * size to liblzma when using lzma_raw_decoder() liblzma 1081 * could correctly deal with BCJ+LZMA. But unfortunately 1082 * there is no way to do that. 1083 * Discussion about this can be found at XZ Utils forum. 1084 */ 1085 if (coder2 != NULL) { 1086 zip->codec2 = coder2->codec; 1087 1088 filters[fi].options = NULL; 1089 switch (zip->codec2) { 1090 case _7Z_X86: 1091 if (zip->codec == _7Z_LZMA2) { 1092 filters[fi].id = LZMA_FILTER_X86; 1093 fi++; 1094 } else 1095 /* Use our filter. */ 1096 x86_Init(zip); 1097 break; 1098 case _7Z_X86_BCJ2: 1099 /* Use our filter. */ 1100 zip->bcj_state = 0; 1101 break; 1102 case _7Z_DELTA: 1103 filters[fi].id = LZMA_FILTER_DELTA; 1104 memset(&delta_opt, 0, sizeof(delta_opt)); 1105 delta_opt.type = LZMA_DELTA_TYPE_BYTE; 1106 delta_opt.dist = 1; 1107 filters[fi].options = &delta_opt; 1108 fi++; 1109 break; 1110 /* Following filters have not been tested yet. */ 1111 case _7Z_POWERPC: 1112 filters[fi].id = LZMA_FILTER_POWERPC; 1113 fi++; 1114 break; 1115 case _7Z_IA64: 1116 filters[fi].id = LZMA_FILTER_IA64; 1117 fi++; 1118 break; 1119 case _7Z_ARM: 1120 filters[fi].id = LZMA_FILTER_ARM; 1121 fi++; 1122 break; 1123 case _7Z_ARMTHUMB: 1124 filters[fi].id = LZMA_FILTER_ARMTHUMB; 1125 fi++; 1126 break; 1127 case _7Z_SPARC: 1128 filters[fi].id = LZMA_FILTER_SPARC; 1129 fi++; 1130 break; 1131 default: 1132 archive_set_error(&a->archive, 1133 ARCHIVE_ERRNO_MISC, 1134 "Unexpected codec ID: %lX", zip->codec2); 1135 return (ARCHIVE_FAILED); 1136 } 1137 } 1138 1139 if (zip->codec == _7Z_LZMA2) 1140 filters[fi].id = LZMA_FILTER_LZMA2; 1141 else 1142 filters[fi].id = LZMA_FILTER_LZMA1; 1143 filters[fi].options = NULL; 1144 ff = &filters[fi]; 1145 r = lzma_properties_decode(&filters[fi], NULL, 1146 coder1->properties, (size_t)coder1->propertiesSize); 1147 if (r != LZMA_OK) { 1148 set_error(a, r); 1149 return (ARCHIVE_FAILED); 1150 } 1151 fi++; 1152 1153 filters[fi].id = LZMA_VLI_UNKNOWN; 1154 filters[fi].options = NULL; 1155 r = lzma_raw_decoder(&(zip->lzstream), filters); 1156 free(ff->options); 1157 if (r != LZMA_OK) { 1158 set_error(a, r); 1159 return (ARCHIVE_FAILED); 1160 } 1161 zip->lzstream_valid = 1; 1162 zip->lzstream.total_in = 0; 1163 zip->lzstream.total_out = 0; 1164 break; 1165 } 1166 #else 1167 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1168 "LZMA codec is unsupported"); 1169 return (ARCHIVE_FAILED); 1170 #endif 1171 case _7Z_BZ2: 1172 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR) 1173 if (zip->bzstream_valid) { 1174 BZ2_bzDecompressEnd(&(zip->bzstream)); 1175 zip->bzstream_valid = 0; 1176 } 1177 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 0); 1178 if (r == BZ_MEM_ERROR) 1179 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 1); 1180 if (r != BZ_OK) { 1181 int err = ARCHIVE_ERRNO_MISC; 1182 const char *detail = NULL; 1183 switch (r) { 1184 case BZ_PARAM_ERROR: 1185 detail = "invalid setup parameter"; 1186 break; 1187 case BZ_MEM_ERROR: 1188 err = ENOMEM; 1189 detail = "out of memory"; 1190 break; 1191 case BZ_CONFIG_ERROR: 1192 detail = "mis-compiled library"; 1193 break; 1194 } 1195 archive_set_error(&a->archive, err, 1196 "Internal error initializing decompressor: %s", 1197 detail != NULL ? detail : "??"); 1198 zip->bzstream_valid = 0; 1199 return (ARCHIVE_FAILED); 1200 } 1201 zip->bzstream_valid = 1; 1202 zip->bzstream.total_in_lo32 = 0; 1203 zip->bzstream.total_in_hi32 = 0; 1204 zip->bzstream.total_out_lo32 = 0; 1205 zip->bzstream.total_out_hi32 = 0; 1206 break; 1207 #else 1208 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1209 "BZ2 codec is unsupported"); 1210 return (ARCHIVE_FAILED); 1211 #endif 1212 case _7Z_DEFLATE: 1213 #ifdef HAVE_ZLIB_H 1214 if (zip->stream_valid) 1215 r = inflateReset(&(zip->stream)); 1216 else 1217 r = inflateInit2(&(zip->stream), 1218 -15 /* Don't check for zlib header */); 1219 if (r != Z_OK) { 1220 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1221 "Couldn't initialize zlib stream."); 1222 return (ARCHIVE_FAILED); 1223 } 1224 zip->stream_valid = 1; 1225 zip->stream.total_in = 0; 1226 zip->stream.total_out = 0; 1227 break; 1228 #else 1229 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1230 "DEFLATE codec is unsupported"); 1231 return (ARCHIVE_FAILED); 1232 #endif 1233 case _7Z_PPMD: 1234 { 1235 unsigned order; 1236 uint32_t msize; 1237 1238 if (zip->ppmd7_valid) { 1239 __archive_ppmd7_functions.Ppmd7_Free( 1240 &zip->ppmd7_context, &g_szalloc); 1241 zip->ppmd7_valid = 0; 1242 } 1243 1244 if (coder1->propertiesSize < 5) { 1245 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1246 "Malformed PPMd parameter"); 1247 return (ARCHIVE_FAILED); 1248 } 1249 order = coder1->properties[0]; 1250 msize = archive_le32dec(&(coder1->properties[1])); 1251 if (order < PPMD7_MIN_ORDER || order > PPMD7_MAX_ORDER || 1252 msize < PPMD7_MIN_MEM_SIZE || msize > PPMD7_MAX_MEM_SIZE) { 1253 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1254 "Malformed PPMd parameter"); 1255 return (ARCHIVE_FAILED); 1256 } 1257 __archive_ppmd7_functions.Ppmd7_Construct(&zip->ppmd7_context); 1258 r = __archive_ppmd7_functions.Ppmd7_Alloc( 1259 &zip->ppmd7_context, msize, &g_szalloc); 1260 if (r == 0) { 1261 archive_set_error(&a->archive, ENOMEM, 1262 "Coludn't allocate memory for PPMd"); 1263 return (ARCHIVE_FATAL); 1264 } 1265 __archive_ppmd7_functions.Ppmd7_Init( 1266 &zip->ppmd7_context, order); 1267 __archive_ppmd7_functions.Ppmd7z_RangeDec_CreateVTable( 1268 &zip->range_dec); 1269 zip->ppmd7_valid = 1; 1270 zip->ppmd7_stat = 0; 1271 zip->ppstream.overconsumed = 0; 1272 zip->ppstream.total_in = 0; 1273 zip->ppstream.total_out = 0; 1274 break; 1275 } 1276 case _7Z_X86: 1277 case _7Z_X86_BCJ2: 1278 case _7Z_POWERPC: 1279 case _7Z_IA64: 1280 case _7Z_ARM: 1281 case _7Z_ARMTHUMB: 1282 case _7Z_SPARC: 1283 case _7Z_DELTA: 1284 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1285 "Unexpected codec ID: %lX", zip->codec); 1286 return (ARCHIVE_FAILED); 1287 case _7Z_CRYPTO_MAIN_ZIP: 1288 case _7Z_CRYPTO_RAR_29: 1289 case _7Z_CRYPTO_AES_256_SHA_256: 1290 if (a->entry) { 1291 archive_entry_set_is_metadata_encrypted(a->entry, 1); 1292 archive_entry_set_is_data_encrypted(a->entry, 1); 1293 zip->has_encrypted_entries = 1; 1294 } 1295 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1296 "Crypto codec not supported yet (ID: 0x%lX)", zip->codec); 1297 return (ARCHIVE_FAILED); 1298 default: 1299 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1300 "Unknown codec ID: %lX", zip->codec); 1301 return (ARCHIVE_FAILED); 1302 } 1303 1304 return (ARCHIVE_OK); 1305 } 1306 1307 static int 1308 decompress(struct archive_read *a, struct _7zip *zip, 1309 void *buff, size_t *outbytes, const void *b, size_t *used) 1310 { 1311 const uint8_t *t_next_in; 1312 uint8_t *t_next_out; 1313 size_t o_avail_in, o_avail_out; 1314 size_t t_avail_in, t_avail_out; 1315 uint8_t *bcj2_next_out; 1316 size_t bcj2_avail_out; 1317 int r, ret = ARCHIVE_OK; 1318 1319 t_avail_in = o_avail_in = *used; 1320 t_avail_out = o_avail_out = *outbytes; 1321 t_next_in = b; 1322 t_next_out = buff; 1323 1324 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) { 1325 int i; 1326 1327 /* Do not copy out the BCJ remaining bytes when the output 1328 * buffer size is less than five bytes. */ 1329 if (o_avail_in != 0 && t_avail_out < 5 && zip->odd_bcj_size) { 1330 *used = 0; 1331 *outbytes = 0; 1332 return (ret); 1333 } 1334 for (i = 0; zip->odd_bcj_size > 0 && t_avail_out; i++) { 1335 *t_next_out++ = zip->odd_bcj[i]; 1336 t_avail_out--; 1337 zip->odd_bcj_size--; 1338 } 1339 if (o_avail_in == 0 || t_avail_out == 0) { 1340 *used = o_avail_in - t_avail_in; 1341 *outbytes = o_avail_out - t_avail_out; 1342 if (o_avail_in == 0) 1343 ret = ARCHIVE_EOF; 1344 return (ret); 1345 } 1346 } 1347 1348 bcj2_next_out = t_next_out; 1349 bcj2_avail_out = t_avail_out; 1350 if (zip->codec2 == _7Z_X86_BCJ2) { 1351 /* 1352 * Decord a remaining decompressed main stream for BCJ2. 1353 */ 1354 if (zip->tmp_stream_bytes_remaining) { 1355 ssize_t bytes; 1356 size_t remaining = zip->tmp_stream_bytes_remaining; 1357 bytes = Bcj2_Decode(zip, t_next_out, t_avail_out); 1358 if (bytes < 0) { 1359 archive_set_error(&(a->archive), 1360 ARCHIVE_ERRNO_MISC, 1361 "BCJ2 conversion Failed"); 1362 return (ARCHIVE_FAILED); 1363 } 1364 zip->main_stream_bytes_remaining -= 1365 remaining - zip->tmp_stream_bytes_remaining; 1366 t_avail_out -= bytes; 1367 if (o_avail_in == 0 || t_avail_out == 0) { 1368 *used = 0; 1369 *outbytes = o_avail_out - t_avail_out; 1370 if (o_avail_in == 0 && 1371 zip->tmp_stream_bytes_remaining) 1372 ret = ARCHIVE_EOF; 1373 return (ret); 1374 } 1375 t_next_out += bytes; 1376 bcj2_next_out = t_next_out; 1377 bcj2_avail_out = t_avail_out; 1378 } 1379 t_next_out = zip->tmp_stream_buff; 1380 t_avail_out = zip->tmp_stream_buff_size; 1381 } 1382 1383 switch (zip->codec) { 1384 case _7Z_COPY: 1385 { 1386 size_t bytes = 1387 (t_avail_in > t_avail_out)?t_avail_out:t_avail_in; 1388 1389 memcpy(t_next_out, t_next_in, bytes); 1390 t_avail_in -= bytes; 1391 t_avail_out -= bytes; 1392 if (o_avail_in == 0) 1393 ret = ARCHIVE_EOF; 1394 break; 1395 } 1396 #ifdef HAVE_LZMA_H 1397 case _7Z_LZMA: case _7Z_LZMA2: 1398 zip->lzstream.next_in = t_next_in; 1399 zip->lzstream.avail_in = t_avail_in; 1400 zip->lzstream.next_out = t_next_out; 1401 zip->lzstream.avail_out = t_avail_out; 1402 1403 r = lzma_code(&(zip->lzstream), LZMA_RUN); 1404 switch (r) { 1405 case LZMA_STREAM_END: /* Found end of stream. */ 1406 lzma_end(&(zip->lzstream)); 1407 zip->lzstream_valid = 0; 1408 ret = ARCHIVE_EOF; 1409 break; 1410 case LZMA_OK: /* Decompressor made some progress. */ 1411 break; 1412 default: 1413 archive_set_error(&(a->archive), 1414 ARCHIVE_ERRNO_MISC, 1415 "Decompression failed(%d)", 1416 r); 1417 return (ARCHIVE_FAILED); 1418 } 1419 t_avail_in = zip->lzstream.avail_in; 1420 t_avail_out = zip->lzstream.avail_out; 1421 break; 1422 #endif 1423 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR) 1424 case _7Z_BZ2: 1425 zip->bzstream.next_in = (char *)(uintptr_t)t_next_in; 1426 zip->bzstream.avail_in = t_avail_in; 1427 zip->bzstream.next_out = (char *)(uintptr_t)t_next_out; 1428 zip->bzstream.avail_out = t_avail_out; 1429 r = BZ2_bzDecompress(&(zip->bzstream)); 1430 switch (r) { 1431 case BZ_STREAM_END: /* Found end of stream. */ 1432 switch (BZ2_bzDecompressEnd(&(zip->bzstream))) { 1433 case BZ_OK: 1434 break; 1435 default: 1436 archive_set_error(&(a->archive), 1437 ARCHIVE_ERRNO_MISC, 1438 "Failed to clean up decompressor"); 1439 return (ARCHIVE_FAILED); 1440 } 1441 zip->bzstream_valid = 0; 1442 ret = ARCHIVE_EOF; 1443 break; 1444 case BZ_OK: /* Decompressor made some progress. */ 1445 break; 1446 default: 1447 archive_set_error(&(a->archive), 1448 ARCHIVE_ERRNO_MISC, 1449 "bzip decompression failed"); 1450 return (ARCHIVE_FAILED); 1451 } 1452 t_avail_in = zip->bzstream.avail_in; 1453 t_avail_out = zip->bzstream.avail_out; 1454 break; 1455 #endif 1456 #ifdef HAVE_ZLIB_H 1457 case _7Z_DEFLATE: 1458 zip->stream.next_in = (Bytef *)(uintptr_t)t_next_in; 1459 zip->stream.avail_in = (uInt)t_avail_in; 1460 zip->stream.next_out = t_next_out; 1461 zip->stream.avail_out = (uInt)t_avail_out; 1462 r = inflate(&(zip->stream), 0); 1463 switch (r) { 1464 case Z_STREAM_END: /* Found end of stream. */ 1465 ret = ARCHIVE_EOF; 1466 break; 1467 case Z_OK: /* Decompressor made some progress.*/ 1468 break; 1469 default: 1470 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1471 "File decompression failed (%d)", r); 1472 return (ARCHIVE_FAILED); 1473 } 1474 t_avail_in = zip->stream.avail_in; 1475 t_avail_out = zip->stream.avail_out; 1476 break; 1477 #endif 1478 case _7Z_PPMD: 1479 { 1480 uint64_t flush_bytes; 1481 1482 if (!zip->ppmd7_valid || zip->ppmd7_stat < 0 || 1483 t_avail_out <= 0) { 1484 archive_set_error(&(a->archive), 1485 ARCHIVE_ERRNO_MISC, 1486 "Decompression internal error"); 1487 return (ARCHIVE_FAILED); 1488 } 1489 zip->ppstream.next_in = t_next_in; 1490 zip->ppstream.avail_in = t_avail_in; 1491 zip->ppstream.next_out = t_next_out; 1492 zip->ppstream.avail_out = t_avail_out; 1493 if (zip->ppmd7_stat == 0) { 1494 zip->bytein.a = a; 1495 zip->bytein.Read = &ppmd_read; 1496 zip->range_dec.Stream = &zip->bytein; 1497 r = __archive_ppmd7_functions.Ppmd7z_RangeDec_Init( 1498 &(zip->range_dec)); 1499 if (r == 0) { 1500 zip->ppmd7_stat = -1; 1501 archive_set_error(&a->archive, 1502 ARCHIVE_ERRNO_MISC, 1503 "Failed to initialize PPMd range decorder"); 1504 return (ARCHIVE_FAILED); 1505 } 1506 if (zip->ppstream.overconsumed) { 1507 zip->ppmd7_stat = -1; 1508 return (ARCHIVE_FAILED); 1509 } 1510 zip->ppmd7_stat = 1; 1511 } 1512 1513 if (t_avail_in == 0) 1514 /* XXX Flush out remaining decoded data XXX */ 1515 flush_bytes = zip->folder_outbytes_remaining; 1516 else 1517 flush_bytes = 0; 1518 1519 do { 1520 int sym; 1521 1522 sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol( 1523 &(zip->ppmd7_context), &(zip->range_dec.p)); 1524 if (sym < 0) { 1525 zip->ppmd7_stat = -1; 1526 archive_set_error(&a->archive, 1527 ARCHIVE_ERRNO_FILE_FORMAT, 1528 "Failed to decode PPMd"); 1529 return (ARCHIVE_FAILED); 1530 } 1531 if (zip->ppstream.overconsumed) { 1532 zip->ppmd7_stat = -1; 1533 return (ARCHIVE_FAILED); 1534 } 1535 *zip->ppstream.next_out++ = (unsigned char)sym; 1536 zip->ppstream.avail_out--; 1537 zip->ppstream.total_out++; 1538 if (flush_bytes) 1539 flush_bytes--; 1540 } while (zip->ppstream.avail_out && 1541 (zip->ppstream.avail_in || flush_bytes)); 1542 1543 t_avail_in = (size_t)zip->ppstream.avail_in; 1544 t_avail_out = (size_t)zip->ppstream.avail_out; 1545 break; 1546 } 1547 default: 1548 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC, 1549 "Decompression internal error"); 1550 return (ARCHIVE_FAILED); 1551 } 1552 if (ret != ARCHIVE_OK && ret != ARCHIVE_EOF) 1553 return (ret); 1554 1555 *used = o_avail_in - t_avail_in; 1556 *outbytes = o_avail_out - t_avail_out; 1557 1558 /* 1559 * Decord BCJ. 1560 */ 1561 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) { 1562 size_t l = x86_Convert(zip, buff, *outbytes); 1563 zip->odd_bcj_size = *outbytes - l; 1564 if (zip->odd_bcj_size > 0 && zip->odd_bcj_size <= 4 && 1565 o_avail_in && ret != ARCHIVE_EOF) { 1566 memcpy(zip->odd_bcj, ((unsigned char *)buff) + l, 1567 zip->odd_bcj_size); 1568 *outbytes = l; 1569 } else 1570 zip->odd_bcj_size = 0; 1571 } 1572 1573 /* 1574 * Decord BCJ2 with a decompressed main stream. 1575 */ 1576 if (zip->codec2 == _7Z_X86_BCJ2) { 1577 ssize_t bytes; 1578 1579 zip->tmp_stream_bytes_avail = 1580 zip->tmp_stream_buff_size - t_avail_out; 1581 if (zip->tmp_stream_bytes_avail > 1582 zip->main_stream_bytes_remaining) 1583 zip->tmp_stream_bytes_avail = 1584 zip->main_stream_bytes_remaining; 1585 zip->tmp_stream_bytes_remaining = zip->tmp_stream_bytes_avail; 1586 bytes = Bcj2_Decode(zip, bcj2_next_out, bcj2_avail_out); 1587 if (bytes < 0) { 1588 archive_set_error(&(a->archive), 1589 ARCHIVE_ERRNO_MISC, "BCJ2 conversion Failed"); 1590 return (ARCHIVE_FAILED); 1591 } 1592 zip->main_stream_bytes_remaining -= 1593 zip->tmp_stream_bytes_avail 1594 - zip->tmp_stream_bytes_remaining; 1595 bcj2_avail_out -= bytes; 1596 *outbytes = o_avail_out - bcj2_avail_out; 1597 } 1598 1599 return (ret); 1600 } 1601 1602 static int 1603 free_decompression(struct archive_read *a, struct _7zip *zip) 1604 { 1605 int r = ARCHIVE_OK; 1606 1607 #if !defined(HAVE_ZLIB_H) &&\ 1608 !(defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)) 1609 (void)a;/* UNUSED */ 1610 #endif 1611 #ifdef HAVE_LZMA_H 1612 if (zip->lzstream_valid) 1613 lzma_end(&(zip->lzstream)); 1614 #endif 1615 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR) 1616 if (zip->bzstream_valid) { 1617 if (BZ2_bzDecompressEnd(&(zip->bzstream)) != BZ_OK) { 1618 archive_set_error(&a->archive, 1619 ARCHIVE_ERRNO_MISC, 1620 "Failed to clean up bzip2 decompressor"); 1621 r = ARCHIVE_FATAL; 1622 } 1623 zip->bzstream_valid = 0; 1624 } 1625 #endif 1626 #ifdef HAVE_ZLIB_H 1627 if (zip->stream_valid) { 1628 if (inflateEnd(&(zip->stream)) != Z_OK) { 1629 archive_set_error(&a->archive, 1630 ARCHIVE_ERRNO_MISC, 1631 "Failed to clean up zlib decompressor"); 1632 r = ARCHIVE_FATAL; 1633 } 1634 zip->stream_valid = 0; 1635 } 1636 #endif 1637 if (zip->ppmd7_valid) { 1638 __archive_ppmd7_functions.Ppmd7_Free( 1639 &zip->ppmd7_context, &g_szalloc); 1640 zip->ppmd7_valid = 0; 1641 } 1642 return (r); 1643 } 1644 1645 static int 1646 parse_7zip_uint64(struct archive_read *a, uint64_t *val) 1647 { 1648 const unsigned char *p; 1649 unsigned char avail, mask; 1650 int i; 1651 1652 if ((p = header_bytes(a, 1)) == NULL) 1653 return (-1); 1654 avail = *p; 1655 mask = 0x80; 1656 *val = 0; 1657 for (i = 0; i < 8; i++) { 1658 if (avail & mask) { 1659 if ((p = header_bytes(a, 1)) == NULL) 1660 return (-1); 1661 *val |= ((uint64_t)*p) << (8 * i); 1662 mask >>= 1; 1663 continue; 1664 } 1665 *val += ((uint64_t)(avail & (mask -1))) << (8 * i); 1666 break; 1667 } 1668 return (0); 1669 } 1670 1671 static int 1672 read_Bools(struct archive_read *a, unsigned char *data, size_t num) 1673 { 1674 const unsigned char *p; 1675 unsigned i, mask = 0, avail = 0; 1676 1677 for (i = 0; i < num; i++) { 1678 if (mask == 0) { 1679 if ((p = header_bytes(a, 1)) == NULL) 1680 return (-1); 1681 avail = *p; 1682 mask = 0x80; 1683 } 1684 data[i] = (avail & mask)?1:0; 1685 mask >>= 1; 1686 } 1687 return (0); 1688 } 1689 1690 static void 1691 free_Digest(struct _7z_digests *d) 1692 { 1693 free(d->defineds); 1694 free(d->digests); 1695 } 1696 1697 static int 1698 read_Digests(struct archive_read *a, struct _7z_digests *d, size_t num) 1699 { 1700 const unsigned char *p; 1701 unsigned i; 1702 1703 if (num == 0) 1704 return (-1); 1705 memset(d, 0, sizeof(*d)); 1706 1707 d->defineds = malloc(num); 1708 if (d->defineds == NULL) 1709 return (-1); 1710 /* 1711 * Read Bools. 1712 */ 1713 if ((p = header_bytes(a, 1)) == NULL) 1714 return (-1); 1715 if (*p == 0) { 1716 if (read_Bools(a, d->defineds, num) < 0) 1717 return (-1); 1718 } else 1719 /* All are defined */ 1720 memset(d->defineds, 1, num); 1721 1722 d->digests = calloc(num, sizeof(*d->digests)); 1723 if (d->digests == NULL) 1724 return (-1); 1725 for (i = 0; i < num; i++) { 1726 if (d->defineds[i]) { 1727 if ((p = header_bytes(a, 4)) == NULL) 1728 return (-1); 1729 d->digests[i] = archive_le32dec(p); 1730 } 1731 } 1732 1733 return (0); 1734 } 1735 1736 static void 1737 free_PackInfo(struct _7z_pack_info *pi) 1738 { 1739 free(pi->sizes); 1740 free(pi->positions); 1741 free_Digest(&(pi->digest)); 1742 } 1743 1744 static int 1745 read_PackInfo(struct archive_read *a, struct _7z_pack_info *pi) 1746 { 1747 const unsigned char *p; 1748 unsigned i; 1749 1750 memset(pi, 0, sizeof(*pi)); 1751 1752 /* 1753 * Read PackPos. 1754 */ 1755 if (parse_7zip_uint64(a, &(pi->pos)) < 0) 1756 return (-1); 1757 1758 /* 1759 * Read NumPackStreams. 1760 */ 1761 if (parse_7zip_uint64(a, &(pi->numPackStreams)) < 0) 1762 return (-1); 1763 if (pi->numPackStreams == 0) 1764 return (-1); 1765 if (UMAX_ENTRY < pi->numPackStreams) 1766 return (-1); 1767 1768 /* 1769 * Read PackSizes[num] 1770 */ 1771 if ((p = header_bytes(a, 1)) == NULL) 1772 return (-1); 1773 if (*p == kEnd) 1774 /* PackSizes[num] are not present. */ 1775 return (0); 1776 if (*p != kSize) 1777 return (-1); 1778 pi->sizes = calloc((size_t)pi->numPackStreams, sizeof(uint64_t)); 1779 pi->positions = calloc((size_t)pi->numPackStreams, sizeof(uint64_t)); 1780 if (pi->sizes == NULL || pi->positions == NULL) 1781 return (-1); 1782 1783 for (i = 0; i < pi->numPackStreams; i++) { 1784 if (parse_7zip_uint64(a, &(pi->sizes[i])) < 0) 1785 return (-1); 1786 } 1787 1788 /* 1789 * Read PackStreamDigests[num] 1790 */ 1791 if ((p = header_bytes(a, 1)) == NULL) 1792 return (-1); 1793 if (*p == kEnd) { 1794 /* PackStreamDigests[num] are not present. */ 1795 pi->digest.defineds = 1796 calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.defineds)); 1797 pi->digest.digests = 1798 calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.digests)); 1799 if (pi->digest.defineds == NULL || pi->digest.digests == NULL) 1800 return (-1); 1801 return (0); 1802 } 1803 1804 if (*p != kSize) 1805 return (-1); 1806 1807 if (read_Digests(a, &(pi->digest), (size_t)pi->numPackStreams) < 0) 1808 return (-1); 1809 1810 /* 1811 * Must be marked by kEnd. 1812 */ 1813 if ((p = header_bytes(a, 1)) == NULL) 1814 return (-1); 1815 if (*p != kEnd) 1816 return (-1); 1817 return (0); 1818 } 1819 1820 static void 1821 free_Folder(struct _7z_folder *f) 1822 { 1823 unsigned i; 1824 1825 if (f->coders) { 1826 for (i = 0; i< f->numCoders; i++) { 1827 free(f->coders[i].properties); 1828 } 1829 free(f->coders); 1830 } 1831 free(f->bindPairs); 1832 free(f->packedStreams); 1833 free(f->unPackSize); 1834 } 1835 1836 static int 1837 read_Folder(struct archive_read *a, struct _7z_folder *f) 1838 { 1839 struct _7zip *zip = (struct _7zip *)a->format->data; 1840 const unsigned char *p; 1841 uint64_t numInStreamsTotal = 0; 1842 uint64_t numOutStreamsTotal = 0; 1843 unsigned i; 1844 1845 memset(f, 0, sizeof(*f)); 1846 1847 /* 1848 * Read NumCoders. 1849 */ 1850 if (parse_7zip_uint64(a, &(f->numCoders)) < 0) 1851 return (-1); 1852 if (f->numCoders > 4) 1853 /* Too many coders. */ 1854 return (-1); 1855 1856 f->coders = calloc((size_t)f->numCoders, sizeof(*f->coders)); 1857 if (f->coders == NULL) 1858 return (-1); 1859 for (i = 0; i< f->numCoders; i++) { 1860 size_t codec_size; 1861 int simple, attr; 1862 1863 if ((p = header_bytes(a, 1)) == NULL) 1864 return (-1); 1865 /* 1866 * 0:3 CodecIdSize 1867 * 4: 0 - IsSimple 1868 * 1 - Is not Simple 1869 * 5: 0 - No Attributes 1870 * 1 - There are Attributes; 1871 * 7: Must be zero. 1872 */ 1873 codec_size = *p & 0xf; 1874 simple = (*p & 0x10)?0:1; 1875 attr = *p & 0x20; 1876 if (*p & 0x80) 1877 return (-1);/* Not supported. */ 1878 1879 /* 1880 * Read Decompression Method IDs. 1881 */ 1882 if ((p = header_bytes(a, codec_size)) == NULL) 1883 return (-1); 1884 1885 f->coders[i].codec = decode_codec_id(p, codec_size); 1886 1887 if (simple) { 1888 f->coders[i].numInStreams = 1; 1889 f->coders[i].numOutStreams = 1; 1890 } else { 1891 if (parse_7zip_uint64( 1892 a, &(f->coders[i].numInStreams)) < 0) 1893 return (-1); 1894 if (UMAX_ENTRY < f->coders[i].numInStreams) 1895 return (-1); 1896 if (parse_7zip_uint64( 1897 a, &(f->coders[i].numOutStreams)) < 0) 1898 return (-1); 1899 if (UMAX_ENTRY < f->coders[i].numOutStreams) 1900 return (-1); 1901 } 1902 1903 if (attr) { 1904 if (parse_7zip_uint64( 1905 a, &(f->coders[i].propertiesSize)) < 0) 1906 return (-1); 1907 if ((p = header_bytes( 1908 a, (size_t)f->coders[i].propertiesSize)) == NULL) 1909 return (-1); 1910 f->coders[i].properties = 1911 malloc((size_t)f->coders[i].propertiesSize); 1912 if (f->coders[i].properties == NULL) 1913 return (-1); 1914 memcpy(f->coders[i].properties, p, 1915 (size_t)f->coders[i].propertiesSize); 1916 } 1917 1918 numInStreamsTotal += f->coders[i].numInStreams; 1919 numOutStreamsTotal += f->coders[i].numOutStreams; 1920 } 1921 1922 if (numOutStreamsTotal == 0 || 1923 numInStreamsTotal < numOutStreamsTotal-1) 1924 return (-1); 1925 1926 f->numBindPairs = numOutStreamsTotal - 1; 1927 if (zip->header_bytes_remaining < f->numBindPairs) 1928 return (-1); 1929 if (f->numBindPairs > 0) { 1930 f->bindPairs = 1931 calloc((size_t)f->numBindPairs, sizeof(*f->bindPairs)); 1932 if (f->bindPairs == NULL) 1933 return (-1); 1934 } else 1935 f->bindPairs = NULL; 1936 for (i = 0; i < f->numBindPairs; i++) { 1937 if (parse_7zip_uint64(a, &(f->bindPairs[i].inIndex)) < 0) 1938 return (-1); 1939 if (UMAX_ENTRY < f->bindPairs[i].inIndex) 1940 return (-1); 1941 if (parse_7zip_uint64(a, &(f->bindPairs[i].outIndex)) < 0) 1942 return (-1); 1943 if (UMAX_ENTRY < f->bindPairs[i].outIndex) 1944 return (-1); 1945 } 1946 1947 f->numPackedStreams = numInStreamsTotal - f->numBindPairs; 1948 f->packedStreams = 1949 calloc((size_t)f->numPackedStreams, sizeof(*f->packedStreams)); 1950 if (f->packedStreams == NULL) 1951 return (-1); 1952 if (f->numPackedStreams == 1) { 1953 for (i = 0; i < numInStreamsTotal; i++) { 1954 unsigned j; 1955 for (j = 0; j < f->numBindPairs; j++) { 1956 if (f->bindPairs[j].inIndex == i) 1957 break; 1958 } 1959 if (j == f->numBindPairs) 1960 break; 1961 } 1962 if (i == numInStreamsTotal) 1963 return (-1); 1964 f->packedStreams[0] = i; 1965 } else { 1966 for (i = 0; i < f->numPackedStreams; i++) { 1967 if (parse_7zip_uint64(a, &(f->packedStreams[i])) < 0) 1968 return (-1); 1969 if (UMAX_ENTRY < f->packedStreams[i]) 1970 return (-1); 1971 } 1972 } 1973 f->numInStreams = numInStreamsTotal; 1974 f->numOutStreams = numOutStreamsTotal; 1975 1976 return (0); 1977 } 1978 1979 static void 1980 free_CodersInfo(struct _7z_coders_info *ci) 1981 { 1982 unsigned i; 1983 1984 if (ci->folders) { 1985 for (i = 0; i < ci->numFolders; i++) 1986 free_Folder(&(ci->folders[i])); 1987 free(ci->folders); 1988 } 1989 } 1990 1991 static int 1992 read_CodersInfo(struct archive_read *a, struct _7z_coders_info *ci) 1993 { 1994 const unsigned char *p; 1995 struct _7z_digests digest; 1996 unsigned i; 1997 1998 memset(ci, 0, sizeof(*ci)); 1999 memset(&digest, 0, sizeof(digest)); 2000 2001 if ((p = header_bytes(a, 1)) == NULL) 2002 goto failed; 2003 if (*p != kFolder) 2004 goto failed; 2005 2006 /* 2007 * Read NumFolders. 2008 */ 2009 if (parse_7zip_uint64(a, &(ci->numFolders)) < 0) 2010 goto failed; 2011 if (UMAX_ENTRY < ci->numFolders) 2012 return (-1); 2013 2014 /* 2015 * Read External. 2016 */ 2017 if ((p = header_bytes(a, 1)) == NULL) 2018 goto failed; 2019 switch (*p) { 2020 case 0: 2021 ci->folders = 2022 calloc((size_t)ci->numFolders, sizeof(*ci->folders)); 2023 if (ci->folders == NULL) 2024 return (-1); 2025 for (i = 0; i < ci->numFolders; i++) { 2026 if (read_Folder(a, &(ci->folders[i])) < 0) 2027 goto failed; 2028 } 2029 break; 2030 case 1: 2031 if (parse_7zip_uint64(a, &(ci->dataStreamIndex)) < 0) 2032 return (-1); 2033 if (UMAX_ENTRY < ci->dataStreamIndex) 2034 return (-1); 2035 if (ci->numFolders > 0) { 2036 archive_set_error(&a->archive, -1, 2037 "Malformed 7-Zip archive"); 2038 goto failed; 2039 } 2040 break; 2041 default: 2042 archive_set_error(&a->archive, -1, 2043 "Malformed 7-Zip archive"); 2044 goto failed; 2045 } 2046 2047 if ((p = header_bytes(a, 1)) == NULL) 2048 goto failed; 2049 if (*p != kCodersUnPackSize) 2050 goto failed; 2051 2052 for (i = 0; i < ci->numFolders; i++) { 2053 struct _7z_folder *folder = &(ci->folders[i]); 2054 unsigned j; 2055 2056 folder->unPackSize = 2057 calloc((size_t)folder->numOutStreams, sizeof(*folder->unPackSize)); 2058 if (folder->unPackSize == NULL) 2059 goto failed; 2060 for (j = 0; j < folder->numOutStreams; j++) { 2061 if (parse_7zip_uint64(a, &(folder->unPackSize[j])) < 0) 2062 goto failed; 2063 } 2064 } 2065 2066 /* 2067 * Read CRCs. 2068 */ 2069 if ((p = header_bytes(a, 1)) == NULL) 2070 goto failed; 2071 if (*p == kEnd) 2072 return (0); 2073 if (*p != kCRC) 2074 goto failed; 2075 if (read_Digests(a, &digest, (size_t)ci->numFolders) < 0) 2076 goto failed; 2077 for (i = 0; i < ci->numFolders; i++) { 2078 ci->folders[i].digest_defined = digest.defineds[i]; 2079 ci->folders[i].digest = digest.digests[i]; 2080 } 2081 2082 /* 2083 * Must be kEnd. 2084 */ 2085 if ((p = header_bytes(a, 1)) == NULL) 2086 goto failed; 2087 if (*p != kEnd) 2088 goto failed; 2089 free_Digest(&digest); 2090 return (0); 2091 failed: 2092 free_Digest(&digest); 2093 return (-1); 2094 } 2095 2096 static uint64_t 2097 folder_uncompressed_size(struct _7z_folder *f) 2098 { 2099 int n = (int)f->numOutStreams; 2100 unsigned pairs = (unsigned)f->numBindPairs; 2101 2102 while (--n >= 0) { 2103 unsigned i; 2104 for (i = 0; i < pairs; i++) { 2105 if (f->bindPairs[i].outIndex == (uint64_t)n) 2106 break; 2107 } 2108 if (i >= pairs) 2109 return (f->unPackSize[n]); 2110 } 2111 return (0); 2112 } 2113 2114 static void 2115 free_SubStreamsInfo(struct _7z_substream_info *ss) 2116 { 2117 free(ss->unpackSizes); 2118 free(ss->digestsDefined); 2119 free(ss->digests); 2120 } 2121 2122 static int 2123 read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss, 2124 struct _7z_folder *f, size_t numFolders) 2125 { 2126 const unsigned char *p; 2127 uint64_t *usizes; 2128 size_t unpack_streams; 2129 int type; 2130 unsigned i; 2131 uint32_t numDigests; 2132 2133 memset(ss, 0, sizeof(*ss)); 2134 2135 for (i = 0; i < numFolders; i++) 2136 f[i].numUnpackStreams = 1; 2137 2138 if ((p = header_bytes(a, 1)) == NULL) 2139 return (-1); 2140 type = *p; 2141 2142 if (type == kNumUnPackStream) { 2143 unpack_streams = 0; 2144 for (i = 0; i < numFolders; i++) { 2145 if (parse_7zip_uint64(a, &(f[i].numUnpackStreams)) < 0) 2146 return (-1); 2147 if (UMAX_ENTRY < f[i].numUnpackStreams) 2148 return (-1); 2149 if (unpack_streams > SIZE_MAX - UMAX_ENTRY) { 2150 return (-1); 2151 } 2152 unpack_streams += (size_t)f[i].numUnpackStreams; 2153 } 2154 if ((p = header_bytes(a, 1)) == NULL) 2155 return (-1); 2156 type = *p; 2157 } else 2158 unpack_streams = numFolders; 2159 2160 ss->unpack_streams = unpack_streams; 2161 if (unpack_streams) { 2162 ss->unpackSizes = calloc(unpack_streams, 2163 sizeof(*ss->unpackSizes)); 2164 ss->digestsDefined = calloc(unpack_streams, 2165 sizeof(*ss->digestsDefined)); 2166 ss->digests = calloc(unpack_streams, 2167 sizeof(*ss->digests)); 2168 if (ss->unpackSizes == NULL || ss->digestsDefined == NULL || 2169 ss->digests == NULL) 2170 return (-1); 2171 } 2172 2173 usizes = ss->unpackSizes; 2174 for (i = 0; i < numFolders; i++) { 2175 unsigned pack; 2176 uint64_t sum; 2177 2178 if (f[i].numUnpackStreams == 0) 2179 continue; 2180 2181 sum = 0; 2182 if (type == kSize) { 2183 for (pack = 1; pack < f[i].numUnpackStreams; pack++) { 2184 if (parse_7zip_uint64(a, usizes) < 0) 2185 return (-1); 2186 sum += *usizes++; 2187 } 2188 } 2189 *usizes++ = folder_uncompressed_size(&f[i]) - sum; 2190 } 2191 2192 if (type == kSize) { 2193 if ((p = header_bytes(a, 1)) == NULL) 2194 return (-1); 2195 type = *p; 2196 } 2197 2198 for (i = 0; i < unpack_streams; i++) { 2199 ss->digestsDefined[i] = 0; 2200 ss->digests[i] = 0; 2201 } 2202 2203 numDigests = 0; 2204 for (i = 0; i < numFolders; i++) { 2205 if (f[i].numUnpackStreams != 1 || !f[i].digest_defined) 2206 numDigests += (uint32_t)f[i].numUnpackStreams; 2207 } 2208 2209 if (type == kCRC) { 2210 struct _7z_digests tmpDigests; 2211 unsigned char *digestsDefined = ss->digestsDefined; 2212 uint32_t * digests = ss->digests; 2213 int di = 0; 2214 2215 memset(&tmpDigests, 0, sizeof(tmpDigests)); 2216 if (read_Digests(a, &(tmpDigests), numDigests) < 0) { 2217 free_Digest(&tmpDigests); 2218 return (-1); 2219 } 2220 for (i = 0; i < numFolders; i++) { 2221 if (f[i].numUnpackStreams == 1 && f[i].digest_defined) { 2222 *digestsDefined++ = 1; 2223 *digests++ = f[i].digest; 2224 } else { 2225 unsigned j; 2226 2227 for (j = 0; j < f[i].numUnpackStreams; 2228 j++, di++) { 2229 *digestsDefined++ = 2230 tmpDigests.defineds[di]; 2231 *digests++ = 2232 tmpDigests.digests[di]; 2233 } 2234 } 2235 } 2236 free_Digest(&tmpDigests); 2237 if ((p = header_bytes(a, 1)) == NULL) 2238 return (-1); 2239 type = *p; 2240 } 2241 2242 /* 2243 * Must be kEnd. 2244 */ 2245 if (type != kEnd) 2246 return (-1); 2247 return (0); 2248 } 2249 2250 static void 2251 free_StreamsInfo(struct _7z_stream_info *si) 2252 { 2253 free_PackInfo(&(si->pi)); 2254 free_CodersInfo(&(si->ci)); 2255 free_SubStreamsInfo(&(si->ss)); 2256 } 2257 2258 static int 2259 read_StreamsInfo(struct archive_read *a, struct _7z_stream_info *si) 2260 { 2261 struct _7zip *zip = (struct _7zip *)a->format->data; 2262 const unsigned char *p; 2263 unsigned i; 2264 2265 memset(si, 0, sizeof(*si)); 2266 2267 if ((p = header_bytes(a, 1)) == NULL) 2268 return (-1); 2269 if (*p == kPackInfo) { 2270 uint64_t packPos; 2271 2272 if (read_PackInfo(a, &(si->pi)) < 0) 2273 return (-1); 2274 2275 if (si->pi.positions == NULL || si->pi.sizes == NULL) 2276 return (-1); 2277 /* 2278 * Calculate packed stream positions. 2279 */ 2280 packPos = si->pi.pos; 2281 for (i = 0; i < si->pi.numPackStreams; i++) { 2282 si->pi.positions[i] = packPos; 2283 packPos += si->pi.sizes[i]; 2284 if (packPos > zip->header_offset) 2285 return (-1); 2286 } 2287 if ((p = header_bytes(a, 1)) == NULL) 2288 return (-1); 2289 } 2290 if (*p == kUnPackInfo) { 2291 uint32_t packIndex; 2292 struct _7z_folder *f; 2293 2294 if (read_CodersInfo(a, &(si->ci)) < 0) 2295 return (-1); 2296 2297 /* 2298 * Calculate packed stream indexes. 2299 */ 2300 packIndex = 0; 2301 f = si->ci.folders; 2302 for (i = 0; i < si->ci.numFolders; i++) { 2303 f[i].packIndex = packIndex; 2304 packIndex += (uint32_t)f[i].numPackedStreams; 2305 if (packIndex > si->pi.numPackStreams) 2306 return (-1); 2307 } 2308 if ((p = header_bytes(a, 1)) == NULL) 2309 return (-1); 2310 } 2311 2312 if (*p == kSubStreamsInfo) { 2313 if (read_SubStreamsInfo(a, &(si->ss), 2314 si->ci.folders, (size_t)si->ci.numFolders) < 0) 2315 return (-1); 2316 if ((p = header_bytes(a, 1)) == NULL) 2317 return (-1); 2318 } 2319 2320 /* 2321 * Must be kEnd. 2322 */ 2323 if (*p != kEnd) 2324 return (-1); 2325 return (0); 2326 } 2327 2328 static void 2329 free_Header(struct _7z_header_info *h) 2330 { 2331 free(h->emptyStreamBools); 2332 free(h->emptyFileBools); 2333 free(h->antiBools); 2334 free(h->attrBools); 2335 } 2336 2337 static int 2338 read_Header(struct archive_read *a, struct _7z_header_info *h, 2339 int check_header_id) 2340 { 2341 struct _7zip *zip = (struct _7zip *)a->format->data; 2342 const unsigned char *p; 2343 struct _7z_folder *folders; 2344 struct _7z_stream_info *si = &(zip->si); 2345 struct _7zip_entry *entries; 2346 uint32_t folderIndex, indexInFolder; 2347 unsigned i; 2348 int eindex, empty_streams, sindex; 2349 2350 if (check_header_id) { 2351 /* 2352 * Read Header. 2353 */ 2354 if ((p = header_bytes(a, 1)) == NULL) 2355 return (-1); 2356 if (*p != kHeader) 2357 return (-1); 2358 } 2359 2360 /* 2361 * Read ArchiveProperties. 2362 */ 2363 if ((p = header_bytes(a, 1)) == NULL) 2364 return (-1); 2365 if (*p == kArchiveProperties) { 2366 for (;;) { 2367 uint64_t size; 2368 if ((p = header_bytes(a, 1)) == NULL) 2369 return (-1); 2370 if (*p == 0) 2371 break; 2372 if (parse_7zip_uint64(a, &size) < 0) 2373 return (-1); 2374 } 2375 if ((p = header_bytes(a, 1)) == NULL) 2376 return (-1); 2377 } 2378 2379 /* 2380 * Read MainStreamsInfo. 2381 */ 2382 if (*p == kMainStreamsInfo) { 2383 if (read_StreamsInfo(a, &(zip->si)) < 0) 2384 return (-1); 2385 if ((p = header_bytes(a, 1)) == NULL) 2386 return (-1); 2387 } 2388 if (*p == kEnd) 2389 return (0); 2390 2391 /* 2392 * Read FilesInfo. 2393 */ 2394 if (*p != kFilesInfo) 2395 return (-1); 2396 2397 if (parse_7zip_uint64(a, &(zip->numFiles)) < 0) 2398 return (-1); 2399 if (UMAX_ENTRY < zip->numFiles) 2400 return (-1); 2401 2402 zip->entries = calloc((size_t)zip->numFiles, sizeof(*zip->entries)); 2403 if (zip->entries == NULL) 2404 return (-1); 2405 entries = zip->entries; 2406 2407 empty_streams = 0; 2408 for (;;) { 2409 int type; 2410 uint64_t size; 2411 size_t ll; 2412 2413 if ((p = header_bytes(a, 1)) == NULL) 2414 return (-1); 2415 type = *p; 2416 if (type == kEnd) 2417 break; 2418 2419 if (parse_7zip_uint64(a, &size) < 0) 2420 return (-1); 2421 if (zip->header_bytes_remaining < size) 2422 return (-1); 2423 ll = (size_t)size; 2424 2425 switch (type) { 2426 case kEmptyStream: 2427 if (h->emptyStreamBools != NULL) 2428 return (-1); 2429 h->emptyStreamBools = calloc((size_t)zip->numFiles, 2430 sizeof(*h->emptyStreamBools)); 2431 if (h->emptyStreamBools == NULL) 2432 return (-1); 2433 if (read_Bools( 2434 a, h->emptyStreamBools, (size_t)zip->numFiles) < 0) 2435 return (-1); 2436 empty_streams = 0; 2437 for (i = 0; i < zip->numFiles; i++) { 2438 if (h->emptyStreamBools[i]) 2439 empty_streams++; 2440 } 2441 break; 2442 case kEmptyFile: 2443 if (empty_streams <= 0) { 2444 /* Unexcepted sequence. Skip this. */ 2445 if (header_bytes(a, ll) == NULL) 2446 return (-1); 2447 break; 2448 } 2449 if (h->emptyFileBools != NULL) 2450 return (-1); 2451 h->emptyFileBools = calloc(empty_streams, 2452 sizeof(*h->emptyFileBools)); 2453 if (h->emptyFileBools == NULL) 2454 return (-1); 2455 if (read_Bools(a, h->emptyFileBools, empty_streams) < 0) 2456 return (-1); 2457 break; 2458 case kAnti: 2459 if (empty_streams <= 0) { 2460 /* Unexcepted sequence. Skip this. */ 2461 if (header_bytes(a, ll) == NULL) 2462 return (-1); 2463 break; 2464 } 2465 if (h->antiBools != NULL) 2466 return (-1); 2467 h->antiBools = calloc(empty_streams, 2468 sizeof(*h->antiBools)); 2469 if (h->antiBools == NULL) 2470 return (-1); 2471 if (read_Bools(a, h->antiBools, empty_streams) < 0) 2472 return (-1); 2473 break; 2474 case kCTime: 2475 case kATime: 2476 case kMTime: 2477 if (read_Times(a, h, type) < 0) 2478 return (-1); 2479 break; 2480 case kName: 2481 { 2482 unsigned char *np; 2483 size_t nl, nb; 2484 2485 /* Skip one byte. */ 2486 if ((p = header_bytes(a, 1)) == NULL) 2487 return (-1); 2488 ll--; 2489 2490 if ((ll & 1) || ll < zip->numFiles * 4) 2491 return (-1); 2492 2493 if (zip->entry_names != NULL) 2494 return (-1); 2495 zip->entry_names = malloc(ll); 2496 if (zip->entry_names == NULL) 2497 return (-1); 2498 np = zip->entry_names; 2499 nb = ll; 2500 /* 2501 * Copy whole file names. 2502 * NOTE: This loop prevents from expanding 2503 * the uncompressed buffer in order not to 2504 * use extra memory resource. 2505 */ 2506 while (nb) { 2507 size_t b; 2508 if (nb > UBUFF_SIZE) 2509 b = UBUFF_SIZE; 2510 else 2511 b = nb; 2512 if ((p = header_bytes(a, b)) == NULL) 2513 return (-1); 2514 memcpy(np, p, b); 2515 np += b; 2516 nb -= b; 2517 } 2518 np = zip->entry_names; 2519 nl = ll; 2520 2521 for (i = 0; i < zip->numFiles; i++) { 2522 entries[i].utf16name = np; 2523 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG) 2524 entries[i].wname = (wchar_t *)np; 2525 #endif 2526 2527 /* Find a terminator. */ 2528 while (nl >= 2 && (np[0] || np[1])) { 2529 np += 2; 2530 nl -= 2; 2531 } 2532 if (nl < 2) 2533 return (-1);/* Terminator not found */ 2534 entries[i].name_len = np - entries[i].utf16name; 2535 np += 2; 2536 nl -= 2; 2537 } 2538 break; 2539 } 2540 case kAttributes: 2541 { 2542 int allAreDefined; 2543 2544 if ((p = header_bytes(a, 2)) == NULL) 2545 return (-1); 2546 allAreDefined = *p; 2547 if (h->attrBools != NULL) 2548 return (-1); 2549 h->attrBools = calloc((size_t)zip->numFiles, 2550 sizeof(*h->attrBools)); 2551 if (h->attrBools == NULL) 2552 return (-1); 2553 if (allAreDefined) 2554 memset(h->attrBools, 1, (size_t)zip->numFiles); 2555 else { 2556 if (read_Bools(a, h->attrBools, 2557 (size_t)zip->numFiles) < 0) 2558 return (-1); 2559 } 2560 for (i = 0; i < zip->numFiles; i++) { 2561 if (h->attrBools[i]) { 2562 if ((p = header_bytes(a, 4)) == NULL) 2563 return (-1); 2564 entries[i].attr = archive_le32dec(p); 2565 } 2566 } 2567 break; 2568 } 2569 case kDummy: 2570 if (ll == 0) 2571 break; 2572 default: 2573 if (header_bytes(a, ll) == NULL) 2574 return (-1); 2575 break; 2576 } 2577 } 2578 2579 /* 2580 * Set up entry's attributes. 2581 */ 2582 folders = si->ci.folders; 2583 eindex = sindex = 0; 2584 folderIndex = indexInFolder = 0; 2585 for (i = 0; i < zip->numFiles; i++) { 2586 if (h->emptyStreamBools == NULL || h->emptyStreamBools[i] == 0) 2587 entries[i].flg |= HAS_STREAM; 2588 /* The high 16 bits of attributes is a posix file mode. */ 2589 entries[i].mode = entries[i].attr >> 16; 2590 if (entries[i].flg & HAS_STREAM) { 2591 if ((size_t)sindex >= si->ss.unpack_streams) 2592 return (-1); 2593 if (entries[i].mode == 0) 2594 entries[i].mode = AE_IFREG | 0666; 2595 if (si->ss.digestsDefined[sindex]) 2596 entries[i].flg |= CRC32_IS_SET; 2597 entries[i].ssIndex = sindex; 2598 sindex++; 2599 } else { 2600 int dir; 2601 if (h->emptyFileBools == NULL) 2602 dir = 1; 2603 else { 2604 if (h->emptyFileBools[eindex]) 2605 dir = 0; 2606 else 2607 dir = 1; 2608 eindex++; 2609 } 2610 if (entries[i].mode == 0) { 2611 if (dir) 2612 entries[i].mode = AE_IFDIR | 0777; 2613 else 2614 entries[i].mode = AE_IFREG | 0666; 2615 } else if (dir && 2616 (entries[i].mode & AE_IFMT) != AE_IFDIR) { 2617 entries[i].mode &= ~AE_IFMT; 2618 entries[i].mode |= AE_IFDIR; 2619 } 2620 if ((entries[i].mode & AE_IFMT) == AE_IFDIR && 2621 entries[i].name_len >= 2 && 2622 (entries[i].utf16name[entries[i].name_len-2] != '/' || 2623 entries[i].utf16name[entries[i].name_len-1] != 0)) { 2624 entries[i].utf16name[entries[i].name_len] = '/'; 2625 entries[i].utf16name[entries[i].name_len+1] = 0; 2626 entries[i].name_len += 2; 2627 } 2628 entries[i].ssIndex = -1; 2629 } 2630 if (entries[i].attr & 0x01) 2631 entries[i].mode &= ~0222;/* Read only. */ 2632 2633 if ((entries[i].flg & HAS_STREAM) == 0 && indexInFolder == 0) { 2634 /* 2635 * The entry is an empty file or a directory file, 2636 * those both have no contents. 2637 */ 2638 entries[i].folderIndex = -1; 2639 continue; 2640 } 2641 if (indexInFolder == 0) { 2642 for (;;) { 2643 if (folderIndex >= si->ci.numFolders) 2644 return (-1); 2645 if (folders[folderIndex].numUnpackStreams) 2646 break; 2647 folderIndex++; 2648 } 2649 } 2650 entries[i].folderIndex = folderIndex; 2651 if ((entries[i].flg & HAS_STREAM) == 0) 2652 continue; 2653 indexInFolder++; 2654 if (indexInFolder >= folders[folderIndex].numUnpackStreams) { 2655 folderIndex++; 2656 indexInFolder = 0; 2657 } 2658 } 2659 2660 return (0); 2661 } 2662 2663 #define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000) 2664 static void 2665 fileTimeToUtc(uint64_t fileTime, time_t *timep, long *ns) 2666 { 2667 2668 if (fileTime >= EPOC_TIME) { 2669 fileTime -= EPOC_TIME; 2670 /* milli seconds base */ 2671 *timep = (time_t)(fileTime / 10000000); 2672 /* nano seconds base */ 2673 *ns = (long)(fileTime % 10000000) * 100; 2674 } else { 2675 *timep = 0; 2676 *ns = 0; 2677 } 2678 } 2679 2680 static int 2681 read_Times(struct archive_read *a, struct _7z_header_info *h, int type) 2682 { 2683 struct _7zip *zip = (struct _7zip *)a->format->data; 2684 const unsigned char *p; 2685 struct _7zip_entry *entries = zip->entries; 2686 unsigned char *timeBools; 2687 int allAreDefined; 2688 unsigned i; 2689 2690 timeBools = calloc((size_t)zip->numFiles, sizeof(*timeBools)); 2691 if (timeBools == NULL) 2692 return (-1); 2693 2694 /* Read allAreDefined. */ 2695 if ((p = header_bytes(a, 1)) == NULL) 2696 goto failed; 2697 allAreDefined = *p; 2698 if (allAreDefined) 2699 memset(timeBools, 1, (size_t)zip->numFiles); 2700 else { 2701 if (read_Bools(a, timeBools, (size_t)zip->numFiles) < 0) 2702 goto failed; 2703 } 2704 2705 /* Read external. */ 2706 if ((p = header_bytes(a, 1)) == NULL) 2707 goto failed; 2708 if (*p) { 2709 if (parse_7zip_uint64(a, &(h->dataIndex)) < 0) 2710 goto failed; 2711 if (UMAX_ENTRY < h->dataIndex) 2712 goto failed; 2713 } 2714 2715 for (i = 0; i < zip->numFiles; i++) { 2716 if (!timeBools[i]) 2717 continue; 2718 if ((p = header_bytes(a, 8)) == NULL) 2719 goto failed; 2720 switch (type) { 2721 case kCTime: 2722 fileTimeToUtc(archive_le64dec(p), 2723 &(entries[i].ctime), 2724 &(entries[i].ctime_ns)); 2725 entries[i].flg |= CTIME_IS_SET; 2726 break; 2727 case kATime: 2728 fileTimeToUtc(archive_le64dec(p), 2729 &(entries[i].atime), 2730 &(entries[i].atime_ns)); 2731 entries[i].flg |= ATIME_IS_SET; 2732 break; 2733 case kMTime: 2734 fileTimeToUtc(archive_le64dec(p), 2735 &(entries[i].mtime), 2736 &(entries[i].mtime_ns)); 2737 entries[i].flg |= MTIME_IS_SET; 2738 break; 2739 } 2740 } 2741 2742 free(timeBools); 2743 return (0); 2744 failed: 2745 free(timeBools); 2746 return (-1); 2747 } 2748 2749 static int 2750 decode_encoded_header_info(struct archive_read *a, struct _7z_stream_info *si) 2751 { 2752 struct _7zip *zip = (struct _7zip *)a->format->data; 2753 2754 errno = 0; 2755 if (read_StreamsInfo(a, si) < 0) { 2756 if (errno == ENOMEM) 2757 archive_set_error(&a->archive, -1, 2758 "Couldn't allocate memory"); 2759 else 2760 archive_set_error(&a->archive, -1, 2761 "Malformed 7-Zip archive"); 2762 return (ARCHIVE_FATAL); 2763 } 2764 2765 if (si->pi.numPackStreams == 0 || si->ci.numFolders == 0) { 2766 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive"); 2767 return (ARCHIVE_FATAL); 2768 } 2769 2770 if (zip->header_offset < si->pi.pos + si->pi.sizes[0] || 2771 (int64_t)(si->pi.pos + si->pi.sizes[0]) < 0 || 2772 si->pi.sizes[0] == 0 || (int64_t)si->pi.pos < 0) { 2773 archive_set_error(&a->archive, -1, "Malformed Header offset"); 2774 return (ARCHIVE_FATAL); 2775 } 2776 2777 return (ARCHIVE_OK); 2778 } 2779 2780 static const unsigned char * 2781 header_bytes(struct archive_read *a, size_t rbytes) 2782 { 2783 struct _7zip *zip = (struct _7zip *)a->format->data; 2784 const unsigned char *p; 2785 2786 if (zip->header_bytes_remaining < rbytes) 2787 return (NULL); 2788 if (zip->pack_stream_bytes_unconsumed) 2789 read_consume(a); 2790 2791 if (zip->header_is_encoded == 0) { 2792 p = __archive_read_ahead(a, rbytes, NULL); 2793 if (p == NULL) 2794 return (NULL); 2795 zip->header_bytes_remaining -= rbytes; 2796 zip->pack_stream_bytes_unconsumed = rbytes; 2797 } else { 2798 const void *buff; 2799 ssize_t bytes; 2800 2801 bytes = read_stream(a, &buff, rbytes, rbytes); 2802 if (bytes <= 0) 2803 return (NULL); 2804 zip->header_bytes_remaining -= bytes; 2805 p = buff; 2806 } 2807 2808 /* Update checksum */ 2809 zip->header_crc32 = crc32(zip->header_crc32, p, (unsigned)rbytes); 2810 return (p); 2811 } 2812 2813 static int 2814 slurp_central_directory(struct archive_read *a, struct _7zip *zip, 2815 struct _7z_header_info *header) 2816 { 2817 const unsigned char *p; 2818 uint64_t next_header_offset; 2819 uint64_t next_header_size; 2820 uint32_t next_header_crc; 2821 ssize_t bytes_avail; 2822 int check_header_crc, r; 2823 2824 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL) 2825 return (ARCHIVE_FATAL); 2826 2827 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) { 2828 /* This is an executable ? Must be self-extracting... */ 2829 r = skip_sfx(a, bytes_avail); 2830 if (r < ARCHIVE_WARN) 2831 return (r); 2832 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL) 2833 return (ARCHIVE_FATAL); 2834 } 2835 zip->seek_base += 32; 2836 2837 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0) { 2838 archive_set_error(&a->archive, -1, "Not 7-Zip archive file"); 2839 return (ARCHIVE_FATAL); 2840 } 2841 2842 /* CRC check. */ 2843 if (crc32(0, (const unsigned char *)p + 12, 20) 2844 != archive_le32dec(p + 8)) { 2845 archive_set_error(&a->archive, -1, "Header CRC error"); 2846 return (ARCHIVE_FATAL); 2847 } 2848 2849 next_header_offset = archive_le64dec(p + 12); 2850 next_header_size = archive_le64dec(p + 20); 2851 next_header_crc = archive_le32dec(p + 28); 2852 2853 if (next_header_size == 0) 2854 /* There is no entry in an archive file. */ 2855 return (ARCHIVE_EOF); 2856 2857 if (((int64_t)next_header_offset) < 0) { 2858 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive"); 2859 return (ARCHIVE_FATAL); 2860 } 2861 __archive_read_consume(a, 32); 2862 if (next_header_offset != 0) { 2863 if (bytes_avail >= (ssize_t)next_header_offset) 2864 __archive_read_consume(a, next_header_offset); 2865 else if (__archive_read_seek(a, 2866 next_header_offset + zip->seek_base, SEEK_SET) < 0) 2867 return (ARCHIVE_FATAL); 2868 } 2869 zip->stream_offset = next_header_offset; 2870 zip->header_offset = next_header_offset; 2871 zip->header_bytes_remaining = next_header_size; 2872 zip->header_crc32 = 0; 2873 zip->header_is_encoded = 0; 2874 zip->header_is_being_read = 1; 2875 zip->has_encrypted_entries = 0; 2876 check_header_crc = 1; 2877 2878 if ((p = header_bytes(a, 1)) == NULL) { 2879 archive_set_error(&a->archive, 2880 ARCHIVE_ERRNO_FILE_FORMAT, 2881 "Truncated 7-Zip file body"); 2882 return (ARCHIVE_FATAL); 2883 } 2884 /* Parse ArchiveProperties. */ 2885 switch (p[0]) { 2886 case kEncodedHeader: 2887 /* 2888 * The archive has an encoded header and we have to decode it 2889 * in order to parse the header correctly. 2890 */ 2891 r = decode_encoded_header_info(a, &(zip->si)); 2892 2893 /* Check the EncodedHeader CRC.*/ 2894 if (r == 0 && zip->header_crc32 != next_header_crc) { 2895 archive_set_error(&a->archive, -1, 2896 "Damaged 7-Zip archive"); 2897 r = -1; 2898 } 2899 if (r == 0) { 2900 if (zip->si.ci.folders[0].digest_defined) 2901 next_header_crc = zip->si.ci.folders[0].digest; 2902 else 2903 check_header_crc = 0; 2904 if (zip->pack_stream_bytes_unconsumed) 2905 read_consume(a); 2906 r = setup_decode_folder(a, zip->si.ci.folders, 1); 2907 if (r == 0) { 2908 zip->header_bytes_remaining = 2909 zip->folder_outbytes_remaining; 2910 r = seek_pack(a); 2911 } 2912 } 2913 /* Clean up StreamsInfo. */ 2914 free_StreamsInfo(&(zip->si)); 2915 memset(&(zip->si), 0, sizeof(zip->si)); 2916 if (r < 0) 2917 return (ARCHIVE_FATAL); 2918 zip->header_is_encoded = 1; 2919 zip->header_crc32 = 0; 2920 /* FALL THROUGH */ 2921 case kHeader: 2922 /* 2923 * Parse the header. 2924 */ 2925 errno = 0; 2926 r = read_Header(a, header, zip->header_is_encoded); 2927 if (r < 0) { 2928 if (errno == ENOMEM) 2929 archive_set_error(&a->archive, -1, 2930 "Couldn't allocate memory"); 2931 else 2932 archive_set_error(&a->archive, -1, 2933 "Damaged 7-Zip archive"); 2934 return (ARCHIVE_FATAL); 2935 } 2936 2937 /* 2938 * Must be kEnd. 2939 */ 2940 if ((p = header_bytes(a, 1)) == NULL ||*p != kEnd) { 2941 archive_set_error(&a->archive, -1, 2942 "Malformed 7-Zip archive"); 2943 return (ARCHIVE_FATAL); 2944 } 2945 2946 /* Check the Header CRC.*/ 2947 if (check_header_crc && zip->header_crc32 != next_header_crc) { 2948 archive_set_error(&a->archive, -1, 2949 "Malformed 7-Zip archive"); 2950 return (ARCHIVE_FATAL); 2951 } 2952 break; 2953 default: 2954 archive_set_error(&a->archive, -1, 2955 "Unexpected Property ID = %X", p[0]); 2956 return (ARCHIVE_FATAL); 2957 } 2958 2959 /* Clean up variables be used for decoding the archive header */ 2960 zip->pack_stream_remaining = 0; 2961 zip->pack_stream_index = 0; 2962 zip->folder_outbytes_remaining = 0; 2963 zip->uncompressed_buffer_bytes_remaining = 0; 2964 zip->pack_stream_bytes_unconsumed = 0; 2965 zip->header_is_being_read = 0; 2966 2967 return (ARCHIVE_OK); 2968 } 2969 2970 static ssize_t 2971 get_uncompressed_data(struct archive_read *a, const void **buff, size_t size, 2972 size_t minimum) 2973 { 2974 struct _7zip *zip = (struct _7zip *)a->format->data; 2975 ssize_t bytes_avail; 2976 2977 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) { 2978 /* Copy mode. */ 2979 2980 /* 2981 * Note: '1' here is a performance optimization. 2982 * Recall that the decompression layer returns a count of 2983 * available bytes; asking for more than that forces the 2984 * decompressor to combine reads by copying data. 2985 */ 2986 *buff = __archive_read_ahead(a, 1, &bytes_avail); 2987 if (bytes_avail <= 0) { 2988 archive_set_error(&a->archive, 2989 ARCHIVE_ERRNO_FILE_FORMAT, 2990 "Truncated 7-Zip file data"); 2991 return (ARCHIVE_FATAL); 2992 } 2993 if ((size_t)bytes_avail > 2994 zip->uncompressed_buffer_bytes_remaining) 2995 bytes_avail = (ssize_t) 2996 zip->uncompressed_buffer_bytes_remaining; 2997 if ((size_t)bytes_avail > size) 2998 bytes_avail = (ssize_t)size; 2999 3000 zip->pack_stream_bytes_unconsumed = bytes_avail; 3001 } else if (zip->uncompressed_buffer_pointer == NULL) { 3002 /* Decompression has failed. */ 3003 archive_set_error(&(a->archive), 3004 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive"); 3005 return (ARCHIVE_FATAL); 3006 } else { 3007 /* Packed mode. */ 3008 if (minimum > zip->uncompressed_buffer_bytes_remaining) { 3009 /* 3010 * If remaining uncompressed data size is less than 3011 * the minimum size, fill the buffer up to the 3012 * minimum size. 3013 */ 3014 if (extract_pack_stream(a, minimum) < 0) 3015 return (ARCHIVE_FATAL); 3016 } 3017 if (size > zip->uncompressed_buffer_bytes_remaining) 3018 bytes_avail = (ssize_t) 3019 zip->uncompressed_buffer_bytes_remaining; 3020 else 3021 bytes_avail = (ssize_t)size; 3022 *buff = zip->uncompressed_buffer_pointer; 3023 zip->uncompressed_buffer_pointer += bytes_avail; 3024 } 3025 zip->uncompressed_buffer_bytes_remaining -= bytes_avail; 3026 return (bytes_avail); 3027 } 3028 3029 static ssize_t 3030 extract_pack_stream(struct archive_read *a, size_t minimum) 3031 { 3032 struct _7zip *zip = (struct _7zip *)a->format->data; 3033 ssize_t bytes_avail; 3034 int r; 3035 3036 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) { 3037 if (minimum == 0) 3038 minimum = 1; 3039 if (__archive_read_ahead(a, minimum, &bytes_avail) == NULL 3040 || bytes_avail <= 0) { 3041 archive_set_error(&a->archive, 3042 ARCHIVE_ERRNO_FILE_FORMAT, 3043 "Truncated 7-Zip file body"); 3044 return (ARCHIVE_FATAL); 3045 } 3046 if (bytes_avail > (ssize_t)zip->pack_stream_inbytes_remaining) 3047 bytes_avail = (ssize_t)zip->pack_stream_inbytes_remaining; 3048 zip->pack_stream_inbytes_remaining -= bytes_avail; 3049 if (bytes_avail > (ssize_t)zip->folder_outbytes_remaining) 3050 bytes_avail = (ssize_t)zip->folder_outbytes_remaining; 3051 zip->folder_outbytes_remaining -= bytes_avail; 3052 zip->uncompressed_buffer_bytes_remaining = bytes_avail; 3053 return (ARCHIVE_OK); 3054 } 3055 3056 /* If the buffer hasn't been allocated, allocate it now. */ 3057 if (zip->uncompressed_buffer == NULL) { 3058 zip->uncompressed_buffer_size = UBUFF_SIZE; 3059 if (zip->uncompressed_buffer_size < minimum) { 3060 zip->uncompressed_buffer_size = minimum + 1023; 3061 zip->uncompressed_buffer_size &= ~0x3ff; 3062 } 3063 zip->uncompressed_buffer = 3064 malloc(zip->uncompressed_buffer_size); 3065 if (zip->uncompressed_buffer == NULL) { 3066 archive_set_error(&a->archive, ENOMEM, 3067 "No memory for 7-Zip decompression"); 3068 return (ARCHIVE_FATAL); 3069 } 3070 zip->uncompressed_buffer_bytes_remaining = 0; 3071 } else if (zip->uncompressed_buffer_size < minimum || 3072 zip->uncompressed_buffer_bytes_remaining < minimum) { 3073 /* 3074 * Make sure the uncompressed buffer can have bytes 3075 * at least `minimum' bytes. 3076 * NOTE: This case happen when reading the header. 3077 */ 3078 size_t used; 3079 if (zip->uncompressed_buffer_pointer != 0) 3080 used = zip->uncompressed_buffer_pointer - 3081 zip->uncompressed_buffer; 3082 else 3083 used = 0; 3084 if (zip->uncompressed_buffer_size < minimum) { 3085 /* 3086 * Expand the uncompressed buffer up to 3087 * the minimum size. 3088 */ 3089 void *p; 3090 size_t new_size; 3091 3092 new_size = minimum + 1023; 3093 new_size &= ~0x3ff; 3094 p = realloc(zip->uncompressed_buffer, new_size); 3095 if (p == NULL) { 3096 archive_set_error(&a->archive, ENOMEM, 3097 "No memory for 7-Zip decompression"); 3098 return (ARCHIVE_FATAL); 3099 } 3100 zip->uncompressed_buffer = (unsigned char *)p; 3101 zip->uncompressed_buffer_size = new_size; 3102 } 3103 /* 3104 * Move unconsumed bytes to the head. 3105 */ 3106 if (used) { 3107 memmove(zip->uncompressed_buffer, 3108 zip->uncompressed_buffer + used, 3109 zip->uncompressed_buffer_bytes_remaining); 3110 } 3111 } else 3112 zip->uncompressed_buffer_bytes_remaining = 0; 3113 zip->uncompressed_buffer_pointer = NULL; 3114 for (;;) { 3115 size_t bytes_in, bytes_out; 3116 const void *buff_in; 3117 unsigned char *buff_out; 3118 int end_of_data; 3119 3120 /* 3121 * Note: '1' here is a performance optimization. 3122 * Recall that the decompression layer returns a count of 3123 * available bytes; asking for more than that forces the 3124 * decompressor to combine reads by copying data. 3125 */ 3126 buff_in = __archive_read_ahead(a, 1, &bytes_avail); 3127 if (bytes_avail <= 0) { 3128 archive_set_error(&a->archive, 3129 ARCHIVE_ERRNO_FILE_FORMAT, 3130 "Truncated 7-Zip file body"); 3131 return (ARCHIVE_FATAL); 3132 } 3133 3134 buff_out = zip->uncompressed_buffer 3135 + zip->uncompressed_buffer_bytes_remaining; 3136 bytes_out = zip->uncompressed_buffer_size 3137 - zip->uncompressed_buffer_bytes_remaining; 3138 bytes_in = bytes_avail; 3139 if (bytes_in > zip->pack_stream_inbytes_remaining) 3140 bytes_in = (size_t)zip->pack_stream_inbytes_remaining; 3141 /* Drive decompression. */ 3142 r = decompress(a, zip, buff_out, &bytes_out, 3143 buff_in, &bytes_in); 3144 switch (r) { 3145 case ARCHIVE_OK: 3146 end_of_data = 0; 3147 break; 3148 case ARCHIVE_EOF: 3149 end_of_data = 1; 3150 break; 3151 default: 3152 return (ARCHIVE_FATAL); 3153 } 3154 zip->pack_stream_inbytes_remaining -= bytes_in; 3155 if (bytes_out > zip->folder_outbytes_remaining) 3156 bytes_out = (size_t)zip->folder_outbytes_remaining; 3157 zip->folder_outbytes_remaining -= bytes_out; 3158 zip->uncompressed_buffer_bytes_remaining += bytes_out; 3159 zip->pack_stream_bytes_unconsumed = bytes_in; 3160 3161 /* 3162 * Continue decompression until uncompressed_buffer is full. 3163 */ 3164 if (zip->uncompressed_buffer_bytes_remaining == 3165 zip->uncompressed_buffer_size) 3166 break; 3167 if (zip->codec2 == _7Z_X86 && zip->odd_bcj_size && 3168 zip->uncompressed_buffer_bytes_remaining + 5 > 3169 zip->uncompressed_buffer_size) 3170 break; 3171 if (zip->pack_stream_inbytes_remaining == 0 && 3172 zip->folder_outbytes_remaining == 0) 3173 break; 3174 if (end_of_data || (bytes_in == 0 && bytes_out == 0)) { 3175 archive_set_error(&(a->archive), 3176 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive"); 3177 return (ARCHIVE_FATAL); 3178 } 3179 read_consume(a); 3180 } 3181 if (zip->uncompressed_buffer_bytes_remaining < minimum) { 3182 archive_set_error(&(a->archive), 3183 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive"); 3184 return (ARCHIVE_FATAL); 3185 } 3186 zip->uncompressed_buffer_pointer = zip->uncompressed_buffer; 3187 return (ARCHIVE_OK); 3188 } 3189 3190 static int 3191 seek_pack(struct archive_read *a) 3192 { 3193 struct _7zip *zip = (struct _7zip *)a->format->data; 3194 int64_t pack_offset; 3195 3196 if (zip->pack_stream_remaining <= 0) { 3197 archive_set_error(&(a->archive), 3198 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive"); 3199 return (ARCHIVE_FATAL); 3200 } 3201 zip->pack_stream_inbytes_remaining = 3202 zip->si.pi.sizes[zip->pack_stream_index]; 3203 pack_offset = zip->si.pi.positions[zip->pack_stream_index]; 3204 if (zip->stream_offset != pack_offset) { 3205 if (0 > __archive_read_seek(a, pack_offset + zip->seek_base, 3206 SEEK_SET)) 3207 return (ARCHIVE_FATAL); 3208 zip->stream_offset = pack_offset; 3209 } 3210 zip->pack_stream_index++; 3211 zip->pack_stream_remaining--; 3212 return (ARCHIVE_OK); 3213 } 3214 3215 static ssize_t 3216 read_stream(struct archive_read *a, const void **buff, size_t size, 3217 size_t minimum) 3218 { 3219 struct _7zip *zip = (struct _7zip *)a->format->data; 3220 uint64_t skip_bytes = 0; 3221 ssize_t r; 3222 3223 if (zip->uncompressed_buffer_bytes_remaining == 0) { 3224 if (zip->pack_stream_inbytes_remaining > 0) { 3225 r = extract_pack_stream(a, 0); 3226 if (r < 0) 3227 return (r); 3228 return (get_uncompressed_data(a, buff, size, minimum)); 3229 } else if (zip->folder_outbytes_remaining > 0) { 3230 /* Extract a remaining pack stream. */ 3231 r = extract_pack_stream(a, 0); 3232 if (r < 0) 3233 return (r); 3234 return (get_uncompressed_data(a, buff, size, minimum)); 3235 } 3236 } else 3237 return (get_uncompressed_data(a, buff, size, minimum)); 3238 3239 /* 3240 * Current pack stream has been consumed. 3241 */ 3242 if (zip->pack_stream_remaining == 0) { 3243 if (zip->header_is_being_read) { 3244 /* Invalid sequence. This might happen when 3245 * reading a malformed archive. */ 3246 archive_set_error(&(a->archive), 3247 ARCHIVE_ERRNO_MISC, "Malformed 7-Zip archive"); 3248 return (ARCHIVE_FATAL); 3249 } 3250 3251 /* 3252 * All current folder's pack streams have been 3253 * consumed. Switch to next folder. 3254 */ 3255 if (zip->folder_index == 0 && 3256 (zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes 3257 || zip->folder_index != zip->entry->folderIndex)) { 3258 zip->folder_index = zip->entry->folderIndex; 3259 skip_bytes = 3260 zip->si.ci.folders[zip->folder_index].skipped_bytes; 3261 } 3262 3263 if (zip->folder_index >= zip->si.ci.numFolders) { 3264 /* 3265 * We have consumed all folders and its pack streams. 3266 */ 3267 *buff = NULL; 3268 return (0); 3269 } 3270 r = setup_decode_folder(a, 3271 &(zip->si.ci.folders[zip->folder_index]), 0); 3272 if (r != ARCHIVE_OK) 3273 return (ARCHIVE_FATAL); 3274 3275 zip->folder_index++; 3276 } 3277 3278 /* 3279 * Switch to next pack stream. 3280 */ 3281 r = seek_pack(a); 3282 if (r < 0) 3283 return (r); 3284 3285 /* Extract a new pack stream. */ 3286 r = extract_pack_stream(a, 0); 3287 if (r < 0) 3288 return (r); 3289 3290 /* 3291 * Skip the bytes we already has skipped in skip_stream(). 3292 */ 3293 while (skip_bytes) { 3294 ssize_t skipped; 3295 3296 if (zip->uncompressed_buffer_bytes_remaining == 0) { 3297 if (zip->pack_stream_inbytes_remaining > 0) { 3298 r = extract_pack_stream(a, 0); 3299 if (r < 0) 3300 return (r); 3301 } else if (zip->folder_outbytes_remaining > 0) { 3302 /* Extract a remaining pack stream. */ 3303 r = extract_pack_stream(a, 0); 3304 if (r < 0) 3305 return (r); 3306 } else { 3307 archive_set_error(&a->archive, 3308 ARCHIVE_ERRNO_FILE_FORMAT, 3309 "Truncated 7-Zip file body"); 3310 return (ARCHIVE_FATAL); 3311 } 3312 } 3313 skipped = get_uncompressed_data( 3314 a, buff, (size_t)skip_bytes, 0); 3315 if (skipped < 0) 3316 return (skipped); 3317 skip_bytes -= skipped; 3318 if (zip->pack_stream_bytes_unconsumed) 3319 read_consume(a); 3320 } 3321 3322 return (get_uncompressed_data(a, buff, size, minimum)); 3323 } 3324 3325 static int 3326 setup_decode_folder(struct archive_read *a, struct _7z_folder *folder, 3327 int header) 3328 { 3329 struct _7zip *zip = (struct _7zip *)a->format->data; 3330 const struct _7z_coder *coder1, *coder2; 3331 const char *cname = (header)?"archive header":"file content"; 3332 unsigned i; 3333 int r, found_bcj2 = 0; 3334 3335 /* 3336 * Release the memory which the previous folder used for BCJ2. 3337 */ 3338 for (i = 0; i < 3; i++) { 3339 if (zip->sub_stream_buff[i] != NULL) 3340 free(zip->sub_stream_buff[i]); 3341 zip->sub_stream_buff[i] = NULL; 3342 } 3343 3344 /* 3345 * Initialize a stream reader. 3346 */ 3347 zip->pack_stream_remaining = (unsigned)folder->numPackedStreams; 3348 zip->pack_stream_index = (unsigned)folder->packIndex; 3349 zip->folder_outbytes_remaining = folder_uncompressed_size(folder); 3350 zip->uncompressed_buffer_bytes_remaining = 0; 3351 3352 /* 3353 * Check coder types. 3354 */ 3355 for (i = 0; i < folder->numCoders; i++) { 3356 switch(folder->coders[i].codec) { 3357 case _7Z_CRYPTO_MAIN_ZIP: 3358 case _7Z_CRYPTO_RAR_29: 3359 case _7Z_CRYPTO_AES_256_SHA_256: { 3360 /* For entry that is associated with this folder, mark 3361 it as encrypted (data+metadata). */ 3362 zip->has_encrypted_entries = 1; 3363 if (a->entry) { 3364 archive_entry_set_is_data_encrypted(a->entry, 1); 3365 archive_entry_set_is_metadata_encrypted(a->entry, 1); 3366 } 3367 archive_set_error(&(a->archive), 3368 ARCHIVE_ERRNO_MISC, 3369 "The %s is encrypted, " 3370 "but currently not supported", cname); 3371 return (ARCHIVE_FATAL); 3372 } 3373 case _7Z_X86_BCJ2: { 3374 found_bcj2++; 3375 break; 3376 } 3377 } 3378 } 3379 /* Now that we've checked for encryption, if there were still no 3380 * encrypted entries found we can say for sure that there are none. 3381 */ 3382 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) { 3383 zip->has_encrypted_entries = 0; 3384 } 3385 3386 if ((folder->numCoders > 2 && !found_bcj2) || found_bcj2 > 1) { 3387 archive_set_error(&(a->archive), 3388 ARCHIVE_ERRNO_MISC, 3389 "The %s is encoded with many filters, " 3390 "but currently not supported", cname); 3391 return (ARCHIVE_FATAL); 3392 } 3393 coder1 = &(folder->coders[0]); 3394 if (folder->numCoders == 2) 3395 coder2 = &(folder->coders[1]); 3396 else 3397 coder2 = NULL; 3398 3399 if (found_bcj2) { 3400 /* 3401 * Preparation to decode BCJ2. 3402 * Decoding BCJ2 requires four sources. Those are at least, 3403 * as far as I know, two types of the storage form. 3404 */ 3405 const struct _7z_coder *fc = folder->coders; 3406 static const struct _7z_coder coder_copy = {0, 1, 1, 0, NULL}; 3407 const struct _7z_coder *scoder[3] = 3408 {&coder_copy, &coder_copy, &coder_copy}; 3409 const void *buff; 3410 ssize_t bytes; 3411 unsigned char *b[3] = {NULL, NULL, NULL}; 3412 uint64_t sunpack[3] ={-1, -1, -1}; 3413 size_t s[3] = {0, 0, 0}; 3414 int idx[3] = {0, 1, 2}; 3415 3416 if (folder->numCoders == 4 && fc[3].codec == _7Z_X86_BCJ2 && 3417 folder->numInStreams == 7 && folder->numOutStreams == 4 && 3418 zip->pack_stream_remaining == 4) { 3419 /* Source type 1 made by 7zr or 7z with -m options. */ 3420 if (folder->bindPairs[0].inIndex == 5) { 3421 /* The form made by 7zr */ 3422 idx[0] = 1; idx[1] = 2; idx[2] = 0; 3423 scoder[1] = &(fc[1]); 3424 scoder[2] = &(fc[0]); 3425 sunpack[1] = folder->unPackSize[1]; 3426 sunpack[2] = folder->unPackSize[0]; 3427 coder1 = &(fc[2]); 3428 } else { 3429 /* 3430 * NOTE: Some patterns do not work. 3431 * work: 3432 * 7z a -m0=BCJ2 -m1=COPY -m2=COPY 3433 * -m3=(any) 3434 * 7z a -m0=BCJ2 -m1=COPY -m2=(any) 3435 * -m3=COPY 3436 * 7z a -m0=BCJ2 -m1=(any) -m2=COPY 3437 * -m3=COPY 3438 * not work: 3439 * other patterns. 3440 * 3441 * We have to handle this like `pipe' or 3442 * our libarchive7s filter frame work, 3443 * decoding the BCJ2 main stream sequentially, 3444 * m3 -> m2 -> m1 -> BCJ2. 3445 * 3446 */ 3447 if (fc[0].codec == _7Z_COPY && 3448 fc[1].codec == _7Z_COPY) 3449 coder1 = &(folder->coders[2]); 3450 else if (fc[0].codec == _7Z_COPY && 3451 fc[2].codec == _7Z_COPY) 3452 coder1 = &(folder->coders[1]); 3453 else if (fc[1].codec == _7Z_COPY && 3454 fc[2].codec == _7Z_COPY) 3455 coder1 = &(folder->coders[0]); 3456 else { 3457 archive_set_error(&(a->archive), 3458 ARCHIVE_ERRNO_MISC, 3459 "Unsupported form of " 3460 "BCJ2 streams"); 3461 return (ARCHIVE_FATAL); 3462 } 3463 } 3464 coder2 = &(fc[3]); 3465 zip->main_stream_bytes_remaining = 3466 (size_t)folder->unPackSize[2]; 3467 } else if (coder2 != NULL && coder2->codec == _7Z_X86_BCJ2 && 3468 zip->pack_stream_remaining == 4 && 3469 folder->numInStreams == 5 && folder->numOutStreams == 2) { 3470 /* Source type 0 made by 7z */ 3471 zip->main_stream_bytes_remaining = 3472 (size_t)folder->unPackSize[0]; 3473 } else { 3474 /* We got an unexpected form. */ 3475 archive_set_error(&(a->archive), 3476 ARCHIVE_ERRNO_MISC, 3477 "Unsupported form of BCJ2 streams"); 3478 return (ARCHIVE_FATAL); 3479 } 3480 3481 /* Skip the main stream at this time. */ 3482 if ((r = seek_pack(a)) < 0) 3483 return (r); 3484 zip->pack_stream_bytes_unconsumed = 3485 (size_t)zip->pack_stream_inbytes_remaining; 3486 read_consume(a); 3487 3488 /* Read following three sub streams. */ 3489 for (i = 0; i < 3; i++) { 3490 const struct _7z_coder *coder = scoder[i]; 3491 3492 if ((r = seek_pack(a)) < 0) { 3493 free(b[0]); free(b[1]); free(b[2]); 3494 return (r); 3495 } 3496 3497 if (sunpack[i] == (uint64_t)-1) 3498 zip->folder_outbytes_remaining = 3499 zip->pack_stream_inbytes_remaining; 3500 else 3501 zip->folder_outbytes_remaining = sunpack[i]; 3502 3503 r = init_decompression(a, zip, coder, NULL); 3504 if (r != ARCHIVE_OK) { 3505 free(b[0]); free(b[1]); free(b[2]); 3506 return (ARCHIVE_FATAL); 3507 } 3508 3509 /* Allocate memory for the decoded data of a sub 3510 * stream. */ 3511 b[i] = malloc((size_t)zip->folder_outbytes_remaining); 3512 if (b[i] == NULL) { 3513 free(b[0]); free(b[1]); free(b[2]); 3514 archive_set_error(&a->archive, ENOMEM, 3515 "No memory for 7-Zip decompression"); 3516 return (ARCHIVE_FATAL); 3517 } 3518 3519 /* Extract a sub stream. */ 3520 while (zip->pack_stream_inbytes_remaining > 0) { 3521 r = (int)extract_pack_stream(a, 0); 3522 if (r < 0) { 3523 free(b[0]); free(b[1]); free(b[2]); 3524 return (r); 3525 } 3526 bytes = get_uncompressed_data(a, &buff, 3527 zip->uncompressed_buffer_bytes_remaining, 3528 0); 3529 if (bytes < 0) { 3530 free(b[0]); free(b[1]); free(b[2]); 3531 return ((int)bytes); 3532 } 3533 memcpy(b[i]+s[i], buff, bytes); 3534 s[i] += bytes; 3535 if (zip->pack_stream_bytes_unconsumed) 3536 read_consume(a); 3537 } 3538 } 3539 3540 /* Set the sub streams to the right place. */ 3541 for (i = 0; i < 3; i++) { 3542 zip->sub_stream_buff[i] = b[idx[i]]; 3543 zip->sub_stream_size[i] = s[idx[i]]; 3544 zip->sub_stream_bytes_remaining[i] = s[idx[i]]; 3545 } 3546 3547 /* Allocate memory used for decoded main stream bytes. */ 3548 if (zip->tmp_stream_buff == NULL) { 3549 zip->tmp_stream_buff_size = 32 * 1024; 3550 zip->tmp_stream_buff = 3551 malloc(zip->tmp_stream_buff_size); 3552 if (zip->tmp_stream_buff == NULL) { 3553 archive_set_error(&a->archive, ENOMEM, 3554 "No memory for 7-Zip decompression"); 3555 return (ARCHIVE_FATAL); 3556 } 3557 } 3558 zip->tmp_stream_bytes_avail = 0; 3559 zip->tmp_stream_bytes_remaining = 0; 3560 zip->odd_bcj_size = 0; 3561 zip->bcj2_outPos = 0; 3562 3563 /* 3564 * Reset a stream reader in order to read the main stream 3565 * of BCJ2. 3566 */ 3567 zip->pack_stream_remaining = 1; 3568 zip->pack_stream_index = (unsigned)folder->packIndex; 3569 zip->folder_outbytes_remaining = 3570 folder_uncompressed_size(folder); 3571 zip->uncompressed_buffer_bytes_remaining = 0; 3572 } 3573 3574 /* 3575 * Initialize the decompressor for the new folder's pack streams. 3576 */ 3577 r = init_decompression(a, zip, coder1, coder2); 3578 if (r != ARCHIVE_OK) 3579 return (ARCHIVE_FATAL); 3580 return (ARCHIVE_OK); 3581 } 3582 3583 static int64_t 3584 skip_stream(struct archive_read *a, size_t skip_bytes) 3585 { 3586 struct _7zip *zip = (struct _7zip *)a->format->data; 3587 const void *p; 3588 int64_t skipped_bytes; 3589 size_t bytes = skip_bytes; 3590 3591 if (zip->folder_index == 0) { 3592 /* 3593 * Optimization for a list mode. 3594 * Avoid unnecessary decoding operations. 3595 */ 3596 zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes 3597 += skip_bytes; 3598 return (skip_bytes); 3599 } 3600 3601 while (bytes) { 3602 skipped_bytes = read_stream(a, &p, bytes, 0); 3603 if (skipped_bytes < 0) 3604 return (skipped_bytes); 3605 if (skipped_bytes == 0) { 3606 archive_set_error(&a->archive, 3607 ARCHIVE_ERRNO_FILE_FORMAT, 3608 "Truncated 7-Zip file body"); 3609 return (ARCHIVE_FATAL); 3610 } 3611 bytes -= (size_t)skipped_bytes; 3612 if (zip->pack_stream_bytes_unconsumed) 3613 read_consume(a); 3614 } 3615 return (skip_bytes); 3616 } 3617 3618 /* 3619 * Brought from LZMA SDK. 3620 * 3621 * Bra86.c -- Converter for x86 code (BCJ) 3622 * 2008-10-04 : Igor Pavlov : Public domain 3623 * 3624 */ 3625 3626 #define Test86MSByte(b) ((b) == 0 || (b) == 0xFF) 3627 3628 static void 3629 x86_Init(struct _7zip *zip) 3630 { 3631 zip->bcj_state = 0; 3632 zip->bcj_prevPosT = (size_t)0 - 1; 3633 zip->bcj_prevMask = 0; 3634 zip->bcj_ip = 5; 3635 } 3636 3637 static size_t 3638 x86_Convert(struct _7zip *zip, uint8_t *data, size_t size) 3639 { 3640 static const uint8_t kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0}; 3641 static const uint8_t kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3}; 3642 size_t bufferPos, prevPosT; 3643 uint32_t ip, prevMask; 3644 3645 if (size < 5) 3646 return 0; 3647 3648 bufferPos = 0; 3649 prevPosT = zip->bcj_prevPosT; 3650 prevMask = zip->bcj_prevMask; 3651 ip = zip->bcj_ip; 3652 3653 for (;;) { 3654 uint8_t *p = data + bufferPos; 3655 uint8_t *limit = data + size - 4; 3656 3657 for (; p < limit; p++) 3658 if ((*p & 0xFE) == 0xE8) 3659 break; 3660 bufferPos = (size_t)(p - data); 3661 if (p >= limit) 3662 break; 3663 prevPosT = bufferPos - prevPosT; 3664 if (prevPosT > 3) 3665 prevMask = 0; 3666 else { 3667 prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7; 3668 if (prevMask != 0) { 3669 unsigned char b = 3670 p[4 - kMaskToBitNumber[prevMask]]; 3671 if (!kMaskToAllowedStatus[prevMask] || 3672 Test86MSByte(b)) { 3673 prevPosT = bufferPos; 3674 prevMask = ((prevMask << 1) & 0x7) | 1; 3675 bufferPos++; 3676 continue; 3677 } 3678 } 3679 } 3680 prevPosT = bufferPos; 3681 3682 if (Test86MSByte(p[4])) { 3683 uint32_t src = ((uint32_t)p[4] << 24) | 3684 ((uint32_t)p[3] << 16) | ((uint32_t)p[2] << 8) | 3685 ((uint32_t)p[1]); 3686 uint32_t dest; 3687 for (;;) { 3688 uint8_t b; 3689 int b_index; 3690 3691 dest = src - (ip + (uint32_t)bufferPos); 3692 if (prevMask == 0) 3693 break; 3694 b_index = kMaskToBitNumber[prevMask] * 8; 3695 b = (uint8_t)(dest >> (24 - b_index)); 3696 if (!Test86MSByte(b)) 3697 break; 3698 src = dest ^ ((1 << (32 - b_index)) - 1); 3699 } 3700 p[4] = (uint8_t)(~(((dest >> 24) & 1) - 1)); 3701 p[3] = (uint8_t)(dest >> 16); 3702 p[2] = (uint8_t)(dest >> 8); 3703 p[1] = (uint8_t)dest; 3704 bufferPos += 5; 3705 } else { 3706 prevMask = ((prevMask << 1) & 0x7) | 1; 3707 bufferPos++; 3708 } 3709 } 3710 zip->bcj_prevPosT = prevPosT; 3711 zip->bcj_prevMask = prevMask; 3712 zip->bcj_ip += (uint32_t)bufferPos; 3713 return (bufferPos); 3714 } 3715 3716 /* 3717 * Brought from LZMA SDK. 3718 * 3719 * Bcj2.c -- Converter for x86 code (BCJ2) 3720 * 2008-10-04 : Igor Pavlov : Public domain 3721 * 3722 */ 3723 3724 #define SZ_ERROR_DATA ARCHIVE_FAILED 3725 3726 #define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80) 3727 #define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1)) 3728 3729 #define kNumTopBits 24 3730 #define kTopValue ((uint32_t)1 << kNumTopBits) 3731 3732 #define kNumBitModelTotalBits 11 3733 #define kBitModelTotal (1 << kNumBitModelTotalBits) 3734 #define kNumMoveBits 5 3735 3736 #define RC_READ_BYTE (*buffer++) 3737 #define RC_TEST { if (buffer == bufferLim) return SZ_ERROR_DATA; } 3738 #define RC_INIT2 zip->bcj2_code = 0; zip->bcj2_range = 0xFFFFFFFF; \ 3739 { int ii; for (ii = 0; ii < 5; ii++) { RC_TEST; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }} 3740 3741 #define NORMALIZE if (zip->bcj2_range < kTopValue) { RC_TEST; zip->bcj2_range <<= 8; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; } 3742 3743 #define IF_BIT_0(p) ttt = *(p); bound = (zip->bcj2_range >> kNumBitModelTotalBits) * ttt; if (zip->bcj2_code < bound) 3744 #define UPDATE_0(p) zip->bcj2_range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); NORMALIZE; 3745 #define UPDATE_1(p) zip->bcj2_range -= bound; zip->bcj2_code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); NORMALIZE; 3746 3747 static ssize_t 3748 Bcj2_Decode(struct _7zip *zip, uint8_t *outBuf, size_t outSize) 3749 { 3750 size_t inPos = 0, outPos = 0; 3751 const uint8_t *buf0, *buf1, *buf2, *buf3; 3752 size_t size0, size1, size2, size3; 3753 const uint8_t *buffer, *bufferLim; 3754 unsigned int i, j; 3755 3756 size0 = zip->tmp_stream_bytes_remaining; 3757 buf0 = zip->tmp_stream_buff + zip->tmp_stream_bytes_avail - size0; 3758 size1 = zip->sub_stream_bytes_remaining[0]; 3759 buf1 = zip->sub_stream_buff[0] + zip->sub_stream_size[0] - size1; 3760 size2 = zip->sub_stream_bytes_remaining[1]; 3761 buf2 = zip->sub_stream_buff[1] + zip->sub_stream_size[1] - size2; 3762 size3 = zip->sub_stream_bytes_remaining[2]; 3763 buf3 = zip->sub_stream_buff[2] + zip->sub_stream_size[2] - size3; 3764 3765 buffer = buf3; 3766 bufferLim = buffer + size3; 3767 3768 if (zip->bcj_state == 0) { 3769 /* 3770 * Initialize. 3771 */ 3772 zip->bcj2_prevByte = 0; 3773 for (i = 0; 3774 i < sizeof(zip->bcj2_p) / sizeof(zip->bcj2_p[0]); i++) 3775 zip->bcj2_p[i] = kBitModelTotal >> 1; 3776 RC_INIT2; 3777 zip->bcj_state = 1; 3778 } 3779 3780 /* 3781 * Gather the odd bytes of a previous call. 3782 */ 3783 for (i = 0; zip->odd_bcj_size > 0 && outPos < outSize; i++) { 3784 outBuf[outPos++] = zip->odd_bcj[i]; 3785 zip->odd_bcj_size--; 3786 } 3787 3788 if (outSize == 0) { 3789 zip->bcj2_outPos += outPos; 3790 return (outPos); 3791 } 3792 3793 for (;;) { 3794 uint8_t b; 3795 CProb *prob; 3796 uint32_t bound; 3797 uint32_t ttt; 3798 3799 size_t limit = size0 - inPos; 3800 if (outSize - outPos < limit) 3801 limit = outSize - outPos; 3802 3803 if (zip->bcj_state == 1) { 3804 while (limit != 0) { 3805 uint8_t bb = buf0[inPos]; 3806 outBuf[outPos++] = bb; 3807 if (IsJ(zip->bcj2_prevByte, bb)) { 3808 zip->bcj_state = 2; 3809 break; 3810 } 3811 inPos++; 3812 zip->bcj2_prevByte = bb; 3813 limit--; 3814 } 3815 } 3816 3817 if (limit == 0 || outPos == outSize) 3818 break; 3819 zip->bcj_state = 1; 3820 3821 b = buf0[inPos++]; 3822 3823 if (b == 0xE8) 3824 prob = zip->bcj2_p + zip->bcj2_prevByte; 3825 else if (b == 0xE9) 3826 prob = zip->bcj2_p + 256; 3827 else 3828 prob = zip->bcj2_p + 257; 3829 3830 IF_BIT_0(prob) { 3831 UPDATE_0(prob) 3832 zip->bcj2_prevByte = b; 3833 } else { 3834 uint32_t dest; 3835 const uint8_t *v; 3836 uint8_t out[4]; 3837 3838 UPDATE_1(prob) 3839 if (b == 0xE8) { 3840 v = buf1; 3841 if (size1 < 4) 3842 return SZ_ERROR_DATA; 3843 buf1 += 4; 3844 size1 -= 4; 3845 } else { 3846 v = buf2; 3847 if (size2 < 4) 3848 return SZ_ERROR_DATA; 3849 buf2 += 4; 3850 size2 -= 4; 3851 } 3852 dest = (((uint32_t)v[0] << 24) | 3853 ((uint32_t)v[1] << 16) | 3854 ((uint32_t)v[2] << 8) | 3855 ((uint32_t)v[3])) - 3856 ((uint32_t)zip->bcj2_outPos + (uint32_t)outPos + 4); 3857 out[0] = (uint8_t)dest; 3858 out[1] = (uint8_t)(dest >> 8); 3859 out[2] = (uint8_t)(dest >> 16); 3860 out[3] = zip->bcj2_prevByte = (uint8_t)(dest >> 24); 3861 3862 for (i = 0; i < 4 && outPos < outSize; i++) 3863 outBuf[outPos++] = out[i]; 3864 if (i < 4) { 3865 /* 3866 * Save odd bytes which we could not add into 3867 * the output buffer because of out of space. 3868 */ 3869 zip->odd_bcj_size = 4 -i; 3870 for (; i < 4; i++) { 3871 j = i - 4 + (unsigned)zip->odd_bcj_size; 3872 zip->odd_bcj[j] = out[i]; 3873 } 3874 break; 3875 } 3876 } 3877 } 3878 zip->tmp_stream_bytes_remaining -= inPos; 3879 zip->sub_stream_bytes_remaining[0] = size1; 3880 zip->sub_stream_bytes_remaining[1] = size2; 3881 zip->sub_stream_bytes_remaining[2] = bufferLim - buffer; 3882 zip->bcj2_outPos += outPos; 3883 3884 return ((ssize_t)outPos); 3885 } 3886 3887