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