This commit was manufactured by cvs2svn to create tag 'busybox_1_00'.

46 files changed, 10404 insertions, 0 deletions

diff --git a/busybox/archival/Config.in b/busybox/archival/Config.in
new file mode 100644
index 000000000..db358db08
--- /dev/null
+++ b/busybox/archival/Config.in
@@ -0,0 +1,258 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+menu "Archival Utilities"
+
+config CONFIG_AR
+        bool "ar"
+        default n
+        help
+          ar is an archival utility program used to create, modify, and
+          extract contents from archives.  An archive is a single file holding
+          a collection of other files in a structure that makes it possible to
+          retrieve the original individual files (called archive members).
+          The original files' contents, mode (permissions), timestamp, owner,
+          and group are preserved in the archive, and can be restored on
+          extraction.
+
+          The stored filename is limited to 15 characters. (for more information
+          see long filename support).
+          ar has 60 bytes of overheads for every stored file.
+
+          This implementation of ar can extract archives, it cannot create or
+          modify them.
+          On an x86 system, the ar applet adds about 1K.
+
+          Unless you have a specific application which requires ar, you should
+          probably say N here.
+
+config CONFIG_FEATURE_AR_LONG_FILENAMES
+        bool "  Enable support for long filenames (not need for debs)"
+        default n
+        depends on CONFIG_AR
+        help
+          By default the ar format can only store the first 15 characters of the
+          filename, this option removes that limitation.
+          It supports the GNU ar long filename method which moves multiple long
+          filenames into a the data section of a new ar entry.
+
+config CONFIG_BUNZIP2
+        bool "bunzip2"
+        default n
+        help
+          bunzip2 is a compression utility using the Burrows-Wheeler block
+          sorting text compression algorithm, and Huffman coding.  Compression
+          is generally considerably better than that achieved by more
+          conventional LZ77/LZ78-based compressors, and approaches the
+          performance of the PPM family of statistical compressors.
+        
+          The BusyBox bunzip2 applet is limited to de-compression only.
+          On an x86 system, this applet adds about 11K.
+        
+          Unless you have a specific application which requires bunzip2, you
+          should probably say N here.
+
+config CONFIG_CPIO
+        bool "cpio"
+        default n
+        help
+          cpio is an archival utility program used to create, modify, and extract
+          contents from archives.
+          cpio has 110 bytes of overheads for every stored file.
+
+          This implementation of cpio can extract cpio archives created in the
+          "newc" or "crc" format, it cannot create or modify them.
+
+          Unless you have a specific application which requires cpio, you should
+          probably say N here.
+
+config CONFIG_DPKG
+        bool "dpkg"
+        default n
+        help
+          dpkg is a medium-level tool to install, build, remove and manage Debian packages.
+        
+          This implementation of dpkg has a number of limitations, you should use the
+          official dpkg if possible.
+
+config CONFIG_DPKG_DEB
+        bool "dpkg_deb"
+        default n
+        help
+          dpkg-deb packs, unpacks and provides information about Debian archives.
+        
+          This implementation of dpkg-deb cannot pack archives.
+        
+          Unless you have a specific application which requires dpkg-deb, you should
+          probably say N here.
+
+config CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY
+        bool "  extract only (-x)"
+        default n
+        depends on CONFIG_DPKG_DEB
+        help
+          This reduces dpkg-deb to the equivalent of "ar -p <deb> data.tar.gz | tar -zx".
+          However it saves space as none of the extra dpkg-deb, ar or tar options are
+          needed, they are linked to internally.
+
+config CONFIG_GUNZIP
+        bool "gunzip"
+        default n
+        help
+          gunzip is used to decompress archives created by gzip.
+          You can use the `-t' option to test the integrity of
+          an archive, without decompressing it.
+
+config CONFIG_FEATURE_GUNZIP_UNCOMPRESS
+        bool "  Uncompress support"
+        default n
+        depends on CONFIG_GUNZIP
+        help
+          Enable if you want gunzip to have the ability to decompress
+          archives created by the program compress (not much
+          used anymore).
+
+config CONFIG_GZIP
+        bool "gzip"
+        default n
+        help
+          gzip is used to compress files.
+          It's probably the most widely used UNIX compression program.
+
+config CONFIG_RPM2CPIO
+        bool "rpm2cpio"
+        default n
+        help
+          Converts an RPM file into a CPIO archive.
+
+config CONFIG_RPM
+        bool "rpm"
+        default n
+        help
+          Mini RPM applet - queries and extracts
+
+config CONFIG_TAR
+        bool "tar"
+        default n
+        help
+          tar is an archiving program. It's commonly used with gzip to
+          create compressed archives. It's probably the most widely used
+          UNIX archive program.
+
+config CONFIG_FEATURE_TAR_CREATE
+        bool "  Enable archive creation"
+        default y
+        depends on CONFIG_TAR
+        help
+          If you enable this option you'll be able to create
+          tar archives using the `-c' option.
+
+config CONFIG_FEATURE_TAR_BZIP2
+        bool "  Enable -j option to handle .tar.bz2 files"
+        default n
+        depends on CONFIG_TAR
+        help
+          If you enable this option you'll be able to extract
+          archives compressed with bzip2.
+
+config CONFIG_FEATURE_TAR_FROM
+        bool "  Enable -X (exclude from) and -T (include from) options)"
+        default n
+        depends on CONFIG_TAR
+        help
+          If you enable this option you'll be able to specify
+          a list of files to include or exclude from an archive.
+
+config CONFIG_FEATURE_TAR_GZIP
+        bool "  Enable -z option"
+        default y
+        depends on CONFIG_TAR
+        help
+          If you enable this option tar will be able to call gzip,
+          when creating or extracting tar gziped archives.
+
+config CONFIG_FEATURE_TAR_COMPRESS
+        bool "  Enable -Z option"
+        default n
+        depends on CONFIG_TAR
+        help
+          If you enable this option tar will be able to call uncompress,
+          when extracting .tar.Z archives.
+
+config CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
+        bool "  Enable support for old tar header format"
+        default N
+        depends on CONFIG_TAR
+        help
+          This option is required to unpack archives created in
+          the old GNU format; help to kill this old format by
+          repacking your ancient archives with the new format.
+
+config CONFIG_FEATURE_TAR_GNU_EXTENSIONS
+        bool "  Enable support for some GNU tar extensions"
+        default y
+        depends on CONFIG_TAR
+        help
+          With this option busybox supports GNU long filenames and
+          linknames.
+
+config CONFIG_FEATURE_TAR_LONG_OPTIONS
+        bool "  Enable long options"
+        default n
+        depends on CONFIG_TAR
+        help
+                Enable use of long options, increases size by about 400 Bytes
+
+config CONFIG_UNCOMPRESS
+        bool "uncompress"
+        default n
+        help
+          uncompress is used to decompress archives created by compress.
+          Not much used anymore, replaced by gzip/gunzip.
+
+config CONFIG_UNZIP
+        bool "unzip"
+        default n
+        help
+          unzip will list or extract files from a ZIP archive,
+          commonly found on DOS/WIN systems. The default behavior
+          (with no options) is to extract the archive into the
+          current directory. Use the `-d' option to extract to a
+          directory of your choice.
+
+comment "Common options for cpio and tar"
+        depends on CONFIG_CPIO || CONFIG_TAR
+
+config CONFIG_FEATURE_UNARCHIVE_TAPE
+        bool "  Enable tape drive support"
+        default n
+        depends on CONFIG_CPIO || CONFIG_TAR
+        help
+          I don't think this is needed anymore.
+
+comment "Common options for dpkg and dpkg_deb"
+        depends on CONFIG_DPKG || CONFIG_DPKG_DEB
+
+config CONFIG_FEATURE_DEB_TAR_GZ
+        bool "  gzip debian packages (normal)"
+        default y if CONFIG_DPKG || CONFIG_DPKG_DEB
+        depends on CONFIG_DPKG || CONFIG_DPKG_DEB
+        help
+          This is the default compression method inside the debian ar file.
+        
+          If you want compatibility with standard .deb's you should say yes here.
+
+config CONFIG_FEATURE_DEB_TAR_BZ2
+        bool "  bzip2 debian packages"
+        default n
+        depends on CONFIG_DPKG || CONFIG_DPKG_DEB
+        help
+          This allows dpkg and dpkg-deb to extract deb's that are compressed internally
+          with bzip2 instead of gzip.
+        
+          You only want this if you are creating your own custom debian packages that
+          use an internal control.tar.bz2 or data.tar.bz2.
+
+endmenu
diff --git a/busybox/archival/Makefile b/busybox/archival/Makefile
new file mode 100644
index 000000000..a96daa4df
--- /dev/null
+++ b/busybox/archival/Makefile
@@ -0,0 +1,32 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+top_srcdir=..
+top_builddir=..
+ARCHIVAL_DIR:=./
+srcdir=$(top_srcdir)/archival
+include $(top_builddir)/Rules.mak
+include $(top_builddir)/.config
+include $(srcdir)/Makefile.in
+all: $(libraries-y)
+-include $(top_builddir)/.depend
+
+clean:
+        rm -f *.o *.a $(AR_TARGET)
+
diff --git a/busybox/archival/Makefile.in b/busybox/archival/Makefile.in
new file mode 100644
index 000000000..76ab6cd08
--- /dev/null
+++ b/busybox/archival/Makefile.in
@@ -0,0 +1,48 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+ARCHIVAL_AR:=archival.a
+ifndef $(ARCHIVAL_DIR)
+ARCHIVAL_DIR:=$(top_builddir)/archival/
+endif
+srcdir=$(top_srcdir)/archival
+
+ARCHIVAL-y:=
+ARCHIVAL-$(CONFIG_APT_GET)      +=
+ARCHIVAL-$(CONFIG_AR)           += ar.o
+ARCHIVAL-$(CONFIG_BUNZIP2)      += bunzip2.o
+ARCHIVAL-$(CONFIG_CPIO)         += cpio.o
+ARCHIVAL-$(CONFIG_DPKG)         += dpkg.o
+ARCHIVAL-$(CONFIG_DPKG_DEB)     += dpkg_deb.o
+ARCHIVAL-$(CONFIG_GUNZIP)       += gunzip.o
+ARCHIVAL-$(CONFIG_GZIP)         += gzip.o
+ARCHIVAL-$(CONFIG_RPM2CPIO)     += rpm2cpio.o
+ARCHIVAL-$(CONFIG_RPM)          += rpm.o
+ARCHIVAL-$(CONFIG_TAR)          += tar.o
+ARCHIVAL-$(CONFIG_UNCOMPRESS)   += uncompress.o
+ARCHIVAL-$(CONFIG_UNZIP)        += unzip.o
+
+libraries-y+=$(ARCHIVAL_DIR)$(ARCHIVAL_AR)
+
+$(ARCHIVAL_DIR)$(ARCHIVAL_AR): $(patsubst %,$(ARCHIVAL_DIR)%, $(ARCHIVAL-y))
+        $(AR) -ro $@ $(patsubst %,$(ARCHIVAL_DIR)%, $(ARCHIVAL-y))
+
+$(ARCHIVAL_DIR)%.o: $(srcdir)/%.c
+        $(CC) $(CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<
+
diff --git a/busybox/archival/ar.c b/busybox/archival/ar.c
new file mode 100644
index 000000000..44c5db035
--- /dev/null
+++ b/busybox/archival/ar.c
@@ -0,0 +1,110 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini ar implementation for busybox
+ *
+ * Copyright (C) 2000 by Glenn McGrath
+ * Written by Glenn McGrath <bug1@iinet.net.au> 1 June 2000
+ *
+ * Based in part on BusyBox tar, Debian dpkg-deb and GNU ar.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * There is no single standard to adhere to so ar may not portable
+ * between different systems
+ * http://www.unix-systems.org/single_unix_specification_v2/xcu/ar.html
+ */
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <utime.h>
+#include <unistd.h>
+
+#include "unarchive.h"
+#include "busybox.h"
+
+static void header_verbose_list_ar(const file_header_t *file_header)
+{
+        const char *mode = bb_mode_string(file_header->mode);
+        char *mtime;
+
+        mtime = ctime(&file_header->mtime);
+        mtime[16] = ' ';
+        memmove(&mtime[17], &mtime[20], 4);
+        mtime[21] = '\0';
+        printf("%s %d/%d%7d %s %s\n", &mode[1], file_header->uid, file_header->gid, (int) file_header->size, &mtime[4], file_header->name);
+}
+
+#define AR_CTX_PRINT                    0x01
+#define AR_CTX_LIST                             0x02
+#define AR_CTX_EXTRACT                  0x04
+#define AR_OPT_PRESERVE_DATE    0x08
+#define AR_OPT_VERBOSE                  0x10
+#define AR_OPT_CREATE                   0x20
+
+extern int ar_main(int argc, char **argv)
+{
+        archive_handle_t *archive_handle;
+        unsigned long opt;
+        char magic[8];
+
+        archive_handle = init_handle();
+
+        bb_opt_complementaly = "p~tx:t~px:x~pt";
+        opt = bb_getopt_ulflags(argc, argv, "ptxovc");
+
+        if ((opt & 0x80000000UL) || (optind == argc)) {
+                bb_show_usage();
+        }
+
+        if (opt & AR_CTX_PRINT) {
+                archive_handle->action_data = data_extract_to_stdout;
+        }
+        if (opt & AR_CTX_LIST) {
+                archive_handle->action_header = header_list;
+        }
+        if (opt & AR_CTX_EXTRACT) {
+                archive_handle->action_data = data_extract_all;
+        }
+        if (opt & AR_OPT_PRESERVE_DATE) {
+                archive_handle->flags |= ARCHIVE_PRESERVE_DATE;
+        }
+        if (opt & AR_OPT_VERBOSE) {
+                archive_handle->action_header = header_verbose_list_ar;
+        }
+        if (opt & AR_OPT_CREATE) {
+                bb_error_msg_and_die("Archive creation not supported.  Install binutils 'ar'.");
+        }
+
+        archive_handle->src_fd = bb_xopen(argv[optind++], O_RDONLY);
+
+        while (optind < argc) {
+                archive_handle->filter = filter_accept_list;
+                archive_handle->accept = llist_add_to(archive_handle->accept, argv[optind++]);
+        }
+
+        archive_xread_all(archive_handle, magic, 7);
+        if (strncmp(magic, "!<arch>", 7) != 0) {
+                bb_error_msg_and_die("Invalid ar magic");
+        }
+        archive_handle->offset += 7;
+
+        while (get_header_ar(archive_handle) == EXIT_SUCCESS);
+
+        return EXIT_SUCCESS;
+}
diff --git a/busybox/archival/bunzip2.c b/busybox/archival/bunzip2.c
new file mode 100644
index 000000000..bedd38c22
--- /dev/null
+++ b/busybox/archival/bunzip2.c
@@ -0,0 +1,91 @@
+/*
+ *  Modified for busybox by Glenn McGrath <bug1@iinet.net.au>
+ *  Added support output to stdout by Thomas Lundquist <thomasez@zelow.no>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "busybox.h"
+#include "unarchive.h"
+
+#define BUNZIP2_OPT_STDOUT      1
+#define BUNZIP2_OPT_FORCE       2
+
+int bunzip2_main(int argc, char **argv)
+{
+        char *compressed_name;
+        /* Note: Ignore the warning about save_name being used uninitialized.
+         * That is not the case, but gcc has trouble working that out... */
+        char *save_name;
+        unsigned long opt;
+        int status;
+        int src_fd;
+        int dst_fd;
+
+        opt = bb_getopt_ulflags(argc, argv, "cf");
+
+        /* if called as bzcat force the stdout flag */
+        if (bb_applet_name[2] == 'c') {
+                opt |= BUNZIP2_OPT_STDOUT;
+        }
+
+        /* Set input filename and number */
+        compressed_name = argv[optind];
+        if ((compressed_name) && (compressed_name[0] != '-') && (compressed_name[1] != '\0')) {
+                /* Open input file */
+                src_fd = bb_xopen(compressed_name, O_RDONLY);
+        } else {
+                src_fd = STDIN_FILENO;
+                opt |= BUNZIP2_OPT_STDOUT;
+        }
+
+        /* Check that the input is sane.  */
+        if (isatty(src_fd) && (opt & BUNZIP2_OPT_FORCE) == 0) {
+                bb_error_msg_and_die("compressed data not read from terminal.  Use -f to force it.");
+        }
+
+        if (opt & BUNZIP2_OPT_STDOUT) {
+                dst_fd = STDOUT_FILENO;
+        } else {
+                int len = strlen(compressed_name) - 4;
+                if (strcmp(compressed_name + len, ".bz2") != 0) {
+                        bb_error_msg_and_die("Invalid extension");
+                }
+                save_name = bb_xstrndup(compressed_name, len);
+                dst_fd = bb_xopen(save_name, O_WRONLY | O_CREAT);
+        }
+
+        status = uncompressStream(src_fd, dst_fd);
+        if(!(opt & BUNZIP2_OPT_STDOUT)) {
+                char *delete_name;
+                if (status) {
+                        delete_name = save_name;
+                } else {
+                        delete_name = compressed_name;
+                }
+                if (unlink(delete_name) < 0) {
+                        bb_error_msg_and_die("Couldn't remove %s", delete_name);
+                }
+        }
+
+        return status;
+}
diff --git a/busybox/archival/cpio.c b/busybox/archival/cpio.c
new file mode 100644
index 000000000..0fbe7b8e5
--- /dev/null
+++ b/busybox/archival/cpio.c
@@ -0,0 +1,99 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini cpio implementation for busybox
+ *
+ * Copyright (C) 2001 by Glenn McGrath
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Limitations:
+ *              Doesn't check CRC's
+ *              Only supports new ASCII and CRC formats
+ *
+ */
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "unarchive.h"
+#include "busybox.h"
+
+#define CPIO_OPT_EXTRACT                0x01
+#define CPIO_OPT_TEST                   0x02
+#define CPIO_OPT_UNCONDITIONAL          0x04
+#define CPIO_OPT_VERBOSE                0x08
+#define CPIO_OPT_FILE                   0x10
+#define CPIO_OPT_CREATE_LEADING_DIR     0x20
+#define CPIO_OPT_PRESERVE_MTIME         0x40
+
+extern int cpio_main(int argc, char **argv)
+{
+        archive_handle_t *archive_handle;
+        char *cpio_filename = NULL;
+        unsigned long opt;
+
+        /* Initialise */
+        archive_handle = init_handle();
+        archive_handle->src_fd = STDIN_FILENO;
+        archive_handle->seek = seek_by_char;
+        archive_handle->flags = ARCHIVE_EXTRACT_NEWER | ARCHIVE_PRESERVE_DATE;
+
+        opt = bb_getopt_ulflags(argc, argv, "ituvF:dm", &cpio_filename);
+
+        /* One of either extract or test options must be given */
+        if ((opt & (CPIO_OPT_TEST | CPIO_OPT_EXTRACT)) == 0) {
+                bb_show_usage();
+        }
+
+        if (opt & CPIO_OPT_TEST) {
+                /* if both extract and test option are given, ignore extract option */
+                if (opt & CPIO_OPT_EXTRACT) {
+                        opt &= ~CPIO_OPT_EXTRACT;
+                }
+                archive_handle->action_header = header_list;
+        }
+        if (opt & CPIO_OPT_EXTRACT) {
+                archive_handle->action_data = data_extract_all;
+        }
+        if (opt & CPIO_OPT_UNCONDITIONAL) {
+                archive_handle->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+                archive_handle->flags &= ~ARCHIVE_EXTRACT_NEWER;
+        }
+        if (opt & CPIO_OPT_VERBOSE) {
+                if (archive_handle->action_header == header_list) {
+                        archive_handle->action_header = header_verbose_list;
+                } else {
+                        archive_handle->action_header = header_list;
+                }
+        }
+        if (cpio_filename) {    /* CPIO_OPT_FILE */
+                archive_handle->src_fd = bb_xopen(cpio_filename, O_RDONLY);
+                archive_handle->seek = seek_by_jump;
+        }
+        if (opt & CPIO_OPT_CREATE_LEADING_DIR) {
+                archive_handle->flags |= ARCHIVE_CREATE_LEADING_DIRS;
+        }
+
+        while (optind < argc) {
+                archive_handle->filter = filter_accept_list;
+                archive_handle->accept = llist_add_to(archive_handle->accept, argv[optind]);
+                optind++;
+        }
+
+        while (get_header_cpio(archive_handle) == EXIT_SUCCESS);
+
+        return(EXIT_SUCCESS);
+}
diff --git a/busybox/archival/dpkg.c b/busybox/archival/dpkg.c
new file mode 100644
index 000000000..c096518a2
--- /dev/null
+++ b/busybox/archival/dpkg.c
@@ -0,0 +1,1833 @@
+/*
+ *  Mini dpkg implementation for busybox.
+ *  This is not meant as a replacement for dpkg
+ *
+ *  Written By Glenn McGrath with the help of others
+ *  Copyright (C) 2001 by Glenn McGrath
+ *
+ *  Started life as a busybox implementation of udpkg
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Known difference between busybox dpkg and the official dpkg that i don't
+ * consider important, its worth keeping a note of differences anyway, just to
+ * make it easier to maintain.
+ *  - The first value for the Confflile: field isnt placed on a new line.
+ *  - When installing a package the Status: field is placed at the end of the
+ *      section, rather than just after the Package: field.
+ *
+ * Bugs that need to be fixed
+ *  - (unknown, please let me know when you find any)
+ *
+ */
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "unarchive.h"
+#include "busybox.h"
+
+/* NOTE: If you vary HASH_PRIME sizes be aware,
+ * 1) Tweaking these will have a big effect on how much memory this program uses.
+ * 2) For computational efficiency these hash tables should be at least 20%
+ *    larger than the maximum number of elements stored in it.
+ * 3) All _HASH_PRIME's must be a prime number or chaos is assured, if your looking
+ *    for a prime, try http://www.utm.edu/research/primes/lists/small/10000.txt
+ * 4) If you go bigger than 15 bits you may get into trouble (untested) as its
+ *    sometimes cast to an unsigned int, if you go to 16 bit you will overlap
+ *    int's and chaos is assured, 16381 is the max prime for 14 bit field
+ */
+
+/* NAME_HASH_PRIME, Stores package names and versions,
+ * I estimate it should be at least 50% bigger than PACKAGE_HASH_PRIME,
+ * as there a lot of duplicate version numbers */
+#define NAME_HASH_PRIME 16381
+char *name_hashtable[NAME_HASH_PRIME + 1];
+
+/* PACKAGE_HASH_PRIME, Maximum number of unique packages,
+ * It must not be smaller than STATUS_HASH_PRIME,
+ * Currently only packages from status_hashtable are stored in here, but in
+ * future this may be used to store packages not only from a status file,
+ * but an available_hashtable, and even multiple packages files.
+ * Package can be stored more than once if they have different versions.
+ * e.g. The same package may have different versions in the status file
+ *      and available file */
+#define PACKAGE_HASH_PRIME 10007
+typedef struct edge_s {
+        unsigned int operator:3;
+        unsigned int type:4;
+        unsigned int name:14;
+        unsigned int version:14;
+} edge_t;
+
+typedef struct common_node_s {
+        unsigned int name:14;
+        unsigned int version:14;
+        unsigned int num_of_edges:14;
+        edge_t **edge;
+} common_node_t;
+common_node_t *package_hashtable[PACKAGE_HASH_PRIME + 1];
+
+/* Currently it doesnt store packages that have state-status of not-installed
+ * So it only really has to be the size of the maximum number of packages
+ * likely to be installed at any one time, so there is a bit of leeway here */
+#define STATUS_HASH_PRIME 8191
+typedef struct status_node_s {
+        unsigned int package:14;        /* has to fit PACKAGE_HASH_PRIME */
+        unsigned int status:14;         /* has to fit STATUS_HASH_PRIME */
+} status_node_t;
+status_node_t *status_hashtable[STATUS_HASH_PRIME + 1];
+
+/* Even numbers are for 'extras', like ored dependencies or null */
+enum edge_type_e {
+        EDGE_NULL = 0,
+        EDGE_PRE_DEPENDS = 1,
+        EDGE_OR_PRE_DEPENDS = 2,
+        EDGE_DEPENDS = 3,
+        EDGE_OR_DEPENDS = 4,
+        EDGE_REPLACES = 5,
+        EDGE_PROVIDES = 7,
+        EDGE_CONFLICTS = 9,
+        EDGE_SUGGESTS = 11,
+        EDGE_RECOMMENDS = 13,
+        EDGE_ENHANCES = 15
+};
+enum operator_e {
+        VER_NULL = 0,
+        VER_EQUAL = 1,
+        VER_LESS = 2,
+        VER_LESS_EQUAL = 3,
+        VER_MORE = 4,
+        VER_MORE_EQUAL = 5,
+        VER_ANY = 6
+};
+
+enum dpkg_opt_e {
+        dpkg_opt_purge = 1,
+        dpkg_opt_remove = 2,
+        dpkg_opt_unpack = 4,
+        dpkg_opt_configure = 8,
+        dpkg_opt_install = 16,
+        dpkg_opt_package_name = 32,
+        dpkg_opt_filename = 64,
+        dpkg_opt_list_installed = 128,
+        dpkg_opt_force_ignore_depends = 256
+};
+
+typedef struct deb_file_s {
+        char *control_file;
+        char *filename;
+        unsigned int package:14;
+} deb_file_t;
+
+
+void make_hash(const char *key, unsigned int *start, unsigned int *decrement, const int hash_prime)
+{
+        unsigned long int hash_num = key[0];
+        int len = strlen(key);
+        int i;
+
+        /* Maybe i should have uses a "proper" hashing algorithm here instead
+         * of making one up myself, seems to be working ok though. */
+        for(i = 1; i < len; i++) {
+                /* shifts the ascii based value and adds it to previous value
+                 * shift amount is mod 24 because long int is 32 bit and data
+                 * to be shifted is 8, don't want to shift data to where it has
+                 * no effect*/
+                hash_num += ((key[i] + key[i-1]) << ((key[i] * i) % 24));
+        }
+        *start = (unsigned int) hash_num % hash_prime;
+        *decrement = (unsigned int) 1 + (hash_num % (hash_prime - 1));
+}
+
+/* this adds the key to the hash table */
+int search_name_hashtable(const char *key)
+{
+        unsigned int probe_address = 0;
+        unsigned int probe_decrement = 0;
+//      char *temp;
+
+        make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME);
+        while(name_hashtable[probe_address] != NULL) {
+                if (strcmp(name_hashtable[probe_address], key) == 0) {
+                        return(probe_address);
+                } else {
+                        probe_address -= probe_decrement;
+                        if ((int)probe_address < 0) {
+                                probe_address += NAME_HASH_PRIME;
+                        }
+                }
+        }
+        name_hashtable[probe_address] = bb_xstrdup(key);
+        return(probe_address);
+}
+
+/* this DOESNT add the key to the hashtable
+ * TODO make it consistent with search_name_hashtable
+ */
+unsigned int search_status_hashtable(const char *key)
+{
+        unsigned int probe_address = 0;
+        unsigned int probe_decrement = 0;
+
+        make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME);
+        while(status_hashtable[probe_address] != NULL) {
+                if (strcmp(key, name_hashtable[package_hashtable[status_hashtable[probe_address]->package]->name]) == 0) {
+                        break;
+                } else {
+                        probe_address -= probe_decrement;
+                        if ((int)probe_address < 0) {
+                                probe_address += STATUS_HASH_PRIME;
+                        }
+                }
+        }
+        return(probe_address);
+}
+
+/* Need to rethink version comparison, maybe the official dpkg has something i can use ? */
+int version_compare_part(const char *version1, const char *version2)
+{
+        int upstream_len1 = 0;
+        int upstream_len2 = 0;
+        char *name1_char;
+        char *name2_char;
+        int len1 = 0;
+        int len2 = 0;
+        int tmp_int;
+        int ver_num1;
+        int ver_num2;
+        int ret;
+
+        if (version1 == NULL) {
+                version1 = bb_xstrdup("");
+        }
+        if (version2 == NULL) {
+                version2 = bb_xstrdup("");
+        }
+        upstream_len1 = strlen(version1);
+        upstream_len2 = strlen(version2);
+
+        while ((len1 < upstream_len1) || (len2 < upstream_len2)) {
+                /* Compare non-digit section */
+                tmp_int = strcspn(&version1[len1], "0123456789");
+                name1_char = bb_xstrndup(&version1[len1], tmp_int);
+                len1 += tmp_int;
+                tmp_int = strcspn(&version2[len2], "0123456789");
+                name2_char = bb_xstrndup(&version2[len2], tmp_int);
+                len2 += tmp_int;
+                tmp_int = strcmp(name1_char, name2_char);
+                free(name1_char);
+                free(name2_char);
+                if (tmp_int != 0) {
+                        ret = tmp_int;
+                        goto cleanup_version_compare_part;
+                }
+
+                /* Compare digits */
+                tmp_int = strspn(&version1[len1], "0123456789");
+                name1_char = bb_xstrndup(&version1[len1], tmp_int);
+                len1 += tmp_int;
+                tmp_int = strspn(&version2[len2], "0123456789");
+                name2_char = bb_xstrndup(&version2[len2], tmp_int);
+                len2 += tmp_int;
+                ver_num1 = atoi(name1_char);
+                ver_num2 = atoi(name2_char);
+                free(name1_char);
+                free(name2_char);
+                if (ver_num1 < ver_num2) {
+                        ret = -1;
+                        goto cleanup_version_compare_part;
+                }
+                else if (ver_num1 > ver_num2) {
+                        ret = 1;
+                        goto cleanup_version_compare_part;
+                }
+        }
+        ret = 0;
+cleanup_version_compare_part:
+        return(ret);
+}
+
+/* if ver1 < ver2 return -1,
+ * if ver1 = ver2 return 0,
+ * if ver1 > ver2 return 1,
+ */
+int version_compare(const unsigned int ver1, const unsigned int ver2)
+{
+        char *ch_ver1 = name_hashtable[ver1];
+        char *ch_ver2 = name_hashtable[ver2];
+
+        char epoch1, epoch2;
+        char *deb_ver1, *deb_ver2;
+        char *ver1_ptr, *ver2_ptr;
+        char *upstream_ver1;
+        char *upstream_ver2;
+        int result;
+
+        /* Compare epoch */
+        if (ch_ver1[1] == ':') {
+                epoch1 = ch_ver1[0];
+                ver1_ptr = strchr(ch_ver1, ':') + 1;
+        } else {
+                epoch1 = '0';
+                ver1_ptr = ch_ver1;
+        }
+        if (ch_ver2[1] == ':') {
+                epoch2 = ch_ver2[0];
+                ver2_ptr = strchr(ch_ver2, ':') + 1;
+        } else {
+                epoch2 = '0';
+                ver2_ptr = ch_ver2;
+        }
+        if (epoch1 < epoch2) {
+                return(-1);
+        }
+        else if (epoch1 > epoch2) {
+                return(1);
+        }
+
+        /* Compare upstream version */
+        upstream_ver1 = bb_xstrdup(ver1_ptr);
+        upstream_ver2 = bb_xstrdup(ver2_ptr);
+
+        /* Chop off debian version, and store for later use */
+        deb_ver1 = strrchr(upstream_ver1, '-');
+        deb_ver2 = strrchr(upstream_ver2, '-');
+        if (deb_ver1) {
+                deb_ver1[0] = '\0';
+                deb_ver1++;
+        }
+        if (deb_ver2) {
+                deb_ver2[0] = '\0';
+                deb_ver2++;
+        }
+        result = version_compare_part(upstream_ver1, upstream_ver2);
+
+        free(upstream_ver1);
+        free(upstream_ver2);
+
+        if (result != 0) {
+                return(result);
+        }
+
+        /* Compare debian versions */
+        return(version_compare_part(deb_ver1, deb_ver2));
+}
+
+int test_version(const unsigned int version1, const unsigned int version2, const unsigned int operator)
+{
+        const int version_result = version_compare(version1, version2);
+        switch(operator) {
+                case (VER_ANY):
+                        return(TRUE);
+                case (VER_EQUAL):
+                        if (version_result == 0) {
+                                return(TRUE);
+                        }
+                        break;
+                case (VER_LESS):
+                        if (version_result < 0) {
+                                return(TRUE);
+                        }
+                        break;
+                case (VER_LESS_EQUAL):
+                        if (version_result <= 0) {
+                                return(TRUE);
+                        }
+                        break;
+                case (VER_MORE):
+                        if (version_result > 0) {
+                                return(TRUE);
+                        }
+                        break;
+                case (VER_MORE_EQUAL):
+                        if (version_result >= 0) {
+                                return(TRUE);
+                        }
+                        break;
+        }
+        return(FALSE);
+}
+
+
+int search_package_hashtable(const unsigned int name, const unsigned int version, const unsigned int operator)
+{
+        unsigned int probe_address = 0;
+        unsigned int probe_decrement = 0;
+
+        make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME);
+        while(package_hashtable[probe_address] != NULL) {
+                if (package_hashtable[probe_address]->name == name) {
+                        if (operator == VER_ANY) {
+                                return(probe_address);
+                        }
+                        if (test_version(package_hashtable[probe_address]->version, version, operator)) {
+                                return(probe_address);
+                        }
+                }
+                probe_address -= probe_decrement;
+                if ((int)probe_address < 0) {
+                        probe_address += PACKAGE_HASH_PRIME;
+                }
+        }
+        return(probe_address);
+}
+
+/*
+ * This function searches through the entire package_hashtable looking
+ * for a package which provides "needle". It returns the index into
+ * the package_hashtable for the providing package.
+ *
+ * needle is the index into name_hashtable of the package we are
+ * looking for.
+ *
+ * start_at is the index in the package_hashtable to start looking
+ * at. If start_at is -1 then start at the beginning. This is to allow
+ * for repeated searches since more than one package might provide
+ * needle.
+ *
+ * FIXME: I don't think this is very efficient, but I thought I'd keep
+ * it simple for now until it proves to be a problem.
+ */
+int search_for_provides(int needle, int start_at) {
+        int i, j;
+        common_node_t *p;
+        for (i = start_at + 1; i < PACKAGE_HASH_PRIME; i++) {
+                p = package_hashtable[i];
+                if ( p == NULL ) continue;
+                for(j = 0; j < p->num_of_edges; j++)
+                        if ( p->edge[j]->type == EDGE_PROVIDES && p->edge[j]->name == needle )
+                                return i;
+        }
+        return -1;
+}
+
+/*
+ * Add an edge to a node
+ */
+void add_edge_to_node(common_node_t *node, edge_t *edge)
+{
+        node->num_of_edges++;
+        node->edge = xrealloc(node->edge, sizeof(edge_t) * (node->num_of_edges + 1));
+        node->edge[node->num_of_edges - 1] = edge;
+}
+
+/*
+ * Create one new node and one new edge for every dependency.
+ *
+ * Dependencies which contain multiple alternatives are represented as
+ * an EDGE_OR_PRE_DEPENDS or EDGE_OR_DEPENDS node, followed by a
+ * number of EDGE_PRE_DEPENDS or EDGE_DEPENDS nodes. The name field of
+ * the OR edge contains the full dependency string while the version
+ * field contains the number of EDGE nodes which follow as part of
+ * this alternative.
+ */
+void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned int edge_type)
+{
+        char *line = bb_xstrdup(whole_line);
+        char *line2;
+        char *line_ptr1 = NULL;
+        char *line_ptr2 = NULL;
+        char *field;
+        char *field2;
+        char *version;
+        edge_t *edge;
+        edge_t *or_edge;
+        int offset_ch;
+
+        field = strtok_r(line, ",", &line_ptr1);
+        do {
+                /* skip leading spaces */
+                field += strspn(field, " ");
+                line2 = bb_xstrdup(field);
+                field2 = strtok_r(line2, "|", &line_ptr2);
+                if ( (edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS) &&
+                     (strcmp(field, field2) != 0)) {
+                        or_edge = (edge_t *)xmalloc(sizeof(edge_t));
+                        or_edge->type = edge_type + 1;
+                } else {
+                        or_edge = NULL;
+                }
+
+                if ( or_edge ) {
+                        or_edge->name = search_name_hashtable(field);
+                        or_edge->version = 0; // tracks the number of altenatives
+
+                        add_edge_to_node(parent_node, or_edge);
+                }
+
+                do {
+                        edge = (edge_t *) xmalloc(sizeof(edge_t));
+                        edge->type = edge_type;
+
+                        /* Skip any extra leading spaces */
+                        field2 += strspn(field2, " ");
+
+                        /* Get dependency version info */
+                        version = strchr(field2, '(');
+                        if (version == NULL) {
+                                edge->operator = VER_ANY;
+                                /* Get the versions hash number, adding it if the number isnt already in there */
+                                edge->version = search_name_hashtable("ANY");
+                        } else {
+                                /* Skip leading ' ' or '(' */
+                                version += strspn(field2, " ");
+                                version += strspn(version, "(");
+                                /* Calculate length of any operator characters */
+                                offset_ch = strspn(version, "<=>");
+                                /* Determine operator */
+                                if (offset_ch > 0) {
+                                        if (strncmp(version, "=", offset_ch) == 0) {
+                                                edge->operator = VER_EQUAL;
+                                        }
+                                        else if (strncmp(version, "<<", offset_ch) == 0) {
+                                                edge->operator = VER_LESS;
+                                        }
+                                        else if (strncmp(version, "<=", offset_ch) == 0) {
+                                                edge->operator = VER_LESS_EQUAL;
+                                        }
+                                        else if (strncmp(version, ">>", offset_ch) == 0) {
+                                                edge->operator = VER_MORE;
+                                        }
+                                        else if (strncmp(version, ">=", offset_ch) == 0) {
+                                                edge->operator = VER_MORE_EQUAL;
+                                        } else {
+                                                bb_error_msg_and_die("Illegal operator\n");
+                                        }
+                                }
+                                /* skip to start of version numbers */
+                                version += offset_ch;
+                                version += strspn(version, " ");
+
+                                /* Truncate version at trailing ' ' or ')' */
+                                version[strcspn(version, " )")] = '\0';
+                                /* Get the versions hash number, adding it if the number isnt already in there */
+                                edge->version = search_name_hashtable(version);
+                        }
+
+                        /* Get the dependency name */
+                        field2[strcspn(field2, " (")] = '\0';
+                        edge->name = search_name_hashtable(field2);
+
+                        if ( or_edge )
+                                or_edge->version++;
+
+                        add_edge_to_node(parent_node, edge);
+                } while ((field2 = strtok_r(NULL, "|", &line_ptr2)) != NULL);
+                free(line2);
+        } while ((field = strtok_r(NULL, ",", &line_ptr1)) != NULL);
+        free(line);
+
+        return;
+}
+
+void free_package(common_node_t *node)
+{
+        unsigned short i;
+        if (node) {
+                for (i = 0; i < node->num_of_edges; i++) {
+                        free(node->edge[i]);
+                }
+                if ( node->edge )
+                        free(node->edge);
+                free(node);
+        }
+}
+
+unsigned int fill_package_struct(char *control_buffer)
+{
+        common_node_t *new_node = (common_node_t *) xcalloc(1, sizeof(common_node_t));
+        const char *field_names[] = { "Package", "Version", "Pre-Depends", "Depends",
+                "Replaces", "Provides", "Conflicts", "Suggests", "Recommends", "Enhances", 0};
+        char *field_name;
+        char *field_value;
+        int field_start = 0;
+        int num = -1;
+        int buffer_length = strlen(control_buffer);
+
+        new_node->version = search_name_hashtable("unknown");
+        while (field_start < buffer_length) {
+                unsigned short field_num;
+
+                field_start += read_package_field(&control_buffer[field_start],
+                                &field_name, &field_value);
+
+                if (field_name == NULL) {
+                        goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement ! */
+                }
+
+                field_num = compare_string_array(field_names, field_name);
+                switch(field_num) {
+                        case 0: /* Package */
+                                new_node->name = search_name_hashtable(field_value);
+                                break;
+                        case 1: /* Version */
+                                new_node->version = search_name_hashtable(field_value);
+                                break;
+                        case 2: /* Pre-Depends */
+                                add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS);
+                                break;
+                        case 3: /* Depends */
+                                add_split_dependencies(new_node, field_value, EDGE_DEPENDS);
+                                break;
+                        case 4: /* Replaces */
+                                add_split_dependencies(new_node, field_value, EDGE_REPLACES);
+                                break;
+                        case 5: /* Provides */
+                                add_split_dependencies(new_node, field_value, EDGE_PROVIDES);
+                                break;
+                        case 6: /* Conflicts */
+                                add_split_dependencies(new_node, field_value, EDGE_CONFLICTS);
+                                break;
+                        case 7: /* Suggests */
+                                add_split_dependencies(new_node, field_value, EDGE_SUGGESTS);
+                                break;
+                        case 8: /* Recommends */
+                                add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS);
+                                break;
+                        case 9: /* Enhances */
+                                add_split_dependencies(new_node, field_value, EDGE_ENHANCES);
+                                break;
+                }
+fill_package_struct_cleanup:
+                free(field_name);
+                free(field_value);
+        }
+
+        if (new_node->version == search_name_hashtable("unknown")) {
+                free_package(new_node);
+                return(-1);
+        }
+        num = search_package_hashtable(new_node->name, new_node->version, VER_EQUAL);
+        if (package_hashtable[num] == NULL) {
+                package_hashtable[num] = new_node;
+        } else {
+                free_package(new_node);
+        }
+        return(num);
+}
+
+/* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
+unsigned int get_status(const unsigned int status_node, const int num)
+{
+        char *status_string = name_hashtable[status_hashtable[status_node]->status];
+        char *state_sub_string;
+        unsigned int state_sub_num;
+        int len;
+        int i;
+
+        /* set tmp_string to point to the start of the word number */
+        for (i = 1; i < num; i++) {
+                /* skip past a word */
+                status_string += strcspn(status_string, " ");
+                /* skip past the separating spaces */
+                status_string += strspn(status_string, " ");
+        }
+        len = strcspn(status_string, " \n\0");
+        state_sub_string = bb_xstrndup(status_string, len);
+        state_sub_num = search_name_hashtable(state_sub_string);
+        free(state_sub_string);
+        return(state_sub_num);
+}
+
+void set_status(const unsigned int status_node_num, const char *new_value, const int position)
+{
+        const unsigned int new_value_len = strlen(new_value);
+        const unsigned int new_value_num = search_name_hashtable(new_value);
+        unsigned int want = get_status(status_node_num, 1);
+        unsigned int flag = get_status(status_node_num, 2);
+        unsigned int status = get_status(status_node_num, 3);
+        int want_len = strlen(name_hashtable[want]);
+        int flag_len = strlen(name_hashtable[flag]);
+        int status_len = strlen(name_hashtable[status]);
+        char *new_status;
+
+        switch (position) {
+                case (1):
+                        want = new_value_num;
+                        want_len = new_value_len;
+                        break;
+                case (2):
+                        flag = new_value_num;
+                        flag_len = new_value_len;
+                        break;
+                case (3):
+                        status = new_value_num;
+                        status_len = new_value_len;
+                        break;
+                default:
+                        bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
+        }
+
+        new_status = (char *) xmalloc(want_len + flag_len + status_len + 3);
+        sprintf(new_status, "%s %s %s", name_hashtable[want], name_hashtable[flag], name_hashtable[status]);
+        status_hashtable[status_node_num]->status = search_name_hashtable(new_status);
+        free(new_status);
+        return;
+}
+
+const char *describe_status(int status_num) {
+        int status_want, status_state ;
+        if ( status_hashtable[status_num] == NULL || status_hashtable[status_num]->status == 0 )
+                return "is not installed or flagged to be installed\n";
+
+        status_want = get_status(status_num, 1);
+        status_state = get_status(status_num, 3);
+
+        if ( status_state == search_name_hashtable("installed") ) {
+                if ( status_want == search_name_hashtable("install") )
+                        return "is installed";
+                if ( status_want == search_name_hashtable("deinstall") )
+                        return "is marked to be removed";
+                if ( status_want == search_name_hashtable("purge") )
+                        return "is marked to be purged";
+        }
+        if ( status_want ==  search_name_hashtable("unknown") )
+                return "is in an indeterminate state";
+        if ( status_want == search_name_hashtable("install") )
+                return "is marked to be installed";
+
+        return "is not installed or flagged to be installed";
+}
+
+
+void index_status_file(const char *filename)
+{
+        FILE *status_file;
+        char *control_buffer;
+        char *status_line;
+        status_node_t *status_node = NULL;
+        unsigned int status_num;
+
+        status_file = bb_xfopen(filename, "r");
+        while ((control_buffer = fgets_str(status_file, "\n\n")) != NULL) {
+                const unsigned int package_num = fill_package_struct(control_buffer);
+                if (package_num != -1) {
+                        status_node = xmalloc(sizeof(status_node_t));
+                        /* fill_package_struct doesnt handle the status field */
+                        status_line = strstr(control_buffer, "Status:");
+                        if (status_line != NULL) {
+                                status_line += 7;
+                                status_line += strspn(status_line, " \n\t");
+                                status_line = bb_xstrndup(status_line, strcspn(status_line, "\n\0"));
+                                status_node->status = search_name_hashtable(status_line);
+                                free(status_line);
+                        }
+                        status_node->package = package_num;
+                        status_num = search_status_hashtable(name_hashtable[package_hashtable[status_node->package]->name]);
+                        status_hashtable[status_num] = status_node;
+                }
+                free(control_buffer);
+        }
+        fclose(status_file);
+        return;
+}
+
+#if 0 /* this code is no longer used */
+char *get_depends_field(common_node_t *package, const int depends_type)
+{
+        char *depends = NULL;
+        char *old_sep = (char *)xcalloc(1, 3);
+        char *new_sep = (char *)xcalloc(1, 3);
+        int line_size = 0;
+        int depends_size;
+
+        int i;
+
+        for (i = 0; i < package->num_of_edges; i++) {
+                if ((package->edge[i]->type == EDGE_OR_PRE_DEPENDS) ||
+                        (package->edge[i]->type == EDGE_OR_DEPENDS)) {
+                }
+
+                if ((package->edge[i]->type == depends_type) ||
+                        (package->edge[i]->type == depends_type + 1)) {
+                        /* Check if its the first time through */
+
+                        depends_size = 8 + strlen(name_hashtable[package->edge[i]->name])
+                                + strlen(name_hashtable[package->edge[i]->version]);
+                        line_size += depends_size;
+                        depends = (char *) xrealloc(depends, line_size + 1);
+
+                        /* Check to see if this dependency is the type we are looking for
+                         * +1 to check for 'extra' types, e.g. ored dependecies */
+                        strcpy(old_sep, new_sep);
+                        if (package->edge[i]->type == depends_type) {
+                                strcpy(new_sep, ", ");
+                        }
+                        else if (package->edge[i]->type == depends_type + 1) {
+                                strcpy(new_sep, "| ");
+                        }
+
+                        if (depends_size == line_size) {
+                                strcpy(depends, "");
+                        } else {
+                                if ((strcmp(old_sep, "| ") == 0) && (strcmp(new_sep, "| ") == 0)) {
+                                        strcat(depends, " | ");
+                                } else {
+                                        strcat(depends, ", ");
+                                }
+                        }
+
+                        strcat(depends, name_hashtable[package->edge[i]->name]);
+                        if (strcmp(name_hashtable[package->edge[i]->version], "NULL") != 0) {
+                                if (package->edge[i]->operator == VER_EQUAL) {
+                                        strcat(depends, " (= ");
+                                }
+                                else if (package->edge[i]->operator == VER_LESS) {
+                                        strcat(depends, " (<< ");
+                                }
+                                else if (package->edge[i]->operator == VER_LESS_EQUAL) {
+                                        strcat(depends, " (<= ");
+                                }
+                                else if (package->edge[i]->operator == VER_MORE) {
+                                        strcat(depends, " (>> ");
+                                }
+                                else if (package->edge[i]->operator == VER_MORE_EQUAL) {
+                                        strcat(depends, " (>= ");
+                                } else {
+                                        strcat(depends, " (");
+                                }
+                                strcat(depends, name_hashtable[package->edge[i]->version]);
+                                strcat(depends, ")");
+                        }
+                }
+        }
+        return(depends);
+}
+#endif
+
+void write_buffer_no_status(FILE *new_status_file, const char *control_buffer)
+{
+        char *name;
+        char *value;
+        int start = 0;
+        while (1) {
+                start += read_package_field(&control_buffer[start], &name, &value);
+                if (name == NULL) {
+                        break;
+                }
+                if (strcmp(name, "Status") != 0) {
+                        fprintf(new_status_file, "%s: %s\n", name, value);
+                }
+        }
+        return;
+}
+
+/* This could do with a cleanup */
+void write_status_file(deb_file_t **deb_file)
+{
+        FILE *old_status_file = bb_xfopen("/var/lib/dpkg/status", "r");
+        FILE *new_status_file = bb_xfopen("/var/lib/dpkg/status.udeb", "w");
+        char *package_name;
+        char *status_from_file;
+        char *control_buffer = NULL;
+        char *tmp_string;
+        int status_num;
+        int field_start = 0;
+        int write_flag;
+        int i = 0;
+
+        /* Update previously known packages */
+        while ((control_buffer = fgets_str(old_status_file, "\n\n")) != NULL) {
+                if ((tmp_string = strstr(control_buffer, "Package:")) == NULL) {
+                        continue;
+                }
+
+                tmp_string += 8;
+                tmp_string += strspn(tmp_string, " \n\t");
+                package_name = bb_xstrndup(tmp_string, strcspn(tmp_string, "\n\0"));
+                write_flag = FALSE;
+                tmp_string = strstr(control_buffer, "Status:");
+                if (tmp_string != NULL) {
+                        /* Seperate the status value from the control buffer */
+                        tmp_string += 7;
+                        tmp_string += strspn(tmp_string, " \n\t");
+                        status_from_file = bb_xstrndup(tmp_string, strcspn(tmp_string, "\n"));
+                } else {
+                        status_from_file = NULL;
+                }
+
+                /* Find this package in the status hashtable */
+                status_num = search_status_hashtable(package_name);
+                if (status_hashtable[status_num] != NULL) {
+                        const char *status_from_hashtable = name_hashtable[status_hashtable[status_num]->status];
+                        if (strcmp(status_from_file, status_from_hashtable) != 0) {
+                                /* New status isnt exactly the same as old status */
+                                const int state_status = get_status(status_num, 3);
+                                if ((strcmp("installed", name_hashtable[state_status]) == 0) ||
+                                        (strcmp("unpacked", name_hashtable[state_status]) == 0)) {
+                                        /* We need to add the control file from the package */
+                                        i = 0;
+                                        while(deb_file[i] != NULL) {
+                                                if (strcmp(package_name, name_hashtable[package_hashtable[deb_file[i]->package]->name]) == 0) {
+                                                        /* Write a status file entry with a modified status */
+                                                        /* remove trailing \n's */
+                                                        write_buffer_no_status(new_status_file, deb_file[i]->control_file);
+                                                        set_status(status_num, "ok", 2);
+                                                        fprintf(new_status_file, "Status: %s\n\n", name_hashtable[status_hashtable[status_num]->status]);
+                                                        write_flag = TRUE;
+                                                        break;
+                                                }
+                                                i++;
+                                        }
+                                        /* This is temperary, debugging only */
+                                        if (deb_file[i] == NULL) {
+                                                bb_error_msg_and_die("ALERT: Couldnt find a control file, your status file may be broken, status may be incorrect for %s", package_name);
+                                        }
+                                }
+                                else if (strcmp("not-installed", name_hashtable[state_status]) == 0) {
+                                        /* Only write the Package, Status, Priority and Section lines */
+                                        fprintf(new_status_file, "Package: %s\n", package_name);
+                                        fprintf(new_status_file, "Status: %s\n", status_from_hashtable);
+
+                                        while (1) {
+                                                char *field_name;
+                                                char *field_value;
+                                                field_start += read_package_field(&control_buffer[field_start], &field_name, &field_value);
+                                                if (field_name == NULL) {
+                                                        break;
+                                                }
+                                                if ((strcmp(field_name, "Priority") == 0) ||
+                                                        (strcmp(field_name, "Section") == 0)) {
+                                                        fprintf(new_status_file, "%s: %s\n", field_name, field_value);
+                                                }
+                                        }
+                                        write_flag = TRUE;
+                                        fputs("\n", new_status_file);
+                                }
+                                else if (strcmp("config-files", name_hashtable[state_status]) == 0) {
+                                        /* only change the status line */
+                                        while (1) {
+                                                char *field_name;
+                                                char *field_value;
+                                                field_start += read_package_field(&control_buffer[field_start], &field_name, &field_value);
+                                                if (field_name == NULL) {
+                                                        break;
+                                                }
+                                                /* Setup start point for next field */
+                                                if (strcmp(field_name, "Status") == 0) {
+                                                        fprintf(new_status_file, "Status: %s\n", status_from_hashtable);
+                                                } else {
+                                                        fprintf(new_status_file, "%s: %s\n", field_name, field_value);
+                                                }
+                                        }
+                                        write_flag = TRUE;
+                                        fputs("\n", new_status_file);
+                                }
+                        }
+                }
+                /* If the package from the status file wasnt handle above, do it now*/
+                if (! write_flag) {
+                        fprintf(new_status_file, "%s\n\n", control_buffer);
+                }
+
+                free(status_from_file);
+                free(package_name);
+                free(control_buffer);
+        }
+
+        /* Write any new packages */
+        for(i = 0; deb_file[i] != NULL; i++) {
+                status_num = search_status_hashtable(name_hashtable[package_hashtable[deb_file[i]->package]->name]);
+                if (strcmp("reinstreq", name_hashtable[get_status(status_num, 2)]) == 0) {
+                        write_buffer_no_status(new_status_file, deb_file[i]->control_file);
+                        set_status(status_num, "ok", 2);
+                        fprintf(new_status_file, "Status: %s\n\n", name_hashtable[status_hashtable[status_num]->status]);
+                }
+        }
+        fclose(old_status_file);
+        fclose(new_status_file);
+
+
+        /* Create a separate backfile to dpkg */
+        if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
+                struct stat stat_buf;
+                if (stat("/var/lib/dpkg/status", &stat_buf) == 0) {
+                        bb_error_msg_and_die("Couldnt create backup status file");
+                }
+                /* Its ok if renaming the status file fails because status
+                 * file doesnt exist, maybe we are starting from scratch */
+                bb_error_msg("No status file found, creating new one");
+        }
+
+        if (rename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status") == -1) {
+                bb_error_msg_and_die("DANGER: Couldnt create status file, you need to manually repair your status file");
+        }
+}
+
+/* This function returns TRUE if the given package can satisfy a
+ * dependency of type depend_type.
+ *
+ * A pre-depends is satisfied only if a package is already installed,
+ * which a regular depends can be satisfied by a package which we want
+ * to install.
+ */
+int package_satisfies_dependency(int package, int depend_type)
+{
+        int status_num = search_status_hashtable(name_hashtable[package_hashtable[package]->name]);
+
+        /* status could be unknown if package is a pure virtual
+         * provides which cannot satisfy any dependency by itself.
+         */
+        if ( status_hashtable[status_num] == NULL )
+                return 0;
+
+        switch (depend_type) {
+        case EDGE_PRE_DEPENDS:  return get_status(status_num, 3) == search_name_hashtable("installed");
+        case EDGE_DEPENDS:      return get_status(status_num, 1) == search_name_hashtable("install");
+        }
+        return 0;
+}
+
+int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
+{
+        int *conflicts = NULL;
+        int conflicts_num = 0;
+        int i = deb_start;
+        int j;
+
+        /* Check for conflicts
+         * TODO: TEST if conflicts with other packages to be installed
+         *
+         * Add install packages and the packages they provide
+         * to the list of files to check conflicts for
+         */
+
+        /* Create array of package numbers to check against
+         * installed package for conflicts*/
+        while (deb_file[i] != NULL) {
+                const unsigned int package_num = deb_file[i]->package;
+                conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
+                conflicts[conflicts_num] = package_num;
+                conflicts_num++;
+                /* add provides to conflicts list */
+                for (j = 0; j < package_hashtable[package_num]->num_of_edges; j++) {
+                        if (package_hashtable[package_num]->edge[j]->type == EDGE_PROVIDES) {
+                                const int conflicts_package_num = search_package_hashtable(
+                                        package_hashtable[package_num]->edge[j]->name,
+                                        package_hashtable[package_num]->edge[j]->version,
+                                        package_hashtable[package_num]->edge[j]->operator);
+                                if (package_hashtable[conflicts_package_num] == NULL) {
+                                        /* create a new package */
+                                        common_node_t *new_node = (common_node_t *) xmalloc(sizeof(common_node_t));
+                                        new_node->name = package_hashtable[package_num]->edge[j]->name;
+                                        new_node->version = package_hashtable[package_num]->edge[j]->version;
+                                        new_node->num_of_edges = 0;
+                                        new_node->edge = NULL;
+                                        package_hashtable[conflicts_package_num] = new_node;
+                                }
+                                conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
+                                conflicts[conflicts_num] = conflicts_package_num;
+                                conflicts_num++;
+                        }
+                }
+                i++;
+        }
+
+        /* Check conflicts */
+        i = 0;
+        while (deb_file[i] != NULL) {
+                const common_node_t *package_node = package_hashtable[deb_file[i]->package];
+                int status_num = 0;
+                status_num = search_status_hashtable(name_hashtable[package_node->name]);
+
+                if (get_status(status_num, 3) == search_name_hashtable("installed")) {
+                        i++;
+                        continue;
+                }
+
+                for (j = 0; j < package_node->num_of_edges; j++) {
+                        const edge_t *package_edge = package_node->edge[j];
+
+                        if (package_edge->type == EDGE_CONFLICTS) {
+                                const unsigned int package_num =
+                                        search_package_hashtable(package_edge->name,
+                                                                 package_edge->version,
+                                                                 package_edge->operator);
+                                int result = 0;
+                                if (package_hashtable[package_num] != NULL) {
+                                        status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
+
+                                        if (get_status(status_num, 1) == search_name_hashtable("install")) {
+                                                result = test_version(package_hashtable[deb_file[i]->package]->version,
+                                                        package_edge->version, package_edge->operator);
+                                        }
+                                }
+
+                                if (result) {
+                                        bb_error_msg_and_die("Package %s conflicts with %s",
+                                                name_hashtable[package_node->name],
+                                                name_hashtable[package_edge->name]);
+                                }
+                        }
+                }
+                i++;
+        }       
+
+
+        /* Check dependendcies */
+        for (i = 0; i < PACKAGE_HASH_PRIME; i++) {
+                int status_num = 0;
+                int number_of_alternatives = 0;
+                const edge_t * root_of_alternatives = NULL;
+                const common_node_t *package_node = package_hashtable[i];
+
+                /* If the package node does not exist then this
+                 * package is a virtual one. In which case there are
+                 * no dependencies to check.
+                 */
+                if ( package_node == NULL ) continue;
+
+                status_num = search_status_hashtable(name_hashtable[package_node->name]);
+
+                /* If there is no status then this package is a
+                 * virtual one provided by something else. In which
+                 * case there are no dependencies to check.
+                 */
+                if ( status_hashtable[status_num] == NULL ) continue;
+
+                /* If we don't want this package installed then we may
+                 * as well ignore it's dependencies.
+                 */
+                if (get_status(status_num, 1) != search_name_hashtable("install")) {
+                        continue;
+                }
+
+#if 0
+                /* This might be needed so we don't complain about
+                 * things which are broken but unrelated to the
+                 * packages that are currently being installed
+                 */
+                if (state_status == search_name_hashtable("installed"))
+                        continue;
+#endif
+
+                /* This code is tested only for EDGE_DEPENDS, since I
+                 * have no suitable pre-depends available. There is no
+                 * reason that it shouldn't work though :-)
+                 */
+                for (j = 0; j < package_node->num_of_edges; j++) {
+                        const edge_t *package_edge = package_node->edge[j];
+                        unsigned int package_num;
+                        
+                        if ( package_edge->type == EDGE_OR_PRE_DEPENDS ||
+                             package_edge->type == EDGE_OR_DEPENDS ) {  /* start an EDGE_OR_ list */
+                                number_of_alternatives = package_edge->version;
+                                root_of_alternatives = package_edge;
+                                continue;
+                        } else if ( number_of_alternatives == 0 ) {     /* not in the middle of an EDGE_OR_ list */
+                                number_of_alternatives = 1;
+                                root_of_alternatives = NULL;
+                        }
+
+                        package_num = search_package_hashtable(package_edge->name, package_edge->version, package_edge->operator);
+
+                        if (package_edge->type == EDGE_PRE_DEPENDS ||
+                            package_edge->type == EDGE_DEPENDS ) {
+                                int result=1;
+                                status_num = 0;
+
+                                /* If we are inside an alternative then check
+                                 * this edge is the right type.
+                                 *
+                                 * EDGE_DEPENDS == OR_DEPENDS -1
+                                 * EDGE_PRE_DEPENDS == OR_PRE_DEPENDS -1
+                                 */
+                                if ( root_of_alternatives && package_edge->type != root_of_alternatives->type - 1)
+                                        bb_error_msg_and_die("Fatal error. Package dependencies corrupt: %d != %d - 1 \n",
+                                                             package_edge->type, root_of_alternatives->type);
+
+                                if (package_hashtable[package_num] != NULL)
+                                        result = !package_satisfies_dependency(package_num, package_edge->type);
+
+                                if (result) { /* check for other package which provide what we are looking for */
+                                        int provider = -1;
+
+                                        while ( (provider = search_for_provides(package_edge->name, provider) ) > -1 ) {
+                                                if ( package_hashtable[provider] == NULL ) {
+                                                        printf("Have a provider but no package information for it\n");
+                                                        continue;
+                                                }
+                                                result = !package_satisfies_dependency(provider, package_edge->type);
+
+                                                if ( result == 0 )
+                                                        break;
+                                        }
+                                }
+
+                                /* It must be already installed, or to be installed */
+                                number_of_alternatives--;
+                                if (result && number_of_alternatives == 0) {
+                                        if ( root_of_alternatives )
+                                                bb_error_msg_and_die(
+                                                        "Package %s %sdepends on %s, "
+                                                        "which cannot be satisfied",
+                                                        name_hashtable[package_node->name],
+                                                        package_edge->type == EDGE_PRE_DEPENDS ? "pre-" : "",
+                                                        name_hashtable[root_of_alternatives->name]);
+                                        else
+                                                bb_error_msg_and_die(
+                                                        "Package %s %sdepends on %s, which %s\n",
+                                                        name_hashtable[package_node->name],
+                                                        package_edge->type == EDGE_PRE_DEPENDS ? "pre-" : "",
+                                                        name_hashtable[package_edge->name],
+                                                        describe_status(status_num));
+                                } else if ( result == 0 && number_of_alternatives ) {
+                                        /* we've found a package which
+                                         * satisfies the dependency,
+                                         * so skip over the rest of
+                                         * the alternatives.
+                                         */
+                                        j += number_of_alternatives;
+                                        number_of_alternatives = 0;
+                                }
+                        }
+                }
+        }
+        free(conflicts);
+        return(TRUE);
+}
+
+char **create_list(const char *filename)
+{
+        FILE *list_stream;
+        char **file_list = NULL;
+        char *line = NULL;
+        int count = 0;
+
+        /* don't use [xw]fopen here, handle error ourself */
+        list_stream = fopen(filename, "r");
+        if (list_stream == NULL) {
+                return(NULL);
+        }
+
+        while ((line = bb_get_chomped_line_from_file(list_stream)) != NULL) {
+                file_list = xrealloc(file_list, sizeof(char *) * (count + 2));
+                file_list[count] = line;
+                count++;
+        }
+        fclose(list_stream);
+
+        if (count == 0) {
+                return(NULL);
+        } else {
+                file_list[count] = NULL;
+                return(file_list);
+        }
+}
+
+/* maybe i should try and hook this into remove_file.c somehow */
+int remove_file_array(char **remove_names, char **exclude_names)
+{
+        struct stat path_stat;
+        int match_flag;
+        int remove_flag = FALSE;
+        int i,j;
+
+        if (remove_names == NULL) {
+                return(FALSE);
+        }
+        for (i = 0; remove_names[i] != NULL; i++) {
+                match_flag = FALSE;
+                if (exclude_names != NULL) {
+                        for (j = 0; exclude_names[j] != 0; j++) {
+                                if (strcmp(remove_names[i], exclude_names[j]) == 0) {
+                                        match_flag = TRUE;
+                                        break;
+                                }
+                        }
+                }
+                if (!match_flag) {
+                        if (lstat(remove_names[i], &path_stat) < 0) {
+                                continue;
+                        }
+                        if (S_ISDIR(path_stat.st_mode)) {
+                                if (rmdir(remove_names[i]) != -1) {
+                                        remove_flag = TRUE;
+                                }
+                        } else {
+                                if (unlink(remove_names[i]) != -1) {
+                                        remove_flag = TRUE;
+                                }
+                        }
+                }
+        }
+        return(remove_flag);
+}
+
+int run_package_script(const char *package_name, const char *script_type)
+{
+        struct stat path_stat;
+        char *script_path;
+        int result;
+
+        script_path = xmalloc(strlen(package_name) + strlen(script_type) + 21);
+        sprintf(script_path, "/var/lib/dpkg/info/%s.%s", package_name, script_type);
+
+        /* If the file doesnt exist is isnt a fatal */
+        if (lstat(script_path, &path_stat) < 0) {
+                result = EXIT_SUCCESS;
+        } else {
+                result = system(script_path);
+        }
+        free(script_path);
+        return(result);
+}
+
+const char *all_control_files[] = {"preinst", "postinst", "prerm", "postrm",
+        "list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL };
+
+char **all_control_list(const char *package_name)
+{
+        unsigned short i = 0;
+        char **remove_files;
+
+        /* Create a list of all /var/lib/dpkg/info/<package> files */
+        remove_files = malloc(sizeof(all_control_files));
+        while (all_control_files[i]) {
+                remove_files[i] = xmalloc(strlen(package_name) + strlen(all_control_files[i]) + 21);
+                sprintf(remove_files[i], "/var/lib/dpkg/info/%s.%s", package_name, all_control_files[i]);
+                i++;
+        }
+        remove_files[sizeof(all_control_files)/sizeof(char*) - 1] = NULL;
+
+        return(remove_files);
+}
+
+void free_array(char **array)
+{
+
+        if (array) {
+                unsigned short i = 0;
+                while (array[i]) {
+                        free(array[i]);
+                        i++;
+                }
+                free(array);
+        }
+}
+
+/* This function lists information on the installed packages. It loops through
+ * the status_hashtable to retrieve the info. This results in smaller code than
+ * scanning the status file. The resulting list, however, is unsorted.
+ */
+void list_packages(void)
+{
+        int i;
+
+        printf("    Name           Version\n");
+        printf("+++-==============-==============\n");
+
+        /* go through status hash, dereference package hash and finally strings */
+        for (i=0; i<STATUS_HASH_PRIME+1; i++) {
+
+                if (status_hashtable[i]) {
+                        const char *stat_str;  /* status string */
+                        const char *name_str;  /* package name */
+                        const char *vers_str;  /* version */
+                        char  s1, s2;          /* status abbreviations */
+                        int   spccnt;          /* space count */
+                        int   j;
+
+                        stat_str = name_hashtable[status_hashtable[i]->status];
+                        name_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->name];
+                        vers_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->version];
+
+                        /* get abbreviation for status field 1 */
+                        s1 = stat_str[0] == 'i' ? 'i' : 'r';
+
+                        /* get abbreviation for status field 2 */
+                        for (j=0, spccnt=0; stat_str[j] && spccnt<2; j++) {
+                                if (stat_str[j] == ' ') spccnt++;
+                        }
+                        s2 = stat_str[j];
+
+                        /* print out the line formatted like Debian dpkg */
+                        printf("%c%c  %-14s %s\n", s1, s2, name_str, vers_str);
+                }
+    }
+}
+
+void remove_package(const unsigned int package_num, int noisy)
+{
+        const char *package_name = name_hashtable[package_hashtable[package_num]->name];
+        const char *package_version = name_hashtable[package_hashtable[package_num]->version];
+        const unsigned int status_num = search_status_hashtable(package_name);
+        const int package_name_length = strlen(package_name);
+        char **remove_files;
+        char **exclude_files;
+        char list_name[package_name_length + 25];
+        char conffile_name[package_name_length + 30];
+        int return_value;
+
+        if ( noisy )
+                printf("Removing %s (%s) ...\n", package_name, package_version);
+
+        /* run prerm script */
+        return_value = run_package_script(package_name, "prerm");
+        if (return_value == -1) {
+                bb_error_msg_and_die("script failed, prerm failure");
+        }
+
+        /* Create a list of files to remove, and a separate list of those to keep */
+        sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name);
+        remove_files = create_list(list_name);
+
+        sprintf(conffile_name, "/var/lib/dpkg/info/%s.conffiles", package_name);
+        exclude_files = create_list(conffile_name);
+
+        /* Some directories cant be removed straight away, so do multiple passes */
+        while (remove_file_array(remove_files, exclude_files));
+        free_array(exclude_files);
+        free_array(remove_files);
+
+        /* Create a list of files in /var/lib/dpkg/info/<package>.* to keep  */
+        exclude_files = xmalloc(sizeof(char*) * 3);
+        exclude_files[0] = bb_xstrdup(conffile_name);
+        exclude_files[1] = xmalloc(package_name_length + 27);
+        sprintf(exclude_files[1], "/var/lib/dpkg/info/%s.postrm", package_name);
+        exclude_files[2] = NULL;
+
+        /* Create a list of all /var/lib/dpkg/info/<package> files */
+        remove_files = all_control_list(package_name);
+
+        remove_file_array(remove_files, exclude_files);
+        free_array(remove_files);
+        free_array(exclude_files);
+
+        /* rename <package>.conffile to <package>.list */
+        rename(conffile_name, list_name);
+
+        /* Change package status */
+        set_status(status_num, "config-files", 3);
+}
+
+void purge_package(const unsigned int package_num)
+{
+        const char *package_name = name_hashtable[package_hashtable[package_num]->name];
+        const char *package_version = name_hashtable[package_hashtable[package_num]->version];
+        const unsigned int status_num = search_status_hashtable(package_name);
+        char **remove_files;
+        char **exclude_files;
+        char list_name[strlen(package_name) + 25];
+
+        printf("Purging %s (%s) ...\n", package_name, package_version);
+
+        /* run prerm script */
+        if (run_package_script(package_name, "prerm") != 0) {
+                bb_error_msg_and_die("script failed, prerm failure");
+        }
+
+        /* Create a list of files to remove */
+        sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name);
+        remove_files = create_list(list_name);
+
+        exclude_files = xmalloc(sizeof(char*));
+        exclude_files[0] = NULL;
+
+        /* Some directories cant be removed straight away, so do multiple passes */
+        while (remove_file_array(remove_files, exclude_files));
+        free_array(remove_files);
+
+        /* Create a list of all /var/lib/dpkg/info/<package> files */
+        remove_files = all_control_list(package_name);
+        remove_file_array(remove_files, exclude_files);
+        free_array(remove_files);
+        free(exclude_files);
+
+        /* run postrm script */
+        if (run_package_script(package_name, "postrm") == -1) {
+                bb_error_msg_and_die("postrm fialure.. set status to what?");
+        }
+
+        /* Change package status */
+        set_status(status_num, "not-installed", 3);
+}
+
+static archive_handle_t *init_archive_deb_ar(const char *filename)
+{
+        archive_handle_t *ar_handle;
+
+        /* Setup an ar archive handle that refers to the gzip sub archive */
+        ar_handle = init_handle();
+        ar_handle->filter = filter_accept_list_reassign;
+        ar_handle->src_fd = bb_xopen(filename, O_RDONLY);
+
+        return(ar_handle);
+}
+
+static void init_archive_deb_control(archive_handle_t *ar_handle)
+{
+        archive_handle_t *tar_handle;
+
+        /* Setup the tar archive handle */
+        tar_handle = init_handle();
+        tar_handle->src_fd = ar_handle->src_fd;
+
+        /* We don't care about data.tar.* or debian-binary, just control.tar.* */
+#ifdef CONFIG_FEATURE_DEB_TAR_GZ
+        ar_handle->accept = llist_add_to(NULL, "control.tar.gz");
+#endif
+#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+        ar_handle->accept = llist_add_to(ar_handle->accept, "control.tar.bz2");
+#endif
+
+        /* Assign the tar handle as a subarchive of the ar handle */
+        ar_handle->sub_archive = tar_handle;
+
+        return;
+}
+
+static void init_archive_deb_data(archive_handle_t *ar_handle)
+{
+        archive_handle_t *tar_handle;
+
+        /* Setup the tar archive handle */
+        tar_handle = init_handle();
+        tar_handle->src_fd = ar_handle->src_fd;
+
+        /* We don't care about control.tar.* or debian-binary, just data.tar.* */
+#ifdef CONFIG_FEATURE_DEB_TAR_GZ
+        ar_handle->accept = llist_add_to(NULL, "data.tar.gz");
+#endif
+#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+        ar_handle->accept = llist_add_to(ar_handle->accept, "data.tar.bz2");
+#endif
+
+        /* Assign the tar handle as a subarchive of the ar handle */
+        ar_handle->sub_archive = tar_handle;
+
+        return;
+}
+
+static char *deb_extract_control_file_to_buffer(archive_handle_t *ar_handle, llist_t *myaccept)
+{
+        ar_handle->sub_archive->action_data = data_extract_to_buffer;
+        ar_handle->sub_archive->accept = myaccept;
+
+        unpack_ar_archive(ar_handle);
+        close(ar_handle->src_fd);
+
+        return(ar_handle->sub_archive->buffer);
+}
+
+static void data_extract_all_prefix(archive_handle_t *archive_handle)
+{
+        char *name_ptr = archive_handle->file_header->name;
+
+        name_ptr += strspn(name_ptr, "./");
+        if (name_ptr[0] != '\0') {
+                archive_handle->file_header->name = xmalloc(strlen(archive_handle->buffer) + 2 + strlen(name_ptr));
+                strcpy(archive_handle->file_header->name, archive_handle->buffer);
+                strcat(archive_handle->file_header->name, name_ptr);
+                data_extract_all(archive_handle);
+        }
+        return;
+}
+
+static void unpack_package(deb_file_t *deb_file)
+{
+        const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
+        const unsigned int status_num = search_status_hashtable(package_name);
+        const unsigned int status_package_num = status_hashtable[status_num]->package;
+        char *info_prefix;
+        archive_handle_t *archive_handle;
+        FILE *out_stream;
+        llist_t *accept_list = NULL;
+        int i = 0;
+
+        /* If existing version, remove it first */
+        if (strcmp(name_hashtable[get_status(status_num, 3)], "installed") == 0) {
+                /* Package is already installed, remove old version first */
+                printf("Preparing to replace %s %s (using %s) ...\n", package_name,
+                        name_hashtable[package_hashtable[status_package_num]->version],
+                        deb_file->filename);
+                remove_package(status_package_num, 0);
+        } else {
+                printf("Unpacking %s (from %s) ...\n", package_name, deb_file->filename);
+        }
+
+        /* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
+        info_prefix = (char *) xmalloc(strlen(package_name) + 20 + 4 + 2);
+        sprintf(info_prefix, "/var/lib/dpkg/info/%s.", package_name);
+        archive_handle = init_archive_deb_ar(deb_file->filename);
+        init_archive_deb_control(archive_handle);
+
+        while(all_control_files[i]) {
+                char *c = (char *) xmalloc(3 + bb_strlen(all_control_files[i]));
+                sprintf(c, "./%s", all_control_files[i]);
+                accept_list= llist_add_to(accept_list, c);
+                i++;
+        }
+        archive_handle->sub_archive->accept = accept_list;
+        archive_handle->sub_archive->filter = filter_accept_list;
+        archive_handle->sub_archive->action_data = data_extract_all_prefix;
+        archive_handle->sub_archive->buffer = info_prefix;
+        archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+        unpack_ar_archive(archive_handle);
+
+        /* Run the preinst prior to extracting */
+        if (run_package_script(package_name, "preinst") != 0) {
+                /* when preinst returns exit code != 0 then quit installation process */
+                bb_error_msg_and_die("subprocess pre-installation script returned error.");
+        }
+
+        /* Extract data.tar.gz to the root directory */
+        archive_handle = init_archive_deb_ar(deb_file->filename);
+        init_archive_deb_data(archive_handle);
+        archive_handle->sub_archive->action_data = data_extract_all_prefix;
+        archive_handle->sub_archive->buffer = "/";
+        archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+        unpack_ar_archive(archive_handle);
+
+        /* Create the list file */
+        strcat(info_prefix, "list");
+        out_stream = bb_xfopen(info_prefix, "w");
+        while (archive_handle->sub_archive->passed) {
+                /* the leading . has been stripped by data_extract_all_prefix already */
+                fputs(archive_handle->sub_archive->passed->data, out_stream);
+                fputc('\n', out_stream);
+                archive_handle->sub_archive->passed = archive_handle->sub_archive->passed->link;
+        }
+        fclose(out_stream);
+
+        /* change status */
+        set_status(status_num, "install", 1);
+        set_status(status_num, "unpacked", 3);
+
+        free(info_prefix);
+}
+
+void configure_package(deb_file_t *deb_file)
+{
+        const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
+        const char *package_version = name_hashtable[package_hashtable[deb_file->package]->version];
+        const int status_num = search_status_hashtable(package_name);
+
+        printf("Setting up %s (%s) ...\n", package_name, package_version);
+
+        /* Run the postinst script */
+        if (run_package_script(package_name, "postinst") != 0) {
+                /* TODO: handle failure gracefully */
+                bb_error_msg_and_die("postrm failure.. set status to what?");
+        }
+        /* Change status to reflect success */
+        set_status(status_num, "install", 1);
+        set_status(status_num, "installed", 3);
+}
+
+int dpkg_main(int argc, char **argv)
+{
+        deb_file_t **deb_file = NULL;
+        status_node_t *status_node;
+        int opt;
+        int package_num;
+        int dpkg_opt = 0;
+        int deb_count = 0;
+        int state_status;
+        int status_num;
+        int i;
+
+        while ((opt = getopt(argc, argv, "CF:ilPru")) != -1) {
+                switch (opt) {
+                        case 'C': // equivalent to --configure in official dpkg
+                                dpkg_opt |= dpkg_opt_configure;
+                                dpkg_opt |= dpkg_opt_package_name;
+                                break;
+                        case 'F': // equivalent to --force in official dpkg
+                                if (strcmp(optarg, "depends") == 0) {
+                                        dpkg_opt |= dpkg_opt_force_ignore_depends;
+                                }
+                                break;
+                        case 'i':
+                                dpkg_opt |= dpkg_opt_install;
+                                dpkg_opt |= dpkg_opt_filename;
+                                break;
+                        case 'l':
+                                dpkg_opt |= dpkg_opt_list_installed;
+                                break;
+                        case 'P':
+                                dpkg_opt |= dpkg_opt_purge;
+                                dpkg_opt |= dpkg_opt_package_name;
+                                break;
+                        case 'r':
+                                dpkg_opt |= dpkg_opt_remove;
+                                dpkg_opt |= dpkg_opt_package_name;
+                                break;
+                        case 'u':       /* Equivalent to --unpack in official dpkg */
+                                dpkg_opt |= dpkg_opt_unpack;
+                                dpkg_opt |= dpkg_opt_filename;
+                                break;
+                        default:
+                                bb_show_usage();
+                }
+        }
+        /* check for non-otion argument if expected  */
+        if ((dpkg_opt == 0) || ((argc == optind) && !(dpkg_opt && dpkg_opt_list_installed))) {
+                bb_show_usage();
+        }
+
+/*      puts("(Reading database ... xxxxx files and directories installed.)"); */
+        index_status_file("/var/lib/dpkg/status");
+
+        /* if the list action was given print the installed packages and exit */
+        if (dpkg_opt & dpkg_opt_list_installed) {
+                list_packages();
+                return(EXIT_SUCCESS);
+        }
+
+        /* Read arguments and store relevant info in structs */
+        while (optind < argc) {
+                /* deb_count = nb_elem - 1 and we need nb_elem + 1 to allocate terminal node [NULL pointer] */
+                deb_file = xrealloc(deb_file, sizeof(deb_file_t *) * (deb_count + 2));
+                deb_file[deb_count] = (deb_file_t *) xmalloc(sizeof(deb_file_t));
+                if (dpkg_opt & dpkg_opt_filename) {
+                        archive_handle_t *archive_handle;
+                        llist_t *control_list = NULL;
+
+                        /* Extract the control file */
+                        control_list = llist_add_to(NULL, "./control");
+                        archive_handle = init_archive_deb_ar(argv[optind]);
+                        init_archive_deb_control(archive_handle);
+                        deb_file[deb_count]->control_file = deb_extract_control_file_to_buffer(archive_handle, control_list);
+                        if (deb_file[deb_count]->control_file == NULL) {
+                                bb_error_msg_and_die("Couldnt extract control file");
+                        }
+                        deb_file[deb_count]->filename = bb_xstrdup(argv[optind]);
+                        package_num = fill_package_struct(deb_file[deb_count]->control_file);
+
+                        if (package_num == -1) {
+                                bb_error_msg("Invalid control file in %s", argv[optind]);
+                                continue;
+                        }
+                        deb_file[deb_count]->package = (unsigned int) package_num;
+
+                        /* Add the package to the status hashtable */
+                        if ((dpkg_opt & dpkg_opt_unpack) || (dpkg_opt & dpkg_opt_install)) {
+                                /* Try and find a currently installed version of this package */
+                                status_num = search_status_hashtable(name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]);
+                                /* If no previous entry was found initialise a new entry */
+                                if ((status_hashtable[status_num] == NULL) ||
+                                        (status_hashtable[status_num]->status == 0)) {
+                                        status_node = (status_node_t *) xmalloc(sizeof(status_node_t));
+                                        status_node->package = deb_file[deb_count]->package;
+                                        /* reinstreq isnt changed to "ok" until the package control info
+                                         * is written to the status file*/
+                                        status_node->status = search_name_hashtable("install reinstreq not-installed");
+                                        status_hashtable[status_num] = status_node;
+                                } else {
+                                        set_status(status_num, "install", 1);
+                                        set_status(status_num, "reinstreq", 2);
+                                }
+                        }
+                }
+                else if (dpkg_opt & dpkg_opt_package_name) {
+                        deb_file[deb_count]->filename = NULL;
+                        deb_file[deb_count]->control_file = NULL;
+                        deb_file[deb_count]->package = search_package_hashtable(
+                                search_name_hashtable(argv[optind]),
+                                search_name_hashtable("ANY"), VER_ANY);
+                        if (package_hashtable[deb_file[deb_count]->package] == NULL) {
+                                bb_error_msg_and_die("Package %s is uninstalled or unknown\n", argv[optind]);
+                        }
+                        package_num = deb_file[deb_count]->package;
+                        status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
+                        state_status = get_status(status_num, 3);
+
+                        /* check package status is "installed" */
+                        if (dpkg_opt & dpkg_opt_remove) {
+                                if ((strcmp(name_hashtable[state_status], "not-installed") == 0) ||
+                                        (strcmp(name_hashtable[state_status], "config-files") == 0)) {
+                                        bb_error_msg_and_die("%s is already removed.", name_hashtable[package_hashtable[package_num]->name]);
+                                }
+                                set_status(status_num, "deinstall", 1);
+                        }
+                        else if (dpkg_opt & dpkg_opt_purge) {
+                                /* if package status is "conf-files" then its ok */
+                                if (strcmp(name_hashtable[state_status], "not-installed") == 0) {
+                                        bb_error_msg_and_die("%s is already purged.", name_hashtable[package_hashtable[package_num]->name]);
+                                }
+                                set_status(status_num, "purge", 1);
+                        }
+                }
+                deb_count++;
+                optind++;
+        }
+        deb_file[deb_count] = NULL;
+
+        /* Check that the deb file arguments are installable */
+        if ((dpkg_opt & dpkg_opt_force_ignore_depends) != dpkg_opt_force_ignore_depends) {
+                if (!check_deps(deb_file, 0, deb_count)) {
+                        bb_error_msg_and_die("Dependency check failed");
+                }
+        }
+
+        /* TODO: install or remove packages in the correct dependency order */
+        for (i = 0; i < deb_count; i++) {
+                /* Remove or purge packages */
+                if (dpkg_opt & dpkg_opt_remove) {
+                        remove_package(deb_file[i]->package, 1);
+                }
+                else if (dpkg_opt & dpkg_opt_purge) {
+                        purge_package(deb_file[i]->package);
+                }
+                else if (dpkg_opt & dpkg_opt_unpack) {
+                        unpack_package(deb_file[i]);
+                }
+                else if (dpkg_opt & dpkg_opt_install) {
+                        unpack_package(deb_file[i]);
+                        /* package is configured in second pass below */
+                }
+                else if (dpkg_opt & dpkg_opt_configure) {
+                        configure_package(deb_file[i]);
+                }
+        }
+        /* configure installed packages */
+        if (dpkg_opt & dpkg_opt_install) {
+                for (i = 0; i < deb_count; i++)
+                        configure_package(deb_file[i]);
+        }
+
+        write_status_file(deb_file);
+
+        for (i = 0; i < deb_count; i++) {
+                free(deb_file[i]->control_file);
+                free(deb_file[i]->filename);
+                free(deb_file[i]);
+        }
+
+        free(deb_file);
+
+        for (i = 0; i < NAME_HASH_PRIME; i++) {
+                free(name_hashtable[i]);
+        }
+
+        for (i = 0; i < PACKAGE_HASH_PRIME; i++) {
+                if (package_hashtable[i] != NULL) {
+                        free_package(package_hashtable[i]);
+                }
+        }
+
+        for (i = 0; i < STATUS_HASH_PRIME; i++) {
+                free(status_hashtable[i]);
+        }
+
+        return(EXIT_SUCCESS);
+}
+
diff --git a/busybox/archival/dpkg_deb.c b/busybox/archival/dpkg_deb.c
new file mode 100644
index 000000000..5aa9881d5
--- /dev/null
+++ b/busybox/archival/dpkg_deb.c
@@ -0,0 +1,112 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+
+#include "unarchive.h"
+#include "busybox.h"
+
+#define DPKG_DEB_OPT_CONTENTS   1
+#define DPKG_DEB_OPT_CONTROL    2
+#define DPKG_DEB_OPT_FIELD      4
+#define DPKG_DEB_OPT_EXTRACT    8
+#define DPKG_DEB_OPT_EXTRACT_VERBOSE    16
+
+extern int dpkg_deb_main(int argc, char **argv)
+{
+        archive_handle_t *ar_archive;
+        archive_handle_t *tar_archive;
+        llist_t *control_tar_llist = NULL;
+        unsigned long opt;
+        char *extract_dir = NULL;
+        short argcount = 1;
+
+        /* Setup the tar archive handle */
+        tar_archive = init_handle();
+
+        /* Setup an ar archive handle that refers to the gzip sub archive */
+        ar_archive = init_handle();
+        ar_archive->sub_archive = tar_archive;
+        ar_archive->filter = filter_accept_list_reassign;
+
+#ifdef CONFIG_FEATURE_DEB_TAR_GZ
+        ar_archive->accept = llist_add_to(NULL, "data.tar.gz");
+        control_tar_llist = llist_add_to(NULL, "control.tar.gz");
+#endif
+
+#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+        ar_archive->accept = llist_add_to(ar_archive->accept, "data.tar.bz2");
+        control_tar_llist = llist_add_to(control_tar_llist, "control.tar.bz2");
+#endif
+
+        bb_opt_complementaly = "c~efXx:e~cfXx:f~ceXx:X~cefx:x~cefX";
+        opt = bb_getopt_ulflags(argc, argv, "cefXx");
+
+        if (opt & DPKG_DEB_OPT_CONTENTS) {
+                tar_archive->action_header = header_verbose_list;
+        }
+        if (opt & DPKG_DEB_OPT_CONTROL) {
+                ar_archive->accept = control_tar_llist;
+                tar_archive->action_data = data_extract_all;
+                if (optind + 1 == argc) {
+                        extract_dir = "./DEBIAN";
+                } else {
+                        argcount++;
+                }
+        }
+        if (opt & DPKG_DEB_OPT_FIELD) {
+                /* Print the entire control file
+                 * it should accept a second argument which specifies a
+                 * specific field to print */
+                ar_archive->accept = control_tar_llist;
+                tar_archive->accept = llist_add_to(NULL, "./control");;
+                tar_archive->filter = filter_accept_list;
+                tar_archive->action_data = data_extract_to_stdout;
+        }
+        if (opt & DPKG_DEB_OPT_EXTRACT) {
+                tar_archive->action_header = header_list;
+        }
+        if (opt & (DPKG_DEB_OPT_EXTRACT_VERBOSE | DPKG_DEB_OPT_EXTRACT)) {
+                tar_archive->action_data = data_extract_all;
+                argcount = 2;
+        }
+
+        if ((optind + argcount != argc) || (opt & 0x80000000UL)) {
+                bb_show_usage();
+        }
+
+        tar_archive->src_fd = ar_archive->src_fd = bb_xopen(argv[optind++], O_RDONLY);
+
+        /* Workout where to extract the files */
+        /* 2nd argument is a dir name */
+        if (argv[optind]) {
+                extract_dir = argv[optind];
+        }
+        if (extract_dir) {
+                mkdir(extract_dir, 0777);
+                chdir(extract_dir);
+        }
+        unpack_ar_archive(ar_archive);
+
+        /* Cleanup */
+        close (ar_archive->src_fd);
+
+        return(EXIT_SUCCESS);
+}
diff --git a/busybox/archival/gunzip.c b/busybox/archival/gunzip.c
new file mode 100644
index 000000000..beb7bd12e
--- /dev/null
+++ b/busybox/archival/gunzip.c
@@ -0,0 +1,198 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Gzip implementation for busybox
+ *
+ * Based on GNU gzip v1.2.4 Copyright (C) 1992-1993 Jean-loup Gailly.
+ *
+ * Originally adjusted for busybox by Sven Rudolph <sr1@inf.tu-dresden.de>
+ * based on gzip sources
+ *
+ * Adjusted further by Erik Andersen <andersen@codepoet.org> to support files as
+ * well as stdin/stdout, and to generally behave itself wrt command line
+ * handling.
+ *
+ * General cleanup to better adhere to the style guide and make use of standard
+ * busybox functions by Glenn McGrath <bug1@iinet.net.au>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *
+ * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * The unzip code was written and put in the public domain by Mark Adler.
+ * Portions of the lzw code are derived from the public domain 'compress'
+ * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
+ * Ken Turkowski, Dave Mack and Peter Jannesen.
+ *
+ * See the license_msg below and the file COPYING for the software license.
+ * See the file algorithm.doc for the compression algorithms and file formats.
+ */
+
+#if 0
+static char *license_msg[] = {
+        "   Copyright (C) 1992-1993 Jean-loup Gailly",
+        "   This program is free software; you can redistribute it and/or modify",
+        "   it under the terms of the GNU General Public License as published by",
+        "   the Free Software Foundation; either version 2, or (at your option)",
+        "   any later version.",
+        "",
+        "   This program 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 General Public License for more details.",
+        "",
+        "   You should have received a copy of the GNU General Public License",
+        "   along with this program; if not, write to the Free Software",
+        "   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",
+        0
+};
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "busybox.h"
+#include "unarchive.h"
+
+#define GUNZIP_OPT_STDOUT       1
+#define GUNZIP_OPT_FORCE        2
+#define GUNZIP_OPT_TEST         4
+#define GUNZIP_OPT_DECOMPRESS   8
+
+extern int gunzip_main(int argc, char **argv)
+{
+        char status = EXIT_SUCCESS;
+        unsigned long opt;
+
+        opt = bb_getopt_ulflags(argc, argv, "cftd");
+        /* if called as zcat */
+        if (strcmp(bb_applet_name, "zcat") == 0) {
+                opt |= GUNZIP_OPT_STDOUT;
+        }
+
+        do {
+                struct stat stat_buf;
+                const char *old_path = argv[optind];
+                const char *delete_path = NULL;
+                char *new_path = NULL;
+                int src_fd;
+                int dst_fd;
+
+                optind++;
+
+                if (old_path == NULL || strcmp(old_path, "-") == 0) {
+                        src_fd = STDIN_FILENO;
+                        opt |= GUNZIP_OPT_STDOUT;
+                } else {
+                        src_fd = bb_xopen(old_path, O_RDONLY);
+
+                        /* Get the time stamp on the input file. */
+                        if (stat(old_path, &stat_buf) < 0) {
+                                bb_error_msg_and_die("Couldn't stat file %s", old_path);
+                        }
+                }
+
+                /* Check that the input is sane.  */
+                if (isatty(src_fd) && ((opt & GUNZIP_OPT_FORCE) == 0)) {
+                        bb_error_msg_and_die
+                                ("compressed data not read from terminal.  Use -f to force it.");
+                }
+
+                /* Set output filename and number */
+                if (opt & GUNZIP_OPT_TEST) {
+                        dst_fd = bb_xopen("/dev/null", O_WRONLY);       /* why does test use filenum 2 ? */
+                } else if (opt & GUNZIP_OPT_STDOUT) {
+                        dst_fd = STDOUT_FILENO;
+                } else {
+                        char *extension;
+
+                        new_path = bb_xstrdup(old_path);
+
+                        extension = strrchr(new_path, '.');
+#ifdef CONFIG_FEATURE_GUNZIP_UNCOMPRESS
+                        if (extension && (strcmp(extension, ".Z") == 0)) {
+                                *extension = '\0';
+                        } else
+#endif
+                        if (extension && (strcmp(extension, ".gz") == 0)) {
+                                *extension = '\0';
+                        } else if (extension && (strcmp(extension, ".tgz") == 0)) {
+                                extension[2] = 'a';
+                                extension[3] = 'r';
+                        } else {
+                                bb_error_msg_and_die("Invalid extension");
+                        }
+
+                        /* Open output file */
+                        dst_fd = bb_xopen(new_path, O_WRONLY | O_CREAT);
+
+                        /* Set permissions on the file */
+                        chmod(new_path, stat_buf.st_mode);
+
+                        /* If unzip succeeds remove the old file */
+                        delete_path = old_path;
+                }
+
+                /* do the decompression, and cleanup */
+                if (bb_xread_char(src_fd) == 0x1f) {
+                        unsigned char magic2;
+
+                        magic2 = bb_xread_char(src_fd);
+#ifdef CONFIG_FEATURE_GUNZIP_UNCOMPRESS
+                        if (magic2 == 0x9d) {
+                                status = uncompress(src_fd, dst_fd);
+                        } else
+#endif
+                                if (magic2 == 0x8b) {
+                                        check_header_gzip(src_fd);
+                                        status = inflate_gunzip(src_fd, dst_fd);
+                                        if (status != 0) {
+                                                bb_error_msg_and_die("Error inflating");
+                                        }
+                                } else {
+                                        bb_error_msg_and_die("Invalid magic");
+                                }
+                } else {
+                        bb_error_msg_and_die("Invalid magic");
+                }
+
+                if ((status != EXIT_SUCCESS) && (new_path)) {
+                        /* Unzip failed, remove new path instead of old path */
+                        delete_path = new_path;
+                }
+
+                if (dst_fd != STDOUT_FILENO) {
+                        close(dst_fd);
+                }
+                if (src_fd != STDIN_FILENO) {
+                        close(src_fd);
+                }
+
+                /* delete_path will be NULL if in test mode or from stdin */
+                if (delete_path && (unlink(delete_path) == -1)) {
+                        bb_error_msg_and_die("Couldn't remove %s", delete_path);
+                }
+
+                free(new_path);
+
+        } while (optind < argc);
+
+        return status;
+}
diff --git a/busybox/archival/gzip.c b/busybox/archival/gzip.c
new file mode 100644
index 000000000..d494aa30e
--- /dev/null
+++ b/busybox/archival/gzip.c
@@ -0,0 +1,2548 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Gzip implementation for busybox
+ *
+ * Based on GNU gzip Copyright (C) 1992-1993 Jean-loup Gailly.
+ *
+ * Originally adjusted for busybox by Charles P. Wright <cpw@unix.asb.com>
+ *              "this is a stripped down version of gzip I put into busybox, it does
+ *              only standard in to standard out with -9 compression.  It also requires
+ *              the zcat module for some important functions."
+ *
+ * Adjusted further by Erik Andersen <andersen@codepoet.org> to support
+ * files as well as stdin/stdout, and to generally behave itself wrt
+ * command line handling.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* These defines are very important for BusyBox.  Without these,
+ * huge chunks of ram are pre-allocated making the BusyBox bss
+ * size Freaking Huge(tm), which is a bad thing.*/
+#define SMALL_MEM
+#define DYN_ALLOC
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <utime.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <time.h>
+#include "busybox.h"
+
+#define memzero(s, n)     memset ((void *)(s), 0, (n))
+
+#ifndef RETSIGTYPE
+#  define RETSIGTYPE void
+#endif
+
+typedef unsigned char uch;
+typedef unsigned short ush;
+typedef unsigned long ulg;
+
+/* Return codes from gzip */
+#define OK      0
+#define ERROR   1
+#define WARNING 2
+
+/* Compression methods (see algorithm.doc) */
+/* Only STORED and DEFLATED are supported by this BusyBox module */
+#define STORED      0
+/* methods 4 to 7 reserved */
+#define DEFLATED    8
+
+/* To save memory for 16 bit systems, some arrays are overlaid between
+ * the various modules:
+ * deflate:  prev+head   window      d_buf  l_buf  outbuf
+ * unlzw:    tab_prefix  tab_suffix  stack  inbuf  outbuf
+ * For compression, input is done in window[]. For decompression, output
+ * is done in window except for unlzw.
+ */
+
+#ifndef INBUFSIZ
+#  ifdef SMALL_MEM
+#    define INBUFSIZ  0x2000    /* input buffer size */
+#  else
+#    define INBUFSIZ  0x8000    /* input buffer size */
+#  endif
+#endif
+#define INBUF_EXTRA  64 /* required by unlzw() */
+
+#ifndef OUTBUFSIZ
+#  ifdef SMALL_MEM
+#    define OUTBUFSIZ   8192    /* output buffer size */
+#  else
+#    define OUTBUFSIZ  16384    /* output buffer size */
+#  endif
+#endif
+#define OUTBUF_EXTRA 2048       /* required by unlzw() */
+
+#ifndef DIST_BUFSIZE
+#  ifdef SMALL_MEM
+#    define DIST_BUFSIZE 0x2000 /* buffer for distances, see trees.c */
+#  else
+#    define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */
+#  endif
+#endif
+
+#ifdef DYN_ALLOC
+#  define DECLARE(type, array, size)  static type * array
+#  define ALLOC(type, array, size) { \
+      array = (type*)xcalloc((size_t)(((size)+1L)/2), 2*sizeof(type)); \
+   }
+#  define FREE(array) {free(array), array=NULL;}
+#else
+#  define DECLARE(type, array, size)  static type array[size]
+#  define ALLOC(type, array, size)
+#  define FREE(array)
+#endif
+
+#define tab_suffix window
+#define tab_prefix prev /* hash link (see deflate.c) */
+#define head (prev+WSIZE)       /* hash head (see deflate.c) */
+
+static long bytes_in;   /* number of input bytes */
+
+#define isize bytes_in
+/* for compatibility with old zip sources (to be cleaned) */
+
+typedef int file_t;             /* Do not use stdio */
+
+#define NO_FILE  (-1)   /* in memory compression */
+
+
+#define PACK_MAGIC     "\037\036"       /* Magic header for packed files */
+#define GZIP_MAGIC     "\037\213"       /* Magic header for gzip files, 1F 8B */
+#define OLD_GZIP_MAGIC "\037\236"       /* Magic header for gzip 0.5 = freeze 1.x */
+#define LZH_MAGIC      "\037\240"       /* Magic header for SCO LZH Compress files */
+#define PKZIP_MAGIC    "\120\113\003\004"       /* Magic header for pkzip files */
+
+/* gzip flag byte */
+#define ASCII_FLAG   0x01       /* bit 0 set: file probably ascii text */
+#define CONTINUATION 0x02       /* bit 1 set: continuation of multi-part gzip file */
+#define EXTRA_FIELD  0x04       /* bit 2 set: extra field present */
+#define ORIG_NAME    0x08       /* bit 3 set: original file name present */
+#define COMMENT      0x10       /* bit 4 set: file comment present */
+#define RESERVED     0xC0       /* bit 6,7:   reserved */
+
+/* internal file attribute */
+#define UNKNOWN 0xffff
+#define BINARY  0
+#define ASCII   1
+
+#ifndef WSIZE
+#  define WSIZE 0x8000  /* window size--must be a power of two, and */
+#endif                                                  /*  at least 32K for zip's deflate method */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST  (WSIZE-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+/* put_byte is used for the compressed output */
+#define put_byte(c) {outbuf[outcnt++]=(uch)(c); if (outcnt==OUTBUFSIZ)\
+   flush_outbuf();}
+
+
+/* Output a 32 bit value to the bit stream, lsb first */
+#if 0
+#define put_long(n) { \
+    put_short((n) & 0xffff); \
+    put_short(((ulg)(n)) >> 16); \
+}
+#endif
+
+#define seekable()    0 /* force sequential output */
+#define translate_eol 0 /* no option -a yet */
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  define Assert(cond,msg) {if(!(cond)) bb_error_msg(msg);}
+#  define Trace(x) fprintf x
+#  define Tracev(x) {if (verbose) fprintf x ;}
+#  define Tracevv(x) {if (verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+#define WARN(msg) {if (!quiet) fprintf msg ; \
+                   if (exit_code == OK) exit_code = WARNING;}
+
+#ifndef MAX_PATH_LEN
+#  define MAX_PATH_LEN   1024   /* max pathname length */
+#endif
+
+
+        /* from zip.c: */
+static int zip(int in, int out);
+static int file_read(char *buf, unsigned size);
+
+        /* from gzip.c */
+static RETSIGTYPE abort_gzip(void);
+
+                /* from deflate.c */
+static void lm_init(ush * flags);
+static ulg deflate(void);
+
+                /* from trees.c */
+static void ct_init(ush * attr, int *methodp);
+static int ct_tally(int dist, int lc);
+static ulg flush_block(char *buf, ulg stored_len, int eof);
+
+                /* from bits.c */
+static void bi_init(file_t zipfile);
+static void send_bits(int value, int length);
+static unsigned bi_reverse(unsigned value, int length);
+static void bi_windup(void);
+static void copy_block(char *buf, unsigned len, int header);
+static int (*read_buf) (char *buf, unsigned size);
+
+        /* from util.c: */
+static void flush_outbuf(void);
+
+/* lzw.h -- define the lzw functions.
+ * Copyright (C) 1992-1993 Jean-loup Gailly.
+ * This is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License, see the file COPYING.
+ */
+
+#if !defined(OF) && defined(lint)
+#  include "gzip.h"
+#endif
+
+#ifndef BITS
+#  define BITS 16
+#endif
+#define INIT_BITS 9             /* Initial number of bits per code */
+
+#define BIT_MASK    0x1f        /* Mask for 'number of compression bits' */
+/* Mask 0x20 is reserved to mean a fourth header byte, and 0x40 is free.
+ * It's a pity that old uncompress does not check bit 0x20. That makes
+ * extension of the format actually undesirable because old compress
+ * would just crash on the new format instead of giving a meaningful
+ * error message. It does check the number of bits, but it's more
+ * helpful to say "unsupported format, get a new version" than
+ * "can only handle 16 bits".
+ */
+
+/* tailor.h -- target dependent definitions
+ * Copyright (C) 1992-1993 Jean-loup Gailly.
+ * This is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License, see the file COPYING.
+ */
+
+/* The target dependent definitions should be defined here only.
+ * The target dependent functions should be defined in tailor.c.
+ */
+
+
+        /* Common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03 /* assume Unix */
+#endif
+
+#ifndef PATH_SEP
+#  define PATH_SEP '/'
+#endif
+
+#ifndef OPTIONS_VAR
+#  define OPTIONS_VAR "GZIP"
+#endif
+
+#ifndef Z_SUFFIX
+#  define Z_SUFFIX ".gz"
+#endif
+
+#ifdef MAX_EXT_CHARS
+#  define MAX_SUFFIX  MAX_EXT_CHARS
+#else
+#  define MAX_SUFFIX  30
+#endif
+
+                /* global buffers */
+
+DECLARE(uch, inbuf, INBUFSIZ + INBUF_EXTRA);
+DECLARE(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
+DECLARE(ush, d_buf, DIST_BUFSIZE);
+DECLARE(uch, window, 2L * WSIZE);
+DECLARE(ush, tab_prefix, 1L << BITS);
+
+static int foreground;  /* set if program run in foreground */
+static int method = DEFLATED;   /* compression method */
+static int exit_code = OK;      /* program exit code */
+static int part_nb;             /* number of parts in .gz file */
+static long time_stamp; /* original time stamp (modification time) */
+static long ifile_size; /* input file size, -1 for devices (debug only) */
+static char z_suffix[MAX_SUFFIX + 1];   /* default suffix (can be set with --suffix) */
+static int z_len;               /* strlen(z_suffix) */
+
+static int ifd;                 /* input file descriptor */
+static int ofd;                 /* output file descriptor */
+static unsigned insize; /* valid bytes in inbuf */
+static unsigned outcnt; /* bytes in output buffer */
+
+
+/* Output a 16 bit value, lsb first */
+static void put_short(ush w)
+{
+        if (outcnt < OUTBUFSIZ - 2) {
+                outbuf[outcnt++] = (uch) ((w) & 0xff);
+                outbuf[outcnt++] = (uch) ((ush) (w) >> 8);
+        } else {
+                put_byte((uch) ((w) & 0xff));
+                put_byte((uch) ((ush) (w) >> 8));
+        }
+}
+
+/* ========================================================================
+ * Signal and error handler.
+ */
+static void abort_gzip()
+{
+        exit(ERROR);
+}
+
+/* ===========================================================================
+ * Clear input and output buffers
+ */
+static void clear_bufs(void)
+{
+        outcnt = 0;
+        insize = 0;
+        bytes_in = 0L;
+}
+
+static void write_bb_error_msg(void)
+{
+        fputc('\n', stderr);
+        bb_perror_nomsg();
+        abort_gzip();
+}
+
+/* ===========================================================================
+ * Does the same as write(), but also handles partial pipe writes and checks
+ * for error return.
+ */
+static void write_buf(int fd, void *buf, unsigned cnt)
+{
+        unsigned n;
+
+        while ((n = write(fd, buf, cnt)) != cnt) {
+                if (n == (unsigned) (-1)) {
+                        write_bb_error_msg();
+                }
+                cnt -= n;
+                buf = (void *) ((char *) buf + n);
+        }
+}
+
+/* ===========================================================================
+ * Run a set of bytes through the crc shift register.  If s is a NULL
+ * pointer, then initialize the crc shift register contents instead.
+ * Return the current crc in either case.
+ */
+static ulg updcrc(uch * s, unsigned n)
+{
+        static ulg crc = (ulg) 0xffffffffL;     /* shift register contents */
+        register ulg c;         /* temporary variable */
+        static unsigned long crc_32_tab[256];
+
+        if (crc_32_tab[1] == 0x00000000L) {
+                unsigned long csr;      /* crc shift register */
+                const unsigned long e = 0xedb88320L;    /* polynomial exclusive-or pattern */
+                int i;                  /* counter for all possible eight bit values */
+                int k;                  /* byte being shifted into crc apparatus */
+
+                /* Compute table of CRC's. */
+                for (i = 1; i < 256; i++) {
+                        csr = i;
+                        /* The idea to initialize the register with the byte instead of
+                           * zero was stolen from Haruhiko Okumura's ar002
+                         */
+                        for (k = 8; k; k--)
+                                csr = csr & 1 ? (csr >> 1) ^ e : csr >> 1;
+                        crc_32_tab[i] = csr;
+                }
+        }
+
+        if (s == NULL) {
+                c = 0xffffffffL;
+        } else {
+                c = crc;
+                if (n)
+                        do {
+                                c = crc_32_tab[((int) c ^ (*s++)) & 0xff] ^ (c >> 8);
+                        } while (--n);
+        }
+        crc = c;
+        return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */
+}
+
+/* bits.c -- output variable-length bit strings
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * This is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License, see the file COPYING.
+ */
+
+
+/*
+ *  PURPOSE
+ *
+ *      Output variable-length bit strings. Compression can be done
+ *      to a file or to memory. (The latter is not supported in this version.)
+ *
+ *  DISCUSSION
+ *
+ *      The PKZIP "deflate" file format interprets compressed file data
+ *      as a sequence of bits.  Multi-bit strings in the file may cross
+ *      byte boundaries without restriction.
+ *
+ *      The first bit of each byte is the low-order bit.
+ *
+ *      The routines in this file allow a variable-length bit value to
+ *      be output right-to-left (useful for literal values). For
+ *      left-to-right output (useful for code strings from the tree routines),
+ *      the bits must have been reversed first with bi_reverse().
+ *
+ *      For in-memory compression, the compressed bit stream goes directly
+ *      into the requested output buffer. The input data is read in blocks
+ *      by the mem_read() function. The buffer is limited to 64K on 16 bit
+ *      machines.
+ *
+ *  INTERFACE
+ *
+ *      void bi_init (FILE *zipfile)
+ *          Initialize the bit string routines.
+ *
+ *      void send_bits (int value, int length)
+ *          Write out a bit string, taking the source bits right to
+ *          left.
+ *
+ *      int bi_reverse (int value, int length)
+ *          Reverse the bits of a bit string, taking the source bits left to
+ *          right and emitting them right to left.
+ *
+ *      void bi_windup (void)
+ *          Write out any remaining bits in an incomplete byte.
+ *
+ *      void copy_block(char *buf, unsigned len, int header)
+ *          Copy a stored block to the zip file, storing first the length and
+ *          its one's complement if requested.
+ *
+ */
+
+/* ===========================================================================
+ * Local data used by the "bit string" routines.
+ */
+
+static file_t zfile;    /* output gzip file */
+
+static unsigned short bi_buf;
+
+/* Output buffer. bits are inserted starting at the bottom (least significant
+ * bits).
+ */
+
+#define Buf_size (8 * 2*sizeof(char))
+/* Number of bits used within bi_buf. (bi_buf might be implemented on
+ * more than 16 bits on some systems.)
+ */
+
+static int bi_valid;
+
+/* Current input function. Set to mem_read for in-memory compression */
+
+#ifdef DEBUG
+ulg bits_sent;                  /* bit length of the compressed data */
+#endif
+
+/* ===========================================================================
+ * Initialize the bit string routines.
+ */
+static void bi_init(file_t zipfile)
+{
+        zfile = zipfile;
+        bi_buf = 0;
+        bi_valid = 0;
+#ifdef DEBUG
+        bits_sent = 0L;
+#endif
+
+        /* Set the defaults for file compression. They are set by memcompress
+         * for in-memory compression.
+         */
+        if (zfile != NO_FILE) {
+                read_buf = file_read;
+        }
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+static void send_bits(int value, int length)
+{
+#ifdef DEBUG
+        Tracev((stderr, " l %2d v %4x ", length, value));
+        Assert(length > 0 && length <= 15, "invalid length");
+        bits_sent += (ulg) length;
+#endif
+        /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+         * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+         * unused bits in value.
+         */
+        if (bi_valid > (int) Buf_size - length) {
+                bi_buf |= (value << bi_valid);
+                put_short(bi_buf);
+                bi_buf = (ush) value >> (Buf_size - bi_valid);
+                bi_valid += length - Buf_size;
+        } else {
+                bi_buf |= value << bi_valid;
+                bi_valid += length;
+        }
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+static unsigned bi_reverse(unsigned code, int len)
+{
+        register unsigned res = 0;
+
+        do {
+                res |= code & 1;
+                code >>= 1, res <<= 1;
+        } while (--len > 0);
+        return res >> 1;
+}
+
+/* ===========================================================================
+ * Write out any remaining bits in an incomplete byte.
+ */
+static void bi_windup()
+{
+        if (bi_valid > 8) {
+                put_short(bi_buf);
+        } else if (bi_valid > 0) {
+                put_byte(bi_buf);
+        }
+        bi_buf = 0;
+        bi_valid = 0;
+#ifdef DEBUG
+        bits_sent = (bits_sent + 7) & ~7;
+#endif
+}
+
+/* ===========================================================================
+ * Copy a stored block to the zip file, storing first the length and its
+ * one's complement if requested.
+ */
+static void copy_block(char *buf, unsigned len, int header)
+{
+        bi_windup();            /* align on byte boundary */
+
+        if (header) {
+                put_short((ush) len);
+                put_short((ush) ~ len);
+#ifdef DEBUG
+                bits_sent += 2 * 16;
+#endif
+        }
+#ifdef DEBUG
+        bits_sent += (ulg) len << 3;
+#endif
+        while (len--) {
+                put_byte(*buf++);
+        }
+}
+
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * This is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License, see the file COPYING.
+ */
+
+/*
+ *  PURPOSE
+ *
+ *      Identify new text as repetitions of old text within a fixed-
+ *      length sliding window trailing behind the new text.
+ *
+ *  DISCUSSION
+ *
+ *      The "deflation" process depends on being able to identify portions
+ *      of the input text which are identical to earlier input (within a
+ *      sliding window trailing behind the input currently being processed).
+ *
+ *      The most straightforward technique turns out to be the fastest for
+ *      most input files: try all possible matches and select the longest.
+ *      The key feature of this algorithm is that insertions into the string
+ *      dictionary are very simple and thus fast, and deletions are avoided
+ *      completely. Insertions are performed at each input character, whereas
+ *      string matches are performed only when the previous match ends. So it
+ *      is preferable to spend more time in matches to allow very fast string
+ *      insertions and avoid deletions. The matching algorithm for small
+ *      strings is inspired from that of Rabin & Karp. A brute force approach
+ *      is used to find longer strings when a small match has been found.
+ *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ *      (by Leonid Broukhis).
+ *         A previous version of this file used a more sophisticated algorithm
+ *      (by Fiala and Greene) which is guaranteed to run in linear amortized
+ *      time, but has a larger average cost, uses more memory and is patented.
+ *      However the F&G algorithm may be faster for some highly redundant
+ *      files if the parameter max_chain_length (described below) is too large.
+ *
+ *  ACKNOWLEDGMENTS
+ *
+ *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ *      I found it in 'freeze' written by Leonid Broukhis.
+ *      Thanks to many info-zippers for bug reports and testing.
+ *
+ *  REFERENCES
+ *
+ *      APPNOTE.TXT documentation file in PKZIP 1.93a distribution.
+ *
+ *      A description of the Rabin and Karp algorithm is given in the book
+ *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ *      Fiala,E.R., and Greene,D.H.
+ *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ *  INTERFACE
+ *
+ *      void lm_init (int pack_level, ush *flags)
+ *          Initialize the "longest match" routines for a new file
+ *
+ *      ulg deflate (void)
+ *          Processes a new input file and return its compressed length. Sets
+ *          the compressed length, crc, deflate flags and internal file
+ *          attributes.
+ */
+
+
+/* ===========================================================================
+ * Configuration parameters
+ */
+
+/* Compile with MEDIUM_MEM to reduce the memory requirements or
+ * with SMALL_MEM to use as little memory as possible. Use BIG_MEM if the
+ * entire input file can be held in memory (not possible on 16 bit systems).
+ * Warning: defining these symbols affects HASH_BITS (see below) and thus
+ * affects the compression ratio. The compressed output
+ * is still correct, and might even be smaller in some cases.
+ */
+
+#ifdef SMALL_MEM
+#   define HASH_BITS  13        /* Number of bits used to hash strings */
+#endif
+#ifdef MEDIUM_MEM
+#   define HASH_BITS  14
+#endif
+#ifndef HASH_BITS
+#   define HASH_BITS  15
+   /* For portability to 16 bit machines, do not use values above 15. */
+#endif
+
+/* To save space (see unlzw.c), we overlay prev+head with tab_prefix and
+ * window with tab_suffix. Check that we can do this:
+ */
+#if (WSIZE<<1) > (1<<BITS)
+#  error cannot overlay window with tab_suffix and prev with tab_prefix0
+#endif
+#if HASH_BITS > BITS-1
+#  error cannot overlay head with tab_prefix1
+#endif
+#define HASH_SIZE (unsigned)(1<<HASH_BITS)
+#define HASH_MASK (HASH_SIZE-1)
+#define WMASK     (WSIZE-1)
+/* HASH_SIZE and WSIZE must be powers of two */
+#define NIL 0
+/* Tail of hash chains */
+#define FAST 4
+#define SLOW 2
+/* speed options for the general purpose bit flag */
+#ifndef TOO_FAR
+#  define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+/* ===========================================================================
+ * Local data used by the "longest match" routines.
+ */
+typedef ush Pos;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+/* DECLARE(uch, window, 2L*WSIZE); */
+/* Sliding window. Input bytes are read into the second half of the window,
+ * and move to the first half later to keep a dictionary of at least WSIZE
+ * bytes. With this organization, matches are limited to a distance of
+ * WSIZE-MAX_MATCH bytes, but this ensures that IO is always
+ * performed with a length multiple of the block size. Also, it limits
+ * the window size to 64K, which is quite useful on MSDOS.
+ * To do: limit the window size to WSIZE+BSZ if SMALL_MEM (the code would
+ * be less efficient).
+ */
+
+/* DECLARE(Pos, prev, WSIZE); */
+/* Link to older string with same hash index. To limit the size of this
+ * array to 64K, this link is maintained only for the last 32K strings.
+ * An index in this array is thus a window index modulo 32K.
+ */
+
+/* DECLARE(Pos, head, 1<<HASH_BITS); */
+/* Heads of the hash chains or NIL. */
+
+static const ulg window_size = (ulg) 2 * WSIZE;
+
+/* window size, 2*WSIZE except for MMAP or BIG_MEM, where it is the
+ * input file length plus MIN_LOOKAHEAD.
+ */
+
+static long block_start;
+
+/* window position at the beginning of the current output block. Gets
+ * negative when the window is moved backwards.
+ */
+
+static unsigned ins_h;  /* hash index of string to be inserted */
+
+#define H_SHIFT  ((HASH_BITS+MIN_MATCH-1)/MIN_MATCH)
+/* Number of bits by which ins_h and del_h must be shifted at each
+ * input step. It must be such that after MIN_MATCH steps, the oldest
+ * byte no longer takes part in the hash key, that is:
+ *   H_SHIFT * MIN_MATCH >= HASH_BITS
+ */
+
+static unsigned int prev_length;
+
+/* Length of the best match at previous step. Matches not greater than this
+ * are discarded. This is used in the lazy match evaluation.
+ */
+
+static unsigned strstart;       /* start of string to insert */
+static unsigned match_start;    /* start of matching string */
+static int eofile;              /* flag set at end of input file */
+static unsigned lookahead;      /* number of valid bytes ahead in window */
+
+static const unsigned max_chain_length = 4096;
+
+/* To speed up deflation, hash chains are never searched beyond this length.
+ * A higher limit improves compression ratio but degrades the speed.
+ */
+
+static const unsigned int max_lazy_match = 258;
+
+/* Attempt to find a better match only when the current match is strictly
+ * smaller than this value. This mechanism is used only for compression
+ * levels >= 4.
+ */
+#define max_insert_length  max_lazy_match
+/* Insert new strings in the hash table only if the match length
+ * is not greater than this length. This saves time but degrades compression.
+ * max_insert_length is used only for compression levels <= 3.
+ */
+
+static const unsigned good_match = 32;
+
+/* Use a faster search when the previous match is longer than this */
+
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+
+static const int nice_match = 258;      /* Stop searching when current match exceeds this */
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+/* ===========================================================================
+ *  Prototypes for local functions.
+ */
+static void fill_window(void);
+
+static int longest_match(IPos cur_match);
+
+#ifdef DEBUG
+static void check_match(IPos start, IPos match, int length);
+#endif
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
+ *    input characters, so that a running hash key can be computed from the
+ *    previous key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(h,c) (h = (((h)<<H_SHIFT) ^ (c)) & HASH_MASK)
+
+/* ===========================================================================
+ * Insert string s in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * IN  assertion: all calls to to INSERT_STRING are made with consecutive
+ *    input characters and the first MIN_MATCH bytes of s are valid
+ *    (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+#define INSERT_STRING(s, match_head) \
+   (UPDATE_HASH(ins_h, window[(s) + MIN_MATCH-1]), \
+    prev[(s) & WMASK] = match_head = head[ins_h], \
+    head[ins_h] = (s))
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new file
+ */
+static void lm_init(ush * flags)
+{
+        register unsigned j;
+
+        /* Initialize the hash table. */
+        memzero((char *) head, HASH_SIZE * sizeof(*head));
+        /* prev will be initialized on the fly */
+
+        *flags |= SLOW;
+        /* ??? reduce max_chain_length for binary files */
+
+        strstart = 0;
+        block_start = 0L;
+
+        lookahead = read_buf((char *) window,
+                                                 sizeof(int) <= 2 ? (unsigned) WSIZE : 2 * WSIZE);
+
+        if (lookahead == 0 || lookahead == (unsigned) EOF) {
+                eofile = 1, lookahead = 0;
+                return;
+        }
+        eofile = 0;
+        /* Make sure that we always have enough lookahead. This is important
+         * if input comes from a device such as a tty.
+         */
+        while (lookahead < MIN_LOOKAHEAD && !eofile)
+                fill_window();
+
+        ins_h = 0;
+        for (j = 0; j < MIN_MATCH - 1; j++)
+                UPDATE_HASH(ins_h, window[j]);
+        /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
+         * not important since only literal bytes will be emitted.
+         */
+}
+
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ */
+
+/* For MSDOS, OS/2 and 386 Unix, an optimized version is in match.asm or
+ * match.s. The code is functionally equivalent, so you can use the C version
+ * if desired.
+ */
+static int longest_match(IPos cur_match)
+{
+        unsigned chain_length = max_chain_length;       /* max hash chain length */
+        register uch *scan = window + strstart; /* current string */
+        register uch *match;    /* matched string */
+        register int len;       /* length of current match */
+        int best_len = prev_length;     /* best match length so far */
+        IPos limit =
+                strstart > (IPos) MAX_DIST ? strstart - (IPos) MAX_DIST : NIL;
+        /* Stop when cur_match becomes <= limit. To simplify the code,
+         * we prevent matches with the string of window index 0.
+         */
+
+/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+ * It is easy to get rid of this optimization if necessary.
+ */
+#if HASH_BITS < 8 || MAX_MATCH != 258
+#  error Code too clever
+#endif
+        register uch *strend = window + strstart + MAX_MATCH;
+        register uch scan_end1 = scan[best_len - 1];
+        register uch scan_end = scan[best_len];
+
+        /* Do not waste too much time if we already have a good match: */
+        if (prev_length >= good_match) {
+                chain_length >>= 2;
+        }
+        Assert(strstart <= window_size - MIN_LOOKAHEAD, "insufficient lookahead");
+
+        do {
+                Assert(cur_match < strstart, "no future");
+                match = window + cur_match;
+
+                /* Skip to next match if the match length cannot increase
+                 * or if the match length is less than 2:
+                 */
+                if (match[best_len] != scan_end ||
+                        match[best_len - 1] != scan_end1 ||
+                        *match != *scan || *++match != scan[1])
+                        continue;
+
+                /* The check at best_len-1 can be removed because it will be made
+                 * again later. (This heuristic is not always a win.)
+                 * It is not necessary to compare scan[2] and match[2] since they
+                 * are always equal when the other bytes match, given that
+                 * the hash keys are equal and that HASH_BITS >= 8.
+                 */
+                scan += 2, match++;
+
+                /* We check for insufficient lookahead only every 8th comparison;
+                 * the 256th check will be made at strstart+258.
+                 */
+                do {
+                } while (*++scan == *++match && *++scan == *++match &&
+                                 *++scan == *++match && *++scan == *++match &&
+                                 *++scan == *++match && *++scan == *++match &&
+                                 *++scan == *++match && *++scan == *++match && scan < strend);
+
+                len = MAX_MATCH - (int) (strend - scan);
+                scan = strend - MAX_MATCH;
+
+                if (len > best_len) {
+                        match_start = cur_match;
+                        best_len = len;
+                        if (len >= nice_match)
+                                break;
+                        scan_end1 = scan[best_len - 1];
+                        scan_end = scan[best_len];
+                }
+        } while ((cur_match = prev[cur_match & WMASK]) > limit
+                         && --chain_length != 0);
+
+        return best_len;
+}
+
+#ifdef DEBUG
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+static void check_match(IPos start, IPos match, int length)
+{
+        /* check that the match is indeed a match */
+        if (memcmp((char *) window + match,
+                           (char *) window + start, length) != EQUAL) {
+                bb_error_msg(" start %d, match %d, length %d", start, match, length);
+                bb_error_msg("invalid match");
+        }
+        if (verbose > 1) {
+                bb_error_msg("\\[%d,%d]", start - match, length);
+                do {
+                        putc(window[start++], stderr);
+                } while (--length != 0);
+        }
+}
+#else
+#  define check_match(start, match, length)
+#endif
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead, and sets eofile if end of input file.
+ * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
+ * OUT assertions: at least one byte has been read, or eofile is set;
+ *    file reads are performed for at least two bytes (required for the
+ *    translate_eol option).
+ */
+static void fill_window()
+{
+        register unsigned n, m;
+        unsigned more =
+                (unsigned) (window_size - (ulg) lookahead - (ulg) strstart);
+        /* Amount of free space at the end of the window. */
+
+        /* If the window is almost full and there is insufficient lookahead,
+         * move the upper half to the lower one to make room in the upper half.
+         */
+        if (more == (unsigned) EOF) {
+                /* Very unlikely, but possible on 16 bit machine if strstart == 0
+                 * and lookahead == 1 (input done one byte at time)
+                 */
+                more--;
+        } else if (strstart >= WSIZE + MAX_DIST) {
+                /* By the IN assertion, the window is not empty so we can't confuse
+                 * more == 0 with more == 64K on a 16 bit machine.
+                 */
+                Assert(window_size == (ulg) 2 * WSIZE, "no sliding with BIG_MEM");
+
+                memcpy((char *) window, (char *) window + WSIZE, (unsigned) WSIZE);
+                match_start -= WSIZE;
+                strstart -= WSIZE;      /* we now have strstart >= MAX_DIST: */
+
+                block_start -= (long) WSIZE;
+
+                for (n = 0; n < HASH_SIZE; n++) {
+                        m = head[n];
+                        head[n] = (Pos) (m >= WSIZE ? m - WSIZE : NIL);
+                }
+                for (n = 0; n < WSIZE; n++) {
+                        m = prev[n];
+                        prev[n] = (Pos) (m >= WSIZE ? m - WSIZE : NIL);
+                        /* If n is not on any hash chain, prev[n] is garbage but
+                         * its value will never be used.
+                         */
+                }
+                more += WSIZE;
+        }
+        /* At this point, more >= 2 */
+        if (!eofile) {
+                n = read_buf((char *) window + strstart + lookahead, more);
+                if (n == 0 || n == (unsigned) EOF) {
+                        eofile = 1;
+                } else {
+                        lookahead += n;
+                }
+        }
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK(eof) \
+   flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \
+                (char*)NULL, (long)strstart - block_start, (eof))
+
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+static ulg deflate()
+{
+        IPos hash_head;         /* head of hash chain */
+        IPos prev_match;        /* previous match */
+        int flush;                      /* set if current block must be flushed */
+        int match_available = 0;        /* set if previous match exists */
+        register unsigned match_length = MIN_MATCH - 1; /* length of best match */
+
+        /* Process the input block. */
+        while (lookahead != 0) {
+                /* Insert the string window[strstart .. strstart+2] in the
+                 * dictionary, and set hash_head to the head of the hash chain:
+                 */
+                INSERT_STRING(strstart, hash_head);
+
+                /* Find the longest match, discarding those <= prev_length.
+                 */
+                prev_length = match_length, prev_match = match_start;
+                match_length = MIN_MATCH - 1;
+
+                if (hash_head != NIL && prev_length < max_lazy_match &&
+                        strstart - hash_head <= MAX_DIST) {
+                        /* To simplify the code, we prevent matches with the string
+                         * of window index 0 (in particular we have to avoid a match
+                         * of the string with itself at the start of the input file).
+                         */
+                        match_length = longest_match(hash_head);
+                        /* longest_match() sets match_start */
+                        if (match_length > lookahead)
+                                match_length = lookahead;
+
+                        /* Ignore a length 3 match if it is too distant: */
+                        if (match_length == MIN_MATCH && strstart - match_start > TOO_FAR) {
+                                /* If prev_match is also MIN_MATCH, match_start is garbage
+                                 * but we will ignore the current match anyway.
+                                 */
+                                match_length--;
+                        }
+                }
+                /* If there was a match at the previous step and the current
+                 * match is not better, output the previous match:
+                 */
+                if (prev_length >= MIN_MATCH && match_length <= prev_length) {
+
+                        check_match(strstart - 1, prev_match, prev_length);
+
+                        flush =
+                                ct_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
+
+                        /* Insert in hash table all strings up to the end of the match.
+                         * strstart-1 and strstart are already inserted.
+                         */
+                        lookahead -= prev_length - 1;
+                        prev_length -= 2;
+                        do {
+                                strstart++;
+                                INSERT_STRING(strstart, hash_head);
+                                /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+                                 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
+                                 * these bytes are garbage, but it does not matter since the
+                                 * next lookahead bytes will always be emitted as literals.
+                                 */
+                        } while (--prev_length != 0);
+                        match_available = 0;
+                        match_length = MIN_MATCH - 1;
+                        strstart++;
+                        if (flush)
+                                FLUSH_BLOCK(0), block_start = strstart;
+
+                } else if (match_available) {
+                        /* If there was no match at the previous position, output a
+                         * single literal. If there was a match but the current match
+                         * is longer, truncate the previous match to a single literal.
+                         */
+                        Tracevv((stderr, "%c", window[strstart - 1]));
+                        if (ct_tally(0, window[strstart - 1])) {
+                                FLUSH_BLOCK(0), block_start = strstart;
+                        }
+                        strstart++;
+                        lookahead--;
+                } else {
+                        /* There is no previous match to compare with, wait for
+                         * the next step to decide.
+                         */
+                        match_available = 1;
+                        strstart++;
+                        lookahead--;
+                }
+                Assert(strstart <= isize && lookahead <= isize, "a bit too far");
+
+                /* Make sure that we always have enough lookahead, except
+                 * at the end of the input file. We need MAX_MATCH bytes
+                 * for the next match, plus MIN_MATCH bytes to insert the
+                 * string following the next match.
+                 */
+                while (lookahead < MIN_LOOKAHEAD && !eofile)
+                        fill_window();
+        }
+        if (match_available)
+                ct_tally(0, window[strstart - 1]);
+
+        return FLUSH_BLOCK(1);  /* eof */
+}
+
+/* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * The unzip code was written and put in the public domain by Mark Adler.
+ * Portions of the lzw code are derived from the public domain 'compress'
+ * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
+ * Ken Turkowski, Dave Mack and Peter Jannesen.
+ *
+ * See the license_msg below and the file COPYING for the software license.
+ * See the file algorithm.doc for the compression algorithms and file formats.
+ */
+
+/* Compress files with zip algorithm and 'compress' interface.
+ * See usage() and help() functions below for all options.
+ * Outputs:
+ *        file.gz:   compressed file with same mode, owner, and utimes
+ *     or stdout with -c option or if stdin used as input.
+ * If the output file name had to be truncated, the original name is kept
+ * in the compressed file.
+ */
+
+                /* configuration */
+
+typedef struct dirent dir_type;
+
+typedef RETSIGTYPE(*sig_type) (int);
+
+/* ======================================================================== */
+int gzip_main(int argc, char **argv)
+{
+        int result;
+        int inFileNum;
+        int outFileNum;
+        struct stat statBuf;
+        char *delFileName;
+        int tostdout = 0;
+        int force = 0;
+        int opt;
+
+        while ((opt = getopt(argc, argv, "cf123456789dq")) != -1) {
+                switch (opt) {
+                case 'c':
+                        tostdout = 1;
+                        break;
+                case 'f':
+                        force = 1;
+                        break;
+                        /* Ignore 1-9 (compression level) options */
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                        break;
+                case 'q':
+                        break;
+#ifdef CONFIG_GUNZIP
+                case 'd':
+                        optind = 1;
+                        return gunzip_main(argc, argv);
+#endif
+                default:
+                        bb_show_usage();
+                }
+        }
+
+        foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
+        if (foreground) {
+                (void) signal(SIGINT, (sig_type) abort_gzip);
+        }
+#ifdef SIGTERM
+        if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
+                (void) signal(SIGTERM, (sig_type) abort_gzip);
+        }
+#endif
+#ifdef SIGHUP
+        if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
+                (void) signal(SIGHUP, (sig_type) abort_gzip);
+        }
+#endif
+
+        strncpy(z_suffix, Z_SUFFIX, sizeof(z_suffix) - 1);
+        z_len = strlen(z_suffix);
+
+        /* Allocate all global buffers (for DYN_ALLOC option) */
+        ALLOC(uch, inbuf, INBUFSIZ + INBUF_EXTRA);
+        ALLOC(uch, outbuf, OUTBUFSIZ + OUTBUF_EXTRA);
+        ALLOC(ush, d_buf, DIST_BUFSIZE);
+        ALLOC(uch, window, 2L * WSIZE);
+        ALLOC(ush, tab_prefix, 1L << BITS);
+
+        clear_bufs();
+        part_nb = 0;
+
+        if (optind == argc) {
+                time_stamp = 0;
+                ifile_size = -1L;
+                zip(STDIN_FILENO, STDOUT_FILENO);
+        } else {
+                int i;
+
+                for (i = optind; i < argc; i++) {
+                        char *path = NULL;
+
+                        if (strcmp(argv[i], "-") == 0) {
+                                time_stamp = 0;
+                                ifile_size = -1L;
+                                inFileNum = STDIN_FILENO;
+                                outFileNum = STDOUT_FILENO;
+                        } else {
+                                inFileNum = open(argv[i], O_RDONLY);
+                                if (inFileNum < 0 || fstat(inFileNum, &statBuf) < 0)
+                                        bb_perror_msg_and_die("%s", argv[i]);
+                                time_stamp = statBuf.st_ctime;
+                                ifile_size = statBuf.st_size;
+
+                                if (!tostdout) {
+                                        path = xmalloc(strlen(argv[i]) + 4);
+                                        strcpy(path, argv[i]);
+                                        strcat(path, ".gz");
+
+                                        /* Open output file */
+#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
+                                        outFileNum =
+                                                open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW);
+#else
+                                        outFileNum = open(path, O_RDWR | O_CREAT | O_EXCL);
+#endif
+                                        if (outFileNum < 0) {
+                                                bb_perror_msg("%s", path);
+                                                free(path);
+                                                continue;
+                                        }
+
+                                        /* Set permissions on the file */
+                                        fchmod(outFileNum, statBuf.st_mode);
+                                } else
+                                        outFileNum = STDOUT_FILENO;
+                        }
+
+                        if (path == NULL && isatty(outFileNum) && force == 0) {
+                                bb_error_msg
+                                        ("compressed data not written to a terminal. Use -f to force compression.");
+                                free(path);
+                                continue;
+                        }
+
+                        result = zip(inFileNum, outFileNum);
+
+                        if (path != NULL) {
+                                close(inFileNum);
+                                close(outFileNum);
+
+                                /* Delete the original file */
+                                if (result == OK)
+                                        delFileName = argv[i];
+                                else
+                                        delFileName = path;
+
+                                if (unlink(delFileName) < 0)
+                                        bb_perror_msg("%s", delFileName);
+                        }
+
+                        free(path);
+                }
+        }
+
+        return (exit_code);
+}
+
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * This is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License, see the file COPYING.
+ */
+
+/*
+ *  PURPOSE
+ *
+ *      Encode various sets of source values using variable-length
+ *      binary code trees.
+ *
+ *  DISCUSSION
+ *
+ *      The PKZIP "deflation" process uses several Huffman trees. The more
+ *      common source values are represented by shorter bit sequences.
+ *
+ *      Each code tree is stored in the ZIP file in a compressed form
+ *      which is itself a Huffman encoding of the lengths of
+ *      all the code strings (in ascending order by source values).
+ *      The actual code strings are reconstructed from the lengths in
+ *      the UNZIP process, as described in the "application note"
+ *      (APPNOTE.TXT) distributed as part of PKWARE's PKZIP program.
+ *
+ *  REFERENCES
+ *
+ *      Lynch, Thomas J.
+ *          Data Compression:  Techniques and Applications, pp. 53-55.
+ *          Lifetime Learning Publications, 1985.  ISBN 0-534-03418-7.
+ *
+ *      Storer, James A.
+ *          Data Compression:  Methods and Theory, pp. 49-50.
+ *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
+ *
+ *      Sedgewick, R.
+ *          Algorithms, p290.
+ *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ *
+ *  INTERFACE
+ *
+ *      void ct_init (ush *attr, int *methodp)
+ *          Allocate the match buffer, initialize the various tables and save
+ *          the location of the internal file attribute (ascii/binary) and
+ *          method (DEFLATE/STORE)
+ *
+ *      void ct_tally (int dist, int lc);
+ *          Save the match info and tally the frequency counts.
+ *
+ *      long flush_block (char *buf, ulg stored_len, int eof)
+ *          Determine the best encoding for the current block: dynamic trees,
+ *          static trees or store, and output the encoded block to the zip
+ *          file. Returns the total compressed length for the file so far.
+ *
+ */
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+typedef uch extra_bits_t;
+
+/* extra bits for each length code */
+static const extra_bits_t extra_lbits[LENGTH_CODES]
+        = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
+        4, 4, 5, 5, 5, 5, 0
+};
+
+/* extra bits for each distance code */
+static const extra_bits_t extra_dbits[D_CODES]
+        = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
+        10, 10, 11, 11, 12, 12, 13, 13
+};
+
+/* extra bits for each bit length code */
+static const extra_bits_t extra_blbits[BL_CODES]
+= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#ifndef LIT_BUFSIZE
+#  ifdef SMALL_MEM
+#    define LIT_BUFSIZE  0x2000
+#  else
+#  ifdef MEDIUM_MEM
+#    define LIT_BUFSIZE  0x4000
+#  else
+#    define LIT_BUFSIZE  0x8000
+#  endif
+#  endif
+#endif
+#ifndef DIST_BUFSIZE
+#  define DIST_BUFSIZE  LIT_BUFSIZE
+#endif
+/* Sizes of match buffers for literals/lengths and distances.  There are
+ * 4 reasons for limiting LIT_BUFSIZE to 64K:
+ *   - frequencies can be kept in 16 bit counters
+ *   - if compression is not successful for the first block, all input data is
+ *     still in the window so we can still emit a stored block even when input
+ *     comes from standard input.  (This can also be done for all blocks if
+ *     LIT_BUFSIZE is not greater than 32K.)
+ *   - if compression is not successful for a file smaller than 64K, we can
+ *     even emit a stored file instead of a stored block (saving 5 bytes).
+ *   - creating new Huffman trees less frequently may not provide fast
+ *     adaptation to changes in the input data statistics. (Take for
+ *     example a binary file with poorly compressible code followed by
+ *     a highly compressible string table.) Smaller buffer sizes give
+ *     fast adaptation but have of course the overhead of transmitting trees
+ *     more frequently.
+ *   - I can't count above 4
+ * The current code is general and allows DIST_BUFSIZE < LIT_BUFSIZE (to save
+ * memory at the expense of compression). Some optimizations would be possible
+ * if we rely on DIST_BUFSIZE == LIT_BUFSIZE.
+ */
+#if LIT_BUFSIZE > INBUFSIZ
+#error cannot overlay l_buf and inbuf
+#endif
+#define REP_3_6      16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+#define REPZ_3_10    17
+/* repeat a zero length 3-10 times  (3 bits of repeat count) */
+#define REPZ_11_138  18
+/* repeat a zero length 11-138 times  (7 bits of repeat count) */
+
+/* ===========================================================================
+ * Local data
+ */
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data {
+        union {
+                ush freq;               /* frequency count */
+                ush code;               /* bit string */
+        } fc;
+        union {
+                ush dad;                /* father node in Huffman tree */
+                ush len;                /* length of bit string */
+        } dl;
+} ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+static ct_data dyn_ltree[HEAP_SIZE];    /* literal and length tree */
+static ct_data dyn_dtree[2 * D_CODES + 1];      /* distance tree */
+
+static ct_data static_ltree[L_CODES + 2];
+
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see ct_init
+ * below).
+ */
+
+static ct_data static_dtree[D_CODES];
+
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+static ct_data bl_tree[2 * BL_CODES + 1];
+
+/* Huffman tree for the bit lengths */
+
+typedef struct tree_desc {
+        ct_data *dyn_tree;      /* the dynamic tree */
+        ct_data *static_tree;   /* corresponding static tree or NULL */
+        const extra_bits_t *extra_bits; /* extra bits for each code or NULL */
+        int extra_base;         /* base index for extra_bits */
+        int elems;                      /* max number of elements in the tree */
+        int max_length;         /* max bit length for the codes */
+        int max_code;           /* largest code with non zero frequency */
+} tree_desc;
+
+static tree_desc l_desc =
+        { dyn_ltree, static_ltree, extra_lbits, LITERALS + 1, L_CODES,
+        MAX_BITS, 0
+};
+
+static tree_desc d_desc =
+        { dyn_dtree, static_dtree, extra_dbits, 0, D_CODES, MAX_BITS, 0 };
+
+static tree_desc bl_desc =
+        { bl_tree, (ct_data *) 0, extra_blbits, 0, BL_CODES, MAX_BL_BITS,
+        0
+};
+
+
+static ush bl_count[MAX_BITS + 1];
+
+/* number of codes at each bit length for an optimal tree */
+
+static const uch bl_order[BL_CODES]
+= { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+static int heap[2 * L_CODES + 1];       /* heap used to build the Huffman trees */
+static int heap_len;    /* number of elements in the heap */
+static int heap_max;    /* element of largest frequency */
+
+/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+ * The same heap array is used to build all trees.
+ */
+
+static uch depth[2 * L_CODES + 1];
+
+/* Depth of each subtree used as tie breaker for trees of equal frequency */
+
+static uch length_code[MAX_MATCH - MIN_MATCH + 1];
+
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+static uch dist_code[512];
+
+/* distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+static int base_length[LENGTH_CODES];
+
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+static int base_dist[D_CODES];
+
+/* First normalized distance for each code (0 = distance of 1) */
+
+#define l_buf inbuf
+/* DECLARE(uch, l_buf, LIT_BUFSIZE);  buffer for literals or lengths */
+
+/* DECLARE(ush, d_buf, DIST_BUFSIZE); buffer for distances */
+
+static uch flag_buf[(LIT_BUFSIZE / 8)];
+
+/* flag_buf is a bit array distinguishing literals from lengths in
+ * l_buf, thus indicating the presence or absence of a distance.
+ */
+
+static unsigned last_lit;       /* running index in l_buf */
+static unsigned last_dist;      /* running index in d_buf */
+static unsigned last_flags;     /* running index in flag_buf */
+static uch flags;               /* current flags not yet saved in flag_buf */
+static uch flag_bit;    /* current bit used in flags */
+
+/* bits are filled in flags starting at bit 0 (least significant).
+ * Note: these flags are overkill in the current code since we don't
+ * take advantage of DIST_BUFSIZE == LIT_BUFSIZE.
+ */
+
+static ulg opt_len;             /* bit length of current block with optimal trees */
+static ulg static_len;  /* bit length of current block with static trees */
+
+static ulg compressed_len;      /* total bit length of compressed file */
+
+
+static ush *file_type;  /* pointer to UNKNOWN, BINARY or ASCII */
+static int *file_method;        /* pointer to DEFLATE or STORE */
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+static void init_block(void);
+static void pqdownheap(ct_data * tree, int k);
+static void gen_bitlen(tree_desc * desc);
+static void gen_codes(ct_data * tree, int max_code);
+static void build_tree(tree_desc * desc);
+static void scan_tree(ct_data * tree, int max_code);
+static void send_tree(ct_data * tree, int max_code);
+static int build_bl_tree(void);
+static void send_all_trees(int lcodes, int dcodes, int blcodes);
+static void compress_block(ct_data * ltree, ct_data * dtree);
+static void set_file_type(void);
+
+
+#ifndef DEBUG
+#  define send_code(c, tree) send_bits(tree[c].Code, tree[c].Len)
+   /* Send a code of the given tree. c and tree must not have side effects */
+
+#else                                                   /* DEBUG */
+#  define send_code(c, tree) \
+     { if (verbose>1) bb_error_msg("\ncd %3d ",(c)); \
+       send_bits(tree[c].Code, tree[c].Len); }
+#endif
+
+#define d_code(dist) \
+   ((dist) < 256 ? dist_code[dist] : dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. dist_code[256] and dist_code[257] are never
+ * used.
+ */
+
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Allocate the match buffer, initialize the various tables and save the
+ * location of the internal file attribute (ascii/binary) and method
+ * (DEFLATE/STORE).
+ */
+static void ct_init(ush * attr, int *methodp)
+{
+        int n;                          /* iterates over tree elements */
+        int bits;                       /* bit counter */
+        int length;                     /* length value */
+        int code;                       /* code value */
+        int dist;                       /* distance index */
+
+        file_type = attr;
+        file_method = methodp;
+        compressed_len = 0L;
+
+        if (static_dtree[0].Len != 0)
+                return;                 /* ct_init already called */
+
+        /* Initialize the mapping length (0..255) -> length code (0..28) */
+        length = 0;
+        for (code = 0; code < LENGTH_CODES - 1; code++) {
+                base_length[code] = length;
+                for (n = 0; n < (1 << extra_lbits[code]); n++) {
+                        length_code[length++] = (uch) code;
+                }
+        }
+        Assert(length == 256, "ct_init: length != 256");
+        /* Note that the length 255 (match length 258) can be represented
+         * in two different ways: code 284 + 5 bits or code 285, so we
+         * overwrite length_code[255] to use the best encoding:
+         */
+        length_code[length - 1] = (uch) code;
+
+        /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+        dist = 0;
+        for (code = 0; code < 16; code++) {
+                base_dist[code] = dist;
+                for (n = 0; n < (1 << extra_dbits[code]); n++) {
+                        dist_code[dist++] = (uch) code;
+                }
+        }
+        Assert(dist == 256, "ct_init: dist != 256");
+        dist >>= 7;                     /* from now on, all distances are divided by 128 */
+        for (; code < D_CODES; code++) {
+                base_dist[code] = dist << 7;
+                for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
+                        dist_code[256 + dist++] = (uch) code;
+                }
+        }
+        Assert(dist == 256, "ct_init: 256+dist != 512");
+
+        /* Construct the codes of the static literal tree */
+        for (bits = 0; bits <= MAX_BITS; bits++)
+                bl_count[bits] = 0;
+        n = 0;
+        while (n <= 143)
+                static_ltree[n++].Len = 8, bl_count[8]++;
+        while (n <= 255)
+                static_ltree[n++].Len = 9, bl_count[9]++;
+        while (n <= 279)
+                static_ltree[n++].Len = 7, bl_count[7]++;
+        while (n <= 287)
+                static_ltree[n++].Len = 8, bl_count[8]++;
+        /* Codes 286 and 287 do not exist, but we must include them in the
+         * tree construction to get a canonical Huffman tree (longest code
+         * all ones)
+         */
+        gen_codes((ct_data *) static_ltree, L_CODES + 1);
+
+        /* The static distance tree is trivial: */
+        for (n = 0; n < D_CODES; n++) {
+                static_dtree[n].Len = 5;
+                static_dtree[n].Code = bi_reverse(n, 5);
+        }
+
+        /* Initialize the first block of the first file: */
+        init_block();
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+static void init_block()
+{
+        int n;                          /* iterates over tree elements */
+
+        /* Initialize the trees. */
+        for (n = 0; n < L_CODES; n++)
+                dyn_ltree[n].Freq = 0;
+        for (n = 0; n < D_CODES; n++)
+                dyn_dtree[n].Freq = 0;
+        for (n = 0; n < BL_CODES; n++)
+                bl_tree[n].Freq = 0;
+
+        dyn_ltree[END_BLOCK].Freq = 1;
+        opt_len = static_len = 0L;
+        last_lit = last_dist = last_flags = 0;
+        flags = 0;
+        flag_bit = 1;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(tree, top) \
+{\
+    top = heap[SMALLEST]; \
+    heap[SMALLEST] = heap[heap_len--]; \
+    pqdownheap(tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m) \
+   (tree[n].Freq < tree[m].Freq || \
+   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+static void pqdownheap(ct_data * tree, int k)
+{
+        int v = heap[k];
+        int j = k << 1;         /* left son of k */
+
+        while (j <= heap_len) {
+                /* Set j to the smallest of the two sons: */
+                if (j < heap_len && smaller(tree, heap[j + 1], heap[j]))
+                        j++;
+
+                /* Exit if v is smaller than both sons */
+                if (smaller(tree, v, heap[j]))
+                        break;
+
+                /* Exchange v with the smallest son */
+                heap[k] = heap[j];
+                k = j;
+
+                /* And continue down the tree, setting j to the left son of k */
+                j <<= 1;
+        }
+        heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ *    above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ *     array bl_count contains the frequencies for each bit length.
+ *     The length opt_len is updated; static_len is also updated if stree is
+ *     not null.
+ */
+static void gen_bitlen(tree_desc * desc)
+{
+        ct_data *tree = desc->dyn_tree;
+        const extra_bits_t *extra = desc->extra_bits;
+        int base = desc->extra_base;
+        int max_code = desc->max_code;
+        int max_length = desc->max_length;
+        ct_data *stree = desc->static_tree;
+        int h;                          /* heap index */
+        int n, m;                       /* iterate over the tree elements */
+        int bits;                       /* bit length */
+        int xbits;                      /* extra bits */
+        ush f;                          /* frequency */
+        int overflow = 0;       /* number of elements with bit length too large */
+
+        for (bits = 0; bits <= MAX_BITS; bits++)
+                bl_count[bits] = 0;
+
+        /* In a first pass, compute the optimal bit lengths (which may
+         * overflow in the case of the bit length tree).
+         */
+        tree[heap[heap_max]].Len = 0;   /* root of the heap */
+
+        for (h = heap_max + 1; h < HEAP_SIZE; h++) {
+                n = heap[h];
+                bits = tree[tree[n].Dad].Len + 1;
+                if (bits > max_length)
+                        bits = max_length, overflow++;
+                tree[n].Len = (ush) bits;
+                /* We overwrite tree[n].Dad which is no longer needed */
+
+                if (n > max_code)
+                        continue;       /* not a leaf node */
+
+                bl_count[bits]++;
+                xbits = 0;
+                if (n >= base)
+                        xbits = extra[n - base];
+                f = tree[n].Freq;
+                opt_len += (ulg) f *(bits + xbits);
+
+                if (stree)
+                        static_len += (ulg) f *(stree[n].Len + xbits);
+        }
+        if (overflow == 0)
+                return;
+
+        Trace((stderr, "\nbit length overflow\n"));
+        /* This happens for example on obj2 and pic of the Calgary corpus */
+
+        /* Find the first bit length which could increase: */
+        do {
+                bits = max_length - 1;
+                while (bl_count[bits] == 0)
+                        bits--;
+                bl_count[bits]--;       /* move one leaf down the tree */
+                bl_count[bits + 1] += 2;        /* move one overflow item as its brother */
+                bl_count[max_length]--;
+                /* The brother of the overflow item also moves one step up,
+                 * but this does not affect bl_count[max_length]
+                 */
+                overflow -= 2;
+        } while (overflow > 0);
+
+        /* Now recompute all bit lengths, scanning in increasing frequency.
+         * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+         * lengths instead of fixing only the wrong ones. This idea is taken
+         * from 'ar' written by Haruhiko Okumura.)
+         */
+        for (bits = max_length; bits != 0; bits--) {
+                n = bl_count[bits];
+                while (n != 0) {
+                        m = heap[--h];
+                        if (m > max_code)
+                                continue;
+                        if (tree[m].Len != (unsigned) bits) {
+                                Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len,
+                                           bits));
+                                opt_len +=
+                                        ((long) bits - (long) tree[m].Len) * (long) tree[m].Freq;
+                                tree[m].Len = (ush) bits;
+                        }
+                        n--;
+                }
+        }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ *     zero code length.
+ */
+static void gen_codes(ct_data * tree, int max_code)
+{
+        ush next_code[MAX_BITS + 1];    /* next code value for each bit length */
+        ush code = 0;           /* running code value */
+        int bits;                       /* bit index */
+        int n;                          /* code index */
+
+        /* The distribution counts are first used to generate the code values
+         * without bit reversal.
+         */
+        for (bits = 1; bits <= MAX_BITS; bits++) {
+                next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
+        }
+        /* Check that the bit counts in bl_count are consistent. The last code
+         * must be all ones.
+         */
+        Assert(code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
+                   "inconsistent bit counts");
+        Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
+
+        for (n = 0; n <= max_code; n++) {
+                int len = tree[n].Len;
+
+                if (len == 0)
+                        continue;
+                /* Now reverse the bits */
+                tree[n].Code = bi_reverse(next_code[len]++, len);
+
+                Tracec(tree != static_ltree,
+                           (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
+                                (isgraph(n) ? n : ' '), len, tree[n].Code,
+                                next_code[len] - 1));
+        }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ *     and corresponding code. The length opt_len is updated; static_len is
+ *     also updated if stree is not null. The field max_code is set.
+ */
+static void build_tree(tree_desc * desc)
+{
+        ct_data *tree = desc->dyn_tree;
+        ct_data *stree = desc->static_tree;
+        int elems = desc->elems;
+        int n, m;                       /* iterate over heap elements */
+        int max_code = -1;      /* largest code with non zero frequency */
+        int node = elems;       /* next internal node of the tree */
+
+        /* Construct the initial heap, with least frequent element in
+         * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+         * heap[0] is not used.
+         */
+        heap_len = 0, heap_max = HEAP_SIZE;
+
+        for (n = 0; n < elems; n++) {
+                if (tree[n].Freq != 0) {
+                        heap[++heap_len] = max_code = n;
+                        depth[n] = 0;
+                } else {
+                        tree[n].Len = 0;
+                }
+        }
+
+        /* The pkzip format requires that at least one distance code exists,
+         * and that at least one bit should be sent even if there is only one
+         * possible code. So to avoid special checks later on we force at least
+         * two codes of non zero frequency.
+         */
+        while (heap_len < 2) {
+                int new = heap[++heap_len] = (max_code < 2 ? ++max_code : 0);
+
+                tree[new].Freq = 1;
+                depth[new] = 0;
+                opt_len--;
+                if (stree)
+                        static_len -= stree[new].Len;
+                /* new is 0 or 1 so it does not have extra bits */
+        }
+        desc->max_code = max_code;
+
+        /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+         * establish sub-heaps of increasing lengths:
+         */
+        for (n = heap_len / 2; n >= 1; n--)
+                pqdownheap(tree, n);
+
+        /* Construct the Huffman tree by repeatedly combining the least two
+         * frequent nodes.
+         */
+        do {
+                pqremove(tree, n);      /* n = node of least frequency */
+                m = heap[SMALLEST];     /* m = node of next least frequency */
+
+                heap[--heap_max] = n;   /* keep the nodes sorted by frequency */
+                heap[--heap_max] = m;
+
+                /* Create a new node father of n and m */
+                tree[node].Freq = tree[n].Freq + tree[m].Freq;
+                depth[node] = (uch) (MAX(depth[n], depth[m]) + 1);
+                tree[n].Dad = tree[m].Dad = (ush) node;
+#ifdef DUMP_BL_TREE
+                if (tree == bl_tree) {
+                        bb_error_msg("\nnode %d(%d), sons %d(%d) %d(%d)",
+                                        node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+                }
+#endif
+                /* and insert the new node in the heap */
+                heap[SMALLEST] = node++;
+                pqdownheap(tree, SMALLEST);
+
+        } while (heap_len >= 2);
+
+        heap[--heap_max] = heap[SMALLEST];
+
+        /* At this point, the fields freq and dad are set. We can now
+         * generate the bit lengths.
+         */
+        gen_bitlen((tree_desc *) desc);
+
+        /* The field len is now set, we can generate the bit codes */
+        gen_codes((ct_data *) tree, max_code);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree. Updates opt_len to take into account the repeat
+ * counts. (The contribution of the bit length codes will be added later
+ * during the construction of bl_tree.)
+ */
+static void scan_tree(ct_data * tree, int max_code)
+{
+        int n;                          /* iterates over all tree elements */
+        int prevlen = -1;       /* last emitted length */
+        int curlen;                     /* length of current code */
+        int nextlen = tree[0].Len;      /* length of next code */
+        int count = 0;          /* repeat count of the current code */
+        int max_count = 7;      /* max repeat count */
+        int min_count = 4;      /* min repeat count */
+
+        if (nextlen == 0)
+                max_count = 138, min_count = 3;
+        tree[max_code + 1].Len = (ush) 0xffff;  /* guard */
+
+        for (n = 0; n <= max_code; n++) {
+                curlen = nextlen;
+                nextlen = tree[n + 1].Len;
+                if (++count < max_count && curlen == nextlen) {
+                        continue;
+                } else if (count < min_count) {
+                        bl_tree[curlen].Freq += count;
+                } else if (curlen != 0) {
+                        if (curlen != prevlen)
+                                bl_tree[curlen].Freq++;
+                        bl_tree[REP_3_6].Freq++;
+                } else if (count <= 10) {
+                        bl_tree[REPZ_3_10].Freq++;
+                } else {
+                        bl_tree[REPZ_11_138].Freq++;
+                }
+                count = 0;
+                prevlen = curlen;
+                if (nextlen == 0) {
+                        max_count = 138, min_count = 3;
+                } else if (curlen == nextlen) {
+                        max_count = 6, min_count = 3;
+                } else {
+                        max_count = 7, min_count = 4;
+                }
+        }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+static void send_tree(ct_data * tree, int max_code)
+{
+        int n;                          /* iterates over all tree elements */
+        int prevlen = -1;       /* last emitted length */
+        int curlen;                     /* length of current code */
+        int nextlen = tree[0].Len;      /* length of next code */
+        int count = 0;          /* repeat count of the current code */
+        int max_count = 7;      /* max repeat count */
+        int min_count = 4;      /* min repeat count */
+
+/* tree[max_code+1].Len = -1; *//* guard already set */
+        if (nextlen == 0)
+                max_count = 138, min_count = 3;
+
+        for (n = 0; n <= max_code; n++) {
+                curlen = nextlen;
+                nextlen = tree[n + 1].Len;
+                if (++count < max_count && curlen == nextlen) {
+                        continue;
+                } else if (count < min_count) {
+                        do {
+                                send_code(curlen, bl_tree);
+                        } while (--count != 0);
+
+                } else if (curlen != 0) {
+                        if (curlen != prevlen) {
+                                send_code(curlen, bl_tree);
+                                count--;
+                        }
+                        Assert(count >= 3 && count <= 6, " 3_6?");
+                        send_code(REP_3_6, bl_tree);
+                        send_bits(count - 3, 2);
+
+                } else if (count <= 10) {
+                        send_code(REPZ_3_10, bl_tree);
+                        send_bits(count - 3, 3);
+
+                } else {
+                        send_code(REPZ_11_138, bl_tree);
+                        send_bits(count - 11, 7);
+                }
+                count = 0;
+                prevlen = curlen;
+                if (nextlen == 0) {
+                        max_count = 138, min_count = 3;
+                } else if (curlen == nextlen) {
+                        max_count = 6, min_count = 3;
+                } else {
+                        max_count = 7, min_count = 4;
+                }
+        }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+static const int build_bl_tree()
+{
+        int max_blindex;        /* index of last bit length code of non zero freq */
+
+        /* Determine the bit length frequencies for literal and distance trees */
+        scan_tree((ct_data *) dyn_ltree, l_desc.max_code);
+        scan_tree((ct_data *) dyn_dtree, d_desc.max_code);
+
+        /* Build the bit length tree: */
+        build_tree((tree_desc *) (&bl_desc));
+        /* opt_len now includes the length of the tree representations, except
+         * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+         */
+
+        /* Determine the number of bit length codes to send. The pkzip format
+         * requires that at least 4 bit length codes be sent. (appnote.txt says
+         * 3 but the actual value used is 4.)
+         */
+        for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
+                if (bl_tree[bl_order[max_blindex]].Len != 0)
+                        break;
+        }
+        /* Update opt_len to include the bit length tree and counts */
+        opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+        Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", opt_len, static_len));
+
+        return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+static void send_all_trees(int lcodes, int dcodes, int blcodes)
+{
+        int rank;                       /* index in bl_order */
+
+        Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+        Assert(lcodes <= L_CODES && dcodes <= D_CODES
+                   && blcodes <= BL_CODES, "too many codes");
+        Tracev((stderr, "\nbl counts: "));
+        send_bits(lcodes - 257, 5);     /* not +255 as stated in appnote.txt */
+        send_bits(dcodes - 1, 5);
+        send_bits(blcodes - 4, 4);      /* not -3 as stated in appnote.txt */
+        for (rank = 0; rank < blcodes; rank++) {
+                Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+                send_bits(bl_tree[bl_order[rank]].Len, 3);
+        }
+        Tracev((stderr, "\nbl tree: sent %ld", bits_sent));
+
+        send_tree((ct_data *) dyn_ltree, lcodes - 1);   /* send the literal tree */
+        Tracev((stderr, "\nlit tree: sent %ld", bits_sent));
+
+        send_tree((ct_data *) dyn_dtree, dcodes - 1);   /* send the distance tree */
+        Tracev((stderr, "\ndist tree: sent %ld", bits_sent));
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file. This function
+ * returns the total compressed length for the file so far.
+ */
+static ulg flush_block(char *buf, ulg stored_len, int eof)
+{
+        ulg opt_lenb, static_lenb;      /* opt_len and static_len in bytes */
+        int max_blindex;        /* index of last bit length code of non zero freq */
+
+        flag_buf[last_flags] = flags;   /* Save the flags for the last 8 items */
+
+        /* Check if the file is ascii or binary */
+        if (*file_type == (ush) UNKNOWN)
+                set_file_type();
+
+        /* Construct the literal and distance trees */
+        build_tree((tree_desc *) (&l_desc));
+        Tracev((stderr, "\nlit data: dyn %ld, stat %ld", opt_len, static_len));
+
+        build_tree((tree_desc *) (&d_desc));
+        Tracev((stderr, "\ndist data: dyn %ld, stat %ld", opt_len, static_len));
+        /* At this point, opt_len and static_len are the total bit lengths of
+         * the compressed block data, excluding the tree representations.
+         */
+
+        /* Build the bit length tree for the above two trees, and get the index
+         * in bl_order of the last bit length code to send.
+         */
+        max_blindex = build_bl_tree();
+
+        /* Determine the best encoding. Compute first the block length in bytes */
+        opt_lenb = (opt_len + 3 + 7) >> 3;
+        static_lenb = (static_len + 3 + 7) >> 3;
+
+        Trace((stderr,
+                   "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
+                   opt_lenb, opt_len, static_lenb, static_len, stored_len,
+                   last_lit, last_dist));
+
+        if (static_lenb <= opt_lenb)
+                opt_lenb = static_lenb;
+
+        /* If compression failed and this is the first and last block,
+         * and if the zip file can be seeked (to rewrite the local header),
+         * the whole file is transformed into a stored file:
+         */
+        if (stored_len <= opt_lenb && eof && compressed_len == 0L && seekable()) {
+                /* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
+                if (buf == (char *) 0)
+                        bb_error_msg("block vanished");
+
+                copy_block(buf, (unsigned) stored_len, 0);      /* without header */
+                compressed_len = stored_len << 3;
+                *file_method = STORED;
+
+        } else if (stored_len + 4 <= opt_lenb && buf != (char *) 0) {
+                /* 4: two words for the lengths */
+                /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+                 * Otherwise we can't have processed more than WSIZE input bytes since
+                 * the last block flush, because compression would have been
+                 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+                 * transform a block into a stored block.
+                 */
+                send_bits((STORED_BLOCK << 1) + eof, 3);        /* send block type */
+                compressed_len = (compressed_len + 3 + 7) & ~7L;
+                compressed_len += (stored_len + 4) << 3;
+
+                copy_block(buf, (unsigned) stored_len, 1);      /* with header */
+
+        } else if (static_lenb == opt_lenb) {
+                send_bits((STATIC_TREES << 1) + eof, 3);
+                compress_block((ct_data *) static_ltree, (ct_data *) static_dtree);
+                compressed_len += 3 + static_len;
+        } else {
+                send_bits((DYN_TREES << 1) + eof, 3);
+                send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1,
+                                           max_blindex + 1);
+                compress_block((ct_data *) dyn_ltree, (ct_data *) dyn_dtree);
+                compressed_len += 3 + opt_len;
+        }
+        Assert(compressed_len == bits_sent, "bad compressed size");
+        init_block();
+
+        if (eof) {
+                bi_windup();
+                compressed_len += 7;    /* align on byte boundary */
+        }
+        Tracev((stderr, "\ncomprlen %lu(%lu) ", compressed_len >> 3,
+                        compressed_len - 7 * eof));
+
+        return compressed_len >> 3;
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+static int ct_tally(int dist, int lc)
+{
+        l_buf[last_lit++] = (uch) lc;
+        if (dist == 0) {
+                /* lc is the unmatched char */
+                dyn_ltree[lc].Freq++;
+        } else {
+                /* Here, lc is the match length - MIN_MATCH */
+                dist--;                 /* dist = match distance - 1 */
+                Assert((ush) dist < (ush) MAX_DIST &&
+                           (ush) lc <= (ush) (MAX_MATCH - MIN_MATCH) &&
+                           (ush) d_code(dist) < (ush) D_CODES, "ct_tally: bad match");
+
+                dyn_ltree[length_code[lc] + LITERALS + 1].Freq++;
+                dyn_dtree[d_code(dist)].Freq++;
+
+                d_buf[last_dist++] = (ush) dist;
+                flags |= flag_bit;
+        }
+        flag_bit <<= 1;
+
+        /* Output the flags if they fill a byte: */
+        if ((last_lit & 7) == 0) {
+                flag_buf[last_flags++] = flags;
+                flags = 0, flag_bit = 1;
+        }
+        /* Try to guess if it is profitable to stop the current block here */
+        if ((last_lit & 0xfff) == 0) {
+                /* Compute an upper bound for the compressed length */
+                ulg out_length = (ulg) last_lit * 8L;
+                ulg in_length = (ulg) strstart - block_start;
+                int dcode;
+
+                for (dcode = 0; dcode < D_CODES; dcode++) {
+                        out_length +=
+                                (ulg) dyn_dtree[dcode].Freq * (5L + extra_dbits[dcode]);
+                }
+                out_length >>= 3;
+                Trace((stderr,
+                           "\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
+                           last_lit, last_dist, in_length, out_length,
+                           100L - out_length * 100L / in_length));
+                if (last_dist < last_lit / 2 && out_length < in_length / 2)
+                        return 1;
+        }
+        return (last_lit == LIT_BUFSIZE - 1 || last_dist == DIST_BUFSIZE);
+        /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
+         * on 16 bit machines and because stored blocks are restricted to
+         * 64K-1 bytes.
+         */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+static void compress_block(ct_data * ltree, ct_data * dtree)
+{
+        unsigned dist;          /* distance of matched string */
+        int lc;                         /* match length or unmatched char (if dist == 0) */
+        unsigned lx = 0;        /* running index in l_buf */
+        unsigned dx = 0;        /* running index in d_buf */
+        unsigned fx = 0;        /* running index in flag_buf */
+        uch flag = 0;           /* current flags */
+        unsigned code;          /* the code to send */
+        int extra;                      /* number of extra bits to send */
+
+        if (last_lit != 0)
+                do {
+                        if ((lx & 7) == 0)
+                                flag = flag_buf[fx++];
+                        lc = l_buf[lx++];
+                        if ((flag & 1) == 0) {
+                                send_code(lc, ltree);   /* send a literal byte */
+                                Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
+                        } else {
+                                /* Here, lc is the match length - MIN_MATCH */
+                                code = length_code[lc];
+                                send_code(code + LITERALS + 1, ltree);  /* send the length code */
+                                extra = extra_lbits[code];
+                                if (extra != 0) {
+                                        lc -= base_length[code];
+                                        send_bits(lc, extra);   /* send the extra length bits */
+                                }
+                                dist = d_buf[dx++];
+                                /* Here, dist is the match distance - 1 */
+                                code = d_code(dist);
+                                Assert(code < D_CODES, "bad d_code");
+
+                                send_code(code, dtree); /* send the distance code */
+                                extra = extra_dbits[code];
+                                if (extra != 0) {
+                                        dist -= base_dist[code];
+                                        send_bits(dist, extra); /* send the extra distance bits */
+                                }
+                        }                       /* literal or match pair ? */
+                        flag >>= 1;
+                } while (lx < last_lit);
+
+        send_code(END_BLOCK, ltree);
+}
+
+/* ===========================================================================
+ * Set the file type to ASCII or BINARY, using a crude approximation:
+ * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
+ * IN assertion: the fields freq of dyn_ltree are set and the total of all
+ * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
+ */
+static void set_file_type()
+{
+        int n = 0;
+        unsigned ascii_freq = 0;
+        unsigned bin_freq = 0;
+
+        while (n < 7)
+                bin_freq += dyn_ltree[n++].Freq;
+        while (n < 128)
+                ascii_freq += dyn_ltree[n++].Freq;
+        while (n < LITERALS)
+                bin_freq += dyn_ltree[n++].Freq;
+        *file_type = bin_freq > (ascii_freq >> 2) ? BINARY : ASCII;
+        if (*file_type == BINARY && translate_eol) {
+                bb_error_msg("-l used on binary file");
+        }
+}
+
+/* zip.c -- compress files to the gzip or pkzip format
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * This is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License, see the file COPYING.
+ */
+
+
+static ulg crc;                 /* crc on uncompressed file data */
+static long header_bytes;       /* number of bytes in gzip header */
+
+static void put_long(ulg n)
+{
+        put_short((n) & 0xffff);
+        put_short(((ulg) (n)) >> 16);
+}
+
+/* put_header_byte is used for the compressed output
+ * - for the initial 4 bytes that can't overflow the buffer.
+ */
+#define put_header_byte(c) {outbuf[outcnt++]=(uch)(c);}
+
+/* ===========================================================================
+ * Deflate in to out.
+ * IN assertions: the input and output buffers are cleared.
+ *   The variables time_stamp and save_orig_name are initialized.
+ */
+static int zip(int in, int out)
+{
+        uch my_flags = 0;       /* general purpose bit flags */
+        ush attr = 0;           /* ascii/binary flag */
+        ush deflate_flags = 0;  /* pkzip -es, -en or -ex equivalent */
+
+        ifd = in;
+        ofd = out;
+        outcnt = 0;
+
+        /* Write the header to the gzip file. See algorithm.doc for the format */
+
+
+        method = DEFLATED;
+        put_header_byte(GZIP_MAGIC[0]); /* magic header */
+        put_header_byte(GZIP_MAGIC[1]);
+        put_header_byte(DEFLATED);      /* compression method */
+
+        put_header_byte(my_flags);      /* general flags */
+        put_long(time_stamp);
+
+        /* Write deflated file to zip file */
+        crc = updcrc(0, 0);
+
+        bi_init(out);
+        ct_init(&attr, &method);
+        lm_init(&deflate_flags);
+
+        put_byte((uch) deflate_flags);  /* extra flags */
+        put_byte(OS_CODE);      /* OS identifier */
+
+        header_bytes = (long) outcnt;
+
+        (void) deflate();
+
+        /* Write the crc and uncompressed size */
+        put_long(crc);
+        put_long(isize);
+        header_bytes += 2 * sizeof(long);
+
+        flush_outbuf();
+        return OK;
+}
+
+
+/* ===========================================================================
+ * Read a new buffer from the current input file, perform end-of-line
+ * translation, and update the crc and input file size.
+ * IN assertion: size >= 2 (for end-of-line translation)
+ */
+static int file_read(char *buf, unsigned size)
+{
+        unsigned len;
+
+        Assert(insize == 0, "inbuf not empty");
+
+        len = read(ifd, buf, size);
+        if (len == (unsigned) (-1) || len == 0)
+                return (int) len;
+
+        crc = updcrc((uch *) buf, len);
+        isize += (ulg) len;
+        return (int) len;
+}
+
+/* ===========================================================================
+ * Write the output buffer outbuf[0..outcnt-1] and update bytes_out.
+ * (used for the compressed data only)
+ */
+static void flush_outbuf()
+{
+        if (outcnt == 0)
+                return;
+
+        write_buf(ofd, (char *) outbuf, outcnt);
+        outcnt = 0;
+}
diff --git a/busybox/archival/libunarchive/Makefile b/busybox/archival/libunarchive/Makefile
new file mode 100644
index 000000000..e985fa49f
--- /dev/null
+++ b/busybox/archival/libunarchive/Makefile
@@ -0,0 +1,32 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+top_srcdir=../..
+top_builddir=../..
+srcdir=$(top_srcdir)/archival/libunarchive
+LIBUNARCHIVE_DIR:=./
+include $(top_builddir)/Rules.mak
+include $(top_builddir)/.config
+include $(srcdir)/Makefile.in
+all: $(libraries-y)
+-include $(top_builddir)/.depend
+
+clean:
+        rm -f *.o *.a $(AR_TARGET)
+
diff --git a/busybox/archival/libunarchive/Makefile.in b/busybox/archival/libunarchive/Makefile.in
new file mode 100644
index 000000000..809b0e10e
--- /dev/null
+++ b/busybox/archival/libunarchive/Makefile.in
@@ -0,0 +1,84 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+LIBUNARCHIVE_AR:=libunarchive.a
+ifndef $(LIBUNARCHIVE_DIR)
+LIBUNARCHIVE_DIR:=$(top_builddir)/archival/libunarchive/
+endif
+srcdir=$(top_srcdir)/archvial/libunarchive
+
+LIBUNARCHIVE-y:= \
+\
+        data_skip.o \
+        data_extract_all.o \
+        data_extract_to_stdout.o \
+        data_extract_to_buffer.o \
+\
+        filter_accept_all.o \
+        filter_accept_list.o \
+        filter_accept_reject_list.o \
+\
+        header_skip.o \
+        header_list.o \
+        header_verbose_list.o \
+\
+        archive_xread_all.o \
+        archive_xread_all_eof.o \
+\
+        seek_by_char.o \
+        seek_by_jump.o \
+\
+        data_align.o \
+        find_list_entry.o \
+        open_transformer.o \
+        init_handle.o
+
+GUNZIP_FILES:= check_header_gzip.o decompress_unzip.o
+DPKG_FILES:= \
+        get_header_ar.o \
+        unpack_ar_archive.o \
+        get_header_tar.o \
+        filter_accept_list_reassign.o
+
+LIBUNARCHIVE-$(CONFIG_AR) += get_header_ar.o unpack_ar_archive.o
+LIBUNARCHIVE-$(CONFIG_BUNZIP2) += decompress_bunzip2.o
+LIBUNARCHIVE-$(CONFIG_CPIO) += get_header_cpio.o
+LIBUNARCHIVE-$(CONFIG_DPKG) += $(DPKG_FILES)
+LIBUNARCHIVE-$(CONFIG_DPKG_DEB) += $(DPKG_FILES)
+LIBUNARCHIVE-$(CONFIG_FEATURE_DEB_TAR_GZ) += $(GUNZIP_FILES) get_header_tar_gz.o
+LIBUNARCHIVE-$(CONFIG_FEATURE_DEB_TAR_BZ2) += decompress_bunzip2.o get_header_tar_bz2.o
+LIBUNARCHIVE-$(CONFIG_GUNZIP) += $(GUNZIP_FILES)
+LIBUNARCHIVE-$(CONFIG_FEATURE_GUNZIP_UNCOMPRESS) += decompress_uncompress.o
+LIBUNARCHIVE-$(CONFIG_RPM2CPIO) += $(GUNZIP_FILES) get_header_cpio.o
+LIBUNARCHIVE-$(CONFIG_RPM) += $(GUNZIP_FILES) get_header_cpio.o
+LIBUNARCHIVE-$(CONFIG_TAR) += get_header_tar.o
+LIBUNARCHIVE-$(CONFIG_FEATURE_TAR_BZIP2) += decompress_bunzip2.o get_header_tar_bz2.o
+LIBUNARCHIVE-$(CONFIG_FEATURE_TAR_GZIP) += $(GUNZIP_FILES) get_header_tar_gz.o
+LIBUNARCHIVE-$(CONFIG_FEATURE_TAR_COMPRESS) += decompress_uncompress.o
+LIBUNARCHIVE-$(CONFIG_UNCOMPRESS) += decompress_uncompress.o
+LIBUNARCHIVE-$(CONFIG_UNZIP) += $(GUNZIP_FILES)
+
+libraries-y+=$(LIBUNARCHIVE_DIR)$(LIBUNARCHIVE_AR)
+
+$(LIBUNARCHIVE_DIR)$(LIBUNARCHIVE_AR): $(patsubst %,$(LIBUNARCHIVE_DIR)%, $(LIBUNARCHIVE-y))
+        $(AR) -ro $@ $(patsubst %,$(LIBUNARCHIVE_DIR)%, $(LIBUNARCHIVE-y))
+
+$(LIBUNARCHIVA_DIR)%.o: $(srcdir)/%.c
+        $(CC) $(CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<
+
diff --git a/busybox/archival/libunarchive/archive_xread_all.c b/busybox/archival/libunarchive/archive_xread_all.c
new file mode 100644
index 000000000..ba9ade2d5
--- /dev/null
+++ b/busybox/archival/libunarchive/archive_xread_all.c
@@ -0,0 +1,32 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "unarchive.h"
+#include "libbb.h"
+
+extern void archive_xread_all(const archive_handle_t *archive_handle, void *buf, const size_t count)
+{
+        ssize_t size;
+
+        size = bb_full_read(archive_handle->src_fd, buf, count);
+        if (size != count) {
+                bb_error_msg_and_die("Short read");
+        }
+        return;
+}
diff --git a/busybox/archival/libunarchive/archive_xread_all_eof.c b/busybox/archival/libunarchive/archive_xread_all_eof.c
new file mode 100644
index 000000000..8084e3524
--- /dev/null
+++ b/busybox/archival/libunarchive/archive_xread_all_eof.c
@@ -0,0 +1,32 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "unarchive.h"
+#include "libbb.h"
+
+extern ssize_t archive_xread_all_eof(archive_handle_t *archive_handle, unsigned char *buf, size_t count)
+{
+        ssize_t size;
+
+        size = bb_full_read(archive_handle->src_fd, buf, count);
+        if ((size != 0) && (size != count)) {
+                bb_perror_msg_and_die("Short read, read %d of %d", size, count);
+        }
+        return(size);
+}
diff --git a/busybox/archival/libunarchive/check_header_gzip.c b/busybox/archival/libunarchive/check_header_gzip.c
new file mode 100644
index 000000000..13832c240
--- /dev/null
+++ b/busybox/archival/libunarchive/check_header_gzip.c
@@ -0,0 +1,57 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include "libbb.h"
+
+extern void check_header_gzip(int src_fd)
+{
+        union {
+                unsigned char raw[8];
+                struct {
+                        unsigned char method;
+                        unsigned char flags;
+                        unsigned int mtime;
+                        unsigned char xtra_flags;
+                        unsigned char os_flags;
+                } formated;
+        } header;
+
+        bb_xread_all(src_fd, header.raw, 8);
+
+        /* Check the compression method */
+        if (header.formated.method != 8) {
+                bb_error_msg_and_die("Unknown compression method %d",
+                                                  header.formated.method);
+        }
+
+        if (header.formated.flags & 0x04) {
+                /* bit 2 set: extra field present */
+                unsigned char extra_short;
+
+                extra_short = bb_xread_char(src_fd) + (bb_xread_char(src_fd) << 8);
+                while (extra_short > 0) {
+                        /* Ignore extra field */
+                        bb_xread_char(src_fd);
+                        extra_short--;
+                }
+        }
+
+        /* Discard original name if any */
+        if (header.formated.flags & 0x08) {
+                /* bit 3 set: original file name present */
+                while(bb_xread_char(src_fd) != 0);
+        }
+
+        /* Discard file comment if any */
+        if (header.formated.flags & 0x10) {
+                /* bit 4 set: file comment present */
+                while(bb_xread_char(src_fd) != 0);
+        }
+
+        /* Read the header checksum */
+        if (header.formated.flags & 0x02) {
+                bb_xread_char(src_fd);
+                bb_xread_char(src_fd);
+        }
+
+        return;
+}
diff --git a/busybox/archival/libunarchive/data_align.c b/busybox/archival/libunarchive/data_align.c
new file mode 100644
index 000000000..1d433957d
--- /dev/null
+++ b/busybox/archival/libunarchive/data_align.c
@@ -0,0 +1,33 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <unistd.h>
+
+#include "libbb.h"
+#include "unarchive.h"
+
+extern void data_align(archive_handle_t *archive_handle, const unsigned short boundary)
+{
+        const unsigned short skip_amount = (boundary - (archive_handle->offset % boundary)) % boundary;
+
+        archive_handle->seek(archive_handle, skip_amount);
+        archive_handle->offset += skip_amount;
+
+        return;
+}
diff --git a/busybox/archival/libunarchive/data_extract_all.c b/busybox/archival/libunarchive/data_extract_all.c
new file mode 100644
index 000000000..d10d665f6
--- /dev/null
+++ b/busybox/archival/libunarchive/data_extract_all.c
@@ -0,0 +1,124 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <utime.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "libbb.h"
+#include "unarchive.h"
+
+extern void data_extract_all(archive_handle_t *archive_handle)
+{
+        file_header_t *file_header = archive_handle->file_header;
+        int dst_fd;
+        int res;
+
+        if (archive_handle->flags & ARCHIVE_CREATE_LEADING_DIRS) {
+                char *name = bb_xstrdup(file_header->name);
+                bb_make_directory (dirname(name), -1, FILEUTILS_RECUR);
+                free(name);
+        }
+
+        /* Check if the file already exists */
+        if (archive_handle->flags & ARCHIVE_EXTRACT_UNCONDITIONAL) {
+                /* Remove the existing entry if it exists */
+                if (((file_header->mode & S_IFMT) != S_IFDIR) && (unlink(file_header->name) == -1) && (errno != ENOENT)) {
+                        bb_perror_msg_and_die("Couldnt remove old file");
+                }
+        }
+        else if (archive_handle->flags & ARCHIVE_EXTRACT_NEWER) {
+                /* Remove the existing entry if its older than the extracted entry */
+                struct stat statbuf;
+                if (lstat(file_header->name, &statbuf) == -1) {
+                        if (errno != ENOENT) {
+                                bb_perror_msg_and_die("Couldnt stat old file");
+                        }
+                }
+                else if (statbuf.st_mtime <= file_header->mtime) {
+                        if (!(archive_handle->flags & ARCHIVE_EXTRACT_QUIET)) {
+                                bb_error_msg("%s not created: newer or same age file exists", file_header->name);
+                        }
+                        data_skip(archive_handle);
+                        return;
+                }
+                else if ((unlink(file_header->name) == -1) && (errno != EISDIR)) {
+                        bb_perror_msg_and_die("Couldnt remove old file %s", file_header->name);
+                }
+        }
+
+        /* Handle hard links separately
+         * We identified hard links as regular files of size 0 with a symlink */
+        if (S_ISREG(file_header->mode) && (file_header->link_name) && (file_header->size == 0)) {
+                /* hard link */
+                res = link(file_header->link_name, file_header->name);
+                if ((res == -1) && !(archive_handle->flags & ARCHIVE_EXTRACT_QUIET)) {
+                        bb_perror_msg("Couldnt create hard link");
+                }
+        } else {
+                /* Create the filesystem entry */
+                switch(file_header->mode & S_IFMT) {
+                        case S_IFREG: {
+                                /* Regular file */
+                                dst_fd = bb_xopen(file_header->name, O_WRONLY | O_CREAT | O_EXCL);
+                                bb_copyfd_size(archive_handle->src_fd, dst_fd, file_header->size);
+                                close(dst_fd);
+                                break;
+                                }
+                        case S_IFDIR:
+                                res = mkdir(file_header->name, file_header->mode);
+                                if ((errno != EISDIR) && (res == -1) && !(archive_handle->flags & ARCHIVE_EXTRACT_QUIET)) {
+                                        bb_perror_msg("extract_archive: %s", file_header->name);
+                                }
+                                break;
+                        case S_IFLNK:
+                                /* Symlink */
+                                res = symlink(file_header->link_name, file_header->name);
+                                if ((res == -1) && !(archive_handle->flags & ARCHIVE_EXTRACT_QUIET)) {
+                                        bb_perror_msg("Cannot create symlink from %s to '%s'", file_header->name, file_header->link_name);
+                                }
+                                break;
+                        case S_IFSOCK:
+                        case S_IFBLK:
+                        case S_IFCHR:
+                        case S_IFIFO:
+                                res = mknod(file_header->name, file_header->mode, file_header->device);
+                                if ((res == -1) && !(archive_handle->flags & ARCHIVE_EXTRACT_QUIET)) {
+                                        bb_perror_msg("Cannot create node %s", file_header->name);
+                                }
+                                break;
+                        default:
+                                bb_error_msg_and_die("Unrecognised file type");
+                }
+        }
+
+        lchown(file_header->name, file_header->uid, file_header->gid);
+        if ((file_header->mode & S_IFMT) != S_IFLNK) {
+                chmod(file_header->name, file_header->mode);
+        }
+
+        if (archive_handle->flags & ARCHIVE_PRESERVE_DATE) {
+                struct utimbuf t;
+                t.actime = t.modtime = file_header->mtime;
+                utime(file_header->name, &t);
+        }
+}
diff --git a/busybox/archival/libunarchive/data_extract_to_buffer.c b/busybox/archival/libunarchive/data_extract_to_buffer.c
new file mode 100644
index 000000000..db5521bcb
--- /dev/null
+++ b/busybox/archival/libunarchive/data_extract_to_buffer.c
@@ -0,0 +1,28 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "libbb.h"
+#include "unarchive.h"
+
+extern void data_extract_to_buffer(archive_handle_t *archive_handle)
+{
+        const unsigned int size = archive_handle->file_header->size;
+
+        archive_handle->buffer = xmalloc(size + 1);
+
+        archive_xread_all(archive_handle, archive_handle->buffer, size);
+        archive_handle->buffer[size] = '\0';
+}
diff --git a/busybox/archival/libunarchive/data_extract_to_stdout.c b/busybox/archival/libunarchive/data_extract_to_stdout.c
new file mode 100644
index 000000000..df2bca6ef
--- /dev/null
+++ b/busybox/archival/libunarchive/data_extract_to_stdout.c
@@ -0,0 +1,23 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "unarchive.h"
+#include <unistd.h>
+
+extern void data_extract_to_stdout(archive_handle_t *archive_handle)
+{
+        bb_copyfd_size(archive_handle->src_fd, STDOUT_FILENO, archive_handle->file_header->size);
+}
diff --git a/busybox/archival/libunarchive/data_skip.c b/busybox/archival/libunarchive/data_skip.c
new file mode 100644
index 000000000..b82c9065b
--- /dev/null
+++ b/busybox/archival/libunarchive/data_skip.c
@@ -0,0 +1,27 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include "unarchive.h"
+#include "libbb.h"
+
+extern void data_skip(archive_handle_t *archive_handle)
+{
+        archive_handle->seek(archive_handle, archive_handle->file_header->size);
+}
diff --git a/busybox/archival/libunarchive/decompress_bunzip2.c b/busybox/archival/libunarchive/decompress_bunzip2.c
new file mode 100644
index 000000000..259a47776
--- /dev/null
+++ b/busybox/archival/libunarchive/decompress_bunzip2.c
@@ -0,0 +1,611 @@
+/* vi: set sw=4 ts=4: */
+/*      Small bzip2 deflate implementation, by Rob Landley (rob@landley.net).
+
+        Based on bzip2 decompression code by Julian R Seward (jseward@acm.org),
+        which also acknowledges contributions by Mike Burrows, David Wheeler,
+        Peter Fenwick, Alistair Moffat, Radford Neal, Ian H. Witten,
+        Robert Sedgewick, and Jon L. Bentley.
+
+        This code is licensed under the LGPLv2:
+                LGPL (http://www.gnu.org/copyleft/lgpl.html
+*/
+
+/*
+        Size and speed optimizations by Manuel Novoa III  (mjn3@codepoet.org).
+
+        More efficient reading of Huffman codes, a streamlined read_bunzip()
+        function, and various other tweaks.  In (limited) tests, approximately
+        20% faster than bzcat on x86 and about 10% faster on arm.
+
+        Note that about 2/3 of the time is spent in read_unzip() reversing
+        the Burrows-Wheeler transformation.  Much of that time is delay
+        resulting from cache misses.
+
+        I would ask that anyone benefiting from this work, especially those
+        using it in commercial products, consider making a donation to my local
+        non-profit hospice organization in the name of the woman I loved, who
+        passed away Feb. 12, 2003.
+
+                In memory of Toni W. Hagan
+
+                Hospice of Acadiana, Inc.
+                2600 Johnston St., Suite 200
+                Lafayette, LA 70503-3240
+
+                Phone (337) 232-1234 or 1-800-738-2226
+                Fax   (337) 232-1297
+
+                http://www.hospiceacadiana.com/
+
+        Manuel
+ */
+
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+
+#include "libbb.h"
+
+/* Constants for Huffman coding */
+#define MAX_GROUPS                      6
+#define GROUP_SIZE              50              /* 64 would have been more efficient */
+#define MAX_HUFCODE_BITS        20              /* Longest Huffman code allowed */
+#define MAX_SYMBOLS             258             /* 256 literals + RUNA + RUNB */
+#define SYMBOL_RUNA                     0
+#define SYMBOL_RUNB                     1
+
+/* Status return values */
+#define RETVAL_OK                                               0
+#define RETVAL_LAST_BLOCK                               (-1)
+#define RETVAL_NOT_BZIP_DATA                    (-2)
+#define RETVAL_UNEXPECTED_INPUT_EOF             (-3)
+#define RETVAL_UNEXPECTED_OUTPUT_EOF    (-4)
+#define RETVAL_DATA_ERROR                               (-5)
+#define RETVAL_OUT_OF_MEMORY                    (-6)
+#define RETVAL_OBSOLETE_INPUT                   (-7)
+
+/* Other housekeeping constants */
+#define IOBUF_SIZE                      4096
+
+/* This is what we know about each Huffman coding group */
+struct group_data {
+        /* We have an extra slot at the end of limit[] for a sentinal value. */
+        int limit[MAX_HUFCODE_BITS+1],base[MAX_HUFCODE_BITS],permute[MAX_SYMBOLS];
+        int minLen, maxLen;
+};
+
+/* Structure holding all the housekeeping data, including IO buffers and
+   memory that persists between calls to bunzip */
+typedef struct {
+        /* State for interrupting output loop */
+        int writeCopies,writePos,writeRunCountdown,writeCount,writeCurrent;
+        /* I/O tracking data (file handles, buffers, positions, etc.) */
+        int in_fd,out_fd,inbufCount,inbufPos /*,outbufPos*/;
+        unsigned char *inbuf /*,*outbuf*/;
+        unsigned int inbufBitCount, inbufBits;
+        /* The CRC values stored in the block header and calculated from the data */
+        unsigned int crc32Table[256],headerCRC, totalCRC, writeCRC;
+        /* Intermediate buffer and its size (in bytes) */
+        unsigned int *dbuf, dbufSize;
+        /* These things are a bit too big to go on the stack */
+        unsigned char selectors[32768];                 /* nSelectors=15 bits */
+        struct group_data groups[MAX_GROUPS];   /* Huffman coding tables */
+        /* For I/O error handling */
+        jmp_buf jmpbuf;
+} bunzip_data;
+
+/* Return the next nnn bits of input.  All reads from the compressed input
+   are done through this function.  All reads are big endian */
+static unsigned int get_bits(bunzip_data *bd, char bits_wanted)
+{
+        unsigned int bits=0;
+
+        /* If we need to get more data from the byte buffer, do so.  (Loop getting
+           one byte at a time to enforce endianness and avoid unaligned access.) */
+        while (bd->inbufBitCount<bits_wanted) {
+                /* If we need to read more data from file into byte buffer, do so */
+                if(bd->inbufPos==bd->inbufCount) {
+                        if((bd->inbufCount = read(bd->in_fd, bd->inbuf, IOBUF_SIZE)) <= 0)
+                                longjmp(bd->jmpbuf,RETVAL_UNEXPECTED_INPUT_EOF);
+                        bd->inbufPos=0;
+                }
+                /* Avoid 32-bit overflow (dump bit buffer to top of output) */
+                if(bd->inbufBitCount>=24) {
+                        bits=bd->inbufBits&((1<<bd->inbufBitCount)-1);
+                        bits_wanted-=bd->inbufBitCount;
+                        bits<<=bits_wanted;
+                        bd->inbufBitCount=0;
+                }
+                /* Grab next 8 bits of input from buffer. */
+                bd->inbufBits=(bd->inbufBits<<8)|bd->inbuf[bd->inbufPos++];
+                bd->inbufBitCount+=8;
+        }
+        /* Calculate result */
+        bd->inbufBitCount-=bits_wanted;
+        bits|=(bd->inbufBits>>bd->inbufBitCount)&((1<<bits_wanted)-1);
+
+        return bits;
+}
+
+/* Unpacks the next block and sets up for the inverse burrows-wheeler step. */
+
+static int get_next_block(bunzip_data *bd)
+{
+        /* Note: Ignore the warning about hufGroup, base and limit being used uninitialized.
+         * They will be initialized on the fist pass of the loop. */
+        struct group_data *hufGroup;
+        int dbufCount,nextSym,dbufSize,groupCount,*base,*limit,selector,
+                i,j,k,t,runPos,symCount,symTotal,nSelectors,byteCount[256];
+        unsigned char uc, symToByte[256], mtfSymbol[256], *selectors;
+        unsigned int *dbuf,origPtr;
+
+        dbuf=bd->dbuf;
+        dbufSize=bd->dbufSize;
+        selectors=bd->selectors;
+        /* Reset longjmp I/O error handling */
+        i=setjmp(bd->jmpbuf);
+        if(i) return i;
+        /* Read in header signature and CRC, then validate signature.
+           (last block signature means CRC is for whole file, return now) */
+        i = get_bits(bd,24);
+        j = get_bits(bd,24);
+        bd->headerCRC=get_bits(bd,32);
+        if ((i == 0x177245) && (j == 0x385090)) return RETVAL_LAST_BLOCK;
+        if ((i != 0x314159) || (j != 0x265359)) return RETVAL_NOT_BZIP_DATA;
+        /* We can add support for blockRandomised if anybody complains.  There was
+           some code for this in busybox 1.0.0-pre3, but nobody ever noticed that
+           it didn't actually work. */
+        if(get_bits(bd,1)) return RETVAL_OBSOLETE_INPUT;
+        if((origPtr=get_bits(bd,24)) > dbufSize) return RETVAL_DATA_ERROR;
+        /* mapping table: if some byte values are never used (encoding things
+           like ascii text), the compression code removes the gaps to have fewer
+           symbols to deal with, and writes a sparse bitfield indicating which
+           values were present.  We make a translation table to convert the symbols
+           back to the corresponding bytes. */
+        t=get_bits(bd, 16);
+        symTotal=0;
+        for (i=0;i<16;i++) {
+                if(t&(1<<(15-i))) {
+                        k=get_bits(bd,16);
+                        for(j=0;j<16;j++)
+                                if(k&(1<<(15-j))) symToByte[symTotal++]=(16*i)+j;
+                }
+        }
+        /* How many different Huffman coding groups does this block use? */
+        groupCount=get_bits(bd,3);
+        if (groupCount<2 || groupCount>MAX_GROUPS) return RETVAL_DATA_ERROR;
+        /* nSelectors: Every GROUP_SIZE many symbols we select a new Huffman coding
+           group.  Read in the group selector list, which is stored as MTF encoded
+           bit runs.  (MTF=Move To Front, as each value is used it's moved to the
+           start of the list.) */
+        if(!(nSelectors=get_bits(bd, 15))) return RETVAL_DATA_ERROR;
+        for(i=0; i<groupCount; i++) mtfSymbol[i] = i;
+        for(i=0; i<nSelectors; i++) {
+                /* Get next value */
+                for(j=0;get_bits(bd,1);j++) if (j>=groupCount) return RETVAL_DATA_ERROR;
+                /* Decode MTF to get the next selector */
+                uc = mtfSymbol[j];
+                for(;j;j--) mtfSymbol[j] = mtfSymbol[j-1];
+                mtfSymbol[0]=selectors[i]=uc;
+        }
+        /* Read the Huffman coding tables for each group, which code for symTotal
+           literal symbols, plus two run symbols (RUNA, RUNB) */
+        symCount=symTotal+2;
+        for (j=0; j<groupCount; j++) {
+                unsigned char length[MAX_SYMBOLS],temp[MAX_HUFCODE_BITS+1];
+                int     minLen, maxLen, pp;
+                /* Read Huffman code lengths for each symbol.  They're stored in
+                   a way similar to mtf; record a starting value for the first symbol,
+                   and an offset from the previous value for everys symbol after that.
+                   (Subtracting 1 before the loop and then adding it back at the end is
+                   an optimization that makes the test inside the loop simpler: symbol
+                   length 0 becomes negative, so an unsigned inequality catches it.) */
+                t=get_bits(bd, 5)-1;
+                for (i = 0; i < symCount; i++) {
+                        for(;;) {
+                                if (((unsigned)t) > (MAX_HUFCODE_BITS-1))
+                                        return RETVAL_DATA_ERROR;
+                                /* If first bit is 0, stop.  Else second bit indicates whether
+                                   to increment or decrement the value.  Optimization: grab 2
+                                   bits and unget the second if the first was 0. */
+                                k = get_bits(bd,2);
+                                if (k < 2) {
+                                        bd->inbufBitCount++;
+                                        break;
+                                }
+                                /* Add one if second bit 1, else subtract 1.  Avoids if/else */
+                                t+=(((k+1)&2)-1);
+                        }
+                        /* Correct for the initial -1, to get the final symbol length */
+                        length[i]=t+1;
+                }
+                /* Find largest and smallest lengths in this group */
+                minLen=maxLen=length[0];
+                for(i = 1; i < symCount; i++) {
+                        if(length[i] > maxLen) maxLen = length[i];
+                        else if(length[i] < minLen) minLen = length[i];
+                }
+                /* Calculate permute[], base[], and limit[] tables from length[].
+                 *
+                 * permute[] is the lookup table for converting Huffman coded symbols
+                 * into decoded symbols.  base[] is the amount to subtract from the
+                 * value of a Huffman symbol of a given length when using permute[].
+                 *
+                 * limit[] indicates the largest numerical value a symbol with a given
+                 * number of bits can have.  This is how the Huffman codes can vary in
+                 * length: each code with a value>limit[length] needs another bit.
+                 */
+                hufGroup=bd->groups+j;
+                hufGroup->minLen = minLen;
+                hufGroup->maxLen = maxLen;
+                /* Note that minLen can't be smaller than 1, so we adjust the base
+                   and limit array pointers so we're not always wasting the first
+                   entry.  We do this again when using them (during symbol decoding).*/
+                base=hufGroup->base-1;
+                limit=hufGroup->limit-1;
+                /* Calculate permute[].  Concurently, initialize temp[] and limit[]. */
+                pp=0;
+                for(i=minLen;i<=maxLen;i++) {
+                        temp[i]=limit[i]=0;
+                        for(t=0;t<symCount;t++)
+                                if(length[t]==i) hufGroup->permute[pp++] = t;
+                }
+                /* Count symbols coded for at each bit length */
+                for (i=0;i<symCount;i++) temp[length[i]]++;
+                /* Calculate limit[] (the largest symbol-coding value at each bit
+                 * length, which is (previous limit<<1)+symbols at this level), and
+                 * base[] (number of symbols to ignore at each bit length, which is
+                 * limit minus the cumulative count of symbols coded for already). */
+                pp=t=0;
+                for (i=minLen; i<maxLen; i++) {
+                        pp+=temp[i];
+                        /* We read the largest possible symbol size and then unget bits
+                           after determining how many we need, and those extra bits could
+                           be set to anything.  (They're noise from future symbols.)  At
+                           each level we're really only interested in the first few bits,
+                           so here we set all the trailing to-be-ignored bits to 1 so they
+                           don't affect the value>limit[length] comparison. */
+                        limit[i]= (pp << (maxLen - i)) - 1;
+                        pp<<=1;
+                        base[i+1]=pp-(t+=temp[i]);
+                }
+                limit[maxLen+1] = INT_MAX; /* Sentinal value for reading next sym. */
+                limit[maxLen]=pp+temp[maxLen]-1;
+                base[minLen]=0;
+        }
+        /* We've finished reading and digesting the block header.  Now read this
+           block's Huffman coded symbols from the file and undo the Huffman coding
+           and run length encoding, saving the result into dbuf[dbufCount++]=uc */
+
+        /* Initialize symbol occurrence counters and symbol Move To Front table */
+        for(i=0;i<256;i++) {
+                byteCount[i] = 0;
+                mtfSymbol[i]=(unsigned char)i;
+        }
+        /* Loop through compressed symbols. */
+        runPos=dbufCount=symCount=selector=0;
+        for(;;) {
+                /* Determine which Huffman coding group to use. */
+                if(!(symCount--)) {
+                        symCount=GROUP_SIZE-1;
+                        if(selector>=nSelectors) return RETVAL_DATA_ERROR;
+                        hufGroup=bd->groups+selectors[selector++];
+                        base=hufGroup->base-1;
+                        limit=hufGroup->limit-1;
+                }
+                /* Read next Huffman-coded symbol. */
+                /* Note: It is far cheaper to read maxLen bits and back up than it is
+                   to read minLen bits and then an additional bit at a time, testing
+                   as we go.  Because there is a trailing last block (with file CRC),
+                   there is no danger of the overread causing an unexpected EOF for a
+                   valid compressed file.  As a further optimization, we do the read
+                   inline (falling back to a call to get_bits if the buffer runs
+                   dry).  The following (up to got_huff_bits:) is equivalent to
+                   j=get_bits(bd,hufGroup->maxLen);
+                 */
+                while (bd->inbufBitCount<hufGroup->maxLen) {
+                        if(bd->inbufPos==bd->inbufCount) {
+                                j = get_bits(bd,hufGroup->maxLen);
+                                goto got_huff_bits;
+                        }
+                        bd->inbufBits=(bd->inbufBits<<8)|bd->inbuf[bd->inbufPos++];
+                        bd->inbufBitCount+=8;
+                };
+                bd->inbufBitCount-=hufGroup->maxLen;
+                j = (bd->inbufBits>>bd->inbufBitCount)&((1<<hufGroup->maxLen)-1);
+got_huff_bits:
+                /* Figure how how many bits are in next symbol and unget extras */
+                i=hufGroup->minLen;
+                while(j>limit[i]) ++i;
+                bd->inbufBitCount += (hufGroup->maxLen - i);
+                /* Huffman decode value to get nextSym (with bounds checking) */
+                if ((i > hufGroup->maxLen)
+                        || (((unsigned)(j=(j>>(hufGroup->maxLen-i))-base[i]))
+                                >= MAX_SYMBOLS))
+                        return RETVAL_DATA_ERROR;
+                nextSym = hufGroup->permute[j];
+                /* We have now decoded the symbol, which indicates either a new literal
+                   byte, or a repeated run of the most recent literal byte.  First,
+                   check if nextSym indicates a repeated run, and if so loop collecting
+                   how many times to repeat the last literal. */
+                if (((unsigned)nextSym) <= SYMBOL_RUNB) { /* RUNA or RUNB */
+                        /* If this is the start of a new run, zero out counter */
+                        if(!runPos) {
+                                runPos = 1;
+                                t = 0;
+                        }
+                        /* Neat trick that saves 1 symbol: instead of or-ing 0 or 1 at
+                           each bit position, add 1 or 2 instead.  For example,
+                           1011 is 1<<0 + 1<<1 + 2<<2.  1010 is 2<<0 + 2<<1 + 1<<2.
+                           You can make any bit pattern that way using 1 less symbol than
+                           the basic or 0/1 method (except all bits 0, which would use no
+                           symbols, but a run of length 0 doesn't mean anything in this
+                           context).  Thus space is saved. */
+                        t += (runPos << nextSym); /* +runPos if RUNA; +2*runPos if RUNB */
+                        runPos <<= 1;
+                        continue;
+                }
+                /* When we hit the first non-run symbol after a run, we now know
+                   how many times to repeat the last literal, so append that many
+                   copies to our buffer of decoded symbols (dbuf) now.  (The last
+                   literal used is the one at the head of the mtfSymbol array.) */
+                if(runPos) {
+                        runPos=0;
+                        if(dbufCount+t>=dbufSize) return RETVAL_DATA_ERROR;
+
+                        uc = symToByte[mtfSymbol[0]];
+                        byteCount[uc] += t;
+                        while(t--) dbuf[dbufCount++]=uc;
+                }
+                /* Is this the terminating symbol? */
+                if(nextSym>symTotal) break;
+                /* At this point, nextSym indicates a new literal character.  Subtract
+                   one to get the position in the MTF array at which this literal is
+                   currently to be found.  (Note that the result can't be -1 or 0,
+                   because 0 and 1 are RUNA and RUNB.  But another instance of the
+                   first symbol in the mtf array, position 0, would have been handled
+                   as part of a run above.  Therefore 1 unused mtf position minus
+                   2 non-literal nextSym values equals -1.) */
+                if(dbufCount>=dbufSize) return RETVAL_DATA_ERROR;
+                i = nextSym - 1;
+                uc = mtfSymbol[i];
+                /* Adjust the MTF array.  Since we typically expect to move only a
+                 * small number of symbols, and are bound by 256 in any case, using
+                 * memmove here would typically be bigger and slower due to function
+                 * call overhead and other assorted setup costs. */
+                do {
+                        mtfSymbol[i] = mtfSymbol[i-1];
+                } while (--i);
+                mtfSymbol[0] = uc;
+                uc=symToByte[uc];
+                /* We have our literal byte.  Save it into dbuf. */
+                byteCount[uc]++;
+                dbuf[dbufCount++] = (unsigned int)uc;
+        }
+        /* At this point, we've read all the Huffman-coded symbols (and repeated
+       runs) for this block from the input stream, and decoded them into the
+           intermediate buffer.  There are dbufCount many decoded bytes in dbuf[].
+           Now undo the Burrows-Wheeler transform on dbuf.
+           See http://dogma.net/markn/articles/bwt/bwt.htm
+         */
+        /* Turn byteCount into cumulative occurrence counts of 0 to n-1. */
+        j=0;
+        for(i=0;i<256;i++) {
+                k=j+byteCount[i];
+                byteCount[i] = j;
+                j=k;
+        }
+        /* Figure out what order dbuf would be in if we sorted it. */
+        for (i=0;i<dbufCount;i++) {
+                uc=(unsigned char)(dbuf[i] & 0xff);
+                dbuf[byteCount[uc]] |= (i << 8);
+                byteCount[uc]++;
+        }
+        /* Decode first byte by hand to initialize "previous" byte.  Note that it
+           doesn't get output, and if the first three characters are identical
+           it doesn't qualify as a run (hence writeRunCountdown=5). */
+        if(dbufCount) {
+                if(origPtr>=dbufCount) return RETVAL_DATA_ERROR;
+                bd->writePos=dbuf[origPtr];
+            bd->writeCurrent=(unsigned char)(bd->writePos&0xff);
+                bd->writePos>>=8;
+                bd->writeRunCountdown=5;
+        }
+        bd->writeCount=dbufCount;
+
+        return RETVAL_OK;
+}
+
+/* Undo burrows-wheeler transform on intermediate buffer to produce output.
+   If start_bunzip was initialized with out_fd=-1, then up to len bytes of
+   data are written to outbuf.  Return value is number of bytes written or
+   error (all errors are negative numbers).  If out_fd!=-1, outbuf and len
+   are ignored, data is written to out_fd and return is RETVAL_OK or error.
+*/
+
+static int read_bunzip(bunzip_data *bd, char *outbuf, int len)
+{
+        const unsigned int *dbuf;
+        int pos,current,previous,gotcount;
+
+        /* If last read was short due to end of file, return last block now */
+        if(bd->writeCount<0) return bd->writeCount;
+
+        gotcount = 0;
+        dbuf=bd->dbuf;
+        pos=bd->writePos;
+        current=bd->writeCurrent;
+
+        /* We will always have pending decoded data to write into the output
+           buffer unless this is the very first call (in which case we haven't
+           Huffman-decoded a block into the intermediate buffer yet). */
+
+        if (bd->writeCopies) {
+                /* Inside the loop, writeCopies means extra copies (beyond 1) */
+                --bd->writeCopies;
+                /* Loop outputting bytes */
+                for(;;) {
+                        /* If the output buffer is full, snapshot state and return */
+                        if(gotcount >= len) {
+                                bd->writePos=pos;
+                                bd->writeCurrent=current;
+                                bd->writeCopies++;
+                                return len;
+                        }
+                        /* Write next byte into output buffer, updating CRC */
+                        outbuf[gotcount++] = current;
+                        bd->writeCRC=(((bd->writeCRC)<<8)
+                                                  ^bd->crc32Table[((bd->writeCRC)>>24)^current]);
+                        /* Loop now if we're outputting multiple copies of this byte */
+                        if (bd->writeCopies) {
+                                --bd->writeCopies;
+                                continue;
+                        }
+decode_next_byte:
+                        if (!bd->writeCount--) break;
+                        /* Follow sequence vector to undo Burrows-Wheeler transform */
+                        previous=current;
+                        pos=dbuf[pos];
+                        current=pos&0xff;
+                        pos>>=8;
+                        /* After 3 consecutive copies of the same byte, the 4th is a repeat
+                           count.  We count down from 4 instead
+                         * of counting up because testing for non-zero is faster */
+                        if(--bd->writeRunCountdown) {
+                                if(current!=previous) bd->writeRunCountdown=4;
+                        } else {
+                                /* We have a repeated run, this byte indicates the count */
+                                bd->writeCopies=current;
+                                current=previous;
+                                bd->writeRunCountdown=5;
+                                /* Sometimes there are just 3 bytes (run length 0) */
+                                if(!bd->writeCopies) goto decode_next_byte;
+                                /* Subtract the 1 copy we'd output anyway to get extras */
+                                --bd->writeCopies;
+                        }
+                }
+                /* Decompression of this block completed successfully */
+                bd->writeCRC=~bd->writeCRC;
+                bd->totalCRC=((bd->totalCRC<<1) | (bd->totalCRC>>31)) ^ bd->writeCRC;
+                /* If this block had a CRC error, force file level CRC error. */
+                if(bd->writeCRC!=bd->headerCRC) {
+                        bd->totalCRC=bd->headerCRC+1;
+                        return RETVAL_LAST_BLOCK;
+                }
+        }
+
+        /* Refill the intermediate buffer by Huffman-decoding next block of input */
+        /* (previous is just a convenient unused temp variable here) */
+        previous=get_next_block(bd);
+        if(previous) {
+                bd->writeCount=previous;
+                return (previous!=RETVAL_LAST_BLOCK) ? previous : gotcount;
+        }
+        bd->writeCRC=0xffffffffUL;
+        pos=bd->writePos;
+        current=bd->writeCurrent;
+        goto decode_next_byte;
+}
+
+/* Allocate the structure, read file header.  If in_fd==-1, inbuf must contain
+   a complete bunzip file (len bytes long).  If in_fd!=-1, inbuf and len are
+   ignored, and data is read from file handle into temporary buffer. */
+static int start_bunzip(bunzip_data **bdp, int in_fd, char *inbuf, int len)
+{
+        bunzip_data *bd;
+        unsigned int i,j,c;
+        const unsigned int BZh0=(((unsigned int)'B')<<24)+(((unsigned int)'Z')<<16)
+                                                        +(((unsigned int)'h')<<8)+(unsigned int)'0';
+
+        /* Figure out how much data to allocate */
+        i=sizeof(bunzip_data);
+        if(in_fd!=-1) i+=IOBUF_SIZE;
+        /* Allocate bunzip_data.  Most fields initialize to zero. */
+        bd=*bdp=xmalloc(i);
+        memset(bd,0,sizeof(bunzip_data));
+        /* Setup input buffer */
+        if(-1==(bd->in_fd=in_fd)) {
+                bd->inbuf=inbuf;
+                bd->inbufCount=len;
+        } else bd->inbuf=(unsigned char *)(bd+1);
+        /* Init the CRC32 table (big endian) */
+        for(i=0;i<256;i++) {
+                c=i<<24;
+                for(j=8;j;j--)
+                        c=c&0x80000000 ? (c<<1)^0x04c11db7 : (c<<1);
+                bd->crc32Table[i]=c;
+        }
+        /* Setup for I/O error handling via longjmp */
+        i=setjmp(bd->jmpbuf);
+        if(i) return i;
+
+        /* Ensure that file starts with "BZh['1'-'9']." */
+        i = get_bits(bd,32);
+        if (((unsigned int)(i-BZh0-1)) >= 9) return RETVAL_NOT_BZIP_DATA;
+
+        /* Fourth byte (ascii '1'-'9'), indicates block size in units of 100k of
+           uncompressed data.  Allocate intermediate buffer for block. */
+        bd->dbufSize=100000*(i-BZh0);
+
+        bd->dbuf=xmalloc(bd->dbufSize * sizeof(int));
+        return RETVAL_OK;
+}
+
+/* Example usage: decompress src_fd to dst_fd.  (Stops at end of bzip data,
+   not end of file.) */
+extern int uncompressStream(int src_fd, int dst_fd)
+{
+        char *outbuf;
+        bunzip_data *bd;
+        int i;
+
+        outbuf=xmalloc(IOBUF_SIZE);
+        if(!(i=start_bunzip(&bd,src_fd,0,0))) {
+                for(;;) {
+                        if((i=read_bunzip(bd,outbuf,IOBUF_SIZE)) <= 0) break;
+                        if(i!=write(dst_fd,outbuf,i)) {
+                                i=RETVAL_UNEXPECTED_OUTPUT_EOF;
+                                break;
+                        }
+                }
+        }
+        /* Check CRC and release memory */
+        if(i==RETVAL_LAST_BLOCK) {
+                if (bd->headerCRC!=bd->totalCRC) {
+                        bb_error_msg("Data integrity error when decompressing.");
+                } else {
+                        i=RETVAL_OK;
+                }
+        }
+        else if (i==RETVAL_UNEXPECTED_OUTPUT_EOF) {
+                bb_error_msg("Compressed file ends unexpectedly");
+        } else {
+                bb_error_msg("Decompression failed");
+        }
+        if(bd->dbuf) free(bd->dbuf);
+        free(bd);
+        free(outbuf);
+
+        return i;
+}
+
+#ifdef TESTING
+
+static char * const bunzip_errors[]={NULL,"Bad file checksum","Not bzip data",
+                "Unexpected input EOF","Unexpected output EOF","Data error",
+                 "Out of memory","Obsolete (pre 0.9.5) bzip format not supported."};
+
+/* Dumb little test thing, decompress stdin to stdout */
+int main(int argc, char *argv[])
+{
+        int i=uncompressStream(0,1);
+        char c;
+
+        if(i) fprintf(stderr,"%s\n", bunzip_errors[-i]);
+    else if(read(0,&c,1)) fprintf(stderr,"Trailing garbage ignored\n");
+        return -i;
+}
+#endif
diff --git a/busybox/archival/libunarchive/decompress_uncompress.c b/busybox/archival/libunarchive/decompress_uncompress.c
new file mode 100644
index 000000000..e39872cbe
--- /dev/null
+++ b/busybox/archival/libunarchive/decompress_uncompress.c
@@ -0,0 +1,293 @@
+#include "config.h"
+#include "libbb.h"
+
+/* uncompress for busybox -- (c) 2002 Robert Griebl
+ *
+ * based on the original compress42.c source
+ * (see disclaimer below)
+ */
+
+
+/* (N)compress42.c - File compression ala IEEE Computer, Mar 1992.
+ *
+ * Authors:
+ *   Spencer W. Thomas   (decvax!harpo!utah-cs!utah-gr!thomas)
+ *   Jim McKie           (decvax!mcvax!jim)
+ *   Steve Davies        (decvax!vax135!petsd!peora!srd)
+ *   Ken Turkowski       (decvax!decwrl!turtlevax!ken)
+ *   James A. Woods      (decvax!ihnp4!ames!jaw)
+ *   Joe Orost           (decvax!vax135!petsd!joe)
+ *   Dave Mack           (csu@alembic.acs.com)
+ *   Peter Jannesen, Network Communication Systems
+ *                       (peter@ncs.nl)
+ *
+ * marc@suse.de : a small security fix for a buffer overflow
+ *
+ * [... History snipped ...]
+ *
+ */
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Default input buffer size */
+#define IBUFSIZ 2048
+
+/* Default output buffer size */
+#define OBUFSIZ 2048
+
+/* Defines for third byte of header */
+#define MAGIC_1         (char_type)'\037'       /* First byte of compressed file               */
+#define MAGIC_2         (char_type)'\235'       /* Second byte of compressed file              */
+#define BIT_MASK        0x1f    /* Mask for 'number of compresssion bits'       */
+                                                        /* Masks 0x20 and 0x40 are free.                */
+                                                        /* I think 0x20 should mean that there is       */
+                                                        /* a fourth header byte (for expansion).        */
+#define BLOCK_MODE      0x80    /* Block compresssion if table is full and      */
+                        /* compression rate is dropping flush tables    */
+                        /* the next two codes should not be changed lightly, as they must not   */
+                        /* lie within the contiguous general code space.                        */
+#define FIRST   257             /* first free entry                             */
+#define CLEAR   256             /* table clear output code                      */
+
+#define INIT_BITS 9             /* initial number of bits/code */
+
+
+/* machine variants which require cc -Dmachine:  pdp11, z8000, DOS */
+#define FAST
+
+#define HBITS           17      /* 50% occupancy */
+#define HSIZE      (1<<HBITS)
+#define HMASK      (HSIZE-1)
+#define HPRIME           9941
+#define BITS               16
+#undef  MAXSEG_64K
+#define MAXCODE(n)      (1L << (n))
+
+/* Block compress mode -C compatible with 2.0 */
+int block_mode = BLOCK_MODE;
+
+/* user settable max # bits/code */
+int maxbits = BITS;
+
+/* Exitcode of compress (-1 no file compressed) */
+int exit_code = -1;
+
+/* Input buffer */
+unsigned char inbuf[IBUFSIZ + 64];
+
+/* Output buffer */
+unsigned char outbuf[OBUFSIZ + 2048];
+
+
+long int htab[HSIZE];
+unsigned short codetab[HSIZE];
+
+#define htabof(i)                               htab[i]
+#define codetabof(i)                    codetab[i]
+#define tab_prefixof(i)                 codetabof(i)
+#define tab_suffixof(i)                 ((unsigned char *)(htab))[i]
+#define de_stack                                ((unsigned char *)&(htab[HSIZE-1]))
+#define clear_htab()                    memset(htab, -1, sizeof(htab))
+#define clear_tab_prefixof()    memset(codetab, 0, 256);
+
+
+/*
+ * Decompress stdin to stdout.  This routine adapts to the codes in the
+ * file building the "string" table on-the-fly; requiring no table to
+ * be stored in the compressed file.  The tables used herein are shared
+ * with those of the compress() routine.  See the definitions above.
+ */
+
+extern int uncompress(int fd_in, int fd_out)
+{
+        unsigned char *stackp;
+        long int code;
+        int finchar;
+        long int oldcode;
+        long int incode;
+        int inbits;
+        int posbits;
+        int outpos;
+        int insize;
+        int bitmask;
+        long int free_ent;
+        long int maxcode;
+        long int maxmaxcode;
+        int n_bits;
+        int rsize = 0;
+
+        insize = 0;
+
+        inbuf[0] = bb_xread_char(fd_in);
+
+        maxbits = inbuf[0] & BIT_MASK;
+        block_mode = inbuf[0] & BLOCK_MODE;
+        maxmaxcode = MAXCODE(maxbits);
+
+        if (maxbits > BITS) {
+                bb_error_msg("compressed with %d bits, can only handle %d bits", maxbits,
+                                  BITS);
+                return -1;
+        }
+
+        maxcode = MAXCODE(n_bits = INIT_BITS) - 1;
+        bitmask = (1 << n_bits) - 1;
+        oldcode = -1;
+        finchar = 0;
+        outpos = 0;
+        posbits = 0 << 3;
+
+        free_ent = ((block_mode) ? FIRST : 256);
+
+        /* As above, initialize the first 256 entries in the table. */
+        clear_tab_prefixof();
+
+        for (code = 255; code >= 0; --code) {
+                tab_suffixof(code) = (unsigned char) code;
+        }
+
+        do {
+          resetbuf:;
+                {
+                        int i;
+                        int e;
+                        int o;
+
+                        e = insize - (o = (posbits >> 3));
+
+                        for (i = 0; i < e; ++i)
+                                inbuf[i] = inbuf[i + o];
+
+                        insize = e;
+                        posbits = 0;
+                }
+
+                if (insize < (int) sizeof(inbuf) - IBUFSIZ) {
+                        rsize = safe_read(fd_in, inbuf + insize, IBUFSIZ);
+                        insize += rsize;
+                }
+
+                inbits = ((rsize > 0) ? (insize - insize % n_bits) << 3 :
+                                  (insize << 3) - (n_bits - 1));
+
+                while (inbits > posbits) {
+                        if (free_ent > maxcode) {
+                                posbits =
+                                        ((posbits - 1) +
+                                         ((n_bits << 3) -
+                                          (posbits - 1 + (n_bits << 3)) % (n_bits << 3)));
+                                ++n_bits;
+                                if (n_bits == maxbits) {
+                                        maxcode = maxmaxcode;
+                                } else {
+                                        maxcode = MAXCODE(n_bits) - 1;
+                                }
+                                bitmask = (1 << n_bits) - 1;
+                                goto resetbuf;
+                        }
+                        {
+                                unsigned char *p = &inbuf[posbits >> 3];
+
+                                code =
+                                        ((((long) (p[0])) | ((long) (p[1]) << 8) |
+                                          ((long) (p[2]) << 16)) >> (posbits & 0x7)) & bitmask;
+                        }
+                        posbits += n_bits;
+
+
+                        if (oldcode == -1) {
+                                outbuf[outpos++] = (unsigned char) (finchar =
+                                                                                                (int) (oldcode = code));
+                                continue;
+                        }
+
+                        if (code == CLEAR && block_mode) {
+                                clear_tab_prefixof();
+                                free_ent = FIRST - 1;
+                                posbits =
+                                        ((posbits - 1) +
+                                         ((n_bits << 3) -
+                                          (posbits - 1 + (n_bits << 3)) % (n_bits << 3)));
+                                maxcode = MAXCODE(n_bits = INIT_BITS) - 1;
+                                bitmask = (1 << n_bits) - 1;
+                                goto resetbuf;
+                        }
+
+                        incode = code;
+                        stackp = de_stack;
+
+                        /* Special case for KwKwK string. */
+                        if (code >= free_ent) {
+                                if (code > free_ent) {
+                                        unsigned char *p;
+
+                                        posbits -= n_bits;
+                                        p = &inbuf[posbits >> 3];
+
+                                        bb_error_msg
+                                                ("insize:%d posbits:%d inbuf:%02X %02X %02X %02X %02X (%d)",
+                                                 insize, posbits, p[-1], p[0], p[1], p[2], p[3],
+                                                 (posbits & 07));
+                                        bb_error_msg("uncompress: corrupt input");
+                                        return -1;
+                                }
+
+                                *--stackp = (unsigned char) finchar;
+                                code = oldcode;
+                        }
+
+                        /* Generate output characters in reverse order */
+                        while ((long int) code >= (long int) 256) {
+                                *--stackp = tab_suffixof(code);
+                                code = tab_prefixof(code);
+                        }
+
+                        *--stackp = (unsigned char) (finchar = tab_suffixof(code));
+
+                        /* And put them out in forward order */
+                        {
+                                int i;
+
+                                if (outpos + (i = (de_stack - stackp)) >= OBUFSIZ) {
+                                        do {
+                                                if (i > OBUFSIZ - outpos) {
+                                                        i = OBUFSIZ - outpos;
+                                                }
+
+                                                if (i > 0) {
+                                                        memcpy(outbuf + outpos, stackp, i);
+                                                        outpos += i;
+                                                }
+
+                                                if (outpos >= OBUFSIZ) {
+                                                        write(fd_out, outbuf, outpos);
+                                                        outpos = 0;
+                                                }
+                                                stackp += i;
+                                        } while ((i = (de_stack - stackp)) > 0);
+                                } else {
+                                        memcpy(outbuf + outpos, stackp, i);
+                                        outpos += i;
+                                }
+                        }
+
+                        /* Generate the new entry. */
+                        if ((code = free_ent) < maxmaxcode) {
+                                tab_prefixof(code) = (unsigned short) oldcode;
+                                tab_suffixof(code) = (unsigned char) finchar;
+                                free_ent = code + 1;
+                        }
+
+                        /* Remember previous code.  */
+                        oldcode = incode;
+                }
+
+        } while (rsize > 0);
+
+        if (outpos > 0) {
+                write(fd_out, outbuf, outpos);
+        }
+
+        return 0;
+}
diff --git a/busybox/archival/libunarchive/decompress_unzip.c b/busybox/archival/libunarchive/decompress_unzip.c
new file mode 100644
index 000000000..e8cf54bff
--- /dev/null
+++ b/busybox/archival/libunarchive/decompress_unzip.c
@@ -0,0 +1,982 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * gunzip implementation for busybox
+ *
+ * Based on GNU gzip v1.2.4 Copyright (C) 1992-1993 Jean-loup Gailly.
+ *
+ * Originally adjusted for busybox by Sven Rudolph <sr1@inf.tu-dresden.de>
+ * based on gzip sources
+ *
+ * Adjusted further by Erik Andersen <andersen@codepoet.org> to support
+ * files as well as stdin/stdout, and to generally behave itself wrt
+ * command line handling.
+ *
+ * General cleanup to better adhere to the style guide and make use of standard
+ * busybox functions by Glenn McGrath <bug1@iinet.net.au>
+ *
+ * read_gz interface + associated hacking by Laurence Anderson
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *
+ * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
+ * Copyright (C) 1992-1993 Jean-loup Gailly
+ * The unzip code was written and put in the public domain by Mark Adler.
+ * Portions of the lzw code are derived from the public domain 'compress'
+ * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
+ * Ken Turkowski, Dave Mack and Peter Jannesen.
+ *
+ * See the license_msg below and the file COPYING for the software license.
+ * See the file algorithm.doc for the compression algorithms and file formats.
+ */
+
+#if 0
+static char *license_msg[] = {
+        "   Copyright (C) 1992-1993 Jean-loup Gailly",
+        "   This program is free software; you can redistribute it and/or modify",
+        "   it under the terms of the GNU General Public License as published by",
+        "   the Free Software Foundation; either version 2, or (at your option)",
+        "   any later version.",
+        "",
+        "   This program 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 General Public License for more details.",
+        "",
+        "   You should have received a copy of the GNU General Public License",
+        "   along with this program; if not, write to the Free Software",
+        "   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",
+        0
+};
+#endif
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "config.h"
+#include "busybox.h"
+#include "unarchive.h"
+
+typedef struct huft_s {
+        unsigned char e;        /* number of extra bits or operation */
+        unsigned char b;        /* number of bits in this code or subcode */
+        union {
+                unsigned short n;       /* literal, length base, or distance base */
+                struct huft_s *t;       /* pointer to next level of table */
+        } v;
+} huft_t;
+
+static int gunzip_src_fd;
+unsigned int gunzip_bytes_out;  /* number of output bytes */
+static unsigned int gunzip_outbuf_count;        /* bytes in output buffer */
+
+/* gunzip_window size--must be a power of two, and
+ *  at least 32K for zip's deflate method */
+static const int gunzip_wsize = 0x8000;
+static unsigned char *gunzip_window;
+
+static unsigned int *gunzip_crc_table;
+unsigned int gunzip_crc;
+
+/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
+#define BMAX 16 /* maximum bit length of any code (16 for explode) */
+#define N_MAX 288       /* maximum number of codes in any set */
+
+/* bitbuffer */
+static unsigned int gunzip_bb;  /* bit buffer */
+static unsigned char gunzip_bk; /* bits in bit buffer */
+
+/* These control the size of the bytebuffer */
+static unsigned int bytebuffer_max = 0x8000;
+static unsigned char *bytebuffer = NULL;
+static unsigned int bytebuffer_offset = 0;
+static unsigned int bytebuffer_size = 0;
+
+static const unsigned short mask_bits[] = {
+        0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+        0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+
+/* Copy lengths for literal codes 257..285 */
+static const unsigned short cplens[] = {
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
+                67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
+};
+
+/* note: see note #13 above about the 258 in this list. */
+/* Extra bits for literal codes 257..285 */
+static const unsigned char cplext[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5,
+                5, 5, 5, 0, 99, 99
+};                                              /* 99==invalid */
+
+/* Copy offsets for distance codes 0..29 */
+static const unsigned short cpdist[] = {
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
+                769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
+};
+
+/* Extra bits for distance codes */
+static const unsigned char cpdext[] = {
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
+                11, 11, 12, 12, 13, 13
+};
+
+/* Tables for deflate from PKZIP's appnote.txt. */
+/* Order of the bit length code lengths */
+static const unsigned char border[] = {
+        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+static unsigned int fill_bitbuffer(unsigned int bitbuffer, unsigned int *current, const unsigned int required)
+{
+        while (*current < required) {
+                if (bytebuffer_offset >= bytebuffer_size) {
+                        /* Leave the first 4 bytes empty so we can always unwind the bitbuffer
+                         * to the front of the bytebuffer, leave 4 bytes free at end of tail
+                         * so we can easily top up buffer in check_trailer_gzip() */
+                        bytebuffer_size = 4 + bb_xread(gunzip_src_fd, &bytebuffer[4], bytebuffer_max - 8);
+                        bytebuffer_offset = 4;
+                }
+                bitbuffer |= ((unsigned int) bytebuffer[bytebuffer_offset]) << *current;
+                bytebuffer_offset++;
+                *current += 8;
+        }
+        return(bitbuffer);
+}
+
+static void make_gunzip_crc_table(void)
+{
+        const unsigned int poly = 0xedb88320;   /* polynomial exclusive-or pattern */
+        unsigned short i;       /* counter for all possible eight bit values */
+
+        /* initial shift register value */
+        gunzip_crc = 0xffffffffL;
+        gunzip_crc_table = (unsigned int *) malloc(256 * sizeof(unsigned int));
+
+        /* Compute and print table of CRC's, five per line */
+        for (i = 0; i < 256; i++) {
+                unsigned int table_entry;       /* crc shift register */
+                unsigned char k;        /* byte being shifted into crc apparatus */
+
+                table_entry = i;
+                /* The idea to initialize the register with the byte instead of
+                   * zero was stolen from Haruhiko Okumura's ar002
+                 */
+                for (k = 8; k; k--) {
+                        if (table_entry & 1) {
+                                table_entry = (table_entry >> 1) ^ poly;
+                        } else {
+                                table_entry >>= 1;
+        }
+        }
+                gunzip_crc_table[i] = table_entry;
+        }
+}
+
+/*
+ * Free the malloc'ed tables built by huft_build(), which makes a linked
+ * list of the tables it made, with the links in a dummy first entry of
+ * each table.
+ * t: table to free
+ */
+static int huft_free(huft_t * t)
+{
+        huft_t *p;
+        huft_t *q;
+
+        /* Go through linked list, freeing from the malloced (t[-1]) address. */
+        p = t;
+        while (p != (huft_t *) NULL) {
+                q = (--p)->v.t;
+                free((char *) p);
+                p = q;
+        }
+        return 0;
+}
+
+/* Given a list of code lengths and a maximum table size, make a set of
+ * tables to decode that set of codes.  Return zero on success, one if
+ * the given code set is incomplete (the tables are still built in this
+ * case), two if the input is invalid (all zero length codes or an
+ * oversubscribed set of lengths), and three if not enough memory.
+ *
+ * b:   code lengths in bits (all assumed <= BMAX)
+ * n:   number of codes (assumed <= N_MAX)
+ * s:   number of simple-valued codes (0..s-1)
+ * d:   list of base values for non-simple codes
+ * e:   list of extra bits for non-simple codes
+ * t:   result: starting table
+ * m:   maximum lookup bits, returns actual
+ */
+static int huft_build(unsigned int *b, const unsigned int n,
+                                          const unsigned int s, const unsigned short *d,
+                                          const unsigned char *e, huft_t ** t, int *m)
+{
+        unsigned a;                     /* counter for codes of length k */
+        unsigned c[BMAX + 1];   /* bit length count table */
+        unsigned f;                     /* i repeats in table every f entries */
+        int g;                          /* maximum code length */
+        int h;                          /* table level */
+        register unsigned i;    /* counter, current code */
+        register unsigned j;    /* counter */
+        register int k;         /* number of bits in current code */
+        int l;                          /* bits per table (returned in m) */
+        register unsigned *p;   /* pointer into c[], b[], or v[] */
+        register huft_t *q;     /* points to current table */
+        huft_t r;                       /* table entry for structure assignment */
+        huft_t *u[BMAX];        /* table stack */
+        unsigned v[N_MAX];      /* values in order of bit length */
+        register int w;         /* bits before this table == (l * h) */
+        unsigned x[BMAX + 1];   /* bit offsets, then code stack */
+        unsigned *xp;           /* pointer into x */
+        int y;                          /* number of dummy codes added */
+        unsigned z;                     /* number of entries in current table */
+
+        /* Generate counts for each bit length */
+        memset((void *) (c), 0, sizeof(c));
+        p = b;
+        i = n;
+        do {
+                c[*p]++;                /* assume all entries <= BMAX */
+                p++;                    /* Can't combine with above line (Solaris bug) */
+        } while (--i);
+        if (c[0] == n) {        /* null input--all zero length codes */
+                *t = (huft_t *) NULL;
+                *m = 0;
+                return 0;
+        }
+
+        /* Find minimum and maximum length, bound *m by those */
+        l = *m;
+        for (j = 1; j <= BMAX; j++) {
+                if (c[j]) {
+                        break;
+                }
+        }
+        k = j;                          /* minimum code length */
+        if ((unsigned) l < j) {
+                l = j;
+        }
+        for (i = BMAX; i; i--) {
+                if (c[i]) {
+                        break;
+                }
+        }
+        g = i;                          /* maximum code length */
+        if ((unsigned) l > i) {
+                l = i;
+        }
+        *m = l;
+
+        /* Adjust last length count to fill out codes, if needed */
+        for (y = 1 << j; j < i; j++, y <<= 1) {
+                if ((y -= c[j]) < 0) {
+                        return 2;       /* bad input: more codes than bits */
+                }
+        }
+        if ((y -= c[i]) < 0) {
+                return 2;
+        }
+        c[i] += y;
+
+        /* Generate starting offsets into the value table for each length */
+        x[1] = j = 0;
+        p = c + 1;
+        xp = x + 2;
+        while (--i) {           /* note that i == g from above */
+                *xp++ = (j += *p++);
+        }
+
+        /* Make a table of values in order of bit lengths */
+        p = b;
+        i = 0;
+        do {
+                if ((j = *p++) != 0) {
+                        v[x[j]++] = i;
+                }
+        } while (++i < n);
+
+        /* Generate the Huffman codes and for each, make the table entries */
+        x[0] = i = 0;           /* first Huffman code is zero */
+        p = v;                          /* grab values in bit order */
+        h = -1;                         /* no tables yet--level -1 */
+        w = -l;                         /* bits decoded == (l * h) */
+        u[0] = (huft_t *) NULL; /* just to keep compilers happy */
+        q = (huft_t *) NULL;    /* ditto */
+        z = 0;                          /* ditto */
+
+        /* go through the bit lengths (k already is bits in shortest code) */
+        for (; k <= g; k++) {
+                a = c[k];
+                while (a--) {
+                        /* here i is the Huffman code of length k bits for value *p */
+                        /* make tables up to required level */
+                        while (k > w + l) {
+                                h++;
+                                w += l; /* previous table always l bits */
+
+                                /* compute minimum size table less than or equal to l bits */
+                                z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
+                                if ((f = 1 << (j = k - w)) > a + 1) {   /* try a k-w bit table *//* too few codes for k-w bit table */
+                                        f -= a + 1;     /* deduct codes from patterns left */
+                                        xp = c + k;
+                                        while (++j < z) {       /* try smaller tables up to z bits */
+                                                if ((f <<= 1) <= *++xp) {
+                                                        break;  /* enough codes to use up j bits */
+                                                }
+                                                f -= *xp;       /* else deduct codes from patterns */
+                                        }
+                                }
+                                z = 1 << j;     /* table entries for j-bit table */
+
+                                /* allocate and link in new table */
+                                q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t));
+
+                                *t = q + 1;     /* link to list for huft_free() */
+                                *(t = &(q->v.t)) = NULL;
+                                u[h] = ++q;     /* table starts after link */
+
+                                /* connect to last table, if there is one */
+                                if (h) {
+                                        x[h] = i;       /* save pattern for backing up */
+                                        r.b = (unsigned char) l;        /* bits to dump before this table */
+                                        r.e = (unsigned char) (16 + j); /* bits in this table */
+                                        r.v.t = q;      /* pointer to this table */
+                                        j = i >> (w - l);       /* (get around Turbo C bug) */
+                                        u[h - 1][j] = r;        /* connect to last table */
+                                }
+                        }
+
+                        /* set up table entry in r */
+                        r.b = (unsigned char) (k - w);
+                        if (p >= v + n) {
+                                r.e = 99;       /* out of values--invalid code */
+                        } else if (*p < s) {
+                                r.e = (unsigned char) (*p < 256 ? 16 : 15);     /* 256 is end-of-block code */
+                                r.v.n = (unsigned short) (*p);  /* simple code is just the value */
+                                p++;    /* one compiler does not like *p++ */
+                        } else {
+                                r.e = (unsigned char) e[*p - s];        /* non-simple--look up in lists */
+                                r.v.n = d[*p++ - s];
+                        }
+
+                        /* fill code-like entries with r */
+                        f = 1 << (k - w);
+                        for (j = i >> w; j < z; j += f) {
+                                q[j] = r;
+                        }
+
+                        /* backwards increment the k-bit code i */
+                        for (j = 1 << (k - 1); i & j; j >>= 1) {
+                                i ^= j;
+                        }
+                        i ^= j;
+
+                        /* backup over finished tables */
+                        while ((i & ((1 << w) - 1)) != x[h]) {
+                                h--;    /* don't need to update q */
+                                w -= l;
+                        }
+                }
+        }
+        /* Return true (1) if we were given an incomplete table */
+        return y != 0 && g != 1;
+}
+
+/*
+ * inflate (decompress) the codes in a deflated (compressed) block.
+ * Return an error code or zero if it all goes ok.
+ *
+ * tl, td: literal/length and distance decoder tables
+ * bl, bd: number of bits decoded by tl[] and td[]
+ */
+static int inflate_codes(huft_t * my_tl, huft_t * my_td, const unsigned int my_bl, const unsigned int my_bd, int setup)
+{
+        static unsigned int e;  /* table entry flag/number of extra bits */
+        static unsigned int n, d;       /* length and index for copy */
+        static unsigned int w;  /* current gunzip_window position */
+        static huft_t *t;                       /* pointer to table entry */
+        static unsigned int ml, md;     /* masks for bl and bd bits */
+        static unsigned int b;  /* bit buffer */
+        static unsigned int k;                  /* number of bits in bit buffer */
+        static huft_t *tl, *td;
+        static unsigned int bl, bd;
+        static int resumeCopy = 0;
+
+        if (setup) { // 1st time we are called, copy in variables
+                tl = my_tl;
+                td = my_td;
+                bl = my_bl;
+                bd = my_bd;
+                /* make local copies of globals */
+                b = gunzip_bb;                          /* initialize bit buffer */
+                k = gunzip_bk;
+                w = gunzip_outbuf_count;                        /* initialize gunzip_window position */
+
+                /* inflate the coded data */
+                ml = mask_bits[bl];     /* precompute masks for speed */
+                md = mask_bits[bd];
+                return 0; // Don't actually do anything the first time
+        }
+
+        if (resumeCopy) goto do_copy;
+
+        while (1) {                     /* do until end of block */
+                b = fill_bitbuffer(b, &k, bl);
+                if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
+                        do {
+                                if (e == 99) {
+                                        bb_error_msg_and_die("inflate_codes error 1");;
+                                }
+                                b >>= t->b;
+                                k -= t->b;
+                                e -= 16;
+                                b = fill_bitbuffer(b, &k, e);
+                        } while ((e =
+                                          (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
+                b >>= t->b;
+                k -= t->b;
+                if (e == 16) {  /* then it's a literal */
+                        gunzip_window[w++] = (unsigned char) t->v.n;
+                        if (w == gunzip_wsize) {
+                                gunzip_outbuf_count = (w);
+                                //flush_gunzip_window();
+                                w = 0;
+                                return 1; // We have a block to read
+                        }
+                } else {                /* it's an EOB or a length */
+
+                        /* exit if end of block */
+                        if (e == 15) {
+                                break;
+                        }
+
+                        /* get length of block to copy */
+                        b = fill_bitbuffer(b, &k, e);
+                        n = t->v.n + ((unsigned) b & mask_bits[e]);
+                        b >>= e;
+                        k -= e;
+
+                        /* decode distance of block to copy */
+                        b = fill_bitbuffer(b, &k, bd);
+                        if ((e = (t = td + ((unsigned) b & md))->e) > 16)
+                                do {
+                                        if (e == 99)
+                                                bb_error_msg_and_die("inflate_codes error 2");;
+                                        b >>= t->b;
+                                        k -= t->b;
+                                        e -= 16;
+                                        b = fill_bitbuffer(b, &k, e);
+                                } while ((e =
+                                                  (t =
+                                                   t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
+                        b >>= t->b;
+                        k -= t->b;
+                        b = fill_bitbuffer(b, &k, e);
+                        d = w - t->v.n - ((unsigned) b & mask_bits[e]);
+                        b >>= e;
+                        k -= e;
+
+                        /* do the copy */
+do_copy:                do {
+                                n -= (e =
+                                          (e =
+                                           gunzip_wsize - ((d &= gunzip_wsize - 1) > w ? d : w)) > n ? n : e);
+                           /* copy to new buffer to prevent possible overwrite */
+                                if (w - d >= e) {       /* (this test assumes unsigned comparison) */
+                                        memcpy(gunzip_window + w, gunzip_window + d, e);
+                                        w += e;
+                                        d += e;
+                                } else {
+                                   /* do it slow to avoid memcpy() overlap */
+                                   /* !NOMEMCPY */
+                                        do {
+                                                gunzip_window[w++] = gunzip_window[d++];
+                                        } while (--e);
+                                }
+                                if (w == gunzip_wsize) {
+                                        gunzip_outbuf_count = (w);
+                                        if (n) resumeCopy = 1;
+                                        else resumeCopy = 0;
+                                        //flush_gunzip_window();
+                                        w = 0;
+                                        return 1;
+                                }
+                        } while (n);
+                        resumeCopy = 0;
+                }
+        }
+
+        /* restore the globals from the locals */
+        gunzip_outbuf_count = w;                        /* restore global gunzip_window pointer */
+        gunzip_bb = b;                          /* restore global bit buffer */
+        gunzip_bk = k;
+
+        /* normally just after call to inflate_codes, but save code by putting it here */
+        /* free the decoding tables, return */
+        huft_free(tl);
+        huft_free(td);
+
+        /* done */
+        return 0;
+}
+
+static int inflate_stored(int my_n, int my_b_stored, int my_k_stored, int setup)
+{
+        static int n, b_stored, k_stored, w;
+        if (setup) {
+                n = my_n;
+                b_stored = my_b_stored;
+                k_stored = my_k_stored;
+                w = gunzip_outbuf_count;                /* initialize gunzip_window position */
+                return 0; // Don't do anything first time
+        }
+
+        /* read and output the compressed data */
+        while (n--) {
+                b_stored = fill_bitbuffer(b_stored, &k_stored, 8);
+                gunzip_window[w++] = (unsigned char) b_stored;
+                if (w == (unsigned int) gunzip_wsize) {
+                        gunzip_outbuf_count = (w);
+                        //flush_gunzip_window();
+                        w = 0;
+                        b_stored >>= 8;
+                        k_stored -= 8;
+                        return 1; // We have a block
+                }
+                b_stored >>= 8;
+                k_stored -= 8;
+        }
+
+        /* restore the globals from the locals */
+        gunzip_outbuf_count = w;                /* restore global gunzip_window pointer */
+        gunzip_bb = b_stored;   /* restore global bit buffer */
+        gunzip_bk = k_stored;
+        return 0; // Finished
+}
+
+/*
+ * decompress an inflated block
+ * e: last block flag
+ *
+ * GLOBAL VARIABLES: bb, kk,
+ */
+ // Return values: -1 = inflate_stored, -2 = inflate_codes
+static int inflate_block(int *e)
+{
+        unsigned t;                     /* block type */
+        register unsigned int b;        /* bit buffer */
+        unsigned int k; /* number of bits in bit buffer */
+
+        /* make local bit buffer */
+
+        b = gunzip_bb;
+        k = gunzip_bk;
+
+        /* read in last block bit */
+        b = fill_bitbuffer(b, &k, 1);
+        *e = (int) b & 1;
+        b >>= 1;
+        k -= 1;
+
+        /* read in block type */
+        b = fill_bitbuffer(b, &k, 2);
+        t = (unsigned) b & 3;
+        b >>= 2;
+        k -= 2;
+
+        /* restore the global bit buffer */
+        gunzip_bb = b;
+        gunzip_bk = k;
+
+        /* inflate that block type */
+        switch (t) {
+        case 0:                 /* Inflate stored */
+        {
+                unsigned int n; /* number of bytes in block */
+                unsigned int b_stored;  /* bit buffer */
+                unsigned int k_stored;  /* number of bits in bit buffer */
+
+                /* make local copies of globals */
+                b_stored = gunzip_bb;   /* initialize bit buffer */
+                k_stored = gunzip_bk;
+
+                /* go to byte boundary */
+                n = k_stored & 7;
+                b_stored >>= n;
+                k_stored -= n;
+
+                /* get the length and its complement */
+                b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
+                n = ((unsigned) b_stored & 0xffff);
+                b_stored >>= 16;
+                k_stored -= 16;
+
+                b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
+                if (n != (unsigned) ((~b_stored) & 0xffff)) {
+                        return 1;       /* error in compressed data */
+                }
+                b_stored >>= 16;
+                k_stored -= 16;
+
+                inflate_stored(n, b_stored, k_stored, 1); // Setup inflate_stored
+                return -1;
+        }
+        case 1:                 /* Inflate fixed
+                                                   * decompress an inflated type 1 (fixed Huffman codes) block.  We should
+                                                   * either replace this with a custom decoder, or at least precompute the
+                                                   * Huffman tables.
+                                                 */
+        {
+                int i;                  /* temporary variable */
+                huft_t *tl;             /* literal/length code table */
+                huft_t *td;             /* distance code table */
+                unsigned int bl;                        /* lookup bits for tl */
+                unsigned int bd;                        /* lookup bits for td */
+                unsigned int l[288];    /* length list for huft_build */
+
+                /* set up literal table */
+                for (i = 0; i < 144; i++) {
+                        l[i] = 8;
+                }
+                for (; i < 256; i++) {
+                        l[i] = 9;
+                }
+                for (; i < 280; i++) {
+                        l[i] = 7;
+                }
+                for (; i < 288; i++) {  /* make a complete, but wrong code set */
+                        l[i] = 8;
+                }
+                bl = 7;
+                if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
+                        return i;
+                }
+
+                /* set up distance table */
+                for (i = 0; i < 30; i++) {      /* make an incomplete code set */
+                        l[i] = 5;
+                }
+                bd = 5;
+                if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
+                        huft_free(tl);
+                        return i;
+                }
+
+                /* decompress until an end-of-block code */
+                inflate_codes(tl, td, bl, bd, 1); // Setup inflate_codes
+
+                /* huft_free code moved into inflate_codes */
+
+                return -2;
+        }
+        case 2:                 /* Inflate dynamic */
+        {
+                const int dbits = 6;    /* bits in base distance lookup table */
+                const int lbits = 9;    /* bits in base literal/length lookup table */
+
+                huft_t *tl;             /* literal/length code table */
+                huft_t *td;             /* distance code table */
+                unsigned int i;                 /* temporary variables */
+                unsigned int j;
+                unsigned int l;         /* last length */
+                unsigned int m;         /* mask for bit lengths table */
+                unsigned int n;         /* number of lengths to get */
+                unsigned int bl;                        /* lookup bits for tl */
+                unsigned int bd;                        /* lookup bits for td */
+                unsigned int nb;        /* number of bit length codes */
+                unsigned int nl;        /* number of literal/length codes */
+                unsigned int nd;        /* number of distance codes */
+
+                unsigned int ll[286 + 30];      /* literal/length and distance code lengths */
+                unsigned int b_dynamic; /* bit buffer */
+                unsigned int k_dynamic; /* number of bits in bit buffer */
+
+                /* make local bit buffer */
+                b_dynamic = gunzip_bb;
+                k_dynamic = gunzip_bk;
+
+                /* read in table lengths */
+                b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
+                nl = 257 + ((unsigned int) b_dynamic & 0x1f);   /* number of literal/length codes */
+
+                b_dynamic >>= 5;
+                k_dynamic -= 5;
+                b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
+                nd = 1 + ((unsigned int) b_dynamic & 0x1f);     /* number of distance codes */
+
+                b_dynamic >>= 5;
+                k_dynamic -= 5;
+                b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 4);
+                nb = 4 + ((unsigned int) b_dynamic & 0xf);      /* number of bit length codes */
+
+                b_dynamic >>= 4;
+                k_dynamic -= 4;
+                if (nl > 286 || nd > 30) {
+                        return 1;       /* bad lengths */
+                }
+
+                /* read in bit-length-code lengths */
+                for (j = 0; j < nb; j++) {
+                        b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
+                        ll[border[j]] = (unsigned int) b_dynamic & 7;
+                        b_dynamic >>= 3;
+                        k_dynamic -= 3;
+                }
+                for (; j < 19; j++) {
+                        ll[border[j]] = 0;
+                }
+
+                /* build decoding table for trees--single level, 7 bit lookup */
+                bl = 7;
+                i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl);
+                if (i != 0) {
+                        if (i == 1) {
+                                huft_free(tl);
+                        }
+                        return i;       /* incomplete code set */
+                }
+
+                /* read in literal and distance code lengths */
+                n = nl + nd;
+                m = mask_bits[bl];
+                i = l = 0;
+                while ((unsigned int) i < n) {
+                        b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, (unsigned int)bl);
+                        j = (td = tl + ((unsigned int) b_dynamic & m))->b;
+                        b_dynamic >>= j;
+                        k_dynamic -= j;
+                        j = td->v.n;
+                        if (j < 16) {   /* length of code in bits (0..15) */
+                                ll[i++] = l = j;        /* save last length in l */
+                        } else if (j == 16) {   /* repeat last length 3 to 6 times */
+                                b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 2);
+                                j = 3 + ((unsigned int) b_dynamic & 3);
+                                b_dynamic >>= 2;
+                                k_dynamic -= 2;
+                                if ((unsigned int) i + j > n) {
+                                        return 1;
+                                }
+                                while (j--) {
+                                        ll[i++] = l;
+                                }
+                        } else if (j == 17) {   /* 3 to 10 zero length codes */
+                                b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
+                                j = 3 + ((unsigned int) b_dynamic & 7);
+                                b_dynamic >>= 3;
+                                k_dynamic -= 3;
+                                if ((unsigned int) i + j > n) {
+                                        return 1;
+                                }
+                                while (j--) {
+                                        ll[i++] = 0;
+                                }
+                                l = 0;
+                        } else {        /* j == 18: 11 to 138 zero length codes */
+                                b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 7);
+                                j = 11 + ((unsigned int) b_dynamic & 0x7f);
+                                b_dynamic >>= 7;
+                                k_dynamic -= 7;
+                                if ((unsigned int) i + j > n) {
+                                        return 1;
+                                }
+                                while (j--) {
+                                        ll[i++] = 0;
+                                }
+                                l = 0;
+                        }
+                }
+
+                /* free decoding table for trees */
+                huft_free(tl);
+
+                /* restore the global bit buffer */
+                gunzip_bb = b_dynamic;
+                gunzip_bk = k_dynamic;
+
+                /* build the decoding tables for literal/length and distance codes */
+                bl = lbits;
+
+                if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
+                        if (i == 1) {
+                                bb_error_msg_and_die("Incomplete literal tree");
+                                huft_free(tl);
+                        }
+                        return i;       /* incomplete code set */
+                }
+
+                bd = dbits;
+                if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
+                        if (i == 1) {
+                                bb_error_msg_and_die("incomplete distance tree");
+                                huft_free(td);
+                        }
+                        huft_free(tl);
+                        return i;       /* incomplete code set */
+                }
+
+                /* decompress until an end-of-block code */
+                inflate_codes(tl, td, bl, bd, 1); // Setup inflate_codes
+
+                /* huft_free code moved into inflate_codes */
+
+                return -2;
+        }
+        default:
+                /* bad block type */
+                bb_error_msg_and_die("bad block type %d\n", t);
+        }
+}
+
+static void calculate_gunzip_crc(void)
+{
+        int n;
+        for (n = 0; n < gunzip_outbuf_count; n++) {
+                gunzip_crc = gunzip_crc_table[((int) gunzip_crc ^ (gunzip_window[n])) & 0xff] ^ (gunzip_crc >> 8);
+        }
+        gunzip_bytes_out += gunzip_outbuf_count;
+}
+
+static int inflate_get_next_window(void)
+{
+        static int method = -1; // Method == -1 for stored, -2 for codes
+        static int e = 0;
+        static int needAnotherBlock = 1;
+
+        gunzip_outbuf_count = 0;
+
+        while(1) {
+                int ret;
+
+                if (needAnotherBlock) {
+                        if(e) {
+                                calculate_gunzip_crc();
+                                e = 0;
+                                needAnotherBlock = 1;
+                                return 0;
+                        } // Last block
+                        method = inflate_block(&e);
+                        needAnotherBlock = 0;
+                }
+
+                switch (method) {
+                        case -1:        ret = inflate_stored(0,0,0,0);
+                                        break;
+                        case -2:        ret = inflate_codes(0,0,0,0,0);
+                                        break;
+                        default:        bb_error_msg_and_die("inflate error %d", method);
+                }
+
+                if (ret == 1) {
+                        calculate_gunzip_crc();
+                        return 1; // More data left
+                } else needAnotherBlock = 1; // End of that block
+        }
+        /* Doesnt get here */
+}
+
+/* Initialise bytebuffer, be careful not to overfill the buffer */
+extern void inflate_init(unsigned int bufsize)
+{
+        /* Set the bytebuffer size, default is same as gunzip_wsize */
+        bytebuffer_max = bufsize + 8;
+        bytebuffer_offset = 4;
+        bytebuffer_size = 0;
+}
+
+extern int inflate_unzip(int in, int out)
+{
+        ssize_t nwrote;
+        typedef void (*sig_type) (int);
+
+        /* Allocate all global buffers (for DYN_ALLOC option) */
+        gunzip_window = xmalloc(gunzip_wsize);
+        gunzip_outbuf_count = 0;
+        gunzip_bytes_out = 0;
+        gunzip_src_fd = in;
+
+        /* initialize gunzip_window, bit buffer */
+        gunzip_bk = 0;
+        gunzip_bb = 0;
+
+        /* Create the crc table */
+        make_gunzip_crc_table();
+
+        /* Allocate space for buffer */
+        bytebuffer = xmalloc(bytebuffer_max);
+
+        while(1) {
+                int ret = inflate_get_next_window();
+                nwrote = bb_full_write(out, gunzip_window, gunzip_outbuf_count);
+                if (nwrote == -1) {
+                        bb_perror_msg("write");
+                        return -1;
+                }
+                if (ret == 0) break;
+        }
+
+        /* Cleanup */
+        free(gunzip_window);
+        free(gunzip_crc_table);
+
+        /* Store unused bytes in a global buffer so calling applets can access it */
+        if (gunzip_bk >= 8) {
+                /* Undo too much lookahead. The next read will be byte aligned
+                 * so we can discard unused bits in the last meaningful byte. */
+                bytebuffer_offset--;
+                bytebuffer[bytebuffer_offset] = gunzip_bb & 0xff;
+                gunzip_bb >>= 8;
+                gunzip_bk -= 8;
+        }
+        return 0;
+}
+
+extern int inflate_gunzip(int in, int out)
+{
+        unsigned int stored_crc = 0;
+        unsigned char count;
+
+        inflate_unzip(in, out);
+
+        /* top up the input buffer with the rest of the trailer */
+        count = bytebuffer_size - bytebuffer_offset;
+        if (count < 8) {
+                bb_xread_all(in, &bytebuffer[bytebuffer_size], 8 - count);
+                bytebuffer_size += 8 - count;
+        }
+        for (count = 0; count != 4; count++) {
+                stored_crc |= (bytebuffer[bytebuffer_offset] << (count * 8));
+                bytebuffer_offset++;
+        }
+
+        /* Validate decompression - crc */
+        if (stored_crc != (gunzip_crc ^ 0xffffffffL)) {
+                bb_error_msg("crc error");
+        }
+
+        /* Validate decompression - size */
+        if (gunzip_bytes_out !=
+                (bytebuffer[bytebuffer_offset] | (bytebuffer[bytebuffer_offset+1] << 8) |
+                (bytebuffer[bytebuffer_offset+2] << 16) | (bytebuffer[bytebuffer_offset+3] << 24))) {
+                bb_error_msg("Incorrect length");
+        }
+
+        return 0;
+}
diff --git a/busybox/archival/libunarchive/filter_accept_all.c b/busybox/archival/libunarchive/filter_accept_all.c
new file mode 100644
index 000000000..baf9e4b71
--- /dev/null
+++ b/busybox/archival/libunarchive/filter_accept_all.c
@@ -0,0 +1,32 @@
+/*
+ *  Copyright (C) 2002 by Glenn McGrath
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <fnmatch.h>
+#include <stdlib.h>
+
+#include "unarchive.h"
+
+/* Accept any non-null name, its not really a filter at all */
+extern char filter_accept_all(archive_handle_t *archive_handle)
+{
+        if (archive_handle->file_header->name) {
+                return(EXIT_SUCCESS);
+        } else {
+                return(EXIT_FAILURE);
+        }
+}
diff --git a/busybox/archival/libunarchive/filter_accept_list.c b/busybox/archival/libunarchive/filter_accept_list.c
new file mode 100644
index 000000000..e1c4827bf
--- /dev/null
+++ b/busybox/archival/libunarchive/filter_accept_list.c
@@ -0,0 +1,34 @@
+/*
+ *  Copyright (C) 2002 by Glenn McGrath
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <fnmatch.h>
+#include <stdlib.h>
+
+#include "unarchive.h"
+
+/*
+ * Accept names that are in the accept list, ignoring reject list.
+ */
+extern char filter_accept_list(archive_handle_t *archive_handle)
+{
+        if (find_list_entry(archive_handle->accept, archive_handle->file_header->name)) {
+                return(EXIT_SUCCESS);
+        } else {
+                return(EXIT_FAILURE);
+        }
+}
diff --git a/busybox/archival/libunarchive/filter_accept_list_reassign.c b/busybox/archival/libunarchive/filter_accept_list_reassign.c
new file mode 100644
index 000000000..d0436549b
--- /dev/null
+++ b/busybox/archival/libunarchive/filter_accept_list_reassign.c
@@ -0,0 +1,55 @@
+/*
+ *  Copyright (C) 2002 by Glenn McGrath
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "libbb.h"
+#include "unarchive.h"
+
+/*
+ *      Reassign the subarchive metadata parser based on the filename extension
+ *  e.g. if its a .tar.gz modify archive_handle->sub_archive to process a .tar.gz
+ *       or if its a .tar.bz2 make archive_handle->sub_archive handle that
+ */
+extern char filter_accept_list_reassign(archive_handle_t *archive_handle)
+{
+        /* Check the file entry is in the accept list */
+        if (find_list_entry(archive_handle->accept, archive_handle->file_header->name)) {
+                const char *name_ptr;
+
+                /* Extract the last 2 extensions */
+                name_ptr = strrchr(archive_handle->file_header->name, '.');
+
+                /* Modify the subarchive handler based on the extension */
+#ifdef CONFIG_FEATURE_DEB_TAR_GZ
+                if (strcmp(name_ptr, ".gz") == 0) {
+                        archive_handle->action_data_subarchive = get_header_tar_gz;
+                        return(EXIT_SUCCESS);
+                }
+#endif
+#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+                if (strcmp(name_ptr, ".bz2") == 0) {
+                        archive_handle->action_data_subarchive = get_header_tar_bz2;
+                        return(EXIT_SUCCESS);
+                }
+#endif
+        }
+        return(EXIT_FAILURE);
+}
diff --git a/busybox/archival/libunarchive/filter_accept_reject_list.c b/busybox/archival/libunarchive/filter_accept_reject_list.c
new file mode 100644
index 000000000..657f7a0bd
--- /dev/null
+++ b/busybox/archival/libunarchive/filter_accept_reject_list.c
@@ -0,0 +1,45 @@
+/*
+ *  Copyright (C) 2002 by Glenn McGrath
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <fnmatch.h>
+#include <stdlib.h>
+
+#include "unarchive.h"
+
+/*
+ * Accept names that are in the accept list and not in the reject list
+ */
+extern char filter_accept_reject_list(archive_handle_t *archive_handle)
+{
+        const char *key = archive_handle->file_header->name;
+        const llist_t *accept_entry = find_list_entry(archive_handle->accept, key);
+        const llist_t *reject_entry = find_list_entry(archive_handle->reject, key);
+
+        /* If the key is in a reject list fail */
+        if (reject_entry) {
+                return(EXIT_FAILURE);
+        }
+
+        /* Fail if an accept list was specified and the key wasnt in there */
+        if (archive_handle->accept && (accept_entry == NULL)) {
+                return(EXIT_FAILURE);
+        }
+
+        /* Accepted */
+        return(EXIT_SUCCESS);
+}
diff --git a/busybox/archival/libunarchive/find_list_entry.c b/busybox/archival/libunarchive/find_list_entry.c
new file mode 100644
index 000000000..7ed9e332f
--- /dev/null
+++ b/busybox/archival/libunarchive/find_list_entry.c
@@ -0,0 +1,30 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <fnmatch.h>
+#include <stdlib.h>
+#include "unarchive.h"
+
+extern const llist_t *find_list_entry(const llist_t *list, const char *filename)
+{
+        while (list) {
+                if (fnmatch(list->data, filename, 0) == 0) {
+                        return(list);
+                }
+                list = list->link;
+        }
+        return(NULL);
+}
diff --git a/busybox/archival/libunarchive/get_header_ar.c b/busybox/archival/libunarchive/get_header_ar.c
new file mode 100644
index 000000000..ebb6f8cbe
--- /dev/null
+++ b/busybox/archival/libunarchive/get_header_ar.c
@@ -0,0 +1,126 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "unarchive.h"
+#include "libbb.h"
+
+extern char get_header_ar(archive_handle_t *archive_handle)
+{
+        file_header_t *typed = archive_handle->file_header;
+        union {
+                char raw[60];
+                struct {
+                        char name[16];
+                        char date[12];
+                        char uid[6];
+                        char gid[6];
+                        char mode[8];
+                        char size[10];
+                        char magic[2];
+                } formated;
+        } ar;
+#ifdef CONFIG_FEATURE_AR_LONG_FILENAMES
+        static char *ar_long_names;
+        static unsigned int ar_long_name_size;
+#endif
+
+        /* dont use bb_xread as we want to handle the error ourself */
+        if (read(archive_handle->src_fd, ar.raw, 60) != 60) {
+                /* End Of File */
+                return(EXIT_FAILURE);
+        }
+
+        /* ar header starts on an even byte (2 byte aligned)
+         * '\n' is used for padding
+         */
+        if (ar.raw[0] == '\n') {
+                /* fix up the header, we started reading 1 byte too early */
+                memmove(ar.raw, &ar.raw[1], 59);
+                ar.raw[59] = bb_xread_char(archive_handle->src_fd);
+                archive_handle->offset++;
+        }
+        archive_handle->offset += 60;
+
+        /* align the headers based on the header magic */
+        if ((ar.formated.magic[0] != '`') || (ar.formated.magic[1] != '\n')) {
+                bb_error_msg_and_die("Invalid ar header");
+        }
+
+        typed->mode = strtol(ar.formated.mode, NULL, 8);
+        typed->mtime = atoi(ar.formated.date);
+        typed->uid = atoi(ar.formated.uid);
+        typed->gid = atoi(ar.formated.gid);
+        typed->size = atoi(ar.formated.size);
+
+        /* long filenames have '/' as the first character */
+        if (ar.formated.name[0] == '/') {
+#ifdef CONFIG_FEATURE_AR_LONG_FILENAMES
+                if (ar.formated.name[1] == '/') {
+                        /* If the second char is a '/' then this entries data section
+                         * stores long filename for multiple entries, they are stored
+                         * in static variable long_names for use in future entries */
+                        ar_long_name_size = typed->size;
+                        ar_long_names = xmalloc(ar_long_name_size);
+                        bb_xread_all(archive_handle->src_fd, ar_long_names, ar_long_name_size);
+                        archive_handle->offset += ar_long_name_size;
+                        /* This ar entries data section only contained filenames for other records
+                         * they are stored in the static ar_long_names for future reference */
+                        return (get_header_ar(archive_handle)); /* Return next header */
+                } else if (ar.formated.name[1] == ' ') {
+                        /* This is the index of symbols in the file for compilers */
+                        data_skip(archive_handle);
+                        archive_handle->offset += typed->size;
+                        return (get_header_ar(archive_handle)); /* Return next header */
+                } else {
+                        /* The number after the '/' indicates the offset in the ar data section
+                        (saved in variable long_name) that conatains the real filename */
+                        const unsigned int long_offset = atoi(&ar.formated.name[1]);
+                        if (long_offset >= ar_long_name_size) {
+                                bb_error_msg_and_die("Cant resolve long filename");
+                        }
+                        typed->name = bb_xstrdup(ar_long_names + long_offset);
+                }
+#else
+                bb_error_msg_and_die("long filenames not supported");
+#endif
+        } else {
+                /* short filenames */
+               typed->name = bb_xstrndup(ar.formated.name, 16);
+        }
+
+        typed->name[strcspn(typed->name, " /")] = '\0';
+
+        if (archive_handle->filter(archive_handle) == EXIT_SUCCESS) {
+                archive_handle->action_header(typed);
+                if (archive_handle->sub_archive) {
+                        while (archive_handle->action_data_subarchive(archive_handle->sub_archive) == EXIT_SUCCESS);
+                } else {
+                        archive_handle->action_data(archive_handle);
+                }
+        } else {
+                data_skip(archive_handle);
+        }
+
+        archive_handle->offset += typed->size;
+        /* Set the file pointer to the correct spot, we may have been reading a compressed file */
+        lseek(archive_handle->src_fd, archive_handle->offset, SEEK_SET);
+
+        return(EXIT_SUCCESS);
+}
diff --git a/busybox/archival/libunarchive/get_header_cpio.c b/busybox/archival/libunarchive/get_header_cpio.c
new file mode 100644
index 000000000..11925c4e3
--- /dev/null
+++ b/busybox/archival/libunarchive/get_header_cpio.c
@@ -0,0 +1,161 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/sysmacros.h>     /* major() and minor() */
+#include "unarchive.h"
+#include "libbb.h"
+
+typedef struct hardlinks_s {
+        file_header_t *entry;
+        int inode;
+        struct hardlinks_s *next;
+} hardlinks_t;
+
+extern char get_header_cpio(archive_handle_t *archive_handle)
+{
+        static hardlinks_t *saved_hardlinks = NULL;
+        static unsigned short pending_hardlinks = 0;
+        file_header_t *file_header = archive_handle->file_header;
+        char cpio_header[110];
+        int namesize;
+        char dummy[16];
+        int major, minor, nlink, inode;
+
+        if (pending_hardlinks) { /* Deal with any pending hardlinks */
+                hardlinks_t *tmp;
+                hardlinks_t *oldtmp;
+
+                tmp = saved_hardlinks;
+                oldtmp = NULL;
+
+                while (tmp) {
+                        bb_error_msg_and_die("need to fix this\n");
+                        if (tmp->entry->link_name) { /* Found a hardlink ready to be extracted */
+                                file_header = tmp->entry;
+                                if (oldtmp) {
+                                        oldtmp->next = tmp->next; /* Remove item from linked list */
+                                } else {
+                                        saved_hardlinks = tmp->next;
+                                }
+                                free(tmp);
+                                continue;
+                        }
+                        oldtmp = tmp;
+                        tmp = tmp->next;
+                }
+                pending_hardlinks = 0; /* No more pending hardlinks, read next file entry */
+        }
+
+        /* There can be padding before archive header */
+        data_align(archive_handle, 4);
+
+        if (archive_xread_all_eof(archive_handle, cpio_header, 110) == 0) {
+                return(EXIT_FAILURE);
+        }
+        archive_handle->offset += 110;
+
+        if ((strncmp(&cpio_header[0], "07070", 5) != 0) || ((cpio_header[5] != '1') && (cpio_header[5] != '2'))) {
+                bb_error_msg_and_die("Unsupported cpio format, use newc or crc");
+        }
+
+        {
+            unsigned long tmpsize;
+            sscanf(cpio_header, "%6c%8x%8x%8x%8x%8x%8lx%8lx%16c%8x%8x%8x%8c",
+                    dummy, &inode, (unsigned int*)&file_header->mode,
+                    (unsigned int*)&file_header->uid, (unsigned int*)&file_header->gid,
+                    &nlink, &file_header->mtime, &tmpsize,
+                    dummy, &major, &minor, &namesize, dummy);
+            file_header->size = tmpsize;
+        }
+
+        file_header->name = (char *) xmalloc(namesize + 1);
+        archive_xread_all(archive_handle, file_header->name, namesize); /* Read in filename */
+        file_header->name[namesize] = '\0';
+        archive_handle->offset += namesize;
+
+        /* Update offset amount and skip padding before file contents */
+        data_align(archive_handle, 4);
+
+        if (strcmp(file_header->name, "TRAILER!!!") == 0) {
+                printf("%d blocks\n", (int) (archive_handle->offset % 512 ? (archive_handle->offset / 512) + 1 : archive_handle->offset / 512)); /* Always round up */
+                if (saved_hardlinks) { /* Bummer - we still have unresolved hardlinks */
+                        hardlinks_t *tmp = saved_hardlinks;
+                        hardlinks_t *oldtmp = NULL;
+                        while (tmp) {
+                                bb_error_msg("%s not created: cannot resolve hardlink", tmp->entry->name);
+                                oldtmp = tmp;
+                                tmp = tmp->next;
+                                free (oldtmp->entry->name);
+                                free (oldtmp->entry);
+                                free (oldtmp);
+                        }
+                        saved_hardlinks = NULL;
+                        pending_hardlinks = 0;
+                }
+                return(EXIT_FAILURE);
+        }
+
+        if (S_ISLNK(file_header->mode)) {
+                file_header->link_name = (char *) xmalloc(file_header->size + 1);
+                archive_xread_all(archive_handle, file_header->link_name, file_header->size);
+                file_header->link_name[file_header->size] = '\0';
+                archive_handle->offset += file_header->size;
+                file_header->size = 0; /* Stop possible seeks in future */
+        } else {
+                file_header->link_name = NULL;
+        }
+        if (nlink > 1 && !S_ISDIR(file_header->mode)) {
+                if (file_header->size == 0) { /* Put file on a linked list for later */
+                        hardlinks_t *new = xmalloc(sizeof(hardlinks_t));
+                        new->next = saved_hardlinks;
+                        new->inode = inode;
+                        new->entry = file_header;
+                        saved_hardlinks = new;
+                        return(EXIT_SUCCESS); // Skip this one
+                } else { /* Found the file with data in */
+                        hardlinks_t *tmp = saved_hardlinks;
+                        pending_hardlinks = 1;
+                        while (tmp) {
+                                if (tmp->inode == inode) {
+                                        tmp->entry->link_name = bb_xstrdup(file_header->name);
+                                        nlink--;
+                                }
+                                tmp = tmp->next;
+                        }
+                        if (nlink > 1) {
+                                bb_error_msg("error resolving hardlink: did you create the archive with GNU cpio 2.0-2.2?");
+                        }
+                }
+        }
+        file_header->device = makedev(major, minor);
+
+        if (archive_handle->filter(archive_handle) == EXIT_SUCCESS) {
+                archive_handle->action_data(archive_handle);
+                archive_handle->action_header(archive_handle->file_header);
+        } else {
+                data_skip(archive_handle);
+        }
+
+        archive_handle->offset += file_header->size;
+
+        free(file_header->link_name);
+
+        return (EXIT_SUCCESS);
+}
diff --git a/busybox/archival/libunarchive/get_header_tar.c b/busybox/archival/libunarchive/get_header_tar.c
new file mode 100644
index 000000000..1ad9ac5e5
--- /dev/null
+++ b/busybox/archival/libunarchive/get_header_tar.c
@@ -0,0 +1,215 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  FIXME:
+ *    In privileged mode if uname and gname map to a uid and gid then use the
+ *    mapped value instead of the uid/gid values in tar header
+ *
+ *  References:
+ *    GNU tar and star man pages,
+ *    Opengroup's ustar interchange format,
+ *              http://www.opengroup.org/onlinepubs/007904975/utilities/pax.html
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "unarchive.h"
+#include "libbb.h"
+
+#ifdef CONFIG_FEATURE_TAR_GNU_EXTENSIONS
+static char *longname = NULL;
+static char *linkname = NULL;
+#endif
+
+extern char get_header_tar(archive_handle_t *archive_handle)
+{
+        file_header_t *file_header = archive_handle->file_header;
+        union {
+                /* ustar header, Posix 1003.1 */
+                unsigned char raw[512];
+                struct {
+                        char name[100]; /*   0-99 */
+                        char mode[8];   /* 100-107 */
+                        char uid[8];    /* 108-115 */
+                        char gid[8];    /* 116-123 */
+                        char size[12];  /* 124-135 */
+                        char mtime[12]; /* 136-147 */
+                        char chksum[8]; /* 148-155 */
+                        char typeflag;  /* 156-156 */
+                        char linkname[100];     /* 157-256 */
+                        char magic[6];  /* 257-262 */
+                        char version[2];        /* 263-264 */
+                        char uname[32]; /* 265-296 */
+                        char gname[32]; /* 297-328 */
+                        char devmajor[8];       /* 329-336 */
+                        char devminor[8];       /* 337-344 */
+                        char prefix[155];       /* 345-499 */
+                        char padding[12];       /* 500-512 */
+                } formated;
+        } tar;
+        long sum = 0;
+        long i;
+
+        /* Align header */
+        data_align(archive_handle, 512);
+
+        if (bb_full_read(archive_handle->src_fd, tar.raw, 512) != 512) {
+                /* Assume end of file */
+                return(EXIT_FAILURE);
+        }
+        archive_handle->offset += 512;
+
+        /* If there is no filename its an empty header */
+        if (tar.formated.name[0] == 0) {
+                return(EXIT_SUCCESS);
+        }
+
+        /* Check header has valid magic, "ustar" is for the proper tar
+         * 0's are for the old tar format
+         */
+        if (strncmp(tar.formated.magic, "ustar", 5) != 0) {
+#ifdef CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
+                if (strncmp(tar.formated.magic, "\0\0\0\0\0", 5) != 0)
+#endif
+                        bb_error_msg_and_die("Invalid tar magic");
+        }
+        /* Do checksum on headers */
+        for (i =  0; i < 148 ; i++) {
+                sum += tar.raw[i];
+        }
+        sum += ' ' * 8;
+        for (i =  156; i < 512 ; i++) {
+                sum += tar.raw[i];
+        }
+        if (sum != strtol(tar.formated.chksum, NULL, 8)) {
+                bb_error_msg("Invalid tar header checksum");
+                return(EXIT_FAILURE);
+        }
+
+#ifdef CONFIG_FEATURE_TAR_GNU_EXTENSIONS
+        if (longname) {
+                file_header->name = longname;
+                longname = NULL;
+        }
+        else if (linkname) {
+                file_header->name = linkname;
+                linkname = NULL;
+        } else
+#endif
+        if (tar.formated.prefix[0] == 0) {
+                file_header->name = strdup(tar.formated.name);
+        } else {
+                file_header->name = concat_path_file(tar.formated.prefix, tar.formated.name);
+        }
+
+        file_header->uid = strtol(tar.formated.uid, NULL, 8);
+        file_header->gid = strtol(tar.formated.gid, NULL, 8);
+        file_header->size = strtol(tar.formated.size, NULL, 8);
+        file_header->mtime = strtol(tar.formated.mtime, NULL, 8);
+        file_header->link_name = (tar.formated.linkname[0] != '\0') ?
+            bb_xstrdup(tar.formated.linkname) : NULL;
+        file_header->device = makedev(strtol(tar.formated.devmajor, NULL, 8),
+                strtol(tar.formated.devminor, NULL, 8));
+
+        /* Set bits 0-11 of the files mode */
+        file_header->mode = 07777 & strtol(tar.formated.mode, NULL, 8);
+
+        /* Set bits 12-15 of the files mode */
+        switch (tar.formated.typeflag) {
+        /* busybox identifies hard links as being regular files with 0 size and a link name */
+        case '1':
+                file_header->mode |= S_IFREG;
+                break;
+        case 'x':
+        case 'g':
+                bb_error_msg_and_die("pax is not tar");
+                break;
+        case '7':
+                /* Reserved for high performance files, treat as normal file */
+        case 0:
+        case '0':
+#ifdef CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
+                if (last_char_is(file_header->name, '/')) {
+                        file_header->mode |= S_IFDIR;
+                } else
+#endif
+                        file_header->mode |= S_IFREG;
+                break;
+        case '2':
+                file_header->mode |= S_IFLNK;
+                break;
+        case '3':
+                file_header->mode |= S_IFCHR;
+                break;
+        case '4':
+                file_header->mode |= S_IFBLK;
+                break;
+        case '5':
+                file_header->mode |= S_IFDIR;
+                break;
+        case '6':
+                file_header->mode |= S_IFIFO;
+                break;
+#ifdef CONFIG_FEATURE_TAR_GNU_EXTENSIONS
+        case 'L': {
+                        longname = xmalloc(file_header->size + 1);
+                        archive_xread_all(archive_handle, longname, file_header->size);
+                        longname[file_header->size] = '\0';
+                        archive_handle->offset += file_header->size;
+
+                        return(get_header_tar(archive_handle));
+                }
+        case 'K': {
+                        linkname = xmalloc(file_header->size + 1);
+                        archive_xread_all(archive_handle, linkname, file_header->size);
+                        linkname[file_header->size] = '\0';
+                        archive_handle->offset += file_header->size;
+
+                        file_header->name = linkname;
+                        return(get_header_tar(archive_handle));
+                }
+        case 'D':       /* GNU dump dir */
+        case 'M':       /* Continuation of multi volume archive*/
+        case 'N':       /* Old GNU for names > 100 characters */
+        case 'S':       /* Sparse file */
+        case 'V':       /* Volume header */
+                bb_error_msg("Ignoring GNU extension type %c", tar.formated.typeflag);
+#endif
+        default:
+                bb_error_msg("Unknown typeflag: 0x%x", tar.formated.typeflag);
+        }
+        {       /* Strip trailing '/' in directories */
+                /* Must be done after mode is set as '/' is used to check if its a directory */
+                char *tmp = last_char_is(file_header->name, '/');
+                if (tmp) {
+                        *tmp = '\0';
+                }
+        }
+
+        if (archive_handle->filter(archive_handle) == EXIT_SUCCESS) {
+                archive_handle->action_header(archive_handle->file_header);
+                archive_handle->flags |= ARCHIVE_EXTRACT_QUIET;
+                archive_handle->action_data(archive_handle);
+                archive_handle->passed = llist_add_to(archive_handle->passed, file_header->name);
+        } else {
+                data_skip(archive_handle);
+        }
+        archive_handle->offset += file_header->size;
+
+        free(file_header->link_name);
+
+        return(EXIT_SUCCESS);
+}
diff --git a/busybox/archival/libunarchive/get_header_tar_bz2.c b/busybox/archival/libunarchive/get_header_tar_bz2.c
new file mode 100644
index 000000000..d49d6b96a
--- /dev/null
+++ b/busybox/archival/libunarchive/get_header_tar_bz2.c
@@ -0,0 +1,38 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "libbb.h"
+#include "unarchive.h"
+
+extern char get_header_tar_bz2(archive_handle_t *archive_handle)
+{
+        /* Cant lseek over pipe's */
+        archive_handle->seek = seek_by_char;
+
+        archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompressStream);
+        archive_handle->offset = 0;
+        while (get_header_tar(archive_handle) == EXIT_SUCCESS);
+
+        /* Can only do one file at a time */
+        return(EXIT_FAILURE);
+}
diff --git a/busybox/archival/libunarchive/get_header_tar_gz.c b/busybox/archival/libunarchive/get_header_tar_gz.c
new file mode 100644
index 000000000..9c708a951
--- /dev/null
+++ b/busybox/archival/libunarchive/get_header_tar_gz.c
@@ -0,0 +1,42 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+
+#include "libbb.h"
+#include "unarchive.h"
+
+extern char get_header_tar_gz(archive_handle_t *archive_handle)
+{
+        unsigned char magic[2];
+
+        /* Cant lseek over pipe's */
+        archive_handle->seek = seek_by_char;
+
+        archive_xread_all(archive_handle, &magic, 2);
+        if ((magic[0] != 0x1f) || (magic[1] != 0x8b)) {
+                bb_error_msg_and_die("Invalid gzip magic");
+        }
+
+        check_header_gzip(archive_handle->src_fd);
+
+        archive_handle->src_fd = open_transformer(archive_handle->src_fd, inflate_gunzip);
+        archive_handle->offset = 0;
+        while (get_header_tar(archive_handle) == EXIT_SUCCESS);
+
+        /* Can only do one file at a time */
+        return(EXIT_FAILURE);
+}
diff --git a/busybox/archival/libunarchive/header_list.c b/busybox/archival/libunarchive/header_list.c
new file mode 100644
index 000000000..5849a762e
--- /dev/null
+++ b/busybox/archival/libunarchive/header_list.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include "unarchive.h"
+
+extern void header_list(const file_header_t *file_header)
+{
+        puts(file_header->name);
+}
diff --git a/busybox/archival/libunarchive/header_skip.c b/busybox/archival/libunarchive/header_skip.c
new file mode 100644
index 000000000..4430178f8
--- /dev/null
+++ b/busybox/archival/libunarchive/header_skip.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include "unarchive.h"
+
+extern void header_skip(const file_header_t *file_header)
+{
+        return;
+}
diff --git a/busybox/archival/libunarchive/header_verbose_list.c b/busybox/archival/libunarchive/header_verbose_list.c
new file mode 100644
index 000000000..6739dd393
--- /dev/null
+++ b/busybox/archival/libunarchive/header_verbose_list.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "libbb.h"
+#include "unarchive.h"
+
+extern void header_verbose_list(const file_header_t *file_header)
+{
+        struct tm *mtime = localtime(&file_header->mtime);
+
+        printf("%s %d/%d%10u %4u-%02u-%02u %02u:%02u:%02u %s",
+                bb_mode_string(file_header->mode),
+                file_header->uid,
+                file_header->gid,
+                (unsigned int) file_header->size,
+                1900 + mtime->tm_year,
+                1 + mtime->tm_mon,
+                mtime->tm_mday,
+                mtime->tm_hour,
+                mtime->tm_min,
+                mtime->tm_sec,
+                file_header->name);
+
+        if (file_header->link_name) {
+                printf(" -> %s", file_header->link_name);
+        }
+        /* putchar isnt used anywhere else i dont think */
+        puts("");
+}
diff --git a/busybox/archival/libunarchive/init_handle.c b/busybox/archival/libunarchive/init_handle.c
new file mode 100644
index 000000000..3cee84f67
--- /dev/null
+++ b/busybox/archival/libunarchive/init_handle.c
@@ -0,0 +1,36 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <unistd.h>
+#include <string.h>
+#include "libbb.h"
+#include "unarchive.h"
+
+archive_handle_t *init_handle(void)
+{
+        archive_handle_t *archive_handle;
+
+        /* Initialise default values */
+        archive_handle = xmalloc(sizeof(archive_handle_t));
+        memset(archive_handle, 0, sizeof(archive_handle_t));
+        archive_handle->file_header = xmalloc(sizeof(file_header_t));
+        archive_handle->action_header = header_skip;
+        archive_handle->action_data = data_skip;
+        archive_handle->filter = filter_accept_all;
+        archive_handle->seek = seek_by_jump;
+
+        return(archive_handle);
+}
diff --git a/busybox/archival/libunarchive/open_transformer.c b/busybox/archival/libunarchive/open_transformer.c
new file mode 100644
index 000000000..fb149fc0b
--- /dev/null
+++ b/busybox/archival/libunarchive/open_transformer.c
@@ -0,0 +1,51 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "libbb.h"
+
+/* transformer(), more than meets the eye */
+extern int open_transformer(int src_fd, int (*transformer)(int src_fd, int dst_fd))
+{
+        int fd_pipe[2];
+        int pid;
+
+        if (pipe(fd_pipe) != 0) {
+                bb_perror_msg_and_die("Can't create pipe");
+        }
+
+        pid = fork();
+        if (pid == -1) {
+                bb_perror_msg_and_die("Fork failed");
+        }
+
+        if (pid == 0) {
+                /* child process */
+            close(fd_pipe[0]); /* We don't wan't to read from the parent */
+            transformer(src_fd, fd_pipe[1]);
+            close(fd_pipe[1]); /* Send EOF */
+                close(src_fd);
+            exit(0);
+            /* notreached */
+        }
+
+        /* parent process */
+        close(fd_pipe[1]); /* Don't want to write to the child */
+
+        return(fd_pipe[0]);
+}
diff --git a/busybox/archival/libunarchive/seek_by_char.c b/busybox/archival/libunarchive/seek_by_char.c
new file mode 100644
index 000000000..a50d566f5
--- /dev/null
+++ b/busybox/archival/libunarchive/seek_by_char.c
@@ -0,0 +1,32 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+
+#include "unarchive.h"
+#include "busybox.h"
+
+/*      If we are reading through a pipe(), or from stdin then we cant lseek,
+ *  we must read and discard the data to skip over it.
+ *
+ *  TODO: rename to seek_by_read
+ */
+extern void seek_by_char(const archive_handle_t *archive_handle, const unsigned int jump_size)
+{
+        if (jump_size) {
+                bb_copyfd_size(archive_handle->src_fd, -1, jump_size);
+        }
+}
diff --git a/busybox/archival/libunarchive/seek_by_jump.c b/busybox/archival/libunarchive/seek_by_jump.c
new file mode 100644
index 000000000..578870d9b
--- /dev/null
+++ b/busybox/archival/libunarchive/seek_by_jump.c
@@ -0,0 +1,35 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "libbb.h"
+#include "unarchive.h"
+
+extern void seek_by_jump(const archive_handle_t *archive_handle, const unsigned int amount)
+{
+        if (lseek(archive_handle->src_fd, (off_t) amount, SEEK_CUR) == (off_t) -1) {
+#ifdef CONFIG_FEATURE_UNARCHIVE_TAPE
+                if (errno == ESPIPE) {
+                        seek_by_char(archive_handle, amount);
+                } else
+#endif
+                        bb_perror_msg_and_die("Seek failure");
+        }
+}
diff --git a/busybox/archival/libunarchive/unpack_ar_archive.c b/busybox/archival/libunarchive/unpack_ar_archive.c
new file mode 100644
index 000000000..e8f113bcf
--- /dev/null
+++ b/busybox/archival/libunarchive/unpack_ar_archive.c
@@ -0,0 +1,34 @@
+/*
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include "unarchive.h"
+#include "busybox.h"
+
+extern void unpack_ar_archive(archive_handle_t *ar_archive)
+{
+        char magic[7];
+
+        archive_xread_all(ar_archive, magic, 7);
+        if (strncmp(magic, "!<arch>", 7) != 0) {
+                bb_error_msg_and_die("Invalid ar magic");
+        }
+        ar_archive->offset += 7;
+
+        while (get_header_ar(ar_archive) == EXIT_SUCCESS);
+}
diff --git a/busybox/archival/rpm.c b/busybox/archival/rpm.c
new file mode 100644
index 000000000..30cdc93fb
--- /dev/null
+++ b/busybox/archival/rpm.c
@@ -0,0 +1,349 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini rpm applet for busybox
+ *
+ * Copyright (C) 2001,2002 by Laurence Anderson
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <netinet/in.h> /* For ntohl & htonl function */
+#include <string.h> /* For strncmp */
+#include <sys/mman.h> /* For mmap */
+#include <time.h> /* For ctime */
+
+#include "busybox.h"
+#include "unarchive.h"
+
+#define RPM_HEADER_MAGIC "\216\255\350"
+#define RPM_CHAR_TYPE           1
+#define RPM_INT8_TYPE           2
+#define RPM_INT16_TYPE          3
+#define RPM_INT32_TYPE          4
+/* #define RPM_INT64_TYPE       5   ---- These aren't supported (yet) */
+#define RPM_STRING_TYPE         6
+#define RPM_BIN_TYPE            7
+#define RPM_STRING_ARRAY_TYPE   8
+#define RPM_I18NSTRING_TYPE     9
+
+#define RPMTAG_NAME                     1000
+#define RPMTAG_VERSION                  1001
+#define RPMTAG_RELEASE                  1002
+#define RPMTAG_SUMMARY                  1004
+#define RPMTAG_DESCRIPTION              1005
+#define RPMTAG_BUILDTIME                1006
+#define RPMTAG_BUILDHOST                1007
+#define RPMTAG_SIZE                     1009
+#define RPMTAG_VENDOR                   1011
+#define RPMTAG_LICENSE                  1014
+#define RPMTAG_PACKAGER                 1015
+#define RPMTAG_GROUP                    1016
+#define RPMTAG_URL                      1020
+#define RPMTAG_PREIN                    1023
+#define RPMTAG_POSTIN                   1024
+#define RPMTAG_FILEFLAGS                1037
+#define RPMTAG_FILEUSERNAME             1039
+#define RPMTAG_FILEGROUPNAME            1040
+#define RPMTAG_SOURCERPM                1044
+#define RPMTAG_PREINPROG                1085
+#define RPMTAG_POSTINPROG               1086
+#define RPMTAG_PREFIXS                  1098
+#define RPMTAG_DIRINDEXES               1116
+#define RPMTAG_BASENAMES                1117
+#define RPMTAG_DIRNAMES                 1118
+#define RPMFILE_CONFIG                  (1 << 0)
+#define RPMFILE_DOC                     (1 << 1)
+
+enum rpm_functions_e {
+        rpm_query = 1,
+        rpm_install = 2,
+        rpm_query_info = 4,
+        rpm_query_package = 8,
+        rpm_query_list = 16,
+        rpm_query_list_doc = 32,
+        rpm_query_list_config = 64
+};
+
+typedef struct {
+        uint32_t tag; /* 4 byte tag */
+        uint32_t type; /* 4 byte type */
+        uint32_t offset; /* 4 byte offset */
+        uint32_t count; /* 4 byte count */
+} rpm_index;
+
+static void *map;
+static rpm_index **mytags;
+static int tagcount;
+
+void extract_cpio_gz(int fd);
+rpm_index **rpm_gettags(int fd, int *num_tags);
+int bsearch_rpmtag(const void *key, const void *item);
+char *rpm_getstring(int tag, int itemindex);
+int rpm_getint(int tag, int itemindex);
+int rpm_getcount(int tag);
+void exec_script(int progtag, int datatag, char *prefix);
+void fileaction_dobackup(char *filename, int fileref);
+void fileaction_setowngrp(char *filename, int fileref);
+void fileaction_list(char *filename, int itemno);
+void loop_through_files(int filetag, void (*fileaction)(char *filename, int fileref));
+
+int rpm_main(int argc, char **argv)
+{
+        int opt = 0, func = 0, rpm_fd, offset;
+
+        while ((opt = getopt(argc, argv, "iqpldc")) != -1) {
+                switch (opt) {
+                case 'i': // First arg: Install mode, with q: Information
+                        if (!func) func |= rpm_install;
+                        else func |= rpm_query_info;
+                        break;
+                case 'q': // First arg: Query mode
+                        if (!func) func |= rpm_query;
+                        else bb_show_usage();
+                        break;
+                case 'p': // Query a package
+                        func |= rpm_query_package;
+                        break;
+                case 'l': // List files in a package
+                        func |= rpm_query_list;
+                        break;
+                case 'd': // List doc files in a package (implies list)
+                        func |= rpm_query_list;
+                        func |= rpm_query_list_doc;
+                        break;
+                case 'c': // List config files in a package (implies list)
+                        func |= rpm_query_list;
+                        func |= rpm_query_list_config;
+                        break;
+                default:
+                        bb_show_usage();
+                }
+        }
+
+        if (optind == argc) bb_show_usage();
+        while (optind < argc) {
+                rpm_fd = bb_xopen(argv[optind], O_RDONLY);
+                mytags = rpm_gettags(rpm_fd, (int *) &tagcount);
+                offset = lseek(rpm_fd, 0, SEEK_CUR);
+                if (!mytags) { printf("Error reading rpm header\n"); exit(-1); }
+                map = mmap(0, offset > getpagesize() ? (offset + offset % getpagesize()) : getpagesize(), PROT_READ, MAP_SHARED, rpm_fd, 0); // Mimimum is one page
+                if (func & rpm_install) {
+                        loop_through_files(RPMTAG_BASENAMES, fileaction_dobackup); /* Backup any config files */
+                        extract_cpio_gz(rpm_fd); // Extact the archive
+                        loop_through_files(RPMTAG_BASENAMES, fileaction_setowngrp); /* Set the correct file uid/gid's */
+                } else if (func & rpm_query && func & rpm_query_package) {
+                        if (!((func & rpm_query_info) || (func & rpm_query_list))) { // If just a straight query, just give package name
+                                printf("%s-%s-%s\n", rpm_getstring(RPMTAG_NAME, 0), rpm_getstring(RPMTAG_VERSION, 0), rpm_getstring(RPMTAG_RELEASE, 0));
+                        }
+                        if (func & rpm_query_info) {
+                                /* Do the nice printout */
+                                time_t bdate_time;
+                                struct tm *bdate;
+                                char bdatestring[50];
+                                printf("Name        : %-29sRelocations: %s\n", rpm_getstring(RPMTAG_NAME, 0), rpm_getstring(RPMTAG_PREFIXS, 0) ? rpm_getstring(RPMTAG_PREFIXS, 0) : "(not relocateable)");
+                                printf("Version     : %-34sVendor: %s\n", rpm_getstring(RPMTAG_VERSION, 0), rpm_getstring(RPMTAG_VENDOR, 0) ? rpm_getstring(RPMTAG_VENDOR, 0) : "(none)");
+                                bdate_time = rpm_getint(RPMTAG_BUILDTIME, 0);
+                                bdate = localtime((time_t *) &bdate_time);
+                                strftime(bdatestring, 50, "%a %d %b %Y %T %Z", bdate);
+                                printf("Release     : %-30sBuild Date: %s\n", rpm_getstring(RPMTAG_RELEASE, 0), bdatestring);
+                                printf("Install date: %-30sBuild Host: %s\n", "(not installed)", rpm_getstring(RPMTAG_BUILDHOST, 0));
+                                printf("Group       : %-30sSource RPM: %s\n", rpm_getstring(RPMTAG_GROUP, 0), rpm_getstring(RPMTAG_SOURCERPM, 0));
+                                printf("Size        : %-33dLicense: %s\n", rpm_getint(RPMTAG_SIZE, 0), rpm_getstring(RPMTAG_LICENSE, 0));
+                                printf("URL         : %s\n", rpm_getstring(RPMTAG_URL, 0));
+                                printf("Summary     : %s\n", rpm_getstring(RPMTAG_SUMMARY, 0));
+                                printf("Description :\n%s\n", rpm_getstring(RPMTAG_DESCRIPTION, 0));
+                        }
+                        if (func & rpm_query_list) {
+                                int count, it, flags;
+                                count = rpm_getcount(RPMTAG_BASENAMES);
+                                for (it = 0; it < count; it++) {
+                                        flags = rpm_getint(RPMTAG_FILEFLAGS, it);
+                                        switch ((func & rpm_query_list_doc) + (func & rpm_query_list_config))
+                                        {
+                                                case rpm_query_list_doc: if (!(flags & RPMFILE_DOC)) continue; break;
+                                                case rpm_query_list_config: if (!(flags & RPMFILE_CONFIG)) continue; break;
+                                                case rpm_query_list_doc + rpm_query_list_config: if (!((flags & RPMFILE_CONFIG) || (flags & RPMFILE_DOC))) continue; break;
+                                        }
+                                        printf("%s%s\n", rpm_getstring(RPMTAG_DIRNAMES, rpm_getint(RPMTAG_DIRINDEXES, it)), rpm_getstring(RPMTAG_BASENAMES, it));
+                                }
+                        }
+                }
+                optind++;
+                free (mytags);
+        }
+        return 0;
+}
+
+void extract_cpio_gz(int fd) {
+        archive_handle_t *archive_handle;
+        unsigned char magic[2];
+
+        /* Initialise */
+        archive_handle = init_handle();
+        archive_handle->seek = seek_by_char;
+        //archive_handle->action_header = header_list;
+        archive_handle->action_data = data_extract_all;
+        archive_handle->flags |= ARCHIVE_PRESERVE_DATE;
+        archive_handle->flags |= ARCHIVE_CREATE_LEADING_DIRS;
+        archive_handle->src_fd = fd;
+        archive_handle->offset = 0;
+
+        bb_xread_all(archive_handle->src_fd, &magic, 2);
+        if ((magic[0] != 0x1f) || (magic[1] != 0x8b)) {
+                bb_error_msg_and_die("Invalid gzip magic");
+        }
+        check_header_gzip(archive_handle->src_fd);
+        chdir("/"); // Install RPM's to root
+
+        archive_handle->src_fd = open_transformer(archive_handle->src_fd, inflate_gunzip);
+        archive_handle->offset = 0;
+        while (get_header_cpio(archive_handle) == EXIT_SUCCESS);
+}
+
+
+rpm_index **rpm_gettags(int fd, int *num_tags)
+{
+        rpm_index **tags = calloc(200, sizeof(struct rpmtag *)); /* We should never need mode than 200, and realloc later */
+        int pass, tagindex = 0;
+        lseek(fd, 96, SEEK_CUR); /* Seek past the unused lead */
+
+        for (pass = 0; pass < 2; pass++) { /* 1st pass is the signature headers, 2nd is the main stuff */
+                struct {
+                        char magic[3]; /* 3 byte magic: 0x8e 0xad 0xe8 */
+                        uint8_t version; /* 1 byte version number */
+                        uint32_t reserved; /* 4 bytes reserved */
+                        uint32_t entries; /* Number of entries in header (4 bytes) */
+                        uint32_t size; /* Size of store (4 bytes) */
+                } header;
+                rpm_index *tmpindex;
+                int storepos;
+
+                read(fd, &header, sizeof(header));
+                if (strncmp((char *) &header.magic, RPM_HEADER_MAGIC, 3) != 0) return NULL; /* Invalid magic */
+                if (header.version != 1) return NULL; /* This program only supports v1 headers */
+                header.size = ntohl(header.size);
+                header.entries = ntohl(header.entries);
+                storepos = lseek(fd,0,SEEK_CUR) + header.entries * 16;
+
+                while (header.entries--) {
+                        tmpindex = tags[tagindex++] = malloc(sizeof(rpm_index));
+                        read(fd, tmpindex, sizeof(rpm_index));
+                        tmpindex->tag = ntohl(tmpindex->tag); tmpindex->type = ntohl(tmpindex->type); tmpindex->count = ntohl(tmpindex->count);
+                        tmpindex->offset = storepos + ntohl(tmpindex->offset);
+                        if (pass==0) tmpindex->tag -= 743;
+                }
+                lseek(fd, header.size, SEEK_CUR); /* Seek past store */
+                if (pass==0) lseek(fd, (8 - (lseek(fd,0,SEEK_CUR) % 8)) % 8, SEEK_CUR); /* Skip padding to 8 byte boundary after reading signature headers */
+        }
+        tags = realloc(tags, tagindex * sizeof(struct rpmtag *)); /* realloc tags to save space */
+        *num_tags = tagindex;
+        return tags; /* All done, leave the file at the start of the gzipped cpio archive */
+}
+
+int bsearch_rpmtag(const void *key, const void *item)
+{
+        rpm_index **tmp = (rpm_index **) item;
+        return ((int) key - tmp[0]->tag);
+}
+
+int rpm_getcount(int tag)
+{
+        rpm_index **found;
+        found = bsearch((void *) tag, mytags, tagcount, sizeof(struct rpmtag *), bsearch_rpmtag);
+        if (!found) return 0;
+        else return found[0]->count;
+}
+
+char *rpm_getstring(int tag, int itemindex)
+{
+        rpm_index **found;
+        found = bsearch((void *) tag, mytags, tagcount, sizeof(struct rpmtag *), bsearch_rpmtag);
+        if (!found || itemindex >= found[0]->count) return NULL;
+        if (found[0]->type == RPM_STRING_TYPE || found[0]->type == RPM_I18NSTRING_TYPE || found[0]->type == RPM_STRING_ARRAY_TYPE) {
+                int n;
+                char *tmpstr = (char *) (map + found[0]->offset);
+                for (n=0; n < itemindex; n++) tmpstr = tmpstr + strlen(tmpstr) + 1;
+                return tmpstr;
+        } else return NULL;
+}
+
+int rpm_getint(int tag, int itemindex)
+{
+        rpm_index **found;
+        int n, *tmpint;
+        found = bsearch((void *) tag, mytags, tagcount, sizeof(struct rpmtag *), bsearch_rpmtag);
+        if (!found || itemindex >= found[0]->count) return -1;
+        tmpint = (int *) (map + found[0]->offset);
+        if (found[0]->type == RPM_INT32_TYPE) {
+                for (n=0; n<itemindex; n++) tmpint = (int *) ((void *) tmpint + 4);
+                return ntohl(*tmpint);
+        } else if (found[0]->type == RPM_INT16_TYPE) {
+                for (n=0; n<itemindex; n++) tmpint = (int *) ((void *) tmpint + 2);
+                return ntohs(*tmpint);
+        } else if (found[0]->type == RPM_INT8_TYPE) {
+                for (n=0; n<itemindex; n++) tmpint = (int *) ((void *) tmpint + 1);
+                return ntohs(*tmpint);
+        } else return -1;
+}
+
+void fileaction_dobackup(char *filename, int fileref)
+{
+        struct stat oldfile;
+        int stat_res;
+        char *newname;
+        if (rpm_getint(RPMTAG_FILEFLAGS, fileref) & RPMFILE_CONFIG) { /* Only need to backup config files */
+                stat_res = lstat (filename, &oldfile);
+                if (stat_res == 0 && S_ISREG(oldfile.st_mode)) { /* File already exists  - really should check MD5's etc to see if different */
+                        newname = bb_xstrdup(filename);
+                        newname = strcat(newname, ".rpmorig");
+                        copy_file(filename, newname, FILEUTILS_RECUR | FILEUTILS_PRESERVE_STATUS);
+                        remove_file(filename, FILEUTILS_RECUR | FILEUTILS_FORCE);
+                        free(newname);
+                }
+        }
+}
+
+void fileaction_setowngrp(char *filename, int fileref)
+{
+        int uid, gid;
+        uid = my_getpwnam(rpm_getstring(RPMTAG_FILEUSERNAME, fileref));
+        gid = my_getgrnam(rpm_getstring(RPMTAG_FILEGROUPNAME, fileref));
+        chown (filename, uid, gid);
+}
+
+void fileaction_list(char *filename, int fileref)
+{
+        printf("%s\n", filename);
+}
+
+void loop_through_files(int filetag, void (*fileaction)(char *filename, int fileref))
+{
+        int count = 0;
+        char *filename, *tmp_dirname, *tmp_basename;
+        while (rpm_getstring(filetag, count)) {
+                tmp_dirname = rpm_getstring(RPMTAG_DIRNAMES, rpm_getint(RPMTAG_DIRINDEXES, count)); /* 1st put on the directory */
+                tmp_basename = rpm_getstring(RPMTAG_BASENAMES, count);
+                filename = xmalloc(strlen(tmp_basename) + strlen(tmp_dirname) + 1);
+                strcpy(filename, tmp_dirname); /* First the directory name */
+                strcat(filename, tmp_basename); /* then the filename */
+                fileaction(filename, count++);
+                free(filename);
+        }
+}
diff --git a/busybox/archival/rpm2cpio.c b/busybox/archival/rpm2cpio.c
new file mode 100644
index 000000000..5314e5300
--- /dev/null
+++ b/busybox/archival/rpm2cpio.c
@@ -0,0 +1,106 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini rpm2cpio implementation for busybox
+ *
+ * Copyright (C) 2001 by Laurence Anderson
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <sys/types.h>
+#include <netinet/in.h> /* For ntohl & htonl function */
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include "busybox.h"
+#include "unarchive.h"
+
+#define RPM_MAGIC "\355\253\356\333"
+#define RPM_HEADER_MAGIC "\216\255\350"
+
+struct rpm_lead {
+    unsigned char magic[4];
+    uint8_t major, minor;
+    uint16_t type;
+    uint16_t archnum;
+    char name[66];
+    uint16_t osnum;
+    uint16_t signature_type;
+    char reserved[16];
+};
+
+struct rpm_header {
+        char magic[3]; /* 3 byte magic: 0x8e 0xad 0xe8 */
+        uint8_t version; /* 1 byte version number */
+        uint32_t reserved; /* 4 bytes reserved */
+        uint32_t entries; /* Number of entries in header (4 bytes) */
+        uint32_t size; /* Size of store (4 bytes) */
+};
+
+void skip_header(int rpm_fd)
+{
+        struct rpm_header header;
+
+        bb_xread_all(rpm_fd, &header, sizeof(struct rpm_header));
+        if (strncmp((char *) &header.magic, RPM_HEADER_MAGIC, 3) != 0) {
+                bb_error_msg_and_die("Invalid RPM header magic"); /* Invalid magic */
+        }
+        if (header.version != 1) {
+                bb_error_msg_and_die("Unsupported RPM header version"); /* This program only supports v1 headers */
+        }
+        header.entries = ntohl(header.entries);
+        header.size = ntohl(header.size);
+        lseek (rpm_fd, 16 * header.entries, SEEK_CUR); /* Seek past index entries */
+        lseek (rpm_fd, header.size, SEEK_CUR); /* Seek past store */
+}
+
+/* No getopt required */
+extern int rpm2cpio_main(int argc, char **argv)
+{
+        struct rpm_lead lead;
+        int rpm_fd;
+        unsigned char magic[2];
+
+        if (argc == 1) {
+                rpm_fd = STDIN_FILENO;
+        } else {
+                rpm_fd = bb_xopen(argv[1], O_RDONLY);
+        }
+
+        bb_xread_all(rpm_fd, &lead, sizeof(struct rpm_lead));
+        if (strncmp((char *) &lead.magic, RPM_MAGIC, 4) != 0) {
+                bb_error_msg_and_die("Invalid RPM magic"); /* Just check the magic, the rest is irrelevant */
+        }
+
+        /* Skip the signature header */
+        skip_header(rpm_fd);
+        lseek(rpm_fd, (8 - (lseek(rpm_fd, 0, SEEK_CUR) % 8)) % 8, SEEK_CUR);
+
+        /* Skip the main header */
+        skip_header(rpm_fd);
+
+        bb_xread_all(rpm_fd, &magic, 2);
+        if ((magic[0] != 0x1f) || (magic[1] != 0x8b)) {
+                bb_error_msg_and_die("Invalid gzip magic");
+        }
+
+        check_header_gzip(rpm_fd);
+        if (inflate_gunzip(rpm_fd, STDOUT_FILENO) != 0) {
+                bb_error_msg("Error inflating");
+        }
+
+        close(rpm_fd);
+
+        return 0;
+}
diff --git a/busybox/archival/tar.c b/busybox/archival/tar.c
new file mode 100644
index 000000000..950e21dd3
--- /dev/null
+++ b/busybox/archival/tar.c
@@ -0,0 +1,891 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini tar implementation for busybox
+ *
+ * Modified to use common extraction code used by ar, cpio, dpkg-deb, dpkg
+ *  Glenn McGrath <bug1@iinet.net.au>
+ *
+ * Note, that as of BusyBox-0.43, tar has been completely rewritten from the
+ * ground up.  It still has remnants of the old code lying about, but it is
+ * very different now (i.e., cleaner, less global variables, etc.)
+ *
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ *
+ * Based in part in the tar implementation in sash
+ *  Copyright (c) 1999 by David I. Bell
+ *  Permission is granted to use, distribute, or modify this source,
+ *  provided that this copyright notice remains intact.
+ *  Permission to distribute sash derived code under the GPL has been granted.
+ *
+ * Based in part on the tar implementation from busybox-0.28
+ *  Copyright (C) 1995 Bruce Perens
+ *  This is free software under the GNU General Public License.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <search.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fnmatch.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <sys/sysmacros.h>     /* major() and minor() */
+#include "unarchive.h"
+#include "busybox.h"
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+
+/* Tar file constants  */
+# define TAR_MAGIC          "ustar"     /* ustar and a null */
+# define TAR_VERSION        "  "        /* Be compatable with GNU tar format */
+
+static const int TAR_BLOCK_SIZE = 512;
+static const int TAR_MAGIC_LEN = 6;
+static const int TAR_VERSION_LEN = 2;
+
+/* POSIX tar Header Block, from POSIX 1003.1-1990  */
+enum { NAME_SIZE = 100 };       /* because gcc won't let me use 'static const int' */
+struct TarHeader {              /* byte offset */
+        char name[NAME_SIZE];   /*   0-99 */
+        char mode[8];           /* 100-107 */
+        char uid[8];            /* 108-115 */
+        char gid[8];            /* 116-123 */
+        char size[12];          /* 124-135 */
+        char mtime[12];         /* 136-147 */
+        char chksum[8];         /* 148-155 */
+        char typeflag;          /* 156-156 */
+        char linkname[NAME_SIZE];       /* 157-256 */
+        char magic[6];          /* 257-262 */
+        char version[2];        /* 263-264 */
+        char uname[32];         /* 265-296 */
+        char gname[32];         /* 297-328 */
+        char devmajor[8];       /* 329-336 */
+        char devminor[8];       /* 337-344 */
+        char prefix[155];       /* 345-499 */
+        char padding[12];       /* 500-512 (pad to exactly the TAR_BLOCK_SIZE) */
+};
+typedef struct TarHeader TarHeader;
+
+/*
+** writeTarFile(),  writeFileToTarball(), and writeTarHeader() are
+** the only functions that deal with the HardLinkInfo structure.
+** Even these functions use the xxxHardLinkInfo() functions.
+*/
+typedef struct HardLinkInfo HardLinkInfo;
+struct HardLinkInfo {
+        HardLinkInfo *next;     /* Next entry in list */
+        dev_t dev;                      /* Device number */
+        ino_t ino;                      /* Inode number */
+        short linkCount;        /* (Hard) Link Count */
+        char name[1];           /* Start of filename (must be last) */
+};
+
+/* Some info to be carried along when creating a new tarball */
+struct TarBallInfo {
+        char *fileName;         /* File name of the tarball */
+        int tarFd;                      /* Open-for-write file descriptor
+                                                   for the tarball */
+        struct stat statBuf;    /* Stat info for the tarball, letting
+                                                           us know the inode and device that the
+                                                           tarball lives, so we can avoid trying
+                                                           to include the tarball into itself */
+        int verboseFlag;        /* Whether to print extra stuff or not */
+        const llist_t *excludeList;     /* List of files to not include */
+        HardLinkInfo *hlInfoHead;       /* Hard Link Tracking Information */
+        HardLinkInfo *hlInfo;   /* Hard Link Info for the current file */
+};
+typedef struct TarBallInfo TarBallInfo;
+
+/* A nice enum with all the possible tar file content types */
+enum TarFileType {
+        REGTYPE = '0',          /* regular file */
+        REGTYPE0 = '\0',        /* regular file (ancient bug compat) */
+        LNKTYPE = '1',          /* hard link */
+        SYMTYPE = '2',          /* symbolic link */
+        CHRTYPE = '3',          /* character special */
+        BLKTYPE = '4',          /* block special */
+        DIRTYPE = '5',          /* directory */
+        FIFOTYPE = '6',         /* FIFO special */
+        CONTTYPE = '7',         /* reserved */
+        GNULONGLINK = 'K',      /* GNU long (>100 chars) link name */
+        GNULONGNAME = 'L',      /* GNU long (>100 chars) file name */
+};
+typedef enum TarFileType TarFileType;
+
+/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
+static inline void addHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr,
+                                        struct stat *statbuf,
+                                        const char *name)
+{
+        /* Note: hlInfoHeadPtr can never be NULL! */
+        HardLinkInfo *hlInfo;
+
+        hlInfo = (HardLinkInfo *) xmalloc(sizeof(HardLinkInfo) + strlen(name));
+        hlInfo->next = *hlInfoHeadPtr;
+        *hlInfoHeadPtr = hlInfo;
+        hlInfo->dev = statbuf->st_dev;
+        hlInfo->ino = statbuf->st_ino;
+        hlInfo->linkCount = statbuf->st_nlink;
+        strcpy(hlInfo->name, name);
+}
+
+static void freeHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr)
+{
+        HardLinkInfo *hlInfo = NULL;
+        HardLinkInfo *hlInfoNext = NULL;
+
+        if (hlInfoHeadPtr) {
+                hlInfo = *hlInfoHeadPtr;
+                while (hlInfo) {
+                        hlInfoNext = hlInfo->next;
+                        free(hlInfo);
+                        hlInfo = hlInfoNext;
+                }
+                *hlInfoHeadPtr = NULL;
+        }
+        return;
+}
+
+/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
+static inline HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, struct stat *statbuf)
+{
+        while (hlInfo) {
+                if ((statbuf->st_ino == hlInfo->ino) && (statbuf->st_dev == hlInfo->dev))
+                        break;
+                hlInfo = hlInfo->next;
+        }
+        return (hlInfo);
+}
+
+/* Put an octal string into the specified buffer.
+ * The number is zero and space padded and possibly null padded.
+ * Returns TRUE if successful.  */
+static int putOctal(char *cp, int len, long value)
+{
+        int tempLength;
+        char tempBuffer[32];
+        char *tempString = tempBuffer;
+
+        /* Create a string of the specified length with an initial space,
+         * leading zeroes and the octal number, and a trailing null.  */
+        sprintf(tempString, "%0*lo", len - 1, value);
+
+        /* If the string is too large, suppress the leading space.  */
+        tempLength = strlen(tempString) + 1;
+        if (tempLength > len) {
+                tempLength--;
+                tempString++;
+        }
+
+        /* If the string is still too large, suppress the trailing null.  */
+        if (tempLength > len)
+                tempLength--;
+
+        /* If the string is still too large, fail.  */
+        if (tempLength > len)
+                return FALSE;
+
+        /* Copy the string to the field.  */
+        memcpy(cp, tempString, len);
+
+        return TRUE;
+}
+
+/* Write out a tar header for the specified file/directory/whatever */
+static inline int writeTarHeader(struct TarBallInfo *tbInfo,
+                                                                 const char *header_name,
+                                                                 const char *real_name, struct stat *statbuf)
+{
+        long chksum = 0;
+        struct TarHeader header;
+        const unsigned char *cp = (const unsigned char *) &header;
+        ssize_t size = sizeof(struct TarHeader);
+
+        memset(&header, 0, size);
+
+        strncpy(header.name, header_name, sizeof(header.name));
+
+        putOctal(header.mode, sizeof(header.mode), statbuf->st_mode);
+        putOctal(header.uid, sizeof(header.uid), statbuf->st_uid);
+        putOctal(header.gid, sizeof(header.gid), statbuf->st_gid);
+        putOctal(header.size, sizeof(header.size), 0);  /* Regular file size is handled later */
+        putOctal(header.mtime, sizeof(header.mtime), statbuf->st_mtime);
+        strncpy(header.magic, TAR_MAGIC TAR_VERSION,
+                        TAR_MAGIC_LEN + TAR_VERSION_LEN);
+
+        /* Enter the user and group names (default to root if it fails) */
+        if (my_getpwuid(header.uname, statbuf->st_uid, sizeof(header.uname)) == NULL)
+                strcpy(header.uname, "root");
+        if (my_getgrgid(header.gname, statbuf->st_gid, sizeof(header.gname)) == NULL)
+                strcpy(header.gname, "root");
+
+        if (tbInfo->hlInfo) {
+                /* This is a hard link */
+                header.typeflag = LNKTYPE;
+                strncpy(header.linkname, tbInfo->hlInfo->name,
+                                sizeof(header.linkname));
+        } else if (S_ISLNK(statbuf->st_mode)) {
+                char *lpath = xreadlink(real_name);
+
+                if (!lpath)             /* Already printed err msg inside xreadlink() */
+                        return (FALSE);
+                header.typeflag = SYMTYPE;
+                strncpy(header.linkname, lpath, sizeof(header.linkname));
+                free(lpath);
+        } else if (S_ISDIR(statbuf->st_mode)) {
+                header.typeflag = DIRTYPE;
+                strncat(header.name, "/", sizeof(header.name));
+        } else if (S_ISCHR(statbuf->st_mode)) {
+                header.typeflag = CHRTYPE;
+                putOctal(header.devmajor, sizeof(header.devmajor),
+                                 major(statbuf->st_rdev));
+                putOctal(header.devminor, sizeof(header.devminor),
+                                 minor(statbuf->st_rdev));
+        } else if (S_ISBLK(statbuf->st_mode)) {
+                header.typeflag = BLKTYPE;
+                putOctal(header.devmajor, sizeof(header.devmajor),
+                                 major(statbuf->st_rdev));
+                putOctal(header.devminor, sizeof(header.devminor),
+                                 minor(statbuf->st_rdev));
+        } else if (S_ISFIFO(statbuf->st_mode)) {
+                header.typeflag = FIFOTYPE;
+        } else if (S_ISREG(statbuf->st_mode)) {
+                header.typeflag = REGTYPE;
+                putOctal(header.size, sizeof(header.size), statbuf->st_size);
+        } else {
+                bb_error_msg("%s: Unknown file type", real_name);
+                return (FALSE);
+        }
+
+        /* Calculate and store the checksum (i.e., the sum of all of the bytes of
+         * the header).  The checksum field must be filled with blanks for the
+         * calculation.  The checksum field is formatted differently from the
+         * other fields: it has [6] digits, a null, then a space -- rather than
+         * digits, followed by a null like the other fields... */
+        memset(header.chksum, ' ', sizeof(header.chksum));
+        cp = (const unsigned char *) &header;
+        while (size-- > 0)
+                chksum += *cp++;
+        putOctal(header.chksum, 7, chksum);
+
+        /* Now write the header out to disk */
+        if ((size =
+                 bb_full_write(tbInfo->tarFd, (char *) &header,
+                                        sizeof(struct TarHeader))) < 0) {
+                bb_error_msg(bb_msg_io_error, real_name);
+                return (FALSE);
+        }
+        /* Pad the header up to the tar block size */
+        for (; size < TAR_BLOCK_SIZE; size++) {
+                write(tbInfo->tarFd, "\0", 1);
+        }
+        /* Now do the verbose thing (or not) */
+
+        if (tbInfo->verboseFlag) {
+                FILE *vbFd = stdout;
+
+                if (tbInfo->tarFd == STDOUT_FILENO)     /* If the archive goes to stdout, verbose to stderr */
+                        vbFd = stderr;
+
+                fprintf(vbFd, "%s\n", header.name);
+        }
+
+        return (TRUE);
+}
+
+# ifdef CONFIG_FEATURE_TAR_FROM
+static inline int exclude_file(const llist_t *excluded_files, const char *file)
+{
+        while (excluded_files) {
+                if (excluded_files->data[0] == '/') {
+                        if (fnmatch(excluded_files->data, file,
+                                                FNM_PATHNAME | FNM_LEADING_DIR) == 0)
+                                return 1;
+                } else {
+                        const char *p;
+
+                        for (p = file; p[0] != '\0'; p++) {
+                                if ((p == file || p[-1] == '/') && p[0] != '/' &&
+                                        fnmatch(excluded_files->data, p,
+                                                        FNM_PATHNAME | FNM_LEADING_DIR) == 0)
+                                        return 1;
+                        }
+                }
+                excluded_files = excluded_files->link;
+        }
+
+        return 0;
+}
+# endif
+
+static int writeFileToTarball(const char *fileName, struct stat *statbuf,
+                                                          void *userData)
+{
+        struct TarBallInfo *tbInfo = (struct TarBallInfo *) userData;
+        const char *header_name;
+
+        /*
+           ** Check to see if we are dealing with a hard link.
+           ** If so -
+           ** Treat the first occurance of a given dev/inode as a file while
+           ** treating any additional occurances as hard links.  This is done
+           ** by adding the file information to the HardLinkInfo linked list.
+         */
+        tbInfo->hlInfo = NULL;
+        if (statbuf->st_nlink > 1) {
+                tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf);
+                if (tbInfo->hlInfo == NULL)
+                        addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, fileName);
+        }
+
+        /* It is against the rules to archive a socket */
+        if (S_ISSOCK(statbuf->st_mode)) {
+                bb_error_msg("%s: socket ignored", fileName);
+                return (TRUE);
+        }
+
+        /* It is a bad idea to store the archive we are in the process of creating,
+         * so check the device and inode to be sure that this particular file isn't
+         * the new tarball */
+        if (tbInfo->statBuf.st_dev == statbuf->st_dev &&
+                tbInfo->statBuf.st_ino == statbuf->st_ino) {
+                bb_error_msg("%s: file is the archive; skipping", fileName);
+                return (TRUE);
+        }
+
+        header_name = fileName;
+        while (header_name[0] == '/') {
+                static int alreadyWarned = FALSE;
+
+                if (alreadyWarned == FALSE) {
+                        bb_error_msg("Removing leading '/' from member names");
+                        alreadyWarned = TRUE;
+                }
+                header_name++;
+        }
+
+        if (strlen(fileName) >= NAME_SIZE) {
+                bb_error_msg(bb_msg_name_longer_than_foo, NAME_SIZE);
+                return (TRUE);
+        }
+
+        if (header_name[0] == '\0')
+                return TRUE;
+
+# ifdef CONFIG_FEATURE_TAR_FROM
+        if (exclude_file(tbInfo->excludeList, header_name)) {
+                return SKIP;
+        }
+# endif                                                 /* CONFIG_FEATURE_TAR_FROM */
+
+        if (writeTarHeader(tbInfo, header_name, fileName, statbuf) == FALSE) {
+                return (FALSE);
+        }
+
+        /* Now, if the file is a regular file, copy it out to the tarball */
+        if ((tbInfo->hlInfo == NULL)
+                && (S_ISREG(statbuf->st_mode))) {
+                int inputFileFd;
+                ssize_t readSize = 0;
+
+                /* open the file we want to archive, and make sure all is well */
+                if ((inputFileFd = open(fileName, O_RDONLY)) < 0) {
+                        bb_perror_msg("%s: Cannot open", fileName);
+                        return (FALSE);
+                }
+
+                /* write the file to the archive */
+                readSize = bb_copyfd_eof(inputFileFd, tbInfo->tarFd);
+
+                /* Pad the file up to the tar block size */
+                for (; (readSize % TAR_BLOCK_SIZE) != 0; readSize++) {
+                        write(tbInfo->tarFd, "\0", 1);
+                }
+                close(inputFileFd);
+        }
+
+        return (TRUE);
+}
+
+static inline int writeTarFile(const int tar_fd, const int verboseFlag,
+        const unsigned long dereferenceFlag, const llist_t *include,
+        const llist_t *exclude, const int gzip)
+{
+#ifdef CONFIG_FEATURE_TAR_GZIP
+        int gzipDataPipe[2] = { -1, -1 };
+        int gzipStatusPipe[2] = { -1, -1 };
+        pid_t gzipPid = 0;
+        volatile int vfork_exec_errno = 0;
+#endif
+
+        int errorFlag = FALSE;
+        ssize_t size;
+        struct TarBallInfo tbInfo;
+
+        tbInfo.hlInfoHead = NULL;
+
+        fchmod(tar_fd, 0644);
+        tbInfo.tarFd = tar_fd;
+        tbInfo.verboseFlag = verboseFlag;
+
+        /* Store the stat info for the tarball's file, so
+         * can avoid including the tarball into itself....  */
+        if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
+                bb_perror_msg_and_die("Couldnt stat tar file");
+
+#ifdef CONFIG_FEATURE_TAR_GZIP
+        if (gzip) {
+                if (pipe(gzipDataPipe) < 0 || pipe(gzipStatusPipe) < 0) {
+                        bb_perror_msg_and_die("Failed to create gzip pipe");
+                }
+
+                signal(SIGPIPE, SIG_IGN);       /* we only want EPIPE on errors */
+
+# if __GNUC__
+                        /* Avoid vfork clobbering */
+                        (void) &include;
+                        (void) &errorFlag;
+# endif
+
+                gzipPid = vfork();
+
+                if (gzipPid == 0) {
+                        dup2(gzipDataPipe[0], 0);
+                        close(gzipDataPipe[1]);
+
+                        if (tbInfo.tarFd != 1)
+                                dup2(tbInfo.tarFd, 1);
+
+                        close(gzipStatusPipe[0]);
+                        fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC);  /* close on exec shows sucess */
+
+                        execl("/bin/gzip", "gzip", "-f", 0);
+                        vfork_exec_errno = errno;
+
+                        close(gzipStatusPipe[1]);
+                        exit(-1);
+                } else if (gzipPid > 0) {
+                        close(gzipDataPipe[0]);
+                        close(gzipStatusPipe[1]);
+
+                        while (1) {
+                                char buf;
+
+                                int n = bb_full_read(gzipStatusPipe[0], &buf, 1);
+
+                                if (n == 0 && vfork_exec_errno != 0) {
+                                        errno = vfork_exec_errno;
+                                        bb_perror_msg_and_die("Could not exec gzip process");
+                                } else if ((n < 0) && (errno == EAGAIN || errno == EINTR))
+                                        continue;       /* try it again */
+                                break;
+                        }
+                        close(gzipStatusPipe[0]);
+
+                        tbInfo.tarFd = gzipDataPipe[1];
+                } else {
+                        bb_perror_msg_and_die("Failed to vfork gzip process");
+                }
+        }
+#endif
+
+        tbInfo.excludeList = exclude;
+
+        /* Read the directory/files and iterate over them one at a time */
+        while (include) {
+                if (!recursive_action(include->data, TRUE, dereferenceFlag, FALSE,
+                                                          writeFileToTarball, writeFileToTarball,
+                                                          (void *) &tbInfo)) {
+                        errorFlag = TRUE;
+                }
+                include = include->link;
+        }
+        /* Write two empty blocks to the end of the archive */
+        for (size = 0; size < (2 * TAR_BLOCK_SIZE); size++) {
+                write(tbInfo.tarFd, "\0", 1);
+        }
+
+        /* To be pedantically correct, we would check if the tarball
+         * is smaller than 20 tar blocks, and pad it if it was smaller,
+         * but that isn't necessary for GNU tar interoperability, and
+         * so is considered a waste of space */
+
+        /* Hang up the tools, close up shop, head home */
+        close(tbInfo.tarFd);
+        if (errorFlag)
+                bb_error_msg("Error exit delayed from previous errors");
+
+        freeHardLinkInfo(&tbInfo.hlInfoHead);
+
+#ifdef CONFIG_FEATURE_TAR_GZIP
+        if (gzip && gzipPid) {
+                if (waitpid(gzipPid, NULL, 0) == -1)
+                        printf("Couldnt wait ?");
+        }
+#endif
+
+        return !errorFlag;
+}
+#endif                                                  /* tar_create */
+
+#ifdef CONFIG_FEATURE_TAR_FROM
+static llist_t *append_file_list_to_list(llist_t *list)
+{
+        FILE *src_stream;
+        llist_t *cur = list;
+        llist_t *tmp;
+        char *line;
+        llist_t *newlist = NULL;
+
+        while(cur) {
+                src_stream = bb_xfopen(cur->data, "r");
+                tmp = cur;
+                cur = cur->link;
+                free(tmp);
+        while((line = bb_get_chomped_line_from_file(src_stream)) != NULL) {
+                        newlist = llist_add_to(newlist, line);
+        }
+        fclose(src_stream);
+        }
+        return newlist;
+}
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+static char get_header_tar_Z(archive_handle_t *archive_handle)
+{
+        /* Cant lseek over pipe's */
+        archive_handle->seek = seek_by_char;
+
+        /* do the decompression, and cleanup */
+        if ((bb_xread_char(archive_handle->src_fd) != 0x1f) || (bb_xread_char(archive_handle->src_fd) != 0x9d)) {
+                bb_error_msg_and_die("Invalid magic");
+        }
+
+        archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress);
+        archive_handle->offset = 0;
+        while (get_header_tar(archive_handle) == EXIT_SUCCESS);
+
+        /* Can only do one file at a time */
+        return(EXIT_FAILURE);
+}
+#endif
+
+#define CTX_TEST        (1 << 0)
+#define CTX_EXTRACT     (1 << 1)
+#define TAR_OPT_BASEDIR  (1 << 2)
+#define TAR_OPT_TARNAME  (1 << 3)
+#define TAR_OPT_2STDOUT  (1 << 4)
+#define TAR_OPT_P        (1 << 5)
+#define TAR_OPT_VERBOSE  (1 << 6)
+#define TAR_OPT_KEEP_OLD        (1 << 7)
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+# define CTX_CREATE     (1 << 8)
+# define TAR_OPT_DEREFERNCE (1 << 9)
+# define TAR_OPT_STR_CREATE     "ch"
+# define TAR_OPT_FLAG_CREATE    2
+#else
+//# define CTX_CREATE   0
+# define TAR_OPT_STR_CREATE     ""
+# define TAR_OPT_FLAG_CREATE    0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_BZIP2
+# define TAR_OPT_BZIP2  (1 << (8 + TAR_OPT_FLAG_CREATE))
+# define TAR_OPT_STR_BZIP2      "j"
+# define TAR_OPT_FLAG_BZIP2     1
+#else
+# define TAR_OPT_STR_BZIP2      ""
+# define TAR_OPT_FLAG_BZIP2     0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_FROM
+# define TAR_OPT_INCLUDE_FROM   (1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2))
+# define TAR_OPT_EXCLUDE_FROM   (1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2 + 1))
+# define TAR_OPT_STR_FROM       "T:X:"
+# define TAR_OPT_FLAG_FROM      2
+#else
+# define TAR_OPT_STR_FROM       ""
+# define TAR_OPT_FLAG_FROM      0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_GZIP
+# define TAR_OPT_GZIP   (1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2 + TAR_OPT_FLAG_FROM))
+# define TAR_OPT_STR_GZIP       "z"
+# define TAR_OPT_FLAG_GZIP      1
+#else
+# define TAR_OPT_STR_GZIP       ""
+# define TAR_OPT_FLAG_GZIP      0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+# define TAR_OPT_UNCOMPRESS     (1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2 + TAR_OPT_FLAG_FROM + TAR_OPT_FLAG_GZIP))
+# define TAR_OPT_STR_COMPRESS   "Z"
+#else
+# define TAR_OPT_STR_COMPRESS   ""
+#endif
+
+static const char tar_options[]="txC:f:Opvk" \
+        TAR_OPT_STR_CREATE \
+        TAR_OPT_STR_BZIP2 \
+        TAR_OPT_STR_FROM \
+        TAR_OPT_STR_GZIP \
+        TAR_OPT_STR_COMPRESS;
+
+#ifdef CONFIG_FEATURE_TAR_LONG_OPTIONS
+static const struct option tar_long_options[] = {
+        { "list",                       0,      NULL,   't' },
+        { "extract",            0,      NULL,   'x' },
+        { "directory",          1,      NULL,   'C' },
+        { "file",                       1,      NULL,   'f'     },
+        { "to-stdout",          0,      NULL,   'O' },
+        { "same-permissions",   0,      NULL,   'p' },
+        { "verbose",            0,      NULL,   'v' },
+        { "keep-old",           0,      NULL,   'k' },
+# ifdef CONFIG_FEATURE_TAR_CREATE
+        { "create",                     0,      NULL,   'c' },
+        { "dereference",        0,      NULL,   'h' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_BZIP2
+        { "bzip2",                      0,      NULL,   'j' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_FROM
+        { "files-from",         1,      NULL,   'T' },
+        { "exclude-from",       1,      NULL,   'X' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_GZIP
+        { "gzip",                       0,      NULL,   'z' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_COMPRESS
+        { "compress",           0,      NULL,   'Z' },
+# endif
+        { 0,                 0, 0, 0 }
+};
+#endif
+
+int tar_main(int argc, char **argv)
+{
+        char (*get_header_ptr)(archive_handle_t *) = get_header_tar;
+        archive_handle_t *tar_handle;
+        char *base_dir = NULL;
+        const char *tar_filename = "-";
+        unsigned long opt;
+        unsigned long ctx_flag = 0;
+
+        if (argc < 2) {
+                bb_show_usage();
+        }
+
+        /* Prepend '-' to the first argument if required */
+        if (argv[1][0] != '-') {
+                char *tmp;
+
+                bb_xasprintf(&tmp, "-%s", argv[1]);
+                argv[1] = tmp;
+        }
+
+        /* Initialise default values */
+        tar_handle = init_handle();
+        tar_handle->flags = ARCHIVE_CREATE_LEADING_DIRS | ARCHIVE_PRESERVE_DATE | ARCHIVE_EXTRACT_UNCONDITIONAL;
+
+        bb_opt_complementaly = "c~tx:t~cx:x~ct:X*:T*";
+#ifdef CONFIG_FEATURE_TAR_LONG_OPTIONS
+        bb_applet_long_options = tar_long_options;
+#endif
+
+        opt = bb_getopt_ulflags(argc, argv, tar_options,
+                                &base_dir,      /* Change to dir <optarg> */
+                                &tar_filename /* archive filename */
+#ifdef CONFIG_FEATURE_TAR_FROM
+                                , &(tar_handle->accept),
+                                &(tar_handle->reject)
+#endif
+                                );
+
+        /* Check one and only one context option was given */
+        if(opt & 0x80000000UL) {
+                bb_show_usage();
+        }
+#ifdef CONFIG_FEATURE_TAR_CREATE
+        ctx_flag = opt & (CTX_CREATE | CTX_TEST | CTX_EXTRACT);
+#else
+        ctx_flag = opt & (CTX_TEST | CTX_EXTRACT);
+#endif
+        if (ctx_flag == 0) {
+                bb_show_usage();
+        }
+        if(ctx_flag & CTX_TEST) {
+                if ((tar_handle->action_header == header_list) ||
+                        (tar_handle->action_header == header_verbose_list)) {
+                        tar_handle->action_header = header_verbose_list;
+                } else {
+                        tar_handle->action_header = header_list;
+                }
+        }
+        if(ctx_flag & CTX_EXTRACT) {
+                if (tar_handle->action_data != data_extract_to_stdout)
+                        tar_handle->action_data = data_extract_all;
+                }
+        if(opt & TAR_OPT_2STDOUT) {
+                /* To stdout */
+                tar_handle->action_data = data_extract_to_stdout;
+        }
+        if(opt & TAR_OPT_VERBOSE) {
+                if ((tar_handle->action_header == header_list) ||
+                        (tar_handle->action_header == header_verbose_list))
+                {
+                tar_handle->action_header = header_verbose_list;
+                } else {
+                        tar_handle->action_header = header_list;
+                }
+        }
+        if (opt & TAR_OPT_KEEP_OLD) {
+                tar_handle->flags &= ~ARCHIVE_EXTRACT_UNCONDITIONAL;
+        }
+
+#ifdef CONFIG_FEATURE_TAR_GZIP
+        if(opt & TAR_OPT_GZIP) {
+                get_header_ptr = get_header_tar_gz;
+        }
+#endif
+#ifdef CONFIG_FEATURE_TAR_BZIP2
+        if(opt & TAR_OPT_BZIP2) {
+                get_header_ptr = get_header_tar_bz2;
+        }
+#endif
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+        if(opt & TAR_OPT_UNCOMPRESS) {
+                get_header_ptr = get_header_tar_Z;
+        }
+#endif
+#ifdef CONFIG_FEATURE_TAR_FROM
+        if(opt & TAR_OPT_EXCLUDE_FROM) {
+                tar_handle->reject = append_file_list_to_list(tar_handle->reject);
+        }
+        if(opt & TAR_OPT_INCLUDE_FROM) {
+                tar_handle->accept = append_file_list_to_list(tar_handle->accept);
+        }
+#endif
+
+        /* Check if we are reading from stdin */
+        if ((argv[optind]) && (*argv[optind] == '-')) {
+                /* Default is to read from stdin, so just skip to next arg */
+                optind++;
+        }
+
+        /* Setup an array of filenames to work with */
+        /* TODO: This is the same as in ar, separate function ? */
+        while (optind < argc) {
+                char *filename_ptr = last_char_is(argv[optind], '/');
+                if (filename_ptr) {
+                        *filename_ptr = '\0';
+                }
+                tar_handle->accept = llist_add_to(tar_handle->accept, argv[optind]);
+                optind++;
+        }
+
+        if ((tar_handle->accept) || (tar_handle->reject)) {
+                tar_handle->filter = filter_accept_reject_list;
+        }
+
+        /* Open the tar file */
+        {
+                FILE *tar_stream;
+                int flags;
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+                if (opt & CTX_CREATE) {
+                        /* Make sure there is at least one file to tar up.  */
+                        if (tar_handle->accept == NULL) {
+                                bb_error_msg_and_die("Cowardly refusing to create an empty archive");
+                        }
+                        tar_stream = stdout;
+                        flags = O_WRONLY | O_CREAT | O_EXCL;
+                        unlink(tar_filename);
+                } else
+#endif
+                {
+                        tar_stream = stdin;
+                        flags = O_RDONLY;
+                }
+
+                if ((tar_filename[0] == '-') && (tar_filename[1] == '\0')) {
+                        tar_handle->src_fd = fileno(tar_stream);
+                        tar_handle->seek = seek_by_char;
+                } else {
+                        tar_handle->src_fd = bb_xopen(tar_filename, flags);
+                }
+        }
+
+        if ((base_dir) && (chdir(base_dir))) {
+                bb_perror_msg_and_die("Couldnt chdir to %s", base_dir);
+        }
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+        /* create an archive */
+        if (opt & CTX_CREATE) {
+                int verboseFlag = FALSE;
+                int gzipFlag = FALSE;
+
+# ifdef CONFIG_FEATURE_TAR_GZIP
+                if (get_header_ptr == get_header_tar_gz) {
+                        gzipFlag = TRUE;
+                }
+# endif /* CONFIG_FEATURE_TAR_GZIP */
+# ifdef CONFIG_FEATURE_TAR_BZIP2
+                if (get_header_ptr == get_header_tar_bz2) {
+                        bb_error_msg_and_die("Creating bzip2 compressed archives is not currently supported.");
+                }
+# endif /* CONFIG_FEATURE_TAR_BZIP2 */
+
+                if ((tar_handle->action_header == header_list) ||
+                                (tar_handle->action_header == header_verbose_list)) {
+                        verboseFlag = TRUE;
+                }
+                writeTarFile(tar_handle->src_fd, verboseFlag, opt & TAR_OPT_DEREFERNCE, tar_handle->accept,
+                        tar_handle->reject, gzipFlag);
+        } else
+#endif /* CONFIG_FEATURE_TAR_CREATE */
+        {
+                while (get_header_ptr(tar_handle) == EXIT_SUCCESS);
+
+                /* Ckeck that every file that should have been extracted was */
+                while (tar_handle->accept) {
+                        if (find_list_entry(tar_handle->reject, tar_handle->accept->data) == NULL) {
+                                if (find_list_entry(tar_handle->passed, tar_handle->accept->data) == NULL) {
+                                        bb_error_msg_and_die("%s: Not found in archive\n", tar_handle->accept->data);
+                                }
+                        }
+                        tar_handle->accept = tar_handle->accept->link;
+                }
+        }
+
+#ifdef CONFIG_FEATURE_CLEAN_UP
+        if (tar_handle->src_fd != STDIN_FILENO) {
+                close(tar_handle->src_fd);
+        }
+#endif /* CONFIG_FEATURE_CLEAN_UP */
+
+        return(EXIT_SUCCESS);
+}
diff --git a/busybox/archival/uncompress.c b/busybox/archival/uncompress.c
new file mode 100644
index 000000000..48b4e2cad
--- /dev/null
+++ b/busybox/archival/uncompress.c
@@ -0,0 +1,115 @@
+/* vi: set sw=4 ts=4: */
+/*
+ *      Uncompress applet for busybox (c) 2002 Glenn McGrath
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "libbb.h"
+#include "unarchive.h"
+
+#define GUNZIP_TO_STDOUT        1
+#define GUNZIP_FORCE    2
+
+extern int uncompress_main(int argc, char **argv)
+{
+        int status = EXIT_SUCCESS;
+        unsigned long flags;
+
+        flags = bb_getopt_ulflags(argc, argv, "cf");
+
+        while (optind < argc) {
+                const char *compressed_file = argv[optind++];
+                const char *delete_path = NULL;
+                char *uncompressed_file = NULL;
+                int src_fd;
+                int dst_fd;
+
+                if (strcmp(compressed_file, "-") == 0) {
+                        src_fd = STDIN_FILENO;
+                        flags |= GUNZIP_TO_STDOUT;
+                } else {
+                        src_fd = bb_xopen(compressed_file, O_RDONLY);
+                }
+
+                /* Check that the input is sane.  */
+                if (isatty(src_fd) && ((flags & GUNZIP_FORCE) == 0)) {
+                        bb_error_msg_and_die
+                                ("compressed data not read from terminal.  Use -f to force it.");
+                }
+
+                /* Set output filename and number */
+                if (flags & GUNZIP_TO_STDOUT) {
+                        dst_fd = STDOUT_FILENO;
+                } else {
+                        struct stat stat_buf;
+                        char *extension;
+
+                        uncompressed_file = bb_xstrdup(compressed_file);
+
+                        extension = strrchr(uncompressed_file, '.');
+                        if (!extension || (strcmp(extension, ".Z") != 0)) {
+                                bb_error_msg_and_die("Invalid extension");
+                        }
+                        *extension = '\0';
+
+                        /* Open output file */
+                        dst_fd = bb_xopen(uncompressed_file, O_WRONLY | O_CREAT);
+
+                        /* Set permissions on the file */
+                        stat(compressed_file, &stat_buf);
+                        chmod(uncompressed_file, stat_buf.st_mode);
+
+                        /* If unzip succeeds remove the old file */
+                        delete_path = compressed_file;
+                }
+
+                /* do the decompression, and cleanup */
+                if ((bb_xread_char(src_fd) != 0x1f) || (bb_xread_char(src_fd) != 0x9d)) {
+                        bb_error_msg_and_die("Invalid magic");
+                }
+
+                status = uncompress(src_fd, dst_fd);
+
+                if ((status != EXIT_SUCCESS) && (uncompressed_file)) {
+                        /* Unzip failed, remove the uncomressed file instead of compressed file */
+                        delete_path = uncompressed_file;
+                }
+
+                if (dst_fd != STDOUT_FILENO) {
+                        close(dst_fd);
+                }
+                if (src_fd != STDIN_FILENO) {
+                        close(src_fd);
+                }
+
+                /* delete_path will be NULL if in test mode or from stdin */
+                if (delete_path && (unlink(delete_path) == -1)) {
+                        bb_error_msg_and_die("Couldn't remove %s", delete_path);
+                }
+
+                free(uncompressed_file);
+        }
+
+        return status;
+}
diff --git a/busybox/archival/unzip.c b/busybox/archival/unzip.c
new file mode 100644
index 000000000..eea2f5438
--- /dev/null
+++ b/busybox/archival/unzip.c
@@ -0,0 +1,247 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini unzip implementation for busybox
+ *
+ * Copyright (C) 2001 by Laurence Anderson
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* For reference see
+ * http://www.pkware.com/products/enterprise/white_papers/appnote.txt
+ * http://www.info-zip.org/pub/infozip/doc/appnote-iz-latest.zip
+ */
+
+/* TODO Endian issues, exclude, should we accept input from stdin ? */
+
+#include <fcntl.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "unarchive.h"
+#include "busybox.h"
+
+#define ZIP_FILEHEADER_MAGIC    0x04034b50
+#define ZIP_CDS_MAGIC                   0x02014b50
+#define ZIP_CDS_END_MAGIC               0x06054b50
+#define ZIP_DD_MAGIC                    0x08074b50
+
+extern unsigned int gunzip_crc;
+extern unsigned int gunzip_bytes_out;
+
+static void header_list_unzip(const file_header_t *file_header)
+{
+        printf("  inflating: %s\n", file_header->name);
+}
+
+static void header_verbose_list_unzip(const file_header_t *file_header)
+{
+        unsigned int dostime = (unsigned int) file_header->mtime;
+
+        /* can printf arguments cut of the decade component ? */
+        unsigned short year = 1980 + ((dostime & 0xfe000000) >> 25);
+        while (year >= 100) {
+                year -= 100;
+        }
+
+        printf("%9u  %02u-%02u-%02u %02u:%02u   %s\n",
+                (unsigned int) file_header->size,
+                (dostime & 0x01e00000) >> 21,
+                (dostime & 0x001f0000) >> 16,
+                year,
+                (dostime & 0x0000f800) >> 11,
+                (dostime & 0x000007e0) >> 5,
+                file_header->name);
+}
+
+extern int unzip_main(int argc, char **argv)
+{
+        union {
+                unsigned char raw[26];
+                struct {
+                        unsigned short version; /* 0-1 */
+                        unsigned short flags;   /* 2-3 */
+                        unsigned short method;  /* 4-5 */
+                        unsigned short modtime; /* 6-7 */
+                        unsigned short moddate; /* 8-9 */
+                        unsigned int crc32 __attribute__ ((packed));            /* 10-13 */
+                        unsigned int cmpsize __attribute__ ((packed));; /* 14-17 */
+                        unsigned int ucmpsize __attribute__ ((packed));;        /* 18-21 */
+                        unsigned short filename_len;            /* 22-23 */
+                        unsigned short extra_len;               /* 24-25 */
+                } formated __attribute__ ((packed));
+        } zip_header;
+
+        archive_handle_t *archive_handle;
+        unsigned int total_size = 0;
+        unsigned int total_entries = 0;
+        char *base_dir = NULL;
+        int opt = 0;
+
+        /* Initialise */
+        archive_handle = init_handle();
+        archive_handle->action_data = NULL;
+        archive_handle->action_header = header_list_unzip;
+
+        while ((opt = getopt(argc, argv, "lnopqd:")) != -1) {
+                switch (opt) {
+                        case 'l':       /* list */
+                                archive_handle->action_header = header_verbose_list_unzip;
+                                archive_handle->action_data = data_skip;
+                                break;
+                        case 'n':       /* never overwright existing files */
+                                break;
+                        case 'o':
+                                archive_handle->flags = ARCHIVE_EXTRACT_UNCONDITIONAL;
+                                break;
+                        case 'p':       /* extract files to stdout */
+                                archive_handle->action_data = data_extract_to_stdout;
+                                break;
+                        case 'q':       /* Extract files quietly */
+                                archive_handle->action_header = header_skip;
+                                break;
+                        case 'd':       /* Extract files to specified base directory*/
+                                base_dir = optarg;
+                                break;
+#if 0
+                        case 'x':       /* Exclude the specified files */
+                                archive_handle->filter = filter_accept_reject_list;
+                                break;
+#endif
+                        default:
+                                bb_show_usage();
+                }
+        }
+
+        if (argc == optind) {
+                bb_show_usage();
+        }
+
+        printf("Archive:  %s\n", argv[optind]);
+        if (archive_handle->action_header == header_verbose_list_unzip) {
+                printf("  Length     Date   Time    Name\n");
+                printf(" --------    ----   ----    ----\n");
+        }
+
+        if (*argv[optind] == '-') {
+                archive_handle->src_fd = STDIN_FILENO;
+                archive_handle->seek = seek_by_char;
+        } else {
+                archive_handle->src_fd = bb_xopen(argv[optind++], O_RDONLY);
+        }
+
+        if ((base_dir) && (chdir(base_dir))) {
+                bb_perror_msg_and_die("Couldnt chdir");
+        }
+
+        while (optind < argc) {
+                archive_handle->filter = filter_accept_list;
+                archive_handle->accept = llist_add_to(archive_handle->accept, argv[optind]);
+                optind++;
+        }
+
+        while (1) {
+                unsigned int magic;
+                int dst_fd;
+
+                /* TODO Endian issues */
+                archive_xread_all(archive_handle, &magic, 4);
+                archive_handle->offset += 4;
+
+                if (magic == ZIP_CDS_MAGIC) {
+                        break;
+                }
+                else if (magic != ZIP_FILEHEADER_MAGIC) {
+                        bb_error_msg_and_die("Invlaide zip magic");
+                }
+
+                /* Read the file header */
+                archive_xread_all(archive_handle, zip_header.raw, 26);
+                archive_handle->offset += 26;
+                archive_handle->file_header->mode = S_IFREG | 0777;
+
+                if (zip_header.formated.method != 8) {
+                        bb_error_msg_and_die("Unsupported compression method %d\n", zip_header.formated.method);
+                }
+
+                /* Read filename */
+                archive_handle->file_header->name = xmalloc(zip_header.formated.filename_len + 1);
+                archive_xread_all(archive_handle, archive_handle->file_header->name, zip_header.formated.filename_len);
+                archive_handle->offset += zip_header.formated.filename_len;
+                archive_handle->file_header->name[zip_header.formated.filename_len] = '\0';
+
+                /* Skip extra header bits */
+                archive_handle->file_header->size = zip_header.formated.extra_len;
+                data_skip(archive_handle);
+                archive_handle->offset += zip_header.formated.extra_len;
+
+                /* Handle directories */
+                archive_handle->file_header->mode = S_IFREG | 0777;
+                if (last_char_is(archive_handle->file_header->name, '/')) {
+                        archive_handle->file_header->mode ^= S_IFREG;
+                        archive_handle->file_header->mode |= S_IFDIR;
+                }
+
+                /* Data section */
+                archive_handle->file_header->size = zip_header.formated.cmpsize;
+                if (archive_handle->action_data) {
+                        archive_handle->action_data(archive_handle);
+                } else {
+                        dst_fd = bb_xopen(archive_handle->file_header->name, O_WRONLY | O_CREAT);
+                        inflate_init(zip_header.formated.cmpsize);
+                        inflate_unzip(archive_handle->src_fd, dst_fd);
+                        close(dst_fd);
+                        chmod(archive_handle->file_header->name, archive_handle->file_header->mode);
+
+                        /* Validate decompression - crc */
+                        if (zip_header.formated.crc32 != (gunzip_crc ^ 0xffffffffL)) {
+                                bb_error_msg("Invalid compressed data--crc error");
+                        }
+
+                        /* Validate decompression - size */
+                        if (gunzip_bytes_out != zip_header.formated.ucmpsize) {
+                                bb_error_msg("Invalid compressed data--length error");
+                        }
+                }
+
+                /* local file descriptor section */
+                archive_handle->offset += zip_header.formated.cmpsize;
+                /* This ISNT unix time */
+                archive_handle->file_header->mtime = zip_header.formated.modtime | (zip_header.formated.moddate << 16);
+                archive_handle->file_header->size = zip_header.formated.ucmpsize;
+                total_size += archive_handle->file_header->size;
+                total_entries++;
+
+                archive_handle->action_header(archive_handle->file_header);
+
+                /* Data descriptor section */
+                if (zip_header.formated.flags & 4) {
+                        /* skip over duplicate crc, compressed size and uncompressed size */
+                        unsigned char data_description[12];
+                        archive_xread_all(archive_handle, data_description, 12);
+                        archive_handle->offset += 12;
+                }
+        }
+        /* Central directory section */
+
+        if (archive_handle->action_header == header_verbose_list_unzip) {
+                printf(" --------                   -------\n");
+                printf("%9d                   %d files\n", total_size, total_entries);
+        }
+
+        return(EXIT_SUCCESS);
+}