libarchive-static 1.0.6 → 1.1.0

data/ext/{libarchive-2.8.4/libarchive/archive_read_support_compression_xz.c → libarchive-3.6.2/libarchive/archive_read_support_filter_xz.c}

@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2009 Michihiro NAKAJIMA
+ * Copyright (c) 2009-2011 Michihiro NAKAJIMA
  * Copyright (c) 2003-2008 Tim Kientzle and Miklos Vajna
  * All rights reserved.
  *
@@ -26,7 +26,7 @@
 
 #include "archive_platform.h"
 
-__FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_xz.c 201167 2009-12-29 06:06:20Z kientzle $");
+__FBSDID("$FreeBSD$");
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
@@ -43,8 +43,6 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_xz.c 20
 #endif
 #if HAVE_LZMA_H
 #include <lzma.h>
-#elif HAVE_LZMADEC_H
-#include <lzmadec.h>
 #endif
 
 #include "archive.h"
@@ -60,26 +58,28 @@ struct private_data {
 	size_t		 out_block_size;
 	int64_t		 total_out;
 	char		 eof; /* True = found end of compressed data. */
+	char		 in_stream;
+
+	/* Following variables are used for lzip only. */
+	char		 lzip_ver;
+	uint32_t	 crc32;
+	int64_t		 member_in;
+	int64_t		 member_out;
 };
 
-/* Combined lzma/xz filter */
+#if LZMA_VERSION_MAJOR >= 5
+/* Effectively disable the limiter. */
+#define LZMA_MEMLIMIT	UINT64_MAX
+#else
+/* NOTE: This needs to check memory size which running system has. */
+#define LZMA_MEMLIMIT	(1U << 30)
+#endif
+
+/* Combined lzip/lzma/xz filter */
 static ssize_t	xz_filter_read(struct archive_read_filter *, const void **);
 static int	xz_filter_close(struct archive_read_filter *);
 static int	xz_lzma_bidder_init(struct archive_read_filter *);
 
-#elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC
-
-struct private_data {
-	lzmadec_stream	 stream;
-	unsigned char	*out_block;
-	size_t		 out_block_size;
-	int64_t		 total_out;
-	char		 eof; /* True = found end of compressed data. */
-};
-
-/* Lzma-only filter */
-static ssize_t	lzma_filter_read(struct archive_read_filter *, const void **);
-static int	lzma_filter_close(struct archive_read_filter *);
 #endif
 
 /*
@@ -94,53 +94,105 @@ static int	xz_bidder_init(struct archive_read_filter *);
 static int	lzma_bidder_bid(struct archive_read_filter_bidder *,
 		    struct archive_read_filter *);
 static int	lzma_bidder_init(struct archive_read_filter *);
+static int	lzip_has_member(struct archive_read_filter *);
+static int	lzip_bidder_bid(struct archive_read_filter_bidder *,
+		    struct archive_read_filter *);
+static int	lzip_bidder_init(struct archive_read_filter *);
+
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Deprecated; remove in libarchive 4.0 */
+int
+archive_read_support_compression_xz(struct archive *a)
+{
+	return archive_read_support_filter_xz(a);
+}
+#endif
+
+static const struct archive_read_filter_bidder_vtable
+xz_bidder_vtable = {
+	.bid = xz_bidder_bid,
+	.init = xz_bidder_init,
+};
 
 int
-archive_read_support_compression_xz(struct archive *_a)
+archive_read_support_filter_xz(struct archive *_a)
 {
 	struct archive_read *a = (struct archive_read *)_a;
-	struct archive_read_filter_bidder *bidder = __archive_read_get_bidder(a);
 
-	archive_clear_error(_a);
-	if (bidder == NULL)
+	if (__archive_read_register_bidder(a, NULL, "xz",
+				&xz_bidder_vtable) != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 
-	bidder->data = NULL;
-	bidder->bid = xz_bidder_bid;
-	bidder->init = xz_bidder_init;
-	bidder->options = NULL;
-	bidder->free = NULL;
 #if HAVE_LZMA_H && HAVE_LIBLZMA
 	return (ARCHIVE_OK);
 #else
 	archive_set_error(_a, ARCHIVE_ERRNO_MISC,
-	    "Using external unxz program for xz decompression");
+	    "Using external xz program for xz decompression");
 	return (ARCHIVE_WARN);
 #endif
 }
 
