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 processor 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.
122 /* Direct access table. */
130 static const int slots[] = {
131 30, 32, 34, 36, 38, 42, 50, 66, 98, 162, 290
134 #define SLOT_MAX 21/*->25*/
137 const unsigned char *next_in;
140 unsigned char *next_out;
147 * Cabinet file definitions.
149 /* CFHEADER offset */
150 #define CFHEADER_signature 0
151 #define CFHEADER_cbCabinet 8
152 #define CFHEADER_coffFiles 16
153 #define CFHEADER_versionMinor 24
154 #define CFHEADER_versionMajor 25
155 #define CFHEADER_cFolders 26
156 #define CFHEADER_cFiles 28
157 #define CFHEADER_flags 30
158 #define CFHEADER_setID 32
159 #define CFHEADER_iCabinet 34
160 #define CFHEADER_cbCFHeader 36
161 #define CFHEADER_cbCFFolder 38
162 #define CFHEADER_cbCFData 39
164 /* CFFOLDER offset */
165 #define CFFOLDER_coffCabStart 0
166 #define CFFOLDER_cCFData 4
167 #define CFFOLDER_typeCompress 6
168 #define CFFOLDER_abReserve 8
171 #define CFFILE_cbFile 0
172 #define CFFILE_uoffFolderStart 4
173 #define CFFILE_iFolder 8
174 #define CFFILE_date_time 10
175 #define CFFILE_attribs 14
178 #define CFDATA_csum 0
179 #define CFDATA_cbData 4
180 #define CFDATA_cbUncomp 6
182 static const char * const compression_name[] = {
190 /* Sum value of this CFDATA. */
192 uint16_t compressed_size;
193 uint16_t compressed_bytes_remaining;
194 uint16_t uncompressed_size;
195 uint16_t uncompressed_bytes_remaining;
196 /* To know how many bytes we have decompressed. */
197 uint16_t uncompressed_avail;
198 /* Offset from the beginning of compressed data of this CFDATA */
199 uint16_t read_offset;
201 /* To keep memory image of this CFDATA to compute the sum. */
202 size_t memimage_size;
203 unsigned char *memimage;
204 /* Result of calculation of sum. */
205 uint32_t sum_calculated;
206 unsigned char sum_extra[4];
212 uint32_t cfdata_offset_in_cab;
213 uint16_t cfdata_count;
215 #define COMPTYPE_NONE 0x0000
216 #define COMPTYPE_MSZIP 0x0001
217 #define COMPTYPE_QUANTUM 0x0002
218 #define COMPTYPE_LZX 0x0003
220 const char *compname;
221 /* At the time reading CFDATA */
222 struct cfdata cfdata;
224 /* Flags to mark progress of decompression. */
225 char decompress_init;
229 uint32_t uncompressed_size;
233 #define iFoldCONTINUED_FROM_PREV 0xFFFD
234 #define iFoldCONTINUED_TO_NEXT 0xFFFE
235 #define iFoldCONTINUED_PREV_AND_NEXT 0xFFFF
237 #define ATTR_RDONLY 0x01
238 #define ATTR_NAME_IS_UTF 0x80
239 struct archive_string pathname;
243 /* Total bytes of all file size in a Cabinet. */
244 uint32_t total_bytes;
245 uint32_t files_offset;
246 uint16_t folder_count;
249 #define PREV_CABINET 0x0001
250 #define NEXT_CABINET 0x0002
251 #define RESERVE_PRESENT 0x0004
254 /* Version number. */
257 unsigned char cffolder;
258 unsigned char cfdata;
259 /* All folders in a cabinet. */
260 struct cffolder *folder_array;
261 /* All files in a cabinet. */
262 struct cffile *file_array;
267 /* entry_bytes_remaining is the number of bytes we expect. */
268 int64_t entry_offset;
269 int64_t entry_bytes_remaining;
270 int64_t entry_unconsumed;
271 int64_t entry_compressed_bytes_read;
272 int64_t entry_uncompressed_bytes_read;
273 struct cffolder *entry_cffolder;
274 struct cffile *entry_cffile;
275 struct cfdata *entry_cfdata;
277 /* Offset from beginning of a cabinet file. */
279 struct cfheader cfheader;
280 struct archive_wstring ws;
282 /* Flag to mark progress that an archive was read their first header.*/
286 char end_of_entry_cleanup;
287 char read_data_invoked;
288 int64_t bytes_skipped;
290 unsigned char *uncompressed_buffer;
291 size_t uncompressed_buffer_size;
293 int init_default_conversion;
294 struct archive_string_conv *sconv;
295 struct archive_string_conv *sconv_default;
296 struct archive_string_conv *sconv_utf8;
297 char format_name[64];
303 struct lzx_stream xstrm;
306 static int archive_read_format_cab_bid(struct archive_read *, int);
307 static int archive_read_format_cab_options(struct archive_read *,
308 const char *, const char *);
309 static int archive_read_format_cab_read_header(struct archive_read *,
310 struct archive_entry *);
311 static int archive_read_format_cab_read_data(struct archive_read *,
312 const void **, size_t *, int64_t *);
313 static int archive_read_format_cab_read_data_skip(struct archive_read *);
314 static int archive_read_format_cab_cleanup(struct archive_read *);
316 static int cab_skip_sfx(struct archive_read *);
317 static time_t cab_dos_time(const unsigned char *);
318 static int cab_read_data(struct archive_read *, const void **,
319 size_t *, int64_t *);
320 static int cab_read_header(struct archive_read *);
321 static uint32_t cab_checksum_cfdata_4(const void *, size_t bytes, uint32_t);
322 static uint32_t cab_checksum_cfdata(const void *, size_t bytes, uint32_t);
323 static void cab_checksum_update(struct archive_read *, size_t);
324 static int cab_checksum_finish(struct archive_read *);
325 static int cab_next_cfdata(struct archive_read *);
326 static const void *cab_read_ahead_cfdata(struct archive_read *, ssize_t *);
327 static const void *cab_read_ahead_cfdata_none(struct archive_read *, ssize_t *);
328 static const void *cab_read_ahead_cfdata_deflate(struct archive_read *,
330 static const void *cab_read_ahead_cfdata_lzx(struct archive_read *,
332 static int64_t cab_consume_cfdata(struct archive_read *, int64_t);
333 static int64_t cab_minimum_consume_cfdata(struct archive_read *, int64_t);
334 static int lzx_decode_init(struct lzx_stream *, int);
335 static int lzx_read_blocks(struct lzx_stream *, int);
336 static int lzx_decode_blocks(struct lzx_stream *, int);
337 static void lzx_decode_free(struct lzx_stream *);
338 static void lzx_translation(struct lzx_stream *, void *, size_t, uint32_t);
339 static void lzx_cleanup_bitstream(struct lzx_stream *);
340 static int lzx_decode(struct lzx_stream *, int);
341 static int lzx_read_pre_tree(struct lzx_stream *);
342 static int lzx_read_bitlen(struct lzx_stream *, struct huffman *, int);
343 static int lzx_huffman_init(struct huffman *, size_t, int);
344 static void lzx_huffman_free(struct huffman *);
345 static int lzx_make_huffman_table(struct huffman *);
346 static inline int lzx_decode_huffman(struct huffman *, unsigned);
350 archive_read_support_format_cab(struct archive *_a)
352 struct archive_read *a = (struct archive_read *)_a;
356 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
357 ARCHIVE_STATE_NEW, "archive_read_support_format_cab");
359 cab = (struct cab *)calloc(1, sizeof(*cab));
361 archive_set_error(&a->archive, ENOMEM,
362 "Can't allocate CAB data");
363 return (ARCHIVE_FATAL);
365 archive_string_init(&cab->ws);
366 archive_wstring_ensure(&cab->ws, 256);
368 r = __archive_read_register_format(a,
371 archive_read_format_cab_bid,
372 archive_read_format_cab_options,
373 archive_read_format_cab_read_header,
374 archive_read_format_cab_read_data,
375 archive_read_format_cab_read_data_skip,
377 archive_read_format_cab_cleanup,
387 find_cab_magic(const char *p)
392 * Note: Self-Extraction program has 'MSCF' string in their
393 * program. If we were finding 'MSCF' string only, we got
394 * wrong place for Cabinet header, thus, we have to check
395 * following four bytes which are reserved and must be set
398 if (memcmp(p, "MSCF\0\0\0\0", 8) == 0)
410 archive_read_format_cab_bid(struct archive_read *a, int best_bid)
413 ssize_t bytes_avail, offset, window;
415 /* If there's already a better bid than we can ever
416 make, don't bother testing. */
420 if ((p = __archive_read_ahead(a, 8, NULL)) == NULL)
423 if (memcmp(p, "MSCF\0\0\0\0", 8) == 0)
427 * Attempt to handle self-extracting archives
428 * by noting a PE header and searching forward
429 * up to 128k for a 'MSCF' marker.
431 if (p[0] == 'M' && p[1] == 'Z') {
434 while (offset < (1024 * 128)) {
435 const char *h = __archive_read_ahead(a, offset + window,
438 /* Remaining bytes are less than window. */
445 while (p + 8 < h + bytes_avail) {
447 if ((next = find_cab_magic(p)) == 0)
458 archive_read_format_cab_options(struct archive_read *a,
459 const char *key, const char *val)
462 int ret = ARCHIVE_FAILED;
464 cab = (struct cab *)(a->format->data);
465 if (strcmp(key, "hdrcharset") == 0) {
466 if (val == NULL || val[0] == 0)
467 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
468 "cab: hdrcharset option needs a character-set name");
470 cab->sconv = archive_string_conversion_from_charset(
471 &a->archive, val, 0);
472 if (cab->sconv != NULL)
480 /* Note: The "warn" return is just to inform the options
481 * supervisor that we didn't handle it. It will generate
482 * a suitable error if no one used this option. */
483 return (ARCHIVE_WARN);
487 cab_skip_sfx(struct archive_read *a)
491 ssize_t bytes, window;
495 const char *h = __archive_read_ahead(a, window, &bytes);
497 /* Remaining size are less than window. */
500 archive_set_error(&a->archive,
501 ARCHIVE_ERRNO_FILE_FORMAT,
502 "Couldn't find out CAB header");
503 return (ARCHIVE_FATAL);
511 * Scan ahead until we find something that looks
512 * like the cab header.
516 if ((next = find_cab_magic(p)) == 0) {
518 __archive_read_consume(a, skip);
524 __archive_read_consume(a, skip);
529 truncated_error(struct archive_read *a)
531 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
532 "Truncated CAB header");
533 return (ARCHIVE_FATAL);
537 cab_strnlen(const unsigned char *p, size_t maxlen)
541 for (i = 0; i <= maxlen; i++) {
546 return (-1);/* invalid */
550 /* Read bytes as much as remaining. */
552 cab_read_ahead_remaining(struct archive_read *a, size_t min, ssize_t *avail)
557 p = __archive_read_ahead(a, min, avail);
565 /* Convert a path separator '\' -> '/' */
567 cab_convert_path_separator_1(struct archive_string *fn, unsigned char attr)
572 /* Easy check if we have '\' in multi-byte string. */
574 for (i = 0; i < archive_strlen(fn); i++) {
575 if (fn->s[i] == '\\') {
577 /* This may be second byte of multi-byte
583 } else if ((fn->s[i] & 0x80) && !(attr & ATTR_NAME_IS_UTF))
588 if (i == archive_strlen(fn))
594 * Replace a character '\' with '/' in wide character.
597 cab_convert_path_separator_2(struct cab *cab, struct archive_entry *entry)
602 /* If a conversion to wide character failed, force the replacement. */
603 if ((wp = archive_entry_pathname_w(entry)) != NULL) {
604 archive_wstrcpy(&(cab->ws), wp);
605 for (i = 0; i < archive_strlen(&(cab->ws)); i++) {
606 if (cab->ws.s[i] == L'\\')
609 archive_entry_copy_pathname_w(entry, cab->ws.s);
614 * Read CFHEADER, CFFOLDER and CFFILE.
617 cab_read_header(struct archive_read *a)
619 const unsigned char *p;
626 int cur_folder, prev_folder;
629 a->archive.archive_format = ARCHIVE_FORMAT_CAB;
630 if (a->archive.archive_format_name == NULL)
631 a->archive.archive_format_name = "CAB";
633 if ((p = __archive_read_ahead(a, 42, NULL)) == NULL)
634 return (truncated_error(a));
636 cab = (struct cab *)(a->format->data);
637 if (cab->found_header == 0 &&
638 p[0] == 'M' && p[1] == 'Z') {
639 /* This is an executable? Must be self-extracting... */
640 err = cab_skip_sfx(a);
641 if (err < ARCHIVE_WARN)
644 /* Re-read header after processing the SFX. */
645 if ((p = __archive_read_ahead(a, 42, NULL)) == NULL)
646 return (truncated_error(a));
654 if (p[CFHEADER_signature+0] != 'M' || p[CFHEADER_signature+1] != 'S' ||
655 p[CFHEADER_signature+2] != 'C' || p[CFHEADER_signature+3] != 'F') {
656 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
657 "Couldn't find out CAB header");
658 return (ARCHIVE_FATAL);
660 hd->total_bytes = archive_le32dec(p + CFHEADER_cbCabinet);
661 hd->files_offset = archive_le32dec(p + CFHEADER_coffFiles);
662 hd->minor = p[CFHEADER_versionMinor];
663 hd->major = p[CFHEADER_versionMajor];
664 hd->folder_count = archive_le16dec(p + CFHEADER_cFolders);
665 if (hd->folder_count == 0)
667 hd->file_count = archive_le16dec(p + CFHEADER_cFiles);
668 if (hd->file_count == 0)
670 hd->flags = archive_le16dec(p + CFHEADER_flags);
671 hd->setid = archive_le16dec(p + CFHEADER_setID);
672 hd->cabinet = archive_le16dec(p + CFHEADER_iCabinet);
673 used = CFHEADER_iCabinet + 2;
674 if (hd->flags & RESERVE_PRESENT) {
676 cfheader = archive_le16dec(p + CFHEADER_cbCFHeader);
677 if (cfheader > 60000U)
679 hd->cffolder = p[CFHEADER_cbCFFolder];
680 hd->cfdata = p[CFHEADER_cbCFData];
681 used += 4;/* cbCFHeader, cbCFFolder and cbCFData */
682 used += cfheader;/* abReserve */
684 hd->cffolder = 0;/* Avoid compiling warning. */
685 if (hd->flags & PREV_CABINET) {
686 /* How many bytes are used for szCabinetPrev. */
687 if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)
688 return (truncated_error(a));
689 if ((len = cab_strnlen(p + used, 255)) <= 0)
692 /* How many bytes are used for szDiskPrev. */
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)
699 if (hd->flags & NEXT_CABINET) {
700 /* How many bytes are used for szCabinetNext. */
701 if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)
702 return (truncated_error(a));
703 if ((len = cab_strnlen(p + used, 255)) <= 0)
706 /* How many bytes are used for szDiskNext. */
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)
713 __archive_read_consume(a, used);
714 cab->cab_offset += used;
720 hd->folder_array = (struct cffolder *)calloc(
721 hd->folder_count, sizeof(struct cffolder));
722 if (hd->folder_array == NULL)
726 if (hd->flags & RESERVE_PRESENT)
727 bytes += hd->cffolder;
728 bytes *= hd->folder_count;
729 if ((p = __archive_read_ahead(a, bytes, NULL)) == NULL)
730 return (truncated_error(a));
732 for (i = 0; i < hd->folder_count; i++) {
733 struct cffolder *folder = &(hd->folder_array[i]);
734 folder->cfdata_offset_in_cab =
735 archive_le32dec(p + CFFOLDER_coffCabStart);
736 folder->cfdata_count = archive_le16dec(p+CFFOLDER_cCFData);
738 archive_le16dec(p+CFFOLDER_typeCompress) & 0x0F;
740 archive_le16dec(p+CFFOLDER_typeCompress) >> 8;
741 /* Get a compression name. */
742 if (folder->comptype <
743 sizeof(compression_name) / sizeof(compression_name[0]))
744 folder->compname = compression_name[folder->comptype];
746 folder->compname = "UNKNOWN";
749 if (hd->flags & RESERVE_PRESENT) {
750 p += hd->cffolder;/* abReserve */
751 used += hd->cffolder;
754 * Sanity check if each data is acceptable.
756 if (offset32 >= folder->cfdata_offset_in_cab)
758 offset32 = folder->cfdata_offset_in_cab;
760 /* Set a request to initialize zlib for the CFDATA of
762 folder->decompress_init = 0;
764 __archive_read_consume(a, used);
765 cab->cab_offset += used;
770 /* Seek read pointer to the offset of CFFILE if needed. */
771 skip = (int64_t)hd->files_offset - cab->cab_offset;
773 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
774 "Invalid offset of CFFILE %jd < %jd",
775 (intmax_t)hd->files_offset, (intmax_t)cab->cab_offset);
776 return (ARCHIVE_FATAL);
779 __archive_read_consume(a, skip);
780 cab->cab_offset += skip;
782 /* Allocate memory for CFDATA */
783 hd->file_array = (struct cffile *)calloc(
784 hd->file_count, sizeof(struct cffile));
785 if (hd->file_array == NULL)
789 for (i = 0; i < hd->file_count; i++) {
790 struct cffile *file = &(hd->file_array[i]);
793 if ((p = __archive_read_ahead(a, 16, NULL)) == NULL)
794 return (truncated_error(a));
795 file->uncompressed_size = archive_le32dec(p + CFFILE_cbFile);
796 file->offset = archive_le32dec(p + CFFILE_uoffFolderStart);
797 file->folder = archive_le16dec(p + CFFILE_iFolder);
798 file->mtime = cab_dos_time(p + CFFILE_date_time);
799 file->attr = (uint8_t)archive_le16dec(p + CFFILE_attribs);
800 __archive_read_consume(a, 16);
802 cab->cab_offset += 16;
803 if ((p = cab_read_ahead_remaining(a, 256, &avail)) == NULL)
804 return (truncated_error(a));
805 if ((len = cab_strnlen(p, avail-1)) <= 0)
808 /* Copy a pathname. */
809 archive_string_init(&(file->pathname));
810 archive_strncpy(&(file->pathname), p, len);
811 __archive_read_consume(a, len + 1);
812 cab->cab_offset += len + 1;
815 * Sanity check if each data is acceptable.
817 if (file->uncompressed_size > 0x7FFF8000)
818 goto invalid;/* Too large */
819 if ((int64_t)file->offset + (int64_t)file->uncompressed_size
820 > ARCHIVE_LITERAL_LL(0x7FFF8000))
821 goto invalid;/* Too large */
822 switch (file->folder) {
823 case iFoldCONTINUED_TO_NEXT:
824 /* This must be last file in a folder. */
825 if (i != hd->file_count -1)
827 cur_folder = hd->folder_count -1;
829 case iFoldCONTINUED_PREV_AND_NEXT:
830 /* This must be only one file in a folder. */
831 if (hd->file_count != 1)
834 case iFoldCONTINUED_FROM_PREV:
835 /* This must be first file in a folder. */
838 prev_folder = cur_folder = 0;
839 offset32 = file->offset;
842 if (file->folder >= hd->folder_count)
844 cur_folder = file->folder;
847 /* Dot not back track. */
848 if (cur_folder < prev_folder)
850 if (cur_folder != prev_folder)
852 prev_folder = cur_folder;
854 /* Make sure there are not any blanks from last file
856 if (offset32 != file->offset)
858 offset32 += file->uncompressed_size;
860 /* CFDATA is available for file contents. */
861 if (file->uncompressed_size > 0 &&
862 hd->folder_array[cur_folder].cfdata_count == 0)
866 if (hd->cabinet != 0 || hd->flags & (PREV_CABINET | NEXT_CABINET)) {
867 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
868 "Multivolume cabinet file is unsupported");
869 return (ARCHIVE_WARN);
873 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
874 "Invalid CAB header");
875 return (ARCHIVE_FATAL);
877 archive_set_error(&a->archive, ENOMEM,
878 "Can't allocate memory for CAB data");
879 return (ARCHIVE_FATAL);
883 archive_read_format_cab_read_header(struct archive_read *a,
884 struct archive_entry *entry)
888 struct cffolder *prev_folder;
890 struct archive_string_conv *sconv;
891 int err = ARCHIVE_OK, r;
893 cab = (struct cab *)(a->format->data);
894 if (cab->found_header == 0) {
895 err = cab_read_header(a);
896 if (err < ARCHIVE_WARN)
898 /* We've found the header. */
899 cab->found_header = 1;
903 if (hd->file_index >= hd->file_count) {
904 cab->end_of_archive = 1;
905 return (ARCHIVE_EOF);
907 file = &hd->file_array[hd->file_index++];
909 cab->end_of_entry = 0;
910 cab->end_of_entry_cleanup = 0;
911 cab->entry_compressed_bytes_read = 0;
912 cab->entry_uncompressed_bytes_read = 0;
913 cab->entry_unconsumed = 0;
914 cab->entry_cffile = file;
917 * Choose a proper folder.
919 prev_folder = cab->entry_cffolder;
920 switch (file->folder) {
921 case iFoldCONTINUED_FROM_PREV:
922 case iFoldCONTINUED_PREV_AND_NEXT:
923 cab->entry_cffolder = &hd->folder_array[0];
925 case iFoldCONTINUED_TO_NEXT:
926 cab->entry_cffolder = &hd->folder_array[hd->folder_count-1];
929 cab->entry_cffolder = &hd->folder_array[file->folder];
932 /* If a cffolder of this file is changed, reset a cfdata to read
933 * file contents from next cfdata. */
934 if (prev_folder != cab->entry_cffolder)
935 cab->entry_cfdata = NULL;
937 /* If a pathname is UTF-8, prepare a string conversion object
938 * for UTF-8 and use it. */
939 if (file->attr & ATTR_NAME_IS_UTF) {
940 if (cab->sconv_utf8 == NULL) {
942 archive_string_conversion_from_charset(
943 &(a->archive), "UTF-8", 1);
944 if (cab->sconv_utf8 == NULL)
945 return (ARCHIVE_FATAL);
947 sconv = cab->sconv_utf8;
948 } else if (cab->sconv != NULL) {
949 /* Choose the conversion specified by the option. */
952 /* Choose the default conversion. */
953 if (!cab->init_default_conversion) {
955 archive_string_default_conversion_for_read(
957 cab->init_default_conversion = 1;
959 sconv = cab->sconv_default;
963 * Set a default value and common data
965 r = cab_convert_path_separator_1(&(file->pathname), file->attr);
966 if (archive_entry_copy_pathname_l(entry, file->pathname.s,
967 archive_strlen(&(file->pathname)), sconv) != 0) {
968 if (errno == ENOMEM) {
969 archive_set_error(&a->archive, ENOMEM,
970 "Can't allocate memory for Pathname");
971 return (ARCHIVE_FATAL);
973 archive_set_error(&a->archive,
974 ARCHIVE_ERRNO_FILE_FORMAT,
975 "Pathname cannot be converted "
976 "from %s to current locale.",
977 archive_string_conversion_charset_name(sconv));
981 /* Convert a path separator '\' -> '/' */
982 cab_convert_path_separator_2(cab, entry);
985 archive_entry_set_size(entry, file->uncompressed_size);
986 if (file->attr & ATTR_RDONLY)
987 archive_entry_set_mode(entry, AE_IFREG | 0555);
989 archive_entry_set_mode(entry, AE_IFREG | 0666);
990 archive_entry_set_mtime(entry, file->mtime, 0);
992 cab->entry_bytes_remaining = file->uncompressed_size;
993 cab->entry_offset = 0;
994 /* We don't need compress data. */
995 if (file->uncompressed_size == 0)
996 cab->end_of_entry_cleanup = cab->end_of_entry = 1;
998 /* Set up a more descriptive format name. */
999 sprintf(cab->format_name, "CAB %d.%d (%s)",
1000 hd->major, hd->minor, cab->entry_cffolder->compname);
1001 a->archive.archive_format_name = cab->format_name;
1007 archive_read_format_cab_read_data(struct archive_read *a,
1008 const void **buff, size_t *size, int64_t *offset)
1010 struct cab *cab = (struct cab *)(a->format->data);
1013 switch (cab->entry_cffile->folder) {
1014 case iFoldCONTINUED_FROM_PREV:
1015 case iFoldCONTINUED_TO_NEXT:
1016 case iFoldCONTINUED_PREV_AND_NEXT:
1020 archive_clear_error(&a->archive);
1021 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1022 "Cannot restore this file split in multivolume.");
1023 return (ARCHIVE_FAILED);
1027 if (cab->read_data_invoked == 0) {
1028 if (cab->bytes_skipped) {
1029 if (cab->entry_cfdata == NULL) {
1030 r = cab_next_cfdata(a);
1034 if (cab_consume_cfdata(a, cab->bytes_skipped) < 0)
1035 return (ARCHIVE_FATAL);
1036 cab->bytes_skipped = 0;
1038 cab->read_data_invoked = 1;
1040 if (cab->entry_unconsumed) {
1041 /* Consume as much as the compressor actually used. */
1042 r = (int)cab_consume_cfdata(a, cab->entry_unconsumed);
1043 cab->entry_unconsumed = 0;
1047 if (cab->end_of_archive || cab->end_of_entry) {
1048 if (!cab->end_of_entry_cleanup) {
1049 /* End-of-entry cleanup done. */
1050 cab->end_of_entry_cleanup = 1;
1052 *offset = cab->entry_offset;
1055 return (ARCHIVE_EOF);
1058 return (cab_read_data(a, buff, size, offset));
1062 cab_checksum_cfdata_4(const void *p, size_t bytes, uint32_t seed)
1064 const unsigned char *b;
1068 u32num = (unsigned)bytes / 4;
1071 for (;u32num > 0; --u32num) {
1072 sum ^= archive_le32dec(b);
1079 cab_checksum_cfdata(const void *p, size_t bytes, uint32_t seed)
1081 const unsigned char *b;
1085 sum = cab_checksum_cfdata_4(p, bytes, seed);
1089 switch (bytes & 3) {
1091 t |= ((uint32_t)(*b++)) << 16;
1094 t |= ((uint32_t)(*b++)) << 8;
1108 cab_checksum_update(struct archive_read *a, size_t bytes)
1110 struct cab *cab = (struct cab *)(a->format->data);
1111 struct cfdata *cfdata = cab->entry_cfdata;
1112 const unsigned char *p;
1115 if (cfdata->sum == 0 || cfdata->sum_ptr == NULL)
1118 * Calculate the sum of this CFDATA.
1119 * Make sure CFDATA must be calculated in four bytes.
1121 p = cfdata->sum_ptr;
1123 if (cfdata->sum_extra_avail) {
1124 while (cfdata->sum_extra_avail < 4 && sumbytes > 0) {
1126 cfdata->sum_extra_avail++] = *p++;
1129 if (cfdata->sum_extra_avail == 4) {
1130 cfdata->sum_calculated = cab_checksum_cfdata_4(
1131 cfdata->sum_extra, 4, cfdata->sum_calculated);
1132 cfdata->sum_extra_avail = 0;
1136 int odd = sumbytes & 3;
1137 if (sumbytes - odd > 0)
1138 cfdata->sum_calculated = cab_checksum_cfdata_4(
1139 p, sumbytes - odd, cfdata->sum_calculated);
1141 memcpy(cfdata->sum_extra, p + sumbytes - odd, odd);
1142 cfdata->sum_extra_avail = odd;
1144 cfdata->sum_ptr = NULL;
1148 cab_checksum_finish(struct archive_read *a)
1150 struct cab *cab = (struct cab *)(a->format->data);
1151 struct cfdata *cfdata = cab->entry_cfdata;
1154 /* Do not need to compute a sum. */
1155 if (cfdata->sum == 0)
1156 return (ARCHIVE_OK);
1159 * Calculate the sum of remaining CFDATA.
1161 if (cfdata->sum_extra_avail) {
1162 cfdata->sum_calculated =
1163 cab_checksum_cfdata(cfdata->sum_extra,
1164 cfdata->sum_extra_avail, cfdata->sum_calculated);
1165 cfdata->sum_extra_avail = 0;
1169 if (cab->cfheader.flags & RESERVE_PRESENT)
1170 l += cab->cfheader.cfdata;
1171 cfdata->sum_calculated = cab_checksum_cfdata(
1172 cfdata->memimage + CFDATA_cbData, l, cfdata->sum_calculated);
1173 if (cfdata->sum_calculated != cfdata->sum) {
1174 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1175 "Checksum error CFDATA[%d] %" PRIx32 ":%" PRIx32 " in %d bytes",
1176 cab->entry_cffolder->cfdata_index -1,
1177 cfdata->sum, cfdata->sum_calculated,
1178 cfdata->compressed_size);
1179 return (ARCHIVE_FAILED);
1181 return (ARCHIVE_OK);
1185 * Read CFDATA if needed.
1188 cab_next_cfdata(struct archive_read *a)
1190 struct cab *cab = (struct cab *)(a->format->data);
1191 struct cfdata *cfdata = cab->entry_cfdata;
1193 /* There are remaining bytes in current CFDATA, use it first. */
1194 if (cfdata != NULL && cfdata->uncompressed_bytes_remaining > 0)
1195 return (ARCHIVE_OK);
1197 if (cfdata == NULL) {
1200 cab->entry_cffolder->cfdata_index = 0;
1202 /* Seek read pointer to the offset of CFDATA if needed. */
1203 skip = cab->entry_cffolder->cfdata_offset_in_cab
1207 switch (cab->entry_cffile->folder) {
1208 case iFoldCONTINUED_FROM_PREV:
1209 case iFoldCONTINUED_PREV_AND_NEXT:
1212 case iFoldCONTINUED_TO_NEXT:
1213 folder_index = cab->cfheader.folder_count-1;
1216 folder_index = cab->entry_cffile->folder;
1219 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1220 "Invalid offset of CFDATA in folder(%d) %jd < %jd",
1222 (intmax_t)cab->entry_cffolder->cfdata_offset_in_cab,
1223 (intmax_t)cab->cab_offset);
1224 return (ARCHIVE_FATAL);
1227 if (__archive_read_consume(a, skip) < 0)
1228 return (ARCHIVE_FATAL);
1230 cab->entry_cffolder->cfdata_offset_in_cab;
1237 if (cab->entry_cffolder->cfdata_index <
1238 cab->entry_cffolder->cfdata_count) {
1239 const unsigned char *p;
1242 cfdata = &(cab->entry_cffolder->cfdata);
1243 cab->entry_cffolder->cfdata_index++;
1244 cab->entry_cfdata = cfdata;
1245 cfdata->sum_calculated = 0;
1246 cfdata->sum_extra_avail = 0;
1247 cfdata->sum_ptr = NULL;
1249 if (cab->cfheader.flags & RESERVE_PRESENT)
1250 l += cab->cfheader.cfdata;
1251 if ((p = __archive_read_ahead(a, l, NULL)) == NULL)
1252 return (truncated_error(a));
1253 cfdata->sum = archive_le32dec(p + CFDATA_csum);
1254 cfdata->compressed_size = archive_le16dec(p + CFDATA_cbData);
1255 cfdata->compressed_bytes_remaining = cfdata->compressed_size;
1256 cfdata->uncompressed_size =
1257 archive_le16dec(p + CFDATA_cbUncomp);
1258 cfdata->uncompressed_bytes_remaining =
1259 cfdata->uncompressed_size;
1260 cfdata->uncompressed_avail = 0;
1261 cfdata->read_offset = 0;
1262 cfdata->unconsumed = 0;
1265 * Sanity check if data size is acceptable.
1267 if (cfdata->compressed_size == 0 ||
1268 cfdata->compressed_size > (0x8000+6144))
1270 if (cfdata->uncompressed_size > 0x8000)
1272 if (cfdata->uncompressed_size == 0) {
1273 switch (cab->entry_cffile->folder) {
1274 case iFoldCONTINUED_PREV_AND_NEXT:
1275 case iFoldCONTINUED_TO_NEXT:
1277 case iFoldCONTINUED_FROM_PREV:
1282 /* If CFDATA is not last in a folder, an uncompressed
1283 * size must be 0x8000(32KBi) */
1284 if ((cab->entry_cffolder->cfdata_index <
1285 cab->entry_cffolder->cfdata_count) &&
1286 cfdata->uncompressed_size != 0x8000)
1289 /* A compressed data size and an uncompressed data size must
1290 * be the same in no compression mode. */
1291 if (cab->entry_cffolder->comptype == COMPTYPE_NONE &&
1292 cfdata->compressed_size != cfdata->uncompressed_size)
1296 * Save CFDATA image for sum check.
1298 if (cfdata->memimage_size < (size_t)l) {
1299 free(cfdata->memimage);
1300 cfdata->memimage = malloc(l);
1301 if (cfdata->memimage == NULL) {
1302 archive_set_error(&a->archive, ENOMEM,
1303 "Can't allocate memory for CAB data");
1304 return (ARCHIVE_FATAL);
1306 cfdata->memimage_size = l;
1308 memcpy(cfdata->memimage, p, l);
1310 /* Consume bytes as much as we used. */
1311 __archive_read_consume(a, l);
1312 cab->cab_offset += l;
1313 } else if (cab->entry_cffolder->cfdata_count > 0) {
1314 /* Run out of all CFDATA in a folder. */
1315 cfdata->compressed_size = 0;
1316 cfdata->uncompressed_size = 0;
1317 cfdata->compressed_bytes_remaining = 0;
1318 cfdata->uncompressed_bytes_remaining = 0;
1320 /* Current folder does not have any CFDATA. */
1321 cfdata = &(cab->entry_cffolder->cfdata);
1322 cab->entry_cfdata = cfdata;
1323 memset(cfdata, 0, sizeof(*cfdata));
1325 return (ARCHIVE_OK);
1327 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1329 return (ARCHIVE_FATAL);
1333 * Read ahead CFDATA.
1336 cab_read_ahead_cfdata(struct archive_read *a, ssize_t *avail)
1338 struct cab *cab = (struct cab *)(a->format->data);
1341 err = cab_next_cfdata(a);
1342 if (err < ARCHIVE_OK) {
1347 switch (cab->entry_cffolder->comptype) {
1349 return (cab_read_ahead_cfdata_none(a, avail));
1350 case COMPTYPE_MSZIP:
1351 return (cab_read_ahead_cfdata_deflate(a, avail));
1353 return (cab_read_ahead_cfdata_lzx(a, avail));
1354 default: /* Unsupported compression. */
1355 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
1356 "Unsupported CAB compression : %s",
1357 cab->entry_cffolder->compname);
1358 *avail = ARCHIVE_FAILED;
1364 * Read ahead CFDATA as uncompressed data.
1367 cab_read_ahead_cfdata_none(struct archive_read *a, ssize_t *avail)
1369 struct cab *cab = (struct cab *)(a->format->data);
1370 struct cfdata *cfdata;
1373 cfdata = cab->entry_cfdata;
1376 * Note: '1' here is a performance optimization.
1377 * Recall that the decompression layer returns a count of
1378 * available bytes; asking for more than that forces the
1379 * decompressor to combine reads by copying data.
1381 d = __archive_read_ahead(a, 1, avail);
1383 *avail = truncated_error(a);
1386 if (*avail > cfdata->uncompressed_bytes_remaining)
1387 *avail = cfdata->uncompressed_bytes_remaining;
1388 cfdata->uncompressed_avail = cfdata->uncompressed_size;
1389 cfdata->unconsumed = *avail;
1390 cfdata->sum_ptr = d;
1395 * Read ahead CFDATA as deflate data.
1399 cab_read_ahead_cfdata_deflate(struct archive_read *a, ssize_t *avail)
1401 struct cab *cab = (struct cab *)(a->format->data);
1402 struct cfdata *cfdata;
1408 cfdata = cab->entry_cfdata;
1409 /* If the buffer hasn't been allocated, allocate it now. */
1410 if (cab->uncompressed_buffer == NULL) {
1411 cab->uncompressed_buffer_size = 0x8000;
1412 cab->uncompressed_buffer
1413 = (unsigned char *)malloc(cab->uncompressed_buffer_size);
1414 if (cab->uncompressed_buffer == NULL) {
1415 archive_set_error(&a->archive, ENOMEM,
1416 "No memory for CAB reader");
1417 *avail = ARCHIVE_FATAL;
1422 uavail = cfdata->uncompressed_avail;
1423 if (uavail == cfdata->uncompressed_size) {
1424 d = cab->uncompressed_buffer + cfdata->read_offset;
1425 *avail = uavail - cfdata->read_offset;
1429 if (!cab->entry_cffolder->decompress_init) {
1430 cab->stream.next_in = NULL;
1431 cab->stream.avail_in = 0;
1432 cab->stream.total_in = 0;
1433 cab->stream.next_out = NULL;
1434 cab->stream.avail_out = 0;
1435 cab->stream.total_out = 0;
1436 if (cab->stream_valid)
1437 r = inflateReset(&cab->stream);
1439 r = inflateInit2(&cab->stream,
1440 -15 /* Don't check for zlib header */);
1442 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1443 "Can't initialize deflate decompression.");
1444 *avail = ARCHIVE_FATAL;
1447 /* Stream structure has been set up. */
1448 cab->stream_valid = 1;
1449 /* We've initialized decompression for this stream. */
1450 cab->entry_cffolder->decompress_init = 1;
1453 if (cfdata->compressed_bytes_remaining == cfdata->compressed_size)
1458 cab->stream.total_out = uavail;
1460 * We always uncompress all data in current CFDATA.
1462 while (!eod && cab->stream.total_out < cfdata->uncompressed_size) {
1463 ssize_t bytes_avail;
1465 cab->stream.next_out =
1466 cab->uncompressed_buffer + cab->stream.total_out;
1467 cab->stream.avail_out =
1468 cfdata->uncompressed_size - cab->stream.total_out;
1470 d = __archive_read_ahead(a, 1, &bytes_avail);
1471 if (bytes_avail <= 0) {
1472 *avail = truncated_error(a);
1475 if (bytes_avail > cfdata->compressed_bytes_remaining)
1476 bytes_avail = cfdata->compressed_bytes_remaining;
1478 * A bug in zlib.h: stream.next_in should be marked 'const'
1479 * but isn't (the library never alters data through the
1480 * next_in pointer, only reads it). The result: this ugly
1481 * cast to remove 'const'.
1483 cab->stream.next_in = (Bytef *)(uintptr_t)d;
1484 cab->stream.avail_in = (uInt)bytes_avail;
1485 cab->stream.total_in = 0;
1487 /* Cut out a tow-byte MSZIP signature(0x43, 0x4b). */
1489 if (bytes_avail <= 0)
1491 if (bytes_avail <= mszip) {
1493 if (cab->stream.next_in[0] != 0x43)
1495 if (bytes_avail > 1 &&
1496 cab->stream.next_in[1] != 0x4b)
1498 } else if (cab->stream.next_in[0] != 0x4b)
1500 cfdata->unconsumed = bytes_avail;
1501 cfdata->sum_ptr = d;
1502 if (cab_minimum_consume_cfdata(
1503 a, cfdata->unconsumed) < 0) {
1504 *avail = ARCHIVE_FATAL;
1507 mszip -= (int)bytes_avail;
1510 if (mszip == 1 && cab->stream.next_in[0] != 0x4b)
1512 else if (mszip == 2 && (cab->stream.next_in[0] != 0x43 ||
1513 cab->stream.next_in[1] != 0x4b))
1515 cab->stream.next_in += mszip;
1516 cab->stream.avail_in -= mszip;
1517 cab->stream.total_in += mszip;
1521 r = inflate(&cab->stream, 0);
1531 cfdata->unconsumed = cab->stream.total_in;
1532 cfdata->sum_ptr = d;
1533 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1534 *avail = ARCHIVE_FATAL;
1538 uavail = (uint16_t)cab->stream.total_out;
1540 if (uavail < cfdata->uncompressed_size) {
1541 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1542 "Invalid uncompressed size (%d < %d)",
1543 uavail, cfdata->uncompressed_size);
1544 *avail = ARCHIVE_FATAL;
1549 * Note: I suspect there is a bug in makecab.exe because, in rare
1550 * case, compressed bytes are still remaining regardless we have
1551 * gotten all uncompressed bytes, which size is recorded in CFDATA,
1552 * as much as we need, and we have to use the garbage so as to
1553 * correctly compute the sum of CFDATA accordingly.
1555 if (cfdata->compressed_bytes_remaining > 0) {
1556 ssize_t bytes_avail;
1558 d = __archive_read_ahead(a, cfdata->compressed_bytes_remaining,
1560 if (bytes_avail <= 0) {
1561 *avail = truncated_error(a);
1564 cfdata->unconsumed = cfdata->compressed_bytes_remaining;
1565 cfdata->sum_ptr = d;
1566 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1567 *avail = ARCHIVE_FATAL;
1573 * Set dictionary data for decompressing of next CFDATA, which
1574 * in the same folder. This is why we always do decompress CFDATA
1575 * even if beginning CFDATA or some of CFDATA are not used in
1576 * skipping file data.
1578 if (cab->entry_cffolder->cfdata_index <
1579 cab->entry_cffolder->cfdata_count) {
1580 r = inflateReset(&cab->stream);
1583 r = inflateSetDictionary(&cab->stream,
1584 cab->uncompressed_buffer, cfdata->uncompressed_size);
1589 d = cab->uncompressed_buffer + cfdata->read_offset;
1590 *avail = uavail - cfdata->read_offset;
1591 cfdata->uncompressed_avail = uavail;
1598 archive_set_error(&a->archive, ENOMEM,
1599 "Out of memory for deflate decompression");
1602 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1603 "Deflate decompression failed (%d)", r);
1606 *avail = ARCHIVE_FATAL;
1609 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1610 "CFDATA incorrect(no MSZIP signature)");
1611 *avail = ARCHIVE_FATAL;
1615 #else /* HAVE_ZLIB_H */
1618 cab_read_ahead_cfdata_deflate(struct archive_read *a, ssize_t *avail)
1620 *avail = ARCHIVE_FATAL;
1621 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1622 "libarchive compiled without deflate support (no libz)");
1626 #endif /* HAVE_ZLIB_H */
1629 cab_read_ahead_cfdata_lzx(struct archive_read *a, ssize_t *avail)
1631 struct cab *cab = (struct cab *)(a->format->data);
1632 struct cfdata *cfdata;
1637 cfdata = cab->entry_cfdata;
1638 /* If the buffer hasn't been allocated, allocate it now. */
1639 if (cab->uncompressed_buffer == NULL) {
1640 cab->uncompressed_buffer_size = 0x8000;
1641 cab->uncompressed_buffer
1642 = (unsigned char *)malloc(cab->uncompressed_buffer_size);
1643 if (cab->uncompressed_buffer == NULL) {
1644 archive_set_error(&a->archive, ENOMEM,
1645 "No memory for CAB reader");
1646 *avail = ARCHIVE_FATAL;
1651 uavail = cfdata->uncompressed_avail;
1652 if (uavail == cfdata->uncompressed_size) {
1653 d = cab->uncompressed_buffer + cfdata->read_offset;
1654 *avail = uavail - cfdata->read_offset;
1658 if (!cab->entry_cffolder->decompress_init) {
1659 r = lzx_decode_init(&cab->xstrm,
1660 cab->entry_cffolder->compdata);
1661 if (r != ARCHIVE_OK) {
1662 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1663 "Can't initialize LZX decompression.");
1664 *avail = ARCHIVE_FATAL;
1667 /* We've initialized decompression for this stream. */
1668 cab->entry_cffolder->decompress_init = 1;
1671 /* Clean up remaining bits of previous CFDATA. */
1672 lzx_cleanup_bitstream(&cab->xstrm);
1673 cab->xstrm.total_out = uavail;
1674 while (cab->xstrm.total_out < cfdata->uncompressed_size) {
1675 ssize_t bytes_avail;
1677 cab->xstrm.next_out =
1678 cab->uncompressed_buffer + cab->xstrm.total_out;
1679 cab->xstrm.avail_out =
1680 cfdata->uncompressed_size - cab->xstrm.total_out;
1682 d = __archive_read_ahead(a, 1, &bytes_avail);
1683 if (bytes_avail <= 0) {
1684 archive_set_error(&a->archive,
1685 ARCHIVE_ERRNO_FILE_FORMAT,
1686 "Truncated CAB file data");
1687 *avail = ARCHIVE_FATAL;
1690 if (bytes_avail > cfdata->compressed_bytes_remaining)
1691 bytes_avail = cfdata->compressed_bytes_remaining;
1693 cab->xstrm.next_in = d;
1694 cab->xstrm.avail_in = bytes_avail;
1695 cab->xstrm.total_in = 0;
1696 r = lzx_decode(&cab->xstrm,
1697 cfdata->compressed_bytes_remaining == bytes_avail);
1703 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1704 "LZX decompression failed (%d)", r);
1705 *avail = ARCHIVE_FATAL;
1708 cfdata->unconsumed = cab->xstrm.total_in;
1709 cfdata->sum_ptr = d;
1710 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1711 *avail = ARCHIVE_FATAL;
1716 uavail = (uint16_t)cab->xstrm.total_out;
1718 * Make sure a read pointer advances to next CFDATA.
1720 if (cfdata->compressed_bytes_remaining > 0) {
1721 ssize_t bytes_avail;
1723 d = __archive_read_ahead(a, cfdata->compressed_bytes_remaining,
1725 if (bytes_avail <= 0) {
1726 *avail = truncated_error(a);
1729 cfdata->unconsumed = cfdata->compressed_bytes_remaining;
1730 cfdata->sum_ptr = d;
1731 if (cab_minimum_consume_cfdata(a, cfdata->unconsumed) < 0) {
1732 *avail = ARCHIVE_FATAL;
1738 * Translation reversal of x86 processor CALL byte sequence(E8).
1740 lzx_translation(&cab->xstrm, cab->uncompressed_buffer,
1741 cfdata->uncompressed_size,
1742 (cab->entry_cffolder->cfdata_index-1) * 0x8000);
1744 d = cab->uncompressed_buffer + cfdata->read_offset;
1745 *avail = uavail - cfdata->read_offset;
1746 cfdata->uncompressed_avail = uavail;
1753 * We always decompress CFDATA to consume CFDATA as much as we need
1754 * in uncompressed bytes because all CFDATA in a folder are related
1755 * so we do not skip any CFDATA without decompressing.
1756 * Note: If the folder of a CFFILE is iFoldCONTINUED_PREV_AND_NEXT or
1757 * iFoldCONTINUED_FROM_PREV, we won't decompress because a CFDATA for
1758 * the CFFILE is remaining bytes of previous Multivolume CAB file.
1761 cab_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
1763 struct cab *cab = (struct cab *)(a->format->data);
1764 struct cfdata *cfdata;
1765 int64_t cbytes, rbytes;
1768 rbytes = cab_minimum_consume_cfdata(a, consumed_bytes);
1770 return (ARCHIVE_FATAL);
1772 cfdata = cab->entry_cfdata;
1773 while (rbytes > 0) {
1776 if (cfdata->compressed_size == 0) {
1777 archive_set_error(&a->archive,
1778 ARCHIVE_ERRNO_FILE_FORMAT,
1780 return (ARCHIVE_FATAL);
1782 cbytes = cfdata->uncompressed_bytes_remaining;
1783 if (cbytes > rbytes)
1787 if (cfdata->uncompressed_avail == 0 &&
1788 (cab->entry_cffile->folder == iFoldCONTINUED_PREV_AND_NEXT ||
1789 cab->entry_cffile->folder == iFoldCONTINUED_FROM_PREV)) {
1790 /* We have not read any data yet. */
1791 if (cbytes == cfdata->uncompressed_bytes_remaining) {
1792 /* Skip whole current CFDATA. */
1793 __archive_read_consume(a,
1794 cfdata->compressed_size);
1795 cab->cab_offset += cfdata->compressed_size;
1796 cfdata->compressed_bytes_remaining = 0;
1797 cfdata->uncompressed_bytes_remaining = 0;
1798 err = cab_next_cfdata(a);
1801 cfdata = cab->entry_cfdata;
1802 if (cfdata->uncompressed_size == 0) {
1803 switch (cab->entry_cffile->folder) {
1804 case iFoldCONTINUED_PREV_AND_NEXT:
1805 case iFoldCONTINUED_TO_NEXT:
1806 case iFoldCONTINUED_FROM_PREV:
1815 cfdata->read_offset += (uint16_t)cbytes;
1816 cfdata->uncompressed_bytes_remaining -= (uint16_t)cbytes;
1818 } else if (cbytes == 0) {
1819 err = cab_next_cfdata(a);
1822 cfdata = cab->entry_cfdata;
1823 if (cfdata->uncompressed_size == 0) {
1824 switch (cab->entry_cffile->folder) {
1825 case iFoldCONTINUED_PREV_AND_NEXT:
1826 case iFoldCONTINUED_TO_NEXT:
1827 case iFoldCONTINUED_FROM_PREV:
1828 return (ARCHIVE_FATAL);
1835 while (cbytes > 0) {
1836 (void)cab_read_ahead_cfdata(a, &avail);
1838 return (ARCHIVE_FATAL);
1840 avail = (ssize_t)cbytes;
1841 if (cab_minimum_consume_cfdata(a, avail) < 0)
1842 return (ARCHIVE_FATAL);
1846 return (consumed_bytes);
1850 * Consume CFDATA as much as we have already gotten and
1851 * compute the sum of CFDATA.
1854 cab_minimum_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
1856 struct cab *cab = (struct cab *)(a->format->data);
1857 struct cfdata *cfdata;
1858 int64_t cbytes, rbytes;
1861 cfdata = cab->entry_cfdata;
1862 rbytes = consumed_bytes;
1863 if (cab->entry_cffolder->comptype == COMPTYPE_NONE) {
1864 if (consumed_bytes < cfdata->unconsumed)
1865 cbytes = consumed_bytes;
1867 cbytes = cfdata->unconsumed;
1869 cfdata->read_offset += (uint16_t)cbytes;
1870 cfdata->uncompressed_bytes_remaining -= (uint16_t)cbytes;
1871 cfdata->unconsumed -= cbytes;
1873 cbytes = cfdata->uncompressed_avail - cfdata->read_offset;
1875 if (consumed_bytes < cbytes)
1876 cbytes = consumed_bytes;
1878 cfdata->read_offset += (uint16_t)cbytes;
1879 cfdata->uncompressed_bytes_remaining -= (uint16_t)cbytes;
1882 if (cfdata->unconsumed) {
1883 cbytes = cfdata->unconsumed;
1884 cfdata->unconsumed = 0;
1889 /* Compute the sum. */
1890 cab_checksum_update(a, (size_t)cbytes);
1892 /* Consume as much as the compressor actually used. */
1893 __archive_read_consume(a, cbytes);
1894 cab->cab_offset += cbytes;
1895 cfdata->compressed_bytes_remaining -= (uint16_t)cbytes;
1896 if (cfdata->compressed_bytes_remaining == 0) {
1897 err = cab_checksum_finish(a);
1906 * Returns ARCHIVE_OK if successful, ARCHIVE_FATAL otherwise, sets
1907 * cab->end_of_entry if it consumes all of the data.
1910 cab_read_data(struct archive_read *a, const void **buff,
1911 size_t *size, int64_t *offset)
1913 struct cab *cab = (struct cab *)(a->format->data);
1914 ssize_t bytes_avail;
1916 if (cab->entry_bytes_remaining == 0) {
1919 *offset = cab->entry_offset;
1920 cab->end_of_entry = 1;
1921 return (ARCHIVE_OK);
1924 *buff = cab_read_ahead_cfdata(a, &bytes_avail);
1925 if (bytes_avail <= 0) {
1929 if (bytes_avail == 0 &&
1930 cab->entry_cfdata->uncompressed_size == 0) {
1931 /* All of CFDATA in a folder has been handled. */
1932 archive_set_error(&a->archive,
1933 ARCHIVE_ERRNO_FILE_FORMAT, "Invalid CFDATA");
1934 return (ARCHIVE_FATAL);
1936 return ((int)bytes_avail);
1938 if (bytes_avail > cab->entry_bytes_remaining)
1939 bytes_avail = (ssize_t)cab->entry_bytes_remaining;
1941 *size = bytes_avail;
1942 *offset = cab->entry_offset;
1943 cab->entry_offset += bytes_avail;
1944 cab->entry_bytes_remaining -= bytes_avail;
1945 if (cab->entry_bytes_remaining == 0)
1946 cab->end_of_entry = 1;
1947 cab->entry_unconsumed = bytes_avail;
1948 if (cab->entry_cffolder->comptype == COMPTYPE_NONE) {
1949 /* Don't consume more than current entry used. */
1950 if (cab->entry_cfdata->unconsumed > cab->entry_unconsumed)
1951 cab->entry_cfdata->unconsumed = cab->entry_unconsumed;
1953 return (ARCHIVE_OK);
1957 archive_read_format_cab_read_data_skip(struct archive_read *a)
1960 int64_t bytes_skipped;
1963 cab = (struct cab *)(a->format->data);
1965 if (cab->end_of_archive)
1966 return (ARCHIVE_EOF);
1968 if (!cab->read_data_invoked) {
1969 cab->bytes_skipped += cab->entry_bytes_remaining;
1970 cab->entry_bytes_remaining = 0;
1971 /* This entry is finished and done. */
1972 cab->end_of_entry_cleanup = cab->end_of_entry = 1;
1973 return (ARCHIVE_OK);
1976 if (cab->entry_unconsumed) {
1977 /* Consume as much as the compressor actually used. */
1978 r = (int)cab_consume_cfdata(a, cab->entry_unconsumed);
1979 cab->entry_unconsumed = 0;
1982 } else if (cab->entry_cfdata == NULL) {
1983 r = cab_next_cfdata(a);
1988 /* if we've already read to end of data, we're done. */
1989 if (cab->end_of_entry_cleanup)
1990 return (ARCHIVE_OK);
1993 * If the length is at the beginning, we can skip the
1994 * compressed data much more quickly.
1996 bytes_skipped = cab_consume_cfdata(a, cab->entry_bytes_remaining);
1997 if (bytes_skipped < 0)
1998 return (ARCHIVE_FATAL);
2000 /* If the compression type is none(uncompressed), we've already
2001 * consumed data as much as the current entry size. */
2002 if (cab->entry_cffolder->comptype == COMPTYPE_NONE &&
2003 cab->entry_cfdata != NULL)
2004 cab->entry_cfdata->unconsumed = 0;
2006 /* This entry is finished and done. */
2007 cab->end_of_entry_cleanup = cab->end_of_entry = 1;
2008 return (ARCHIVE_OK);
2012 archive_read_format_cab_cleanup(struct archive_read *a)
2014 struct cab *cab = (struct cab *)(a->format->data);
2015 struct cfheader *hd = &cab->cfheader;
2018 if (hd->folder_array != NULL) {
2019 for (i = 0; i < hd->folder_count; i++)
2020 free(hd->folder_array[i].cfdata.memimage);
2021 free(hd->folder_array);
2023 if (hd->file_array != NULL) {
2024 for (i = 0; i < cab->cfheader.file_count; i++)
2025 archive_string_free(&(hd->file_array[i].pathname));
2026 free(hd->file_array);
2029 if (cab->stream_valid)
2030 inflateEnd(&cab->stream);
2032 lzx_decode_free(&cab->xstrm);
2033 archive_wstring_free(&cab->ws);
2034 free(cab->uncompressed_buffer);
2036 (a->format->data) = NULL;
2037 return (ARCHIVE_OK);
2040 /* Convert an MSDOS-style date/time into Unix-style time. */
2042 cab_dos_time(const unsigned char *p)
2047 msDate = archive_le16dec(p);
2048 msTime = archive_le16dec(p+2);
2050 memset(&ts, 0, sizeof(ts));
2051 ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
2052 ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
2053 ts.tm_mday = msDate & 0x1f; /* Day of month. */
2054 ts.tm_hour = (msTime >> 11) & 0x1f;
2055 ts.tm_min = (msTime >> 5) & 0x3f;
2056 ts.tm_sec = (msTime << 1) & 0x3e;
2058 return (mktime(&ts));
2061 /*****************************************************************
2063 * LZX decompression code.
2065 *****************************************************************/
2068 * Initialize LZX decoder.
2070 * Returns ARCHIVE_OK if initialization was successful.
2071 * Returns ARCHIVE_FAILED if w_bits has unsupported value.
2072 * Returns ARCHIVE_FATAL if initialization failed; memory allocation
2076 lzx_decode_init(struct lzx_stream *strm, int w_bits)
2079 int slot, w_size, w_slot;
2083 if (strm->ds == NULL) {
2084 strm->ds = calloc(1, sizeof(*strm->ds));
2085 if (strm->ds == NULL)
2086 return (ARCHIVE_FATAL);
2089 ds->error = ARCHIVE_FAILED;
2091 /* Allow bits from 15(32KBi) up to 21(2MBi) */
2092 if (w_bits < SLOT_BASE || w_bits > SLOT_MAX)
2093 return (ARCHIVE_FAILED);
2095 ds->error = ARCHIVE_FATAL;
2100 w_size = ds->w_size;
2101 w_slot = slots[w_bits - SLOT_BASE];
2102 ds->w_size = 1U << w_bits;
2103 ds->w_mask = ds->w_size -1;
2104 if (ds->w_buff == NULL || w_size != ds->w_size) {
2106 ds->w_buff = malloc(ds->w_size);
2107 if (ds->w_buff == NULL)
2108 return (ARCHIVE_FATAL);
2110 ds->pos_tbl = malloc(sizeof(ds->pos_tbl[0]) * w_slot);
2111 if (ds->pos_tbl == NULL)
2112 return (ARCHIVE_FATAL);
2113 lzx_huffman_free(&(ds->mt));
2116 for (footer = 0; footer < 18; footer++)
2117 base_inc[footer] = 1 << footer;
2119 for (slot = 0; slot < w_slot; slot++) {
2124 base += base_inc[footer];
2127 for (n = base; n; n >>= 1)
2132 ds->pos_tbl[slot].base = base;
2133 ds->pos_tbl[slot].footer_bits = footer;
2138 ds->br.cache_buffer = 0;
2139 ds->br.cache_avail = 0;
2140 ds->r0 = ds->r1 = ds->r2 = 1;
2142 /* Initialize aligned offset tree. */
2143 if (lzx_huffman_init(&(ds->at), 8, 8) != ARCHIVE_OK)
2144 return (ARCHIVE_FATAL);
2146 /* Initialize pre-tree. */
2147 if (lzx_huffman_init(&(ds->pt), 20, 10) != ARCHIVE_OK)
2148 return (ARCHIVE_FATAL);
2150 /* Initialize Main tree. */
2151 if (lzx_huffman_init(&(ds->mt), 256+(w_slot<<3), 16)
2153 return (ARCHIVE_FATAL);
2155 /* Initialize Length tree. */
2156 if (lzx_huffman_init(&(ds->lt), 249, 16) != ARCHIVE_OK)
2157 return (ARCHIVE_FATAL);
2161 return (ARCHIVE_OK);
2165 * Release LZX decoder.
2168 lzx_decode_free(struct lzx_stream *strm)
2171 if (strm->ds == NULL)
2173 free(strm->ds->w_buff);
2174 free(strm->ds->pos_tbl);
2175 lzx_huffman_free(&(strm->ds->at));
2176 lzx_huffman_free(&(strm->ds->pt));
2177 lzx_huffman_free(&(strm->ds->mt));
2178 lzx_huffman_free(&(strm->ds->lt));
2184 * E8 Call Translation reversal.
2187 lzx_translation(struct lzx_stream *strm, void *p, size_t size, uint32_t offset)
2189 struct lzx_dec *ds = strm->ds;
2190 unsigned char *b, *end;
2192 if (!ds->translation || size <= 10)
2195 end = b + size - 10;
2196 while (b < end && (b = memchr(b, 0xE8, end - b)) != NULL) {
2197 size_t i = b - (unsigned char *)p;
2198 int32_t cp, displacement, value;
2200 cp = (int32_t)(offset + (uint32_t)i);
2201 value = archive_le32dec(&b[1]);
2202 if (value >= -cp && value < (int32_t)ds->translation_size) {
2204 displacement = value - cp;
2206 displacement = value + ds->translation_size;
2207 archive_le32enc(&b[1], (uint32_t)displacement);
2214 * Bit stream reader.
2216 /* Check that the cache buffer has enough bits. */
2217 #define lzx_br_has(br, n) ((br)->cache_avail >= n)
2218 /* Get compressed data by bit. */
2219 #define lzx_br_bits(br, n) \
2220 (((uint32_t)((br)->cache_buffer >> \
2221 ((br)->cache_avail - (n)))) & cache_masks[n])
2222 #define lzx_br_bits_forced(br, n) \
2223 (((uint32_t)((br)->cache_buffer << \
2224 ((n) - (br)->cache_avail))) & cache_masks[n])
2225 /* Read ahead to make sure the cache buffer has enough compressed data we
2227 * True : completed, there is enough data in the cache buffer.
2228 * False : we met that strm->next_in is empty, we have to get following
2230 #define lzx_br_read_ahead_0(strm, br, n) \
2231 (lzx_br_has((br), (n)) || lzx_br_fillup(strm, br))
2232 /* True : the cache buffer has some bits as much as we need.
2233 * False : there are no enough bits in the cache buffer to be used,
2234 * we have to get following bytes if we could. */
2235 #define lzx_br_read_ahead(strm, br, n) \
2236 (lzx_br_read_ahead_0((strm), (br), (n)) || lzx_br_has((br), (n)))
2238 /* Notify how many bits we consumed. */
2239 #define lzx_br_consume(br, n) ((br)->cache_avail -= (n))
2240 #define lzx_br_consume_unaligned_bits(br) ((br)->cache_avail &= ~0x0f)
2242 #define lzx_br_is_unaligned(br) ((br)->cache_avail & 0x0f)
2244 static const uint32_t cache_masks[] = {
2245 0x00000000, 0x00000001, 0x00000003, 0x00000007,
2246 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
2247 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
2248 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
2249 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
2250 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
2251 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
2252 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
2253 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
2257 * Shift away used bits in the cache data and fill it up with following bits.
2258 * Call this when cache buffer does not have enough bits you need.
2260 * Returns 1 if the cache buffer is full.
2261 * Returns 0 if the cache buffer is not full; input buffer is empty.
2264 lzx_br_fillup(struct lzx_stream *strm, struct lzx_br *br)
2267 * x86 processor family can read misaligned data without an access error.
2269 int n = CACHE_BITS - br->cache_avail;
2274 if (strm->avail_in >= 8) {
2276 ((uint64_t)strm->next_in[1]) << 56 |
2277 ((uint64_t)strm->next_in[0]) << 48 |
2278 ((uint64_t)strm->next_in[3]) << 40 |
2279 ((uint64_t)strm->next_in[2]) << 32 |
2280 ((uint32_t)strm->next_in[5]) << 24 |
2281 ((uint32_t)strm->next_in[4]) << 16 |
2282 ((uint32_t)strm->next_in[7]) << 8 |
2283 (uint32_t)strm->next_in[6];
2285 strm->avail_in -= 8;
2286 br->cache_avail += 8 * 8;
2291 if (strm->avail_in >= 6) {
2293 (br->cache_buffer << 48) |
2294 ((uint64_t)strm->next_in[1]) << 40 |
2295 ((uint64_t)strm->next_in[0]) << 32 |
2296 ((uint32_t)strm->next_in[3]) << 24 |
2297 ((uint32_t)strm->next_in[2]) << 16 |
2298 ((uint32_t)strm->next_in[5]) << 8 |
2299 (uint32_t)strm->next_in[4];
2301 strm->avail_in -= 6;
2302 br->cache_avail += 6 * 8;
2307 /* We have enough compressed data in
2308 * the cache buffer.*/
2313 if (strm->avail_in < 2) {
2314 /* There is not enough compressed data to
2315 * fill up the cache buffer. */
2316 if (strm->avail_in == 1) {
2317 br->odd = *strm->next_in++;
2324 (br->cache_buffer << 16) |
2325 archive_le16dec(strm->next_in);
2327 strm->avail_in -= 2;
2328 br->cache_avail += 16;
2334 lzx_br_fixup(struct lzx_stream *strm, struct lzx_br *br)
2336 int n = CACHE_BITS - br->cache_avail;
2338 if (br->have_odd && n >= 16 && strm->avail_in > 0) {
2340 (br->cache_buffer << 16) |
2341 ((uint16_t)(*strm->next_in)) << 8 | br->odd;
2344 br->cache_avail += 16;
2350 lzx_cleanup_bitstream(struct lzx_stream *strm)
2352 strm->ds->br.cache_avail = 0;
2353 strm->ds->br.have_odd = 0;
2359 * 1. Returns ARCHIVE_OK if output buffer or input buffer are empty.
2360 * Please set available buffer and call this function again.
2361 * 2. Returns ARCHIVE_EOF if decompression has been completed.
2362 * 3. Returns ARCHIVE_FAILED if an error occurred; compressed data
2363 * is broken or you do not set 'last' flag properly.
2365 #define ST_RD_TRANSLATION 0
2366 #define ST_RD_TRANSLATION_SIZE 1
2367 #define ST_RD_BLOCK_TYPE 2
2368 #define ST_RD_BLOCK_SIZE 3
2369 #define ST_RD_ALIGNMENT 4
2373 #define ST_COPY_UNCOMP1 8
2374 #define ST_COPY_UNCOMP2 9
2375 #define ST_RD_ALIGNED_OFFSET 10
2376 #define ST_RD_VERBATIM 11
2377 #define ST_RD_PRE_MAIN_TREE_256 12
2378 #define ST_MAIN_TREE_256 13
2379 #define ST_RD_PRE_MAIN_TREE_REM 14
2380 #define ST_MAIN_TREE_REM 15
2381 #define ST_RD_PRE_LENGTH_TREE 16
2382 #define ST_LENGTH_TREE 17
2384 #define ST_LENGTH 19
2385 #define ST_OFFSET 20
2386 #define ST_REAL_POS 21
2390 lzx_decode(struct lzx_stream *strm, int last)
2392 struct lzx_dec *ds = strm->ds;
2399 avail_in = strm->avail_in;
2400 lzx_br_fixup(strm, &(ds->br));
2402 if (ds->state < ST_MAIN)
2403 r = lzx_read_blocks(strm, last);
2405 int64_t bytes_written = strm->avail_out;
2406 r = lzx_decode_blocks(strm, last);
2407 bytes_written -= strm->avail_out;
2408 strm->next_out += bytes_written;
2409 strm->total_out += bytes_written;
2412 strm->total_in += avail_in - strm->avail_in;
2417 lzx_read_blocks(struct lzx_stream *strm, int last)
2419 struct lzx_dec *ds = strm->ds;
2420 struct lzx_br *br = &(ds->br);
2424 switch (ds->state) {
2425 case ST_RD_TRANSLATION:
2426 if (!lzx_br_read_ahead(strm, br, 1)) {
2427 ds->state = ST_RD_TRANSLATION;
2430 return (ARCHIVE_OK);
2432 ds->translation = lzx_br_bits(br, 1);
2433 lzx_br_consume(br, 1);
2435 case ST_RD_TRANSLATION_SIZE:
2436 if (ds->translation) {
2437 if (!lzx_br_read_ahead(strm, br, 32)) {
2438 ds->state = ST_RD_TRANSLATION_SIZE;
2441 return (ARCHIVE_OK);
2443 ds->translation_size = lzx_br_bits(br, 16);
2444 lzx_br_consume(br, 16);
2445 ds->translation_size <<= 16;
2446 ds->translation_size |= lzx_br_bits(br, 16);
2447 lzx_br_consume(br, 16);
2450 case ST_RD_BLOCK_TYPE:
2451 if (!lzx_br_read_ahead(strm, br, 3)) {
2452 ds->state = ST_RD_BLOCK_TYPE;
2455 return (ARCHIVE_OK);
2457 ds->block_type = lzx_br_bits(br, 3);
2458 lzx_br_consume(br, 3);
2459 /* Check a block type. */
2460 switch (ds->block_type) {
2461 case VERBATIM_BLOCK:
2462 case ALIGNED_OFFSET_BLOCK:
2463 case UNCOMPRESSED_BLOCK:
2466 goto failed;/* Invalid */
2469 case ST_RD_BLOCK_SIZE:
2470 if (!lzx_br_read_ahead(strm, br, 24)) {
2471 ds->state = ST_RD_BLOCK_SIZE;
2474 return (ARCHIVE_OK);
2476 ds->block_size = lzx_br_bits(br, 8);
2477 lzx_br_consume(br, 8);
2478 ds->block_size <<= 16;
2479 ds->block_size |= lzx_br_bits(br, 16);
2480 lzx_br_consume(br, 16);
2481 if (ds->block_size == 0)
2483 ds->block_bytes_avail = ds->block_size;
2484 if (ds->block_type != UNCOMPRESSED_BLOCK) {
2485 if (ds->block_type == VERBATIM_BLOCK)
2486 ds->state = ST_RD_VERBATIM;
2488 ds->state = ST_RD_ALIGNED_OFFSET;
2492 case ST_RD_ALIGNMENT:
2494 * Handle an Uncompressed Block.
2496 /* Skip padding to align following field on
2497 * 16-bit boundary. */
2498 if (lzx_br_is_unaligned(br))
2499 lzx_br_consume_unaligned_bits(br);
2501 if (lzx_br_read_ahead(strm, br, 16))
2502 lzx_br_consume(br, 16);
2504 ds->state = ST_RD_ALIGNMENT;
2507 return (ARCHIVE_OK);
2510 /* Preparation to read repeated offsets R0,R1 and R2. */
2511 ds->rbytes_avail = 0;
2512 ds->state = ST_RD_R0;
2519 /* Drain bits in the cache buffer of
2521 if (lzx_br_has(br, 32)) {
2522 u16 = lzx_br_bits(br, 16);
2523 lzx_br_consume(br, 16);
2524 archive_le16enc(ds->rbytes, u16);
2525 u16 = lzx_br_bits(br, 16);
2526 lzx_br_consume(br, 16);
2527 archive_le16enc(ds->rbytes+2, u16);
2528 ds->rbytes_avail = 4;
2529 } else if (lzx_br_has(br, 16)) {
2530 u16 = lzx_br_bits(br, 16);
2531 lzx_br_consume(br, 16);
2532 archive_le16enc(ds->rbytes, u16);
2533 ds->rbytes_avail = 2;
2535 if (ds->rbytes_avail < 4 && ds->br.have_odd) {
2536 ds->rbytes[ds->rbytes_avail++] =
2538 ds->br.have_odd = 0;
2540 while (ds->rbytes_avail < 4) {
2541 if (strm->avail_in <= 0) {
2544 return (ARCHIVE_OK);
2546 ds->rbytes[ds->rbytes_avail++] =
2550 ds->rbytes_avail = 0;
2551 if (ds->state == ST_RD_R0) {
2552 ds->r0 = archive_le32dec(ds->rbytes);
2555 ds->state = ST_RD_R1;
2556 } else if (ds->state == ST_RD_R1) {
2557 ds->r1 = archive_le32dec(ds->rbytes);
2560 ds->state = ST_RD_R2;
2561 } else if (ds->state == ST_RD_R2) {
2562 ds->r2 = archive_le32dec(ds->rbytes);
2565 /* We've gotten all repeated offsets. */
2566 ds->state = ST_COPY_UNCOMP1;
2568 } while (ds->state != ST_COPY_UNCOMP1);
2570 case ST_COPY_UNCOMP1:
2572 * Copy bytes form next_in to next_out directly.
2574 while (ds->block_bytes_avail) {
2577 if (strm->avail_out <= 0)
2578 /* Output buffer is empty. */
2579 return (ARCHIVE_OK);
2580 if (strm->avail_in <= 0) {
2581 /* Input buffer is empty. */
2584 return (ARCHIVE_OK);
2586 l = (int)ds->block_bytes_avail;
2587 if (l > ds->w_size - ds->w_pos)
2588 l = ds->w_size - ds->w_pos;
2589 if (l > strm->avail_out)
2590 l = (int)strm->avail_out;
2591 if (l > strm->avail_in)
2592 l = (int)strm->avail_in;
2593 memcpy(strm->next_out, strm->next_in, l);
2594 memcpy(&(ds->w_buff[ds->w_pos]),
2597 strm->avail_in -= l;
2598 strm->next_out += l;
2599 strm->avail_out -= l;
2600 strm->total_out += l;
2601 ds->w_pos = (ds->w_pos + l) & ds->w_mask;
2602 ds->block_bytes_avail -= l;
2605 case ST_COPY_UNCOMP2:
2606 /* Re-align; skip padding byte. */
2607 if (ds->block_size & 1) {
2608 if (strm->avail_in <= 0) {
2609 /* Input buffer is empty. */
2610 ds->state = ST_COPY_UNCOMP2;
2613 return (ARCHIVE_OK);
2618 /* This block ended. */
2619 ds->state = ST_RD_BLOCK_TYPE;
2620 return (ARCHIVE_EOF);
2621 /********************/
2622 case ST_RD_ALIGNED_OFFSET:
2624 * Read Aligned offset tree.
2626 if (!lzx_br_read_ahead(strm, br, 3 * ds->at.len_size)) {
2627 ds->state = ST_RD_ALIGNED_OFFSET;
2630 return (ARCHIVE_OK);
2632 memset(ds->at.freq, 0, sizeof(ds->at.freq));
2633 for (i = 0; i < ds->at.len_size; i++) {
2634 ds->at.bitlen[i] = lzx_br_bits(br, 3);
2635 ds->at.freq[ds->at.bitlen[i]]++;
2636 lzx_br_consume(br, 3);
2638 if (!lzx_make_huffman_table(&ds->at))
2641 case ST_RD_VERBATIM:
2644 case ST_RD_PRE_MAIN_TREE_256:
2646 * Read Pre-tree for first 256 elements of main tree.
2648 if (!lzx_read_pre_tree(strm)) {
2649 ds->state = ST_RD_PRE_MAIN_TREE_256;
2652 return (ARCHIVE_OK);
2654 if (!lzx_make_huffman_table(&ds->pt))
2658 case ST_MAIN_TREE_256:
2660 * Get path lengths of first 256 elements of main tree.
2662 r = lzx_read_bitlen(strm, &ds->mt, 256);
2666 ds->state = ST_MAIN_TREE_256;
2669 return (ARCHIVE_OK);
2673 case ST_RD_PRE_MAIN_TREE_REM:
2675 * Read Pre-tree for remaining elements of main tree.
2677 if (!lzx_read_pre_tree(strm)) {
2678 ds->state = ST_RD_PRE_MAIN_TREE_REM;
2681 return (ARCHIVE_OK);
2683 if (!lzx_make_huffman_table(&ds->pt))
2687 case ST_MAIN_TREE_REM:
2689 * Get path lengths of remaining elements of main tree.
2691 r = lzx_read_bitlen(strm, &ds->mt, -1);
2695 ds->state = ST_MAIN_TREE_REM;
2698 return (ARCHIVE_OK);
2700 if (!lzx_make_huffman_table(&ds->mt))
2704 case ST_RD_PRE_LENGTH_TREE:
2706 * Read Pre-tree for remaining elements of main tree.
2708 if (!lzx_read_pre_tree(strm)) {
2709 ds->state = ST_RD_PRE_LENGTH_TREE;
2712 return (ARCHIVE_OK);
2714 if (!lzx_make_huffman_table(&ds->pt))
2718 case ST_LENGTH_TREE:
2720 * Get path lengths of remaining elements of main tree.
2722 r = lzx_read_bitlen(strm, &ds->lt, -1);
2726 ds->state = ST_LENGTH_TREE;
2729 return (ARCHIVE_OK);
2731 if (!lzx_make_huffman_table(&ds->lt))
2733 ds->state = ST_MAIN;
2738 return (ds->error = ARCHIVE_FAILED);
2742 lzx_decode_blocks(struct lzx_stream *strm, int last)
2744 struct lzx_dec *ds = strm->ds;
2745 struct lzx_br bre = ds->br;
2746 struct huffman *at = &(ds->at), *lt = &(ds->lt), *mt = &(ds->mt);
2747 const struct lzx_pos_tbl *pos_tbl = ds->pos_tbl;
2748 unsigned char *noutp = strm->next_out;
2749 unsigned char *endp = noutp + strm->avail_out;
2750 unsigned char *w_buff = ds->w_buff;
2751 unsigned char *at_bitlen = at->bitlen;
2752 unsigned char *lt_bitlen = lt->bitlen;
2753 unsigned char *mt_bitlen = mt->bitlen;
2754 size_t block_bytes_avail = ds->block_bytes_avail;
2755 int at_max_bits = at->max_bits;
2756 int lt_max_bits = lt->max_bits;
2757 int mt_max_bits = mt->max_bits;
2758 int c, copy_len = ds->copy_len, copy_pos = ds->copy_pos;
2759 int w_pos = ds->w_pos, w_mask = ds->w_mask, w_size = ds->w_size;
2760 int length_header = ds->length_header;
2761 int offset_bits = ds->offset_bits;
2762 int position_slot = ds->position_slot;
2763 int r0 = ds->r0, r1 = ds->r1, r2 = ds->r2;
2764 int state = ds->state;
2765 char block_type = ds->block_type;
2771 if (block_bytes_avail == 0) {
2772 /* This block ended. */
2773 ds->state = ST_RD_BLOCK_TYPE;
2775 ds->block_bytes_avail =
2777 ds->copy_len = copy_len;
2778 ds->copy_pos = copy_pos;
2779 ds->length_header = length_header;
2780 ds->position_slot = position_slot;
2781 ds->r0 = r0; ds->r1 = r1; ds->r2 = r2;
2783 strm->avail_out = endp - noutp;
2784 return (ARCHIVE_EOF);
2787 /* Output buffer is empty. */
2790 if (!lzx_br_read_ahead(strm, &bre,
2794 /* Remaining bits are less than
2795 * maximum bits(mt.max_bits) but maybe
2796 * it still remains as much as we need,
2797 * so we should try to use it with
2799 c = lzx_decode_huffman(mt,
2801 &bre, mt_max_bits));
2802 lzx_br_consume(&bre, mt_bitlen[c]);
2803 if (!lzx_br_has(&bre, 0))
2804 goto failed;/* Over read. */
2806 c = lzx_decode_huffman(mt,
2807 lzx_br_bits(&bre, mt_max_bits));
2808 lzx_br_consume(&bre, mt_bitlen[c]);
2813 * 'c' is exactly literal code.
2815 /* Save a decoded code to reference it
2818 w_pos = (w_pos + 1) & w_mask;
2819 /* Store the decoded code to output buffer. */
2821 block_bytes_avail--;
2824 * Get a match code, its length and offset.
2827 length_header = c & 7;
2828 position_slot = c >> 3;
2834 if (length_header == 7) {
2835 if (!lzx_br_read_ahead(strm, &bre,
2841 c = lzx_decode_huffman(lt,
2843 &bre, lt_max_bits));
2844 lzx_br_consume(&bre, lt_bitlen[c]);
2845 if (!lzx_br_has(&bre, 0))
2846 goto failed;/* Over read. */
2848 c = lzx_decode_huffman(lt,
2849 lzx_br_bits(&bre, lt_max_bits));
2850 lzx_br_consume(&bre, lt_bitlen[c]);
2852 copy_len = c + 7 + 2;
2854 copy_len = length_header + 2;
2855 if ((size_t)copy_len > block_bytes_avail)
2860 switch (position_slot) {
2861 case 0: /* Use repeated offset 0. */
2863 state = ST_REAL_POS;
2865 case 1: /* Use repeated offset 1. */
2867 /* Swap repeated offset. */
2870 state = ST_REAL_POS;
2872 case 2: /* Use repeated offset 2. */
2874 /* Swap repeated offset. */
2877 state = ST_REAL_POS;
2881 pos_tbl[position_slot].footer_bits;
2887 * Get the offset, which is a distance from
2888 * current window position.
2890 if (block_type == ALIGNED_OFFSET_BLOCK &&
2892 int offbits = offset_bits - 3;
2894 if (!lzx_br_read_ahead(strm, &bre, offbits)) {
2900 copy_pos = lzx_br_bits(&bre, offbits) << 3;
2902 /* Get an aligned number. */
2903 if (!lzx_br_read_ahead(strm, &bre,
2904 offbits + at_max_bits)) {
2909 lzx_br_consume(&bre, offbits);
2910 c = lzx_decode_huffman(at,
2911 lzx_br_bits_forced(&bre,
2913 lzx_br_consume(&bre, at_bitlen[c]);
2914 if (!lzx_br_has(&bre, 0))
2915 goto failed;/* Over read. */
2917 lzx_br_consume(&bre, offbits);
2918 c = lzx_decode_huffman(at,
2919 lzx_br_bits(&bre, at_max_bits));
2920 lzx_br_consume(&bre, at_bitlen[c]);
2922 /* Add an aligned number. */
2925 if (!lzx_br_read_ahead(strm, &bre,
2932 copy_pos = lzx_br_bits(&bre, offset_bits);
2933 lzx_br_consume(&bre, offset_bits);
2935 copy_pos += pos_tbl[position_slot].base -2;
2937 /* Update repeated offset LRU queue. */
2944 * Compute a real position in window.
2946 copy_pos = (w_pos - copy_pos) & w_mask;
2950 * Copy several bytes as extracted data from the window
2951 * into the output buffer.
2954 const unsigned char *s;
2958 if (copy_pos > w_pos) {
2959 if (l > w_size - copy_pos)
2960 l = w_size - copy_pos;
2962 if (l > w_size - w_pos)
2965 if (noutp + l >= endp)
2966 l = (int)(endp - noutp);
2967 s = w_buff + copy_pos;
2968 if (l >= 8 && ((copy_pos + l < w_pos)
2969 || (w_pos + l < copy_pos))) {
2970 memcpy(w_buff + w_pos, s, l);
2971 memcpy(noutp, s, l);
2977 for (li = 0; li < l; li++)
2978 noutp[li] = d[li] = s[li];
2981 copy_pos = (copy_pos + l) & w_mask;
2982 w_pos = (w_pos + l) & w_mask;
2983 block_bytes_avail -= l;
2985 /* A copy of current pattern ended. */
2988 if (noutp >= endp) {
2989 /* Output buffer is empty. */
2999 return (ds->error = ARCHIVE_FAILED);
3002 ds->block_bytes_avail = block_bytes_avail;
3003 ds->copy_len = copy_len;
3004 ds->copy_pos = copy_pos;
3005 ds->length_header = length_header;
3006 ds->offset_bits = offset_bits;
3007 ds->position_slot = position_slot;
3008 ds->r0 = r0; ds->r1 = r1; ds->r2 = r2;
3011 strm->avail_out = endp - noutp;
3012 return (ARCHIVE_OK);
3016 lzx_read_pre_tree(struct lzx_stream *strm)
3018 struct lzx_dec *ds = strm->ds;
3019 struct lzx_br *br = &(ds->br);
3023 memset(ds->pt.freq, 0, sizeof(ds->pt.freq));
3024 for (i = ds->loop; i < ds->pt.len_size; i++) {
3025 if (!lzx_br_read_ahead(strm, br, 4)) {
3029 ds->pt.bitlen[i] = lzx_br_bits(br, 4);
3030 ds->pt.freq[ds->pt.bitlen[i]]++;
3031 lzx_br_consume(br, 4);
3038 * Read a bunch of bit-lengths from pre-tree.
3041 lzx_read_bitlen(struct lzx_stream *strm, struct huffman *d, int end)
3043 struct lzx_dec *ds = strm->ds;
3044 struct lzx_br *br = &(ds->br);
3045 int c, i, j, ret, same;
3050 memset(d->freq, 0, sizeof(d->freq));
3056 if (!lzx_br_read_ahead(strm, br, ds->pt.max_bits))
3058 rbits = lzx_br_bits(br, ds->pt.max_bits);
3059 c = lzx_decode_huffman(&(ds->pt), rbits);
3061 case 17:/* several zero lengths, from 4 to 19. */
3062 if (!lzx_br_read_ahead(strm, br, ds->pt.bitlen[c]+4))
3064 lzx_br_consume(br, ds->pt.bitlen[c]);
3065 same = lzx_br_bits(br, 4) + 4;
3067 return (-1);/* Invalid */
3068 lzx_br_consume(br, 4);
3069 for (j = 0; j < same; j++)
3072 case 18:/* many zero lengths, from 20 to 51. */
3073 if (!lzx_br_read_ahead(strm, br, ds->pt.bitlen[c]+5))
3075 lzx_br_consume(br, ds->pt.bitlen[c]);
3076 same = lzx_br_bits(br, 5) + 20;
3078 return (-1);/* Invalid */
3079 lzx_br_consume(br, 5);
3080 memset(d->bitlen + i, 0, same);
3083 case 19:/* a few same lengths. */
3084 if (!lzx_br_read_ahead(strm, br,
3085 ds->pt.bitlen[c]+1+ds->pt.max_bits))
3087 lzx_br_consume(br, ds->pt.bitlen[c]);
3088 same = lzx_br_bits(br, 1) + 4;
3091 lzx_br_consume(br, 1);
3092 rbits = lzx_br_bits(br, ds->pt.max_bits);
3093 c = lzx_decode_huffman(&(ds->pt), rbits);
3094 lzx_br_consume(br, ds->pt.bitlen[c]);
3095 c = (d->bitlen[i] - c + 17) % 17;
3097 return (-1);/* Invalid */
3098 for (j = 0; j < same; j++)
3103 lzx_br_consume(br, ds->pt.bitlen[c]);
3104 c = (d->bitlen[i] - c + 17) % 17;
3106 return (-1);/* Invalid */
3119 lzx_huffman_init(struct huffman *hf, size_t len_size, int tbl_bits)
3122 if (hf->bitlen == NULL || hf->len_size != (int)len_size) {
3124 hf->bitlen = calloc(len_size, sizeof(hf->bitlen[0]));
3125 if (hf->bitlen == NULL)
3126 return (ARCHIVE_FATAL);
3127 hf->len_size = (int)len_size;
3129 memset(hf->bitlen, 0, len_size * sizeof(hf->bitlen[0]));
3130 if (hf->tbl == NULL) {
3131 hf->tbl = malloc(((size_t)1 << tbl_bits) * sizeof(hf->tbl[0]));
3132 if (hf->tbl == NULL)
3133 return (ARCHIVE_FATAL);
3134 hf->tbl_bits = tbl_bits;
3136 return (ARCHIVE_OK);
3140 lzx_huffman_free(struct huffman *hf)
3147 * Make a huffman coding table.
3150 lzx_make_huffman_table(struct huffman *hf)
3153 const unsigned char *bitlen;
3154 int bitptn[17], weight[17];
3155 int i, maxbits = 0, ptn, tbl_size, w;
3159 * Initialize bit patterns.
3162 for (i = 1, w = 1 << 15; i <= 16; i++, w >>= 1) {
3166 ptn += hf->freq[i] * w;
3170 if ((ptn & 0xffff) != 0 || maxbits > hf->tbl_bits)
3171 return (0);/* Invalid */
3173 hf->max_bits = maxbits;
3176 * Cut out extra bits which we won't house in the table.
3177 * This preparation reduces the same calculation in the for-loop
3181 int ebits = 16 - maxbits;
3182 for (i = 1; i <= maxbits; i++) {
3183 bitptn[i] >>= ebits;
3184 weight[i] >>= ebits;
3191 tbl_size = 1 << hf->tbl_bits;
3193 bitlen = hf->bitlen;
3194 len_avail = hf->len_size;
3196 for (i = 0; i < len_avail; i++) {
3202 /* Get a bit pattern */
3208 /* Calculate next bit pattern */
3209 if ((bitptn[len] = ptn + cnt) > tbl_size)
3210 return (0);/* Invalid */
3211 /* Update the table */
3214 p[cnt] = (uint16_t)i;
3220 lzx_decode_huffman(struct huffman *hf, unsigned rbits)
3224 if (c < hf->len_size)