Lines Matching refs:zip
336 * corrupted 7-zip files on assuming there are not so many entries in
406 struct _7zip *zip;
412 zip = calloc(1, sizeof(*zip));
413 if (zip == NULL) {
415 "Can't allocate 7zip data");
423 zip->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
427 zip,
428 "7zip",
440 free(zip);
457 struct _7zip * zip = (struct _7zip *)_a->format->data;
458 if (zip) {
459 return zip->has_encrypted_entries;
588 struct _7zip *zip =
592 zip->seek_base = SFX_MIN_ADDR + offset + skip;
613 struct _7zip *zip = (struct _7zip *)a->format->data;
626 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
627 zip->has_encrypted_entries = 0;
634 if (zip->entries == NULL) {
638 r = slurp_central_directory(a, zip, &header);
642 zip->entries_remaining = (size_t)zip->numFiles;
643 zip->entry = zip->entries;
645 ++zip->entry;
647 zip_entry = zip->entry;
649 if (zip->entries_remaining <= 0 || zip_entry == NULL)
651 --zip->entries_remaining;
653 zip->entry_offset = 0;
654 zip->end_of_entry = 0;
655 zip->entry_crc32 = crc32(0, NULL, 0);
658 if (zip->sconv == NULL) {
659 zip->sconv = archive_string_conversion_from_charset(
661 if (zip->sconv == NULL)
666 that is associated to the current 7zip entry. If the folder
669 if (zip_entry && zip_entry->folderIndex < zip->si.ci.numFolders) {
670 folder = &(zip->si.ci.folders[zip_entry->folderIndex]);
677 zip->has_encrypted_entries = 1;
687 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
688 zip->has_encrypted_entries = 0;
693 zip_entry->name_len, zip->sconv) != 0) {
703 archive_string_conversion_charset_name(zip->sconv));
719 zip->entry_bytes_remaining =
720 zip->si.ss.unpackSizes[zip_entry->ssIndex];
721 archive_entry_set_size(entry, zip->entry_bytes_remaining);
723 zip->entry_bytes_remaining = 0;
728 if (zip->entry_bytes_remaining < 1)
729 zip->end_of_entry = 1;
739 while (zip->entry_bytes_remaining > 0) {
778 sprintf(zip->format_name, "7-Zip");
779 a->archive.archive_format_name = zip->format_name;
788 struct _7zip *zip;
792 zip = (struct _7zip *)(a->format->data);
794 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
795 zip->has_encrypted_entries = 0;
798 if (zip->pack_stream_bytes_unconsumed)
801 *offset = zip->entry_offset;
808 if (zip->end_of_entry)
813 if ((uint64_t)bytes_to_read > zip->entry_bytes_remaining) {
814 bytes_to_read = zip->entry_bytes_remaining;
825 zip->entry_bytes_remaining -= bytes;
826 if (zip->entry_bytes_remaining == 0)
827 zip->end_of_entry = 1;
830 if ((zip->entry->flg & CRC32_IS_SET) && bytes)
831 zip->entry_crc32 = crc32(zip->entry_crc32, *buff,
835 if (zip->end_of_entry) {
837 if ((zip->entry->flg & CRC32_IS_SET) &&
838 zip->si.ss.digests[zip->entry->ssIndex] !=
839 zip->entry_crc32) {
842 (unsigned long)zip->entry_crc32,
843 (unsigned long)zip->si.ss.digests[
844 zip->entry->ssIndex]);
850 *offset = zip->entry_offset;
851 zip->entry_offset += bytes;
859 struct _7zip *zip;
862 zip = (struct _7zip *)(a->format->data);
864 if (zip->pack_stream_bytes_unconsumed)
868 if (zip->end_of_entry)
875 bytes_skipped = skip_stream(a, (size_t)zip->entry_bytes_remaining);
878 zip->entry_bytes_remaining = 0;
881 zip->end_of_entry = 1;
888 struct _7zip *zip;
890 zip = (struct _7zip *)(a->format->data);
891 free_StreamsInfo(&(zip->si));
892 free(zip->entries);
893 free(zip->entry_names);
894 free_decompression(a, zip);
895 free(zip->uncompressed_buffer);
896 free(zip->sub_stream_buff[0]);
897 free(zip->sub_stream_buff[1]);
898 free(zip->sub_stream_buff[2]);
899 free(zip->tmp_stream_buff);
900 free(zip);
908 struct _7zip *zip = (struct _7zip *)a->format->data;
910 if (zip->pack_stream_bytes_unconsumed) {
911 __archive_read_consume(a, zip->pack_stream_bytes_unconsumed);
912 zip->stream_offset += zip->pack_stream_bytes_unconsumed;
913 zip->pack_stream_bytes_unconsumed = 0;
986 struct _7zip *zip = (struct _7zip *)(a->format->data);
989 if (zip->ppstream.avail_in == 0) {
992 zip->ppstream.overconsumed = 1;
995 b = *zip->ppstream.next_in++;
996 zip->ppstream.avail_in--;
997 zip->ppstream.total_in++;
1002 init_decompression(struct archive_read *a, struct _7zip *zip,
1007 zip->codec = coder1->codec;
1008 zip->codec2 = -1;
1010 switch (zip->codec) {
1024 zip->codec2 = coder2->codec;
1025 zip->bcj_state = 0;
1027 x86_Init(zip);
1034 switch (zip->codec) {
1052 if (zip->lzstream_valid) {
1053 lzma_end(&(zip->lzstream));
1054 zip->lzstream_valid = 0;
1076 zip->codec2 = coder2->codec;
1079 switch (zip->codec2) {
1081 if (zip->codec == _7Z_LZMA2) {
1086 x86_Init(zip);
1090 zip->bcj_state = 0;
1131 "Unexpected codec ID: %lX", zip->codec2);
1136 if (zip->codec == _7Z_LZMA2)
1152 r = lzma_raw_decoder(&(zip->lzstream), filters);
1158 zip->lzstream_valid = 1;
1159 zip->lzstream.total_in = 0;
1160 zip->lzstream.total_out = 0;
1170 if (zip->bzstream_valid) {
1171 BZ2_bzDecompressEnd(&(zip->bzstream));
1172 zip->bzstream_valid = 0;
1174 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 0);
1176 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 1);
1195 zip->bzstream_valid = 0;
1198 zip->bzstream_valid = 1;
1199 zip->bzstream.total_in_lo32 = 0;
1200 zip->bzstream.total_in_hi32 = 0;
1201 zip->bzstream.total_out_lo32 = 0;
1202 zip->bzstream.total_out_hi32 = 0;
1211 if (zip->stream_valid)
1212 r = inflateReset(&(zip->stream));
1214 r = inflateInit2(&(zip->stream),
1221 zip->stream_valid = 1;
1222 zip->stream.total_in = 0;
1223 zip->stream.total_out = 0;
1235 if (zip->ppmd7_valid) {
1237 &zip->ppmd7_context);
1238 zip->ppmd7_valid = 0;
1254 __archive_ppmd7_functions.Ppmd7_Construct(&zip->ppmd7_context);
1256 &zip->ppmd7_context, msize);
1263 &zip->ppmd7_context, order);
1265 &zip->range_dec);
1266 zip->ppmd7_valid = 1;
1267 zip->ppmd7_stat = 0;
1268 zip->ppstream.overconsumed = 0;
1269 zip->ppstream.total_in = 0;
1270 zip->ppstream.total_out = 0;
1282 "Unexpected codec ID: %lX", zip->codec);
1290 zip->has_encrypted_entries = 1;
1293 "Crypto codec not supported yet (ID: 0x%lX)", zip->codec);
1297 "Unknown codec ID: %lX", zip->codec);
1305 decompress(struct archive_read *a, struct _7zip *zip,
1321 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1326 if (o_avail_in != 0 && t_avail_out < 5 && zip->odd_bcj_size) {
1331 for (i = 0; zip->odd_bcj_size > 0 && t_avail_out; i++) {
1332 *t_next_out++ = zip->odd_bcj[i];
1334 zip->odd_bcj_size--;
1347 if (zip->codec2 == _7Z_X86_BCJ2) {
1351 if (zip->tmp_stream_bytes_remaining) {
1353 size_t remaining = zip->tmp_stream_bytes_remaining;
1354 bytes = Bcj2_Decode(zip, t_next_out, t_avail_out);
1361 zip->main_stream_bytes_remaining -=
1362 remaining - zip->tmp_stream_bytes_remaining;
1368 zip->tmp_stream_bytes_remaining)
1376 t_next_out = zip->tmp_stream_buff;
1377 t_avail_out = zip->tmp_stream_buff_size;
1380 switch (zip->codec) {
1395 zip->lzstream.next_in = t_next_in;
1396 zip->lzstream.avail_in = t_avail_in;
1397 zip->lzstream.next_out = t_next_out;
1398 zip->lzstream.avail_out = t_avail_out;
1400 r = lzma_code(&(zip->lzstream), LZMA_RUN);
1403 lzma_end(&(zip->lzstream));
1404 zip->lzstream_valid = 0;
1416 t_avail_in = zip->lzstream.avail_in;
1417 t_avail_out = zip->lzstream.avail_out;
1422 zip->bzstream.next_in = (char *)(uintptr_t)t_next_in;
1423 zip->bzstream.avail_in = t_avail_in;
1424 zip->bzstream.next_out = (char *)(uintptr_t)t_next_out;
1425 zip->bzstream.avail_out = t_avail_out;
1426 r = BZ2_bzDecompress(&(zip->bzstream));
1429 switch (BZ2_bzDecompressEnd(&(zip->bzstream))) {
1438 zip->bzstream_valid = 0;
1449 t_avail_in = zip->bzstream.avail_in;
1450 t_avail_out = zip->bzstream.avail_out;
1455 zip->stream.next_in = (Bytef *)(uintptr_t)t_next_in;
1456 zip->stream.avail_in = (uInt)t_avail_in;
1457 zip->stream.next_out = t_next_out;
1458 zip->stream.avail_out = (uInt)t_avail_out;
1459 r = inflate(&(zip->stream), 0);
1471 t_avail_in = zip->stream.avail_in;
1472 t_avail_out = zip->stream.avail_out;
1479 if (!zip->ppmd7_valid || zip->ppmd7_stat < 0 ||
1486 zip->ppstream.next_in = t_next_in;
1487 zip->ppstream.avail_in = t_avail_in;
1488 zip->ppstream.next_out = t_next_out;
1489 zip->ppstream.avail_out = t_avail_out;
1490 if (zip->ppmd7_stat == 0) {
1491 zip->bytein.a = a;
1492 zip->bytein.Read = &ppmd_read;
1493 zip->range_dec.Stream = &zip->bytein;
1495 &(zip->range_dec));
1497 zip->ppmd7_stat = -1;
1503 if (zip->ppstream.overconsumed) {
1504 zip->ppmd7_stat = -1;
1507 zip->ppmd7_stat = 1;
1512 flush_bytes = zip->folder_outbytes_remaining;
1520 &(zip->ppmd7_context), &(zip->range_dec.p));
1522 zip->ppmd7_stat = -1;
1528 if (zip->ppstream.overconsumed) {
1529 zip->ppmd7_stat = -1;
1532 *zip->ppstream.next_out++ = (unsigned char)sym;
1533 zip->ppstream.avail_out--;
1534 zip->ppstream.total_out++;
1537 } while (zip->ppstream.avail_out &&
1538 (zip->ppstream.avail_in || flush_bytes));
1540 t_avail_in = (size_t)zip->ppstream.avail_in;
1541 t_avail_out = (size_t)zip->ppstream.avail_out;
1558 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1559 size_t l = x86_Convert(zip, buff, *outbytes);
1560 zip->odd_bcj_size = *outbytes - l;
1561 if (zip->odd_bcj_size > 0 && zip->odd_bcj_size <= 4 &&
1563 memcpy(zip->odd_bcj, ((unsigned char *)buff) + l,
1564 zip->odd_bcj_size);
1567 zip->odd_bcj_size = 0;
1573 if (zip->codec2 == _7Z_X86_BCJ2) {
1576 zip->tmp_stream_bytes_avail =
1577 zip->tmp_stream_buff_size - t_avail_out;
1578 if (zip->tmp_stream_bytes_avail >
1579 zip->main_stream_bytes_remaining)
1580 zip->tmp_stream_bytes_avail =
1581 zip->main_stream_bytes_remaining;
1582 zip->tmp_stream_bytes_remaining = zip->tmp_stream_bytes_avail;
1583 bytes = Bcj2_Decode(zip, bcj2_next_out, bcj2_avail_out);
1589 zip->main_stream_bytes_remaining -=
1590 zip->tmp_stream_bytes_avail
1591 - zip->tmp_stream_bytes_remaining;
1600 free_decompression(struct archive_read *a, struct _7zip *zip)
1609 if (zip->lzstream_valid)
1610 lzma_end(&(zip->lzstream));
1613 if (zip->bzstream_valid) {
1614 if (BZ2_bzDecompressEnd(&(zip->bzstream)) != BZ_OK) {
1620 zip->bzstream_valid = 0;
1624 if (zip->stream_valid) {
1625 if (inflateEnd(&(zip->stream)) != Z_OK) {
1631 zip->stream_valid = 0;
1634 if (zip->ppmd7_valid) {
1636 &zip->ppmd7_context);
1637 zip->ppmd7_valid = 0;
1836 struct _7zip *zip = (struct _7zip *)a->format->data;
1924 if (zip->header_bytes_remaining < f->numBindPairs)
2258 struct _7zip *zip = (struct _7zip *)a->format->data;
2281 if (packPos > zip->header_offset)
2338 struct _7zip *zip = (struct _7zip *)a->format->data;
2341 struct _7z_stream_info *si = &(zip->si);
2380 if (read_StreamsInfo(a, &(zip->si)) < 0)
2394 if (parse_7zip_uint64(a, &(zip->numFiles)) < 0)
2396 if (UMAX_ENTRY < zip->numFiles)
2399 zip->entries = calloc((size_t)zip->numFiles, sizeof(*zip->entries));
2400 if (zip->entries == NULL)
2402 entries = zip->entries;
2418 if (zip->header_bytes_remaining < size)
2426 h->emptyStreamBools = calloc((size_t)zip->numFiles,
2431 a, h->emptyStreamBools, (size_t)zip->numFiles) < 0)
2434 for (i = 0; i < zip->numFiles; i++) {
2487 if ((ll & 1) || ll < zip->numFiles * 4)
2490 if (zip->entry_names != NULL)
2492 zip->entry_names = malloc(ll);
2493 if (zip->entry_names == NULL)
2495 np = zip->entry_names;
2515 np = zip->entry_names;
2518 for (i = 0; i < zip->numFiles; i++) {
2546 h->attrBools = calloc((size_t)zip->numFiles,
2551 memset(h->attrBools, 1, (size_t)zip->numFiles);
2554 (size_t)zip->numFiles) < 0)
2557 for (i = 0; i < zip->numFiles; i++) {
2583 for (i = 0; i < zip->numFiles; i++) {
2681 struct _7zip *zip = (struct _7zip *)a->format->data;
2683 struct _7zip_entry *entries = zip->entries;
2688 timeBools = calloc((size_t)zip->numFiles, sizeof(*timeBools));
2697 memset(timeBools, 1, (size_t)zip->numFiles);
2699 if (read_Bools(a, timeBools, (size_t)zip->numFiles) < 0)
2713 for (i = 0; i < zip->numFiles; i++) {
2750 struct _7zip *zip = (struct _7zip *)a->format->data;
2768 if (zip->header_offset < si->pi.pos + si->pi.sizes[0] ||
2781 struct _7zip *zip = (struct _7zip *)a->format->data;
2784 if (zip->header_bytes_remaining < rbytes)
2786 if (zip->pack_stream_bytes_unconsumed)
2789 if (zip->header_is_encoded == 0) {
2793 zip->header_bytes_remaining -= rbytes;
2794 zip->pack_stream_bytes_unconsumed = rbytes;
2802 zip->header_bytes_remaining -= bytes;
2807 zip->header_crc32 = crc32(zip->header_crc32, p, (unsigned)rbytes);
2812 slurp_central_directory(struct archive_read *a, struct _7zip *zip,
2833 zip->seek_base += 32;
2864 next_header_offset + zip->seek_base, SEEK_SET) < 0)
2867 zip->stream_offset = next_header_offset;
2868 zip->header_offset = next_header_offset;
2869 zip->header_bytes_remaining = next_header_size;
2870 zip->header_crc32 = 0;
2871 zip->header_is_encoded = 0;
2872 zip->header_is_being_read = 1;
2873 zip->has_encrypted_entries = 0;
2889 r = decode_encoded_header_info(a, &(zip->si));
2892 if (r == 0 && zip->header_crc32 != next_header_crc) {
2898 if (zip->si.ci.folders[0].digest_defined)
2899 next_header_crc = zip->si.ci.folders[0].digest;
2902 if (zip->pack_stream_bytes_unconsumed)
2904 r = setup_decode_folder(a, zip->si.ci.folders, 1);
2906 zip->header_bytes_remaining =
2907 zip->folder_outbytes_remaining;
2912 free_StreamsInfo(&(zip->si));
2913 memset(&(zip->si), 0, sizeof(zip->si));
2916 zip->header_is_encoded = 1;
2917 zip->header_crc32 = 0;
2924 r = read_Header(a, header, zip->header_is_encoded);
2945 if (check_header_crc && zip->header_crc32 != next_header_crc) {
2958 zip->pack_stream_remaining = 0;
2959 zip->pack_stream_index = 0;
2960 zip->folder_outbytes_remaining = 0;
2961 zip->uncompressed_buffer_bytes_remaining = 0;
2962 zip->pack_stream_bytes_unconsumed = 0;
2963 zip->header_is_being_read = 0;
2972 struct _7zip *zip = (struct _7zip *)a->format->data;
2975 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
2986 zip->uncompressed_buffer_bytes_remaining)
2988 zip->uncompressed_buffer_bytes_remaining;
2992 zip->pack_stream_bytes_unconsumed = bytes_avail;
2993 } else if (zip->uncompressed_buffer_pointer == NULL) {
3000 if (minimum > zip->uncompressed_buffer_bytes_remaining) {
3009 if (size > zip->uncompressed_buffer_bytes_remaining)
3011 zip->uncompressed_buffer_bytes_remaining;
3014 *buff = zip->uncompressed_buffer_pointer;
3015 zip->uncompressed_buffer_pointer += bytes_avail;
3017 zip->uncompressed_buffer_bytes_remaining -= bytes_avail;
3024 struct _7zip *zip = (struct _7zip *)a->format->data;
3028 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
3038 if ((uint64_t)bytes_avail > zip->pack_stream_inbytes_remaining)
3039 bytes_avail = (ssize_t)zip->pack_stream_inbytes_remaining;
3040 zip->pack_stream_inbytes_remaining -= bytes_avail;
3041 if ((uint64_t)bytes_avail > zip->folder_outbytes_remaining)
3042 bytes_avail = (ssize_t)zip->folder_outbytes_remaining;
3043 zip->folder_outbytes_remaining -= bytes_avail;
3044 zip->uncompressed_buffer_bytes_remaining = bytes_avail;
3049 if (zip->uncompressed_buffer == NULL) {
3050 zip->uncompressed_buffer_size = UBUFF_SIZE;
3051 if (zip->uncompressed_buffer_size < minimum) {
3052 zip->uncompressed_buffer_size = minimum + 1023;
3053 zip->uncompressed_buffer_size &= ~0x3ff;
3055 zip->uncompressed_buffer =
3056 malloc(zip->uncompressed_buffer_size);
3057 if (zip->uncompressed_buffer == NULL) {
3062 zip->uncompressed_buffer_bytes_remaining = 0;
3063 } else if (zip->uncompressed_buffer_size < minimum ||
3064 zip->uncompressed_buffer_bytes_remaining < minimum) {
3071 if (zip->uncompressed_buffer_pointer != 0)
3072 used = zip->uncompressed_buffer_pointer -
3073 zip->uncompressed_buffer;
3076 if (zip->uncompressed_buffer_size < minimum) {
3086 p = realloc(zip->uncompressed_buffer, new_size);
3092 zip->uncompressed_buffer = (unsigned char *)p;
3093 zip->uncompressed_buffer_size = new_size;
3099 memmove(zip->uncompressed_buffer,
3100 zip->uncompressed_buffer + used,
3101 zip->uncompressed_buffer_bytes_remaining);
3104 zip->uncompressed_buffer_bytes_remaining = 0;
3105 zip->uncompressed_buffer_pointer = NULL;
3126 buff_out = zip->uncompressed_buffer
3127 + zip->uncompressed_buffer_bytes_remaining;
3128 bytes_out = zip->uncompressed_buffer_size
3129 - zip->uncompressed_buffer_bytes_remaining;
3131 if (bytes_in > zip->pack_stream_inbytes_remaining)
3132 bytes_in = (size_t)zip->pack_stream_inbytes_remaining;
3134 r = decompress(a, zip, buff_out, &bytes_out,
3146 zip->pack_stream_inbytes_remaining -= bytes_in;
3147 if (bytes_out > zip->folder_outbytes_remaining)
3148 bytes_out = (size_t)zip->folder_outbytes_remaining;
3149 zip->folder_outbytes_remaining -= bytes_out;
3150 zip->uncompressed_buffer_bytes_remaining += bytes_out;
3151 zip->pack_stream_bytes_unconsumed = bytes_in;
3156 if (zip->uncompressed_buffer_bytes_remaining ==
3157 zip->uncompressed_buffer_size)
3159 if (zip->codec2 == _7Z_X86 && zip->odd_bcj_size &&
3160 zip->uncompressed_buffer_bytes_remaining + 5 >
3161 zip->uncompressed_buffer_size)
3163 if (zip->pack_stream_inbytes_remaining == 0 &&
3164 zip->folder_outbytes_remaining == 0)
3173 if (zip->uncompressed_buffer_bytes_remaining < minimum) {
3178 zip->uncompressed_buffer_pointer = zip->uncompressed_buffer;
3185 struct _7zip *zip = (struct _7zip *)a->format->data;
3188 if (zip->pack_stream_remaining <= 0) {
3193 zip->pack_stream_inbytes_remaining =
3194 zip->si.pi.sizes[zip->pack_stream_index];
3195 pack_offset = zip->si.pi.positions[zip->pack_stream_index];
3196 if (zip->stream_offset != pack_offset) {
3197 if (0 > __archive_read_seek(a, pack_offset + zip->seek_base,
3200 zip->stream_offset = pack_offset;
3202 zip->pack_stream_index++;
3203 zip->pack_stream_remaining--;
3211 struct _7zip *zip = (struct _7zip *)a->format->data;
3215 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3216 if (zip->pack_stream_inbytes_remaining > 0) {
3221 } else if (zip->folder_outbytes_remaining > 0) {
3234 if (zip->pack_stream_remaining == 0) {
3235 if (zip->header_is_being_read) {
3247 if (zip->folder_index == 0 &&
3248 (zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3249 || zip->folder_index != zip->entry->folderIndex)) {
3250 zip->folder_index = zip->entry->folderIndex;
3252 zip->si.ci.folders[zip->folder_index].skipped_bytes;
3255 if (zip->folder_index >= zip->si.ci.numFolders) {
3263 &(zip->si.ci.folders[zip->folder_index]), 0);
3267 zip->folder_index++;
3288 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3289 if (zip->pack_stream_inbytes_remaining > 0) {
3293 } else if (zip->folder_outbytes_remaining > 0) {
3310 if (zip->pack_stream_bytes_unconsumed)
3321 struct _7zip *zip = (struct _7zip *)a->format->data;
3331 free(zip->sub_stream_buff[i]);
3332 zip->sub_stream_buff[i] = NULL;
3338 zip->pack_stream_remaining = (unsigned)folder->numPackedStreams;
3339 zip->pack_stream_index = (unsigned)folder->packIndex;
3340 zip->folder_outbytes_remaining = folder_uncompressed_size(folder);
3341 zip->uncompressed_buffer_bytes_remaining = 0;
3353 zip->has_encrypted_entries = 1;
3373 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
3374 zip->has_encrypted_entries = 0;
3409 zip->pack_stream_remaining == 4) {
3456 zip->main_stream_bytes_remaining =
3459 zip->pack_stream_remaining == 4 &&
3462 zip->main_stream_bytes_remaining =
3475 zip->pack_stream_bytes_unconsumed =
3476 (size_t)zip->pack_stream_inbytes_remaining;
3489 zip->folder_outbytes_remaining =
3490 zip->pack_stream_inbytes_remaining;
3492 zip->folder_outbytes_remaining = sunpack[i];
3494 r = init_decompression(a, zip, coder, NULL);
3502 b[i] = malloc((size_t)zip->folder_outbytes_remaining);
3511 while (zip->pack_stream_inbytes_remaining > 0) {
3518 zip->uncompressed_buffer_bytes_remaining,
3526 if (zip->pack_stream_bytes_unconsumed)
3533 zip->sub_stream_buff[i] = b[idx[i]];
3534 zip->sub_stream_size[i] = s[idx[i]];
3535 zip->sub_stream_bytes_remaining[i] = s[idx[i]];
3539 if (zip->tmp_stream_buff == NULL) {
3540 zip->tmp_stream_buff_size = 32 * 1024;
3541 zip->tmp_stream_buff =
3542 malloc(zip->tmp_stream_buff_size);
3543 if (zip->tmp_stream_buff == NULL) {
3549 zip->tmp_stream_bytes_avail = 0;
3550 zip->tmp_stream_bytes_remaining = 0;
3551 zip->odd_bcj_size = 0;
3552 zip->bcj2_outPos = 0;
3558 zip->pack_stream_remaining = 1;
3559 zip->pack_stream_index = (unsigned)folder->packIndex;
3560 zip->folder_outbytes_remaining =
3562 zip->uncompressed_buffer_bytes_remaining = 0;
3568 r = init_decompression(a, zip, coder1, coder2);
3577 struct _7zip *zip = (struct _7zip *)a->format->data;
3582 if (zip->folder_index == 0) {
3587 zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3603 if (zip->pack_stream_bytes_unconsumed)
3620 x86_Init(struct _7zip *zip)
3622 zip->bcj_state = 0;
3623 zip->bcj_prevPosT = (size_t)0 - 1;
3624 zip->bcj_prevMask = 0;
3625 zip->bcj_ip = 5;
3629 x86_Convert(struct _7zip *zip, uint8_t *data, size_t size)
3640 prevPosT = zip->bcj_prevPosT;
3641 prevMask = zip->bcj_prevMask;
3642 ip = zip->bcj_ip;
3701 zip->bcj_prevPosT = prevPosT;
3702 zip->bcj_prevMask = prevMask;
3703 zip->bcj_ip += (uint32_t)bufferPos;
3729 #define RC_INIT2 zip->bcj2_code = 0; zip->bcj2_range = 0xFFFFFFFF; \
3730 { int ii; for (ii = 0; ii < 5; ii++) { RC_TEST; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }}
3732 #define NORMALIZE if (zip->bcj2_range < kTopValue) { RC_TEST; zip->bcj2_range <<= 8; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }
3734 #define IF_BIT_0(p) ttt = *(p); bound = (zip->bcj2_range >> kNumBitModelTotalBits) * ttt; if (zip->bcj2_code < bound)
3735 #define UPDATE_0(p) zip->bcj2_range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); NORMALIZE;
3736 #define UPDATE_1(p) zip->bcj2_range -= bound; zip->bcj2_code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); NORMALIZE;
3739 Bcj2_Decode(struct _7zip *zip, uint8_t *outBuf, size_t outSize)
3747 size0 = zip->tmp_stream_bytes_remaining;
3748 buf0 = zip->tmp_stream_buff + zip->tmp_stream_bytes_avail - size0;
3749 size1 = zip->sub_stream_bytes_remaining[0];
3750 buf1 = zip->sub_stream_buff[0] + zip->sub_stream_size[0] - size1;
3751 size2 = zip->sub_stream_bytes_remaining[1];
3752 buf2 = zip->sub_stream_buff[1] + zip->sub_stream_size[1] - size2;
3753 size3 = zip->sub_stream_bytes_remaining[2];
3754 buf3 = zip->sub_stream_buff[2] + zip->sub_stream_size[2] - size3;
3759 if (zip->bcj_state == 0) {
3763 zip->bcj2_prevByte = 0;
3765 i < sizeof(zip->bcj2_p) / sizeof(zip->bcj2_p[0]); i++)
3766 zip->bcj2_p[i] = kBitModelTotal >> 1;
3768 zip->bcj_state = 1;
3774 for (i = 0; zip->odd_bcj_size > 0 && outPos < outSize; i++) {
3775 outBuf[outPos++] = zip->odd_bcj[i];
3776 zip->odd_bcj_size--;
3780 zip->bcj2_outPos += outPos;
3794 if (zip->bcj_state == 1) {
3798 if (IsJ(zip->bcj2_prevByte, bb)) {
3799 zip->bcj_state = 2;
3803 zip->bcj2_prevByte = bb;
3810 zip->bcj_state = 1;
3815 prob = zip->bcj2_p + zip->bcj2_prevByte;
3817 prob = zip->bcj2_p + 256;
3819 prob = zip->bcj2_p + 257;
3823 zip->bcj2_prevByte = b;
3847 ((uint32_t)zip->bcj2_outPos + (uint32_t)outPos + 4);
3851 out[3] = zip->bcj2_prevByte = (uint8_t)(dest >> 24);
3860 zip->odd_bcj_size = 4 -i;
3862 j = i - 4 + (unsigned)zip->odd_bcj_size;
3863 zip->odd_bcj[j] = out[i];
3869 zip->tmp_stream_bytes_remaining -= inPos;
3870 zip->sub_stream_bytes_remaining[0] = size1;
3871 zip->sub_stream_bytes_remaining[1] = size2;
3872 zip->sub_stream_bytes_remaining[2] = bufferLim - buffer;
3873 zip->bcj2_outPos += outPos;