X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Flzx-decompress.c;h=ec8ccf25159fdc83fee6e85ddce47d64166145fe;hb=5944d11442d5df847c3393951a8563412d16e640;hp=0a4562975159214f238f95179ae1f122f72cad45;hpb=4757f17833c96b8c83a7e17cbc6f374c449d60db;p=wimlib

diff --git a/src/lzx-decompress.c b/src/lzx-decompress.c
index 0a456297..ec8ccf25 100644
--- a/src/lzx-decompress.c
+++ b/src/lzx-decompress.c
@@ -121,9 +121,9 @@
 struct lzx_tables {
 
 	u16 maintree_decode_table[(1 << LZX_MAINCODE_TABLEBITS) +
-					(LZX_MAINCODE_NUM_SYMBOLS * 2)]
+					(LZX_MAINCODE_MAX_NUM_SYMBOLS * 2)]
 					_aligned_attribute(DECODE_TABLE_ALIGNMENT);
-	u8 maintree_lens[LZX_MAINCODE_NUM_SYMBOLS];
+	u8 maintree_lens[LZX_MAINCODE_MAX_NUM_SYMBOLS];
 
 
 	u16 lentree_decode_table[(1 << LZX_LENCODE_TABLEBITS) +
@@ -156,10 +156,11 @@ read_huffsym_using_pretree(struct input_bitstream *istream,
 static inline int
 read_huffsym_using_maintree(struct input_bitstream *istream,
 			    const struct lzx_tables *tables,
-			    unsigned *n)
+			    unsigned *n,
+			    unsigned num_main_syms)
 {
 	return read_huffsym(istream, tables->maintree_decode_table,
-			    tables->maintree_lens, LZX_MAINCODE_NUM_SYMBOLS,
+			    tables->maintree_lens, num_main_syms,
 			    LZX_MAINCODE_TABLEBITS, n, LZX_MAX_MAIN_CODEWORD_LEN);
 }
 
@@ -209,7 +210,7 @@ lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
 					_aligned_attribute(DECODE_TABLE_ALIGNMENT);
 	u8 pretree_lens[LZX_PRECODE_NUM_SYMBOLS];
 	unsigned i;
-	unsigned len;
+	u32 len;
 	int ret;
 
 	/* Read the code lengths of the pretree codes.  There are 20 lengths of
@@ -243,9 +244,9 @@ lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
 		 * the next lengths are all equal to the next symbol in the
 		 * input. */
 		unsigned tree_code;
-		unsigned num_zeroes;
+		u32 num_zeroes;
 		unsigned code;
-		unsigned num_same;
+		u32 num_same;
 		signed char value;
 
 		ret = read_huffsym_using_pretree(istream, pretree_decode_table,
@@ -324,6 +325,8 @@ lzx_read_code_lens(struct input_bitstream *istream, u8 lens[],
  */
 static int
 lzx_read_block_header(struct input_bitstream *istream,
+		      unsigned num_main_syms,
+		      unsigned max_window_size,
 		      unsigned *block_size_ret,
 		      unsigned *block_type_ret,
 		      struct lzx_tables *tables,
@@ -332,32 +335,42 @@ lzx_read_block_header(struct input_bitstream *istream,
 	int ret;
 	unsigned block_type;
 	unsigned block_size;
-	unsigned s;
-	unsigned i;
-	unsigned len;
 
-	ret = bitstream_ensure_bits(istream, LZX_BLOCKTYPE_NBITS + 1);
-	if (ret) {
-		LZX_DEBUG("LZX input stream overrun");
+	ret = bitstream_ensure_bits(istream, 4);
+	if (ret)
 		return ret;
-	}
 
 	/* The first three bits tell us what kind of block it is, and are one
 	 * of the LZX_BLOCKTYPE_* values.  */
-	block_type = bitstream_read_bits_nocheck(istream, LZX_BLOCKTYPE_NBITS);
-
-	/* The next bit indicates whether the block size is the default (32768),
-	 * indicated by a 1 bit, or whether the block size is given by the next
-	 * 16 bits, indicated by a 0 bit. */
-	s = bitstream_read_bits_nocheck(istream, 1);
+	block_type = bitstream_read_bits_nocheck(istream, 3);
 
-	if (s) {
-		block_size = 32768;
+	/* Read the block size.  This mirrors the behavior
+	 * lzx_write_compressed_block() in lzx-compress.c; see that for more
+	 * details.  */
+	if (bitstream_read_bits_nocheck(istream, 1)) {
+		block_size = LZX_DEFAULT_BLOCK_SIZE;
 	} else {
-		ret = bitstream_read_bits(istream, LZX_BLOCKSIZE_NBITS, &block_size);
+		u32 tmp;
+		block_size = 0;
+
+		ret = bitstream_read_bits(istream, 8, &tmp);
+		if (ret)
+			return ret;
+		block_size |= tmp;
+
+		ret = bitstream_read_bits(istream, 8, &tmp);
 		if (ret)
 			return ret;
-		block_size = le16_to_cpu(block_size);
+		block_size <<= 8;
+		block_size |= tmp;
+
+		if (max_window_size >= 65536) {
+			ret = bitstream_read_bits(istream, 8, &tmp);
+			if (ret)
+				return ret;
+			block_size <<= 8;
+			block_size |= tmp;
+		}
 	}
 
 	switch (block_type) {
@@ -365,7 +378,9 @@ lzx_read_block_header(struct input_bitstream *istream,
 		/* Read the path lengths for the elements of the aligned tree,
 		 * then build it. */
 
-		for (i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++) {
+		for (unsigned i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++) {
+			u32 len;
+
 			ret = bitstream_read_bits(istream,
 						  LZX_ALIGNEDCODE_ELEMENT_SIZE,
 						  &len);
@@ -408,10 +423,10 @@ lzx_read_block_header(struct input_bitstream *istream,
 		 * tree. */
 		LZX_DEBUG("Reading path lengths for remaining elements of "
 			  "main tree (%d elements).",
-			  LZX_MAINCODE_NUM_SYMBOLS - LZX_NUM_CHARS);
+			  num_main_syms - LZX_NUM_CHARS);
 		ret = lzx_read_code_lens(istream,
 					 tables->maintree_lens + LZX_NUM_CHARS,
-					 LZX_MAINCODE_NUM_SYMBOLS - LZX_NUM_CHARS);
+					 num_main_syms - LZX_NUM_CHARS);
 		if (ret) {
 			LZX_DEBUG("Failed to read the path lengths for the "
 				  "remaining elements of the main tree");
@@ -422,7 +437,7 @@ lzx_read_block_header(struct input_bitstream *istream,
 			  "table for the main tree.");
 
 		ret = make_huffman_decode_table(tables->maintree_decode_table,
-						LZX_MAINCODE_NUM_SYMBOLS,
+						num_main_syms,
 						LZX_MAINCODE_TABLEBITS,
 						tables->maintree_lens,
 						LZX_MAX_MAIN_CODEWORD_LEN);
@@ -545,8 +560,8 @@ lzx_decode_match(unsigned main_element, int block_type,
 	unsigned match_offset;
 	unsigned additional_len;
 	unsigned num_extra_bits;
-	unsigned verbatim_bits;
-	unsigned aligned_bits;
+	u32 verbatim_bits;
+	u32 aligned_bits;
 	unsigned i;
 	int ret;
 	u8 *match_dest;
@@ -754,6 +769,7 @@ undo_call_insn_preprocessing(u8 uncompressed_data[], int uncompressed_data_len)
  * @block_type:	The type of the block (LZX_BLOCKTYPE_VERBATIM or
  * 		LZX_BLOCKTYPE_ALIGNED)
  * @block_size:	The size of the block, in bytes.
+ * @num_main_syms:	Number of symbols in the main alphabet.
  * @window:	Pointer to the decompression window.
  * @window_pos:	The current position in the window.  Will be 0 for the first
  * 			block.
@@ -764,6 +780,7 @@ undo_call_insn_preprocessing(u8 uncompressed_data[], int uncompressed_data_len)
  */
 static int
 lzx_decompress_block(int block_type, unsigned block_size,
+		     unsigned num_main_syms,
 		     u8 *window,
 		     unsigned window_pos,
 		     const struct lzx_tables *tables,
@@ -778,7 +795,8 @@ lzx_decompress_block(int block_type, unsigned block_size,
 	end = window_pos + block_size;
 	while (window_pos < end) {
 		ret = read_huffsym_using_maintree(istream, tables,
-						  &main_element);
+						  &main_element,
+						  num_main_syms);
 		if (ret)
 			return ret;
 
@@ -786,7 +804,7 @@ lzx_decompress_block(int block_type, unsigned block_size,
 			/* literal: 0 to LZX_NUM_CHARS - 1 */
 			window[window_pos++] = main_element;
 		} else {
-			/* match: LZX_NUM_CHARS to LZX_MAINCODE_NUM_SYMBOLS - 1 */
+			/* match: LZX_NUM_CHARS to num_main_syms - 1 */
 			match_len = lzx_decode_match(main_element,
 						     block_type,
 						     end - window_pos,
@@ -803,10 +821,10 @@ lzx_decompress_block(int block_type, unsigned block_size,
 	return 0;
 }
 
-/* API function documented in wimlib.h  */
 WIMLIBAPI int
-wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
-		      void *uncompressed_data, unsigned uncompressed_len)
+wimlib_lzx_decompress2(const void *compressed_data, unsigned compressed_len,
+		       void *uncompressed_data, unsigned uncompressed_len,
+		       u32 max_window_size)
 {
 	struct lzx_tables tables;
 	struct input_bitstream istream;
@@ -814,15 +832,30 @@ wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
 	unsigned window_pos;
 	unsigned block_size;
 	unsigned block_type;
+	unsigned num_main_syms;
 	int ret;
 	bool e8_preprocessing_done;
 
-	LZX_DEBUG("lzx_decompress (compressed_data = %p, compressed_len = %d, "
-		  "uncompressed_data = %p, uncompressed_len = %d).",
+	LZX_DEBUG("compressed_data = %p, compressed_len = %u, "
+		  "uncompressed_data = %p, uncompressed_len = %u, "
+		  "max_window_size=%u).",
 		  compressed_data, compressed_len,
-		  uncompressed_data, uncompressed_len);
+		  uncompressed_data, uncompressed_len, max_window_size);
+
+	if (!lzx_window_size_valid(max_window_size)) {
+		LZX_DEBUG("Window size of %u is invalid!",
+			  max_window_size);
+		return -1;
+	}
 
-	wimlib_assert(uncompressed_len <= 32768);
+	num_main_syms = lzx_get_num_main_syms(max_window_size);
+
+	if (uncompressed_len > max_window_size) {
+		LZX_DEBUG("Uncompressed chunk size of %u exceeds "
+			  "window size of %u!",
+			  uncompressed_len, max_window_size);
+		return -1;
+	}
 
 	memset(tables.maintree_lens, 0, sizeof(tables.maintree_lens));
 	memset(tables.lentree_lens, 0, sizeof(tables.lentree_lens));
@@ -842,7 +875,8 @@ wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
 	     window_pos += block_size)
 	{
 		LZX_DEBUG("Reading block header.");
-		ret = lzx_read_block_header(&istream, &block_size,
+		ret = lzx_read_block_header(&istream, num_main_syms,
+					    max_window_size, &block_size,
 					    &block_type, &tables, &queue);
 		if (ret)
 			return ret;
@@ -866,6 +900,7 @@ wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
 				LZX_DEBUG("LZX_BLOCKTYPE_ALIGNED");
 			ret = lzx_decompress_block(block_type,
 						   block_size,
+						   num_main_syms,
 						   uncompressed_data,
 						   window_pos,
 						   &tables,
@@ -873,6 +908,7 @@ wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
 						   &istream);
 			if (ret)
 				return ret;
+
 			if (tables.maintree_lens[0xe8] != 0)
 				e8_preprocessing_done = true;
 			break;
@@ -903,3 +939,13 @@ wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
 		undo_call_insn_preprocessing(uncompressed_data, uncompressed_len);
 	return 0;
 }
+
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_lzx_decompress(const void *compressed_data, unsigned compressed_len,
+		      void *uncompressed_data, unsigned uncompressed_len)
+{
+	return wimlib_lzx_decompress2(compressed_data, compressed_len,
+				      uncompressed_data, uncompressed_len,
+				      32768);
+}