2 * Copyright (c) 2010-2012 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"
45 #include "archive_entry.h"
46 #include "archive_entry_locale.h"
47 #include "archive_private.h"
48 #include "archive_read_private.h"
49 #include "archive_endian.h"
53 /* Decoding status. */
57 * Window to see last decoded data, from 32KBi to 2MBi.
61 /* Window buffer, which is a loop buffer. */
62 unsigned char *w_buff;
63 /* The insert position to the window. */
65 /* The position where we can copy decoded code from the window. */
67 /* The length how many bytes we can copy decoded code from
70 /* Translation reversal for x86 proccessor CALL byte sequence(E8).
71 * This is used for LZX only. */
72 uint32_t translation_size;
75 #define VERBATIM_BLOCK 1
76 #define ALIGNED_OFFSET_BLOCK 2
77 #define UNCOMPRESSED_BLOCK 3
79 size_t block_bytes_avail;
80 /* Repeated offset. */
82 unsigned char rbytes[4];
96 #define CACHE_TYPE uint64_t
97 #define CACHE_BITS (8 * sizeof(CACHE_TYPE))
99 CACHE_TYPE cache_buffer;
100 /* Indicates how many bits avail in cache_buffer. */
112 unsigned char *bitlen;
115 * Use a index table. It's faster than searching a huffman
116 * coding tree, which is a binary tree. But a use of a large
117 * index table causes L1 cache read miss many times.
125 /* Direct access table. */
127 /* Binary tree table for extra bits over the direct access. */
138 static const int slots[] = {
139 30, 32, 34, 36, 38, 42, 50, 66, 98, 162, 290
142 #define SLOT_MAX 21/*->25*/
145 const unsigned char *next_in;
148 unsigned char *next_out;
155 * Cabinet file definitions.
157 /* CFHEADER offset */
158 #define CFHEADER_signature 0
159 #define CFHEADER_cbCabinet 8
160 #define CFHEADER_coffFiles 16
161 #define CFHEADER_versionMinor 24
162 #define CFHEADER_versionMajor 25
163 #define CFHEADER_cFolders 26
164 #define CFHEADER_cFiles 28
165 #define CFHEADER_flags 30
166 #define CFHEADER_setID 32
167 #define CFHEADER_iCabinet 34
168 #define CFHEADER_cbCFHeader 36
169 #define CFHEADER_cbCFFolder 38
170 #define CFHEADER_cbCFData 39
172 /* CFFOLDER offset */
173 #define CFFOLDER_coffCabStart 0
174 #define CFFOLDER_cCFData 4
175 #define CFFOLDER_typeCompress 6
176 #define CFFOLDER_abReserve 8
179 #define CFFILE_cbFile 0
180 #define CFFILE_uoffFolderStart 4
181 #define CFFILE_iFolder 8
182 #define CFFILE_date_time 10
183 #define CFFILE_attribs 14
186 #define CFDATA_csum 0
187 #define CFDATA_cbData 4
188 #define CFDATA_cbUncomp 6
190 static const char *compression_name[] = {
198 /* Sum value of this CFDATA. */
200 uint16_t compressed_size;
201 uint16_t compressed_bytes_remaining;
202 uint16_t uncompressed_size;
203 uint16_t uncompressed_bytes_remaining;
204 /* To know how many bytes we have decompressed. */
205 uint16_t uncompressed_avail;
206 /* Offset from the beginning of compressed data of this CFDATA */
207 uint16_t read_offset;
209 /* To keep memory image of this CFDATA to compute the sum. */
210 size_t memimage_size;
211 unsigned char *memimage;
212 /* Result of calculation of sum. */
213 uint32_t sum_calculated;
214 unsigned char sum_extra[4];
220 uint32_t cfdata_offset_in_cab;
221 uint16_t cfdata_count;
223 #define COMPTYPE_NONE 0x0000
224 #define COMPTYPE_MSZIP 0x0001
225 #define COMPTYPE_QUANTUM 0x0002
226 #define COMPTYPE_LZX 0x0003
228 const char *compname;
229 /* At the time reading CFDATA */
230 struct cfdata cfdata;
232 /* Flags to mark progress of decompression. */
233 char decompress_init;
237 uint32_t uncompressed_size;
241 #define iFoldCONTINUED_FROM_PREV 0xFFFD
242 #define iFoldCONTINUED_TO_NEXT 0xFFFE
243 #define iFoldCONTINUED_PREV_AND_NEXT 0xFFFF
245 #define ATTR_RDONLY 0x01
246 #define ATTR_NAME_IS_UTF 0x80
247 struct archive_string pathname;
251 /* Total bytes of all file size in a Cabinet. */
252 uint32_t total_bytes;
253 uint32_t files_offset;
254 uint16_t folder_count;
257 #define PREV_CABINET 0x0001
258 #define NEXT_CABINET 0x0002
259 #define RESERVE_PRESENT 0x0004
262 /* Version number. */
265 unsigned char cffolder;
266 unsigned char cfdata;
267 /* All folders in a cabinet. */
268 struct cffolder *folder_array;
269 /* All files in a cabinet. */
270 struct cffile *file_array;
275 /* entry_bytes_remaining is the number of bytes we expect. */
276 int64_t entry_offset;
277 int64_t entry_bytes_remaining;
278 int64_t entry_unconsumed;
279 int64_t entry_compressed_bytes_read;
280 int64_t entry_uncompressed_bytes_read;
281 struct cffolder *entry_cffolder;
282 struct cffile *entry_cffile;
283 struct cfdata *entry_cfdata;
285 /* Offset from beginning of a cabinet file. */
287 struct cfheader cfheader;
288 struct archive_wstring ws;
290 /* Flag to mark progress that an archive was read their first header.*/
294 char end_of_entry_cleanup;
295 char read_data_invoked;
296 int64_t bytes_skipped;
298 unsigned char *uncompressed_buffer;
299 size_t uncompressed_buffer_size;
301 int init_default_conversion;
302 struct archive_string_conv *sconv;
303 struct archive_string_conv *sconv_default;
304 struct archive_string_conv *sconv_utf8;
305 char format_name[64];
311 struct lzx_stream xstrm;
314 static int archive_read_format_cab_bid(struct archive_read *, int);
315 static int archive_read_format_cab_options(struct archive_read *,
316 const char *, const char *);
317 static int archive_read_format_cab_read_header(struct archive_read *,
318 struct archive_entry *);
319 static int archive_read_format_cab_read_data(struct archive_read *,
320 const void **, size_t *, int64_t *);
321 static int archive_read_format_cab_read_data_skip(struct archive_read *);
322 static int archive_read_format_cab_cleanup(struct archive_read *);
324 static int cab_skip_sfx(struct archive_read *);
325 static time_t cab_dos_time(const unsigned char *);
326 static int cab_read_data(struct archive_read *, const void **,
327 size_t *, int64_t *);
328 static int cab_read_header(struct archive_read *);
329 static uint32_t cab_checksum_cfdata_4(const void *, size_t bytes, uint32_t);
330 static uint32_t cab_checksum_cfdata(const void *, size_t bytes, uint32_t);
331 static void cab_checksum_update(struct archive_read *, size_t);
332 static int cab_checksum_finish(struct archive_read *);
333 static int cab_next_cfdata(struct archive_read *);
334 static const void *cab_read_ahead_cfdata(struct archive_read *, ssize_t *);
335 static const void *cab_read_ahead_cfdata_none(struct archive_read *, ssize_t *);
336 static const void *cab_read_ahead_cfdata_deflate(struct archive_read *,
338 static const void *cab_read_ahead_cfdata_lzx(struct archive_read *,
340 static int64_t cab_consume_cfdata(struct archive_read *, int64_t);
341 static int64_t cab_minimum_consume_cfdata(struct archive_read *, int64_t);
342 static int lzx_decode_init(struct lzx_stream *, int);
343 static int lzx_read_blocks(struct lzx_stream *, int);
344 static int lzx_decode_blocks(struct lzx_stream *, int);
345 static void lzx_decode_free(struct lzx_stream *);
346 static void lzx_translation(struct lzx_stream *, void *, size_t, uint32_t);
347 static void lzx_cleanup_bitstream(struct lzx_stream *);
348 static int lzx_decode(struct lzx_stream *, int);
349 static int lzx_read_pre_tree(struct lzx_stream *);
350 static int lzx_read_bitlen(struct lzx_stream *, struct huffman *, int);
351 static int lzx_huffman_init(struct huffman *, size_t, int);
352 static void lzx_huffman_free(struct huffman *);
353 static int lzx_make_huffman_table(struct huffman *);
354 static inline int lzx_decode_huffman(struct huffman *, unsigned);
355 static int lzx_decode_huffman_tree(struct huffman *, unsigned, int);
359 archive_read_support_format_cab(struct archive *_a)
361 struct archive_read *a = (struct archive_read *)_a;
365 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
366 ARCHIVE_STATE_NEW, "archive_read_support_format_cab");
368 cab = (struct cab *)calloc(1, sizeof(*cab));
370 archive_set_error(&a->archive, ENOMEM,
371 "Can't allocate CAB data");
372 return (ARCHIVE_FATAL);
374 archive_string_init(&cab->ws);
375 archive_wstring_ensure(&cab->ws, 256);
377 r = __archive_read_register_format(a,
380 archive_read_format_cab_bid,
381 archive_read_format_cab_options,
382 archive_read_format_cab_read_header,
383 archive_read_format_cab_read_data,
384 archive_read_format_cab_read_data_skip,
386 archive_read_format_cab_cleanup);
394 find_cab_magic(const char *p)
399 * Note: Self-Extraction program has 'MSCF' string in their
400 * program. If we were finding 'MSCF' string only, we got
401 * wrong place for Cabinet header, thus, we have to check
402 * following four bytes which are reserved and must be set
405 if (memcmp(p, "MSCF\0\0\0\0", 8) == 0)
417 archive_read_format_cab_bid(struct archive_read *a, int best_bid)
420 ssize_t bytes_avail, offset, window;
422 /* If there's already a better bid than we can ever
423 make, don't bother testing. */
427 if ((p = __archive_read_ahead(a, 8, NULL)) == NULL)
430 if (memcmp(p, "MSCF\0\0\0\0", 8) == 0)
434 * Attempt to handle self-extracting archives
435 * by noting a PE header and searching forward
436 * up to 128k for a 'MSCF' marker.
438 if (p[0] == 'M' && p[1] == 'Z') {
441 while (offset < (1024 * 128)) {
442 const char *h = __archive_read_ahead(a, offset + window,
445 /* Remaining bytes are less than window. */
452 while (p + 8 < h + bytes_avail) {
454 if ((next = find_cab_magic(p)) == 0)
465 archive_read_format_cab_options(struct archive_read *a,
466 const char *key, const char *val)
469 int ret = ARCHIVE_FAILED;
471 cab = (struct cab *)(a->format->data);
472 if (strcmp(key, "hdrcharset") == 0) {
473 if (val == NULL || val[0] == 0)
474 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
475 "cab: hdrcharset option needs a character-set name");
477 cab->sconv = archive_string_conversion_from_charset(
478 &a->archive, val, 0);
479 if (cab->sconv != NULL)
487 /* Note: The "warn" return is just to inform the options
488 * supervisor that we didn't handle it. It will generate
489 * a suitable error if no one used this option. */
490 return (ARCHIVE_WARN);
494 cab_skip_sfx(struct archive_read *a)
498 ssize_t bytes, window;
502 const char *h = __archive_read_ahead(a, window, &bytes);
504 /* Remaining size are less than window. */
507 archive_set_error(&a->archive,
508 ARCHIVE_ERRNO_FILE_FORMAT,
509 "Couldn't find out CAB header");
510 return (ARCHIVE_FATAL);
518 * Scan ahead until we find something that looks
519 * like the cab header.
523 if ((next = find_cab_magic(p)) == 0) {
525 __archive_read_consume(a, skip);
531 __archive_read_consume(a, skip);
536 truncated_error(struct archive_read *a)
538 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
539 "Truncated CAB header");
540 return (ARCHIVE_FATAL);
544 cab_strnlen(const unsigned char *p, size_t maxlen)
548 for (i = 0; i <= maxlen; i++) {
553 return (-1);/* invalid */
557 /* Read bytes as much as remaining. */
559 cab_read_ahead_remaining(struct archive_read *a, size_t min, ssize_t *avail)
564 p = __archive_read_ahead(a, min, avail);
572 /* Convert a path separator '\' -> '/' */
574 cab_convert_path_separator_1(struct archive_string *fn, unsigned char attr)
579 /* Easy check if we have '\' in multi-byte string. */
581 for (i = 0; i < archive_strlen(fn); i++) {
582 if (fn->s[i] == '\\') {
584 /* This may be second byte of multi-byte
590 } else if ((fn->s[i] & 0x80) && !(attr & ATTR_NAME_IS_UTF))
595 if (i == archive_strlen(fn))
601 * Replace a character '\' with '/' in wide character.
604 cab_convert_path_separator_2(struct cab *cab, struct archive_entry *entry)
609 /* If a conversion to wide character failed, force the replacement. */
610 if ((wp = archive_entry_pathname_w(entry)) != NULL) {
611 archive_wstrcpy(&(cab->ws), wp);
612 for (i = 0; i < archive_strlen(&(cab->ws)); i++) {
613 if (cab->ws.s[i] == L'\\')
616 archive_entry_copy_pathname_w(entry, cab->ws.s);
621 * Read CFHEADER, CFFOLDER and CFFILE.
624 cab_read_header(struct archive_read *a)
626 const unsigned char *p;
633 int cur_folder, prev_folder;
636 a->archive.archive_format = ARCHIVE_FORMAT_CAB;
637 if (a->archive.archive_format_name == NULL)
638 a->archive.archive_format_name = "CAB";
640 if ((p = __archive_read_ahead(a, 42, NULL)) == NULL)
641 return (truncated_error(a));
643 cab = (struct cab *)(a->format->data);
644 if (cab->found_header == 0 &&
645 p[0] == 'M' && p[1] == 'Z') {
646 /* This is an executable? Must be self-extracting... */
647 err = cab_skip_sfx(a);
648 if (err < ARCHIVE_WARN)
651 if ((p = __archive_read_ahead(a, sizeof(*p), NULL)) == NULL)
652 return (truncated_error(a));
660 if (p[CFHEADER_signature+0] != 'M' || p[CFHEADER_signature+1] != 'S' ||
661 p[CFHEADER_signature+2] != 'C' || p[CFHEADER_signature+3] != 'F') {
662 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
663 "Couldn't find out CAB header");
664 return (ARCHIVE_FATAL);
666 hd->total_bytes = archive_le32dec(p + CFHEADER_cbCabinet);
667 hd->files_offset = archive_le32dec(p + CFHEADER_coffFiles);
668 hd->minor = p[CFHEADER_versionMinor];
669 hd->major = p[CFHEADER_versionMajor];
670 hd->folder_count = archive_le16dec(p + CFHEADER_cFolders);
671 if (hd->folder_count == 0)
673 hd->file_count = archive_le16dec(p + CFHEADER_cFiles);
674 if (hd->file_count == 0)
676 hd->flags = archive_le16dec(p + CFHEADER_flags);
677 hd->setid = archive_le16dec(p + CFHEADER_setID);
678 hd->cabinet = archive_le16dec(p + CFHEADER_iCabinet);
679 used = CFHEADER_iCabinet + 2;
680 if (hd->flags & RESERVE_PRESENT) {
682 cfheader = archive_le16dec(p + CFHEADER_cbCFHeader);
683 if (cfheader > 60000U)
685 hd->cffolder = p[CFHEADER_cbCFFolder];
686 hd->cfdata = p[CFHEADER_cbCFData];
687 used += 4;/* cbCFHeader, cbCFFolder and cbCFData */
688 used += cfheader;/* abReserve */
690 hd->cffolder = 0;/* Avoid compiling warning. */
691 if (hd->flags & PREV_CABINET) {
692 /* How many bytes are used for szCabinetPrev. */
693 if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)
694 return (truncated_error(a));
695 if ((len = cab_strnlen(p + used, 255)) <= 0)
698 /* How many bytes are used for szDiskPrev. */
699 if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)
700 return (truncated_error(a));
701 if ((len = cab_strnlen(p + used, 255)) <= 0)
705 if (hd->flags & NEXT_CABINET) {
706 /* How many bytes are used for szCabinetNext. */
707 if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)
708 return (truncated_error(a));
709 if ((len = cab_strnlen(p + used, 255)) <= 0)
712 /* How many bytes are used for szDiskNext. */
713 if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)
714 return (truncated_error(a));
715 if ((len = cab_strnlen(p + used, 255)) <= 0)
719 __archive_read_consume(a, used);
720 cab->cab_offset += used;
726 hd->folder_array = (struct cffolder *)calloc(
727 hd->folder_count, sizeof(struct cffolder));
728 if (hd->folder_array == NULL)
732 if (hd->flags & RESERVE_PRESENT)
733 bytes += hd->cffolder;
734 bytes *= hd->folder_count;
735 if ((p = __archive_read_ahead(a, bytes, NULL)) == NULL)
736 return (truncated_error(a));
738 for (i = 0; i < hd->folder_count; i++) {
739 struct cffolder *folder = &(hd->folder_array[i]);
740 folder->cfdata_offset_in_cab =
741 archive_le32dec(p + CFFOLDER_coffCabStart);
742 folder->cfdata_count = archive_le16dec(p+CFFOLDER_cCFData);
744 archive_le16dec(p+CFFOLDER_typeCompress) & 0x0F;
746 archive_le16dec(p+CFFOLDER_typeCompress) >> 8;
747 /* Get a compression name. */
748 if (folder->comptype <
749 sizeof(compression_name) / sizeof(compression_name[0]))
750 folder->compname = compression_name[folder->comptype];
752 folder->compname = "UNKNOWN";
755 if (hd->flags & RESERVE_PRESENT) {
756 p += hd->cffolder;/* abReserve */
757 used += hd->cffolder;
760 * Sanity check if each data is acceptable.
762 if (offset32 >= folder->cfdata_offset_in_cab)
764 offset32 = folder->cfdata_offset_in_cab;
766 /* Set a request to initialize zlib for the CFDATA of
768 folder->decompress_init = 0;
770 __archive_read_consume(a, used);
771 cab->cab_offset += used;
776 /* Seek read pointer to the offset of CFFILE if needed. */
777 skip = (int64_t)hd->files_offset - cab->cab_offset;
779 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
780 "Invalid offset of CFFILE %jd < %jd",
781 (intmax_t)hd->files_offset, (intmax_t)cab->cab_offset);
782 return (ARCHIVE_FATAL);
785 __archive_read_consume(a, skip);
786 cab->cab_offset += skip;
788 /* Allocate memory for CFDATA */
789 hd->file_array = (struct cffile *)calloc(
790 hd->file_count, sizeof(struct cffile));
791 if (hd->file_array == NULL)
795 for (i = 0; i < hd->file_count; i++) {
796 struct cffile *file = &(hd->file_array[i]);
799 if ((p = __archive_read_ahead(a, 16, NULL)) == NULL)
800 return (truncated_error(a));
801 file->uncompressed_size = archive_le32dec(p + CFFILE_cbFile);
802 file->offset = archive_le32dec(p + CFFILE_uoffFolderStart);
803 file->folder = archive_le16dec(p + CFFILE_iFolder);
804 file->mtime = cab_dos_time(p + CFFILE_date_time);
805 file->attr = (uint8_t)archive_le16dec(p + CFFILE_attribs);
806 __archive_read_consume(a, 16);
808 cab->cab_offset += 16;
809 if ((p = cab_read_ahead_remaining(a, 256, &avail)) == NULL)
810 return (truncated_error(a));
811 if ((len = cab_strnlen(p, avail-1)) <= 0)
814 /* Copy a pathname. */
815 archive_string_init(&(file->pathname));
816 archive_strncpy(&(file->pathname), p, len);
817 __archive_read_consume(a, len + 1);
818 cab->cab_offset += len + 1;
821 * Sanity check if each data is acceptable.
823 if (file->uncompressed_size > 0x7FFF8000)
824 goto invalid;/* Too large */
825 if ((int64_t)file->offset + (int64_t)file->uncompressed_size
826 > ARCHIVE_LITERAL_LL(0x7FFF8000))
827 goto invalid;/* Too large */
828 switch (file->folder) {
829 case iFoldCONTINUED_TO_NEXT:
830 /* This must be last file in a folder. */
831 if (i != hd->file_count -1)
833 cur_folder = hd->folder_count -1;
835 case iFoldCONTINUED_PREV_AND_NEXT:
836 /* This must be only one file in a folder. */
837 if (hd->file_count != 1)
840 case iFoldCONTINUED_FROM_PREV:
841 /* This must be first file in a folder. */
844 prev_folder = cur_folder = 0;
845 offset32 = file->offset;
848 if (file->folder >= hd->folder_count)
850 cur_folder = file->folder;
853 /* Dot not back track. */
854 if (cur_folder < prev_folder)
856 if (cur_folder != prev_folder)
858 prev_folder = cur_folder;
860 /* Make sure there are not any blanks from last file
862 if (offset32 != file->offset)
864 offset32 += file->uncompressed_size;
866 /* CFDATA is available for file contents. */
867 if (file->uncompressed_size > 0 &&
868 hd->folder_array[cur_folder].cfdata_count == 0)
872 if (hd->cabinet != 0 || hd->flags & (PREV_CABINET | NEXT_CABINET)) {
873 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
874 "Multivolume cabinet file is unsupported");
875 return (ARCHIVE_WARN);
879 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
880 "Invalid CAB header");
881 return (ARCHIVE_FATAL);
883 archive_set_error(&a->archive, ENOMEM,
884 "Can't allocate memory for CAB data");
885 return (ARCHIVE_FATAL);
889 archive_read_format_cab_read_header(struct archive_read *a,
890 struct archive_entry *entry)
894 struct cffolder *prev_folder;
896 struct archive_string_conv *sconv;
897 int err = ARCHIVE_OK, r;
899 cab = (struct cab *)(a->format->data);
900 if (cab->found_header == 0) {
901 err = cab_read_header(a);
902 if (err < ARCHIVE_WARN)
904 /* We've found the header. */
905 cab->found_header = 1;
909 if (hd->file_index >= hd->file_count) {
910 cab->end_of_archive = 1;
911 return (ARCHIVE_EOF);
913 file = &hd->file_array[hd->file_index++];
915 cab->end_of_entry = 0;
916 cab->end_of_entry_cleanup = 0;
917 cab->entry_compressed_bytes_read = 0;
918 cab->entry_uncompressed_bytes_read = 0;
919 cab->entry_unconsumed = 0;
920 cab->entry_cffile = file;
923 * Choose a proper folder.
925 prev_folder = cab->entry_cffolder;
926 switch (file->folder) {
927 case iFoldCONTINUED_FROM_PREV:
928 case iFoldCONTINUED_PREV_AND_NEXT:
929 cab->entry_cffolder = &hd->folder_array[0];
931 case iFoldCONTINUED_TO_NEXT:
932 cab->entry_cffolder = &hd->folder_array[hd->folder_count-1];
935 cab->entry_cffolder = &hd->folder_array[file->folder];
938 /* If a cffolder of this file is changed, reset a cfdata to read
939 * file contents from next cfdata. */
940 if (prev_folder != cab->entry_cffolder)
941 cab->entry_cfdata = NULL;
943 /* If a pathname is UTF-8, prepare a string conversion object
944 * for UTF-8 and use it. */
945 if (file->attr & ATTR_NAME_IS_UTF) {
946 if (cab->sconv_utf8 == NULL) {
948 archive_string_conversion_from_charset(
949 &(a->archive), "UTF-8", 1);
950 if (cab->sconv_utf8 == NULL)
951 return (ARCHIVE_FATAL);
953 sconv = cab->sconv_utf8;
954 } else if (cab->sconv != NULL) {
955 /* Choose the conversion specified by the option. */
958 /* Choose the default conversion. */
959 if (!cab->init_default_conversion) {
961 archive_string_default_conversion_for_read(
963 cab->init_default_conversion = 1;
965 sconv = cab->sconv_default;
969 * Set a default value and common data
971 r = cab_convert_path_separator_1(&(file->pathname), file->attr);
972 if (archive_entry_copy_pathname_l(entry, file->pathname.s,
973 archive_strlen(&(file->pathname)), sconv) != 0) {
974 if (errno == ENOMEM) {
975 archive_set_error(&a->archive, ENOMEM,
976 "Can't allocate memory for Pathname");
977 return (ARCHIVE_FATAL);
979 archive_set_error(&a->archive,
980 ARCHIVE_ERRNO_FILE_FORMAT,
981 "Pathname cannot be converted "
982 "from %s to current locale.",
983 archive_string_conversion_charset_name(sconv));
987 /* Convert a path separator '\' -> '/' */
988 cab_convert_path_separator_2(cab, entry);
991 archive_entry_set_size(entry, file->uncompressed_size);
992 if (file->attr & ATTR_RDONLY)
993 archive_entry_set_mode(entry, AE_IFREG | 0555);
995 archive_entry_set_mode(entry, AE_IFREG | 0666);
996 archive_entry_set_mtime(entry, file->mtime, 0);
998 cab->entry_bytes_remaining = file->uncompressed_size;
999 cab->entry_offset = 0;
1000 /* We don't need compress data. */
1001 if (file->uncompressed_size == 0)
1002 cab->end_of_entry_cleanup = cab->end_of_entry = 1;
1004 /* Set up a more descriptive format name. */
1005 sprintf(cab->format_name, "CAB %d.%d (%s)",
1006 hd->major, hd->minor, cab->entry_cffolder->compname);
1007 a->archive.archive_format_name = cab->format_name;
1013 archive_read_format_cab_read_data(struct archive_read *a,
1014 const void **buff, size_t *size, int64_t *offset)
1016 struct cab *cab = (struct cab *)(a->format->data);
1019 switch (cab->entry_cffile->folder) {
1020 case iFoldCONTINUED_FROM_PREV:
1021 case iFoldCONTINUED_TO_NEXT:
1022 case iFoldCONTINUED_PREV_AND_NEXT:
1026 archive_clear_error(&a->archive);
1027 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1028 "Cannot restore this file split in multivolume.");
1029 return (ARCHIVE_FAILED);
1033 if (cab->read_data_invoked == 0) {
1034 if (cab->bytes_skipped) {
1035 if (cab->entry_cfdata == NULL) {
1036 r = cab_next_cfdata(a);
1040 if (cab_consume_cfdata(a, cab->bytes_skipped) < 0)
1041 return (ARCHIVE_FATAL);
1042 cab->bytes_skipped = 0;
1044 cab->read_data_invoked = 1;
1046 if (cab->entry_unconsumed) {
1047 /* Consume as much as the compressor actually used. */
1048 r = (int)cab_consume_cfdata(a, cab->entry_unconsumed);
1049 cab->entry_unconsumed = 0;
1053 if (cab->end_of_archive || cab->end_of_entry) {
1054 if (!cab->end_of_entry_cleanup) {
1055 /* End-of-entry cleanup done. */
1056 cab->end_of_entry_cleanup = 1;
1058 *offset = cab->entry_offset;
1061 return (ARCHIVE_EOF);
1064 return (cab_read_data(a, buff, size, offset));
1068 cab_checksum_cfdata_4(const void *p, size_t bytes, uint32_t seed)
1070 const unsigned char *b;
1074 u32num = (unsigned)bytes / 4;
1077 for (;u32num > 0; --u32num) {
1078 sum ^= archive_le32dec(b);
1085 cab_checksum_cfdata(const void *p, size_t bytes, uint32_t seed)
1087 const unsigned char *b;
1091 sum = cab_checksum_cfdata_4(p, bytes, seed);
1095 switch (bytes & 3) {
1097 t |= ((uint32_t)(*b++)) << 16;
1100 t |= ((uint32_t)(*b++)) << 8;
1114 cab_checksum_update(struct archive_read *a, size_t bytes)
1116 struct cab *cab = (struct cab *)(a->format->data);
1117 struct cfdata *cfdata = cab->entry_cfdata;
1118 const unsigned char *p;
1121 if (cfdata->sum == 0 || cfdata->sum_ptr == NULL)
1124 * Calculate the sum of this CFDATA.
1125 * Make sure CFDATA must be calculated in four bytes.
1127 p = cfdata->sum_ptr;
1129 if (cfdata->sum_extra_avail) {
1130 while (cfdata->sum_extra_avail < 4 && sumbytes > 0) {
1132 cfdata->sum_extra_avail++] = *p++;
1135 if (cfdata->sum_extra_avail == 4) {
1136 cfdata->sum_calculated = cab_checksum_cfdata_4(
1137 cfdata->sum_extra, 4, cfdata->sum_calculated);
1138 cfdata->sum_extra_avail = 0;
1142 int odd = sumbytes & 3;
1143 if (sumbytes - odd > 0)
1144 cfdata->sum_calculated = cab_checksum_cfdata_4(
1145 p, sumbytes - odd, cfdata->sum_calculated);
1147 memcpy(cfdata->sum_extra, p + sumbytes - odd, odd);
1148 cfdata->sum_extra_avail = odd;
1150 cfdata->sum_ptr = NULL;
1154 cab_checksum_finish(struct archive_read *a)
1156 struct cab *cab = (struct cab *)(a->format->data);
1157 struct cfdata *cfdata = cab->entry_cfdata;
1160 /* Do not need to compute a sum. */
1161 if (cfdata->sum == 0)
1162 return (ARCHIVE_OK);
1165 * Calculate the sum of remaining CFDATA.
1167 if (cfdata->sum_extra_avail) {
1168 cfdata->sum_calculated =
1169 cab_checksum_cfdata(cfdata->sum_extra,
1170 cfdata->sum_extra_avail, cfdata->sum_calculated);
1171 cfdata->sum_extra_avail = 0;
1175 if (cab->cfheader.flags & RESERVE_PRESENT)
1176 l += cab->cfheader.cfdata;
1177 cfdata->sum_calculated = cab_checksum_cfdata(
1178 cfdata->memimage + CFDATA_cbData, l, cfdata->sum_calculated);
1179 if (cfdata->sum_calculated != cfdata->sum) {
1180 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1181 "Checksum error CFDATA[%d] %x:%x in %d bytes",
1182 cab->entry_cffolder->cfdata_index -1,
1183 cfdata->sum, cfdata->sum_calculated,
1184 cfdata->compressed_size);
1185 return (ARCHIVE_FAILED);
1187 return (ARCHIVE_OK);
1191 * Read CFDATA if needed.
1194 cab_next_cfdata(struct archive_read *a)
1196 struct cab *cab = (struct cab *)(a->format->data);
1197 struct cfdata *cfdata = cab->entry_cfdata;
1199 /* There are remaining bytes in current CFDATA, use it first. */
1200 if (cfdata != NULL && cfdata->uncompressed_bytes_remaining > 0)
1201 return (ARCHIVE_OK);
1203 if (cfdata == NULL) {
1206 cab->entry_cffolder->cfdata_index = 0;
1208 /* Seek read pointer to the offset of CFDATA if needed. */
1209 skip = cab->entry_cffolder->cfdata_offset_in_cab
1213 switch (cab->entry_cffile->folder) {
1214 case iFoldCONTINUED_FROM_PREV:
1215 case iFoldCONTINUED_PREV_AND_NEXT:
1218 case iFoldCONTINUED_TO_NEXT:
1219 folder_index = cab->cfheader.folder_count-1;
1222 folder_index = cab->entry_cffile->folder;
1225 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1226 "Invalid offset of CFDATA in folder(%d) %jd < %jd",
1228 (intmax_t)cab->entry_cffolder->cfdata_offset_in_cab,
1229 (intmax_t)cab->cab_offset);
1230 return (ARCHIVE_FATAL);
1233 if (__archive_read_consume(a, skip) < 0)
1234 return (ARCHIVE_FATAL);
1236 cab->entry_cffolder->cfdata_offset_in_cab;
1243 if (cab->entry_cffolder->cfdata_index <
1244 cab->entry_cffolder->cfdata_count) {
1245 const unsigned char *p;
1248 cfdata = &(cab->entry_cffolder->cfdata);
1249 cab->entry_cffolder->cfdata_index++;
1250 cab->entry_cfdata = cfdata;
1251 cfdata->sum_calculated = 0;
1252 cfdata->sum_extra_avail = 0;
1253 cfdata->sum_ptr = NULL;
1255 if (cab->cfheader.flags & RESERVE_PRESENT)
1256 l += cab->cfheader.cfdata;
1257 if ((p = __archive_read_ahead(a, l, NULL)) == NULL)
1258 return (truncated_error(a));
1259 cfdata->sum = archive_le32dec(p + CFDATA_csum);
1260 cfdata->compressed_size = archive_le16dec(p + CFDATA_cbData);
1261 cfdata->compressed_bytes_remaining = cfdata->compressed_size;
1262 cfdata->uncompressed_size =
1263 archive_le16dec(p + CFDATA_cbUncomp);
1264 cfdata->uncompressed_bytes_remaining =
1265 cfdata->uncompressed_size;
1266 cfdata->uncompressed_avail = 0;
1267 cfdata->read_offset = 0;
1268 cfdata->unconsumed = 0;
1271 * Sanity check if data size is acceptable.
1273 if (cfdata->compressed_size == 0 ||
1274 cfdata->compressed_size > (0x8000+6144))
1276 if (cfdata->uncompressed_size > 0x8000)
1278 if (cfdata->uncompressed_size == 0) {
1279 switch (cab->entry_cffile->folder) {
1280 case iFoldCONTINUED_PREV_AND_NEXT:
1281 case iFoldCONTINUED_TO_NEXT:
1283 case iFoldCONTINUED_FROM_PREV:
1288 /* If CFDATA is not last in a folder, an uncompressed
1289 * size must be 0x8000(32KBi) */
1290 if ((cab->entry_cffolder->cfdata_index <
1291 cab->entry_cffolder->cfdata_count) &&
1292 cfdata->uncompressed_size != 0x8000)
1295 /* A compressed data size and an uncompressed data size must
1296 * be the same in no compression mode. */
1297 if (cab->entry_cffolder->comptype == COMPTYPE_NONE &&
1298 cfdata->compressed_size != cfdata->uncompressed_size)
1302 * Save CFDATA image for sum check.
1304 if (cfdata->memimage_size < (size_t)l) {
1305 free(cfdata->memimage);
1306 cfdata->memimage = malloc(l);
1307 if (cfdata->memimage == NULL) {
1308 archive_set_error(&a->archive, ENOMEM,
1309 "Can't allocate memory for CAB data");
1310 return (ARCHIVE_FATAL);
1312 cfdata->memimage_size = l;
1314 memcpy(cfdata->memimage, p, l);
1316 /* Consume bytes as much as we used. */
1317 __archive_read_consume(a, l);
1318 cab->cab_offset += l;
1319 } else if (cab->entry_cffolder->cfdata_count > 0) {
1320 /* Run out of all CFDATA in a folder. */
1321 cfdata->compressed_size = 0;
1322 cfdata->uncompressed_size = 0;
1323 cfdata->compressed_bytes_remaining = 0;
1324 cfdata->uncompressed_bytes_remaining = 0;
1326 /* Current folder does not have any CFDATA. */
1327 cfdata = &(cab->entry_cffolder->cfdata);
1328 cab->entry_cfdata = cfdata;
1329 memset(cfdata, 0, sizeof(*cfdata));
1331 return (ARCHIVE_OK);
1333 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1335 return (ARCHIVE_FATAL);
1339 * Read ahead CFDATA.
1342 cab_read_ahead_cfdata(struct archive_read *a, ssize_t *avail)
1344 struct cab *cab = (struct cab *)(a->format->data);
1347 err = cab_next_cfdata(a);
1348 if (err < ARCHIVE_OK) {
1353 switch (cab->entry_cffolder->comptype) {
1355 return (cab_read_ahead_cfdata_none(a, avail));
1356 case COMPTYPE_MSZIP:
1357 return (cab_read_ahead_cfdata_deflate(a, avail));
1359 return (cab_read_ahead_cfdata_lzx(a, avail));
1360 default: /* Unsupported compression. */
1361 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1362 "Unsupported CAB compression : %s",
1363 cab->entry_cffolder->compname);
1364 *avail = ARCHIVE_FAILED;
1370 * Read ahead CFDATA as uncompressed data.
1373 cab_read_ahead_cfdata_none(struct archive_read *a, ssize_t *avail)
1375 struct cab *cab = (struct cab *)(a->format->data);
1376 struct cfdata *cfdata;
1379 cfdata = cab->entry_cfdata;
1382 * Note: '1' here is a performance optimization.
1383 * Recall that the decompression layer returns a count of
1384 * available bytes; asking for more than that forces the
1385 * decompressor to combine reads by copying data.
1387 d = __archive_read_ahead(a, 1, avail);
1389 *avail = truncated_error(a);
1392 if (*avail > cfdata->uncompressed_bytes_remaining)
1393 *avail = cfdata->uncompressed_bytes_remaining;
1394 cfdata->uncompressed_avail = cfdata->uncompressed_size;
1395 cfdata->unconsumed = *avail;
1396 cfdata->sum_ptr = d;
1401 * Read ahead CFDATA as deflate data.
1405 cab_read_ahead_cfdata_deflate(struct archive_read *a, ssize_t *avail)
1407 struct cab *cab = (struct cab *)(a->format->data);
1408 struct cfdata *cfdata;
1414 cfdata = cab->entry_cfdata;
1415 /* If the buffer hasn't been allocated, allocate it now. */
1416 if (cab->uncompressed_buffer == NULL) {
1417 cab->uncompressed_buffer_size = 0x8000;
1418 cab->uncompressed_buffer
1419 = (unsigned char *)malloc(cab->uncompressed_buffer_size);
1420 if (cab->uncompressed_buffer == NULL) {
1421 archive_set_error(&a->archive, ENOMEM,
1422 "No memory for CAB reader");
1423 *avail = ARCHIVE_FATAL;
1428 uavail = cfdata->uncompressed_avail;
1429 if (uavail == cfdata->uncompressed_size) {
1430 d = cab->uncompressed_buffer + cfdata->read_offset;
1431 *avail = uavail - cfdata->read_offset;
1435 if (!cab->entry_cffolder->decompress_init) {
1436 cab->stream.next_in = NULL;
1437 cab->stream.avail_in = 0;
1438 cab->stream.total_in = 0;
1439 cab->stream.next_out = NULL;
1440 cab->stream.avail_out = 0;
1441 cab->stream.total_out = 0;
1442 if (cab->stream_valid)
1443 r = inflateReset(&cab->stream);
1445 r = inflateInit2(&cab->stream,
1446 -15 /* Don't check for zlib header */);
1448 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1449 "Can't initialize deflate decompression.");
1450 *avail = ARCHIVE_FATAL;
1453 /* Stream structure has been set up. */
1454 cab->stream_valid = 1;
1455 /* We've initialized decompression for this stream. */
1456 cab->entry_cffolder->decompress_init = 1;
1459 if (cfdata->compressed_bytes_remaining == cfdata->compressed_size)
1464 cab->stream.total_out = uavail;
1466 * We always uncompress all data in current CFDATA.
1468 while (!eod && cab->stream.total_out < cfdata->uncompressed_size) {
1469 ssize_t bytes_avail;
1471 cab->stream.next_out =
1472 cab->uncompressed_buffer + cab->stream.total_out;
1473 cab->stream.avail_out =
1474 cfdata->uncompressed_size - cab->stream.total_out;
1476 d = __archive_read_ahead(a, 1, &bytes_avail);
1477 if (bytes_avail <= 0) {
1478 *avail = truncated_error(a);
1481 if (bytes_avail > cfdata->compressed_bytes_remaining)
1482 bytes_avail = cfdata->compressed_bytes_remaining;
1484 * A bug in zlib.h: stream.next_in should be marked 'const'
1485 * but isn't (the library never alters data through the
1486 * next_in pointer, only reads it). The result: this ugly
1487 * cast to remove 'const'.
1489 cab->stream.next_in = (Bytef *)(uintptr_t)d;
1490 cab->stream.avail_in = (uInt)bytes_avail;
1491 cab->stream.total_in = 0;
1493 /* Cut out a tow-byte MSZIP signature(0x43, 0x4b). */
1495 if (bytes_avail <= mszip) {
1497 if (cab->stream.next_in[0] != 0x43)
1499 if (bytes_avail > 1 &&
1500 cab->stream.next_in[1] != 0x4b)
1502 } else if (cab->stream.next_in[0] != 0x4b)
1504 cfdata->unconsumed = bytes_avail;
1505 cfdata->sum_ptr = d;
1506 if (cab_minimum_consume_cfdata(
1507 a, cfdata->unconsumed) < 0) {
1508 *avail = ARCHIVE_FATAL;
1511 mszip -= (int)bytes_avail;
1514 if (mszip == 1 && cab->stream.next_in[0] != 0x4b)
1516 else if (cab->stream.next_in[0] != 0x43 ||
1517 cab->stream.next_in[1] != 0x4b)
1519 cab->stream.next_in += mszip;
1520 cab->stream.avail_in -= mszip;
1521 cab->stream.total_in += mszip;
1525 r = inflate(&cab->stream, 0);
1535 cfdata->unconsumed = cab->stream.total_in;
1536 cfdata->sum_ptr = d;
1537 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1538 *avail = ARCHIVE_FATAL;
1542 uavail = (uint16_t)cab->stream.total_out;
1544 if (uavail < cfdata->uncompressed_size) {
1545 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1546 "Invalid uncompressed size (%d < %d)",
1547 uavail, cfdata->uncompressed_size);
1548 *avail = ARCHIVE_FATAL;
1553 * Note: I suspect there is a bug in makecab.exe because, in rare
1554 * case, compressed bytes are still remaining regardless we have
1555 * gotten all uncompressed bytes, which size is recoded in CFDATA,
1556 * as much as we need, and we have to use the garbage so as to
1557 * correctly compute the sum of CFDATA accordingly.
1559 if (cfdata->compressed_bytes_remaining > 0) {
1560 ssize_t bytes_avail;
1562 d = __archive_read_ahead(a, cfdata->compressed_bytes_remaining,
1564 if (bytes_avail <= 0) {
1565 *avail = truncated_error(a);
1568 cfdata->unconsumed = cfdata->compressed_bytes_remaining;
1569 cfdata->sum_ptr = d;
1570 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1571 *avail = ARCHIVE_FATAL;
1577 * Set dictionary data for decompressing of next CFDATA, which
1578 * in the same folder. This is why we always do decompress CFDATA
1579 * even if beginning CFDATA or some of CFDATA are not used in
1580 * skipping file data.
1582 if (cab->entry_cffolder->cfdata_index <
1583 cab->entry_cffolder->cfdata_count) {
1584 r = inflateReset(&cab->stream);
1587 r = inflateSetDictionary(&cab->stream,
1588 cab->uncompressed_buffer, cfdata->uncompressed_size);
1593 d = cab->uncompressed_buffer + cfdata->read_offset;
1594 *avail = uavail - cfdata->read_offset;
1595 cfdata->uncompressed_avail = uavail;
1602 archive_set_error(&a->archive, ENOMEM,
1603 "Out of memory for deflate decompression");
1606 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1607 "Deflate decompression failed (%d)", r);
1610 *avail = ARCHIVE_FATAL;
1613 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1614 "CFDATA incorrect(no MSZIP signature)");
1615 *avail = ARCHIVE_FATAL;
1619 #else /* HAVE_ZLIB_H */
1622 cab_read_ahead_cfdata_deflate(struct archive_read *a, ssize_t *avail)
1624 *avail = ARCHIVE_FATAL;
1625 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1626 "libarchive compiled without deflate support (no libz)");
1630 #endif /* HAVE_ZLIB_H */
1633 cab_read_ahead_cfdata_lzx(struct archive_read *a, ssize_t *avail)
1635 struct cab *cab = (struct cab *)(a->format->data);
1636 struct cfdata *cfdata;
1641 cfdata = cab->entry_cfdata;
1642 /* If the buffer hasn't been allocated, allocate it now. */
1643 if (cab->uncompressed_buffer == NULL) {
1644 cab->uncompressed_buffer_size = 0x8000;
1645 cab->uncompressed_buffer
1646 = (unsigned char *)malloc(cab->uncompressed_buffer_size);
1647 if (cab->uncompressed_buffer == NULL) {
1648 archive_set_error(&a->archive, ENOMEM,
1649 "No memory for CAB reader");
1650 *avail = ARCHIVE_FATAL;
1655 uavail = cfdata->uncompressed_avail;
1656 if (uavail == cfdata->uncompressed_size) {
1657 d = cab->uncompressed_buffer + cfdata->read_offset;
1658 *avail = uavail - cfdata->read_offset;
1662 if (!cab->entry_cffolder->decompress_init) {
1663 r = lzx_decode_init(&cab->xstrm,
1664 cab->entry_cffolder->compdata);
1665 if (r != ARCHIVE_OK) {
1666 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1667 "Can't initialize LZX decompression.");
1668 *avail = ARCHIVE_FATAL;
1671 /* We've initialized decompression for this stream. */
1672 cab->entry_cffolder->decompress_init = 1;
1675 /* Clean up remaining bits of previous CFDATA. */
1676 lzx_cleanup_bitstream(&cab->xstrm);
1677 cab->xstrm.total_out = uavail;
1678 while (cab->xstrm.total_out < cfdata->uncompressed_size) {
1679 ssize_t bytes_avail;
1681 cab->xstrm.next_out =
1682 cab->uncompressed_buffer + cab->xstrm.total_out;
1683 cab->xstrm.avail_out =
1684 cfdata->uncompressed_size - cab->xstrm.total_out;
1686 d = __archive_read_ahead(a, 1, &bytes_avail);
1687 if (bytes_avail <= 0) {
1688 archive_set_error(&a->archive,
1689 ARCHIVE_ERRNO_FILE_FORMAT,
1690 "Truncated CAB file data");
1691 *avail = ARCHIVE_FATAL;
1694 if (bytes_avail > cfdata->compressed_bytes_remaining)
1695 bytes_avail = cfdata->compressed_bytes_remaining;
1697 cab->xstrm.next_in = d;
1698 cab->xstrm.avail_in = bytes_avail;
1699 cab->xstrm.total_in = 0;
1700 r = lzx_decode(&cab->xstrm,
1701 cfdata->compressed_bytes_remaining == bytes_avail);
1707 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1708 "LZX decompression failed (%d)", r);
1709 *avail = ARCHIVE_FATAL;
1712 cfdata->unconsumed = cab->xstrm.total_in;
1713 cfdata->sum_ptr = d;
1714 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1715 *avail = ARCHIVE_FATAL;
1720 uavail = (uint16_t)cab->xstrm.total_out;
1722 * Make sure a read pointer advances to next CFDATA.
1724 if (cfdata->compressed_bytes_remaining > 0) {
1725 ssize_t bytes_avail;
1727 d = __archive_read_ahead(a, cfdata->compressed_bytes_remaining,
1729 if (bytes_avail <= 0) {
1730 *avail = truncated_error(a);
1733 cfdata->unconsumed = cfdata->compressed_bytes_remaining;
1734 cfdata->sum_ptr = d;
1735 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1736 *avail = ARCHIVE_FATAL;
1742 * Translation reversal of x86 proccessor CALL byte sequence(E8).
1744 lzx_translation(&cab->xstrm, cab->uncompressed_buffer,
1745 cfdata->uncompressed_size,
1746 (cab->entry_cffolder->cfdata_index-1) * 0x8000);
1748 d = cab->uncompressed_buffer + cfdata->read_offset;
1749 *avail = uavail - cfdata->read_offset;
1750 cfdata->uncompressed_avail = uavail;
1757 * We always decompress CFDATA to consume CFDATA as much as we need
1758 * in uncompressed bytes because all CFDATA in a folder are related
1759 * so we do not skip any CFDATA without decompressing.
1760 * Note: If the folder of a CFFILE is iFoldCONTINUED_PREV_AND_NEXT or
1761 * iFoldCONTINUED_FROM_PREV, we won't decompress because a CFDATA for
1762 * the CFFILE is remaining bytes of previous Multivolume CAB file.
1765 cab_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
1767 struct cab *cab = (struct cab *)(a->format->data);
1768 struct cfdata *cfdata;
1769 int64_t cbytes, rbytes;
1772 rbytes = cab_minimum_consume_cfdata(a, consumed_bytes);
1774 return (ARCHIVE_FATAL);
1776 cfdata = cab->entry_cfdata;
1777 while (rbytes > 0) {
1780 if (cfdata->compressed_size == 0) {
1781 archive_set_error(&a->archive,
1782 ARCHIVE_ERRNO_FILE_FORMAT,
1784 return (ARCHIVE_FATAL);
1786 cbytes = cfdata->uncompressed_bytes_remaining;
1787 if (cbytes > rbytes)
1791 if (cfdata->uncompressed_avail == 0 &&
1792 (cab->entry_cffile->folder == iFoldCONTINUED_PREV_AND_NEXT ||
1793 cab->entry_cffile->folder == iFoldCONTINUED_FROM_PREV)) {
1794 /* We have not read any data yet. */
1795 if (cbytes == cfdata->uncompressed_bytes_remaining) {
1796 /* Skip whole current CFDATA. */
1797 __archive_read_consume(a,
1798 cfdata->compressed_size);
1799 cab->cab_offset += cfdata->compressed_size;
1800 cfdata->compressed_bytes_remaining = 0;
1801 cfdata->uncompressed_bytes_remaining = 0;
1802 err = cab_next_cfdata(a);
1805 cfdata = cab->entry_cfdata;
1806 if (cfdata->uncompressed_size == 0) {
1807 switch (cab->entry_cffile->folder) {
1808 case iFoldCONTINUED_PREV_AND_NEXT:
1809 case iFoldCONTINUED_TO_NEXT:
1810 case iFoldCONTINUED_FROM_PREV:
1819 cfdata->read_offset += (uint16_t)cbytes;
1820 cfdata->uncompressed_bytes_remaining -= (uint16_t)cbytes;
1822 } else if (cbytes == 0) {
1823 err = cab_next_cfdata(a);
1826 cfdata = cab->entry_cfdata;
1827 if (cfdata->uncompressed_size == 0) {
1828 switch (cab->entry_cffile->folder) {
1829 case iFoldCONTINUED_PREV_AND_NEXT:
1830 case iFoldCONTINUED_TO_NEXT:
1831 case iFoldCONTINUED_FROM_PREV:
1832 return (ARCHIVE_FATAL);
1839 while (cbytes > 0) {
1840 (void)cab_read_ahead_cfdata(a, &avail);
1842 return (ARCHIVE_FATAL);
1844 avail = (ssize_t)cbytes;
1845 if (cab_minimum_consume_cfdata(a, avail) < 0)
1846 return (ARCHIVE_FATAL);
1850 return (consumed_bytes);
1854 * Consume CFDATA as much as we have already gotten and
1855 * compute the sum of CFDATA.
1858 cab_minimum_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
1860 struct cab *cab = (struct cab *)(a->format->data);
1861 struct cfdata *cfdata;
1862 int64_t cbytes, rbytes;
1865 cfdata = cab->entry_cfdata;
1866 rbytes = consumed_bytes;
1867 if (cab->entry_cffolder->comptype == COMPTYPE_NONE) {
1868 if (consumed_bytes < cfdata->unconsumed)
1869 cbytes = consumed_bytes;
1871 cbytes = cfdata->unconsumed;
1873 cfdata->read_offset += (uint16_t)cbytes;
1874 cfdata->uncompressed_bytes_remaining -= (uint16_t)cbytes;
1875 cfdata->unconsumed -= cbytes;
1877 cbytes = cfdata->uncompressed_avail - cfdata->read_offset;
1879 if (consumed_bytes < cbytes)
1880 cbytes = consumed_bytes;
1882 cfdata->read_offset += (uint16_t)cbytes;
1883 cfdata->uncompressed_bytes_remaining -= (uint16_t)cbytes;
1886 if (cfdata->unconsumed) {
1887 cbytes = cfdata->unconsumed;
1888 cfdata->unconsumed = 0;
1893 /* Compute the sum. */
1894 cab_checksum_update(a, (size_t)cbytes);
1896 /* Consume as much as the compressor actually used. */
1897 __archive_read_consume(a, cbytes);
1898 cab->cab_offset += cbytes;
1899 cfdata->compressed_bytes_remaining -= (uint16_t)cbytes;
1900 if (cfdata->compressed_bytes_remaining == 0) {
1901 err = cab_checksum_finish(a);
1910 * Returns ARCHIVE_OK if successful, ARCHIVE_FATAL otherwise, sets
1911 * cab->end_of_entry if it consumes all of the data.
1914 cab_read_data(struct archive_read *a, const void **buff,
1915 size_t *size, int64_t *offset)
1917 struct cab *cab = (struct cab *)(a->format->data);
1918 ssize_t bytes_avail;
1920 if (cab->entry_bytes_remaining == 0) {
1923 *offset = cab->entry_offset;
1924 cab->end_of_entry = 1;
1925 return (ARCHIVE_OK);
1928 *buff = cab_read_ahead_cfdata(a, &bytes_avail);
1929 if (bytes_avail <= 0) {
1933 if (bytes_avail == 0 &&
1934 cab->entry_cfdata->uncompressed_size == 0) {
1935 /* All of CFDATA in a folder has been handled. */
1936 archive_set_error(&a->archive,
1937 ARCHIVE_ERRNO_FILE_FORMAT, "Invalid CFDATA");
1938 return (ARCHIVE_FATAL);
1940 return ((int)bytes_avail);
1942 if (bytes_avail > cab->entry_bytes_remaining)
1943 bytes_avail = (ssize_t)cab->entry_bytes_remaining;
1945 *size = bytes_avail;
1946 *offset = cab->entry_offset;
1947 cab->entry_offset += bytes_avail;
1948 cab->entry_bytes_remaining -= bytes_avail;
1949 if (cab->entry_bytes_remaining == 0)
1950 cab->end_of_entry = 1;
1951 cab->entry_unconsumed = bytes_avail;
1952 if (cab->entry_cffolder->comptype == COMPTYPE_NONE) {
1953 /* Don't consume more than current entry used. */
1954 if (cab->entry_cfdata->unconsumed > cab->entry_unconsumed)
1955 cab->entry_cfdata->unconsumed = cab->entry_unconsumed;
1957 return (ARCHIVE_OK);
1961 archive_read_format_cab_read_data_skip(struct archive_read *a)
1964 int64_t bytes_skipped;
1967 cab = (struct cab *)(a->format->data);
1969 if (cab->end_of_archive)
1970 return (ARCHIVE_EOF);
1972 if (!cab->read_data_invoked) {
1973 cab->bytes_skipped += cab->entry_bytes_remaining;
1974 cab->entry_bytes_remaining = 0;
1975 /* This entry is finished and done. */
1976 cab->end_of_entry_cleanup = cab->end_of_entry = 1;
1977 return (ARCHIVE_OK);
1980 if (cab->entry_unconsumed) {
1981 /* Consume as much as the compressor actually used. */
1982 r = (int)cab_consume_cfdata(a, cab->entry_unconsumed);
1983 cab->entry_unconsumed = 0;
1986 } else if (cab->entry_cfdata == NULL) {
1987 r = cab_next_cfdata(a);
1992 /* if we've already read to end of data, we're done. */
1993 if (cab->end_of_entry_cleanup)
1994 return (ARCHIVE_OK);
1997 * If the length is at the beginning, we can skip the
1998 * compressed data much more quickly.
2000 bytes_skipped = cab_consume_cfdata(a, cab->entry_bytes_remaining);
2001 if (bytes_skipped < 0)
2002 return (ARCHIVE_FATAL);
2004 /* If the compression type is none(uncompressed), we've already
2005 * consumed data as much as the current entry size. */
2006 if (cab->entry_cffolder->comptype == COMPTYPE_NONE &&
2007 cab->entry_cfdata != NULL)
2008 cab->entry_cfdata->unconsumed = 0;
2010 /* This entry is finished and done. */
2011 cab->end_of_entry_cleanup = cab->end_of_entry = 1;
2012 return (ARCHIVE_OK);
2016 archive_read_format_cab_cleanup(struct archive_read *a)
2018 struct cab *cab = (struct cab *)(a->format->data);
2019 struct cfheader *hd = &cab->cfheader;
2022 if (hd->folder_array != NULL) {
2023 for (i = 0; i < hd->folder_count; i++)
2024 free(hd->folder_array[i].cfdata.memimage);
2025 free(hd->folder_array);
2027 if (hd->file_array != NULL) {
2028 for (i = 0; i < cab->cfheader.file_count; i++)
2029 archive_string_free(&(hd->file_array[i].pathname));
2030 free(hd->file_array);
2033 if (cab->stream_valid)
2034 inflateEnd(&cab->stream);
2036 lzx_decode_free(&cab->xstrm);
2037 archive_wstring_free(&cab->ws);
2038 free(cab->uncompressed_buffer);
2040 (a->format->data) = NULL;
2041 return (ARCHIVE_OK);
2044 /* Convert an MSDOS-style date/time into Unix-style time. */
2046 cab_dos_time(const unsigned char *p)
2051 msDate = archive_le16dec(p);
2052 msTime = archive_le16dec(p+2);
2054 memset(&ts, 0, sizeof(ts));
2055 ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
2056 ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
2057 ts.tm_mday = msDate & 0x1f; /* Day of month. */
2058 ts.tm_hour = (msTime >> 11) & 0x1f;
2059 ts.tm_min = (msTime >> 5) & 0x3f;
2060 ts.tm_sec = (msTime << 1) & 0x3e;
2062 return (mktime(&ts));
2065 /*****************************************************************
2067 * LZX decompression code.
2069 *****************************************************************/
2072 * Initialize LZX decoder.
2074 * Returns ARCHIVE_OK if initialization was successful.
2075 * Returns ARCHIVE_FAILED if w_bits has unsupported value.
2076 * Returns ARCHIVE_FATAL if initialization failed; memory allocation
2080 lzx_decode_init(struct lzx_stream *strm, int w_bits)
2083 int slot, w_size, w_slot;
2087 if (strm->ds == NULL) {
2088 strm->ds = calloc(1, sizeof(*strm->ds));
2089 if (strm->ds == NULL)
2090 return (ARCHIVE_FATAL);
2093 ds->error = ARCHIVE_FAILED;
2095 /* Allow bits from 15(32KBi) up to 21(2MBi) */
2096 if (w_bits < SLOT_BASE || w_bits > SLOT_MAX)
2097 return (ARCHIVE_FAILED);
2099 ds->error = ARCHIVE_FATAL;
2104 w_size = ds->w_size;
2105 w_slot = slots[w_bits - SLOT_BASE];
2106 ds->w_size = 1U << w_bits;
2107 ds->w_mask = ds->w_size -1;
2108 if (ds->w_buff == NULL || w_size != ds->w_size) {
2110 ds->w_buff = malloc(ds->w_size);
2111 if (ds->w_buff == NULL)
2112 return (ARCHIVE_FATAL);
2114 ds->pos_tbl = malloc(sizeof(ds->pos_tbl[0]) * w_slot);
2115 if (ds->pos_tbl == NULL)
2116 return (ARCHIVE_FATAL);
2117 lzx_huffman_free(&(ds->mt));
2120 for (footer = 0; footer < 18; footer++)
2121 base_inc[footer] = 1 << footer;
2123 for (slot = 0; slot < w_slot; slot++) {
2128 base += base_inc[footer];
2131 for (n = base; n; n >>= 1)
2136 ds->pos_tbl[slot].base = base;
2137 ds->pos_tbl[slot].footer_bits = footer;
2142 ds->br.cache_buffer = 0;
2143 ds->br.cache_avail = 0;
2144 ds->r0 = ds->r1 = ds->r2 = 1;
2146 /* Initialize aligned offset tree. */
2147 if (lzx_huffman_init(&(ds->at), 8, 8) != ARCHIVE_OK)
2148 return (ARCHIVE_FATAL);
2150 /* Initialize pre-tree. */
2151 if (lzx_huffman_init(&(ds->pt), 20, 10) != ARCHIVE_OK)
2152 return (ARCHIVE_FATAL);
2154 /* Initialize Main tree. */
2155 if (lzx_huffman_init(&(ds->mt), 256+(w_slot<<3), 16)
2157 return (ARCHIVE_FATAL);
2159 /* Initialize Length tree. */
2160 if (lzx_huffman_init(&(ds->lt), 249, 16) != ARCHIVE_OK)
2161 return (ARCHIVE_FATAL);
2165 return (ARCHIVE_OK);
2169 * Release LZX decoder.
2172 lzx_decode_free(struct lzx_stream *strm)
2175 if (strm->ds == NULL)
2177 free(strm->ds->w_buff);
2178 free(strm->ds->pos_tbl);
2179 lzx_huffman_free(&(strm->ds->at));
2180 lzx_huffman_free(&(strm->ds->pt));
2181 lzx_huffman_free(&(strm->ds->mt));
2182 lzx_huffman_free(&(strm->ds->lt));
2188 * E8 Call Translation reversal.
2191 lzx_translation(struct lzx_stream *strm, void *p, size_t size, uint32_t offset)
2193 struct lzx_dec *ds = strm->ds;
2194 unsigned char *b, *end;
2196 if (!ds->translation || size <= 10)
2199 end = b + size - 10;
2200 while (b < end && (b = memchr(b, 0xE8, end - b)) != NULL) {
2201 size_t i = b - (unsigned char *)p;
2202 int32_t cp, displacement, value;
2204 cp = (int32_t)(offset + (uint32_t)i);
2205 value = archive_le32dec(&b[1]);
2206 if (value >= -cp && value < (int32_t)ds->translation_size) {
2208 displacement = value - cp;
2210 displacement = value + ds->translation_size;
2211 archive_le32enc(&b[1], (uint32_t)displacement);
2218 * Bit stream reader.
2220 /* Check that the cache buffer has enough bits. */
2221 #define lzx_br_has(br, n) ((br)->cache_avail >= n)
2222 /* Get compressed data by bit. */
2223 #define lzx_br_bits(br, n) \
2224 (((uint32_t)((br)->cache_buffer >> \
2225 ((br)->cache_avail - (n)))) & cache_masks[n])
2226 #define lzx_br_bits_forced(br, n) \
2227 (((uint32_t)((br)->cache_buffer << \
2228 ((n) - (br)->cache_avail))) & cache_masks[n])
2229 /* Read ahead to make sure the cache buffer has enough compressed data we
2231 * True : completed, there is enough data in the cache buffer.
2232 * False : we met that strm->next_in is empty, we have to get following
2234 #define lzx_br_read_ahead_0(strm, br, n) \
2235 (lzx_br_has((br), (n)) || lzx_br_fillup(strm, br))
2236 /* True : the cache buffer has some bits as much as we need.
2237 * False : there are no enough bits in the cache buffer to be used,
2238 * we have to get following bytes if we could. */
2239 #define lzx_br_read_ahead(strm, br, n) \
2240 (lzx_br_read_ahead_0((strm), (br), (n)) || lzx_br_has((br), (n)))
2242 /* Notify how many bits we consumed. */
2243 #define lzx_br_consume(br, n) ((br)->cache_avail -= (n))
2244 #define lzx_br_consume_unaligned_bits(br) ((br)->cache_avail &= ~0x0f)
2246 #define lzx_br_is_unaligned(br) ((br)->cache_avail & 0x0f)
2248 static const uint32_t cache_masks[] = {
2249 0x00000000, 0x00000001, 0x00000003, 0x00000007,
2250 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
2251 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
2252 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
2253 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
2254 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
2255 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
2256 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
2257 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
2261 * Shift away used bits in the cache data and fill it up with following bits.
2262 * Call this when cache buffer does not have enough bits you need.
2264 * Returns 1 if the cache buffer is full.
2265 * Returns 0 if the cache buffer is not full; input buffer is empty.
2268 lzx_br_fillup(struct lzx_stream *strm, struct lzx_br *br)
2271 * x86 proccessor family can read misaligned data without an access error.
2273 int n = CACHE_BITS - br->cache_avail;
2278 if (strm->avail_in >= 8) {
2280 ((uint64_t)strm->next_in[1]) << 56 |
2281 ((uint64_t)strm->next_in[0]) << 48 |
2282 ((uint64_t)strm->next_in[3]) << 40 |
2283 ((uint64_t)strm->next_in[2]) << 32 |
2284 ((uint32_t)strm->next_in[5]) << 24 |
2285 ((uint32_t)strm->next_in[4]) << 16 |
2286 ((uint32_t)strm->next_in[7]) << 8 |
2287 (uint32_t)strm->next_in[6];
2289 strm->avail_in -= 8;
2290 br->cache_avail += 8 * 8;
2295 if (strm->avail_in >= 6) {
2297 (br->cache_buffer << 48) |
2298 ((uint64_t)strm->next_in[1]) << 40 |
2299 ((uint64_t)strm->next_in[0]) << 32 |
2300 ((uint32_t)strm->next_in[3]) << 24 |
2301 ((uint32_t)strm->next_in[2]) << 16 |
2302 ((uint32_t)strm->next_in[5]) << 8 |
2303 (uint32_t)strm->next_in[4];
2305 strm->avail_in -= 6;
2306 br->cache_avail += 6 * 8;
2311 /* We have enough compressed data in
2312 * the cache buffer.*/
2317 if (strm->avail_in < 2) {
2318 /* There is not enough compressed data to
2319 * fill up the cache buffer. */
2320 if (strm->avail_in == 1) {
2321 br->odd = *strm->next_in++;
2328 (br->cache_buffer << 16) |
2329 archive_le16dec(strm->next_in);
2331 strm->avail_in -= 2;
2332 br->cache_avail += 16;
2338 lzx_br_fixup(struct lzx_stream *strm, struct lzx_br *br)
2340 int n = CACHE_BITS - br->cache_avail;
2342 if (br->have_odd && n >= 16 && strm->avail_in > 0) {
2344 (br->cache_buffer << 16) |
2345 ((uint16_t)(*strm->next_in)) << 8 | br->odd;
2348 br->cache_avail += 16;
2354 lzx_cleanup_bitstream(struct lzx_stream *strm)
2356 strm->ds->br.cache_avail = 0;
2357 strm->ds->br.have_odd = 0;
2363 * 1. Returns ARCHIVE_OK if output buffer or input buffer are empty.
2364 * Please set available buffer and call this function again.
2365 * 2. Returns ARCHIVE_EOF if decompression has been completed.
2366 * 3. Returns ARCHIVE_FAILED if an error occurred; compressed data
2367 * is broken or you do not set 'last' flag properly.
2369 #define ST_RD_TRANSLATION 0
2370 #define ST_RD_TRANSLATION_SIZE 1
2371 #define ST_RD_BLOCK_TYPE 2
2372 #define ST_RD_BLOCK_SIZE 3
2373 #define ST_RD_ALIGNMENT 4
2377 #define ST_COPY_UNCOMP1 8
2378 #define ST_COPY_UNCOMP2 9
2379 #define ST_RD_ALIGNED_OFFSET 10
2380 #define ST_RD_VERBATIM 11
2381 #define ST_RD_PRE_MAIN_TREE_256 12
2382 #define ST_MAIN_TREE_256 13
2383 #define ST_RD_PRE_MAIN_TREE_REM 14
2384 #define ST_MAIN_TREE_REM 15
2385 #define ST_RD_PRE_LENGTH_TREE 16
2386 #define ST_LENGTH_TREE 17
2388 #define ST_LENGTH 19
2389 #define ST_OFFSET 20
2390 #define ST_REAL_POS 21
2394 lzx_decode(struct lzx_stream *strm, int last)
2396 struct lzx_dec *ds = strm->ds;
2403 avail_in = strm->avail_in;
2404 lzx_br_fixup(strm, &(ds->br));
2406 if (ds->state < ST_MAIN)
2407 r = lzx_read_blocks(strm, last);
2409 int64_t bytes_written = strm->avail_out;
2410 r = lzx_decode_blocks(strm, last);
2411 bytes_written -= strm->avail_out;
2412 strm->next_out += bytes_written;
2413 strm->total_out += bytes_written;
2416 strm->total_in += avail_in - strm->avail_in;
2421 lzx_read_blocks(struct lzx_stream *strm, int last)
2423 struct lzx_dec *ds = strm->ds;
2424 struct lzx_br *br = &(ds->br);
2428 switch (ds->state) {
2429 case ST_RD_TRANSLATION:
2430 if (!lzx_br_read_ahead(strm, br, 1)) {
2431 ds->state = ST_RD_TRANSLATION;
2434 return (ARCHIVE_OK);
2436 ds->translation = lzx_br_bits(br, 1);
2437 lzx_br_consume(br, 1);
2439 case ST_RD_TRANSLATION_SIZE:
2440 if (ds->translation) {
2441 if (!lzx_br_read_ahead(strm, br, 32)) {
2442 ds->state = ST_RD_TRANSLATION_SIZE;
2445 return (ARCHIVE_OK);
2447 ds->translation_size = lzx_br_bits(br, 16);
2448 lzx_br_consume(br, 16);
2449 ds->translation_size <<= 16;
2450 ds->translation_size |= lzx_br_bits(br, 16);
2451 lzx_br_consume(br, 16);
2454 case ST_RD_BLOCK_TYPE:
2455 if (!lzx_br_read_ahead(strm, br, 3)) {
2456 ds->state = ST_RD_BLOCK_TYPE;
2459 return (ARCHIVE_OK);
2461 ds->block_type = lzx_br_bits(br, 3);
2462 lzx_br_consume(br, 3);
2463 /* Check a block type. */
2464 switch (ds->block_type) {
2465 case VERBATIM_BLOCK:
2466 case ALIGNED_OFFSET_BLOCK:
2467 case UNCOMPRESSED_BLOCK:
2470 goto failed;/* Invalid */
2473 case ST_RD_BLOCK_SIZE:
2474 if (!lzx_br_read_ahead(strm, br, 24)) {
2475 ds->state = ST_RD_BLOCK_SIZE;
2478 return (ARCHIVE_OK);
2480 ds->block_size = lzx_br_bits(br, 8);
2481 lzx_br_consume(br, 8);
2482 ds->block_size <<= 16;
2483 ds->block_size |= lzx_br_bits(br, 16);
2484 lzx_br_consume(br, 16);
2485 if (ds->block_size == 0)
2487 ds->block_bytes_avail = ds->block_size;
2488 if (ds->block_type != UNCOMPRESSED_BLOCK) {
2489 if (ds->block_type == VERBATIM_BLOCK)
2490 ds->state = ST_RD_VERBATIM;
2492 ds->state = ST_RD_ALIGNED_OFFSET;
2496 case ST_RD_ALIGNMENT:
2498 * Handle an Uncompressed Block.
2500 /* Skip padding to align following field on
2501 * 16-bit boundary. */
2502 if (lzx_br_is_unaligned(br))
2503 lzx_br_consume_unaligned_bits(br);
2505 if (lzx_br_read_ahead(strm, br, 16))
2506 lzx_br_consume(br, 16);
2508 ds->state = ST_RD_ALIGNMENT;
2511 return (ARCHIVE_OK);
2514 /* Preparation to read repeated offsets R0,R1 and R2. */
2515 ds->rbytes_avail = 0;
2516 ds->state = ST_RD_R0;
2523 /* Drain bits in the cache buffer of
2525 if (lzx_br_has(br, 32)) {
2526 u16 = lzx_br_bits(br, 16);
2527 lzx_br_consume(br, 16);
2528 archive_le16enc(ds->rbytes, u16);
2529 u16 = lzx_br_bits(br, 16);
2530 lzx_br_consume(br, 16);
2531 archive_le16enc(ds->rbytes+2, u16);
2532 ds->rbytes_avail = 4;
2533 } else if (lzx_br_has(br, 16)) {
2534 u16 = lzx_br_bits(br, 16);
2535 lzx_br_consume(br, 16);
2536 archive_le16enc(ds->rbytes, u16);
2537 ds->rbytes_avail = 2;
2539 if (ds->rbytes_avail < 4 && ds->br.have_odd) {
2540 ds->rbytes[ds->rbytes_avail++] =
2542 ds->br.have_odd = 0;
2544 while (ds->rbytes_avail < 4) {
2545 if (strm->avail_in <= 0) {
2548 return (ARCHIVE_OK);
2550 ds->rbytes[ds->rbytes_avail++] =
2554 ds->rbytes_avail = 0;
2555 if (ds->state == ST_RD_R0) {
2556 ds->r0 = archive_le32dec(ds->rbytes);
2559 ds->state = ST_RD_R1;
2560 } else if (ds->state == ST_RD_R1) {
2561 ds->r1 = archive_le32dec(ds->rbytes);
2564 ds->state = ST_RD_R2;
2565 } else if (ds->state == ST_RD_R2) {
2566 ds->r2 = archive_le32dec(ds->rbytes);
2569 /* We've gotten all repeated offsets. */
2570 ds->state = ST_COPY_UNCOMP1;
2572 } while (ds->state != ST_COPY_UNCOMP1);
2574 case ST_COPY_UNCOMP1:
2576 * Copy bytes form next_in to next_out directly.
2578 while (ds->block_bytes_avail) {
2581 if (strm->avail_out <= 0)
2582 /* Output buffer is empty. */
2583 return (ARCHIVE_OK);
2584 if (strm->avail_in <= 0) {
2585 /* Input buffer is empty. */
2588 return (ARCHIVE_OK);
2590 l = (int)ds->block_bytes_avail;
2591 if (l > ds->w_size - ds->w_pos)
2592 l = ds->w_size - ds->w_pos;
2593 if (l > strm->avail_out)
2594 l = (int)strm->avail_out;
2595 if (l > strm->avail_in)
2596 l = (int)strm->avail_in;
2597 memcpy(strm->next_out, strm->next_in, l);
2598 memcpy(&(ds->w_buff[ds->w_pos]),
2601 strm->avail_in -= l;
2602 strm->next_out += l;
2603 strm->avail_out -= l;
2604 strm->total_out += l;
2605 ds->w_pos = (ds->w_pos + l) & ds->w_mask;
2606 ds->block_bytes_avail -= l;
2609 case ST_COPY_UNCOMP2:
2610 /* Re-align; skip padding byte. */
2611 if (ds->block_size & 1) {
2612 if (strm->avail_in <= 0) {
2613 /* Input buffer is empty. */
2614 ds->state = ST_COPY_UNCOMP2;
2617 return (ARCHIVE_OK);
2622 /* This block ended. */
2623 ds->state = ST_RD_BLOCK_TYPE;
2624 return (ARCHIVE_EOF);
2625 /********************/
2626 case ST_RD_ALIGNED_OFFSET:
2628 * Read Aligned offset tree.
2630 if (!lzx_br_read_ahead(strm, br, 3 * ds->at.len_size)) {
2631 ds->state = ST_RD_ALIGNED_OFFSET;
2634 return (ARCHIVE_OK);
2636 memset(ds->at.freq, 0, sizeof(ds->at.freq));
2637 for (i = 0; i < ds->at.len_size; i++) {
2638 ds->at.bitlen[i] = lzx_br_bits(br, 3);
2639 ds->at.freq[ds->at.bitlen[i]]++;
2640 lzx_br_consume(br, 3);
2642 if (!lzx_make_huffman_table(&ds->at))
2645 case ST_RD_VERBATIM:
2648 case ST_RD_PRE_MAIN_TREE_256:
2650 * Read Pre-tree for first 256 elements of main tree.
2652 if (!lzx_read_pre_tree(strm)) {
2653 ds->state = ST_RD_PRE_MAIN_TREE_256;
2656 return (ARCHIVE_OK);
2658 if (!lzx_make_huffman_table(&ds->pt))
2662 case ST_MAIN_TREE_256:
2664 * Get path lengths of first 256 elements of main tree.
2666 r = lzx_read_bitlen(strm, &ds->mt, 256);
2670 ds->state = ST_MAIN_TREE_256;
2673 return (ARCHIVE_OK);
2677 case ST_RD_PRE_MAIN_TREE_REM:
2679 * Read Pre-tree for remaining elements of main tree.
2681 if (!lzx_read_pre_tree(strm)) {
2682 ds->state = ST_RD_PRE_MAIN_TREE_REM;
2685 return (ARCHIVE_OK);
2687 if (!lzx_make_huffman_table(&ds->pt))
2691 case ST_MAIN_TREE_REM:
2693 * Get path lengths of remaining elements of main tree.
2695 r = lzx_read_bitlen(strm, &ds->mt, -1);
2699 ds->state = ST_MAIN_TREE_REM;
2702 return (ARCHIVE_OK);
2704 if (!lzx_make_huffman_table(&ds->mt))
2708 case ST_RD_PRE_LENGTH_TREE:
2710 * Read Pre-tree for remaining elements of main tree.
2712 if (!lzx_read_pre_tree(strm)) {
2713 ds->state = ST_RD_PRE_LENGTH_TREE;
2716 return (ARCHIVE_OK);
2718 if (!lzx_make_huffman_table(&ds->pt))
2722 case ST_LENGTH_TREE:
2724 * Get path lengths of remaining elements of main tree.
2726 r = lzx_read_bitlen(strm, &ds->lt, -1);
2730 ds->state = ST_LENGTH_TREE;
2733 return (ARCHIVE_OK);
2735 if (!lzx_make_huffman_table(&ds->lt))
2737 ds->state = ST_MAIN;
2742 return (ds->error = ARCHIVE_FAILED);
2746 lzx_decode_blocks(struct lzx_stream *strm, int last)
2748 struct lzx_dec *ds = strm->ds;
2749 struct lzx_br bre = ds->br;
2750 struct huffman *at = &(ds->at), *lt = &(ds->lt), *mt = &(ds->mt);
2751 const struct lzx_pos_tbl *pos_tbl = ds->pos_tbl;
2752 unsigned char *noutp = strm->next_out;
2753 unsigned char *endp = noutp + strm->avail_out;
2754 unsigned char *w_buff = ds->w_buff;
2755 unsigned char *at_bitlen = at->bitlen;
2756 unsigned char *lt_bitlen = lt->bitlen;
2757 unsigned char *mt_bitlen = mt->bitlen;
2758 size_t block_bytes_avail = ds->block_bytes_avail;
2759 int at_max_bits = at->max_bits;
2760 int lt_max_bits = lt->max_bits;
2761 int mt_max_bits = mt->max_bits;
2762 int c, copy_len = ds->copy_len, copy_pos = ds->copy_pos;
2763 int w_pos = ds->w_pos, w_mask = ds->w_mask, w_size = ds->w_size;
2764 int length_header = ds->length_header;
2765 int offset_bits = ds->offset_bits;
2766 int position_slot = ds->position_slot;
2767 int r0 = ds->r0, r1 = ds->r1, r2 = ds->r2;
2768 int state = ds->state;
2769 char block_type = ds->block_type;
2775 if (block_bytes_avail == 0) {
2776 /* This block ended. */
2777 ds->state = ST_RD_BLOCK_TYPE;
2779 ds->block_bytes_avail =
2781 ds->copy_len = copy_len;
2782 ds->copy_pos = copy_pos;
2783 ds->length_header = length_header;
2784 ds->position_slot = position_slot;
2785 ds->r0 = r0; ds->r1 = r1; ds->r2 = r2;
2787 strm->avail_out = endp - noutp;
2788 return (ARCHIVE_EOF);
2791 /* Output buffer is empty. */
2794 if (!lzx_br_read_ahead(strm, &bre,
2798 /* Remaining bits are less than
2799 * maximum bits(mt.max_bits) but maybe
2800 * it still remains as much as we need,
2801 * so we should try to use it with
2803 c = lzx_decode_huffman(mt,
2805 &bre, mt_max_bits));
2806 lzx_br_consume(&bre, mt_bitlen[c]);
2807 if (!lzx_br_has(&bre, 0))
2808 goto failed;/* Over read. */
2810 c = lzx_decode_huffman(mt,
2811 lzx_br_bits(&bre, mt_max_bits));
2812 lzx_br_consume(&bre, mt_bitlen[c]);
2817 * 'c' is exactly literal code.
2819 /* Save a decoded code to reference it
2822 w_pos = (w_pos + 1) & w_mask;
2823 /* Store the decoded code to output buffer. */
2825 block_bytes_avail--;
2828 * Get a match code, its length and offset.
2831 length_header = c & 7;
2832 position_slot = c >> 3;
2838 if (length_header == 7) {
2839 if (!lzx_br_read_ahead(strm, &bre,
2845 c = lzx_decode_huffman(lt,
2847 &bre, lt_max_bits));
2848 lzx_br_consume(&bre, lt_bitlen[c]);
2849 if (!lzx_br_has(&bre, 0))
2850 goto failed;/* Over read. */
2852 c = lzx_decode_huffman(lt,
2853 lzx_br_bits(&bre, lt_max_bits));
2854 lzx_br_consume(&bre, lt_bitlen[c]);
2856 copy_len = c + 7 + 2;
2858 copy_len = length_header + 2;
2859 if ((size_t)copy_len > block_bytes_avail)
2864 switch (position_slot) {
2865 case 0: /* Use repeated offset 0. */
2867 state = ST_REAL_POS;
2869 case 1: /* Use repeated offset 1. */
2871 /* Swap repeated offset. */
2874 state = ST_REAL_POS;
2876 case 2: /* Use repeated offset 2. */
2878 /* Swap repeated offset. */
2881 state = ST_REAL_POS;
2885 pos_tbl[position_slot].footer_bits;
2891 * Get the offset, which is a distance from
2892 * current window position.
2894 if (block_type == ALIGNED_OFFSET_BLOCK &&
2896 int offbits = offset_bits - 3;
2898 if (!lzx_br_read_ahead(strm, &bre, offbits)) {
2904 copy_pos = lzx_br_bits(&bre, offbits) << 3;
2906 /* Get an aligned number. */
2907 if (!lzx_br_read_ahead(strm, &bre,
2908 offbits + at_max_bits)) {
2913 lzx_br_consume(&bre, offbits);
2914 c = lzx_decode_huffman(at,
2915 lzx_br_bits_forced(&bre,
2917 lzx_br_consume(&bre, at_bitlen[c]);
2918 if (!lzx_br_has(&bre, 0))
2919 goto failed;/* Over read. */
2921 lzx_br_consume(&bre, offbits);
2922 c = lzx_decode_huffman(at,
2923 lzx_br_bits(&bre, at_max_bits));
2924 lzx_br_consume(&bre, at_bitlen[c]);
2926 /* Add an aligned number. */
2929 if (!lzx_br_read_ahead(strm, &bre,
2936 copy_pos = lzx_br_bits(&bre, offset_bits);
2937 lzx_br_consume(&bre, offset_bits);
2939 copy_pos += pos_tbl[position_slot].base -2;
2941 /* Update repeated offset LRU queue. */
2948 * Compute a real position in window.
2950 copy_pos = (w_pos - copy_pos) & w_mask;
2954 * Copy several bytes as extracted data from the window
2955 * into the output buffer.
2958 const unsigned char *s;
2962 if (copy_pos > w_pos) {
2963 if (l > w_size - copy_pos)
2964 l = w_size - copy_pos;
2966 if (l > w_size - w_pos)
2969 if (noutp + l >= endp)
2970 l = (int)(endp - noutp);
2971 s = w_buff + copy_pos;
2972 if (l >= 8 && ((copy_pos + l < w_pos)
2973 || (w_pos + l < copy_pos))) {
2974 memcpy(w_buff + w_pos, s, l);
2975 memcpy(noutp, s, l);
2981 for (li = 0; li < l; li++)
2982 noutp[li] = d[li] = s[li];
2985 copy_pos = (copy_pos + l) & w_mask;
2986 w_pos = (w_pos + l) & w_mask;
2987 block_bytes_avail -= l;
2989 /* A copy of current pattern ended. */
2992 if (noutp >= endp) {
2993 /* Output buffer is empty. */
3003 return (ds->error = ARCHIVE_FAILED);
3006 ds->block_bytes_avail = block_bytes_avail;
3007 ds->copy_len = copy_len;
3008 ds->copy_pos = copy_pos;
3009 ds->length_header = length_header;
3010 ds->offset_bits = offset_bits;
3011 ds->position_slot = position_slot;
3012 ds->r0 = r0; ds->r1 = r1; ds->r2 = r2;
3015 strm->avail_out = endp - noutp;
3016 return (ARCHIVE_OK);
3020 lzx_read_pre_tree(struct lzx_stream *strm)
3022 struct lzx_dec *ds = strm->ds;
3023 struct lzx_br *br = &(ds->br);
3027 memset(ds->pt.freq, 0, sizeof(ds->pt.freq));
3028 for (i = ds->loop; i < ds->pt.len_size; i++) {
3029 if (!lzx_br_read_ahead(strm, br, 4)) {
3033 ds->pt.bitlen[i] = lzx_br_bits(br, 4);
3034 ds->pt.freq[ds->pt.bitlen[i]]++;
3035 lzx_br_consume(br, 4);
3042 * Read a bunch of bit-lengths from pre-tree.
3045 lzx_read_bitlen(struct lzx_stream *strm, struct huffman *d, int end)
3047 struct lzx_dec *ds = strm->ds;
3048 struct lzx_br *br = &(ds->br);
3049 int c, i, j, ret, same;
3054 memset(d->freq, 0, sizeof(d->freq));
3060 if (!lzx_br_read_ahead(strm, br, ds->pt.max_bits))
3062 rbits = lzx_br_bits(br, ds->pt.max_bits);
3063 c = lzx_decode_huffman(&(ds->pt), rbits);
3065 case 17:/* several zero lengths, from 4 to 19. */
3066 if (!lzx_br_read_ahead(strm, br, ds->pt.bitlen[c]+4))
3068 lzx_br_consume(br, ds->pt.bitlen[c]);
3069 same = lzx_br_bits(br, 4) + 4;
3071 return (-1);/* Invalid */
3072 lzx_br_consume(br, 4);
3073 for (j = 0; j < same; j++)
3076 case 18:/* many zero lengths, from 20 to 51. */
3077 if (!lzx_br_read_ahead(strm, br, ds->pt.bitlen[c]+5))
3079 lzx_br_consume(br, ds->pt.bitlen[c]);
3080 same = lzx_br_bits(br, 5) + 20;
3082 return (-1);/* Invalid */
3083 lzx_br_consume(br, 5);
3084 memset(d->bitlen + i, 0, same);
3087 case 19:/* a few same lengths. */
3088 if (!lzx_br_read_ahead(strm, br,
3089 ds->pt.bitlen[c]+1+ds->pt.max_bits))
3091 lzx_br_consume(br, ds->pt.bitlen[c]);
3092 same = lzx_br_bits(br, 1) + 4;
3095 lzx_br_consume(br, 1);
3096 rbits = lzx_br_bits(br, ds->pt.max_bits);
3097 c = lzx_decode_huffman(&(ds->pt), rbits);
3098 lzx_br_consume(br, ds->pt.bitlen[c]);
3099 c = (d->bitlen[i] - c + 17) % 17;
3101 return (-1);/* Invalid */
3102 for (j = 0; j < same; j++)
3107 lzx_br_consume(br, ds->pt.bitlen[c]);
3108 c = (d->bitlen[i] - c + 17) % 17;
3110 return (-1);/* Invalid */
3123 lzx_huffman_init(struct huffman *hf, size_t len_size, int tbl_bits)
3127 if (hf->bitlen == NULL || hf->len_size != (int)len_size) {
3129 hf->bitlen = calloc(len_size, sizeof(hf->bitlen[0]));
3130 if (hf->bitlen == NULL)
3131 return (ARCHIVE_FATAL);
3132 hf->len_size = (int)len_size;
3134 memset(hf->bitlen, 0, len_size * sizeof(hf->bitlen[0]));
3135 if (hf->tbl == NULL) {
3136 if (tbl_bits < HTBL_BITS)
3140 hf->tbl = malloc(((size_t)1 << bits) * sizeof(hf->tbl[0]));
3141 if (hf->tbl == NULL)
3142 return (ARCHIVE_FATAL);
3143 hf->tbl_bits = tbl_bits;
3145 if (hf->tree == NULL && tbl_bits > HTBL_BITS) {
3146 hf->tree_avail = 1 << (tbl_bits - HTBL_BITS + 4);
3147 hf->tree = malloc(hf->tree_avail * sizeof(hf->tree[0]));
3148 if (hf->tree == NULL)
3149 return (ARCHIVE_FATAL);
3151 return (ARCHIVE_OK);
3155 lzx_huffman_free(struct huffman *hf)
3163 * Make a huffman coding table.
3166 lzx_make_huffman_table(struct huffman *hf)
3169 const unsigned char *bitlen;
3170 int bitptn[17], weight[17];
3171 int i, maxbits = 0, ptn, tbl_size, w;
3172 int diffbits, len_avail;
3175 * Initialize bit patterns.
3178 for (i = 1, w = 1 << 15; i <= 16; i++, w >>= 1) {
3182 ptn += hf->freq[i] * w;
3186 if ((ptn & 0xffff) != 0 || maxbits > hf->tbl_bits)
3187 return (0);/* Invalid */
3189 hf->max_bits = maxbits;
3192 * Cut out extra bits which we won't house in the table.
3193 * This preparation reduces the same calculation in the for-loop
3197 int ebits = 16 - maxbits;
3198 for (i = 1; i <= maxbits; i++) {
3199 bitptn[i] >>= ebits;
3200 weight[i] >>= ebits;
3203 if (maxbits > HTBL_BITS) {
3207 diffbits = maxbits - HTBL_BITS;
3208 for (i = 1; i <= HTBL_BITS; i++) {
3209 bitptn[i] >>= diffbits;
3210 weight[i] >>= diffbits;
3212 htbl_max = bitptn[HTBL_BITS] +
3213 weight[HTBL_BITS] * hf->freq[HTBL_BITS];
3214 p = &(hf->tbl[htbl_max]);
3215 while (p < &hf->tbl[1U<<HTBL_BITS])
3219 hf->shift_bits = diffbits;
3224 tbl_size = 1 << HTBL_BITS;
3226 bitlen = hf->bitlen;
3227 len_avail = hf->len_size;
3229 for (i = 0; i < len_avail; i++) {
3238 /* Get a bit pattern */
3242 if (len <= HTBL_BITS) {
3243 /* Calculate next bit pattern */
3244 if ((bitptn[len] = ptn + cnt) > tbl_size)
3245 return (0);/* Invalid */
3246 /* Update the table */
3249 p[cnt] = (uint16_t)i;
3254 * A bit length is too big to be housed to a direct table,
3255 * so we use a tree model for its extra bits.
3257 bitptn[len] = ptn + cnt;
3258 bit = 1U << (diffbits -1);
3259 extlen = len - HTBL_BITS;
3261 p = &(tbl[ptn >> diffbits]);
3263 *p = len_avail + hf->tree_used;
3264 ht = &(hf->tree[hf->tree_used++]);
3265 if (hf->tree_used > hf->tree_avail)
3266 return (0);/* Invalid */
3270 if (*p < len_avail ||
3271 *p >= (len_avail + hf->tree_used))
3272 return (0);/* Invalid */
3273 ht = &(hf->tree[*p - len_avail]);
3275 while (--extlen > 0) {
3277 if (ht->left < len_avail) {
3278 ht->left = len_avail + hf->tree_used;
3279 ht = &(hf->tree[hf->tree_used++]);
3280 if (hf->tree_used > hf->tree_avail)
3281 return (0);/* Invalid */
3285 ht = &(hf->tree[ht->left - len_avail]);
3288 if (ht->right < len_avail) {
3289 ht->right = len_avail + hf->tree_used;
3290 ht = &(hf->tree[hf->tree_used++]);
3291 if (hf->tree_used > hf->tree_avail)
3292 return (0);/* Invalid */
3296 ht = &(hf->tree[ht->right - len_avail]);
3303 return (0);/* Invalid */
3304 ht->left = (uint16_t)i;
3307 return (0);/* Invalid */
3308 ht->right = (uint16_t)i;
3315 lzx_decode_huffman_tree(struct huffman *hf, unsigned rbits, int c)
3321 extlen = hf->shift_bits;
3322 while (c >= hf->len_size) {
3324 if (extlen-- <= 0 || c >= hf->tree_used)
3326 if (rbits & (1U << extlen))
3335 lzx_decode_huffman(struct huffman *hf, unsigned rbits)
3339 * At first search an index table for a bit pattern.
3340 * If it fails, search a huffman tree for.
3342 c = hf->tbl[rbits >> hf->shift_bits];
3343 if (c < hf->len_size)
3345 /* This bit pattern needs to be found out at a huffman tree. */
3346 return (lzx_decode_huffman_tree(hf, rbits, c));