Imported to git.

1 files changed, 436 insertions, 0 deletions

diff --git a/src/liblzma/common/metadata_encoder.c b/src/liblzma/common/metadata_encoder.c
new file mode 100644
index 00000000..17587c5c
--- /dev/null
+++ b/src/liblzma/common/metadata_encoder.c
@@ -0,0 +1,436 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       metadata_encoder.c
+/// \brief      Encodes metadata to be stored into Metadata Blocks
+//
+//  Copyright (C) 2007 Lasse Collin
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "metadata_encoder.h"
+#include "block_encoder.h"
+
+
+struct lzma_coder_s {
+	enum {
+		SEQ_FLAGS,
+		SEQ_HEADER_METADATA_SIZE,
+		SEQ_TOTAL_SIZE,
+		SEQ_UNCOMPRESSED_SIZE,
+		SEQ_INDEX_COUNT,
+		SEQ_INDEX_TOTAL,
+		SEQ_INDEX_UNCOMPRESSED,
+		SEQ_EXTRA_ID,
+		SEQ_EXTRA_SIZE,
+		SEQ_EXTRA_DATA,
+		SEQ_END,
+	} sequence;
+
+	/// Position in variable-length integers
+	size_t pos;
+
+	/// Local copy of the Metadata structure. Note that we keep
+	/// a copy only of the main structure, not Index or Extra Records.
+	lzma_metadata metadata;
+
+	/// Number of Records in Index
+	size_t index_count;
+
+	/// Index Record currently being processed
+	const lzma_index *index_current;
+
+	/// Block encoder for the encoded Metadata
+	lzma_next_coder block_encoder;
+
+	/// True once everything except compression has been done.
+	bool end_was_reached;
+
+	/// buffer[buffer_pos] is the first byte that needs to be compressed.
+	size_t buffer_pos;
+
+	/// buffer[buffer_size] is the next position where a byte will be
+	/// written by process().
+	size_t buffer_size;
+
+	/// Temporary buffer to which encoded Metadata is written before
+	/// it is compressed.
+	uint8_t buffer[LZMA_BUFFER_SIZE];
+};
+
+
+#define write_vli(num) \
+do { \
+	const lzma_ret ret = lzma_vli_encode(num, &coder->pos, 1, \
+			coder->buffer, &coder->buffer_size, \
+			LZMA_BUFFER_SIZE); \
+	if (ret != LZMA_STREAM_END) \
+		return ret; \
+	coder->pos = 0; \
+} while (0)
+
+
+static lzma_ret
+process(lzma_coder *coder)
+{
+	while (coder->buffer_size < LZMA_BUFFER_SIZE)
+	switch (coder->sequence) {
+	case SEQ_FLAGS:
+		coder->buffer[coder->buffer_size] = 0;
+
+		if (coder->metadata.header_metadata_size
+				!= LZMA_VLI_VALUE_UNKNOWN)
+			coder->buffer[coder->buffer_size] |= 0x01;
+
+		if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
+			coder->buffer[coder->buffer_size] |= 0x02;
+
+		if (coder->metadata.uncompressed_size
+				!= LZMA_VLI_VALUE_UNKNOWN)
+			coder->buffer[coder->buffer_size] |= 0x04;
+
+		if (coder->index_count > 0)
+			coder->buffer[coder->buffer_size] |= 0x08;
+
+		if (coder->metadata.extra != NULL)
+			coder->buffer[coder->buffer_size] |= 0x80;
+
+		++coder->buffer_size;
+		coder->sequence = SEQ_HEADER_METADATA_SIZE;
+		break;
+
+	case SEQ_HEADER_METADATA_SIZE:
+		if (coder->metadata.header_metadata_size
+				!= LZMA_VLI_VALUE_UNKNOWN)
+			write_vli(coder->metadata.header_metadata_size);
+
+		coder->sequence = SEQ_TOTAL_SIZE;
+		break;
+
+	case SEQ_TOTAL_SIZE:
+		if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
+			write_vli(coder->metadata.total_size);
+
+		coder->sequence = SEQ_UNCOMPRESSED_SIZE;
+		break;
+
+	case SEQ_UNCOMPRESSED_SIZE:
+		if (coder->metadata.uncompressed_size
+				!= LZMA_VLI_VALUE_UNKNOWN)
+			write_vli(coder->metadata.uncompressed_size);
+
+		coder->sequence = SEQ_INDEX_COUNT;
+		break;
+
+	case SEQ_INDEX_COUNT:
+		if (coder->index_count == 0) {
+			if (coder->metadata.extra == NULL) {
+				coder->sequence = SEQ_END;
+				return LZMA_STREAM_END;
+			}
+
+			coder->sequence = SEQ_EXTRA_ID;
+			break;
+		}
+
+		write_vli(coder->index_count);
+		coder->sequence = SEQ_INDEX_TOTAL;
+		break;
+
+	case SEQ_INDEX_TOTAL:
+		write_vli(coder->index_current->total_size);
+
+		coder->index_current = coder->index_current->next;
+		if (coder->index_current == NULL) {
+			coder->index_current = coder->metadata.index;
+			coder->sequence = SEQ_INDEX_UNCOMPRESSED;
+		}
+
+		break;
+
+	case SEQ_INDEX_UNCOMPRESSED:
+		write_vli(coder->index_current->uncompressed_size);
+
+		coder->index_current = coder->index_current->next;
+		if (coder->index_current != NULL)
+			break;
+
+		if (coder->metadata.extra != NULL) {
+			coder->sequence = SEQ_EXTRA_ID;
+			break;
+		}
+
+		coder->sequence = SEQ_END;
+		return LZMA_STREAM_END;
+
+	case SEQ_EXTRA_ID: {
+		const lzma_ret ret = lzma_vli_encode(
+				coder->metadata.extra->id, &coder->pos, 1,
+				coder->buffer, &coder->buffer_size,
+				LZMA_BUFFER_SIZE);
+		switch (ret) {
+		case LZMA_OK:
+			break;
+
+		case LZMA_STREAM_END:
+			coder->pos = 0;
+
+			// Handle the special ID 0.
+			if (coder->metadata.extra->id == 0) {
+				coder->metadata.extra
+						= coder->metadata.extra->next;
+				if (coder->metadata.extra == NULL) {
+					coder->sequence = SEQ_END;
+					return LZMA_STREAM_END;
+				}
+
+				coder->sequence = SEQ_EXTRA_ID;
+
+			} else {
+				coder->sequence = SEQ_EXTRA_SIZE;
+			}
+
+			break;
+
+		default:
+			return ret;
+		}
+
+		break;
+	}
+
+	case SEQ_EXTRA_SIZE:
+		if (coder->metadata.extra->size >= (lzma_vli)(SIZE_MAX))
+			return LZMA_HEADER_ERROR;
+
+		write_vli(coder->metadata.extra->size);
+		coder->sequence = SEQ_EXTRA_DATA;
+		break;
+
+	case SEQ_EXTRA_DATA:
+		bufcpy(coder->metadata.extra->data, &coder->pos,
+				coder->metadata.extra->size,
+				coder->buffer, &coder->buffer_size,
+				LZMA_BUFFER_SIZE);
+
+		if ((size_t)(coder->metadata.extra->size) == coder->pos) {
+			coder->metadata.extra = coder->metadata.extra->next;
+			if (coder->metadata.extra == NULL) {
+				coder->sequence = SEQ_END;
+				return LZMA_STREAM_END;
+			}
+
+			coder->pos = 0;
+			coder->sequence = SEQ_EXTRA_ID;
+		}
+
+		break;
+
+	case SEQ_END:
+		// Everything is encoded. Let the compression code finish
+		// its work now.
+		return LZMA_STREAM_END;
+	}
+
+	return LZMA_OK;
+}
+
+
+static lzma_ret
+metadata_encode(lzma_coder *coder, lzma_allocator *allocator,
+		const uint8_t *restrict in lzma_attribute((unused)),
+		size_t *restrict in_pos lzma_attribute((unused)),
+		size_t in_size lzma_attribute((unused)), uint8_t *restrict out,
+		size_t *restrict out_pos, size_t out_size,
+		lzma_action action lzma_attribute((unused)))
+{
+	while (!coder->end_was_reached) {
+		// Flush coder->buffer if it isn't empty.
+		if (coder->buffer_size > 0) {
+			const lzma_ret ret = coder->block_encoder.code(
+					coder->block_encoder.coder, allocator,
+					coder->buffer, &coder->buffer_pos,
+					coder->buffer_size,
+					out, out_pos, out_size, LZMA_RUN);
+			if (coder->buffer_pos < coder->buffer_size
+					|| ret != LZMA_OK)
+				return ret;
+
+			coder->buffer_pos = 0;
+			coder->buffer_size = 0;
+		}
+
+		const lzma_ret ret = process(coder);
+
+		switch (ret) {
+		case LZMA_OK:
+			break;
+
+		case LZMA_STREAM_END:
+			coder->end_was_reached = true;
+			break;
+
+		default:
+			return ret;
+		}
+	}
+
+	// Finish
+	return coder->block_encoder.code(coder->block_encoder.coder, allocator,
+			coder->buffer, &coder->buffer_pos, coder->buffer_size,
+			out, out_pos, out_size, LZMA_FINISH);
+}
+
+
+static void
+metadata_encoder_end(lzma_coder *coder, lzma_allocator *allocator)
+{
+	lzma_next_coder_end(&coder->block_encoder, allocator);
+	lzma_free(coder, allocator);
+	return;
+}
+
+
+static lzma_ret
+metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
+		lzma_options_block *options, const lzma_metadata *metadata)
+{
+	if (options == NULL || metadata == NULL)
+		return LZMA_PROG_ERROR;
+
+	if (next->coder == NULL) {
+		next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
+		if (next->coder == NULL)
+			return LZMA_MEM_ERROR;
+
+		next->code = &metadata_encode;
+		next->end = &metadata_encoder_end;
+		next->coder->block_encoder = LZMA_NEXT_CODER_INIT;
+	}
+
+	next->coder->sequence = SEQ_FLAGS;
+	next->coder->pos = 0;
+	next->coder->metadata = *metadata;
+	next->coder->index_count = 0;
+	next->coder->index_current = metadata->index;
+	next->coder->end_was_reached = false;
+	next->coder->buffer_pos = 0;
+	next->coder->buffer_size = 0;
+
+	// Count and validate the Index Records.
+	{
+		const lzma_index *i = metadata->index;
+		while (i != NULL) {
+			if (i->total_size > LZMA_VLI_VALUE_MAX
+					|| i->uncompressed_size
+						> LZMA_VLI_VALUE_MAX)
+				return LZMA_PROG_ERROR;
+
+			++next->coder->index_count;
+			i = i->next;
+		}
+	}
+
+	// Initialize the Block encoder.
+	return lzma_block_encoder_init(
+			&next->coder->block_encoder, allocator, options);
+}
+
+
+extern lzma_ret
+lzma_metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
+		lzma_options_block *options, const lzma_metadata *metadata)
+{
+	lzma_next_coder_init(metadata_encoder_init, next, allocator,
+			options, metadata);
+}
+
+
+extern LZMA_API lzma_ret
+lzma_metadata_encoder(lzma_stream *strm, lzma_options_block *options,
+		const lzma_metadata *metadata)
+{
+	lzma_next_strm_init(strm, metadata_encoder_init, options, metadata);
+
+	strm->internal->supported_actions[LZMA_FINISH] = true;
+
+	return LZMA_OK;
+}
+
+
+extern LZMA_API lzma_vli
+lzma_metadata_size(const lzma_metadata *metadata)
+{
+	lzma_vli size = 1; // Metadata Flags
+
+	// Validate header_metadata_size, total_size, and uncompressed_size.
+	if (!lzma_vli_is_valid(metadata->header_metadata_size)
+			|| !lzma_vli_is_valid(metadata->total_size)
+			|| !lzma_vli_is_valid(metadata->uncompressed_size))
+		return 0;
+
+	// Add the sizes of these three fields.
+	if (metadata->header_metadata_size != LZMA_VLI_VALUE_UNKNOWN)
+		size += lzma_vli_size(metadata->header_metadata_size);
+
+	if (metadata->total_size != LZMA_VLI_VALUE_UNKNOWN)
+		size += lzma_vli_size(metadata->total_size);
+
+	if (metadata->uncompressed_size != LZMA_VLI_VALUE_UNKNOWN)
+		size += lzma_vli_size(metadata->uncompressed_size);
+
+	// Index
+	if (metadata->index != NULL) {
+		const lzma_index *i = metadata->index;
+		size_t count = 1;
+
+		do {
+			const size_t x = lzma_vli_size(i->total_size);
+			const size_t y = lzma_vli_size(i->uncompressed_size);
+			if (x == 0 || y == 0)
+				return 0;
+
+			size += x + y;
+			++count;
+			i = i->next;
+
+		} while (i != NULL);
+
+		const size_t tmp = lzma_vli_size(count);
+		if (tmp == 0)
+			return 0;
+
+		size += tmp;
+	}
+
+	// Extra
+	{
+		const lzma_extra *e = metadata->extra;
+		while (e != NULL) {
+			// Validate the numbers.
+			if (e->id > LZMA_VLI_VALUE_MAX
+					|| e->size >= (lzma_vli)(SIZE_MAX))
+				return 0;
+
+			// Add the sizes.
+			size += lzma_vli_size(e->id);
+			if (e->id != 0) {
+				size += lzma_vli_size(e->size);
+				size += e->size;
+			}
+
+			e = e->next;
+		}
+	}
+
+	return size;
+}