node-liblzma 1.0.4 → 1.1.4

package/deps/xz/src/liblzma/common/stream_flags_common.c

@@ -1,47 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_flags_common.c
-/// \brief      Common stuff for Stream flags coders
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "stream_flags_common.h"
-
-
-const uint8_t lzma_header_magic[6] = { 0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00 };
-const uint8_t lzma_footer_magic[2] = { 0x59, 0x5A };
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_flags_compare(
-		const lzma_stream_flags *a, const lzma_stream_flags *b)
-{
-	// We can compare only version 0 structures.
-	if (a->version != 0 || b->version != 0)
-		return LZMA_OPTIONS_ERROR;
-
-	// Check type
-	if ((unsigned int)(a->check) > LZMA_CHECK_ID_MAX
-			|| (unsigned int)(b->check) > LZMA_CHECK_ID_MAX)
-		return LZMA_PROG_ERROR;
-
-	if (a->check != b->check)
-		return LZMA_DATA_ERROR;
-
-	// Backward Sizes are compared only if they are known in both.
-	if (a->backward_size != LZMA_VLI_UNKNOWN
-			&& b->backward_size != LZMA_VLI_UNKNOWN) {
-		if (!is_backward_size_valid(a) || !is_backward_size_valid(b))
-			return LZMA_PROG_ERROR;
-
-		if (a->backward_size != b->backward_size)
-			return LZMA_DATA_ERROR;
-	}
-
-	return LZMA_OK;
-}

package/deps/xz/src/liblzma/common/stream_flags_common.h

@@ -1,33 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_flags_common.h
-/// \brief      Common stuff for Stream flags coders
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_STREAM_FLAGS_COMMON_H
-#define LZMA_STREAM_FLAGS_COMMON_H
-
-#include "common.h"
-
-/// Size of the Stream Flags field
-#define LZMA_STREAM_FLAGS_SIZE 2
-
-extern const uint8_t lzma_header_magic[6];
-extern const uint8_t lzma_footer_magic[2];
-
-
-static inline bool
-is_backward_size_valid(const lzma_stream_flags *options)
-{
-	return options->backward_size >= LZMA_BACKWARD_SIZE_MIN
-			&& options->backward_size <= LZMA_BACKWARD_SIZE_MAX
-			&& (options->backward_size & 3) == 0;
-}
-
-#endif

package/deps/xz/src/liblzma/common/stream_flags_decoder.c