+#if ARCHIVE_VERSION_NUMBER < 4000000
 int
-archive_read_support_compression_lzma(struct archive *_a)
+archive_read_support_compression_lzma(struct archive *a)
+{
+	return archive_read_support_filter_lzma(a);
+}
+#endif
+
+static const struct archive_read_filter_bidder_vtable
+lzma_bidder_vtable = {
+	.bid = lzma_bidder_bid,
+	.init = lzma_bidder_init,
+};
+
+int
+archive_read_support_filter_lzma(struct archive *_a)
 {
 	struct archive_read *a = (struct archive_read *)_a;
-	struct archive_read_filter_bidder *bidder = __archive_read_get_bidder(a);
 
-	archive_clear_error(_a);
-	if (bidder == NULL)
+	if (__archive_read_register_bidder(a, NULL, "lzma",
+				&lzma_bidder_vtable) != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 
-	bidder->data = NULL;
-	bidder->bid = lzma_bidder_bid;
-	bidder->init = lzma_bidder_init;
-	bidder->options = NULL;
-	bidder->free = NULL;
 #if HAVE_LZMA_H && HAVE_LIBLZMA
 	return (ARCHIVE_OK);
-#elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC
+#else
+	archive_set_error(_a, ARCHIVE_ERRNO_MISC,
+	    "Using external lzma program for lzma decompression");
+	return (ARCHIVE_WARN);
+#endif
+}
+
+
+#if ARCHIVE_VERSION_NUMBER < 4000000
+int
+archive_read_support_compression_lzip(struct archive *a)
+{
+	return archive_read_support_filter_lzip(a);
+}
+#endif
+
+static const struct archive_read_filter_bidder_vtable
+lzip_bidder_vtable = {
+	.bid = lzip_bidder_bid,
+	.init = lzip_bidder_init,
+};
+
+int
+archive_read_support_filter_lzip(struct archive *_a)
+{
+	struct archive_read *a = (struct archive_read *)_a;
+
+	if (__archive_read_register_bidder(a, NULL, "lzip",
+				&lzip_bidder_vtable) != ARCHIVE_OK)
+		return (ARCHIVE_FATAL);
+
+#if HAVE_LZMA_H && HAVE_LIBLZMA
 	return (ARCHIVE_OK);
 #else
 	archive_set_error(_a, ARCHIVE_ERRNO_MISC,
-	    "Using external unlzma program for lzma decompression");
+	    "Using external lzip program for lzip decompression");
 	return (ARCHIVE_WARN);
 #endif
 }
