Update the code to mostly match the new simpler file format

specification. Simplify things by removing most of the
support for known uncompressed size in most places.
There are some miscellaneous changes here and there too.

The API of liblzma has got many changes and still some
more will be done soon. While most of the code has been
updated, some things are not fixed (the command line tool
will choke with invalid filter chain, if nothing else).

Subblock filter is somewhat broken for now. It will be
updated once the encoded format of the Subblock filter
has been decided.

1 files changed, 157 insertions, 254 deletions

diff --git a/tests/test_block_header.c b/tests/test_block_header.c
index b38f4b24..658f7fe2 100644
--- a/tests/test_block_header.c
+++ b/tests/test_block_header.c
@@ -20,204 +20,124 @@
 #include "tests.h"
 
 
-static uint8_t buffer[4096];
-static lzma_stream strm = LZMA_STREAM_INIT;
+static void
+test4(void)
+{
+	known_options = (lzma_options_block){
+		.has_crc32 = false,
+		.has_eopm = true,
+		.is_metadata = false,
+		.compressed_size = 0,
+		.uncompressed_size = 0,
+		.compressed_reserve = LZMA_VLI_BYTES_MAX,
+		.uncompressed_reserve = LZMA_VLI_BYTES_MAX,
+		.padding = 0,
+	};
+	memcpy(known_options.filters, filters_powerpc,
+			sizeof(filters_powerpc));
+	expect(!code(21));
+
+	// Reserved bits
+	buffer[0] ^= 0x40;
+	expect(!decode_ret(1, LZMA_HEADER_ERROR));
+	buffer[0] ^= 0x40;
+
+	buffer[1] ^= 0x40;
+	expect(decode_ret(21, LZMA_HEADER_ERROR));
+	buffer[1] ^= 0x40;
+
+
+}
+*/
+
+static uint8_t buf[LZMA_BLOCK_HEADER_SIZE_MAX];
 static lzma_options_block known_options;
 static lzma_options_block decoded_options;
 