@@ -1,82 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_flags_decoder.c
-/// \brief      Decodes Stream Header and Stream Footer from .xz files
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "stream_flags_common.h"
-
-
-static bool
-stream_flags_decode(lzma_stream_flags *options, const uint8_t *in)
-{
-	// Reserved bits must be unset.
-	if (in[0] != 0x00 || (in[1] & 0xF0))
-		return true;
-
-	options->version = 0;
-	options->check = in[1] & 0x0F;
-
-	return false;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_header_decode(lzma_stream_flags *options, const uint8_t *in)
-{
-	// Magic
-	if (memcmp(in, lzma_header_magic, sizeof(lzma_header_magic)) != 0)
-		return LZMA_FORMAT_ERROR;
-
-	// Verify the CRC32 so we can distinguish between corrupt
-	// and unsupported files.
-	const uint32_t crc = lzma_crc32(in + sizeof(lzma_header_magic),
-			LZMA_STREAM_FLAGS_SIZE, 0);
-	if (crc != unaligned_read32le(in + sizeof(lzma_header_magic)
-			+ LZMA_STREAM_FLAGS_SIZE))
-		return LZMA_DATA_ERROR;
-
-	// Stream Flags
-	if (stream_flags_decode(options, in + sizeof(lzma_header_magic)))
-		return LZMA_OPTIONS_ERROR;
-
-	// Set Backward Size to indicate unknown value. That way
-	// lzma_stream_flags_compare() can be used to compare Stream Header
-	// and Stream Footer while keeping it useful also for comparing
-	// two Stream Footers.
-	options->backward_size = LZMA_VLI_UNKNOWN;
-
-	return LZMA_OK;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_footer_decode(lzma_stream_flags *options, const uint8_t *in)
-{
-	// Magic
-	if (memcmp(in + sizeof(uint32_t) * 2 + LZMA_STREAM_FLAGS_SIZE,
-			lzma_footer_magic, sizeof(lzma_footer_magic)) != 0)
-		return LZMA_FORMAT_ERROR;
-
-	// CRC32
-	const uint32_t crc = lzma_crc32(in + sizeof(uint32_t),
-			sizeof(uint32_t) + LZMA_STREAM_FLAGS_SIZE, 0);
-	if (crc != unaligned_read32le(in))
-		return LZMA_DATA_ERROR;
-
-	// Stream Flags
-	if (stream_flags_decode(options, in + sizeof(uint32_t) * 2))
-		return LZMA_OPTIONS_ERROR;
-
-	// Backward Size
-	options->backward_size = unaligned_read32le(in + sizeof(uint32_t));
-	options->backward_size = (options->backward_size + 1) * 4;
-
-	return LZMA_OK;
-}

package/deps/xz/src/liblzma/common/stream_flags_encoder.c

@@ -1,86 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_flags_encoder.c
-/// \brief      Encodes Stream Header and Stream Footer for .xz files
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "stream_flags_common.h"
-
-
-static bool
-stream_flags_encode(const lzma_stream_flags *options, uint8_t *out)
-{
-	if ((unsigned int)(options->check) > LZMA_CHECK_ID_MAX)
-		return true;
-
-	out[0] = 0x00;
-	out[1] = options->check;
-
-	return false;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_header_encode(const lzma_stream_flags *options, uint8_t *out)
-{
-	assert(sizeof(lzma_header_magic) + LZMA_STREAM_FLAGS_SIZE
-			+ 4 == LZMA_STREAM_HEADER_SIZE);
-
-	if (options->version != 0)
-		return LZMA_OPTIONS_ERROR;
-
-	// Magic
-	memcpy(out, lzma_header_magic, sizeof(lzma_header_magic));
-
-	// Stream Flags
-	if (stream_flags_encode(options, out + sizeof(lzma_header_magic)))
-		return LZMA_PROG_ERROR;
-
-	// CRC32 of the Stream Header
-	const uint32_t crc = lzma_crc32(out + sizeof(lzma_header_magic),
-			LZMA_STREAM_FLAGS_SIZE, 0);
-
-	unaligned_write32le(out + sizeof(lzma_header_magic)
-			+ LZMA_STREAM_FLAGS_SIZE, crc);
-
-	return LZMA_OK;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_footer_encode(const lzma_stream_flags *options, uint8_t *out)
-{
-	assert(2 * 4 + LZMA_STREAM_FLAGS_SIZE + sizeof(lzma_footer_magic)
-			== LZMA_STREAM_HEADER_SIZE);
-
-	if (options->version != 0)
-		return LZMA_OPTIONS_ERROR;
-
-	// Backward Size
-	if (!is_backward_size_valid(options))
-		return LZMA_PROG_ERROR;
-
-	unaligned_write32le(out + 4, options->backward_size / 4 - 1);
-
-	// Stream Flags
-	if (stream_flags_encode(options, out + 2 * 4))
-		return LZMA_PROG_ERROR;
-
-	// CRC32
-	const uint32_t crc = lzma_crc32(
-			out + 4, 4 + LZMA_STREAM_FLAGS_SIZE, 0);
-
-	unaligned_write32le(out, crc);
-
-	// Magic
-	memcpy(out + 2 * 4 + LZMA_STREAM_FLAGS_SIZE,
-			lzma_footer_magic, sizeof(lzma_footer_magic));
-
-	return LZMA_OK;
-}

package/deps/xz/src/liblzma/common/vli_decoder.c

@@ -1,86 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       vli_decoder.c
-/// \brief      Decodes variable-length integers
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_vli_decode(lzma_vli *restrict vli, size_t *vli_pos,
-		const uint8_t *restrict in, size_t *restrict in_pos,
-		size_t in_size)
-{
-	// If we haven't been given vli_pos, work in single-call mode.
-	size_t vli_pos_internal = 0;
-	if (vli_pos == NULL) {
-		vli_pos = &vli_pos_internal;
-		*vli = 0;
-
-		// If there's no input, use LZMA_DATA_ERROR. This way it is
-		// easy to decode VLIs from buffers that have known size,
-		// and get the correct error code in case the buffer is
-		// too short.
-		if (*in_pos >= in_size)
-			return LZMA_DATA_ERROR;
-
-	} else {
-		// Initialize *vli when starting to decode a new integer.
-		if (*vli_pos == 0)
-			*vli = 0;
-
-		// Validate the arguments.
-		if (*vli_pos >= LZMA_VLI_BYTES_MAX
-				|| (*vli >> (*vli_pos * 7)) != 0)
-			return LZMA_PROG_ERROR;;
-
-		if (*in_pos >= in_size)
-			return LZMA_BUF_ERROR;
-	}
-
-	do {
-		// Read the next byte. Use a temporary variable so that we
-		// can update *in_pos immediately.
-		const uint8_t byte = in[*in_pos];
-		++*in_pos;
-
-		// Add the newly read byte to *vli.
-		*vli += (lzma_vli)(byte & 0x7F) << (*vli_pos * 7);
-		++*vli_pos;
-
-		// Check if this is the last byte of a multibyte integer.
-		if ((byte & 0x80) == 0) {
-			// We don't allow using variable-length integers as
-			// padding i.e. the encoding must use the most the
-			// compact form.
-			if (byte == 0x00 && *vli_pos > 1)
-				return LZMA_DATA_ERROR;
-
-			return vli_pos == &vli_pos_internal
-					? LZMA_OK : LZMA_STREAM_END;
-		}
-
-		// There is at least one more byte coming. If we have already
-		// read maximum number of bytes, the integer is considered
-		// corrupt.
-		//
-		// If we need bigger integers in future, old versions liblzma
-		// will confusingly indicate the file being corrupt istead of
-		// unsupported. I suppose it's still better this way, because
-		// in the foreseeable future (writing this in 2008) the only
-		// reason why files would appear having over 63-bit integers
-		// is that the files are simply corrupt.
-		if (*vli_pos == LZMA_VLI_BYTES_MAX)
-			return LZMA_DATA_ERROR;
-
-	} while (*in_pos < in_size);
-
-	return vli_pos == &vli_pos_internal ? LZMA_DATA_ERROR : LZMA_OK;
-}

package/deps/xz/src/liblzma/common/vli_encoder.c

@@ -1,69 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       vli_encoder.c
-/// \brief      Encodes variable-length integers
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_vli_encode(lzma_vli vli, size_t *vli_pos,
-		uint8_t *restrict out, size_t *restrict out_pos,
-		size_t out_size)
-{
-	// If we haven't been given vli_pos, work in single-call mode.
-	size_t vli_pos_internal = 0;
-	if (vli_pos == NULL) {
-		vli_pos = &vli_pos_internal;
-
-		// In single-call mode, we expect that the caller has
-		// reserved enough output space.
-		if (*out_pos >= out_size)
-			return LZMA_PROG_ERROR;
-	} else {
-		// This never happens when we are called by liblzma, but
-		// may happen if called directly from an application.
-		if (*out_pos >= out_size)
-			return LZMA_BUF_ERROR;
-	}
-
-	// Validate the arguments.
-	if (*vli_pos >= LZMA_VLI_BYTES_MAX || vli > LZMA_VLI_MAX)
-		return LZMA_PROG_ERROR;
-
-	// Shift vli so that the next bits to encode are the lowest. In
-	// single-call mode this never changes vli since *vli_pos is zero.
-	vli >>= *vli_pos * 7;
-
-	// Write the non-last bytes in a loop.
-	while (vli >= 0x80) {
-		// We don't need *vli_pos during this function call anymore,
-		// but update it here so that it is ready if we need to
-		// return before the whole integer has been decoded.
-		++*vli_pos;
-		assert(*vli_pos < LZMA_VLI_BYTES_MAX);
-
-		// Write the next byte.
-		out[*out_pos] = (uint8_t)(vli) | 0x80;
-		vli >>= 7;
-
-		if (++*out_pos == out_size)
-			return vli_pos == &vli_pos_internal
-					? LZMA_PROG_ERROR : LZMA_OK;
-	}
-
-	// Write the last byte.
-	out[*out_pos] = (uint8_t)(vli);
-	++*out_pos;
-	++*vli_pos;
-
-	return vli_pos == &vli_pos_internal ? LZMA_OK : LZMA_STREAM_END;
-
-}

package/deps/xz/src/liblzma/common/vli_size.c

@@ -1,30 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       vli_size.c
-/// \brief      Calculates the encoded size of a variable-length integer
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-extern LZMA_API(uint32_t)
-lzma_vli_size(lzma_vli vli)
-{
-	if (vli > LZMA_VLI_MAX)
-		return 0;
-
-	uint32_t i = 0;
-	do {
-		vli >>= 7;
-		++i;
-	} while (vli != 0);
-
-	assert(i <= LZMA_VLI_BYTES_MAX);
-	return i;
-}

package/deps/xz/src/liblzma/delta/Makefile.inc

@@ -1,23 +0,0 @@
-##
-## Author: Lasse Collin
-##
-## This file has been put into the public domain.
-## You can do whatever you want with this file.
-##
-
-liblzma_la_SOURCES += \
-	delta/delta_common.c \
-	delta/delta_common.h \
-	delta/delta_private.h
-
-if COND_ENCODER_DELTA
-liblzma_la_SOURCES += \
-	delta/delta_encoder.c \
-	delta/delta_encoder.h
-endif
-
-if COND_DECODER_DELTA
-liblzma_la_SOURCES += \
-	delta/delta_decoder.c \
-	delta/delta_decoder.h
-endif

package/deps/xz/src/liblzma/delta/delta_common.c

@@ -1,70 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       delta_common.c
-/// \brief      Common stuff for Delta encoder and decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "delta_common.h"
-#include "delta_private.h"
-
-
-static void
-delta_coder_end(lzma_coder *coder, const lzma_allocator *allocator)
-{
-	lzma_next_end(&coder->next, allocator);
-	lzma_free(coder, allocator);
-	return;
-}
-
-
-extern lzma_ret
-lzma_delta_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	// Allocate memory for the decoder if needed.
-	if (next->coder == NULL) {
-		next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-		if (next->coder == NULL)
-			return LZMA_MEM_ERROR;
-
-		// End function is the same for encoder and decoder.
-		next->end = &delta_coder_end;
-		next->coder->next = LZMA_NEXT_CODER_INIT;
-	}
-
-	// Validate the options.
-	if (lzma_delta_coder_memusage(filters[0].options) == UINT64_MAX)
-		return LZMA_OPTIONS_ERROR;
-
-	// Set the delta distance.
-	const lzma_options_delta *opt = filters[0].options;
-	next->coder->distance = opt->dist;
-
-	// Initialize the rest of the variables.
-	next->coder->pos = 0;
-	memzero(next->coder->history, LZMA_DELTA_DIST_MAX);
-
-	// Initialize the next decoder in the chain, if any.
-	return lzma_next_filter_init(&next->coder->next,
-			allocator, filters + 1);
-}
-
-
-extern uint64_t
-lzma_delta_coder_memusage(const void *options)
-{
-	const lzma_options_delta *opt = options;
-
-	if (opt == NULL || opt->type != LZMA_DELTA_TYPE_BYTE
-			|| opt->dist < LZMA_DELTA_DIST_MIN
-			|| opt->dist > LZMA_DELTA_DIST_MAX)
-		return UINT64_MAX;
-
-	return sizeof(lzma_coder);
-}

package/deps/xz/src/liblzma/delta/delta_common.h

@@ -1,20 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       delta_common.h
-/// \brief      Common stuff for Delta encoder and decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_DELTA_COMMON_H
-#define LZMA_DELTA_COMMON_H
-
-#include "common.h"
-
-extern uint64_t lzma_delta_coder_memusage(const void *options);
-
-#endif

package/deps/xz/src/liblzma/delta/delta_decoder.c

@@ -1,76 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       delta_decoder.c
-/// \brief      Delta filter decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "delta_decoder.h"
-#include "delta_private.h"
-
-
-static void
-decode_buffer(lzma_coder *coder, uint8_t *buffer, size_t size)
-{
-	const size_t distance = coder->distance;
-
-	for (size_t i = 0; i < size; ++i) {
-		buffer[i] += coder->history[(distance + coder->pos) & 0xFF];
-		coder->history[coder->pos-- & 0xFF] = buffer[i];
-	}
-}
-
-
-static lzma_ret
-delta_decode(lzma_coder *coder, const lzma_allocator *allocator,
-		const uint8_t *restrict in, size_t *restrict in_pos,
-		size_t in_size, uint8_t *restrict out,
-		size_t *restrict out_pos, size_t out_size, lzma_action action)
-{
-	assert(coder->next.code != NULL);
-
-	const size_t out_start = *out_pos;
-
-	const lzma_ret ret = coder->next.code(coder->next.coder, allocator,
-			in, in_pos, in_size, out, out_pos, out_size,
-			action);
-
-	decode_buffer(coder, out + out_start, *out_pos - out_start);
-
-	return ret;
-}
-
-
-extern lzma_ret
-lzma_delta_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	next->code = &delta_decode;
-	return lzma_delta_coder_init(next, allocator, filters);
-}
-
-
-extern lzma_ret
-lzma_delta_props_decode(void **options, const lzma_allocator *allocator,
-		const uint8_t *props, size_t props_size)
-{
-	if (props_size != 1)
-		return LZMA_OPTIONS_ERROR;
-
-	lzma_options_delta *opt
-			= lzma_alloc(sizeof(lzma_options_delta), allocator);
-	if (opt == NULL)
-		return LZMA_MEM_ERROR;
-
-	opt->type = LZMA_DELTA_TYPE_BYTE;
-	opt->dist = props[0] + 1;
-
-	*options = opt;
-
-	return LZMA_OK;
-}

package/deps/xz/src/liblzma/delta/delta_decoder.h

@@ -1,26 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       delta_decoder.h
-/// \brief      Delta filter decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_DELTA_DECODER_H
-#define LZMA_DELTA_DECODER_H
-
-#include "delta_common.h"
-
-extern lzma_ret lzma_delta_decoder_init(lzma_next_coder *next,
-		const lzma_allocator *allocator,
-		const lzma_filter_info *filters);
-
-extern lzma_ret lzma_delta_props_decode(
-		void **options, const lzma_allocator *allocator,
-		const uint8_t *props, size_t props_size);
-
-#endif