@@ -154,7 +206,6 @@ xz_bidder_bid(struct archive_read_filter_bidder *self,
 {
 	const unsigned char *buffer;
 	ssize_t avail;
-	int bits_checked;
 
 	(void)self; /* UNUSED */
 
@@ -165,27 +216,10 @@ xz_bidder_bid(struct archive_read_filter_bidder *self,
 	/*
 	 * Verify Header Magic Bytes : FD 37 7A 58 5A 00
 	 */
-	bits_checked = 0;
-	if (buffer[0] != 0xFD)
-		return (0);
-	bits_checked += 8;
-	if (buffer[1] != 0x37)
-		return (0);
-	bits_checked += 8;
-	if (buffer[2] != 0x7A)
-		return (0);
-	bits_checked += 8;
-	if (buffer[3] != 0x58)
-		return (0);
-	bits_checked += 8;
-	if (buffer[4] != 0x5A)
-		return (0);
-	bits_checked += 8;
-	if (buffer[5] != 0x00)
+	if (memcmp(buffer, "\xFD\x37\x7A\x58\x5A\x00", 6) != 0)
 		return (0);
-	bits_checked += 8;
 
-	return (bits_checked);
+	return (48);
 }
 
 /*
@@ -250,8 +284,8 @@ lzma_bidder_bid(struct archive_read_filter_bidder *self,
 	/* Second through fifth bytes are dictionary size, stored in
 	 * little-endian order. The minimum dictionary size is
 	 * 1 << 12(4KiB) which the lzma of LZMA SDK uses with option
-	 * -d12 and the maxinam dictionary size is 1 << 27(128MiB)
-	 * which the one uses with option -d27.
+	 * -d12 and the maximum dictionary size is 1 << 29(512MiB)
+	 * which the one uses with option -d29.
 	 * NOTE: A comment of LZMA SDK source code says this dictionary
 	 * range is from 1 << 12 to 1 << 30. */
 	dicsize = archive_le32dec(buffer+1);
@@ -307,6 +341,49 @@ lzma_bidder_bid(struct archive_read_filter_bidder *self,
 	return (bits_checked);
 }
 
+static int
+lzip_has_member(struct archive_read_filter *filter)
+{
+	const unsigned char *buffer;
+	ssize_t avail;
+	int bits_checked;
+	int log2dic;
+
+	buffer = __archive_read_filter_ahead(filter, 6, &avail);
+	if (buffer == NULL)
+		return (0);
+
+	/*
+	 * Verify Header Magic Bytes : 4C 5A 49 50 (`LZIP')
+	 */
+	bits_checked = 0;
+	if (memcmp(buffer, "LZIP", 4) != 0)
+		return (0);
+	bits_checked += 32;
+
+	/* A version number must be 0 or 1 */
+	if (buffer[4] != 0 && buffer[4] != 1)
+		return (0);
+	bits_checked += 8;
+
+	/* Dictionary size. */
+	log2dic = buffer[5] & 0x1f;
+	if (log2dic < 12 || log2dic > 29)
+		return (0);
+	bits_checked += 8;
+
+	return (bits_checked);
+}
+
+static int
+lzip_bidder_bid(struct archive_read_filter_bidder *self,
+    struct archive_read_filter *filter)
+{
+
+	(void)self; /* UNUSED */
+	return (lzip_has_member(filter));
+}
+
 #if HAVE_LZMA_H && HAVE_LIBLZMA
 
 /*
@@ -315,7 +392,7 @@ lzma_bidder_bid(struct archive_read_filter_bidder *self,
 static int
 xz_bidder_init(struct archive_read_filter *self)
 {
-	self->code = ARCHIVE_COMPRESSION_XZ;
+	self->code = ARCHIVE_FILTER_XZ;
 	self->name = "xz";
 	return (xz_lzma_bidder_init(self));
 }
@@ -323,11 +400,73 @@ xz_bidder_init(struct archive_read_filter *self)
 static int
 lzma_bidder_init(struct archive_read_filter *self)
 {
-	self->code = ARCHIVE_COMPRESSION_LZMA;
+	self->code = ARCHIVE_FILTER_LZMA;
 	self->name = "lzma";
 	return (xz_lzma_bidder_init(self));
 }
 
+static int
+lzip_bidder_init(struct archive_read_filter *self)
+{
+	self->code = ARCHIVE_FILTER_LZIP;
+	self->name = "lzip";
+	return (xz_lzma_bidder_init(self));
+}
+
+/*
+ * Set an error code and choose an error message
+ */
+static void
+set_error(struct archive_read_filter *self, int ret)
+{
+
+	switch (ret) {
+	case LZMA_STREAM_END: /* Found end of stream. */
+	case LZMA_OK: /* Decompressor made some progress. */
+		break;
+	case LZMA_MEM_ERROR:
+		archive_set_error(&self->archive->archive, ENOMEM,
+		    "Lzma library error: Cannot allocate memory");
+		break;
+	case LZMA_MEMLIMIT_ERROR:
+		archive_set_error(&self->archive->archive, ENOMEM,
+		    "Lzma library error: Out of memory");
+		break;
+	case LZMA_FORMAT_ERROR:
+		archive_set_error(&self->archive->archive,
+		    ARCHIVE_ERRNO_MISC,
+		    "Lzma library error: format not recognized");
+		break;
+	case LZMA_OPTIONS_ERROR:
+		archive_set_error(&self->archive->archive,
+		    ARCHIVE_ERRNO_MISC,
+		    "Lzma library error: Invalid options");
+		break;
+	case LZMA_DATA_ERROR:
+		archive_set_error(&self->archive->archive,
+		    ARCHIVE_ERRNO_MISC,
+		    "Lzma library error: Corrupted input data");
+		break;
+	case LZMA_BUF_ERROR:
+		archive_set_error(&self->archive->archive,
+		    ARCHIVE_ERRNO_MISC,
+		    "Lzma library error:  No progress is possible");
+		break;
+	default:
+		/* Return an error. */
+		archive_set_error(&self->archive->archive,
+		    ARCHIVE_ERRNO_MISC,
+		    "Lzma decompression failed:  Unknown error");
+		break;
+	}
+}
+
+static const struct archive_read_filter_vtable
+xz_lzma_reader_vtable = {
+	.read = xz_filter_read,
+	.close = xz_filter_close,
+};
+
 /*
  * Setup the callbacks.
  */
@@ -352,49 +491,39 @@ xz_lzma_bidder_init(struct archive_read_filter *self)
 	self->data = state;
 	state->out_block_size = out_block_size;
 	state->out_block = out_block;
-	self->read = xz_filter_read;
-	self->skip = NULL; /* not supported */
-	self->close = xz_filter_close;
+	self->vtable = &xz_lzma_reader_vtable;
 
 	state->stream.avail_in = 0;
 
 	state->stream.next_out = state->out_block;
 	state->stream.avail_out = state->out_block_size;
 
-	/* Initialize compression library.
-	 * TODO: I don't know what value is best for memlimit.
-	 *       maybe, it needs to check memory size which
-	 *       running system has.
-	 */
-	if (self->code == ARCHIVE_COMPRESSION_XZ)
+	state->crc32 = 0;
+	if (self->code == ARCHIVE_FILTER_LZIP) {
+		/*
+		 * We have to read a lzip header and use it to initialize
+		 * compression library, thus we cannot initialize the
+		 * library for lzip here.
+		 */
+		state->in_stream = 0;
+		return (ARCHIVE_OK);
+	} else
+		state->in_stream = 1;
+
+	/* Initialize compression library. */
+	if (self->code == ARCHIVE_FILTER_XZ)
 		ret = lzma_stream_decoder(&(state->stream),
-		    (1U << 30),/* memlimit */
+		    LZMA_MEMLIMIT,/* memlimit */
 		    LZMA_CONCATENATED);
 	else
 		ret = lzma_alone_decoder(&(state->stream),
-		    (1U << 30));/* memlimit */
+		    LZMA_MEMLIMIT);/* memlimit */
 
 	if (ret == LZMA_OK)
 		return (ARCHIVE_OK);
 
 	/* Library setup failed: Choose an error message and clean up. */
-	switch (ret) {
-	case LZMA_MEM_ERROR:
-		archive_set_error(&self->archive->archive, ENOMEM,
-		    "Internal error initializing compression library: "
-		    "Cannot allocate memory");
-		break;
-	case LZMA_OPTIONS_ERROR:
-		archive_set_error(&self->archive->archive,
-		    ARCHIVE_ERRNO_MISC,
-		    "Internal error initializing compression library: "
-		    "Invalid or unsupported options");
-		break;
-	default:
-		archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
-		    "Internal error initializing lzma library");
-		break;
-	}
+	set_error(self, ret);
 
 	free(state->out_block);
 	free(state);
