2 * Copyright (c) 2011 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD$");
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"
54 #include "archive_crc32.h"
57 #define _7ZIP_SIGNATURE "7z\xBC\xAF\x27\x1C"
58 #define SFX_MIN_ADDR 0x27000
59 #define SFX_MAX_ADDR 0x60000
66 #define _7Z_LZMA 0x030101
67 #define _7Z_LZMA2 0x21
68 #define _7Z_DEFLATE 0x040108
69 #define _7Z_BZ2 0x040202
70 #define _7Z_PPMD 0x030401
71 #define _7Z_DELTA 0x03
72 #define _7Z_CRYPTO_MAIN_ZIP 0x06F10101 /* Main Zip crypto algo */
73 #define _7Z_CRYPTO_RAR_29 0x06F10303 /* Rar29 AES-128 + (modified SHA-1) */
74 #define _7Z_CRYPTO_AES_256_SHA_256 0x06F10701 /* AES-256 + SHA-256 */
77 #define _7Z_X86 0x03030103
78 #define _7Z_X86_BCJ2 0x0303011B
79 #define _7Z_POWERPC 0x03030205
80 #define _7Z_IA64 0x03030401
81 #define _7Z_ARM 0x03030501
82 #define _7Z_ARMTHUMB 0x03030701
83 #define _7Z_SPARC 0x03030805
86 * 7-Zip header property IDs.
90 #define kArchiveProperties 0x02
91 #define kAdditionalStreamsInfo 0x03
92 #define kMainStreamsInfo 0x04
93 #define kFilesInfo 0x05
94 #define kPackInfo 0x06
95 #define kUnPackInfo 0x07
96 #define kSubStreamsInfo 0x08
100 #define kCodersUnPackSize 0x0C
101 #define kNumUnPackStream 0x0D
102 #define kEmptyStream 0x0E
103 #define kEmptyFile 0x0F
109 #define kAttributes 0x15
110 #define kEncodedHeader 0x17
114 unsigned char *defineds;
123 uint64_t numInStreams;
124 uint64_t numOutStreams;
125 uint64_t propertiesSize;
126 unsigned char *properties;
128 uint64_t numBindPairs;
133 uint64_t numPackedStreams;
134 uint64_t *packedStreams;
135 uint64_t numInStreams;
136 uint64_t numOutStreams;
137 uint64_t *unPackSize;
138 unsigned char digest_defined;
140 uint64_t numUnpackStreams;
142 /* Unoperated bytes. */
143 uint64_t skipped_bytes;
146 struct _7z_coders_info {
148 struct _7z_folder *folders;
149 uint64_t dataStreamIndex;
152 struct _7z_pack_info {
154 uint64_t numPackStreams;
156 struct _7z_digests digest;
157 /* Calculated from pos and numPackStreams. */
161 struct _7z_substream_info {
162 size_t unpack_streams;
163 uint64_t *unpackSizes;
164 unsigned char *digestsDefined;
168 struct _7z_stream_info {
169 struct _7z_pack_info pi;
170 struct _7z_coders_info ci;
171 struct _7z_substream_info ss;
174 struct _7z_header_info {
177 unsigned char *emptyStreamBools;
178 unsigned char *emptyFileBools;
179 unsigned char *antiBools;
180 unsigned char *attrBools;
185 unsigned char *utf16name;
186 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
187 const wchar_t *wname;
189 uint32_t folderIndex;
192 #define MTIME_IS_SET (1<<0)
193 #define ATIME_IS_SET (1<<1)
194 #define CTIME_IS_SET (1<<2)
195 #define CRC32_IS_SET (1<<3)
196 #define HAS_STREAM (1<<4)
209 /* Structural information about the archive. */
210 struct _7z_stream_info si;
212 int header_is_being_read;
213 int header_is_encoded;
214 uint64_t header_bytes_remaining;
215 unsigned long header_crc32;
216 /* Header offset to check that reading points of the file contents
217 * will not exceed the header. */
218 uint64_t header_offset;
219 /* Base offset of the archive file for a seek in case reading SFX. */
222 /* List of entries */
223 size_t entries_remaining;
225 struct _7zip_entry *entries;
226 struct _7zip_entry *entry;
227 unsigned char *entry_names;
229 /* entry_bytes_remaining is the number of bytes we expect. */
230 int64_t entry_offset;
231 uint64_t entry_bytes_remaining;
233 /* Running CRC32 of the decompressed data */
234 unsigned long entry_crc32;
236 /* Flags to mark progress of decompression. */
239 /* Uncompressed buffer control. */
240 #define UBUFF_SIZE (64 * 1024)
241 unsigned char *uncompressed_buffer;
242 unsigned char *uncompressed_buffer_pointer;
243 size_t uncompressed_buffer_size;
244 size_t uncompressed_buffer_bytes_remaining;
246 /* Offset of the compressed data. */
247 int64_t stream_offset;
250 * Decompressing control data.
252 unsigned folder_index;
253 uint64_t folder_outbytes_remaining;
254 unsigned pack_stream_index;
255 unsigned pack_stream_remaining;
256 uint64_t pack_stream_inbytes_remaining;
257 size_t pack_stream_bytes_unconsumed;
259 /* The codec information of a folder. */
261 unsigned long codec2;
264 * Decompressor controllers.
266 /* Decoding LZMA1 and LZMA2 data. */
268 lzma_stream lzstream;
271 /* Decoding bzip2 data. */
272 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
276 /* Decoding deflate data. */
281 /* Decoding PPMd data. */
283 CPpmd7 ppmd7_context;
284 CPpmd7z_RangeDec range_dec;
287 const unsigned char *next_in;
290 unsigned char *next_out;
297 /* Decoding BCJ and BCJ2 data. */
300 unsigned char odd_bcj[4];
301 /* Decoding BCJ data. */
303 uint32_t bcj_prevMask;
306 /* Decoding BCJ2 data. */
307 size_t main_stream_bytes_remaining;
308 unsigned char *sub_stream_buff[3];
309 size_t sub_stream_size[3];
310 size_t sub_stream_bytes_remaining[3];
311 unsigned char *tmp_stream_buff;
312 size_t tmp_stream_buff_size;
313 size_t tmp_stream_bytes_avail;
314 size_t tmp_stream_bytes_remaining;
316 #define CProb uint32_t
318 #define CProb uint16_t
320 CProb bcj2_p[256 + 2];
321 uint8_t bcj2_prevByte;
324 uint64_t bcj2_outPos;
326 /* Filename character-set conversion data. */
327 struct archive_string_conv *sconv;
329 char format_name[64];
331 /* Custom value that is non-zero if this archive contains encrypted entries. */
332 int has_encrypted_entries;
335 /* Maximum entry size. This limitation prevents reading intentional
336 * corrupted 7-zip files on assuming there are not so many entries in
338 #define UMAX_ENTRY ARCHIVE_LITERAL_ULL(100000000)
340 static int archive_read_format_7zip_has_encrypted_entries(struct archive_read *);
341 static int archive_read_support_format_7zip_capabilities(struct archive_read *a);
342 static int archive_read_format_7zip_bid(struct archive_read *, int);
343 static int archive_read_format_7zip_cleanup(struct archive_read *);
344 static int archive_read_format_7zip_read_data(struct archive_read *,
345 const void **, size_t *, int64_t *);
346 static int archive_read_format_7zip_read_data_skip(struct archive_read *);
347 static int archive_read_format_7zip_read_header(struct archive_read *,
348 struct archive_entry *);
349 static int check_7zip_header_in_sfx(const char *);
350 static unsigned long decode_codec_id(const unsigned char *, size_t);
351 static int decode_encoded_header_info(struct archive_read *,
352 struct _7z_stream_info *);
353 static int decompress(struct archive_read *, struct _7zip *,
354 void *, size_t *, const void *, size_t *);
355 static ssize_t extract_pack_stream(struct archive_read *, size_t);
356 static void fileTimeToUtc(uint64_t, time_t *, long *);
357 static uint64_t folder_uncompressed_size(struct _7z_folder *);
358 static void free_CodersInfo(struct _7z_coders_info *);
359 static void free_Digest(struct _7z_digests *);
360 static void free_Folder(struct _7z_folder *);
361 static void free_Header(struct _7z_header_info *);
362 static void free_PackInfo(struct _7z_pack_info *);
363 static void free_StreamsInfo(struct _7z_stream_info *);
364 static void free_SubStreamsInfo(struct _7z_substream_info *);
365 static int free_decompression(struct archive_read *, struct _7zip *);
366 static ssize_t get_uncompressed_data(struct archive_read *, const void **,
368 static const unsigned char * header_bytes(struct archive_read *, size_t);
369 static int init_decompression(struct archive_read *, struct _7zip *,
370 const struct _7z_coder *, const struct _7z_coder *);
371 static int parse_7zip_uint64(struct archive_read *, uint64_t *);
372 static int read_Bools(struct archive_read *, unsigned char *, size_t);
373 static int read_CodersInfo(struct archive_read *,
374 struct _7z_coders_info *);
375 static int read_Digests(struct archive_read *, struct _7z_digests *,
377 static int read_Folder(struct archive_read *, struct _7z_folder *);
378 static int read_Header(struct archive_read *, struct _7z_header_info *,
380 static int read_PackInfo(struct archive_read *, struct _7z_pack_info *);
381 static int read_StreamsInfo(struct archive_read *,
382 struct _7z_stream_info *);
383 static int read_SubStreamsInfo(struct archive_read *,
384 struct _7z_substream_info *, struct _7z_folder *, size_t);
385 static int read_Times(struct archive_read *, struct _7z_header_info *,
387 static void read_consume(struct archive_read *);
388 static ssize_t read_stream(struct archive_read *, const void **, size_t,
390 static int seek_pack(struct archive_read *);
391 static int64_t skip_stream(struct archive_read *, size_t);
392 static int skip_sfx(struct archive_read *, ssize_t);
393 static int slurp_central_directory(struct archive_read *, struct _7zip *,
394 struct _7z_header_info *);
395 static int setup_decode_folder(struct archive_read *, struct _7z_folder *,
397 static void x86_Init(struct _7zip *);
398 static size_t x86_Convert(struct _7zip *, uint8_t *, size_t);
399 static ssize_t Bcj2_Decode(struct _7zip *, uint8_t *, size_t);
403 archive_read_support_format_7zip(struct archive *_a)
405 struct archive_read *a = (struct archive_read *)_a;
409 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
410 ARCHIVE_STATE_NEW, "archive_read_support_format_7zip");
412 zip = calloc(1, sizeof(*zip));
414 archive_set_error(&a->archive, ENOMEM,
415 "Can't allocate 7zip data");
416 return (ARCHIVE_FATAL);
420 * Until enough data has been read, we cannot tell about
421 * any encrypted entries yet.
423 zip->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
426 r = __archive_read_register_format(a,
429 archive_read_format_7zip_bid,
431 archive_read_format_7zip_read_header,
432 archive_read_format_7zip_read_data,
433 archive_read_format_7zip_read_data_skip,
435 archive_read_format_7zip_cleanup,
436 archive_read_support_format_7zip_capabilities,
437 archive_read_format_7zip_has_encrypted_entries);
445 archive_read_support_format_7zip_capabilities(struct archive_read * a)
447 (void)a; /* UNUSED */
448 return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA |
449 ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);
454 archive_read_format_7zip_has_encrypted_entries(struct archive_read *_a)
456 if (_a && _a->format) {
457 struct _7zip * zip = (struct _7zip *)_a->format->data;
459 return zip->has_encrypted_entries;
462 return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
466 archive_read_format_7zip_bid(struct archive_read *a, int best_bid)
470 /* If someone has already bid more than 32, then avoid
471 trashing the look-ahead buffers with a seek. */
475 if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)
478 /* If first six bytes are the 7-Zip signature,
479 * return the bid right now. */
480 if (memcmp(p, _7ZIP_SIGNATURE, 6) == 0)
484 * It may a 7-Zip SFX archive file. If first two bytes are
485 * 'M' and 'Z' available on Windows or first four bytes are
486 * "\x7F\x45LF" available on posix like system, seek the 7-Zip
487 * signature. Although we will perform a seek when reading
488 * a header, what we do not use __archive_read_seek() here is
489 * due to a bidding performance.
491 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
492 ssize_t offset = SFX_MIN_ADDR;
493 ssize_t window = 4096;
495 while (offset + window <= (SFX_MAX_ADDR)) {
496 const char *buff = __archive_read_ahead(a,
497 offset + window, &bytes_avail);
499 /* Remaining bytes are less than window. */
506 while (p + 32 < buff + bytes_avail) {
507 int step = check_7zip_header_in_sfx(p);
519 check_7zip_header_in_sfx(const char *p)
521 switch ((unsigned char)p[5]) {
523 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0)
526 * Test the CRC because its extraction code has 7-Zip
527 * Magic Code, so we should do this in order not to
528 * make a mis-detection.
530 if (crc32(0, (const unsigned char *)p + 12, 20)
531 != archive_le32dec(p + 8))
533 /* Hit the header! */
535 case 0x37: return (5);
536 case 0x7A: return (4);
537 case 0xBC: return (3);
538 case 0xAF: return (2);
539 case 0x27: return (1);
545 skip_sfx(struct archive_read *a, ssize_t bytes_avail)
550 ssize_t bytes, window;
553 * If bytes_avail > SFX_MIN_ADDR we do not have to call
554 * __archive_read_seek() at this time since we have
555 * already had enough data.
557 if (bytes_avail > SFX_MIN_ADDR)
558 __archive_read_consume(a, SFX_MIN_ADDR);
559 else if (__archive_read_seek(a, SFX_MIN_ADDR, SEEK_SET) < 0)
560 return (ARCHIVE_FATAL);
564 while (offset + window <= SFX_MAX_ADDR - SFX_MIN_ADDR) {
565 h = __archive_read_ahead(a, window, &bytes);
567 /* Remaining bytes are less than window. */
574 /* This case might happen when window == 1. */
582 * Scan ahead until we find something that looks
583 * like the 7-Zip header.
586 int step = check_7zip_header_in_sfx(p);
589 (struct _7zip *)a->format->data;
590 skip = p - (const char *)h;
591 __archive_read_consume(a, skip);
592 zip->seek_base = SFX_MIN_ADDR + offset + skip;
597 skip = p - (const char *)h;
598 __archive_read_consume(a, skip);
604 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
605 "Couldn't find out 7-Zip header");
606 return (ARCHIVE_FATAL);
610 archive_read_format_7zip_read_header(struct archive_read *a,
611 struct archive_entry *entry)
613 struct _7zip *zip = (struct _7zip *)a->format->data;
614 struct _7zip_entry *zip_entry;
615 int r, ret = ARCHIVE_OK;
616 struct _7z_folder *folder = 0;
620 * It should be sufficient to call archive_read_next_header() for
621 * a reader to determine if an entry is encrypted or not. If the
622 * encryption of an entry is only detectable when calling
623 * archive_read_data(), so be it. We'll do the same check there
626 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
627 zip->has_encrypted_entries = 0;
630 a->archive.archive_format = ARCHIVE_FORMAT_7ZIP;
631 if (a->archive.archive_format_name == NULL)
632 a->archive.archive_format_name = "7-Zip";
634 if (zip->entries == NULL) {
635 struct _7z_header_info header;
637 memset(&header, 0, sizeof(header));
638 r = slurp_central_directory(a, zip, &header);
639 free_Header(&header);
642 zip->entries_remaining = (size_t)zip->numFiles;
643 zip->entry = zip->entries;
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);
657 /* Setup a string conversion for a filename. */
658 if (zip->sconv == NULL) {
659 zip->sconv = archive_string_conversion_from_charset(
660 &a->archive, "UTF-16LE", 1);
661 if (zip->sconv == NULL)
662 return (ARCHIVE_FATAL);
665 /* Figure out if the entry is encrypted by looking at the folder
666 that is associated to the current 7zip entry. If the folder
667 has a coder with a _7Z_CRYPTO codec then the folder is encrypted.
668 Hence the entry must also be encrypted. */
669 if (zip_entry && zip_entry->folderIndex < zip->si.ci.numFolders) {
670 folder = &(zip->si.ci.folders[zip_entry->folderIndex]);
671 for (fidx=0; folder && fidx<folder->numCoders; fidx++) {
672 switch(folder->coders[fidx].codec) {
673 case _7Z_CRYPTO_MAIN_ZIP:
674 case _7Z_CRYPTO_RAR_29:
675 case _7Z_CRYPTO_AES_256_SHA_256: {
676 archive_entry_set_is_data_encrypted(entry, 1);
677 zip->has_encrypted_entries = 1;
684 /* Now that we've checked for encryption, if there were still no
685 * encrypted entries found we can say for sure that there are none.
687 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
688 zip->has_encrypted_entries = 0;
691 if (archive_entry_copy_pathname_l(entry,
692 (const char *)zip_entry->utf16name,
693 zip_entry->name_len, zip->sconv) != 0) {
694 if (errno == ENOMEM) {
695 archive_set_error(&a->archive, ENOMEM,
696 "Can't allocate memory for Pathname");
697 return (ARCHIVE_FATAL);
699 archive_set_error(&a->archive,
700 ARCHIVE_ERRNO_FILE_FORMAT,
701 "Pathname cannot be converted "
702 "from %s to current locale.",
703 archive_string_conversion_charset_name(zip->sconv));
707 /* Populate some additional entry fields: */
708 archive_entry_set_mode(entry, zip_entry->mode);
709 if (zip_entry->flg & MTIME_IS_SET)
710 archive_entry_set_mtime(entry, zip_entry->mtime,
711 zip_entry->mtime_ns);
712 if (zip_entry->flg & CTIME_IS_SET)
713 archive_entry_set_ctime(entry, zip_entry->ctime,
714 zip_entry->ctime_ns);
715 if (zip_entry->flg & ATIME_IS_SET)
716 archive_entry_set_atime(entry, zip_entry->atime,
717 zip_entry->atime_ns);
718 if (zip_entry->ssIndex != (uint32_t)-1) {
719 zip->entry_bytes_remaining =
720 zip->si.ss.unpackSizes[zip_entry->ssIndex];
721 archive_entry_set_size(entry, zip->entry_bytes_remaining);
723 zip->entry_bytes_remaining = 0;
724 archive_entry_set_size(entry, 0);
727 /* If there's no body, force read_data() to return EOF immediately. */
728 if (zip->entry_bytes_remaining < 1)
729 zip->end_of_entry = 1;
731 if ((zip_entry->mode & AE_IFMT) == AE_IFLNK) {
732 unsigned char *symname = NULL;
736 * Symbolic-name is recorded as its contents. We have to
737 * read the contents at this time.
739 while (zip->entry_bytes_remaining > 0) {
745 r = archive_read_format_7zip_read_data(a, &buff,
747 if (r < ARCHIVE_WARN) {
751 mem = realloc(symname, symsize + size + 1);
754 archive_set_error(&a->archive, ENOMEM,
755 "Can't allocate memory for Symname");
756 return (ARCHIVE_FATAL);
759 memcpy(symname+symsize, buff, size);
763 /* If there is no symname, handle it as a regular
765 zip_entry->mode &= ~AE_IFMT;
766 zip_entry->mode |= AE_IFREG;
767 archive_entry_set_mode(entry, zip_entry->mode);
769 symname[symsize] = '\0';
770 archive_entry_copy_symlink(entry,
771 (const char *)symname);
774 archive_entry_set_size(entry, 0);
777 /* Set up a more descriptive format name. */
778 sprintf(zip->format_name, "7-Zip");
779 a->archive.archive_format_name = zip->format_name;
785 archive_read_format_7zip_read_data(struct archive_read *a,
786 const void **buff, size_t *size, int64_t *offset)
790 int ret = ARCHIVE_OK;
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;
805 * If we hit end-of-entry last time, clean up and return
806 * ARCHIVE_EOF this time.
808 if (zip->end_of_entry)
809 return (ARCHIVE_EOF);
811 bytes = read_stream(a, buff,
812 (size_t)zip->entry_bytes_remaining, 0);
816 archive_set_error(&a->archive,
817 ARCHIVE_ERRNO_FILE_FORMAT,
818 "Truncated 7-Zip file body");
819 return (ARCHIVE_FATAL);
821 zip->entry_bytes_remaining -= bytes;
822 if (zip->entry_bytes_remaining == 0)
823 zip->end_of_entry = 1;
825 /* Update checksum */
826 if ((zip->entry->flg & CRC32_IS_SET) && bytes)
827 zip->entry_crc32 = crc32(zip->entry_crc32, *buff,
830 /* If we hit the end, swallow any end-of-data marker. */
831 if (zip->end_of_entry) {
832 /* Check computed CRC against file contents. */
833 if ((zip->entry->flg & CRC32_IS_SET) &&
834 zip->si.ss.digests[zip->entry->ssIndex] !=
836 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
837 "7-Zip bad CRC: 0x%lx should be 0x%lx",
838 (unsigned long)zip->entry_crc32,
839 (unsigned long)zip->si.ss.digests[
840 zip->entry->ssIndex]);
846 *offset = zip->entry_offset;
847 zip->entry_offset += bytes;
853 archive_read_format_7zip_read_data_skip(struct archive_read *a)
856 int64_t bytes_skipped;
858 zip = (struct _7zip *)(a->format->data);
860 if (zip->pack_stream_bytes_unconsumed)
863 /* If we've already read to end of data, we're done. */
864 if (zip->end_of_entry)
868 * If the length is at the beginning, we can skip the
869 * compressed data much more quickly.
871 bytes_skipped = skip_stream(a, (size_t)zip->entry_bytes_remaining);
872 if (bytes_skipped < 0)
873 return (ARCHIVE_FATAL);
874 zip->entry_bytes_remaining = 0;
876 /* This entry is finished and done. */
877 zip->end_of_entry = 1;
882 archive_read_format_7zip_cleanup(struct archive_read *a)
886 zip = (struct _7zip *)(a->format->data);
887 free_StreamsInfo(&(zip->si));
889 free(zip->entry_names);
890 free_decompression(a, zip);
891 free(zip->uncompressed_buffer);
892 free(zip->sub_stream_buff[0]);
893 free(zip->sub_stream_buff[1]);
894 free(zip->sub_stream_buff[2]);
895 free(zip->tmp_stream_buff);
897 (a->format->data) = NULL;
902 read_consume(struct archive_read *a)
904 struct _7zip *zip = (struct _7zip *)a->format->data;
906 if (zip->pack_stream_bytes_unconsumed) {
907 __archive_read_consume(a, zip->pack_stream_bytes_unconsumed);
908 zip->stream_offset += zip->pack_stream_bytes_unconsumed;
909 zip->pack_stream_bytes_unconsumed = 0;
916 * Set an error code and choose an error message for liblzma.
919 set_error(struct archive_read *a, int ret)
923 case LZMA_STREAM_END: /* Found end of stream. */
924 case LZMA_OK: /* Decompressor made some progress. */
927 archive_set_error(&a->archive, ENOMEM,
928 "Lzma library error: Cannot allocate memory");
930 case LZMA_MEMLIMIT_ERROR:
931 archive_set_error(&a->archive, ENOMEM,
932 "Lzma library error: Out of memory");
934 case LZMA_FORMAT_ERROR:
935 archive_set_error(&a->archive,
937 "Lzma library error: format not recognized");
939 case LZMA_OPTIONS_ERROR:
940 archive_set_error(&a->archive,
942 "Lzma library error: Invalid options");
944 case LZMA_DATA_ERROR:
945 archive_set_error(&a->archive,
947 "Lzma library error: Corrupted input data");
950 archive_set_error(&a->archive,
952 "Lzma library error: No progress is possible");
955 /* Return an error. */
956 archive_set_error(&a->archive,
958 "Lzma decompression failed: Unknown error");
966 decode_codec_id(const unsigned char *codecId, size_t id_size)
969 unsigned long id = 0;
971 for (i = 0; i < id_size; i++) {
979 ppmd_alloc(void *p, size_t size)
985 ppmd_free(void *p, void *address)
993 struct archive_read *a = ((IByteIn*)p)->a;
994 struct _7zip *zip = (struct _7zip *)(a->format->data);
997 if (zip->ppstream.avail_in == 0) {
998 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
999 "Truncated RAR file data");
1000 zip->ppstream.overconsumed = 1;
1003 b = *zip->ppstream.next_in++;
1004 zip->ppstream.avail_in--;
1005 zip->ppstream.total_in++;
1009 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free };
1012 init_decompression(struct archive_read *a, struct _7zip *zip,
1013 const struct _7z_coder *coder1, const struct _7z_coder *coder2)
1017 zip->codec = coder1->codec;
1020 switch (zip->codec) {
1025 if (coder2 != NULL) {
1026 if (coder2->codec != _7Z_X86 &&
1027 coder2->codec != _7Z_X86_BCJ2) {
1028 archive_set_error(&a->archive,
1030 "Unsupported filter %lx for %lx",
1031 coder2->codec, coder1->codec);
1032 return (ARCHIVE_FAILED);
1034 zip->codec2 = coder2->codec;
1036 if (coder2->codec == _7Z_X86)
1044 switch (zip->codec) {
1048 case _7Z_LZMA: case _7Z_LZMA2:
1050 #if LZMA_VERSION_MAJOR >= 5
1051 /* Effectively disable the limiter. */
1052 #define LZMA_MEMLIMIT UINT64_MAX
1054 /* NOTE: This needs to check memory size which running system has. */
1055 #define LZMA_MEMLIMIT (1U << 30)
1058 lzma_options_delta delta_opt;
1059 lzma_filter filters[LZMA_FILTERS_MAX], *ff;
1062 if (zip->lzstream_valid) {
1063 lzma_end(&(zip->lzstream));
1064 zip->lzstream_valid = 0;
1068 * NOTE: liblzma incompletely handle the BCJ+LZMA compressed
1069 * data made by 7-Zip because 7-Zip does not add End-Of-
1070 * Payload Marker(EOPM) at the end of LZMA compressed data,
1071 * and so liblzma cannot know the end of the compressed data
1072 * without EOPM. So consequently liblzma will not return last
1073 * three or four bytes of uncompressed data because
1074 * LZMA_FILTER_X86 filter does not handle input data if its
1075 * data size is less than five bytes. If liblzma detect EOPM
1076 * or know the uncompressed data size, liblzma will flush out
1077 * the remaining that three or four bytes of uncompressed
1078 * data. That is why we have to use our converting program
1079 * for BCJ+LZMA. If we were able to tell the uncompressed
1080 * size to liblzma when using lzma_raw_decoder() liblzma
1081 * could correctly deal with BCJ+LZMA. But unfortunately
1082 * there is no way to do that.
1083 * Discussion about this can be found at XZ Utils forum.
1085 if (coder2 != NULL) {
1086 zip->codec2 = coder2->codec;
1088 filters[fi].options = NULL;
1089 switch (zip->codec2) {
1091 if (zip->codec == _7Z_LZMA2) {
1092 filters[fi].id = LZMA_FILTER_X86;
1095 /* Use our filter. */
1099 /* Use our filter. */
1103 filters[fi].id = LZMA_FILTER_DELTA;
1104 memset(&delta_opt, 0, sizeof(delta_opt));
1105 delta_opt.type = LZMA_DELTA_TYPE_BYTE;
1107 filters[fi].options = &delta_opt;
1110 /* Following filters have not been tested yet. */
1112 filters[fi].id = LZMA_FILTER_POWERPC;
1116 filters[fi].id = LZMA_FILTER_IA64;
1120 filters[fi].id = LZMA_FILTER_ARM;
1124 filters[fi].id = LZMA_FILTER_ARMTHUMB;
1128 filters[fi].id = LZMA_FILTER_SPARC;
1132 archive_set_error(&a->archive,
1134 "Unexpected codec ID: %lX", zip->codec2);
1135 return (ARCHIVE_FAILED);
1139 if (zip->codec == _7Z_LZMA2)
1140 filters[fi].id = LZMA_FILTER_LZMA2;
1142 filters[fi].id = LZMA_FILTER_LZMA1;
1143 filters[fi].options = NULL;
1145 r = lzma_properties_decode(&filters[fi], NULL,
1146 coder1->properties, (size_t)coder1->propertiesSize);
1149 return (ARCHIVE_FAILED);
1153 filters[fi].id = LZMA_VLI_UNKNOWN;
1154 filters[fi].options = NULL;
1155 r = lzma_raw_decoder(&(zip->lzstream), filters);
1159 return (ARCHIVE_FAILED);
1161 zip->lzstream_valid = 1;
1162 zip->lzstream.total_in = 0;
1163 zip->lzstream.total_out = 0;
1167 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1168 "LZMA codec is unsupported");
1169 return (ARCHIVE_FAILED);
1172 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1173 if (zip->bzstream_valid) {
1174 BZ2_bzDecompressEnd(&(zip->bzstream));
1175 zip->bzstream_valid = 0;
1177 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 0);
1178 if (r == BZ_MEM_ERROR)
1179 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 1);
1181 int err = ARCHIVE_ERRNO_MISC;
1182 const char *detail = NULL;
1184 case BZ_PARAM_ERROR:
1185 detail = "invalid setup parameter";
1189 detail = "out of memory";
1191 case BZ_CONFIG_ERROR:
1192 detail = "mis-compiled library";
1195 archive_set_error(&a->archive, err,
1196 "Internal error initializing decompressor: %s",
1197 detail != NULL ? detail : "??");
1198 zip->bzstream_valid = 0;
1199 return (ARCHIVE_FAILED);
1201 zip->bzstream_valid = 1;
1202 zip->bzstream.total_in_lo32 = 0;
1203 zip->bzstream.total_in_hi32 = 0;
1204 zip->bzstream.total_out_lo32 = 0;
1205 zip->bzstream.total_out_hi32 = 0;
1208 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1209 "BZ2 codec is unsupported");
1210 return (ARCHIVE_FAILED);
1214 if (zip->stream_valid)
1215 r = inflateReset(&(zip->stream));
1217 r = inflateInit2(&(zip->stream),
1218 -15 /* Don't check for zlib header */);
1220 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1221 "Couldn't initialize zlib stream.");
1222 return (ARCHIVE_FAILED);
1224 zip->stream_valid = 1;
1225 zip->stream.total_in = 0;
1226 zip->stream.total_out = 0;
1229 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1230 "DEFLATE codec is unsupported");
1231 return (ARCHIVE_FAILED);
1238 if (zip->ppmd7_valid) {
1239 __archive_ppmd7_functions.Ppmd7_Free(
1240 &zip->ppmd7_context, &g_szalloc);
1241 zip->ppmd7_valid = 0;
1244 if (coder1->propertiesSize < 5) {
1245 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1246 "Malformed PPMd parameter");
1247 return (ARCHIVE_FAILED);
1249 order = coder1->properties[0];
1250 msize = archive_le32dec(&(coder1->properties[1]));
1251 if (order < PPMD7_MIN_ORDER || order > PPMD7_MAX_ORDER ||
1252 msize < PPMD7_MIN_MEM_SIZE || msize > PPMD7_MAX_MEM_SIZE) {
1253 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1254 "Malformed PPMd parameter");
1255 return (ARCHIVE_FAILED);
1257 __archive_ppmd7_functions.Ppmd7_Construct(&zip->ppmd7_context);
1258 r = __archive_ppmd7_functions.Ppmd7_Alloc(
1259 &zip->ppmd7_context, msize, &g_szalloc);
1261 archive_set_error(&a->archive, ENOMEM,
1262 "Coludn't allocate memory for PPMd");
1263 return (ARCHIVE_FATAL);
1265 __archive_ppmd7_functions.Ppmd7_Init(
1266 &zip->ppmd7_context, order);
1267 __archive_ppmd7_functions.Ppmd7z_RangeDec_CreateVTable(
1269 zip->ppmd7_valid = 1;
1270 zip->ppmd7_stat = 0;
1271 zip->ppstream.overconsumed = 0;
1272 zip->ppstream.total_in = 0;
1273 zip->ppstream.total_out = 0;
1284 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1285 "Unexpected codec ID: %lX", zip->codec);
1286 return (ARCHIVE_FAILED);
1287 case _7Z_CRYPTO_MAIN_ZIP:
1288 case _7Z_CRYPTO_RAR_29:
1289 case _7Z_CRYPTO_AES_256_SHA_256:
1291 archive_entry_set_is_metadata_encrypted(a->entry, 1);
1292 archive_entry_set_is_data_encrypted(a->entry, 1);
1293 zip->has_encrypted_entries = 1;
1295 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1296 "Crypto codec not supported yet (ID: 0x%lX)", zip->codec);
1297 return (ARCHIVE_FAILED);
1299 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1300 "Unknown codec ID: %lX", zip->codec);
1301 return (ARCHIVE_FAILED);
1304 return (ARCHIVE_OK);
1308 decompress(struct archive_read *a, struct _7zip *zip,
1309 void *buff, size_t *outbytes, const void *b, size_t *used)
1311 const uint8_t *t_next_in;
1312 uint8_t *t_next_out;
1313 size_t o_avail_in, o_avail_out;
1314 size_t t_avail_in, t_avail_out;
1315 uint8_t *bcj2_next_out;
1316 size_t bcj2_avail_out;
1317 int r, ret = ARCHIVE_OK;
1319 t_avail_in = o_avail_in = *used;
1320 t_avail_out = o_avail_out = *outbytes;
1324 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1327 /* Do not copy out the BCJ remaining bytes when the output
1328 * buffer size is less than five bytes. */
1329 if (o_avail_in != 0 && t_avail_out < 5 && zip->odd_bcj_size) {
1334 for (i = 0; zip->odd_bcj_size > 0 && t_avail_out; i++) {
1335 *t_next_out++ = zip->odd_bcj[i];
1337 zip->odd_bcj_size--;
1339 if (o_avail_in == 0 || t_avail_out == 0) {
1340 *used = o_avail_in - t_avail_in;
1341 *outbytes = o_avail_out - t_avail_out;
1342 if (o_avail_in == 0)
1348 bcj2_next_out = t_next_out;
1349 bcj2_avail_out = t_avail_out;
1350 if (zip->codec2 == _7Z_X86_BCJ2) {
1352 * Decord a remaining decompressed main stream for BCJ2.
1354 if (zip->tmp_stream_bytes_remaining) {
1356 size_t remaining = zip->tmp_stream_bytes_remaining;
1357 bytes = Bcj2_Decode(zip, t_next_out, t_avail_out);
1359 archive_set_error(&(a->archive),
1361 "BCJ2 conversion Failed");
1362 return (ARCHIVE_FAILED);
1364 zip->main_stream_bytes_remaining -=
1365 remaining - zip->tmp_stream_bytes_remaining;
1366 t_avail_out -= bytes;
1367 if (o_avail_in == 0 || t_avail_out == 0) {
1369 *outbytes = o_avail_out - t_avail_out;
1370 if (o_avail_in == 0 &&
1371 zip->tmp_stream_bytes_remaining)
1375 t_next_out += bytes;
1376 bcj2_next_out = t_next_out;
1377 bcj2_avail_out = t_avail_out;
1379 t_next_out = zip->tmp_stream_buff;
1380 t_avail_out = zip->tmp_stream_buff_size;
1383 switch (zip->codec) {
1387 (t_avail_in > t_avail_out)?t_avail_out:t_avail_in;
1389 memcpy(t_next_out, t_next_in, bytes);
1390 t_avail_in -= bytes;
1391 t_avail_out -= bytes;
1392 if (o_avail_in == 0)
1397 case _7Z_LZMA: case _7Z_LZMA2:
1398 zip->lzstream.next_in = t_next_in;
1399 zip->lzstream.avail_in = t_avail_in;
1400 zip->lzstream.next_out = t_next_out;
1401 zip->lzstream.avail_out = t_avail_out;
1403 r = lzma_code(&(zip->lzstream), LZMA_RUN);
1405 case LZMA_STREAM_END: /* Found end of stream. */
1406 lzma_end(&(zip->lzstream));
1407 zip->lzstream_valid = 0;
1410 case LZMA_OK: /* Decompressor made some progress. */
1413 archive_set_error(&(a->archive),
1415 "Decompression failed(%d)",
1417 return (ARCHIVE_FAILED);
1419 t_avail_in = zip->lzstream.avail_in;
1420 t_avail_out = zip->lzstream.avail_out;
1423 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1425 zip->bzstream.next_in = (char *)(uintptr_t)t_next_in;
1426 zip->bzstream.avail_in = t_avail_in;
1427 zip->bzstream.next_out = (char *)(uintptr_t)t_next_out;
1428 zip->bzstream.avail_out = t_avail_out;
1429 r = BZ2_bzDecompress(&(zip->bzstream));
1431 case BZ_STREAM_END: /* Found end of stream. */
1432 switch (BZ2_bzDecompressEnd(&(zip->bzstream))) {
1436 archive_set_error(&(a->archive),
1438 "Failed to clean up decompressor");
1439 return (ARCHIVE_FAILED);
1441 zip->bzstream_valid = 0;
1444 case BZ_OK: /* Decompressor made some progress. */
1447 archive_set_error(&(a->archive),
1449 "bzip decompression failed");
1450 return (ARCHIVE_FAILED);
1452 t_avail_in = zip->bzstream.avail_in;
1453 t_avail_out = zip->bzstream.avail_out;
1458 zip->stream.next_in = (Bytef *)(uintptr_t)t_next_in;
1459 zip->stream.avail_in = (uInt)t_avail_in;
1460 zip->stream.next_out = t_next_out;
1461 zip->stream.avail_out = (uInt)t_avail_out;
1462 r = inflate(&(zip->stream), 0);
1464 case Z_STREAM_END: /* Found end of stream. */
1467 case Z_OK: /* Decompressor made some progress.*/
1470 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1471 "File decompression failed (%d)", r);
1472 return (ARCHIVE_FAILED);
1474 t_avail_in = zip->stream.avail_in;
1475 t_avail_out = zip->stream.avail_out;
1480 uint64_t flush_bytes;
1482 if (!zip->ppmd7_valid || zip->ppmd7_stat < 0 ||
1484 archive_set_error(&(a->archive),
1486 "Decompression internal error");
1487 return (ARCHIVE_FAILED);
1489 zip->ppstream.next_in = t_next_in;
1490 zip->ppstream.avail_in = t_avail_in;
1491 zip->ppstream.next_out = t_next_out;
1492 zip->ppstream.avail_out = t_avail_out;
1493 if (zip->ppmd7_stat == 0) {
1495 zip->bytein.Read = &ppmd_read;
1496 zip->range_dec.Stream = &zip->bytein;
1497 r = __archive_ppmd7_functions.Ppmd7z_RangeDec_Init(
1500 zip->ppmd7_stat = -1;
1501 archive_set_error(&a->archive,
1503 "Failed to initialize PPMd range decorder");
1504 return (ARCHIVE_FAILED);
1506 if (zip->ppstream.overconsumed) {
1507 zip->ppmd7_stat = -1;
1508 return (ARCHIVE_FAILED);
1510 zip->ppmd7_stat = 1;
1513 if (t_avail_in == 0)
1514 /* XXX Flush out remaining decoded data XXX */
1515 flush_bytes = zip->folder_outbytes_remaining;
1522 sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1523 &(zip->ppmd7_context), &(zip->range_dec.p));
1525 zip->ppmd7_stat = -1;
1526 archive_set_error(&a->archive,
1527 ARCHIVE_ERRNO_FILE_FORMAT,
1528 "Failed to decode PPMd");
1529 return (ARCHIVE_FAILED);
1531 if (zip->ppstream.overconsumed) {
1532 zip->ppmd7_stat = -1;
1533 return (ARCHIVE_FAILED);
1535 *zip->ppstream.next_out++ = (unsigned char)sym;
1536 zip->ppstream.avail_out--;
1537 zip->ppstream.total_out++;
1540 } while (zip->ppstream.avail_out &&
1541 (zip->ppstream.avail_in || flush_bytes));
1543 t_avail_in = (size_t)zip->ppstream.avail_in;
1544 t_avail_out = (size_t)zip->ppstream.avail_out;
1548 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
1549 "Decompression internal error");
1550 return (ARCHIVE_FAILED);
1552 if (ret != ARCHIVE_OK && ret != ARCHIVE_EOF)
1555 *used = o_avail_in - t_avail_in;
1556 *outbytes = o_avail_out - t_avail_out;
1561 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1562 size_t l = x86_Convert(zip, buff, *outbytes);
1563 zip->odd_bcj_size = *outbytes - l;
1564 if (zip->odd_bcj_size > 0 && zip->odd_bcj_size <= 4 &&
1565 o_avail_in && ret != ARCHIVE_EOF) {
1566 memcpy(zip->odd_bcj, ((unsigned char *)buff) + l,
1570 zip->odd_bcj_size = 0;
1574 * Decord BCJ2 with a decompressed main stream.
1576 if (zip->codec2 == _7Z_X86_BCJ2) {
1579 zip->tmp_stream_bytes_avail =
1580 zip->tmp_stream_buff_size - t_avail_out;
1581 if (zip->tmp_stream_bytes_avail >
1582 zip->main_stream_bytes_remaining)
1583 zip->tmp_stream_bytes_avail =
1584 zip->main_stream_bytes_remaining;
1585 zip->tmp_stream_bytes_remaining = zip->tmp_stream_bytes_avail;
1586 bytes = Bcj2_Decode(zip, bcj2_next_out, bcj2_avail_out);
1588 archive_set_error(&(a->archive),
1589 ARCHIVE_ERRNO_MISC, "BCJ2 conversion Failed");
1590 return (ARCHIVE_FAILED);
1592 zip->main_stream_bytes_remaining -=
1593 zip->tmp_stream_bytes_avail
1594 - zip->tmp_stream_bytes_remaining;
1595 bcj2_avail_out -= bytes;
1596 *outbytes = o_avail_out - bcj2_avail_out;
1603 free_decompression(struct archive_read *a, struct _7zip *zip)
1607 #if !defined(HAVE_ZLIB_H) &&\
1608 !(defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR))
1609 (void)a;/* UNUSED */
1612 if (zip->lzstream_valid)
1613 lzma_end(&(zip->lzstream));
1615 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1616 if (zip->bzstream_valid) {
1617 if (BZ2_bzDecompressEnd(&(zip->bzstream)) != BZ_OK) {
1618 archive_set_error(&a->archive,
1620 "Failed to clean up bzip2 decompressor");
1623 zip->bzstream_valid = 0;
1627 if (zip->stream_valid) {
1628 if (inflateEnd(&(zip->stream)) != Z_OK) {
1629 archive_set_error(&a->archive,
1631 "Failed to clean up zlib decompressor");
1634 zip->stream_valid = 0;
1637 if (zip->ppmd7_valid) {
1638 __archive_ppmd7_functions.Ppmd7_Free(
1639 &zip->ppmd7_context, &g_szalloc);
1640 zip->ppmd7_valid = 0;
1646 parse_7zip_uint64(struct archive_read *a, uint64_t *val)
1648 const unsigned char *p;
1649 unsigned char avail, mask;
1652 if ((p = header_bytes(a, 1)) == NULL)
1657 for (i = 0; i < 8; i++) {
1659 if ((p = header_bytes(a, 1)) == NULL)
1661 *val |= ((uint64_t)*p) << (8 * i);
1665 *val += ((uint64_t)(avail & (mask -1))) << (8 * i);
1672 read_Bools(struct archive_read *a, unsigned char *data, size_t num)
1674 const unsigned char *p;
1675 unsigned i, mask = 0, avail = 0;
1677 for (i = 0; i < num; i++) {
1679 if ((p = header_bytes(a, 1)) == NULL)
1684 data[i] = (avail & mask)?1:0;
1691 free_Digest(struct _7z_digests *d)
1698 read_Digests(struct archive_read *a, struct _7z_digests *d, size_t num)
1700 const unsigned char *p;
1705 memset(d, 0, sizeof(*d));
1707 d->defineds = malloc(num);
1708 if (d->defineds == NULL)
1713 if ((p = header_bytes(a, 1)) == NULL)
1716 if (read_Bools(a, d->defineds, num) < 0)
1719 /* All are defined */
1720 memset(d->defineds, 1, num);
1722 d->digests = calloc(num, sizeof(*d->digests));
1723 if (d->digests == NULL)
1725 for (i = 0; i < num; i++) {
1726 if (d->defineds[i]) {
1727 if ((p = header_bytes(a, 4)) == NULL)
1729 d->digests[i] = archive_le32dec(p);
1737 free_PackInfo(struct _7z_pack_info *pi)
1740 free(pi->positions);
1741 free_Digest(&(pi->digest));
1745 read_PackInfo(struct archive_read *a, struct _7z_pack_info *pi)
1747 const unsigned char *p;
1750 memset(pi, 0, sizeof(*pi));
1755 if (parse_7zip_uint64(a, &(pi->pos)) < 0)
1759 * Read NumPackStreams.
1761 if (parse_7zip_uint64(a, &(pi->numPackStreams)) < 0)
1763 if (pi->numPackStreams == 0)
1765 if (UMAX_ENTRY < pi->numPackStreams)
1769 * Read PackSizes[num]
1771 if ((p = header_bytes(a, 1)) == NULL)
1774 /* PackSizes[num] are not present. */
1778 pi->sizes = calloc((size_t)pi->numPackStreams, sizeof(uint64_t));
1779 pi->positions = calloc((size_t)pi->numPackStreams, sizeof(uint64_t));
1780 if (pi->sizes == NULL || pi->positions == NULL)
1783 for (i = 0; i < pi->numPackStreams; i++) {
1784 if (parse_7zip_uint64(a, &(pi->sizes[i])) < 0)
1789 * Read PackStreamDigests[num]
1791 if ((p = header_bytes(a, 1)) == NULL)
1794 /* PackStreamDigests[num] are not present. */
1795 pi->digest.defineds =
1796 calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.defineds));
1797 pi->digest.digests =
1798 calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.digests));
1799 if (pi->digest.defineds == NULL || pi->digest.digests == NULL)
1807 if (read_Digests(a, &(pi->digest), (size_t)pi->numPackStreams) < 0)
1811 * Must be marked by kEnd.
1813 if ((p = header_bytes(a, 1)) == NULL)
1821 free_Folder(struct _7z_folder *f)
1826 for (i = 0; i< f->numCoders; i++) {
1827 free(f->coders[i].properties);
1832 free(f->packedStreams);
1833 free(f->unPackSize);
1837 read_Folder(struct archive_read *a, struct _7z_folder *f)
1839 struct _7zip *zip = (struct _7zip *)a->format->data;
1840 const unsigned char *p;
1841 uint64_t numInStreamsTotal = 0;
1842 uint64_t numOutStreamsTotal = 0;
1845 memset(f, 0, sizeof(*f));
1850 if (parse_7zip_uint64(a, &(f->numCoders)) < 0)
1852 if (f->numCoders > 4)
1853 /* Too many coders. */
1856 f->coders = calloc((size_t)f->numCoders, sizeof(*f->coders));
1857 if (f->coders == NULL)
1859 for (i = 0; i< f->numCoders; i++) {
1863 if ((p = header_bytes(a, 1)) == NULL)
1869 * 5: 0 - No Attributes
1870 * 1 - There are Attributes;
1873 codec_size = *p & 0xf;
1874 simple = (*p & 0x10)?0:1;
1877 return (-1);/* Not supported. */
1880 * Read Decompression Method IDs.
1882 if ((p = header_bytes(a, codec_size)) == NULL)
1885 f->coders[i].codec = decode_codec_id(p, codec_size);
1888 f->coders[i].numInStreams = 1;
1889 f->coders[i].numOutStreams = 1;
1891 if (parse_7zip_uint64(
1892 a, &(f->coders[i].numInStreams)) < 0)
1894 if (UMAX_ENTRY < f->coders[i].numInStreams)
1896 if (parse_7zip_uint64(
1897 a, &(f->coders[i].numOutStreams)) < 0)
1899 if (UMAX_ENTRY < f->coders[i].numOutStreams)
1904 if (parse_7zip_uint64(
1905 a, &(f->coders[i].propertiesSize)) < 0)
1907 if ((p = header_bytes(
1908 a, (size_t)f->coders[i].propertiesSize)) == NULL)
1910 f->coders[i].properties =
1911 malloc((size_t)f->coders[i].propertiesSize);
1912 if (f->coders[i].properties == NULL)
1914 memcpy(f->coders[i].properties, p,
1915 (size_t)f->coders[i].propertiesSize);
1918 numInStreamsTotal += f->coders[i].numInStreams;
1919 numOutStreamsTotal += f->coders[i].numOutStreams;
1922 if (numOutStreamsTotal == 0 ||
1923 numInStreamsTotal < numOutStreamsTotal-1)
1926 f->numBindPairs = numOutStreamsTotal - 1;
1927 if (zip->header_bytes_remaining < f->numBindPairs)
1929 if (f->numBindPairs > 0) {
1931 calloc((size_t)f->numBindPairs, sizeof(*f->bindPairs));
1932 if (f->bindPairs == NULL)
1935 f->bindPairs = NULL;
1936 for (i = 0; i < f->numBindPairs; i++) {
1937 if (parse_7zip_uint64(a, &(f->bindPairs[i].inIndex)) < 0)
1939 if (UMAX_ENTRY < f->bindPairs[i].inIndex)
1941 if (parse_7zip_uint64(a, &(f->bindPairs[i].outIndex)) < 0)
1943 if (UMAX_ENTRY < f->bindPairs[i].outIndex)
1947 f->numPackedStreams = numInStreamsTotal - f->numBindPairs;
1949 calloc((size_t)f->numPackedStreams, sizeof(*f->packedStreams));
1950 if (f->packedStreams == NULL)
1952 if (f->numPackedStreams == 1) {
1953 for (i = 0; i < numInStreamsTotal; i++) {
1955 for (j = 0; j < f->numBindPairs; j++) {
1956 if (f->bindPairs[j].inIndex == i)
1959 if (j == f->numBindPairs)
1962 if (i == numInStreamsTotal)
1964 f->packedStreams[0] = i;
1966 for (i = 0; i < f->numPackedStreams; i++) {
1967 if (parse_7zip_uint64(a, &(f->packedStreams[i])) < 0)
1969 if (UMAX_ENTRY < f->packedStreams[i])
1973 f->numInStreams = numInStreamsTotal;
1974 f->numOutStreams = numOutStreamsTotal;
1980 free_CodersInfo(struct _7z_coders_info *ci)
1985 for (i = 0; i < ci->numFolders; i++)
1986 free_Folder(&(ci->folders[i]));
1992 read_CodersInfo(struct archive_read *a, struct _7z_coders_info *ci)
1994 const unsigned char *p;
1995 struct _7z_digests digest;
1998 memset(ci, 0, sizeof(*ci));
1999 memset(&digest, 0, sizeof(digest));
2001 if ((p = header_bytes(a, 1)) == NULL)
2009 if (parse_7zip_uint64(a, &(ci->numFolders)) < 0)
2011 if (UMAX_ENTRY < ci->numFolders)
2017 if ((p = header_bytes(a, 1)) == NULL)
2022 calloc((size_t)ci->numFolders, sizeof(*ci->folders));
2023 if (ci->folders == NULL)
2025 for (i = 0; i < ci->numFolders; i++) {
2026 if (read_Folder(a, &(ci->folders[i])) < 0)
2031 if (parse_7zip_uint64(a, &(ci->dataStreamIndex)) < 0)
2033 if (UMAX_ENTRY < ci->dataStreamIndex)
2035 if (ci->numFolders > 0) {
2036 archive_set_error(&a->archive, -1,
2037 "Malformed 7-Zip archive");
2042 archive_set_error(&a->archive, -1,
2043 "Malformed 7-Zip archive");
2047 if ((p = header_bytes(a, 1)) == NULL)
2049 if (*p != kCodersUnPackSize)
2052 for (i = 0; i < ci->numFolders; i++) {
2053 struct _7z_folder *folder = &(ci->folders[i]);
2056 folder->unPackSize =
2057 calloc((size_t)folder->numOutStreams, sizeof(*folder->unPackSize));
2058 if (folder->unPackSize == NULL)
2060 for (j = 0; j < folder->numOutStreams; j++) {
2061 if (parse_7zip_uint64(a, &(folder->unPackSize[j])) < 0)
2069 if ((p = header_bytes(a, 1)) == NULL)
2075 if (read_Digests(a, &digest, (size_t)ci->numFolders) < 0)
2077 for (i = 0; i < ci->numFolders; i++) {
2078 ci->folders[i].digest_defined = digest.defineds[i];
2079 ci->folders[i].digest = digest.digests[i];
2085 if ((p = header_bytes(a, 1)) == NULL)
2089 free_Digest(&digest);
2092 free_Digest(&digest);
2097 folder_uncompressed_size(struct _7z_folder *f)
2099 int n = (int)f->numOutStreams;
2100 unsigned pairs = (unsigned)f->numBindPairs;
2104 for (i = 0; i < pairs; i++) {
2105 if (f->bindPairs[i].outIndex == (uint64_t)n)
2109 return (f->unPackSize[n]);
2115 free_SubStreamsInfo(struct _7z_substream_info *ss)
2117 free(ss->unpackSizes);
2118 free(ss->digestsDefined);
2123 read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss,
2124 struct _7z_folder *f, size_t numFolders)
2126 const unsigned char *p;
2128 size_t unpack_streams;
2131 uint32_t numDigests;
2133 memset(ss, 0, sizeof(*ss));
2135 for (i = 0; i < numFolders; i++)
2136 f[i].numUnpackStreams = 1;
2138 if ((p = header_bytes(a, 1)) == NULL)
2142 if (type == kNumUnPackStream) {
2144 for (i = 0; i < numFolders; i++) {
2145 if (parse_7zip_uint64(a, &(f[i].numUnpackStreams)) < 0)
2147 if (UMAX_ENTRY < f[i].numUnpackStreams)
2149 if (unpack_streams > SIZE_MAX - UMAX_ENTRY) {
2152 unpack_streams += (size_t)f[i].numUnpackStreams;
2154 if ((p = header_bytes(a, 1)) == NULL)
2158 unpack_streams = numFolders;
2160 ss->unpack_streams = unpack_streams;
2161 if (unpack_streams) {
2162 ss->unpackSizes = calloc(unpack_streams,
2163 sizeof(*ss->unpackSizes));
2164 ss->digestsDefined = calloc(unpack_streams,
2165 sizeof(*ss->digestsDefined));
2166 ss->digests = calloc(unpack_streams,
2167 sizeof(*ss->digests));
2168 if (ss->unpackSizes == NULL || ss->digestsDefined == NULL ||
2169 ss->digests == NULL)
2173 usizes = ss->unpackSizes;
2174 for (i = 0; i < numFolders; i++) {
2178 if (f[i].numUnpackStreams == 0)
2182 if (type == kSize) {
2183 for (pack = 1; pack < f[i].numUnpackStreams; pack++) {
2184 if (parse_7zip_uint64(a, usizes) < 0)
2189 *usizes++ = folder_uncompressed_size(&f[i]) - sum;
2192 if (type == kSize) {
2193 if ((p = header_bytes(a, 1)) == NULL)
2198 for (i = 0; i < unpack_streams; i++) {
2199 ss->digestsDefined[i] = 0;
2204 for (i = 0; i < numFolders; i++) {
2205 if (f[i].numUnpackStreams != 1 || !f[i].digest_defined)
2206 numDigests += (uint32_t)f[i].numUnpackStreams;
2210 struct _7z_digests tmpDigests;
2211 unsigned char *digestsDefined = ss->digestsDefined;
2212 uint32_t * digests = ss->digests;
2215 memset(&tmpDigests, 0, sizeof(tmpDigests));
2216 if (read_Digests(a, &(tmpDigests), numDigests) < 0) {
2217 free_Digest(&tmpDigests);
2220 for (i = 0; i < numFolders; i++) {
2221 if (f[i].numUnpackStreams == 1 && f[i].digest_defined) {
2222 *digestsDefined++ = 1;
2223 *digests++ = f[i].digest;
2227 for (j = 0; j < f[i].numUnpackStreams;
2230 tmpDigests.defineds[di];
2232 tmpDigests.digests[di];
2236 free_Digest(&tmpDigests);
2237 if ((p = header_bytes(a, 1)) == NULL)
2251 free_StreamsInfo(struct _7z_stream_info *si)
2253 free_PackInfo(&(si->pi));
2254 free_CodersInfo(&(si->ci));
2255 free_SubStreamsInfo(&(si->ss));
2259 read_StreamsInfo(struct archive_read *a, struct _7z_stream_info *si)
2261 struct _7zip *zip = (struct _7zip *)a->format->data;
2262 const unsigned char *p;
2265 memset(si, 0, sizeof(*si));
2267 if ((p = header_bytes(a, 1)) == NULL)
2269 if (*p == kPackInfo) {
2272 if (read_PackInfo(a, &(si->pi)) < 0)
2275 if (si->pi.positions == NULL || si->pi.sizes == NULL)
2278 * Calculate packed stream positions.
2280 packPos = si->pi.pos;
2281 for (i = 0; i < si->pi.numPackStreams; i++) {
2282 si->pi.positions[i] = packPos;
2283 packPos += si->pi.sizes[i];
2284 if (packPos > zip->header_offset)
2287 if ((p = header_bytes(a, 1)) == NULL)
2290 if (*p == kUnPackInfo) {
2292 struct _7z_folder *f;
2294 if (read_CodersInfo(a, &(si->ci)) < 0)
2298 * Calculate packed stream indexes.
2302 for (i = 0; i < si->ci.numFolders; i++) {
2303 f[i].packIndex = packIndex;
2304 packIndex += (uint32_t)f[i].numPackedStreams;
2305 if (packIndex > si->pi.numPackStreams)
2308 if ((p = header_bytes(a, 1)) == NULL)
2312 if (*p == kSubStreamsInfo) {
2313 if (read_SubStreamsInfo(a, &(si->ss),
2314 si->ci.folders, (size_t)si->ci.numFolders) < 0)
2316 if ((p = header_bytes(a, 1)) == NULL)
2329 free_Header(struct _7z_header_info *h)
2331 free(h->emptyStreamBools);
2332 free(h->emptyFileBools);
2338 read_Header(struct archive_read *a, struct _7z_header_info *h,
2339 int check_header_id)
2341 struct _7zip *zip = (struct _7zip *)a->format->data;
2342 const unsigned char *p;
2343 struct _7z_folder *folders;
2344 struct _7z_stream_info *si = &(zip->si);
2345 struct _7zip_entry *entries;
2346 uint32_t folderIndex, indexInFolder;
2348 int eindex, empty_streams, sindex;
2350 if (check_header_id) {
2354 if ((p = header_bytes(a, 1)) == NULL)
2361 * Read ArchiveProperties.
2363 if ((p = header_bytes(a, 1)) == NULL)
2365 if (*p == kArchiveProperties) {
2368 if ((p = header_bytes(a, 1)) == NULL)
2372 if (parse_7zip_uint64(a, &size) < 0)
2375 if ((p = header_bytes(a, 1)) == NULL)
2380 * Read MainStreamsInfo.
2382 if (*p == kMainStreamsInfo) {
2383 if (read_StreamsInfo(a, &(zip->si)) < 0)
2385 if ((p = header_bytes(a, 1)) == NULL)
2394 if (*p != kFilesInfo)
2397 if (parse_7zip_uint64(a, &(zip->numFiles)) < 0)
2399 if (UMAX_ENTRY < zip->numFiles)
2402 zip->entries = calloc((size_t)zip->numFiles, sizeof(*zip->entries));
2403 if (zip->entries == NULL)
2405 entries = zip->entries;
2413 if ((p = header_bytes(a, 1)) == NULL)
2419 if (parse_7zip_uint64(a, &size) < 0)
2421 if (zip->header_bytes_remaining < size)
2427 if (h->emptyStreamBools != NULL)
2429 h->emptyStreamBools = calloc((size_t)zip->numFiles,
2430 sizeof(*h->emptyStreamBools));
2431 if (h->emptyStreamBools == NULL)
2434 a, h->emptyStreamBools, (size_t)zip->numFiles) < 0)
2437 for (i = 0; i < zip->numFiles; i++) {
2438 if (h->emptyStreamBools[i])
2443 if (empty_streams <= 0) {
2444 /* Unexcepted sequence. Skip this. */
2445 if (header_bytes(a, ll) == NULL)
2449 if (h->emptyFileBools != NULL)
2451 h->emptyFileBools = calloc(empty_streams,
2452 sizeof(*h->emptyFileBools));
2453 if (h->emptyFileBools == NULL)
2455 if (read_Bools(a, h->emptyFileBools, empty_streams) < 0)
2459 if (empty_streams <= 0) {
2460 /* Unexcepted sequence. Skip this. */
2461 if (header_bytes(a, ll) == NULL)
2465 if (h->antiBools != NULL)
2467 h->antiBools = calloc(empty_streams,
2468 sizeof(*h->antiBools));
2469 if (h->antiBools == NULL)
2471 if (read_Bools(a, h->antiBools, empty_streams) < 0)
2477 if (read_Times(a, h, type) < 0)
2485 /* Skip one byte. */
2486 if ((p = header_bytes(a, 1)) == NULL)
2490 if ((ll & 1) || ll < zip->numFiles * 4)
2493 if (zip->entry_names != NULL)
2495 zip->entry_names = malloc(ll);
2496 if (zip->entry_names == NULL)
2498 np = zip->entry_names;
2501 * Copy whole file names.
2502 * NOTE: This loop prevents from expanding
2503 * the uncompressed buffer in order not to
2504 * use extra memory resource.
2508 if (nb > UBUFF_SIZE)
2512 if ((p = header_bytes(a, b)) == NULL)
2518 np = zip->entry_names;
2521 for (i = 0; i < zip->numFiles; i++) {
2522 entries[i].utf16name = np;
2523 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
2524 entries[i].wname = (wchar_t *)np;
2527 /* Find a terminator. */
2528 while (nl >= 2 && (np[0] || np[1])) {
2533 return (-1);/* Terminator not found */
2534 entries[i].name_len = np - entries[i].utf16name;
2544 if ((p = header_bytes(a, 2)) == NULL)
2547 if (h->attrBools != NULL)
2549 h->attrBools = calloc((size_t)zip->numFiles,
2550 sizeof(*h->attrBools));
2551 if (h->attrBools == NULL)
2554 memset(h->attrBools, 1, (size_t)zip->numFiles);
2556 if (read_Bools(a, h->attrBools,
2557 (size_t)zip->numFiles) < 0)
2560 for (i = 0; i < zip->numFiles; i++) {
2561 if (h->attrBools[i]) {
2562 if ((p = header_bytes(a, 4)) == NULL)
2564 entries[i].attr = archive_le32dec(p);
2573 if (header_bytes(a, ll) == NULL)
2580 * Set up entry's attributes.
2582 folders = si->ci.folders;
2583 eindex = sindex = 0;
2584 folderIndex = indexInFolder = 0;
2585 for (i = 0; i < zip->numFiles; i++) {
2586 if (h->emptyStreamBools == NULL || h->emptyStreamBools[i] == 0)
2587 entries[i].flg |= HAS_STREAM;
2588 /* The high 16 bits of attributes is a posix file mode. */
2589 entries[i].mode = entries[i].attr >> 16;
2590 if (entries[i].flg & HAS_STREAM) {
2591 if ((size_t)sindex >= si->ss.unpack_streams)
2593 if (entries[i].mode == 0)
2594 entries[i].mode = AE_IFREG | 0666;
2595 if (si->ss.digestsDefined[sindex])
2596 entries[i].flg |= CRC32_IS_SET;
2597 entries[i].ssIndex = sindex;
2601 if (h->emptyFileBools == NULL)
2604 if (h->emptyFileBools[eindex])
2610 if (entries[i].mode == 0) {
2612 entries[i].mode = AE_IFDIR | 0777;
2614 entries[i].mode = AE_IFREG | 0666;
2616 (entries[i].mode & AE_IFMT) != AE_IFDIR) {
2617 entries[i].mode &= ~AE_IFMT;
2618 entries[i].mode |= AE_IFDIR;
2620 if ((entries[i].mode & AE_IFMT) == AE_IFDIR &&
2621 entries[i].name_len >= 2 &&
2622 (entries[i].utf16name[entries[i].name_len-2] != '/' ||
2623 entries[i].utf16name[entries[i].name_len-1] != 0)) {
2624 entries[i].utf16name[entries[i].name_len] = '/';
2625 entries[i].utf16name[entries[i].name_len+1] = 0;
2626 entries[i].name_len += 2;
2628 entries[i].ssIndex = -1;
2630 if (entries[i].attr & 0x01)
2631 entries[i].mode &= ~0222;/* Read only. */
2633 if ((entries[i].flg & HAS_STREAM) == 0 && indexInFolder == 0) {
2635 * The entry is an empty file or a directory file,
2636 * those both have no contents.
2638 entries[i].folderIndex = -1;
2641 if (indexInFolder == 0) {
2643 if (folderIndex >= si->ci.numFolders)
2645 if (folders[folderIndex].numUnpackStreams)
2650 entries[i].folderIndex = folderIndex;
2651 if ((entries[i].flg & HAS_STREAM) == 0)
2654 if (indexInFolder >= folders[folderIndex].numUnpackStreams) {
2663 #define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
2665 fileTimeToUtc(uint64_t fileTime, time_t *timep, long *ns)
2668 if (fileTime >= EPOC_TIME) {
2669 fileTime -= EPOC_TIME;
2670 /* milli seconds base */
2671 *timep = (time_t)(fileTime / 10000000);
2672 /* nano seconds base */
2673 *ns = (long)(fileTime % 10000000) * 100;
2681 read_Times(struct archive_read *a, struct _7z_header_info *h, int type)
2683 struct _7zip *zip = (struct _7zip *)a->format->data;
2684 const unsigned char *p;
2685 struct _7zip_entry *entries = zip->entries;
2686 unsigned char *timeBools;
2690 timeBools = calloc((size_t)zip->numFiles, sizeof(*timeBools));
2691 if (timeBools == NULL)
2694 /* Read allAreDefined. */
2695 if ((p = header_bytes(a, 1)) == NULL)
2699 memset(timeBools, 1, (size_t)zip->numFiles);
2701 if (read_Bools(a, timeBools, (size_t)zip->numFiles) < 0)
2705 /* Read external. */
2706 if ((p = header_bytes(a, 1)) == NULL)
2709 if (parse_7zip_uint64(a, &(h->dataIndex)) < 0)
2711 if (UMAX_ENTRY < h->dataIndex)
2715 for (i = 0; i < zip->numFiles; i++) {
2718 if ((p = header_bytes(a, 8)) == NULL)
2722 fileTimeToUtc(archive_le64dec(p),
2723 &(entries[i].ctime),
2724 &(entries[i].ctime_ns));
2725 entries[i].flg |= CTIME_IS_SET;
2728 fileTimeToUtc(archive_le64dec(p),
2729 &(entries[i].atime),
2730 &(entries[i].atime_ns));
2731 entries[i].flg |= ATIME_IS_SET;
2734 fileTimeToUtc(archive_le64dec(p),
2735 &(entries[i].mtime),
2736 &(entries[i].mtime_ns));
2737 entries[i].flg |= MTIME_IS_SET;
2750 decode_encoded_header_info(struct archive_read *a, struct _7z_stream_info *si)
2752 struct _7zip *zip = (struct _7zip *)a->format->data;
2755 if (read_StreamsInfo(a, si) < 0) {
2756 if (errno == ENOMEM)
2757 archive_set_error(&a->archive, -1,
2758 "Couldn't allocate memory");
2760 archive_set_error(&a->archive, -1,
2761 "Malformed 7-Zip archive");
2762 return (ARCHIVE_FATAL);
2765 if (si->pi.numPackStreams == 0 || si->ci.numFolders == 0) {
2766 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive");
2767 return (ARCHIVE_FATAL);
2770 if (zip->header_offset < si->pi.pos + si->pi.sizes[0] ||
2771 (int64_t)(si->pi.pos + si->pi.sizes[0]) < 0 ||
2772 si->pi.sizes[0] == 0 || (int64_t)si->pi.pos < 0) {
2773 archive_set_error(&a->archive, -1, "Malformed Header offset");
2774 return (ARCHIVE_FATAL);
2777 return (ARCHIVE_OK);
2780 static const unsigned char *
2781 header_bytes(struct archive_read *a, size_t rbytes)
2783 struct _7zip *zip = (struct _7zip *)a->format->data;
2784 const unsigned char *p;
2786 if (zip->header_bytes_remaining < rbytes)
2788 if (zip->pack_stream_bytes_unconsumed)
2791 if (zip->header_is_encoded == 0) {
2792 p = __archive_read_ahead(a, rbytes, NULL);
2795 zip->header_bytes_remaining -= rbytes;
2796 zip->pack_stream_bytes_unconsumed = rbytes;
2801 bytes = read_stream(a, &buff, rbytes, rbytes);
2804 zip->header_bytes_remaining -= bytes;
2808 /* Update checksum */
2809 zip->header_crc32 = crc32(zip->header_crc32, p, (unsigned)rbytes);
2814 slurp_central_directory(struct archive_read *a, struct _7zip *zip,
2815 struct _7z_header_info *header)
2817 const unsigned char *p;
2818 uint64_t next_header_offset;
2819 uint64_t next_header_size;
2820 uint32_t next_header_crc;
2821 ssize_t bytes_avail;
2822 int check_header_crc, r;
2824 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL)
2825 return (ARCHIVE_FATAL);
2827 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
2828 /* This is an executable ? Must be self-extracting... */
2829 r = skip_sfx(a, bytes_avail);
2830 if (r < ARCHIVE_WARN)
2832 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL)
2833 return (ARCHIVE_FATAL);
2835 zip->seek_base += 32;
2837 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0) {
2838 archive_set_error(&a->archive, -1, "Not 7-Zip archive file");
2839 return (ARCHIVE_FATAL);
2843 if (crc32(0, (const unsigned char *)p + 12, 20)
2844 != archive_le32dec(p + 8)) {
2845 archive_set_error(&a->archive, -1, "Header CRC error");
2846 return (ARCHIVE_FATAL);
2849 next_header_offset = archive_le64dec(p + 12);
2850 next_header_size = archive_le64dec(p + 20);
2851 next_header_crc = archive_le32dec(p + 28);
2853 if (next_header_size == 0)
2854 /* There is no entry in an archive file. */
2855 return (ARCHIVE_EOF);
2857 if (((int64_t)next_header_offset) < 0) {
2858 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive");
2859 return (ARCHIVE_FATAL);
2861 __archive_read_consume(a, 32);
2862 if (next_header_offset != 0) {
2863 if (bytes_avail >= (ssize_t)next_header_offset)
2864 __archive_read_consume(a, next_header_offset);
2865 else if (__archive_read_seek(a,
2866 next_header_offset + zip->seek_base, SEEK_SET) < 0)
2867 return (ARCHIVE_FATAL);
2869 zip->stream_offset = next_header_offset;
2870 zip->header_offset = next_header_offset;
2871 zip->header_bytes_remaining = next_header_size;
2872 zip->header_crc32 = 0;
2873 zip->header_is_encoded = 0;
2874 zip->header_is_being_read = 1;
2875 zip->has_encrypted_entries = 0;
2876 check_header_crc = 1;
2878 if ((p = header_bytes(a, 1)) == NULL) {
2879 archive_set_error(&a->archive,
2880 ARCHIVE_ERRNO_FILE_FORMAT,
2881 "Truncated 7-Zip file body");
2882 return (ARCHIVE_FATAL);
2884 /* Parse ArchiveProperties. */
2886 case kEncodedHeader:
2888 * The archive has an encoded header and we have to decode it
2889 * in order to parse the header correctly.
2891 r = decode_encoded_header_info(a, &(zip->si));
2893 /* Check the EncodedHeader CRC.*/
2894 if (r == 0 && zip->header_crc32 != next_header_crc) {
2895 archive_set_error(&a->archive, -1,
2896 "Damaged 7-Zip archive");
2900 if (zip->si.ci.folders[0].digest_defined)
2901 next_header_crc = zip->si.ci.folders[0].digest;
2903 check_header_crc = 0;
2904 if (zip->pack_stream_bytes_unconsumed)
2906 r = setup_decode_folder(a, zip->si.ci.folders, 1);
2908 zip->header_bytes_remaining =
2909 zip->folder_outbytes_remaining;
2913 /* Clean up StreamsInfo. */
2914 free_StreamsInfo(&(zip->si));
2915 memset(&(zip->si), 0, sizeof(zip->si));
2917 return (ARCHIVE_FATAL);
2918 zip->header_is_encoded = 1;
2919 zip->header_crc32 = 0;
2926 r = read_Header(a, header, zip->header_is_encoded);
2928 if (errno == ENOMEM)
2929 archive_set_error(&a->archive, -1,
2930 "Couldn't allocate memory");
2932 archive_set_error(&a->archive, -1,
2933 "Damaged 7-Zip archive");
2934 return (ARCHIVE_FATAL);
2940 if ((p = header_bytes(a, 1)) == NULL ||*p != kEnd) {
2941 archive_set_error(&a->archive, -1,
2942 "Malformed 7-Zip archive");
2943 return (ARCHIVE_FATAL);
2946 /* Check the Header CRC.*/
2947 if (check_header_crc && zip->header_crc32 != next_header_crc) {
2948 archive_set_error(&a->archive, -1,
2949 "Malformed 7-Zip archive");
2950 return (ARCHIVE_FATAL);
2954 archive_set_error(&a->archive, -1,
2955 "Unexpected Property ID = %X", p[0]);
2956 return (ARCHIVE_FATAL);
2959 /* Clean up variables be used for decoding the archive header */
2960 zip->pack_stream_remaining = 0;
2961 zip->pack_stream_index = 0;
2962 zip->folder_outbytes_remaining = 0;
2963 zip->uncompressed_buffer_bytes_remaining = 0;
2964 zip->pack_stream_bytes_unconsumed = 0;
2965 zip->header_is_being_read = 0;
2967 return (ARCHIVE_OK);
2971 get_uncompressed_data(struct archive_read *a, const void **buff, size_t size,
2974 struct _7zip *zip = (struct _7zip *)a->format->data;
2975 ssize_t bytes_avail;
2977 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
2981 * Note: '1' here is a performance optimization.
2982 * Recall that the decompression layer returns a count of
2983 * available bytes; asking for more than that forces the
2984 * decompressor to combine reads by copying data.
2986 *buff = __archive_read_ahead(a, 1, &bytes_avail);
2987 if (bytes_avail <= 0) {
2988 archive_set_error(&a->archive,
2989 ARCHIVE_ERRNO_FILE_FORMAT,
2990 "Truncated 7-Zip file data");
2991 return (ARCHIVE_FATAL);
2993 if ((size_t)bytes_avail >
2994 zip->uncompressed_buffer_bytes_remaining)
2995 bytes_avail = (ssize_t)
2996 zip->uncompressed_buffer_bytes_remaining;
2997 if ((size_t)bytes_avail > size)
2998 bytes_avail = (ssize_t)size;
3000 zip->pack_stream_bytes_unconsumed = bytes_avail;
3001 } else if (zip->uncompressed_buffer_pointer == NULL) {
3002 /* Decompression has failed. */
3003 archive_set_error(&(a->archive),
3004 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3005 return (ARCHIVE_FATAL);
3008 if (minimum > zip->uncompressed_buffer_bytes_remaining) {
3010 * If remaining uncompressed data size is less than
3011 * the minimum size, fill the buffer up to the
3014 if (extract_pack_stream(a, minimum) < 0)
3015 return (ARCHIVE_FATAL);
3017 if (size > zip->uncompressed_buffer_bytes_remaining)
3018 bytes_avail = (ssize_t)
3019 zip->uncompressed_buffer_bytes_remaining;
3021 bytes_avail = (ssize_t)size;
3022 *buff = zip->uncompressed_buffer_pointer;
3023 zip->uncompressed_buffer_pointer += bytes_avail;
3025 zip->uncompressed_buffer_bytes_remaining -= bytes_avail;
3026 return (bytes_avail);
3030 extract_pack_stream(struct archive_read *a, size_t minimum)
3032 struct _7zip *zip = (struct _7zip *)a->format->data;
3033 ssize_t bytes_avail;
3036 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
3039 if (__archive_read_ahead(a, minimum, &bytes_avail) == NULL
3040 || bytes_avail <= 0) {
3041 archive_set_error(&a->archive,
3042 ARCHIVE_ERRNO_FILE_FORMAT,
3043 "Truncated 7-Zip file body");
3044 return (ARCHIVE_FATAL);
3046 if (bytes_avail > (ssize_t)zip->pack_stream_inbytes_remaining)
3047 bytes_avail = (ssize_t)zip->pack_stream_inbytes_remaining;
3048 zip->pack_stream_inbytes_remaining -= bytes_avail;
3049 if (bytes_avail > (ssize_t)zip->folder_outbytes_remaining)
3050 bytes_avail = (ssize_t)zip->folder_outbytes_remaining;
3051 zip->folder_outbytes_remaining -= bytes_avail;
3052 zip->uncompressed_buffer_bytes_remaining = bytes_avail;
3053 return (ARCHIVE_OK);
3056 /* If the buffer hasn't been allocated, allocate it now. */
3057 if (zip->uncompressed_buffer == NULL) {
3058 zip->uncompressed_buffer_size = UBUFF_SIZE;
3059 if (zip->uncompressed_buffer_size < minimum) {
3060 zip->uncompressed_buffer_size = minimum + 1023;
3061 zip->uncompressed_buffer_size &= ~0x3ff;
3063 zip->uncompressed_buffer =
3064 malloc(zip->uncompressed_buffer_size);
3065 if (zip->uncompressed_buffer == NULL) {
3066 archive_set_error(&a->archive, ENOMEM,
3067 "No memory for 7-Zip decompression");
3068 return (ARCHIVE_FATAL);
3070 zip->uncompressed_buffer_bytes_remaining = 0;
3071 } else if (zip->uncompressed_buffer_size < minimum ||
3072 zip->uncompressed_buffer_bytes_remaining < minimum) {
3074 * Make sure the uncompressed buffer can have bytes
3075 * at least `minimum' bytes.
3076 * NOTE: This case happen when reading the header.
3079 if (zip->uncompressed_buffer_pointer != 0)
3080 used = zip->uncompressed_buffer_pointer -
3081 zip->uncompressed_buffer;
3084 if (zip->uncompressed_buffer_size < minimum) {
3086 * Expand the uncompressed buffer up to
3092 new_size = minimum + 1023;
3094 p = realloc(zip->uncompressed_buffer, new_size);
3096 archive_set_error(&a->archive, ENOMEM,
3097 "No memory for 7-Zip decompression");
3098 return (ARCHIVE_FATAL);
3100 zip->uncompressed_buffer = (unsigned char *)p;
3101 zip->uncompressed_buffer_size = new_size;
3104 * Move unconsumed bytes to the head.
3107 memmove(zip->uncompressed_buffer,
3108 zip->uncompressed_buffer + used,
3109 zip->uncompressed_buffer_bytes_remaining);
3112 zip->uncompressed_buffer_bytes_remaining = 0;
3113 zip->uncompressed_buffer_pointer = NULL;
3115 size_t bytes_in, bytes_out;
3116 const void *buff_in;
3117 unsigned char *buff_out;
3121 * Note: '1' here is a performance optimization.
3122 * Recall that the decompression layer returns a count of
3123 * available bytes; asking for more than that forces the
3124 * decompressor to combine reads by copying data.
3126 buff_in = __archive_read_ahead(a, 1, &bytes_avail);
3127 if (bytes_avail <= 0) {
3128 archive_set_error(&a->archive,
3129 ARCHIVE_ERRNO_FILE_FORMAT,
3130 "Truncated 7-Zip file body");
3131 return (ARCHIVE_FATAL);
3134 buff_out = zip->uncompressed_buffer
3135 + zip->uncompressed_buffer_bytes_remaining;
3136 bytes_out = zip->uncompressed_buffer_size
3137 - zip->uncompressed_buffer_bytes_remaining;
3138 bytes_in = bytes_avail;
3139 if (bytes_in > zip->pack_stream_inbytes_remaining)
3140 bytes_in = (size_t)zip->pack_stream_inbytes_remaining;
3141 /* Drive decompression. */
3142 r = decompress(a, zip, buff_out, &bytes_out,
3143 buff_in, &bytes_in);
3152 return (ARCHIVE_FATAL);
3154 zip->pack_stream_inbytes_remaining -= bytes_in;
3155 if (bytes_out > zip->folder_outbytes_remaining)
3156 bytes_out = (size_t)zip->folder_outbytes_remaining;
3157 zip->folder_outbytes_remaining -= bytes_out;
3158 zip->uncompressed_buffer_bytes_remaining += bytes_out;
3159 zip->pack_stream_bytes_unconsumed = bytes_in;
3162 * Continue decompression until uncompressed_buffer is full.
3164 if (zip->uncompressed_buffer_bytes_remaining ==
3165 zip->uncompressed_buffer_size)
3167 if (zip->codec2 == _7Z_X86 && zip->odd_bcj_size &&
3168 zip->uncompressed_buffer_bytes_remaining + 5 >
3169 zip->uncompressed_buffer_size)
3171 if (zip->pack_stream_inbytes_remaining == 0 &&
3172 zip->folder_outbytes_remaining == 0)
3174 if (end_of_data || (bytes_in == 0 && bytes_out == 0)) {
3175 archive_set_error(&(a->archive),
3176 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3177 return (ARCHIVE_FATAL);
3181 if (zip->uncompressed_buffer_bytes_remaining < minimum) {
3182 archive_set_error(&(a->archive),
3183 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3184 return (ARCHIVE_FATAL);
3186 zip->uncompressed_buffer_pointer = zip->uncompressed_buffer;
3187 return (ARCHIVE_OK);
3191 seek_pack(struct archive_read *a)
3193 struct _7zip *zip = (struct _7zip *)a->format->data;
3194 int64_t pack_offset;
3196 if (zip->pack_stream_remaining <= 0) {
3197 archive_set_error(&(a->archive),
3198 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3199 return (ARCHIVE_FATAL);
3201 zip->pack_stream_inbytes_remaining =
3202 zip->si.pi.sizes[zip->pack_stream_index];
3203 pack_offset = zip->si.pi.positions[zip->pack_stream_index];
3204 if (zip->stream_offset != pack_offset) {
3205 if (0 > __archive_read_seek(a, pack_offset + zip->seek_base,
3207 return (ARCHIVE_FATAL);
3208 zip->stream_offset = pack_offset;
3210 zip->pack_stream_index++;
3211 zip->pack_stream_remaining--;
3212 return (ARCHIVE_OK);
3216 read_stream(struct archive_read *a, const void **buff, size_t size,
3219 struct _7zip *zip = (struct _7zip *)a->format->data;
3220 uint64_t skip_bytes = 0;
3223 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3224 if (zip->pack_stream_inbytes_remaining > 0) {
3225 r = extract_pack_stream(a, 0);
3228 return (get_uncompressed_data(a, buff, size, minimum));
3229 } else if (zip->folder_outbytes_remaining > 0) {
3230 /* Extract a remaining pack stream. */
3231 r = extract_pack_stream(a, 0);
3234 return (get_uncompressed_data(a, buff, size, minimum));
3237 return (get_uncompressed_data(a, buff, size, minimum));
3240 * Current pack stream has been consumed.
3242 if (zip->pack_stream_remaining == 0) {
3243 if (zip->header_is_being_read) {
3244 /* Invalid sequence. This might happen when
3245 * reading a malformed archive. */
3246 archive_set_error(&(a->archive),
3247 ARCHIVE_ERRNO_MISC, "Malformed 7-Zip archive");
3248 return (ARCHIVE_FATAL);
3252 * All current folder's pack streams have been
3253 * consumed. Switch to next folder.
3255 if (zip->folder_index == 0 &&
3256 (zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3257 || zip->folder_index != zip->entry->folderIndex)) {
3258 zip->folder_index = zip->entry->folderIndex;
3260 zip->si.ci.folders[zip->folder_index].skipped_bytes;
3263 if (zip->folder_index >= zip->si.ci.numFolders) {
3265 * We have consumed all folders and its pack streams.
3270 r = setup_decode_folder(a,
3271 &(zip->si.ci.folders[zip->folder_index]), 0);
3272 if (r != ARCHIVE_OK)
3273 return (ARCHIVE_FATAL);
3275 zip->folder_index++;
3279 * Switch to next pack stream.
3285 /* Extract a new pack stream. */
3286 r = extract_pack_stream(a, 0);
3291 * Skip the bytes we already has skipped in skip_stream().
3293 while (skip_bytes) {
3296 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3297 if (zip->pack_stream_inbytes_remaining > 0) {
3298 r = extract_pack_stream(a, 0);
3301 } else if (zip->folder_outbytes_remaining > 0) {
3302 /* Extract a remaining pack stream. */
3303 r = extract_pack_stream(a, 0);
3307 archive_set_error(&a->archive,
3308 ARCHIVE_ERRNO_FILE_FORMAT,
3309 "Truncated 7-Zip file body");
3310 return (ARCHIVE_FATAL);
3313 skipped = get_uncompressed_data(
3314 a, buff, (size_t)skip_bytes, 0);
3317 skip_bytes -= skipped;
3318 if (zip->pack_stream_bytes_unconsumed)
3322 return (get_uncompressed_data(a, buff, size, minimum));
3326 setup_decode_folder(struct archive_read *a, struct _7z_folder *folder,
3329 struct _7zip *zip = (struct _7zip *)a->format->data;
3330 const struct _7z_coder *coder1, *coder2;
3331 const char *cname = (header)?"archive header":"file content";
3333 int r, found_bcj2 = 0;
3336 * Release the memory which the previous folder used for BCJ2.
3338 for (i = 0; i < 3; i++) {
3339 if (zip->sub_stream_buff[i] != NULL)
3340 free(zip->sub_stream_buff[i]);
3341 zip->sub_stream_buff[i] = NULL;
3345 * Initialize a stream reader.
3347 zip->pack_stream_remaining = (unsigned)folder->numPackedStreams;
3348 zip->pack_stream_index = (unsigned)folder->packIndex;
3349 zip->folder_outbytes_remaining = folder_uncompressed_size(folder);
3350 zip->uncompressed_buffer_bytes_remaining = 0;
3353 * Check coder types.
3355 for (i = 0; i < folder->numCoders; i++) {
3356 switch(folder->coders[i].codec) {
3357 case _7Z_CRYPTO_MAIN_ZIP:
3358 case _7Z_CRYPTO_RAR_29:
3359 case _7Z_CRYPTO_AES_256_SHA_256: {
3360 /* For entry that is associated with this folder, mark
3361 it as encrypted (data+metadata). */
3362 zip->has_encrypted_entries = 1;
3364 archive_entry_set_is_data_encrypted(a->entry, 1);
3365 archive_entry_set_is_metadata_encrypted(a->entry, 1);
3367 archive_set_error(&(a->archive),
3369 "The %s is encrypted, "
3370 "but currently not supported", cname);
3371 return (ARCHIVE_FATAL);
3373 case _7Z_X86_BCJ2: {
3379 /* Now that we've checked for encryption, if there were still no
3380 * encrypted entries found we can say for sure that there are none.
3382 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
3383 zip->has_encrypted_entries = 0;
3386 if ((folder->numCoders > 2 && !found_bcj2) || found_bcj2 > 1) {
3387 archive_set_error(&(a->archive),
3389 "The %s is encoded with many filters, "
3390 "but currently not supported", cname);
3391 return (ARCHIVE_FATAL);
3393 coder1 = &(folder->coders[0]);
3394 if (folder->numCoders == 2)
3395 coder2 = &(folder->coders[1]);
3401 * Preparation to decode BCJ2.
3402 * Decoding BCJ2 requires four sources. Those are at least,
3403 * as far as I know, two types of the storage form.
3405 const struct _7z_coder *fc = folder->coders;
3406 static const struct _7z_coder coder_copy = {0, 1, 1, 0, NULL};
3407 const struct _7z_coder *scoder[3] =
3408 {&coder_copy, &coder_copy, &coder_copy};
3411 unsigned char *b[3] = {NULL, NULL, NULL};
3412 uint64_t sunpack[3] ={-1, -1, -1};
3413 size_t s[3] = {0, 0, 0};
3414 int idx[3] = {0, 1, 2};
3416 if (folder->numCoders == 4 && fc[3].codec == _7Z_X86_BCJ2 &&
3417 folder->numInStreams == 7 && folder->numOutStreams == 4 &&
3418 zip->pack_stream_remaining == 4) {
3419 /* Source type 1 made by 7zr or 7z with -m options. */
3420 if (folder->bindPairs[0].inIndex == 5) {
3421 /* The form made by 7zr */
3422 idx[0] = 1; idx[1] = 2; idx[2] = 0;
3423 scoder[1] = &(fc[1]);
3424 scoder[2] = &(fc[0]);
3425 sunpack[1] = folder->unPackSize[1];
3426 sunpack[2] = folder->unPackSize[0];
3430 * NOTE: Some patterns do not work.
3432 * 7z a -m0=BCJ2 -m1=COPY -m2=COPY
3434 * 7z a -m0=BCJ2 -m1=COPY -m2=(any)
3436 * 7z a -m0=BCJ2 -m1=(any) -m2=COPY
3441 * We have to handle this like `pipe' or
3442 * our libarchive7s filter frame work,
3443 * decoding the BCJ2 main stream sequentially,
3444 * m3 -> m2 -> m1 -> BCJ2.
3447 if (fc[0].codec == _7Z_COPY &&
3448 fc[1].codec == _7Z_COPY)
3449 coder1 = &(folder->coders[2]);
3450 else if (fc[0].codec == _7Z_COPY &&
3451 fc[2].codec == _7Z_COPY)
3452 coder1 = &(folder->coders[1]);
3453 else if (fc[1].codec == _7Z_COPY &&
3454 fc[2].codec == _7Z_COPY)
3455 coder1 = &(folder->coders[0]);
3457 archive_set_error(&(a->archive),
3459 "Unsupported form of "
3461 return (ARCHIVE_FATAL);
3465 zip->main_stream_bytes_remaining =
3466 (size_t)folder->unPackSize[2];
3467 } else if (coder2 != NULL && coder2->codec == _7Z_X86_BCJ2 &&
3468 zip->pack_stream_remaining == 4 &&
3469 folder->numInStreams == 5 && folder->numOutStreams == 2) {
3470 /* Source type 0 made by 7z */
3471 zip->main_stream_bytes_remaining =
3472 (size_t)folder->unPackSize[0];
3474 /* We got an unexpected form. */
3475 archive_set_error(&(a->archive),
3477 "Unsupported form of BCJ2 streams");
3478 return (ARCHIVE_FATAL);
3481 /* Skip the main stream at this time. */
3482 if ((r = seek_pack(a)) < 0)
3484 zip->pack_stream_bytes_unconsumed =
3485 (size_t)zip->pack_stream_inbytes_remaining;
3488 /* Read following three sub streams. */
3489 for (i = 0; i < 3; i++) {
3490 const struct _7z_coder *coder = scoder[i];
3492 if ((r = seek_pack(a)) < 0) {
3493 free(b[0]); free(b[1]); free(b[2]);
3497 if (sunpack[i] == (uint64_t)-1)
3498 zip->folder_outbytes_remaining =
3499 zip->pack_stream_inbytes_remaining;
3501 zip->folder_outbytes_remaining = sunpack[i];
3503 r = init_decompression(a, zip, coder, NULL);
3504 if (r != ARCHIVE_OK) {
3505 free(b[0]); free(b[1]); free(b[2]);
3506 return (ARCHIVE_FATAL);
3509 /* Allocate memory for the decoded data of a sub
3511 b[i] = malloc((size_t)zip->folder_outbytes_remaining);
3513 free(b[0]); free(b[1]); free(b[2]);
3514 archive_set_error(&a->archive, ENOMEM,
3515 "No memory for 7-Zip decompression");
3516 return (ARCHIVE_FATAL);
3519 /* Extract a sub stream. */
3520 while (zip->pack_stream_inbytes_remaining > 0) {
3521 r = (int)extract_pack_stream(a, 0);
3523 free(b[0]); free(b[1]); free(b[2]);
3526 bytes = get_uncompressed_data(a, &buff,
3527 zip->uncompressed_buffer_bytes_remaining,
3530 free(b[0]); free(b[1]); free(b[2]);
3531 return ((int)bytes);
3533 memcpy(b[i]+s[i], buff, bytes);
3535 if (zip->pack_stream_bytes_unconsumed)
3540 /* Set the sub streams to the right place. */
3541 for (i = 0; i < 3; i++) {
3542 zip->sub_stream_buff[i] = b[idx[i]];
3543 zip->sub_stream_size[i] = s[idx[i]];
3544 zip->sub_stream_bytes_remaining[i] = s[idx[i]];
3547 /* Allocate memory used for decoded main stream bytes. */
3548 if (zip->tmp_stream_buff == NULL) {
3549 zip->tmp_stream_buff_size = 32 * 1024;
3550 zip->tmp_stream_buff =
3551 malloc(zip->tmp_stream_buff_size);
3552 if (zip->tmp_stream_buff == NULL) {
3553 archive_set_error(&a->archive, ENOMEM,
3554 "No memory for 7-Zip decompression");
3555 return (ARCHIVE_FATAL);
3558 zip->tmp_stream_bytes_avail = 0;
3559 zip->tmp_stream_bytes_remaining = 0;
3560 zip->odd_bcj_size = 0;
3561 zip->bcj2_outPos = 0;
3564 * Reset a stream reader in order to read the main stream
3567 zip->pack_stream_remaining = 1;
3568 zip->pack_stream_index = (unsigned)folder->packIndex;
3569 zip->folder_outbytes_remaining =
3570 folder_uncompressed_size(folder);
3571 zip->uncompressed_buffer_bytes_remaining = 0;
3575 * Initialize the decompressor for the new folder's pack streams.
3577 r = init_decompression(a, zip, coder1, coder2);
3578 if (r != ARCHIVE_OK)
3579 return (ARCHIVE_FATAL);
3580 return (ARCHIVE_OK);
3584 skip_stream(struct archive_read *a, size_t skip_bytes)
3586 struct _7zip *zip = (struct _7zip *)a->format->data;
3588 int64_t skipped_bytes;
3589 size_t bytes = skip_bytes;
3591 if (zip->folder_index == 0) {
3593 * Optimization for a list mode.
3594 * Avoid unnecessary decoding operations.
3596 zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3598 return (skip_bytes);
3602 skipped_bytes = read_stream(a, &p, bytes, 0);
3603 if (skipped_bytes < 0)
3604 return (skipped_bytes);
3605 if (skipped_bytes == 0) {
3606 archive_set_error(&a->archive,
3607 ARCHIVE_ERRNO_FILE_FORMAT,
3608 "Truncated 7-Zip file body");
3609 return (ARCHIVE_FATAL);
3611 bytes -= (size_t)skipped_bytes;
3612 if (zip->pack_stream_bytes_unconsumed)
3615 return (skip_bytes);
3619 * Brought from LZMA SDK.
3621 * Bra86.c -- Converter for x86 code (BCJ)
3622 * 2008-10-04 : Igor Pavlov : Public domain
3626 #define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
3629 x86_Init(struct _7zip *zip)
3632 zip->bcj_prevPosT = (size_t)0 - 1;
3633 zip->bcj_prevMask = 0;
3638 x86_Convert(struct _7zip *zip, uint8_t *data, size_t size)
3640 static const uint8_t kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};
3641 static const uint8_t kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};
3642 size_t bufferPos, prevPosT;
3643 uint32_t ip, prevMask;
3649 prevPosT = zip->bcj_prevPosT;
3650 prevMask = zip->bcj_prevMask;
3654 uint8_t *p = data + bufferPos;
3655 uint8_t *limit = data + size - 4;
3657 for (; p < limit; p++)
3658 if ((*p & 0xFE) == 0xE8)
3660 bufferPos = (size_t)(p - data);
3663 prevPosT = bufferPos - prevPosT;
3667 prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7;
3668 if (prevMask != 0) {
3670 p[4 - kMaskToBitNumber[prevMask]];
3671 if (!kMaskToAllowedStatus[prevMask] ||
3673 prevPosT = bufferPos;
3674 prevMask = ((prevMask << 1) & 0x7) | 1;
3680 prevPosT = bufferPos;
3682 if (Test86MSByte(p[4])) {
3683 uint32_t src = ((uint32_t)p[4] << 24) |
3684 ((uint32_t)p[3] << 16) | ((uint32_t)p[2] << 8) |
3691 dest = src - (ip + (uint32_t)bufferPos);
3694 b_index = kMaskToBitNumber[prevMask] * 8;
3695 b = (uint8_t)(dest >> (24 - b_index));
3696 if (!Test86MSByte(b))
3698 src = dest ^ ((1 << (32 - b_index)) - 1);
3700 p[4] = (uint8_t)(~(((dest >> 24) & 1) - 1));
3701 p[3] = (uint8_t)(dest >> 16);
3702 p[2] = (uint8_t)(dest >> 8);
3703 p[1] = (uint8_t)dest;
3706 prevMask = ((prevMask << 1) & 0x7) | 1;
3710 zip->bcj_prevPosT = prevPosT;
3711 zip->bcj_prevMask = prevMask;
3712 zip->bcj_ip += (uint32_t)bufferPos;
3717 * Brought from LZMA SDK.
3719 * Bcj2.c -- Converter for x86 code (BCJ2)
3720 * 2008-10-04 : Igor Pavlov : Public domain
3724 #define SZ_ERROR_DATA ARCHIVE_FAILED
3726 #define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80)
3727 #define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1))
3729 #define kNumTopBits 24
3730 #define kTopValue ((uint32_t)1 << kNumTopBits)
3732 #define kNumBitModelTotalBits 11
3733 #define kBitModelTotal (1 << kNumBitModelTotalBits)
3734 #define kNumMoveBits 5
3736 #define RC_READ_BYTE (*buffer++)
3737 #define RC_TEST { if (buffer == bufferLim) return SZ_ERROR_DATA; }
3738 #define RC_INIT2 zip->bcj2_code = 0; zip->bcj2_range = 0xFFFFFFFF; \
3739 { int ii; for (ii = 0; ii < 5; ii++) { RC_TEST; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }}
3741 #define NORMALIZE if (zip->bcj2_range < kTopValue) { RC_TEST; zip->bcj2_range <<= 8; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }
3743 #define IF_BIT_0(p) ttt = *(p); bound = (zip->bcj2_range >> kNumBitModelTotalBits) * ttt; if (zip->bcj2_code < bound)
3744 #define UPDATE_0(p) zip->bcj2_range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); NORMALIZE;
3745 #define UPDATE_1(p) zip->bcj2_range -= bound; zip->bcj2_code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); NORMALIZE;
3748 Bcj2_Decode(struct _7zip *zip, uint8_t *outBuf, size_t outSize)
3750 size_t inPos = 0, outPos = 0;
3751 const uint8_t *buf0, *buf1, *buf2, *buf3;
3752 size_t size0, size1, size2, size3;
3753 const uint8_t *buffer, *bufferLim;
3756 size0 = zip->tmp_stream_bytes_remaining;
3757 buf0 = zip->tmp_stream_buff + zip->tmp_stream_bytes_avail - size0;
3758 size1 = zip->sub_stream_bytes_remaining[0];
3759 buf1 = zip->sub_stream_buff[0] + zip->sub_stream_size[0] - size1;
3760 size2 = zip->sub_stream_bytes_remaining[1];
3761 buf2 = zip->sub_stream_buff[1] + zip->sub_stream_size[1] - size2;
3762 size3 = zip->sub_stream_bytes_remaining[2];
3763 buf3 = zip->sub_stream_buff[2] + zip->sub_stream_size[2] - size3;
3766 bufferLim = buffer + size3;
3768 if (zip->bcj_state == 0) {
3772 zip->bcj2_prevByte = 0;
3774 i < sizeof(zip->bcj2_p) / sizeof(zip->bcj2_p[0]); i++)
3775 zip->bcj2_p[i] = kBitModelTotal >> 1;
3781 * Gather the odd bytes of a previous call.
3783 for (i = 0; zip->odd_bcj_size > 0 && outPos < outSize; i++) {
3784 outBuf[outPos++] = zip->odd_bcj[i];
3785 zip->odd_bcj_size--;
3789 zip->bcj2_outPos += outPos;
3799 size_t limit = size0 - inPos;
3800 if (outSize - outPos < limit)
3801 limit = outSize - outPos;
3803 if (zip->bcj_state == 1) {
3804 while (limit != 0) {
3805 uint8_t bb = buf0[inPos];
3806 outBuf[outPos++] = bb;
3807 if (IsJ(zip->bcj2_prevByte, bb)) {
3812 zip->bcj2_prevByte = bb;
3817 if (limit == 0 || outPos == outSize)
3824 prob = zip->bcj2_p + zip->bcj2_prevByte;
3826 prob = zip->bcj2_p + 256;
3828 prob = zip->bcj2_p + 257;
3832 zip->bcj2_prevByte = b;
3842 return SZ_ERROR_DATA;
3848 return SZ_ERROR_DATA;
3852 dest = (((uint32_t)v[0] << 24) |
3853 ((uint32_t)v[1] << 16) |
3854 ((uint32_t)v[2] << 8) |
3856 ((uint32_t)zip->bcj2_outPos + (uint32_t)outPos + 4);
3857 out[0] = (uint8_t)dest;
3858 out[1] = (uint8_t)(dest >> 8);
3859 out[2] = (uint8_t)(dest >> 16);
3860 out[3] = zip->bcj2_prevByte = (uint8_t)(dest >> 24);
3862 for (i = 0; i < 4 && outPos < outSize; i++)
3863 outBuf[outPos++] = out[i];
3866 * Save odd bytes which we could not add into
3867 * the output buffer because of out of space.
3869 zip->odd_bcj_size = 4 -i;
3870 for (; i < 4; i++) {
3871 j = i - 4 + (unsigned)zip->odd_bcj_size;
3872 zip->odd_bcj[j] = out[i];
3878 zip->tmp_stream_bytes_remaining -= inPos;
3879 zip->sub_stream_bytes_remaining[0] = size1;
3880 zip->sub_stream_bytes_remaining[1] = size2;
3881 zip->sub_stream_bytes_remaining[2] = bufferLim - buffer;
3882 zip->bcj2_outPos += outPos;
3884 return ((ssize_t)outPos);