libarchive-static 1.0.6 → 1.1.0

data/ext/{libarchive-2.8.4/libarchive/archive_read_support_compression_all.c → libarchive-3.6.2/libarchive/archive_read_support_filter_all.c}

@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2003-2007 Tim Kientzle
+ * Copyright (c) 2003-2011 Tim Kientzle
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -24,30 +24,55 @@
  */
 
 #include "archive_platform.h"
-__FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_all.c 201248 2009-12-30 06:12:03Z kientzle $");
+__FBSDID("$FreeBSD$");
 
 #include "archive.h"
+#include "archive_private.h"
 
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Deprecated; remove in libarchive 4.0 */
 int
 archive_read_support_compression_all(struct archive *a)
 {
+	return archive_read_support_filter_all(a);
+}
+#endif
+
+int
+archive_read_support_filter_all(struct archive *a)
+{
+	archive_check_magic(a, ARCHIVE_READ_MAGIC,
+	    ARCHIVE_STATE_NEW, "archive_read_support_filter_all");
+
 	/* Bzip falls back to "bunzip2" command-line */
-	archive_read_support_compression_bzip2(a);
+	archive_read_support_filter_bzip2(a);
 	/* The decompress code doesn't use an outside library. */
-	archive_read_support_compression_compress(a);
-	/* Gzip decompress falls back to "gunzip" command-line. */
-	archive_read_support_compression_gzip(a);
+	archive_read_support_filter_compress(a);
+	/* Gzip decompress falls back to "gzip -d" command-line. */
+	archive_read_support_filter_gzip(a);
+	/* Lzip falls back to "unlzip" command-line program. */
+	archive_read_support_filter_lzip(a);
 	/* The LZMA file format has a very weak signature, so it
 	 * may not be feasible to keep this here, but we'll try.
 	 * This will come back out if there are problems. */
 	/* Lzma falls back to "unlzma" command-line program. */
-	archive_read_support_compression_lzma(a);
+	archive_read_support_filter_lzma(a);
 	/* Xz falls back to "unxz" command-line program. */
-	archive_read_support_compression_xz(a);
+	archive_read_support_filter_xz(a);
 	/* The decode code doesn't use an outside library. */
-	archive_read_support_compression_uu(a);
+	archive_read_support_filter_uu(a);
 	/* The decode code doesn't use an outside library. */
-	archive_read_support_compression_rpm(a);
+	archive_read_support_filter_rpm(a);
+	/* The decode code always uses "lrzip -q -d" command-line. */
+	archive_read_support_filter_lrzip(a);
+	/* Lzop decompress falls back to "lzop -d" command-line. */
+	archive_read_support_filter_lzop(a);
+	/* The decode code always uses "grzip -d" command-line. */
+	archive_read_support_filter_grzip(a);
+	/* Lz4 falls back to "lz4 -d" command-line program. */
+	archive_read_support_filter_lz4(a);
+	/* Zstd falls back to "zstd -d" command-line program. */
+	archive_read_support_filter_zstd(a);
 
 	/* Note: We always return ARCHIVE_OK here, even if some of the
 	 * above return ARCHIVE_WARN.  The intent here is to enable

data/ext/libarchive-3.6.2/libarchive/archive_read_support_filter_by_code.c

@@ -0,0 +1,83 @@
+/*-
+ * Copyright (c) 2020 Martin Matuska
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "archive_platform.h"
+__FBSDID("$FreeBSD$");
+
+#include "archive.h"
+#include "archive_private.h"
+
+int
+archive_read_support_filter_by_code(struct archive *a, int filter_code)
+{
+	archive_check_magic(a, ARCHIVE_READ_MAGIC,
+	    ARCHIVE_STATE_NEW, "archive_read_support_filter_by_code");
+
+	switch (filter_code) {
+	case ARCHIVE_FILTER_NONE:
+		return archive_read_support_filter_none(a);
+		break;
+	case ARCHIVE_FILTER_GZIP:
+		return archive_read_support_filter_gzip(a);
+		break;
+	case ARCHIVE_FILTER_BZIP2:
+		return archive_read_support_filter_bzip2(a);
+		break;
+	case ARCHIVE_FILTER_COMPRESS:
+		return archive_read_support_filter_compress(a);
+		break;
+	case ARCHIVE_FILTER_LZMA:
+		return archive_read_support_filter_lzma(a);
+		break;
+	case ARCHIVE_FILTER_XZ:
+		return archive_read_support_filter_xz(a);
+		break;
+	case ARCHIVE_FILTER_UU:
+		return archive_read_support_filter_uu(a);
+		break;
+	case ARCHIVE_FILTER_RPM:
+		return archive_read_support_filter_rpm(a);
+		break;
+	case ARCHIVE_FILTER_LZIP:
+		return archive_read_support_filter_lzip(a);
+		break;
+	case ARCHIVE_FILTER_LRZIP:
+		return archive_read_support_filter_lrzip(a);
+		break;
+	case ARCHIVE_FILTER_LZOP:
+		return archive_read_support_filter_lzop(a);
+		break;
+	case ARCHIVE_FILTER_GRZIP:
+		return archive_read_support_filter_grzip(a);
+		break;
+	case ARCHIVE_FILTER_LZ4:
+		return archive_read_support_filter_lz4(a);
+		break;
+	case ARCHIVE_FILTER_ZSTD:
+		return archive_read_support_filter_zstd(a);
+		break;
+	}
+	return (ARCHIVE_FATAL);
+}

data/ext/{libarchive-2.8.4/libarchive/archive_read_support_compression_bzip2.c → libarchive-3.6.2/libarchive/archive_read_support_filter_bzip2.c}

@@ -25,7 +25,7 @@
 
 #include "archive_platform.h"
 
-__FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_bzip2.c 201108 2009-12-28 03:28:21Z kientzle $");
+__FBSDID("$FreeBSD$");
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
@@ -70,37 +70,40 @@ static int	bzip2_filter_close(struct archive_read_filter *);
  */
 static int	bzip2_reader_bid(struct archive_read_filter_bidder *, struct archive_read_filter *);
 static int	bzip2_reader_init(struct archive_read_filter *);
-static int	bzip2_reader_free(struct archive_read_filter_bidder *);
 
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Deprecated; remove in libarchive 4.0 */
 int
-archive_read_support_compression_bzip2(struct archive *_a)
+archive_read_support_compression_bzip2(struct archive *a)
+{
+	return archive_read_support_filter_bzip2(a);
+}
+#endif
+
+static const struct archive_read_filter_bidder_vtable
+bzip2_bidder_vtable = {
+	.bid = bzip2_reader_bid,
+	.init = bzip2_reader_init,
+};
+
+int
+archive_read_support_filter_bzip2(struct archive *_a)
 {
 	struct archive_read *a = (struct archive_read *)_a;
-	struct archive_read_filter_bidder *reader = __archive_read_get_bidder(a);
 
-	if (reader == NULL)
+	if (__archive_read_register_bidder(a, NULL, "bzip2",
+				&bzip2_bidder_vtable) != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 
-	reader->data = NULL;
-	reader->bid = bzip2_reader_bid;
-	reader->init = bzip2_reader_init;
-	reader->options = NULL;
-	reader->free = bzip2_reader_free;
 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
 	return (ARCHIVE_OK);
 #else
 	archive_set_error(_a, ARCHIVE_ERRNO_MISC,
-	    "Using external bunzip2 program");
+	    "Using external bzip2 program");
 	return (ARCHIVE_WARN);
 #endif
 }
 
-static int
-bzip2_reader_free(struct archive_read_filter_bidder *self){
-	(void)self; /* UNUSED */
-	return (ARCHIVE_OK);
-}
-
 /*
  * Test whether we can handle this data.
  *
@@ -124,7 +127,7 @@ bzip2_reader_bid(struct archive_read_filter_bidder *self, struct archive_read_fi
 
 	/* First three bytes must be "BZh" */
 	bits_checked = 0;
-	if (buffer[0] != 'B' || buffer[1] != 'Z' || buffer[2] != 'h')
+	if (memcmp(buffer, "BZh", 3) != 0)
 		return (0);
 	bits_checked += 24;
 
@@ -158,11 +161,11 @@ bzip2_reader_init(struct archive_read_filter *self)
 {
 	int r;
 
-	r = __archive_read_program(self, "bunzip2");
+	r = __archive_read_program(self, "bzip2 -d");
 	/* 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_BZIP2;
+	self->code = ARCHIVE_FILTER_BZIP2;
 	self->name = "bzip2";
 	return (r);
 }
@@ -170,6 +173,12 @@ bzip2_reader_init(struct archive_read_filter *self)
 
 #else
 
+static const struct archive_read_filter_vtable
+bzip2_reader_vtable = {
+	.read = bzip2_filter_read,
+	.close = bzip2_filter_close,
+};
+
 /*
  * Setup the callbacks.
  */
@@ -180,12 +189,12 @@ bzip2_reader_init(struct archive_read_filter *self)
 	void *out_block;
 	struct private_data *state;
 
-	self->code = ARCHIVE_COMPRESSION_BZIP2;
+	self->code = ARCHIVE_FILTER_BZIP2;
 	self->name = "bzip2";
 
 	state = (struct private_data *)calloc(sizeof(*state), 1);
 	out_block = (unsigned char *)malloc(out_block_size);
-	if (self == NULL || state == NULL || out_block == NULL) {
+	if (state == NULL || out_block == NULL) {
 		archive_set_error(&self->archive->archive, ENOMEM,
 		    "Can't allocate data for bzip2 decompression");
 		free(out_block);
@@ -196,9 +205,7 @@ bzip2_reader_init(struct archive_read_filter *self)
 	self->data = state;
 	state->out_block_size = out_block_size;
 	state->out_block = out_block;
-	self->read = bzip2_filter_read;
-	self->skip = NULL; /* not supported */
-	self->close = bzip2_filter_close;
+	self->vtable = &bzip2_reader_vtable;
 
 	return (ARCHIVE_OK);
 }
@@ -274,8 +281,12 @@ bzip2_filter_read(struct archive_read_filter *self, const void **p)
 		 * doesn't declare it so. <sigh> */
 		read_buf =
 		    __archive_read_filter_ahead(self->upstream, 1, &ret);
-		if (read_buf == NULL)
+		if (read_buf == NULL) {
+			archive_set_error(&self->archive->archive,
+			    ARCHIVE_ERRNO_MISC,
+			    "truncated bzip2 input");
 			return (ARCHIVE_FATAL);
+		}
 		state->stream.next_in = (char *)(uintptr_t)read_buf;
 		state->stream.avail_in = ret;
 		/* There is no more data, return whatever we have. */
@@ -343,6 +354,7 @@ bzip2_filter_close(struct archive_read_filter *self)
 					  "Failed to clean up decompressor");
 			ret = ARCHIVE_FATAL;
 		}
+		state->valid = 0;
 	}
 
 	free(state->out_block);