@@ -402,193 +531,132 @@ xz_lzma_bidder_init(struct archive_read_filter *self)
 	return (ARCHIVE_FATAL);
 }
 
-/*
- * Return the next block of decompressed data.
- */
-static ssize_t
-xz_filter_read(struct archive_read_filter *self, const void **p)
+static int
+lzip_init(struct archive_read_filter *self)
 {
 	struct private_data *state;
-	size_t decompressed;
+	const unsigned char *h;
+	lzma_filter filters[2];
+	unsigned char props[5];
 	ssize_t avail_in;
-	int ret;
+	uint32_t dicsize;
+	int log2dic, ret;
 
 	state = (struct private_data *)self->data;
+	h = __archive_read_filter_ahead(self->upstream, 6, &avail_in);
+	if (h == NULL)
+		return (ARCHIVE_FATAL);
 
-	/* Empty our output buffer. */
-	state->stream.next_out = state->out_block;
-	state->stream.avail_out = state->out_block_size;
+	/* Get a version number. */
+	state->lzip_ver = h[4];
 
-	/* Try to fill the output buffer. */
-	while (state->stream.avail_out > 0 && !state->eof) {
-		state->stream.next_in =
-		    __archive_read_filter_ahead(self->upstream, 1, &avail_in);
-		if (state->stream.next_in == NULL && avail_in < 0)
-			return (ARCHIVE_FATAL);
-		state->stream.avail_in = avail_in;
+	/*
+	 * Setup lzma property.
+	 */
+	props[0] = 0x5d;
 
-		/* Decompress as much as we can in one pass. */
-		ret = lzma_code(&(state->stream),
-		    (state->stream.avail_in == 0)? LZMA_FINISH: LZMA_RUN);
-		switch (ret) {
-		case LZMA_STREAM_END: /* Found end of stream. */
-			state->eof = 1;
-			/* FALL THROUGH */
-		case LZMA_OK: /* Decompressor made some progress. */
-			__archive_read_filter_consume(self->upstream,
-			    avail_in - state->stream.avail_in);
-			break;
-		case LZMA_MEM_ERROR:
-			archive_set_error(&self->archive->archive, ENOMEM,
-			    "Lzma library error: Cannot allocate memory");
-			return (ARCHIVE_FATAL);
-		case LZMA_MEMLIMIT_ERROR:
-			archive_set_error(&self->archive->archive, ENOMEM,
-			    "Lzma library error: Out of memory");
-			return (ARCHIVE_FATAL);
-		case LZMA_FORMAT_ERROR:
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Lzma library error: format not recognized");
-			return (ARCHIVE_FATAL);
-		case LZMA_OPTIONS_ERROR:
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Lzma library error: Invalid options");
-			return (ARCHIVE_FATAL);
-		case LZMA_DATA_ERROR:
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Lzma library error: Corrupted input data");
-			return (ARCHIVE_FATAL);
-		case LZMA_BUF_ERROR:
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Lzma library error:  No progress is possible");
-			return (ARCHIVE_FATAL);
-		default:
-			/* Return an error. */
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Lzma decompression failed:  Unknown error");
-			return (ARCHIVE_FATAL);
-		}
+	/* Get dictionary size. */
+	log2dic = h[5] & 0x1f;
+	if (log2dic < 12 || log2dic > 29)
+		return (ARCHIVE_FATAL);
+	dicsize = 1U << log2dic;
+	if (log2dic > 12)
+		dicsize -= (dicsize / 16) * (h[5] >> 5);
+	archive_le32enc(props+1, dicsize);
+
+	/* Consume lzip header. */
+	__archive_read_filter_consume(self->upstream, 6);
+	state->member_in = 6;
+
+	filters[0].id = LZMA_FILTER_LZMA1;
+	filters[0].options = NULL;
+	filters[1].id = LZMA_VLI_UNKNOWN;
+	filters[1].options = NULL;
+
+	ret = lzma_properties_decode(&filters[0], NULL, props, sizeof(props));
+	if (ret != LZMA_OK) {
+		set_error(self, ret);
+		return (ARCHIVE_FATAL);
+	}
+	ret = lzma_raw_decoder(&(state->stream), filters);
+	free(filters[0].options);
+	if (ret != LZMA_OK) {
+		set_error(self, ret);
+		return (ARCHIVE_FATAL);
 	}
-
-	decompressed = state->stream.next_out - state->out_block;
-	state->total_out += decompressed;
-	if (decompressed == 0)
-		*p = NULL;
-	else
-		*p = state->out_block;
-	return (decompressed);
-}
-
-/*
- * Clean up the decompressor.
- */
-static int
-xz_filter_close(struct archive_read_filter *self)
-{
-	struct private_data *state;
-
-	state = (struct private_data *)self->data;
-	lzma_end(&(state->stream));
-	free(state->out_block);
-	free(state);
 	return (ARCHIVE_OK);
 }
 
-#else
-
-#if HAVE_LZMADEC_H && HAVE_LIBLZMADEC
-
-/*
- * If we have the older liblzmadec library, then we can handle
- * LZMA streams but not XZ streams.
- */
-
-/*
- * Setup the callbacks.
- */
 static int
-lzma_bidder_init(struct archive_read_filter *self)
+lzip_tail(struct archive_read_filter *self)
 {
-	static const size_t out_block_size = 64 * 1024;
-	void *out_block;
 	struct private_data *state;
-	ssize_t ret, avail_in;
-
-	self->code = ARCHIVE_COMPRESSION_LZMA;
-	self->name = "lzma";
+	const unsigned char *f;
+	ssize_t avail_in;
+	int tail;
 
-	state = (struct private_data *)calloc(sizeof(*state), 1);
-	out_block = (unsigned char *)malloc(out_block_size);
-	if (state == NULL || out_block == NULL) {
-		archive_set_error(&self->archive->archive, ENOMEM,
-		    "Can't allocate data for lzma decompression");
-		free(out_block);
-		free(state);
+	state = (struct private_data *)self->data;
+	if (state->lzip_ver == 0)
+		tail = 12;
+	else
+		tail = 20;
+	f = __archive_read_filter_ahead(self->upstream, tail, &avail_in);
+	if (f == NULL && avail_in < 0)
 		return (ARCHIVE_FATAL);
+	if (f == NULL || avail_in < tail) {
+		archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
+		    "Lzip: Remaining data is less bytes");
+		return (ARCHIVE_FAILED);
 	}
 
-	self->data = state;
-	state->out_block_size = out_block_size;
-	state->out_block = out_block;
-	self->read = lzma_filter_read;
-	self->skip = NULL; /* not supported */
-	self->close = lzma_filter_close;
-
-	/* Prime the lzma library with 18 bytes of input. */
-	state->stream.next_in = (unsigned char *)(uintptr_t)
-	    __archive_read_filter_ahead(self->upstream, 18, &avail_in);
-	if (state->stream.next_in == NULL)
-		return (ARCHIVE_FATAL);
-	state->stream.avail_in = avail_in;
-	state->stream.next_out = state->out_block;
-	state->stream.avail_out = state->out_block_size;
-
-	/* Initialize compression library. */
-	ret = lzmadec_init(&(state->stream));
-	__archive_read_filter_consume(self->upstream,
-	    avail_in - state->stream.avail_in);
-	if (ret == LZMADEC_OK)
-		return (ARCHIVE_OK);
-
-	/* Library setup failed: Clean up. */
-	archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
-	    "Internal error initializing lzma library");
+	/* Check the crc32 value of the uncompressed data of the current
+	 * member */
+	if (state->crc32 != archive_le32dec(f)) {
+#ifndef DONT_FAIL_ON_CRC_ERROR
+		archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
+		    "Lzip: CRC32 error");
+		return (ARCHIVE_FAILED);
+#endif
+	}
 
