path: root/src/liblzma/common/metadata_encoder.c

///////////////////////////////////////////////////////////////////////////////
//
/// \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;
}