data/ext/{libarchive-2.8.4/libarchive/archive_read_support_compression_compress.c → libarchive-3.6.2/libarchive/archive_read_support_filter_compress.c}

@@ -64,7 +64,7 @@
 
 
 #include "archive_platform.h"
-__FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_compress.c 201094 2009-12-28 02:29:21Z kientzle $");
+__FBSDID("$FreeBSD$");
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
@@ -95,6 +95,7 @@ struct private_data {
 	/* Input variables. */
 	const unsigned char	*next_in;
 	size_t			 avail_in;
+	size_t			 consume_unnotified;
 	int			 bit_buffer;
 	int			 bits_avail;
 	size_t			 bytes_in_section;
@@ -132,7 +133,6 @@ struct private_data {
 
 static int	compress_bidder_bid(struct archive_read_filter_bidder *, struct archive_read_filter *);
 static int	compress_bidder_init(struct archive_read_filter *);
-static int	compress_bidder_free(struct archive_read_filter_bidder *);
 
 static ssize_t	compress_filter_read(struct archive_read_filter *, const void **);
 static int	compress_filter_close(struct archive_read_filter *);
@@ -140,29 +140,33 @@ static int	compress_filter_close(struct archive_read_filter *);
 static int	getbits(struct archive_read_filter *, int n);
 static int	next_code(struct archive_read_filter *);
 
+#if ARCHIVE_VERSION_NUMBER < 4000000
+/* Deprecated; remove in libarchive 4.0 */
 int
-archive_read_support_compression_compress(struct archive *_a)
+archive_read_support_compression_compress(struct archive *a)
 {
-	struct archive_read *a = (struct archive_read *)_a;
-	struct archive_read_filter_bidder *bidder = __archive_read_get_bidder(a);
+	return archive_read_support_filter_compress(a);
+}
+#endif
 
-	if (bidder == NULL)
-		return (ARCHIVE_FATAL);
+static const struct archive_read_filter_bidder_vtable
+compress_bidder_vtable = {
+	.bid = compress_bidder_bid,
+	.init = compress_bidder_init,
+};
 
-	bidder->data = NULL;
-	bidder->bid = compress_bidder_bid;
-	bidder->init = compress_bidder_init;
-	bidder->options = NULL;
-	bidder->free = compress_bidder_free;
-	return (ARCHIVE_OK);
+int
+archive_read_support_filter_compress(struct archive *_a)
+{
+	struct archive_read *a = (struct archive_read *)_a;
+
+	return __archive_read_register_bidder(a, NULL, "compress (.Z)",
+			&compress_bidder_vtable);
 }
 
 /*
  * Test whether we can handle this data.
- *
- * This logic returns zero if any part of the signature fails.  It
- * also tries to Do The Right Thing if a very short buffer prevents us
- * from verifying as much as we would like.
+ * This logic returns zero if any part of the signature fails.
  */
 static int
 compress_bidder_bid(struct archive_read_filter_bidder *self,
@@ -174,27 +178,32 @@ compress_bidder_bid(struct archive_read_filter_bidder *self,
 
 	(void)self; /* UNUSED */
 
-	buffer = __archive_read_filter_ahead(filter, 2, &avail);
+	/* Shortest valid compress file is 3 bytes. */
+	buffer = __archive_read_filter_ahead(filter, 3, &avail);
 
 	if (buffer == NULL)
 		return (0);
 
 	bits_checked = 0;
-	if (buffer[0] != 037)	/* Verify first ID byte. */
+	/* First two bytes are the magic value */
+	if (buffer[0] != 0x1F || buffer[1] != 0x9D)
 		return (0);
-	bits_checked += 8;
-
-	if (buffer[1] != 0235)	/* Verify second ID byte. */
+	/* Third byte holds compression parameters. */
+	if (buffer[2] & 0x20) /* Reserved bit, must be zero. */
 		return (0);
-	bits_checked += 8;
-
-	/*
-	 * TODO: Verify more.
-	 */
+	if (buffer[2] & 0x40) /* Reserved bit, must be zero. */
+		return (0);
+	bits_checked += 18;
 
 	return (bits_checked);
 }
 
+static const struct archive_read_filter_vtable
+compress_reader_vtable = {
+	.read = compress_filter_read,
+	.close = compress_filter_close,
+};
+
 /*
  * Setup the callbacks.
  */
@@ -206,7 +215,7 @@ compress_bidder_init(struct archive_read_filter *self)
 	void *out_block;
 	int code;
 
-	self->code = ARCHIVE_COMPRESSION_COMPRESS;
+	self->code = ARCHIVE_FILTER_COMPRESS;
 	self->name = "compress (.Z)";
 
 	state = (struct private_data *)calloc(sizeof(*state), 1);
@@ -223,16 +232,20 @@ compress_bidder_init(struct archive_read_filter *self)
 	self->data = state;
 	state->out_block_size = out_block_size;
 	state->out_block = out_block;
-	self->read = compress_filter_read;
-	self->skip = NULL; /* not supported */
-	self->close = compress_filter_close;
+	self->vtable = &compress_reader_vtable;
 
 	/* XXX MOVE THE FOLLOWING OUT OF INIT() XXX */
 
 	(void)getbits(self, 8); /* Skip first signature byte. */
 	(void)getbits(self, 8); /* Skip second signature byte. */
 
+	/* Get compression parameters. */
 	code = getbits(self, 8);
+	if ((code & 0x1f) > 16) {
+		archive_set_error(&self->archive->archive, -1,
+		    "Invalid compressed data");
+		return (ARCHIVE_FATAL);
+	}
 	state->maxcode_bits = code & 0x1f;
 	state->maxcode = (1 << state->maxcode_bits);
 	state->use_reset_code = code & 0x80;
@@ -289,16 +302,6 @@ compress_filter_read(struct archive_read_filter *self, const void **pblock)
 	return (p - start);
 }
 
-/*
- * Clean up the reader.
- */
-static int
-compress_bidder_free(struct archive_read_filter_bidder *self)
-{
-	self->data = NULL;
-	return (ARCHIVE_OK);
-}
-
 /*
  * Close and release the filter.
  */
@@ -361,7 +364,8 @@ next_code(struct archive_read_filter *self)
 		return (next_code(self));
 	}
 
-	if (code > state->free_ent) {
+	if (code > state->free_ent
+	    || (code == state->free_ent && state->oldcode < 0)) {
 		/* An invalid code is a fatal error. */
 		archive_set_error(&(self->archive->archive), -1,
 		    "Invalid compressed data");
@@ -420,6 +424,11 @@ getbits(struct archive_read_filter *self, int n)
 
 	while (state->bits_avail < n) {
 		if (state->avail_in <= 0) {
+			if (state->consume_unnotified) {
+				__archive_read_filter_consume(self->upstream,
+					state->consume_unnotified);
+				state->consume_unnotified = 0;
+			}
 			state->next_in
 			    = __archive_read_filter_ahead(self->upstream,
 				1, &ret);
@@ -427,8 +436,7 @@ getbits(struct archive_read_filter *self, int n)
 				return (-1);
 			if (ret < 0 || state->next_in == NULL)
 				return (ARCHIVE_FATAL);
-			state->avail_in = ret;
-			__archive_read_filter_consume(self->upstream, ret);
+			state->consume_unnotified = state->avail_in = ret;
 		}
 		state->bit_buffer |= *state->next_in++ << state->bits_avail;
 		state->avail_in--;

data/ext/libarchive-3.6.2/libarchive/archive_read_support_filter_grzip.c

@@ -0,0 +1,112 @@
+/*-
+ * Copyright (c) 2012 Michihiro NAKAJIMA
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "archive_platform.h"
+
+__FBSDID("$FreeBSD$");
+
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "archive.h"
+#include "archive_private.h"
+#include "archive_read_private.h"
+
+static const unsigned char grzip_magic[] = {
+	0x47, 0x52, 0x5a, 0x69, 0x70, 0x49, 0x49, 0x00,
+	0x02, 0x04, 0x3a, 0x29 };
+
+static int	grzip_bidder_bid(struct archive_read_filter_bidder *,
+		    struct archive_read_filter *);
+static int	grzip_bidder_init(struct archive_read_filter *);
+
+
+static const struct archive_read_filter_bidder_vtable
+grzip_bidder_vtable = {
+	.bid = grzip_bidder_bid,
+	.init = grzip_bidder_init,
+};
+
+int
+archive_read_support_filter_grzip(struct archive *_a)
+{
+	struct archive_read *a = (struct archive_read *)_a;
+
+	if (__archive_read_register_bidder(a, NULL, NULL,
+				&grzip_bidder_vtable) != ARCHIVE_OK)
+		return (ARCHIVE_FATAL);
+
+	/* This filter always uses an external program. */
+	archive_set_error(_a, ARCHIVE_ERRNO_MISC,
+	    "Using external grzip program for grzip decompression");
+	return (ARCHIVE_WARN);
+}
+
+/*
+ * Bidder just verifies the header and returns the number of verified bits.
+ */
+static int
+grzip_bidder_bid(struct archive_read_filter_bidder *self,
+    struct archive_read_filter *filter)
+{
+	const unsigned char *p;
+	ssize_t avail;
+
+	(void)self; /* UNUSED */
+
+	p = __archive_read_filter_ahead(filter, sizeof(grzip_magic), &avail);
+	if (p == NULL || avail == 0)
+		return (0);
+
+	if (memcmp(p, grzip_magic, sizeof(grzip_magic)))
+		return (0);
+
+	return (sizeof(grzip_magic) * 8);
+}
+
+static int
+grzip_bidder_init(struct archive_read_filter *self)
+{
+	int r;
+
+	r = __archive_read_program(self, "grzip -d");
+	/* 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_GRZIP;
+	self->name = "grzip";
+	return (r);
+}