-	/* Override the error message if we know what really went wrong. */
-	switch (ret) {
-	case LZMADEC_HEADER_ERROR:
-		archive_set_error(&self->archive->archive,
-		    ARCHIVE_ERRNO_MISC,
-		    "Internal error initializing compression library: "
-		    "invalid header");
-		break;
-	case LZMADEC_MEM_ERROR:
-		archive_set_error(&self->archive->archive, ENOMEM,
-		    "Internal error initializing compression library: "
-		    "out of memory");
-		break;
+	/* Check the uncompressed size of the current member */
+	if ((uint64_t)state->member_out != archive_le64dec(f + 4)) {
+		archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
+		    "Lzip: Uncompressed size error");
+		return (ARCHIVE_FAILED);
 	}
 
-	free(state->out_block);
-	free(state);
-	self->data = NULL;
-	return (ARCHIVE_FATAL);
+	/* Check the total size of the current member */
+	if (state->lzip_ver == 1 &&
+	    (uint64_t)state->member_in + tail != archive_le64dec(f + 12)) {
+		archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
+		    "Lzip: Member size error");
+		return (ARCHIVE_FAILED);
+	}
+	__archive_read_filter_consume(self->upstream, tail);
+
+	/* If current lzip data consists of multi member, try decompressing
+	 * a next member. */
+	if (lzip_has_member(self->upstream) != 0) {
+		state->in_stream = 0;
+		state->crc32 = 0;
+		state->member_out = 0;
+		state->member_in = 0;
+		state->eof = 0;
+	}
+	return (ARCHIVE_OK);
 }
 
 /*
  * Return the next block of decompressed data.
  */
 static ssize_t