-// We want to test zero, one, and two filters in the chain.
-
-static const lzma_options_filter filters_none[1] = {
+static lzma_options_filter filters_none[1] = {
 	{
 		.id = LZMA_VLI_VALUE_UNKNOWN,
-		.options = NULL,
 	},
 };
 
-static const lzma_options_filter filters_powerpc[2] = {
+
+static lzma_options_filter filters_one[2] = {
 	{
-		.id = LZMA_FILTER_POWERPC,
-		.options = NULL,
+		.id = LZMA_FILTER_LZMA,
+		.options = (void *)(&lzma_preset_lzma[0]),
 	}, {
 		.id = LZMA_VLI_VALUE_UNKNOWN,
-		.options = NULL,
-	},
+	}
 };
 
-static const lzma_options_delta options_delta = {
-	.distance = 4,
-};
 
-static const lzma_options_filter filters_delta[3] = {
+static lzma_options_filter filters_four[5] = {
 	{
-		.id = LZMA_FILTER_DELTA,
-		.options = (void *)(&options_delta),
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
 	}, {
-		.id = LZMA_FILTER_COPY,
+		.id = LZMA_FILTER_X86,
 		.options = NULL,
 	}, {
-		.id = LZMA_VLI_VALUE_UNKNOWN,
+		.id = LZMA_FILTER_X86,
 		.options = NULL,
-	},
+	}, {
+		.id = LZMA_FILTER_LZMA,
+		.options = (void *)(&lzma_preset_lzma[0]),
+	}, {
+		.id = LZMA_VLI_VALUE_UNKNOWN,
+	}
 };
 
 
-static void
-free_decoded_options(void)
-{
-	for (size_t i = 0; i < sizeof(decoded_options.filters)
-			/ sizeof(decoded_options.filters[0]); ++i) {
-		free(decoded_options.filters[i].options);
-		decoded_options.filters[i].options = NULL;
+static lzma_options_filter filters_five[6] = {
+	{
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_X86,
+		.options = NULL,
+	}, {
+		.id = LZMA_FILTER_LZMA,
+		.options = (void *)(&lzma_preset_lzma[0]),
+	}, {
+		.id = LZMA_VLI_VALUE_UNKNOWN,
 	}
-}
-
-
-static bool
-encode(uint32_t header_size)
-{
-	memcrap(buffer, sizeof(buffer));
-
-	if (lzma_block_header_size(&known_options) != LZMA_OK)
-		return true;
-
-	if (known_options.header_size != header_size)
-		return true;
-
-	if (lzma_block_header_encode(buffer, &known_options) != LZMA_OK)
-		return true;
-
-	return false;
-}
+};
 
 
-static bool
-decode_ret(uint32_t header_size, lzma_ret ret_ok)
+static void
+code(void)
 {
-	memcrap(&decoded_options, sizeof(decoded_options));
-	decoded_options.has_crc32 = known_options.has_crc32;
+	expect(lzma_block_header_encode(&known_options, buf) == LZMA_OK);
 
-	expect(lzma_block_header_decoder(&strm, &decoded_options) == LZMA_OK);
-
-	const bool ret = decoder_loop_ret(&strm, buffer, header_size, ret_ok);
-	free_decoded_options();
-	return ret;
-}
-
-
-static bool
-decode(uint32_t header_size)
-{
+	lzma_options_filter filters[LZMA_BLOCK_FILTERS_MAX + 1];
+	memcrap(filters, sizeof(filters));
 	memcrap(&decoded_options, sizeof(decoded_options));
-	decoded_options.has_crc32 = known_options.has_crc32;
-
-	expect(lzma_block_header_decoder(&strm, &decoded_options) == LZMA_OK);
-
-	const bool ret = decoder_loop(&strm, buffer, header_size);
-	free_decoded_options();
-	if (ret)
-		return true;
-
-	if (known_options.has_eopm != decoded_options.has_eopm)
-		return true;
-
-	if (known_options.is_metadata != decoded_options.is_metadata)
-		return true;
 
-	if (known_options.compressed_size == LZMA_VLI_VALUE_UNKNOWN
-			&& known_options.compressed_reserve != 0) {
-		if (decoded_options.compressed_size != 0)
-			return true;
-	} else if (known_options.compressed_size
-			!= decoded_options.compressed_size) {
-		return true;
-	}
-
-	if (known_options.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN
-			&& known_options.uncompressed_reserve != 0) {
-		if (decoded_options.uncompressed_size != 0)
-			return true;
-	} else if (known_options.uncompressed_size
-			!= decoded_options.uncompressed_size) {
-		return true;
-	}
-
-	if (known_options.compressed_reserve != 0
-			&& known_options.compressed_reserve
-				!= decoded_options.compressed_reserve)
-		return true;
-
-	if (known_options.uncompressed_reserve != 0
-			&& known_options.uncompressed_reserve
-				!= decoded_options.uncompressed_reserve)
-		return true;
-
-	if (known_options.padding != decoded_options.padding)
-		return true;
-
-	return false;
-}
-
-
-static bool
-code(uint32_t header_size)
-{
-	return encode(header_size) || decode(header_size);
-}
-
-
-static bool
-helper_loop(uint32_t unpadded_size, uint32_t multiple)
-{
-	for (int i = 0; i <= LZMA_BLOCK_HEADER_PADDING_MAX; ++i) {
-		known_options.padding = i;
-		if (code(unpadded_size + i))
-			return true;
-	}
-
-	for (int i = 0 - LZMA_BLOCK_HEADER_PADDING_MAX - 1;
-			i <= LZMA_BLOCK_HEADER_PADDING_MAX + 1; ++i) {
-		known_options.alignment = i;
-
-		uint32_t size = unpadded_size;
-		while ((size + known_options.alignment) % multiple)
-			++size;
-
-		known_options.padding = LZMA_BLOCK_HEADER_PADDING_AUTO;
-		if (code(size))
-			return true;
-
-	} while (++known_options.alignment
-			<= LZMA_BLOCK_HEADER_PADDING_MAX + 1);
+	decoded_options.header_size = known_options.header_size;
+	decoded_options.check = known_options.check;
+	decoded_options.filters = filters;
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_OK);
 
-	return false;
-}
+	expect(known_options.compressed_size
+			== decoded_options.compressed_size);
+	expect(known_options.uncompressed_size
+			== decoded_options.uncompressed_size);
 
+	for (size_t i = 0; known_options.filters[i].id
+			!= LZMA_VLI_VALUE_UNKNOWN; ++i)
+		expect(known_options.filters[i].id == filters[i].id);
 
-static bool
-helper(uint32_t unpadded_size, uint32_t multiple)
-{
-	known_options.has_crc32 = false;
-	known_options.is_metadata = false;
-	if (helper_loop(unpadded_size, multiple))
-		return true;
-
-	known_options.has_crc32 = false;
-	known_options.is_metadata = true;
-	if (helper_loop(unpadded_size, multiple))
-		return true;
-
-	known_options.has_crc32 = true;
-	known_options.is_metadata = false;
-	if (helper_loop(unpadded_size + 4, multiple))
-		return true;
-
-	known_options.has_crc32 = true;
-	known_options.is_metadata = true;
-	if (helper_loop(unpadded_size + 4, multiple))
-		return true;
-
-	return false;
+	for (size_t i = 0; i < LZMA_BLOCK_FILTERS_MAX; ++i)
+		free(decoded_options.filters[i].options);
 }
 
 
@@ -225,128 +145,114 @@ static void
 test1(void)
 {
 	known_options = (lzma_options_block){
-		.has_eopm = true,
+		.check = LZMA_CHECK_NONE,
 		.compressed_size = LZMA_VLI_VALUE_UNKNOWN,
 		.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
-		.compressed_reserve = 0,
-		.uncompressed_reserve = 0,
+		.filters = NULL,
 	};
-	memcpy(known_options.filters, filters_none, sizeof(filters_none));
-	expect(!helper(2, 1));
-
-	memcpy(known_options.filters, filters_powerpc,
-			sizeof(filters_powerpc));
-	expect(!helper(3, 4));
-
-	memcpy(known_options.filters, filters_delta, sizeof(filters_delta));
-	expect(!helper(5, 1));
 
-	known_options.padding = LZMA_BLOCK_HEADER_PADDING_MAX + 1;
 	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
-}
 
+	known_options.filters = filters_none;
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 
-static void
-test2_helper(uint32_t unpadded_size, uint32_t multiple)
-{
-	known_options.has_eopm = true;
-	known_options.compressed_size = LZMA_VLI_VALUE_UNKNOWN;
-	known_options.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
-	known_options.compressed_reserve = 1;
-	known_options.uncompressed_reserve = 1;
-	expect(!helper(unpadded_size + 2, multiple));
+	known_options.filters = filters_five;
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 
-	known_options.compressed_reserve = LZMA_VLI_BYTES_MAX;
-	known_options.uncompressed_reserve = LZMA_VLI_BYTES_MAX;
-	expect(!helper(unpadded_size + 18, multiple));
+	known_options.filters = filters_one;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
 
-	known_options.compressed_size = 1234;
-	known_options.uncompressed_size = 2345;
-	expect(!helper(unpadded_size + 18, multiple));
+	known_options.check = 999; // Some invalid value, which gets ignored.
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
 
-	known_options.compressed_reserve = 1;
-	known_options.uncompressed_reserve = 1;
+	known_options.compressed_size = 5; // Not a multiple of four.
 	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
-}
 
+	known_options.compressed_size = 0; // Cannot be zero.
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 
-static void
-test2(void)
-{
-	memcpy(known_options.filters, filters_none, sizeof(filters_none));
-	test2_helper(2, 1);
-
-	memcpy(known_options.filters, filters_powerpc,
-			sizeof(filters_powerpc));
-	test2_helper(3, 4);
+	known_options.compressed_size = LZMA_VLI_VALUE_UNKNOWN;
+	known_options.uncompressed_size = 0;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
 
-	memcpy(known_options.filters, filters_delta,
-			sizeof(filters_delta));
-	test2_helper(5, 1);
+	known_options.uncompressed_size = LZMA_VLI_VALUE_MAX + 1;
+	expect(lzma_block_header_size(&known_options) == LZMA_PROG_ERROR);
 }
 
 
 static void
-test3(void)
+test2(void)
 {
 	known_options = (lzma_options_block){
-		.has_crc32 = false,
-		.has_eopm = true,
-		.is_metadata = false,
+		.check = LZMA_CHECK_CRC32,
 		.compressed_size = LZMA_VLI_VALUE_UNKNOWN,
 		.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
-		.compressed_reserve = 1,
-		.uncompressed_reserve = 1,
+		.filters = filters_four,
 	};
-	memcpy(known_options.filters, filters_none, sizeof(filters_none));
-
-	known_options.header_size = 3;
-	expect(lzma_block_header_encode(buffer, &known_options)
-			== LZMA_PROG_ERROR);
 
-	known_options.header_size = 4;
-	expect(lzma_block_header_encode(buffer, &known_options) == LZMA_OK);
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
+	code();
 
-	known_options.header_size = 5;
-	expect(lzma_block_header_encode(buffer, &known_options)
-			== LZMA_PROG_ERROR);
+	known_options.compressed_size = 123456;
+	known_options.uncompressed_size = 234567;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
+	code();
 
-	// NOTE: This assumes that Filter ID 0x1F is not supported. Update
-	// this test to use some other ID if 0x1F becomes supported.
-	known_options.filters[0].id = 0x1F;
-	known_options.header_size = 5;
-	expect(lzma_block_header_encode(buffer, &known_options)
-			== LZMA_HEADER_ERROR);
+	// We can make the sizes smaller while keeping the header size
+	// the same.
+	known_options.compressed_size = 12;
+	known_options.uncompressed_size = 23;
+	code();
 }
 
 
 static void
-test4(void)
+test3(void)
 {
 	known_options = (lzma_options_block){
-		.has_crc32 = false,
-		.has_eopm = true,
-		.is_metadata = false,
-		.compressed_size = 0,
-		.uncompressed_size = 0,
-		.compressed_reserve = LZMA_VLI_BYTES_MAX,
-		.uncompressed_reserve = LZMA_VLI_BYTES_MAX,
-		.padding = 0,
+		.check = LZMA_CHECK_CRC32,
+		.compressed_size = LZMA_VLI_VALUE_UNKNOWN,
+		.uncompressed_size = LZMA_VLI_VALUE_UNKNOWN,
+		.filters = filters_one,
 	};
-	memcpy(known_options.filters, filters_powerpc,
-			sizeof(filters_powerpc));
-	expect(!code(21));
 
-	// Reserved bits
-	buffer[0] ^= 0x40;
-	expect(!decode_ret(1, LZMA_HEADER_ERROR));
-	buffer[0] ^= 0x40;
+	expect(lzma_block_header_size(&known_options) == LZMA_OK);
+	known_options.header_size += 4;
+	expect(lzma_block_header_encode(&known_options, buf) == LZMA_OK);
 
-	buffer[1] ^= 0x40;
-	expect(decode_ret(21, LZMA_HEADER_ERROR));
-	buffer[1] ^= 0x40;
+	lzma_options_filter filters[LZMA_BLOCK_FILTERS_MAX + 1];
+	decoded_options.header_size = known_options.header_size;
+	decoded_options.check = known_options.check;
+	decoded_options.filters = filters;
 
+	// Wrong size
+	++buf[0];
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_PROG_ERROR);
+	--buf[0];
+
+	// Wrong CRC32
+	buf[known_options.header_size - 1] ^= 1;
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_DATA_ERROR);
+	buf[known_options.header_size - 1] ^= 1;
+
+	// Unsupported filter
+	// NOTE: This may need updating when new IDs become supported.
+	buf[2] ^= 0x1F;
+	integer_write_32(buf + known_options.header_size - 4,
+			lzma_crc32(buf, known_options.header_size - 4, 0));
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_HEADER_ERROR);
+	buf[2] ^= 0x1F;
 
+	// Non-nul Padding
+	buf[known_options.header_size - 4 - 1] ^= 1;
+	integer_write_32(buf + known_options.header_size - 4,
+			lzma_crc32(buf, known_options.header_size - 4, 0));
+	expect(lzma_block_header_decode(&decoded_options, NULL, buf)
+			== LZMA_HEADER_ERROR);
+	buf[known_options.header_size - 4 - 1] ^= 1;
 }
 
 
@@ -358,9 +264,6 @@ main(void)
 	test1();
 	test2();
 	test3();
-	test4();
-
-	lzma_end(&strm);
 
 	return 0;
 }