imported original firmware WRT54GL_v4.30.11_11_US

48 files changed, 11267 insertions, 0 deletions

diff --git a/release/src/router/busybox/archival/Config.in b/release/src/router/busybox/archival/Config.in
new file mode 100755
index 00000000..09e40dd4
--- /dev/null
+++ b/release/src/router/busybox/archival/Config.in
@@ -0,0 +1,236 @@
+#
+# 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 XXX bytes.
+
+	  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 an 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 XXX bytes.
+	  
+	  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 reduced 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_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 compatability 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 is your are creating your own custom debian packages that
+	  use an internal control.tar.bz2 or data.tar.bz2.
+
+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
+	  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 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 - querys 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 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_EXCLUDE
+	bool "  Enable -X and --exclude options (exclude files)"
+	default n
+	depends on CONFIG_TAR
+	help
+	  If you enable this option you'll be able to specify
+	  a list of files to 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_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 with
+	  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_UNARCHIVE_TAPE
+	bool "  Enable tape drive support"
+	default n
+	depends on CONFIG_TAR || CONFIG_CPIO
+	help
+	  I dont think this is needed anymore.
+
+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.
+
+endmenu
diff --git a/release/src/router/busybox/archival/Makefile b/release/src/router/busybox/archival/Makefile
new file mode 100644
index 00000000..3362feaf
--- /dev/null
+++ b/release/src/router/busybox/archival/Makefile
@@ -0,0 +1,30 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 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
+#
+
+TOPDIR:= ../
+ARCHIVAL_DIR:=./
+include $(TOPDIR).config
+include $(TOPDIR)Rules.mak
+include Makefile.in
+all: $(libraries-y)
+-include $(TOPDIR).depend
+
+clean:
+	rm -f *.o *.a $(AR_TARGET)
+
diff --git a/release/src/router/busybox/archival/Makefile.in b/release/src/router/busybox/archival/Makefile.in
new file mode 100755
index 00000000..3247ad8b
--- /dev/null
+++ b/release/src/router/busybox/archival/Makefile.in
@@ -0,0 +1,44 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 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:=$(TOPDIR)archival/
+endif
+
+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))
+
diff --git a/release/src/router/busybox/archival/ar.c b/release/src/router/busybox/archival/ar.c
new file mode 100644
index 00000000..57ec9271
--- /dev/null
+++ b/release/src/router/busybox/archival/ar.c
@@ -0,0 +1,144 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini ar implementation for busybox 
+ *
+ * Copyright (C) 2000 by Glenn McGrath
+ * Written by Glenn McGrath <bug1@optushome.com.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 signle 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 <sys/types.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <utime.h>
+#include <unistd.h>
+#include <getopt.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);
+}
+
+#if !defined CONFIG_TAR && !defined CONFIG_DPKG_DEB && !defined CONFIG_CPIO
+/* This is simpler than data_extract_all */
+static void data_extract_regular_file(archive_handle_t *archive_handle)
+{
+	file_header_t *file_header;
+	int dst_fd;
+
+	file_header = archive_handle->file_header;
+	dst_fd = bb_xopen(file_header->name, O_WRONLY | O_CREAT);
+	archive_copy_file(archive_handle, dst_fd);	
+	close(dst_fd);
+
+	chmod(file_header->name, file_header->mode);
+	chown(file_header->name, file_header->uid, file_header->gid);
+
+	if (archive_handle->flags & ARCHIVE_PRESERVE_DATE) {
+		struct utimbuf t;
+		t.actime = t.modtime = file_header->mtime;
+		utime(file_header->name, &t);
+	}
+
+	return;
+}
+#endif
+
+extern int ar_main(int argc, char **argv)
+{
+	archive_handle_t *archive_handle;
+	int opt;
+
+#if !defined CONFIG_DPKG_DEB && !defined CONFIG_DPKG
+	char magic[8];
+#endif
+	archive_handle = init_handle();
+
+	while ((opt = getopt(argc, argv, "covtpxX")) != -1) {
+		switch (opt) {
+		case 'p':	/* print */
+			archive_handle->action_data = data_extract_to_stdout;
+			break;
+		case 't':	/* list contents */
+			archive_handle->action_header = header_list;
+			break;
+		case 'X':
+			archive_handle->action_header = header_verbose_list_ar;
+		case 'x':	/* extract */
+#if defined CONFIG_TAR || defined CONFIG_DPKG_DEB || defined CONFIG_CPIO
+			archive_handle->action_data = data_extract_all;
+#else
+			archive_handle->action_data = data_extract_regular_file;
+#endif
+			break;
+		/* Modifiers */
+		case 'o':	/* preserve original dates */
+			archive_handle->flags |= ARCHIVE_PRESERVE_DATE;
+			break;
+		case 'v':	/* verbose */
+			archive_handle->action_header = header_verbose_list_ar;
+			break;
+		default:
+			bb_show_usage();
+		}
+	}
+ 
+	/* check the src filename was specified */
+	if (optind == argc) {
+		bb_show_usage();
+	}
+
+	archive_handle->src_fd = bb_xopen(argv[optind++], O_RDONLY);
+
+	/* TODO: This is the same as in tar, seperate function ? */
+	while (optind < argc) {
+		archive_handle->filter = filter_accept_list;
+		archive_handle->accept = llist_add_to(archive_handle->accept, argv[optind]);
+		optind++;
+	}
+
+#if defined CONFIG_DPKG_DEB || defined CONFIG_DPKG
+	unpack_ar_archive(archive_handle);
+#else
+	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);
+#endif
+
+	return EXIT_SUCCESS;
+}
diff --git a/release/src/router/busybox/archival/bunzip2.c b/release/src/router/busybox/archival/bunzip2.c
new file mode 100644
index 00000000..eb5238cd
--- /dev/null
+++ b/release/src/router/busybox/archival/bunzip2.c
@@ -0,0 +1,103 @@
+/*
+ *  Modified for busybox by Glenn McGrath <bug1@optushome.com.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"
+
+int bunzip2_main(int argc, char **argv)
+{
+	const int bunzip_to_stdout = 1;
+	const int bunzip_force = 2;
+	int flags = 0;
+	int opt = 0;
+	int status;
+
+	int src_fd;
+	int dst_fd;
+	char *save_name = NULL;
+	char *delete_name = NULL;
+
+	/* if called as bzcat */
+	if (strcmp(bb_applet_name, "bzcat") == 0)
+		flags |= bunzip_to_stdout;
+
+	while ((opt = getopt(argc, argv, "cfh")) != -1) {
+		switch (opt) {
+		case 'c':
+			flags |= bunzip_to_stdout;
+			break;
+		case 'f':
+			flags |= bunzip_force;
+			break;
+		case 'h':
+		default:
+			bb_show_usage(); /* exit's inside usage */
+		}
+	}
+
+	/* Set input filename and number */
+	if (argv[optind] == NULL || strcmp(argv[optind], "-") == 0) {
+		flags |= bunzip_to_stdout;
+		src_fd = fileno(stdin);
+	} else {
+		/* Open input file */
+		src_fd = bb_xopen(argv[optind], O_RDONLY);
+
+		save_name = bb_xstrdup(argv[optind]);
+		if (strcmp(save_name + strlen(save_name) - 4, ".bz2") != 0)
+			bb_error_msg_and_die("Invalid extension");
+		save_name[strlen(save_name) - 4] = '\0';
+	}
+
+	/* Check that the input is sane.  */
+	if (isatty(src_fd) && (flags & bunzip_force) == 0) {
+		bb_error_msg_and_die("compressed data not read from terminal.  Use -f to force it.");
+	}
+
+	if (flags & bunzip_to_stdout) {
+		dst_fd = fileno(stdout);
+	} else {
+		dst_fd = bb_xopen(save_name, O_WRONLY | O_CREAT);
+	}
+
+	if (uncompressStream(src_fd, dst_fd)) {
+		if (!(flags & bunzip_to_stdout)) {
+			delete_name = argv[optind];
+		}
+		status = EXIT_SUCCESS;
+	} else {
+		if (!(flags & bunzip_to_stdout)) {
+			delete_name = save_name;
+		}
+		status = EXIT_FAILURE;
+	}
+
+	if ((delete_name) && (unlink(delete_name) < 0)) {
+		bb_error_msg_and_die("Couldn't remove %s", delete_name);
+	}
+
+	return status;
+}
diff --git a/release/src/router/busybox/archival/cpio.c b/release/src/router/busybox/archival/cpio.c
new file mode 100644
index 00000000..111807c4
--- /dev/null
+++ b/release/src/router/busybox/archival/cpio.c
@@ -0,0 +1,84 @@
+/* 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"
+
+extern int cpio_main(int argc, char **argv)
+{
+	archive_handle_t *archive_handle;
+	int opt;
+
+	/* Initialise */
+	archive_handle = init_handle();
+	archive_handle->src_fd = fileno(stdin);
+	archive_handle->seek = seek_by_char;
+	archive_handle->action_header = header_list;
+
+	while ((opt = getopt(argc, argv, "idmuvtF:")) != -1) {
+		switch (opt) {
+		case 'i': /* extract */
+			archive_handle->action_data = data_extract_all;
+			break;
+		case 'd': /* create _leading_ directories */
+			archive_handle->flags |= ARCHIVE_CREATE_LEADING_DIRS;
+			break;
+		case 'm': /* preserve modification time */
+			archive_handle->flags |= ARCHIVE_PRESERVE_DATE;
+			break;
+		case 'v': /* verbosly list files */
+			archive_handle->action_header = header_verbose_list;
+			break;
+		case 'u': /* unconditional */
+			archive_handle->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+			break;
+		case 't': /* list files */
+			archive_handle->action_header = header_list;
+			break;
+		case 'F':
+			archive_handle->src_fd = bb_xopen(optarg, O_RDONLY);
+			archive_handle->seek = seek_by_jump;
+			break;
+		default:
+			bb_show_usage();
+		}
+	}
+
+	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/release/src/router/busybox/archival/dpkg.c b/release/src/router/busybox/archival/dpkg.c
new file mode 100644
index 00000000..3288f7e6
--- /dev/null
+++ b/release/src/router/busybox/archival/dpkg.c
@@ -0,0 +1,1653 @@
+/*
+ *  Mini dpkg implementation for busybox.
+ *  This is not meant as a replacemnt 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 dont
+ * 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.
+ *  - The <package>.control file is extracted and kept in the info dir.
+ *  - When installing a package the Status: field is placed at the end of the
+ *      section, rather than just after the Package: field.
+ *  - Packages with previously unknown status are inserted at the begining of
+ *      the status file
+ *
+ * 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 leaway 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 dependecies 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, dont 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);
+}
+
+/*
+ * Create one new node and one new edge for every dependency.
+ */
+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;
+	int offset_ch;
+	int type;
+
+	field = strtok_r(line, ",", &line_ptr1);
+	do {
+		line2 = bb_xstrdup(field);
+		field2 = strtok_r(line2, "|", &line_ptr2);
+		if ((edge_type == EDGE_DEPENDS) && (strcmp(field, field2) != 0)) {
+			type = EDGE_OR_DEPENDS;
+		}
+		else if ((edge_type == EDGE_PRE_DEPENDS) && (strcmp(field, field2) != 0)) {
+			type = EDGE_OR_PRE_DEPENDS;
+		} else {
+			type = edge_type;
+		}
+
+		do {
+			edge = (edge_t *) xmalloc(sizeof(edge_t));
+			edge->type = 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 charactors */
+				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);
+	
+			/* link the new edge to the current node */
+			parent_node->num_of_edges++;
+			parent_node->edge = xrealloc(parent_node->edge, sizeof(edge_t) * (parent_node->num_of_edges + 1));
+			parent_node->edge[parent_node->num_of_edges - 1] = 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]);
+		}
+		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 seperating 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;
+}
+
+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;
+}
+
+
+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);
+}
+
+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 seperate 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 becasue 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");
+	}
+}
+
+int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
+{
+	int *conflicts = NULL;
+	int conflicts_num = 0;
+	int state_status;
+	int state_flag;
+	int state_want;
+	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];
+			const unsigned int package_num = 
+			search_package_hashtable(package_edge->name,
+				package_edge->version, package_edge->operator);	
+
+			if (package_edge->type == EDGE_CONFLICTS) {
+				int result = 0;
+				if (package_hashtable[package_num] != NULL) {
+					status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
+					state_status = get_status(status_num, 3);
+					state_flag = get_status(status_num, 1);
+
+					result = (state_status == search_name_hashtable("installed")) || 
+						(state_flag == search_name_hashtable("want-install"));
+
+					if (result) {
+						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 */
+	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]);	  
+		state_status = get_status(status_num, 3);
+		state_want = get_status(status_num, 1);
+
+		if (state_status == search_name_hashtable("installed")) {
+			i++;
+			continue;
+		}
+
+		for (j = 0; j < package_hashtable[deb_file[i]->package]->num_of_edges; j++) {
+			const edge_t *package_edge = package_node->edge[j];
+			unsigned int package_num;
+
+			package_num = search_package_hashtable(package_edge->name, package_edge->version, package_edge->operator);
+
+			switch (package_edge->type) {
+				case(EDGE_PRE_DEPENDS):
+				case(EDGE_OR_PRE_DEPENDS): {
+					int result=1;
+					/* It must be already installed */
+					/* NOTE: This is untested, nothing apropriate in my status file */
+					if (package_hashtable[package_num] != NULL) {
+						status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
+						state_status = get_status(status_num, 3);
+						state_want = get_status(status_num, 1);
+						result = (state_status != search_name_hashtable("installed"));
+					}
+
+					if (result) {
+						bb_error_msg_and_die("Package %s pre-depends on %s, but it is not installed",
+							name_hashtable[package_node->name],
+							name_hashtable[package_edge->name]);
+					}
+					break;
+				}
+				case(EDGE_DEPENDS):
+				case(EDGE_OR_DEPENDS): {
+					int result=1;
+					if (package_hashtable[package_num] != NULL) {
+						status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
+						state_status = get_status(status_num, 3);
+						state_want = get_status(status_num, 1);
+						result=(state_status != search_name_hashtable("installed")) && (state_want != search_name_hashtable("want-install"));
+					}
+					/* It must be already installed, or to be installed */
+					if (result) {
+						bb_error_msg_and_die("Package %s depends on %s, but it is not installed, or flaged to be installed",
+							name_hashtable[package_node->name],
+							name_hashtable[package_edge->name]);
+					}
+					break;
+				}
+			}
+		}
+		i++;
+	}
+	free(conflicts);
+	return(TRUE);
+}
+
+char **create_list(const char *filename)
+{
+	FILE *list_stream;
+	char **file_list = NULL;
+	char *line = NULL;
+	int count = 0;
+
+	/* dont 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);
+}
+
+char **all_control_list(const char *package_name)
+{
+	const char *extensions[11] = {"preinst", "postinst", "prerm", "postrm",
+		"list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL };
+	unsigned short i = 0;
+	char **remove_files;
+
+	/* Create a list of all /var/lib/dpkg/info/<package> files */
+	remove_files = malloc(sizeof(char *) * 11);
+	while (extensions[i]) {
+		remove_files[i] = xmalloc(strlen(package_name) + strlen(extensions[i]) + 21);
+		sprintf(remove_files[i], "/var/lib/dpkg/info/%s.%s", package_name, extensions[i]);
+		i++;
+	}
+	remove_files[10] = 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)
+{
+	const char *package_name = name_hashtable[package_hashtable[package_num]->name];
+	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;
+
+	printf("Removing %s ...\n", package_name);
+
+	/* 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 seperate 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, "deinstall", 1);
+	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 unsigned int status_num = search_status_hashtable(package_name);
+	char **remove_files;
+	char **exclude_files;
+	char list_name[strlen(package_name) + 25];
+
+	/* 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, "purge", 1);
+	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->filter = filter_accept_list;
+	tar_handle->src_fd = ar_handle->src_fd;
+
+	/* We dont 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->filter = filter_accept_all;
+	tar_handle->src_fd = ar_handle->src_fd;
+
+	/* We dont care about data.tar.* or debian-binary, just control.tar.* */
+#ifdef CONFIG_FEATURE_DEB_TAR_GZ
+	tar_handle->accept = llist_add_to(NULL, "data.tar.gz");
+#endif
+#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+	tar_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 *accept)
+{
+	ar_handle->sub_archive->action_data = data_extract_to_buffer;
+	ar_handle->sub_archive->accept = accept;
+
+	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;
+
+	/* 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);
+	} 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);
+	archive_handle->sub_archive->action_data = data_extract_all_prefix;
+	archive_handle->sub_archive->buffer = info_prefix;
+	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);
+	unpack_ar_archive(archive_handle);
+
+	/* Create the list file */
+	strcat(info_prefix, "list");
+	out_stream = bb_xfopen(info_prefix, "w");			
+	while (archive_handle->passed) {
+		/* blindly skip over the leading '.' */
+		fputs(archive_handle->passed->data + 1, out_stream);
+		fputc('\n', out_stream);
+		archive_handle->passed = archive_handle->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;
+				}				
+			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)) {
+				status_node = (status_node_t *) xmalloc(sizeof(status_node_t));
+				status_node->package = deb_file[deb_count]->package;
+				/* 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)) {
+					/* reinstreq isnt changed to "ok" until the package control info
+					 * is written to the status file*/
+					status_node->status = search_name_hashtable("want-install reinstreq not-installed");
+					status_hashtable[status_num] = status_node;
+				} else {
+					status_hashtable[status_num]->status = search_name_hashtable("want-install reinstreq not-installed");
+				}
+			}
+		}
+		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]);
+			}
+			state_status = get_status(search_status_hashtable(name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]), 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[deb_file[deb_count]->package]->name]);
+				}
+			}
+			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[deb_file[deb_count]->package]->name]);
+				}
+			}
+		}
+		deb_count++;
+		optind++;
+	}
+	deb_file[deb_count] = NULL;
+
+	/* Check that the deb file arguments are installable */
+	/* TODO: check dependencies before removing */
+	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");
+		}
+	}
+
+	for (i = 0; i < deb_count; i++) {
+		/* Remove or purge packages */
+		if (dpkg_opt & dpkg_opt_remove) {
+			remove_package(deb_file[i]->package);
+		}
+		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]);
+			configure_package(deb_file[i]);
+		}
+		else if (dpkg_opt & dpkg_opt_configure) {
+			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/release/src/router/busybox/archival/dpkg_deb.c b/release/src/router/busybox/archival/dpkg_deb.c
new file mode 100644
index 00000000..2d7383fd
--- /dev/null
+++ b/release/src/router/busybox/archival/dpkg_deb.c
@@ -0,0 +1,107 @@
+/*
+ *  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"
+
+extern int dpkg_deb_main(int argc, char **argv)
+{
+	archive_handle_t *ar_archive;
+	archive_handle_t *tar_archive;
+	int opt = 0;
+#ifndef CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY
+	llist_t *control_tar_llist = NULL;
+#endif
+	
+	/* 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");
+# ifndef CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY
+	control_tar_llist = llist_add_to(NULL, "control.tar.gz");
+# endif
+#endif
+
+#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+	ar_archive->accept = llist_add_to(ar_archive->accept, "data.tar.bz2");
+# ifndef CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY
+	control_tar_llist = llist_add_to(control_tar_llist, "control.tar.bz2");
+# endif
+#endif
+
+#ifndef CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY
+	while ((opt = getopt(argc, argv, "cefXx")) != -1) {
+#else
+	while ((opt = getopt(argc, argv, "x")) != -1) {
+#endif
+		switch (opt) {
+#ifndef CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY
+			case 'c':
+				tar_archive->action_header = header_verbose_list;
+				break;
+			case 'e':
+				ar_archive->accept = control_tar_llist;
+				tar_archive->action_data = data_extract_all;
+				break;
+			case 'f':
+				/* 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;
+				break;
+			case 'X':
+				tar_archive->action_header = header_list;
+#endif
+			case 'x':
+				tar_archive->action_data = data_extract_all;
+				break;
+			default:
+				bb_show_usage();
+		}
+	}
+
+	if (optind + 2 < argc)  {
+		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 */
+	mkdir(argv[optind], 0777);
+	chdir(argv[optind]);
+
+	unpack_ar_archive(ar_archive);
+
+	/* Cleanup */
+	close (ar_archive->src_fd);
+
+	return(EXIT_SUCCESS);
+}
+
diff --git a/release/src/router/busybox/archival/gunzip.c b/release/src/router/busybox/archival/gunzip.c
new file mode 100644
index 00000000..7d382b89
--- /dev/null
+++ b/release/src/router/busybox/archival/gunzip.c
@@ -0,0 +1,216 @@
+/* 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@optushome.com.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"
+
+const char gunzip_to_stdout = 1;
+const char gunzip_force = 2;
+const char gunzip_test = 4;
+
+extern int gunzip_main(int argc, char **argv)
+{
+	char status = EXIT_SUCCESS;
+	char flags = 0;
+	int opt;
+
+	/* if called as zcat */
+	if (strcmp(bb_applet_name, "zcat") == 0) {
+		flags |= gunzip_to_stdout;
+	}
+
+	while ((opt = getopt(argc, argv, "ctfhd")) != -1) {
+		switch (opt) {
+		case 'c':
+			flags |= gunzip_to_stdout;
+			break;
+		case 'f':
+			flags |= gunzip_force;
+			break;
+		case 't':
+			flags |= gunzip_test;
+			break;
+		case 'd':		/* Used to convert gzip to gunzip. */
+			break;
+		default:
+			bb_show_usage();	/* exit's inside usage */
+		}
+	}
+
+	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 = fileno(stdin);
+			flags |= gunzip_to_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) && ((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_test) {
+			dst_fd = bb_xopen("/dev/null", O_WRONLY);	/* why does test use filenum 2 ? */
+		} else if (flags & gunzip_to_stdout) {
+			dst_fd = fileno(stdout);
+		} 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(src_fd, dst_fd);
+					if (status != 0) {
+						bb_error_msg_and_die("Error inflating");
+					}
+					check_trailer_gzip(src_fd);
+				} 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 != fileno(stdout)) {
+			close(dst_fd);
+		}
+		if (src_fd != fileno(stdin)) {
+			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/release/src/router/busybox/archival/gzip.c b/release/src/router/busybox/archival/gzip.c
new file mode 100644
index 00000000..bc4c7bad
--- /dev/null
+++ b/release/src/router/busybox/archival/gzip.c
@@ -0,0 +1,2551 @@
+/* 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 crc_table_empty = 1;
+
+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_table_empty) {
+		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. */
+		crc_32_tab[0] = 0x00000000L;
+		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.
+ *
+ *  ACKNOWLEDGEMENTS
+ *
+ *      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/release/src/router/busybox/archival/libunarchive/Makefile b/release/src/router/busybox/archival/libunarchive/Makefile
new file mode 100644
index 00000000..272ca243
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/Makefile
@@ -0,0 +1,30 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 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
+#
+
+TOPDIR:= ../../
+LIBUNARCHIVE_DIR:=./
+include $(TOPDIR).config
+include $(TOPDIR)Rules.mak
+include Makefile.in
+all: $(libraries-y)
+-include $(TOPDIR).depend
+
+clean:
+	rm -f *.o *.a $(AR_TARGET)
+
diff --git a/release/src/router/busybox/archival/libunarchive/Makefile.in b/release/src/router/busybox/archival/libunarchive/Makefile.in
new file mode 100755
index 00000000..2b32aaa5
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/Makefile.in
@@ -0,0 +1,79 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 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:=$(TOPDIR)archival/libunarchive/
+endif
+
+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_list_reassign.o \
+	filter_accept_reject_list.o \
+\
+	get_header_ar.o \
+	get_header_cpio.o \
+	get_header_tar.o \
+	get_header_tar_bz2.o \
+	get_header_tar_gz.o \
+\
+	header_skip.o \
+	header_list.o \
+	header_verbose_list.o \
+\
+	archive_xread.o \
+	archive_xread_all.o \
+	archive_xread_all_eof.o \
+	archive_xread_char.o \
+\
+	seek_by_char.o \
+	seek_by_jump.o \
+\
+	archive_copy_file.o \
+\
+	check_header_gzip.o \
+	data_align.o \
+	decompress_bunzip2.o \
+	find_list_entry.o \
+	init_handle.o \
+	uncompress.o \
+	unpack_ar_archive.o \
+	unzip.o
+
+LIBUNARCHIVE-$(CONFIG_DPKG) += 
+LIBUNARCHIVE-$(CONFIG_DPKG_DEB) += 
+LIBUNARCHIVE-$(CONFIG_AR) += 
+LIBUNARCHIVE-$(CONFIG_CPIO) += 
+LIBUNARCHIVE-$(CONFIG_GUNZIP) += 
+LIBUNARCHIVE-$(CONFIG_RPM2CPIO) += 
+LIBUNARCHIVE-$(CONFIG_TAR) += 
+LIBUNARCHIVE-$(CONFIG_UNZIP) += 
+
+libraries-y+=$(LIBUNARCHIVE_DIR)$(LIBUNARCHIVE_AR)
+
+$(LIBUNARCHIVE_DIR)$(LIBUNARCHIVE_AR): $(patsubst %,$(LIBUNARCHIVE_DIR)%, $(LIBUNARCHIVE-y))
+	$(AR) -ro $@ $(patsubst %,$(LIBUNARCHIVE_DIR)%, $(LIBUNARCHIVE-y))
+
diff --git a/release/src/router/busybox/archival/libunarchive/archive_copy_file.c b/release/src/router/busybox/archival/libunarchive/archive_copy_file.c
new file mode 100644
index 00000000..675bc6ff
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/archive_copy_file.c
@@ -0,0 +1,44 @@
+/*
+ *  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 "libbb.h"
+#include "unarchive.h"
+
+extern void archive_copy_file(const archive_handle_t *archive_handle, const int dst_fd)
+{
+	char buffer[512];
+	off_t chunksize = archive_handle->file_header->size;
+
+	while (chunksize != 0) {
+		size_t size;
+		if (chunksize > 512) {
+			size = 512;
+		} else {
+			size = chunksize;
+		}
+//		archive_xread_all(archive_handle, buffer, size);
+		size = archive_xread(archive_handle, buffer, size);
+
+		if (write(dst_fd, buffer, size) != size) {
+			bb_error_msg_and_die ("Short write");
+		}
+		chunksize -= size;
+	}
+
+	return;
+}
diff --git a/release/src/router/busybox/archival/libunarchive/archive_xread.c b/release/src/router/busybox/archival/libunarchive/archive_xread.c
new file mode 100644
index 00000000..d63d0d5a
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/archive_xread.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 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(const archive_handle_t *archive_handle, unsigned char *buf, const size_t count)
+{
+	ssize_t size;
+
+	size = archive_handle->read(archive_handle->src_fd, buf, count);
+	if (size < 0) {
+		bb_perror_msg_and_die("Read error");
+	}
+
+	return(size);
+}
diff --git a/release/src/router/busybox/archival/libunarchive/archive_xread_all.c b/release/src/router/busybox/archival/libunarchive/archive_xread_all.c
new file mode 100644
index 00000000..cfe046b2
--- /dev/null
+++ b/release/src/router/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 = archive_xread(archive_handle, buf, count);
+	if (size != count) {
+		bb_error_msg_and_die("Short read");
+	}
+	return;
+}
diff --git a/release/src/router/busybox/archival/libunarchive/archive_xread_all_eof.c b/release/src/router/busybox/archival/libunarchive/archive_xread_all_eof.c
new file mode 100644
index 00000000..23719cd7
--- /dev/null
+++ b/release/src/router/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 = archive_xread(archive_handle, 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/release/src/router/busybox/archival/libunarchive/archive_xread_char.c b/release/src/router/busybox/archival/libunarchive/archive_xread_char.c
new file mode 100644
index 00000000..4c665e15
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/archive_xread_char.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 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 unsigned char archive_xread_char(const archive_handle_t *archive_handle)
+{
+	unsigned char tmp;
+	
+	archive_xread(archive_handle, &tmp, 1);
+
+	return(tmp);
+}
diff --git a/release/src/router/busybox/archival/libunarchive/check_header_gzip.c b/release/src/router/busybox/archival/libunarchive/check_header_gzip.c
new file mode 100644
index 00000000..13832c24
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/data_align.c b/release/src/router/busybox/archival/libunarchive/data_align.c
new file mode 100644
index 00000000..037242f2
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/data_align.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 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/release/src/router/busybox/archival/libunarchive/data_extract_all.c b/release/src/router/busybox/archival/libunarchive/data_extract_all.c
new file mode 100644
index 00000000..bd264dd7
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/data_extract_all.c
@@ -0,0 +1,100 @@
+/*
+ *  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), 0777, FILEUTILS_RECUR);
+		free(name);
+	}                  
+
+	/* Create the filesystem entry */
+	switch(file_header->mode & S_IFMT) {
+		case S_IFREG: {
+#ifdef CONFIG_CPIO
+			if (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
+#endif
+			{
+				/* Regular file */
+				unlink(file_header->name);
+				dst_fd = bb_xopen(file_header->name, O_WRONLY | O_CREAT | O_EXCL);
+				archive_copy_file(archive_handle, dst_fd);
+				close(dst_fd);
+			}
+			break;
+		}
+		case S_IFDIR:
+			unlink(file_header->name);
+			res = mkdir(file_header->name, file_header->mode);
+			if ((res == -1) && !(archive_handle->flags & ARCHIVE_EXTRACT_QUIET)) {
+				bb_perror_msg("extract_archive: %s", file_header->name);
+			}
+			break;
+		case S_IFLNK:
+			/* Symlink */
+			unlink(file_header->name);
+			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:
+			unlink(file_header->name);
+			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");
+	}
+
+	chmod(file_header->name, file_header->mode);
+	chown(file_header->name, file_header->uid, file_header->gid);
+
+	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/release/src/router/busybox/archival/libunarchive/data_extract_to_buffer.c b/release/src/router/busybox/archival/libunarchive/data_extract_to_buffer.c
new file mode 100644
index 00000000..db5521bc
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/data_extract_to_stdout.c b/release/src/router/busybox/archival/libunarchive/data_extract_to_stdout.c
new file mode 100644
index 00000000..8be2fa2e
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/data_extract_to_stdout.c
@@ -0,0 +1,22 @@
+/*
+ *  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"
+
+extern void data_extract_to_stdout(archive_handle_t *archive_handle)
+{
+	archive_copy_file(archive_handle, fileno(stdout));
+}
diff --git a/release/src/router/busybox/archival/libunarchive/data_skip.c b/release/src/router/busybox/archival/libunarchive/data_skip.c
new file mode 100644
index 00000000..b82c9065
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/decompress_bunzip2.c b/release/src/router/busybox/archival/libunarchive/decompress_bunzip2.c
new file mode 100644
index 00000000..0164b77e
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/decompress_bunzip2.c
@@ -0,0 +1,1658 @@
+/*--
+  This file is a part of bzip2 and/or libbzip2, a program and
+  library for lossless, block-sorting data compression.
+
+  Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. The origin of this software must not be misrepresented; you must 
+     not claim that you wrote the original software.  If you use this 
+     software in a product, an acknowledgment in the product 
+     documentation would be appreciated but is not required.
+
+  3. Altered source versions must be plainly marked as such, and must
+     not be misrepresented as being the original software.
+
+  4. The name of the author may not be used to endorse or promote 
+     products derived from this software without specific prior written 
+     permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  Julian Seward, Cambridge, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 1.0 of 21 March 2000
+
+  This program is based on (at least) the work of:
+     Mike Burrows
+     David Wheeler
+     Peter Fenwick
+     Alistair Moffat
+     Radford Neal
+     Ian H. Witten
+     Robert Sedgewick
+     Jon L. Bentley
+
+  For more information on these sources, see the manual.
+--*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <getopt.h>
+#include <unistd.h>
+
+#include "busybox.h"
+
+#define MTFA_SIZE 4096
+#define MTFL_SIZE 16
+#define BZ_N_GROUPS 6
+#define BZ_G_SIZE   50
+#define BZ_MAX_ALPHA_SIZE 258
+
+#define BZ_OK                0
+#define BZ_STREAM_END        4
+#define BZ_SEQUENCE_ERROR    (-1)
+#define BZ_DATA_ERROR        (-4)
+#define BZ_DATA_ERROR_MAGIC  (-5)
+#define BZ_IO_ERROR          (-6)
+#define BZ_UNEXPECTED_EOF    (-7)
+
+#define BZ_RUNA 0
+#define BZ_RUNB 1
+
+#define BZ_MAX_UNUSED 5000
+#define FILE_NAME_LEN 1034
+/*-- states for decompression. --*/
+
+#define BZ_X_IDLE        1
+#define BZ_X_OUTPUT      2
+
+#define BZ_X_MAGIC_1     10
+#define BZ_X_MAGIC_2     11
+#define BZ_X_MAGIC_3     12
+#define BZ_X_MAGIC_4     13
+#define BZ_X_BLKHDR_1    14
+#define BZ_X_BLKHDR_2    15
+#define BZ_X_BLKHDR_3    16
+#define BZ_X_BLKHDR_4    17
+#define BZ_X_BLKHDR_5    18
+#define BZ_X_BLKHDR_6    19
+#define BZ_X_BCRC_1      20
+#define BZ_X_BCRC_2      21
+#define BZ_X_BCRC_3      22
+#define BZ_X_BCRC_4      23
+#define BZ_X_RANDBIT     24
+#define BZ_X_ORIGPTR_1   25
+#define BZ_X_ORIGPTR_2   26
+#define BZ_X_ORIGPTR_3   27
+#define BZ_X_MAPPING_1   28
+#define BZ_X_MAPPING_2   29
+#define BZ_X_SELECTOR_1  30
+#define BZ_X_SELECTOR_2  31
+#define BZ_X_SELECTOR_3  32
+#define BZ_X_CODING_1    33
+#define BZ_X_CODING_2    34
+#define BZ_X_CODING_3    35
+#define BZ_X_MTF_1       36
+#define BZ_X_MTF_2       37
+#define BZ_X_MTF_3       38
+#define BZ_X_MTF_4       39
+#define BZ_X_MTF_5       40
+#define BZ_X_MTF_6       41
+#define BZ_X_ENDHDR_2    42
+#define BZ_X_ENDHDR_3    43
+#define BZ_X_ENDHDR_4    44
+#define BZ_X_ENDHDR_5    45
+#define BZ_X_ENDHDR_6    46
+#define BZ_X_CCRC_1      47
+#define BZ_X_CCRC_2      48
+#define BZ_X_CCRC_3      49
+#define BZ_X_CCRC_4      50
+
+#define BZ_MAX_CODE_LEN    23
+#define OM_TEST          3
+
+typedef struct {
+	char *next_in;
+	unsigned int avail_in;
+
+	char *next_out;
+	unsigned int avail_out;
+
+	void *state;
+
+} bz_stream;
+
+#define BZ_MAX_UNUSED 5000
+typedef struct {
+	bz_stream	strm;
+	int			fd;
+    unsigned char	initialisedOk;
+	char	buf[BZ_MAX_UNUSED];
+	int		lastErr;
+	int		bufN;
+} bzFile;
+
+/*-- Structure holding all the decompression-side stuff. --*/
+typedef struct {
+	/* pointer back to the struct bz_stream */
+	bz_stream* strm;
+
+	/* state indicator for this stream */
+	int	state;
+
+	/* for doing the final run-length decoding */
+	unsigned char    state_out_ch;
+	int    state_out_len;
+	unsigned char     blockRandomised;
+	int rNToGo;
+	int rTPos;
+
+	/* the buffer for bit stream reading */
+	unsigned int   bsBuff;
+	int    bsLive;
+
+	/* misc administratium */
+	int    blockSize100k;
+	int    currBlockNo;
+
+	/* for undoing the Burrows-Wheeler transform */
+	int    origPtr;
+	unsigned int   tPos;
+	int    k0;
+	int    unzftab[256];
+	int    nblock_used;
+	int    cftab[257];
+	int    cftabCopy[257];
+
+	/* for undoing the Burrows-Wheeler transform (FAST) */
+	unsigned int *tt;
+
+	/* stored and calculated CRCs */
+	unsigned int   storedBlockCRC;
+	unsigned int   storedCombinedCRC;
+	unsigned int   calculatedBlockCRC;
+	unsigned int   calculatedCombinedCRC;
+
+	/* map of bytes used in block */
+	int    nInUse;
+	unsigned char     inUse[256];
+	unsigned char     inUse16[16];
+	unsigned char    seqToUnseq[256];
+
+	/* for decoding the MTF values */
+	unsigned char    mtfa   [MTFA_SIZE];
+	unsigned char    selector   [2 + (900000 / BZ_G_SIZE)];
+	unsigned char    selectorMtf[2 + (900000 / BZ_G_SIZE)];
+	unsigned char    len  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    mtfbase[256 / MTFL_SIZE];
+
+	int    limit  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    base   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    perm   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    minLens[BZ_N_GROUPS];
+
+	/* save area for scalars in the main decompress code */
+	int    save_i;
+	int    save_j;
+	int    save_t;
+	int    save_alphaSize;
+	int    save_nGroups;
+	int    save_nSelectors;
+	int    save_EOB;
+	int    save_groupNo;
+	int    save_groupPos;
+	int    save_nextSym;
+	int    save_nblockMAX;
+	int    save_nblock;
+	int    save_es;
+	int    save_N;
+	int    save_curr;
+	int    save_zt;
+	int    save_zn; 
+	int    save_zvec;
+	int    save_zj;
+	int    save_gSel;
+	int    save_gMinlen;
+	int	*save_gLimit;
+	int	*save_gBase;
+	int	*save_gPerm;
+} DState;
+
+static int BZ2_rNums[512];
+static bzFile *bzf;
+static int bzerr = BZ_OK;
+
+static const unsigned int BZ2_crc32Table[256] = {
+
+   /*-- Ugly, innit? --*/
+
+   0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
+   0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
+   0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
+   0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
+   0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
+   0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
+   0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
+   0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
+   0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
+   0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
+   0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
+   0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
+   0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
+   0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
+   0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
+   0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
+   0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
+   0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
+   0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
+   0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
+   0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
+   0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
+   0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
+   0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
+   0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
+   0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
+   0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
+   0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
+   0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
+   0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
+   0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
+   0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
+   0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
+   0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
+   0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
+   0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
+   0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
+   0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
+   0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
+   0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
+   0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
+   0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
+   0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
+   0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
+   0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
+   0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
+   0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
+   0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
+   0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
+   0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
+   0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
+   0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
+   0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
+   0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
+   0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
+   0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
+   0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
+   0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
+   0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
+   0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
+   0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
+   0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
+   0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
+   0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
+};
+
+static void bz_rand_udp_mask(DState *s)
+{
+	if (s->rNToGo == 0) {
+		s->rNToGo = BZ2_rNums[s->rTPos];
+		s->rTPos++;
+		if (s->rTPos == 512) {
+			s->rTPos = 0;
+		}
+	}
+	s->rNToGo--;
+}
+
+static void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize )
+{
+	int pp, i, j, vec;
+
+	pp = 0;
+	for (i = minLen; i <= maxLen; i++) {
+		for (j = 0; j < alphaSize; j++) {
+			if (length[j] == i) {
+				perm[pp] = j;
+				pp++;
+			}
+		}
+	}
+
+	for (i = 0; i < BZ_MAX_CODE_LEN; i++) {
+		base[i] = 0;
+	}
+
+	for (i = 0; i < alphaSize; i++) {
+		base[length[i]+1]++;
+	}
+
+	for (i = 1; i < BZ_MAX_CODE_LEN; i++) {
+		base[i] += base[i-1];
+	}
+
+	for (i = 0; i < BZ_MAX_CODE_LEN; i++) {
+		limit[i] = 0;
+	}
+	vec = 0;
+
+	for (i = minLen; i <= maxLen; i++) {
+		vec += (base[i+1] - base[i]);
+		limit[i] = vec-1;
+		vec <<= 1;
+	}
+	for (i = minLen + 1; i <= maxLen; i++) {
+		base[i] = ((limit[i-1] + 1) << 1) - base[i];
+	}
+}
+
+
+static int get_bits(DState *s, int *vvv, char nnn)
+{
+	while (1) {
+		if (s->bsLive >= nnn) {
+			*vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1);
+			s->bsLive -= nnn;
+			break;
+		}
+		if (s->strm->avail_in == 0) {
+			return(FALSE);
+		}
+		s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in))));
+		s->bsLive += 8;
+		s->strm->next_in++;
+		s->strm->avail_in--;
+	}
+	return(TRUE);
+}
+
+static int bz_get_fast(DState *s)
+{
+	int cccc;
+	s->tPos = s->tt[s->tPos];
+	cccc = (unsigned char)(s->tPos & 0xff);
+	s->tPos >>= 8;
+	return(cccc);
+}
+
+/*---------------------------------------------------*/
+static inline int BZ2_decompress(DState *s)
+{
+	int uc = 0;
+	int	retVal;
+	int	minLen,	maxLen;
+
+	/* stuff that needs to be saved/restored */
+	int  i;
+	int  j;
+	int  t;
+	int  alphaSize;
+	int  nGroups;
+	int  nSelectors;
+	int  EOB;
+	int  groupNo;
+	int  groupPos;
+	int  nextSym;
+	int  nblockMAX;
+	int  nblock;
+	int  es;
+	int  N;
+	int  curr;
+	int  zt;
+	int  zn; 
+	int  zvec;
+	int  zj;
+	int  gSel;
+	int  gMinlen;
+	int *gLimit;
+	int *gBase;
+	int *gPerm;
+	int switch_val;
+
+	int get_mtf_val_init(void)
+	{
+		if (groupPos == 0) {
+			groupNo++;
+			if (groupNo >= nSelectors) {
+				retVal = BZ_DATA_ERROR;
+				return(FALSE);
+			}
+			groupPos = BZ_G_SIZE;
+			gSel = s->selector[groupNo];
+			gMinlen = s->minLens[gSel];
+			gLimit = &(s->limit[gSel][0]);
+			gPerm = &(s->perm[gSel][0]);
+			gBase = &(s->base[gSel][0]);
+		}
+		groupPos--;
+		zn = gMinlen;
+		return(TRUE);
+	}
+
+	if (s->state == BZ_X_MAGIC_1) {
+		/*initialise the save area*/
+		s->save_i           = 0;
+		s->save_j           = 0;
+		s->save_t           = 0;
+		s->save_alphaSize   = 0;
+		s->save_nGroups     = 0;
+		s->save_nSelectors  = 0;
+		s->save_EOB         = 0;
+		s->save_groupNo     = 0;
+		s->save_groupPos    = 0;
+		s->save_nextSym     = 0;
+		s->save_nblockMAX   = 0;
+		s->save_nblock      = 0;
+		s->save_es          = 0;
+		s->save_N           = 0;
+		s->save_curr        = 0;
+		s->save_zt          = 0;
+		s->save_zn          = 0;
+		s->save_zvec        = 0;
+		s->save_zj          = 0;
+		s->save_gSel        = 0;
+		s->save_gMinlen     = 0;
+		s->save_gLimit      = NULL;
+		s->save_gBase       = NULL;
+		s->save_gPerm       = NULL;
+	}
+
+	/*restore from the save area*/
+	i           = s->save_i;
+	j           = s->save_j;
+	t           = s->save_t;
+	alphaSize   = s->save_alphaSize;
+	nGroups     = s->save_nGroups;
+	nSelectors  = s->save_nSelectors;
+	EOB         = s->save_EOB;
+	groupNo     = s->save_groupNo;
+	groupPos    = s->save_groupPos;
+	nextSym     = s->save_nextSym;
+	nblockMAX   = s->save_nblockMAX;
+	nblock      = s->save_nblock;
+	es          = s->save_es;
+	N           = s->save_N;
+	curr        = s->save_curr;
+	zt          = s->save_zt;
+	zn          = s->save_zn; 
+	zvec        = s->save_zvec;
+	zj          = s->save_zj;
+	gSel        = s->save_gSel;
+	gMinlen     = s->save_gMinlen;
+	gLimit      = s->save_gLimit;
+	gBase       = s->save_gBase;
+	gPerm       = s->save_gPerm;
+
+	retVal = BZ_OK;
+	switch_val = s->state;
+	switch (switch_val) {
+		case BZ_X_MAGIC_1:
+			s->state = BZ_X_MAGIC_1;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'B') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_2:
+			s->state = BZ_X_MAGIC_2;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'Z') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_3:
+			s->state = BZ_X_MAGIC_3;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'h') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_4:
+			s->state = BZ_X_MAGIC_4;
+			if (! get_bits(s, &s->blockSize100k, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+			s->blockSize100k -= '0';
+
+			s->tt = xmalloc(s->blockSize100k * 100000 * sizeof(int));
+
+		case BZ_X_BLKHDR_1:
+			s->state = BZ_X_BLKHDR_1;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+
+			if (uc == 0x17) {
+				goto endhdr_2;
+			}
+			if (uc != 0x31) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_2:
+			s->state = BZ_X_BLKHDR_2;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x41) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_3:
+			s->state = BZ_X_BLKHDR_3;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x59) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_4:
+			s->state = BZ_X_BLKHDR_4;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x26) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_5:
+			s->state = BZ_X_BLKHDR_5;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x53) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_6:
+			s->state = BZ_X_BLKHDR_6;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x59) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		s->currBlockNo++;
+		s->storedBlockCRC = 0;
+
+		case BZ_X_BCRC_1:
+			s->state = BZ_X_BCRC_1;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_2:
+			s->state = BZ_X_BCRC_2;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_3:
+			s->state = BZ_X_BCRC_3;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_4:
+			s->state = BZ_X_BCRC_4;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_RANDBIT:
+			s->state = BZ_X_RANDBIT;
+			{
+				int tmp = s->blockRandomised;
+				const int ret = get_bits(s, &tmp, 1);
+				s->blockRandomised = tmp;
+				if (! ret) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+			}
+
+			s->origPtr = 0;
+
+		case BZ_X_ORIGPTR_1:
+			s->state = BZ_X_ORIGPTR_1;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+		case BZ_X_ORIGPTR_2:
+			s->state = BZ_X_ORIGPTR_2;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+		case BZ_X_ORIGPTR_3:
+			s->state = BZ_X_ORIGPTR_3;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+			if (s->origPtr < 0) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			if (s->origPtr > 10 + 100000*s->blockSize100k) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+			/*--- Receive the mapping table ---*/
+		case BZ_X_MAPPING_1:
+			for (i = 0; i < 16; i++) {
+				s->state = BZ_X_MAPPING_1;
+				if (! get_bits(s, &uc, 1)) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+				if (uc == 1) {
+					s->inUse16[i] = TRUE;
+				} else {
+					s->inUse16[i] = FALSE;
+				}
+			}
+
+			for (i = 0; i < 256; i++) {
+				s->inUse[i] = FALSE;
+			}
+
+			for (i = 0; i < 16; i++) {
+				if (s->inUse16[i]) {
+					for (j = 0; j < 16; j++) {
+					case BZ_X_MAPPING_2:
+						s->state = BZ_X_MAPPING_2;
+						if (! get_bits(s, &uc, 1)) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 1) {
+							s->inUse[i * 16 + j] = TRUE;
+						}
+					}
+				}
+			}
+
+			s->nInUse = 0;
+			for (i = 0; i < 256; i++) {
+				if (s->inUse[i]) {
+					s->seqToUnseq[s->nInUse] = i;
+					s->nInUse++;
+				}
+			}
+			if (s->nInUse == 0) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			alphaSize = s->nInUse+2;
+
+		/*--- Now the selectors ---*/
+		case BZ_X_SELECTOR_1:
+			s->state = BZ_X_SELECTOR_1;
+			if (! get_bits(s, &nGroups, 3)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (nGroups < 2 || nGroups > 6) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_SELECTOR_2:
+			s->state = BZ_X_SELECTOR_2;
+			if (! get_bits(s, &nSelectors, 15)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (nSelectors < 1) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+
+
+			for (i = 0; i < nSelectors; i++) {
+				j = 0;
+				while (1) {
+					case BZ_X_SELECTOR_3:
+					s->state = BZ_X_SELECTOR_3;
+					if (! get_bits(s, &uc, 1)) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					if (uc == 0) {
+						break;
+					}
+					j++;
+					if (j >= nGroups) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+				}
+				s->selectorMtf[i] = j;
+			}
+
+			/*--- Undo the MTF values for the selectors. ---*/
+			{
+				unsigned char pos[BZ_N_GROUPS], tmp, v;
+				for (v = 0; v < nGroups; v++) {
+					pos[v] = v;
+				}
+				for (i = 0; i < nSelectors; i++) {
+					v = s->selectorMtf[i];
+					tmp = pos[v];
+					while (v > 0) {
+						pos[v] = pos[v-1];
+						v--;
+					}
+					pos[0] = tmp;
+					s->selector[i] = tmp;
+				}
+			}
+
+			/*--- Now the coding tables ---*/
+			for (t = 0; t < nGroups; t++) {
+			case BZ_X_CODING_1:
+				s->state = BZ_X_CODING_1;
+				if (! get_bits(s, &curr, 5)) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+			for (i = 0; i < alphaSize; i++) {
+				while (TRUE) {
+					if (curr < 1 || curr > 20) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+
+					case BZ_X_CODING_2:
+						s->state = BZ_X_CODING_2;
+						if (! get_bits(s, &uc, 1)) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 0) {
+							break;
+						}
+
+					case BZ_X_CODING_3:
+						s->state = BZ_X_CODING_3;
+						if (! get_bits(s, &uc, 1)) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 0) {
+							curr++;
+						} else {
+							curr--;
+						}
+				}
+				s->len[t][i] = curr;
+			}
+		}
+
+		/*--- Create the Huffman decoding tables ---*/
+		for (t = 0; t < nGroups; t++) {
+			minLen = 32;
+			maxLen = 0;
+			for (i = 0; i < alphaSize; i++) {
+				if (s->len[t][i] > maxLen) {
+					maxLen = s->len[t][i];
+				}
+				if (s->len[t][i] < minLen) {
+					minLen = s->len[t][i];
+				}
+			}
+
+			BZ2_hbCreateDecodeTables ( 
+				&(s->limit[t][0]), 
+				&(s->base[t][0]), 
+				&(s->perm[t][0]), 
+				&(s->len[t][0]),
+				minLen, maxLen, alphaSize
+				);
+
+
+			s->minLens[t] = minLen;
+		}
+
+		/*--- Now the MTF values ---*/
+
+		EOB      = s->nInUse+1;
+		nblockMAX = 100000 * s->blockSize100k;
+		groupNo  = -1;
+		groupPos = 0;
+
+		for (i = 0; i <= 255; i++) {
+			s->unzftab[i] = 0;
+		}
+		/*-- MTF init --*/
+		{
+			int ii, jj, kk;
+			kk = MTFA_SIZE-1;
+			for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
+				for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
+					s->mtfa[kk] = (unsigned char)(ii * MTFL_SIZE + jj);
+					kk--;
+				}
+				s->mtfbase[ii] = kk + 1;
+			}
+		}
+		/*-- end MTF init --*/
+
+		nblock = 0;
+
+		if (! get_mtf_val_init()) {
+			goto save_state_and_return;
+		}
+		case BZ_X_MTF_1:
+			s->state = BZ_X_MTF_1;
+			if (! get_bits(s, &zvec, zn)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			while (1) {
+				if (zn > 20 /* the longest code */) {
+					retVal = BZ_DATA_ERROR;
+					goto save_state_and_return;
+				}
+				if (zvec <= gLimit[zn]) {
+					break;
+				}
+				zn++;
+
+				case BZ_X_MTF_2:
+					s->state = BZ_X_MTF_2;
+					if (! get_bits(s, &zj, 1)) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					zvec = (zvec << 1) | zj;
+			}
+			if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			nextSym = gPerm[zvec - gBase[zn]];
+
+		while (1) {
+			if (nextSym == EOB) {
+				break;
+			}
+
+		if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
+			es = -1;
+			N = 1;
+			do {
+				if (nextSym == BZ_RUNA) {
+					es = es + (0+1) * N;
+				} else {
+					if (nextSym == BZ_RUNB) {
+						es = es + (1+1) * N;
+					}
+				}
+				N = N * 2;
+				if (! get_mtf_val_init()) {
+					goto save_state_and_return;
+				}
+				case BZ_X_MTF_3:
+					s->state = BZ_X_MTF_3;
+					if (! get_bits(s, &zvec, zn)) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					while (1) {
+						if (zn > 20 /* the longest code */) {
+							retVal = BZ_DATA_ERROR;
+							goto save_state_and_return;
+						}
+						if (zvec <= gLimit[zn]) {
+							break;
+						}
+						zn++;
+
+						case BZ_X_MTF_4:
+							s->state = BZ_X_MTF_4;
+							if (! get_bits(s, &zj, 1)) {
+								retVal = BZ_OK;
+								goto save_state_and_return;
+							}
+							zvec = (zvec << 1) | zj;
+					}
+					if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+
+					}
+					nextSym = gPerm[zvec - gBase[zn]];
+			}
+			while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
+
+			es++;
+			uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
+			s->unzftab[uc] += es;
+
+			while (es > 0) {
+				if (nblock >= nblockMAX) {
+					retVal = BZ_DATA_ERROR;
+					goto save_state_and_return;
+				}
+				s->tt[nblock] = (unsigned int)uc;
+				nblock++;
+				es--;
+			}
+			continue;
+		} else {
+			if (nblock >= nblockMAX) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			/*-- uc = MTF ( nextSym-1 ) --*/
+			{
+				int ii, jj, kk, pp, lno, off;
+				unsigned int nn;
+				nn = (unsigned int)(nextSym - 1);
+
+				if (nn < MTFL_SIZE) {
+					/* avoid general-case expense */
+					pp = s->mtfbase[0];
+					uc = s->mtfa[pp+nn];
+					while (nn > 3) {
+						int z = pp+nn;
+						s->mtfa[(z)  ] = s->mtfa[(z)-1];
+						s->mtfa[(z)-1] = s->mtfa[(z)-2];
+						s->mtfa[(z)-2] = s->mtfa[(z)-3];
+						s->mtfa[(z)-3] = s->mtfa[(z)-4];
+						nn -= 4;
+					}
+					while (nn > 0) { 
+						s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; 
+					}
+					s->mtfa[pp] = uc;
+				} else { 
+					/* general case */
+					lno = nn / MTFL_SIZE;
+					off = nn % MTFL_SIZE;
+					pp = s->mtfbase[lno] + off;
+					uc = s->mtfa[pp];
+					while (pp > s->mtfbase[lno]) { 
+						s->mtfa[pp] = s->mtfa[pp-1];
+						pp--; 
+					}
+					s->mtfbase[lno]++;
+					while (lno > 0) {
+						s->mtfbase[lno]--;
+						s->mtfa[s->mtfbase[lno]] = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
+						lno--;
+					}
+					s->mtfbase[0]--;
+					s->mtfa[s->mtfbase[0]] = uc;
+					if (s->mtfbase[0] == 0) {
+						kk = MTFA_SIZE-1;
+						for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
+							for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
+								s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
+								kk--;
+							}
+							s->mtfbase[ii] = kk + 1;
+						}
+					}
+				}
+			}
+			/*-- end uc = MTF ( nextSym-1 ) --*/
+
+			s->unzftab[s->seqToUnseq[uc]]++;
+			s->tt[nblock]   = (unsigned int)(s->seqToUnseq[uc]);
+			nblock++;
+
+			if (! get_mtf_val_init()) {
+				goto save_state_and_return;
+			}
+			case BZ_X_MTF_5:
+				s->state = BZ_X_MTF_5;
+				if (! get_bits(s, &zvec, zn)) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+				while (1) {
+					if (zn > 20 /* the longest code */) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					if (zvec <= gLimit[zn]) {
+						break;
+					}
+					zn++;
+
+					case BZ_X_MTF_6:
+						s->state = BZ_X_MTF_6;
+						if (! get_bits(s, &zj, 1)) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						zvec = (zvec << 1) | zj;
+				}
+			if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			nextSym = gPerm[zvec - gBase[zn]];
+			continue;
+		}
+	}
+
+	/* Now we know what nblock is, we can do a better sanity
+		check on s->origPtr.
+	*/
+	if (s->origPtr < 0 || s->origPtr >= nblock) {
+		retVal = BZ_DATA_ERROR;
+		goto save_state_and_return;
+	}
+	s->state_out_len = 0;
+	s->state_out_ch  = 0;
+	s->calculatedBlockCRC = 0xffffffffL;
+	s->state = BZ_X_OUTPUT;
+
+	/*-- Set up cftab to facilitate generation of T^(-1) --*/
+	s->cftab[0] = 0;
+	for (i = 1; i <= 256; i++) {
+		s->cftab[i] = s->unzftab[i-1];
+	}
+	for (i = 1; i <= 256; i++) {
+		s->cftab[i] += s->cftab[i-1];
+	}
+
+	/*-- compute the T^(-1) vector --*/
+	for (i = 0; i < nblock; i++) {
+		uc = (unsigned char)(s->tt[i] & 0xff);
+		s->tt[s->cftab[uc]] |= (i << 8);
+		s->cftab[uc]++;
+	}
+
+	s->tPos = s->tt[s->origPtr] >> 8;
+	s->nblock_used = 0;
+	if (s->blockRandomised) {
+		s->rNToGo = 0;
+		s->rTPos  = 0;
+		s->k0 = bz_get_fast(s);
+
+		s->nblock_used++;
+		bz_rand_udp_mask(s);
+		s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+	} else {
+		s->k0 = bz_get_fast(s);
+		s->nblock_used++;
+	}
+
+		retVal = BZ_OK;
+		goto save_state_and_return;
+
+endhdr_2:
+		case BZ_X_ENDHDR_2:
+			s->state = BZ_X_ENDHDR_2;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x72) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_3:
+			s->state = BZ_X_ENDHDR_3;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x45) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_4:
+			s->state = BZ_X_ENDHDR_4;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x38) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_5:
+			s->state = BZ_X_ENDHDR_5;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x50) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_6:
+			s->state = BZ_X_ENDHDR_6;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x90) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = 0;
+
+		case BZ_X_CCRC_1:
+			s->state = BZ_X_CCRC_1;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+		case BZ_X_CCRC_2:
+			s->state = BZ_X_CCRC_2;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_CCRC_3:
+			s->state = BZ_X_CCRC_3;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_CCRC_4:
+			s->state = BZ_X_CCRC_4;
+			if (! get_bits(s, &uc, 8)) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		s->state = BZ_X_IDLE;
+		retVal = BZ_STREAM_END;
+		goto save_state_and_return;
+
+	}
+
+save_state_and_return:
+	s->save_i           = i;
+	s->save_j           = j;
+	s->save_t           = t;
+	s->save_alphaSize   = alphaSize;
+	s->save_nGroups     = nGroups;
+	s->save_nSelectors  = nSelectors;
+	s->save_EOB         = EOB;
+	s->save_groupNo     = groupNo;
+	s->save_groupPos    = groupPos;
+	s->save_nextSym     = nextSym;
+	s->save_nblockMAX   = nblockMAX;
+	s->save_nblock      = nblock;
+	s->save_es          = es;
+	s->save_N           = N;
+	s->save_curr        = curr;
+	s->save_zt          = zt;
+	s->save_zn          = zn;
+	s->save_zvec        = zvec;
+	s->save_zj          = zj;
+	s->save_gSel        = gSel;
+	s->save_gMinlen     = gMinlen;
+	s->save_gLimit      = gLimit;
+	s->save_gBase       = gBase;
+	s->save_gPerm       = gPerm;
+
+	return retVal;   
+}
+
+extern void BZ2_bzReadClose(void)
+{
+	if (bzf->initialisedOk) {
+		bz_stream *strm = &(bzf->strm);
+		DState *s;
+		if (strm == NULL) {
+			return;
+		}
+		s = strm->state;
+		if ((s == NULL) || (s->strm != strm)) {
+			return;
+		}
+		free(s->tt);
+		free(strm->state);
+		strm->state = NULL;
+		return;
+	}
+	free(bzf);
+}
+
+static void unRLE_obuf_to_output_FAST(DState *s)
+{
+	unsigned char k1;
+
+	if (s->blockRandomised) {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+			}
+   
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+
+			s->state_out_len = 2;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+			s->state_out_len = 3;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+		}
+	} else {
+		/* restore */
+		unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC;
+		unsigned char c_state_out_ch       = s->state_out_ch;
+		int c_state_out_len      = s->state_out_len;
+		int c_nblock_used        = s->nblock_used;
+		int c_k0                 = s->k0;
+		unsigned int	*c_tt                 = s->tt;
+		unsigned int	c_tPos               = s->tPos;
+		char	*cs_next_out          = s->strm->next_out;
+		unsigned int  cs_avail_out         = s->strm->avail_out;
+		/* end restore */
+
+		int        s_save_nblockPP = s->save_nblock+1;
+
+		while (1) {
+			/* try to finish existing run */
+			if (c_state_out_len > 0) {
+				while (TRUE) {
+					if (cs_avail_out == 0) {
+						goto return_notr;
+					}
+					if (c_state_out_len == 1) {
+						break;
+					}
+					*((unsigned char *)(cs_next_out)) = c_state_out_ch;
+					c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
+						BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
+						((unsigned char)c_state_out_ch)];
+					c_state_out_len--;
+					cs_next_out++;
+					cs_avail_out--;
+				}
+s_state_out_len_eq_one:
+				{
+					if (cs_avail_out == 0) { 
+						c_state_out_len = 1;
+						goto return_notr;
+					}
+					*((unsigned char *)(cs_next_out)) = c_state_out_ch;
+					c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
+						BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
+						((unsigned char)c_state_out_ch)];
+					cs_next_out++;
+					cs_avail_out--;
+				}
+			}   
+			/* can a new run be started? */
+			if (c_nblock_used == s_save_nblockPP) {
+				c_state_out_len = 0; goto return_notr;
+			}
+			c_state_out_ch = c_k0;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+
+			if (k1 != c_k0) { 
+				c_k0 = k1;
+				goto s_state_out_len_eq_one; 
+			}
+
+			if (c_nblock_used == s_save_nblockPP) {
+				goto s_state_out_len_eq_one;
+			}
+
+			c_state_out_len = 2;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			if (c_nblock_used == s_save_nblockPP) {
+				continue;
+			}
+			if (k1 != c_k0) {
+				c_k0 = k1;
+				continue;
+			}
+
+			c_state_out_len = 3;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			if (c_nblock_used == s_save_nblockPP) {
+				continue;
+			}
+			if (k1 != c_k0) {
+				c_k0 = k1;
+				continue;
+			}
+   
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			c_state_out_len = ((int)k1) + 4;
+
+			c_tPos = c_tt[c_tPos];
+			c_k0 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+		}
+
+return_notr:
+
+		/* save */
+		s->calculatedBlockCRC = c_calculatedBlockCRC;
+		s->state_out_ch       = c_state_out_ch;
+		s->state_out_len      = c_state_out_len;
+		s->nblock_used        = c_nblock_used;
+		s->k0                 = c_k0;
+		s->tt                 = c_tt;
+		s->tPos               = c_tPos;
+		s->strm->next_out     = cs_next_out;
+		s->strm->avail_out    = cs_avail_out;
+		/* end save */
+	}
+}
+static inline
+int BZ2_bzDecompress(bz_stream *strm)
+{
+	DState* s;
+	s = strm->state;
+
+	while (1) {
+		if (s->state == BZ_X_IDLE) {
+			return BZ_SEQUENCE_ERROR;
+		}
+		if (s->state == BZ_X_OUTPUT) {
+			unRLE_obuf_to_output_FAST(s);
+			if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
+				s->calculatedBlockCRC = ~(s->calculatedBlockCRC);
+				if (s->calculatedBlockCRC != s->storedBlockCRC) {
+					return BZ_DATA_ERROR;
+				}
+				s->calculatedCombinedCRC = (s->calculatedCombinedCRC << 1) | (s->calculatedCombinedCRC >> 31);
+				s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
+				s->state = BZ_X_BLKHDR_1;
+			} else {
+				return BZ_OK;
+			}
+		}
+		if (s->state >= BZ_X_MAGIC_1) {
+			int r = BZ2_decompress(s);
+			if (r == BZ_STREAM_END) {
+				if (s->calculatedCombinedCRC != s->storedCombinedCRC) {
+					return BZ_DATA_ERROR;
+				}
+				return r;
+			}
+			if (s->state != BZ_X_OUTPUT) {
+				return r;
+			}
+		}
+	}
+
+	return(0);  /*NOTREACHED*/
+}
+
+extern ssize_t read_bz2(int fd, void *buf, size_t count)
+{
+	int n, ret;
+
+	bzerr = BZ_OK;
+	if (count == 0) {
+		return(0);
+	}
+	bzf->strm.avail_out = count;
+	bzf->strm.next_out = buf;
+
+	while (1) {
+		if (bzf->strm.avail_in == 0) {
+			n = bb_xread(bzf->fd, bzf->buf, BZ_MAX_UNUSED);
+			if (n == 0) {
+				break;
+			}
+			bzf->bufN = n;
+			bzf->strm.avail_in = bzf->bufN;
+			bzf->strm.next_in = bzf->buf;
+		}
+
+		ret = BZ2_bzDecompress(&(bzf->strm));
+
+		if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) {
+			bb_error_msg_and_die("Error decompressing");
+		}
+
+		if (ret == BZ_STREAM_END) {
+			bzerr = BZ_STREAM_END;
+			return(count - bzf->strm.avail_out);
+		}
+		if (bzf->strm.avail_out == 0) {
+			bzerr = BZ_OK;
+			return(count);
+		}
+	}
+	return(0);
+}
+
+extern void BZ2_bzReadOpen(int fd, void *unused, int nUnused)
+{
+	DState *s;
+
+	bzf = xmalloc(sizeof(bzFile));
+	bzf->initialisedOk = FALSE;
+	bzf->fd        = fd;
+	bzf->bufN      = 0;
+
+	s = xmalloc(sizeof(DState));
+	s->strm = &bzf->strm;
+	s->state = BZ_X_MAGIC_1;
+	s->bsLive = 0;
+	s->bsBuff = 0;
+	s->calculatedCombinedCRC = 0;
+	s->tt = NULL;
+	s->currBlockNo = 0;
+	bzf->strm.state = s;
+
+	while (nUnused > 0) {
+		bzf->buf[bzf->bufN] = *((unsigned char *)(unused));
+		bzf->bufN++;
+		unused = ((void *)( 1 + ((unsigned char *)(unused))  ));
+		nUnused--;
+	}
+	bzf->strm.avail_in = bzf->bufN;
+	bzf->strm.next_in  = bzf->buf;
+
+	bzf->initialisedOk = TRUE;
+
+	return;
+}
+
+extern unsigned char uncompressStream(int src_fd, int dst_fd)
+{
+	unsigned char unused[BZ_MAX_UNUSED];
+	unsigned char *unusedTmp;
+	unsigned char obuf[5000];
+	int nread;
+	int nUnused;
+	int streamNo;
+	int i;
+
+	nUnused = 0;
+	streamNo = 0;
+
+	while(1) {
+		BZ2_bzReadOpen(src_fd, unused, nUnused);
+		streamNo++;
+
+		while (bzerr == BZ_OK) {
+			nread = read_bz2(src_fd, obuf, 5000);
+			if (bzerr == BZ_DATA_ERROR_MAGIC) {
+				bb_error_msg_and_die("invalid magic");
+			}
+			if (((bzerr == BZ_OK) || (bzerr == BZ_STREAM_END)) && (nread > 0)) {
+				if (write(dst_fd, obuf, nread) != nread) {
+					BZ2_bzReadClose();
+					bb_perror_msg_and_die("Couldnt write to file");
+				}
+			}
+		}
+		nUnused = bzf->strm.avail_in;
+		unusedTmp = bzf->strm.next_in;
+
+		for (i = 0; i < nUnused; i++) {
+			unused[i] = unusedTmp[i];
+		}
+		BZ2_bzReadClose();
+		if (nUnused == 0) {
+			break;
+		}
+	}
+
+	close(src_fd);
+	if (dst_fd != fileno(stdout)) {
+		close(dst_fd);
+	}
+	return TRUE;
+}
+
diff --git a/release/src/router/busybox/archival/libunarchive/filter_accept_all.c b/release/src/router/busybox/archival/libunarchive/filter_accept_all.c
new file mode 100644
index 00000000..baf9e4b7
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/filter_accept_list.c b/release/src/router/busybox/archival/libunarchive/filter_accept_list.c
new file mode 100644
index 00000000..e1c4827b
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/filter_accept_list_reassign.c b/release/src/router/busybox/archival/libunarchive/filter_accept_list_reassign.c
new file mode 100644
index 00000000..d9bee79d
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/filter_accept_list_reassign.c
@@ -0,0 +1,58 @@
+/*
+ *  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->sub_archive->read = read;
+			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->sub_archive->read = read_bz2;
+			BZ2_bzReadOpen(archive_handle->src_fd, NULL, 0);
+			archive_handle->action_data_subarchive = get_header_tar;
+			return(EXIT_SUCCESS);
+		}
+#endif
+	}
+	return(EXIT_FAILURE);
+}
diff --git a/release/src/router/busybox/archival/libunarchive/filter_accept_reject_list.c b/release/src/router/busybox/archival/libunarchive/filter_accept_reject_list.c
new file mode 100644
index 00000000..657f7a0b
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/find_list_entry.c b/release/src/router/busybox/archival/libunarchive/find_list_entry.c
new file mode 100644
index 00000000..7ed9e332
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/get_header_ar.c b/release/src/router/busybox/archival/libunarchive/get_header_ar.c
new file mode 100644
index 00000000..6c576a8d
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/get_header_ar.c
@@ -0,0 +1,122 @@
+/*
+ *  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);
+		}
+
+	/* Some ar entries have a trailing '\n' after the previous data entry */
+	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);
+			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 + 1;
+
+	return(EXIT_SUCCESS);
+}
+
diff --git a/release/src/router/busybox/archival/libunarchive/get_header_cpio.c b/release/src/router/busybox/archival/libunarchive/get_header_cpio.c
new file mode 100644
index 00000000..975e2a4b
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/get_header_cpio.c
@@ -0,0 +1,189 @@
+/*
+ *  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"
+
+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;
+	char extract_flag;
+	
+	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) {
+		printf("cpio header is %x-%x-%x-%x-%x\n",
+			cpio_header[0],
+			cpio_header[1],
+			cpio_header[2],
+			cpio_header[3],
+			cpio_header[4]);
+		bb_error_msg_and_die("Unsupported cpio format");
+	}
+		
+	if ((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 */
+	}
+	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 = (major << 8) | minor;
+
+	extract_flag = FALSE;
+	if (archive_handle->filter(archive_handle) == EXIT_SUCCESS) {
+		struct stat statbuf;
+
+		extract_flag = TRUE;
+
+		/* Check if the file already exists */
+		if (lstat (file_header->name, &statbuf) == 0) {
+			if ((archive_handle->flags & ARCHIVE_EXTRACT_UNCONDITIONAL) || (statbuf.st_mtime < file_header->mtime)) {
+				/* Remove file if flag set or its older than the file to be extracted */
+				if (unlink(file_header->name) == -1) {
+					bb_perror_msg_and_die("Couldnt remove old file");
+				}
+			} else {
+				if (! archive_handle->flags & ARCHIVE_EXTRACT_QUIET) {
+					bb_error_msg("%s not created: newer or same age file exists", file_header->name);
+				}
+				extract_flag = FALSE;
+			}
+		}
+		archive_handle->action_header(file_header);
+	}
+
+	archive_handle->action_header(file_header);
+	if (extract_flag) {
+		archive_handle->action_data(archive_handle);
+	} else {
+		data_skip(archive_handle);
+	}
+	archive_handle->offset += file_header->size;
+	return (EXIT_SUCCESS);
+}
+
diff --git a/release/src/router/busybox/archival/libunarchive/get_header_tar.c b/release/src/router/busybox/archival/libunarchive/get_header_tar.c
new file mode 100644
index 00000000..33cb75df
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/get_header_tar.c
@@ -0,0 +1,188 @@
+/*
+ *  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"
+
+#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 {
+		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;
+	char *tmp;
+
+	/* Align header */
+	data_align(archive_handle, 512);
+
+	if (archive_xread(archive_handle, 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);
+	}
+	tmp = last_char_is(archive_handle->file_header->name, '/');
+	if (tmp) {
+		*tmp = '\0';
+	}
+
+	file_header->mode = strtol(tar.formated.mode, NULL, 8);
+	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 = (dev_t) ((strtol(tar.formated.devmajor, NULL, 8) << 8) +
+				 strtol(tar.formated.devminor, NULL, 8));
+
+#if defined CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY || defined CONFIG_FEATURE_TAR_GNU_EXTENSIONS
+	/* Fix mode, used by the old format */
+	switch (tar.formated.typeflag) {
+# ifdef CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
+	case 0:
+	case '0':
+		file_header->mode |= S_IFREG;
+		break;
+	case '1':
+		bb_error_msg("WARNING: Converting hard link to symlink");
+	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;
+# endif
+# 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':
+	case 'M':
+	case 'N':
+	case 'S':
+	case 'V':
+		bb_error_msg("Ignoring GNU extension type %c", tar.formated.typeflag);
+# endif
+	}
+#endif
+	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, archive_handle->file_header->name);
+	} else {
+		data_skip(archive_handle);			
+	}
+	archive_handle->offset += file_header->size;
+
+	return(EXIT_SUCCESS);
+}
+
diff --git a/release/src/router/busybox/archival/libunarchive/get_header_tar_bz2.c b/release/src/router/busybox/archival/libunarchive/get_header_tar_bz2.c
new file mode 100644
index 00000000..b49ccae1
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/get_header_tar_bz2.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 <sys/types.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)
+{
+	BZ2_bzReadOpen(archive_handle->src_fd, NULL, 0);
+
+	archive_handle->read = read_bz2;
+	archive_handle->seek = seek_by_char;
+
+	archive_handle->offset = 0;
+	while (get_header_tar(archive_handle) == EXIT_SUCCESS);
+
+	/* Cleanup */
+	BZ2_bzReadClose();
+	
+	/* Can only do one tar.bz2 per archive */
+	return(EXIT_FAILURE);
+}
+
diff --git a/release/src/router/busybox/archival/libunarchive/get_header_tar_gz.c b/release/src/router/busybox/archival/libunarchive/get_header_tar_gz.c
new file mode 100644
index 00000000..7792432a
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/get_header_tar_gz.c
@@ -0,0 +1,49 @@
+/*
+ *  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];
+
+	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);
+
+	GZ_gzReadOpen(archive_handle->src_fd, 0, 0);
+
+	archive_handle->read = read_gz;
+	archive_handle->seek = seek_by_char;
+
+	archive_handle->offset = 0;
+	while (get_header_tar(archive_handle) == EXIT_SUCCESS);
+
+	/* Cleanup */
+	GZ_gzReadClose();
+
+	check_trailer_gzip(archive_handle->src_fd);
+	
+	/* Can only do one tar.bz2 per archive */
+	return(EXIT_FAILURE);
+}
+
diff --git a/release/src/router/busybox/archival/libunarchive/header_list.c b/release/src/router/busybox/archival/libunarchive/header_list.c
new file mode 100644
index 00000000..5849a762
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/header_skip.c b/release/src/router/busybox/archival/libunarchive/header_skip.c
new file mode 100644
index 00000000..4430178f
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/header_verbose_list.c b/release/src/router/busybox/archival/libunarchive/header_verbose_list.c
new file mode 100644
index 00000000..6739dd39
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/init_handle.c b/release/src/router/busybox/archival/libunarchive/init_handle.c
new file mode 100644
index 00000000..2659aa3e
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/init_handle.c
@@ -0,0 +1,37 @@
+/*
+ *  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->read = bb_full_read;
+	archive_handle->seek = seek_by_jump;
+
+	return(archive_handle);
+}
diff --git a/release/src/router/busybox/archival/libunarchive/seek_by_char.c b/release/src/router/busybox/archival/libunarchive/seek_by_char.c
new file mode 100644
index 00000000..f33935cb
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/seek_by_char.c
@@ -0,0 +1,25 @@
+/*
+ *  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 "unarchive.h"
+
+extern void seek_by_char(const archive_handle_t *archive_handle, const unsigned int amount)
+{
+	unsigned int i;
+	for (i = 0; i < amount; i++) {
+		archive_xread_char(archive_handle);
+	}
+}
diff --git a/release/src/router/busybox/archival/libunarchive/seek_by_jump.c b/release/src/router/busybox/archival/libunarchive/seek_by_jump.c
new file mode 100644
index 00000000..578870d9
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/uncompress.c b/release/src/router/busybox/archival/libunarchive/uncompress.c
new file mode 100644
index 00000000..9851ca39
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/uncompress.c
@@ -0,0 +1,298 @@
+#include "config.h"
+#include "libbb.h"
+
+#if defined CONFIG_UNCOMPRESS || defined CONFIG_FEATURE_GUNZIP_UNCOMPRESS
+
+/* 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>
+
+/* Defailt 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 = 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;
+}
+
+
+#endif
diff --git a/release/src/router/busybox/archival/libunarchive/unpack_ar_archive.c b/release/src/router/busybox/archival/libunarchive/unpack_ar_archive.c
new file mode 100644
index 00000000..e8f113bc
--- /dev/null
+++ b/release/src/router/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/release/src/router/busybox/archival/libunarchive/unzip.c b/release/src/router/busybox/archival/libunarchive/unzip.c
new file mode 100644
index 00000000..2b16db3c
--- /dev/null
+++ b/release/src/router/busybox/archival/libunarchive/unzip.c
@@ -0,0 +1,1040 @@
+/* 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@optushome.com.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 */
+#define 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 void fill_bytebuffer(void)
+{
+	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;
+	}
+}
+
+static unsigned int fill_bitbuffer(unsigned int bitbuffer, unsigned int *current, const unsigned int required)
+{
+	while (*current < required) {
+		fill_bytebuffer();
+		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 needAnotherBlock = 1;
+	static int method = -1; // Method == -1 for stored, -2 for codes
+	static int e = 0;
+	
+	gunzip_outbuf_count = 0;
+
+	while(1) {
+		int ret;
+	
+		if (needAnotherBlock) {
+			if(e) {
+				calculate_gunzip_crc();
+				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 */
+}
+
+/*
+ * User functions
+ *
+ * read_gz, GZ_gzReadOpen, GZ_gzReadClose, inflate
+ */
+
+extern ssize_t read_gz(int fd, void *buf, size_t count)
+{
+	static int morebytes = 0, finished = 0;
+	
+	if (morebytes) {
+		int bytesRead = morebytes > count ? count : morebytes;
+		memcpy(buf, gunzip_window + (gunzip_outbuf_count - morebytes), bytesRead);
+		morebytes -= bytesRead;
+		return bytesRead;
+	} else if (finished) {
+		return 0;
+	} else if (count >= 0x8000) { // We can decompress direcly to the buffer, 32k at a time
+		// Could decompress to larger buffer, but it must be a power of 2, and calculating that is probably more expensive than the benefit
+		unsigned char *old_gunzip_window = gunzip_window; // Save old window
+		gunzip_window = buf;
+		if (inflate_get_next_window() == 0) finished = 1;
+		gunzip_window = old_gunzip_window; // Restore old window
+		return gunzip_outbuf_count;
+	} else { // Oh well, need to split up the gunzip_window
+		int bytesRead;
+		if (inflate_get_next_window() == 0) finished = 1;
+		morebytes = gunzip_outbuf_count;
+		bytesRead = morebytes > count ? count : morebytes;
+		memcpy(buf, gunzip_window, bytesRead);
+		morebytes -= bytesRead;
+		return bytesRead;
+	}
+	
+}
+
+extern void GZ_gzReadOpen(int fd, void *unused, int nUnused)
+{
+	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 = fd;
+
+	/* Input buffer */
+	bytebuffer = xmalloc(BYTEBUFFER_MAX);
+
+	/* initialize gunzip_window, bit buffer */
+	gunzip_bk = 0;
+	gunzip_bb = 0;
+
+	/* Create the crc table */
+	make_gunzip_crc_table();
+}
+
+extern void GZ_gzReadClose(void)
+{
+	/* 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;
+	}
+}
+
+/*extern int inflate(int in, int out) // Useful for testing read_gz
+{
+	char buf[8192];
+	ssize_t nread, nwrote;
+
+	GZ_gzReadOpen(in, 0, 0);
+	while(1) { // Robbed from bb_copyfd.c
+		nread = read_gz(in, buf, sizeof(buf));
+		if (nread == 0) break; // no data to write
+		else if (nread == -1) {
+			bb_perror_msg("read");
+			return -1;
+		}
+		nwrote = bb_full_write(out, buf, nread);
+		if (nwrote == -1) {
+			bb_perror_msg("write");
+			return -1;
+		}
+	}
+	GZ_gzReadClose();
+	return 0;
+}*/
+
+extern int inflate(int in, int out)
+{
+	ssize_t nwrote;
+	GZ_gzReadOpen(in, 0, 0);
+	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;
+	}
+	GZ_gzReadClose();
+	return 0;
+}
+
+extern void check_trailer_gzip(int src_fd)
+{
+	unsigned int stored_crc = 0;
+	unsigned char count;
+
+	/* top up the input buffer with the rest of the trailer */
+	count = bytebuffer_size - bytebuffer_offset;
+	if (count < 8) {
+		bb_xread_all(src_fd, &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_and_die("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_and_die("Incorrect length, but crc is correct");
+	}
+
+}
diff --git a/release/src/router/busybox/archival/rpm.c b/release/src/router/busybox/archival/rpm.c
new file mode 100644
index 00000000..5bde5328
--- /dev/null
+++ b/release/src/router/busybox/archival/rpm.c
@@ -0,0 +1,352 @@
+/* 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 {
+	u_int32_t tag; /* 4 byte tag */
+	u_int32_t type; /* 4 byte type */
+	u_int32_t offset; /* 4 byte offset */
+	u_int32_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->read = read_gz;
+	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
+
+	GZ_gzReadOpen(archive_handle->src_fd, 0, 0);
+	while (get_header_cpio(archive_handle) == EXIT_SUCCESS);
+	GZ_gzReadClose();
+	
+	check_trailer_gzip(archive_handle->src_fd);
+}
+
+
+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 */
+			u_int8_t version; /* 1 byte version number */
+			u_int32_t reserved; /* 4 bytes reserved */
+			u_int32_t entries; /* Number of entries in header (4 bytes) */
+			u_int32_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/release/src/router/busybox/archival/rpm2cpio.c b/release/src/router/busybox/archival/rpm2cpio.c
new file mode 100644
index 00000000..bb9f6957
--- /dev/null
+++ b/release/src/router/busybox/archival/rpm2cpio.c
@@ -0,0 +1,107 @@
+/* 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];
+    u_int8_t major, minor;
+    u_int16_t type;
+    u_int16_t archnum;
+    char name[66];
+    u_int16_t osnum;
+    u_int16_t signature_type;
+    char reserved[16];
+};
+
+struct rpm_header {
+	char magic[3]; /* 3 byte magic: 0x8e 0xad 0xe8 */
+	u_int8_t version; /* 1 byte version number */
+	u_int32_t reserved; /* 4 bytes reserved */
+	u_int32_t entries; /* Number of entries in header (4 bytes) */
+	u_int32_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 = fileno(stdin);
+	} 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(rpm_fd, fileno(stdout)) != 0) {
+		bb_error_msg("Error inflating");
+	}
+	check_trailer_gzip(rpm_fd);
+
+	close(rpm_fd);
+
+	return 0;
+}
diff --git a/release/src/router/busybox/archival/tar.c b/release/src/router/busybox/archival/tar.c
new file mode 100644
index 00000000..2f0c83b2
--- /dev/null
+++ b/release/src/router/busybox/archival/tar.c
@@ -0,0 +1,773 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini tar implementation for busybox 
+ *
+ * Modifed to use common extraction code used by ar, cpio, dpkg-deb, dpkg
+ *  Glenn McGrath <bug1@optushome.com.au>
+ *
+ * Note, that as of BusyBox-0.43, tar has been completely rewritten from the
+ * ground up.  It still has remnents of the old code lying about, but it is
+ * very different now (i.e., cleaner, less global variables, etc.)
+ *
+ * Copyright (C) 1999-2003 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 "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 */
+
+# ifndef MAJOR
+#  define MAJOR(dev) (((dev)>>8)&0xff)
+#  define MINOR(dev) ((dev)&0xff)
+# endif
+
+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) == NULL)
+		strcpy(header.uname, "root");
+	if (my_getgrgid(header.gname, statbuf->st_gid) == 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->verboseFlag == 2)	/* If the archive goes to stdout, verbose to stderr */
+			vbFd = stderr;
+		fprintf(vbFd, "%s\n", header.name);
+	}
+
+	return (TRUE);
+}
+
+# if defined CONFIG_FEATURE_TAR_EXCLUDE
+static inline int exclude_file(const llist_t *excluded_files, const char *file)
+{
+	if (excluded_files == NULL) {
+		return 0;
+	}
+
+	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;
+
+# if defined CONFIG_FEATURE_TAR_EXCLUDE
+	if (exclude_file(tbInfo->excludeList, header_name)) {
+		return SKIP;
+	}
+# endif							/* CONFIG_FEATURE_TAR_EXCLUDE */
+
+	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;
+		char buffer[BUFSIZ];
+		ssize_t size = 0, 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 */
+		while ((size = bb_full_read(inputFileFd, buffer, sizeof(buffer))) > 0) {
+			if (bb_full_write(tbInfo->tarFd, buffer, size) != size) {
+				/* Output file seems to have a problem */
+				bb_error_msg(bb_msg_io_error, fileName);
+				return (FALSE);
+			}
+			readSize += size;
+		}
+		if (size == -1) {
+			bb_error_msg(bb_msg_io_error, fileName);
+			return (FALSE);
+		}
+		/* 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 char *tarName, const int verboseFlag,
+							   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;
+
+	/* Make sure there is at least one file to tar up.  */
+	if (include == NULL) {
+		bb_error_msg_and_die("Cowardly refusing to create an empty archive");
+	}
+
+	/* Open the tar file for writing.  */
+	if (tarName == NULL || (tarName[0] == '-' && tarName[1] == '\0')) {
+		tbInfo.tarFd = fileno(stdout);
+		tbInfo.verboseFlag = verboseFlag ? 2 : 0;
+	} else {
+		unlink(tarName);
+		tbInfo.tarFd = open(tarName, O_WRONLY | O_CREAT | O_EXCL, 0644);
+		tbInfo.verboseFlag = verboseFlag ? 1 : 0;
+	}
+
+	if (tbInfo.tarFd < 0) {
+		bb_perror_msg("%s: Cannot open", tarName);
+		freeHardLinkInfo(&tbInfo.hlInfoHead);
+		return (FALSE);
+	}
+
+	/* 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_error_msg_and_die(bb_msg_io_error, tarName);
+
+#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, FALSE, 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_EXCLUDE
+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
+
+
+static const char tar_options[]="ctxjT:X:C:f:Opvz";
+#define CTX_CREATE	1
+#define CTX_TEST	2
+#define CTX_EXTRACT	4
+#define TAR_OPT_BZIP2    8
+#define TAR_OPT_INCLUDE  16
+#define TAR_OPT_EXCLUDE  32
+#define TAR_OPT_BASEDIR  64
+#define TAR_OPT_ARNAME   128
+#define TAR_OPT_2STDOUT  256
+#define TAR_OPT_P        512
+#define TAR_OPT_VERBOSE  1024
+#define TAR_OPT_GZIP     2048
+
+int tar_main(int argc, char **argv)
+{
+	char (*get_header_ptr)(archive_handle_t *) = get_header_tar;
+	archive_handle_t *tar_handle;
+	int opt;
+	char *base_dir = NULL;
+	const char *tar_filename = "-";
+	unsigned char 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;
+
+	bb_opt_complementaly = "c~tx:t~cx:x~ct:X*";
+	opt = bb_getopt_ulflags(argc, argv, tar_options,
+				NULL,   /* T: arg is ignored by default
+					    a list is an include list */
+				&(tar_handle->reject),
+				&base_dir,      /* Change to dir <optarg> */
+				&tar_filename); /* archive filename */
+	/* Check one and only one context option was given */
+	if(opt & 0x80000000UL)
+		bb_show_usage();
+	ctx_flag = opt & (CTX_CREATE | CTX_TEST | CTX_EXTRACT);
+	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;
+			}
+	}
+#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_EXCLUDE
+	if(opt & TAR_OPT_EXCLUDE) {
+		tar_handle->reject = append_file_list_to_list(tar_handle->reject);
+	}
+#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, seperate function ? */
+	while (optind < argc) {
+		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;
+	}
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+	/* create an archive */
+	if (ctx_flag == 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_filename, verboseFlag, tar_handle->accept,
+			tar_handle->reject, gzipFlag);
+	} else 
+#endif /* CONFIG_FEATURE_TAR_CREATE */
+	{
+		if ((tar_filename[0] == '-') && (tar_filename[1] == '\0')) {
+			tar_handle->src_fd = fileno(stdin);
+			tar_handle->seek = seek_by_char;
+		} else {
+			tar_handle->src_fd = bb_xopen(tar_filename, O_RDONLY);
+		}
+
+		if ((base_dir) && (chdir(base_dir))) {
+			bb_perror_msg_and_die("Couldnt chdir");
+		}
+
+		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 != fileno(stdin)) {
+		close(tar_handle->src_fd);
+	}
+#endif /* CONFIG_FEATURE_CLEAN_UP */
+
+	return(EXIT_SUCCESS);
+}
diff --git a/release/src/router/busybox/archival/uncompress.c b/release/src/router/busybox/archival/uncompress.c
new file mode 100644
index 00000000..2de37d27
--- /dev/null
+++ b/release/src/router/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 = fileno(stdin);
+			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 = fileno(stdout);
+		} 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 != fileno(stdout)) {
+			close(dst_fd);
+		}
+		if (src_fd != fileno(stdin)) {
+			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/release/src/router/busybox/archival/unzip.c b/release/src/router/busybox/archival/unzip.c
new file mode 100644
index 00000000..f2d7f491
--- /dev/null
+++ b/release/src/router/busybox/archival/unzip.c
@@ -0,0 +1,245 @@
+/* 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 to format see http://www.pkware.com/support/appnote.html */
+
+/* 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 = fileno(stdin);
+		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(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 short i;
+			for (i = 0; i != 12; i++) {
+				archive_xread_char(archive_handle);
+			}
+			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);
+}