-lzma_filter_read(struct archive_read_filter *self, const void **p)
+xz_filter_read(struct archive_read_filter *self, const void **p)
 {
 	struct private_data *state;
 	size_t decompressed;
-	ssize_t avail_in, ret;
+	ssize_t avail_in;
+	int ret;
 
 	state = (struct private_data *)self->data;
 
@@ -598,42 +666,61 @@ lzma_filter_read(struct archive_read_filter *self, const void **p)
 
 	/* Try to fill the output buffer. */
 	while (state->stream.avail_out > 0 && !state->eof) {
-		state->stream.next_in = (unsigned char *)(uintptr_t)
+		if (!state->in_stream) {
+			/*
+			 * Initialize liblzma for lzip
+			 */
+			ret = lzip_init(self);
+			if (ret != ARCHIVE_OK)
+				return (ret);
+			state->in_stream = 1;
+		}
+		state->stream.next_in =
 		    __archive_read_filter_ahead(self->upstream, 1, &avail_in);
-		if (state->stream.next_in == NULL && avail_in < 0)
+		if (state->stream.next_in == NULL && avail_in < 0) {
+			archive_set_error(&self->archive->archive,
+			    ARCHIVE_ERRNO_MISC,
+			    "truncated input");
 			return (ARCHIVE_FATAL);
+		}
 		state->stream.avail_in = avail_in;
 
 		/* Decompress as much as we can in one pass. */
-		ret = lzmadec_decode(&(state->stream), avail_in == 0);
+		ret = lzma_code(&(state->stream),
+		    (state->stream.avail_in == 0)? LZMA_FINISH: LZMA_RUN);
 		switch (ret) {
-		case LZMADEC_STREAM_END: /* Found end of stream. */
+		case LZMA_STREAM_END: /* Found end of stream. */
 			state->eof = 1;
 			/* FALL THROUGH */
-		case LZMADEC_OK: /* Decompressor made some progress. */
+		case LZMA_OK: /* Decompressor made some progress. */
 			__archive_read_filter_consume(self->upstream,
 			    avail_in - state->stream.avail_in);
+			state->member_in +=
+			    avail_in - state->stream.avail_in;
 			break;
-		case LZMADEC_BUF_ERROR: /* Insufficient input data? */
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Insufficient compressed data");
-			return (ARCHIVE_FATAL);
 		default:
-			/* Return an error. */
-			archive_set_error(&self->archive->archive,
-			    ARCHIVE_ERRNO_MISC,
-			    "Lzma decompression failed");
+			set_error(self, ret);
 			return (ARCHIVE_FATAL);
 		}
 	}
 
 	decompressed = state->stream.next_out - state->out_block;
 	state->total_out += decompressed;
+	state->member_out += decompressed;
 	if (decompressed == 0)
 		*p = NULL;
-	else
+	else {
 		*p = state->out_block;
+		if (self->code == ARCHIVE_FILTER_LZIP) {
+			state->crc32 = lzma_crc32(state->out_block,
+			    decompressed, state->crc32);
+			if (state->eof) {
+				ret = lzip_tail(self);
+				if (ret != ARCHIVE_OK)
+					return (ret);
+			}
+		}
+	}
 	return (decompressed);
 }
 
@@ -641,27 +728,15 @@ lzma_filter_read(struct archive_read_filter *self, const void **p)
  * Clean up the decompressor.
  */
 static int
-lzma_filter_close(struct archive_read_filter *self)
+xz_filter_close(struct archive_read_filter *self)
 {
 	struct private_data *state;
-	int ret;
 
 	state = (struct private_data *)self->data;
-	ret = ARCHIVE_OK;
-	switch (lzmadec_end(&(state->stream))) {
-	case LZMADEC_OK:
-		break;
-	default:
-		archive_set_error(&(self->archive->archive),
-		    ARCHIVE_ERRNO_MISC,
-		    "Failed to clean up %s compressor",
-		    self->archive->archive.compression_name);
-		ret = ARCHIVE_FATAL;
-	}
-
+	lzma_end(&(state->stream));
 	free(state->out_block);
 	free(state);
-	return (ret);
+	return (ARCHIVE_OK);
 }
 
 #else
@@ -678,31 +753,41 @@ lzma_bidder_init(struct archive_read_filter *self)
 {
 	int r;
 
-	r = __archive_read_program(self, "unlzma");
+	r = __archive_read_program(self, "lzma -d -qq");
 	/* Note: We set the format here even if __archive_read_program()
 	 * above fails.  We do, after all, know what the format is
 	 * even if we weren't able to read it. */
-	self->code = ARCHIVE_COMPRESSION_LZMA;
+	self->code = ARCHIVE_FILTER_LZMA;
 	self->name = "lzma";
 	return (r);
 }
 
-#endif /* HAVE_LZMADEC_H */
-
-
 static int
 xz_bidder_init(struct archive_read_filter *self)
 {
 	int r;
 
-	r = __archive_read_program(self, "unxz");
+	r = __archive_read_program(self, "xz -d -qq");
 	/* Note: We set the format here even if __archive_read_program()
 	 * above fails.  We do, after all, know what the format is
 	 * even if we weren't able to read it. */
-	self->code = ARCHIVE_COMPRESSION_XZ;
+	self->code = ARCHIVE_FILTER_XZ;
 	self->name = "xz";
 	return (r);
 }
 
+static int
+lzip_bidder_init(struct archive_read_filter *self)
+{
+	int r;
+
+	r = __archive_read_program(self, "lzip -d -q");
+	/* Note: We set the format here even if __archive_read_program()
+	 * above fails.  We do, after all, know what the format is
+	 * even if we weren't able to read it. */
+	self->code = ARCHIVE_FILTER_LZIP;
+	self->name = "lzip";
+	return (r);
+}
 
 #endif /* HAVE_LZMA_H */