Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/archival

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

Location:

branches/2.2.9/mindi-busybox/archival

Files:

• Config.in (modified) (12 diffs)
• Config.src (added)
• Kbuild (modified) (1 diff)
• Kbuild.src (added)
• ar.c (modified) (3 diffs)
• bbunzip.c (modified) (15 diffs)
• bbunzip_test.sh (added)
• bbunzip_test2.sh (added)
• bbunzip_test3.sh (added)
• bzip2.c (added)
• cpio.c (modified) (3 diffs)
• dpkg.c (modified) (52 diffs)
• dpkg_deb.c (modified) (5 diffs)
• gzip.c (modified) (15 diffs)
• libarchive (added)
• libarchive/Kbuild.src (added)
• libarchive/bz (added)
• libarchive/bz/LICENSE (added)
• libarchive/bz/README (added)
• libarchive/bz/blocksort.c (added)
• libarchive/bz/bzlib.c (added)
• libarchive/bz/bzlib.h (added)
• libarchive/bz/bzlib_private.h (added)
• libarchive/bz/compress.c (added)
• libarchive/bz/huffman.c (added)
• libarchive/data_align.c (added)
• libarchive/data_extract_all.c (added)
• libarchive/data_extract_to_command.c (added)
• libarchive/data_extract_to_stdout.c (added)
• libarchive/data_skip.c (added)
• libarchive/decompress_bunzip2.c (added)
• libarchive/decompress_uncompress.c (added)
• libarchive/decompress_unlzma.c (added)
• libarchive/decompress_unxz.c (added)
• libarchive/decompress_unzip.c (added)
• libarchive/filter_accept_all.c (added)
• libarchive/filter_accept_list.c (added)
• libarchive/filter_accept_list_reassign.c (added)
• libarchive/filter_accept_reject_list.c (added)
• libarchive/find_list_entry.c (added)
• libarchive/get_header_ar.c (added)
• libarchive/get_header_cpio.c (added)
• libarchive/get_header_tar.c (added)
• libarchive/get_header_tar_bz2.c (added)
• libarchive/get_header_tar_gz.c (added)
• libarchive/get_header_tar_lzma.c (added)
• libarchive/header_list.c (added)
• libarchive/header_skip.c (added)
• libarchive/header_verbose_list.c (added)
• libarchive/init_handle.c (added)
• libarchive/liblzo.h (added)
• libarchive/lzo1x_1.c (added)
• libarchive/lzo1x_1o.c (added)
• libarchive/lzo1x_9x.c (added)
• libarchive/lzo1x_c.c (added)
• libarchive/lzo1x_d.c (added)
• libarchive/open_transformer.c (added)
• libarchive/seek_by_jump.c (added)
• libarchive/seek_by_read.c (added)
• libarchive/unpack_ar_archive.c (added)
• libarchive/unxz (added)
• libarchive/unxz/README (added)
• libarchive/unxz/xz.h (added)
• libarchive/unxz/xz_config.h (added)
• libarchive/unxz/xz_dec_bcj.c (added)
• libarchive/unxz/xz_dec_lzma2.c (added)
• libarchive/unxz/xz_dec_stream.c (added)
• libarchive/unxz/xz_lzma2.h (added)
• libarchive/unxz/xz_private.h (added)
• libarchive/unxz/xz_stream.h (added)
• lzop.c (added)
• rpm.c (modified) (12 diffs)
• rpm.h (added)
• rpm2cpio.c (modified) (1 diff)
• tar.c (modified) (42 diffs)
• unzip.c (modified) (15 diffs)

branches/2.2.9/mindi-busybox/archival/Config.in

@@ +1 @@
+# DO NOT EDIT. This file is generated from Config.src
 #
 # For a description of the syntax of this configuration file,
@@ -6 +7 @@
 menu "Archival Utilities"
 
+
+
+config FEATURE_SEAMLESS_XZ
+    bool "Make tar, rpm, modprobe etc understand .xz data"
+    default y
+    help
+      Make tar, rpm, modprobe etc understand .xz data.
+
+config FEATURE_SEAMLESS_LZMA
+    bool "Make tar, rpm, modprobe etc understand .lzma data"
+    default y
+    help
+      Make tar, rpm, modprobe etc understand .lzma data.
+
+config FEATURE_SEAMLESS_BZ2
+    bool "Make tar, rpm, modprobe etc understand .bz2 data"
+    default y
+    help
+      Make tar, rpm, modprobe etc understand .bz2 data.
+
+config FEATURE_SEAMLESS_GZ
+    bool "Make tar, rpm, modprobe etc understand .gz data"
+    default y
+    help
+      Make tar, rpm, modprobe etc understand .gz data.
+
+config FEATURE_SEAMLESS_Z
+    bool "Make tar and gunzip understand .Z data"
+    default n
+    help
+      Make tar and gunzip understand .Z data.
+
 config AR
     bool "ar"
-    default n
+    default n  # needs to be improved to be able to replace binutils ar
     help
       ar is an archival utility program used to create, modify, and
-      extract contents from archives.  An archive is a single file holding
+      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).
@@ -30 +63 @@
 
 config FEATURE_AR_LONG_FILENAMES
-    bool "Enable support for long filenames (not need for debs)"
-    default n
+    bool "Support for long filenames (not needed for debs)"
+    default y
     depends on AR
     help
-      By default the ar format can only store the first 15 characters of the
-      filename, this option removes that limitation.
+      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 FEATURE_AR_CREATE
+    bool "Support archive creation"
+    default y
+    depends on AR
+    help
+      This enables archive creation (-c and -r) with busybox ar.
+
 config BUNZIP2
     bool "bunzip2"
-    default n
+    default y
     help
       bunzip2 is a compression utility using the Burrows-Wheeler block
-      sorting text compression algorithm, and Huffman coding.  Compression
+      sorting text compression algorithm, and Huffman coding. Compression
       is generally considerably better than that achieved by more
       conventional LZ77/LZ78-based compressors, and approaches the
       performance of the PPM family of statistical compressors.
 
-      The BusyBox bunzip2 applet is limited to de-compression only.
-      On an x86 system, this applet adds about 11K.
-
       Unless you have a specific application which requires bunzip2, you
       should probably say N here.
 
+config BZIP2
+    bool "bzip2"
+    default y
+    help
+      bzip2 is a compression utility using the Burrows-Wheeler block
+      sorting text compression algorithm, and Huffman coding. Compression
+      is generally considerably better than that achieved by more
+      conventional LZ77/LZ78-based compressors, and approaches the
+      performance of the PPM family of statistical compressors.
+
+      Unless you have a specific application which requires bzip2, you
+      should probably say N here.
+
 config CPIO
     bool "cpio"
-    default n
-    help
-      cpio is an archival utility program used to create, modify, and extract
-      contents from archives.
+    default y
+    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.
 
@@ -66 +116 @@
       "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.
+      Unless you have a specific application which requires cpio, you
+      should probably say N here.
+
+config FEATURE_CPIO_O
+    bool "Support for archive creation"
+    default y
+    depends on CPIO
+    help
+      This implementation of cpio can create cpio archives in the "newc"
+      format only.
+
+config FEATURE_CPIO_P
+    bool "Support for passthrough mode"
+    default y
+    depends on FEATURE_CPIO_O
+    help
+      Passthrough mode. Rarely used.
 
 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.
+    select FEATURE_SEAMLESS_GZ
+    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 DPKG_DEB
     bool "dpkg_deb"
     default n
-    help
-      dpkg-deb packs, unpacks and provides information about Debian archives.
+    select FEATURE_SEAMLESS_GZ
+    help
+      dpkg-deb 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.
+      Unless you have a specific application which requires dpkg-deb,
+      say N here.
 
 config FEATURE_DPKG_DEB_EXTRACT_ONLY
-    bool "extract only (-x)"
+    bool "Extract only (-x)"
     default n
     depends on DPKG_DEB
     help
-      This reduces dpkg-deb to the equivalent of "ar -p <deb> data.tar.gz | tar -zx".
-      However it saves space as none of the extra dpkg-deb, ar or tar options are
-      needed, they are linked to internally.
+      This reduces dpkg-deb to the equivalent of
+      "ar -p <deb> data.tar.gz | tar -zx". However it saves space as none
+      of the extra dpkg-deb, ar or tar options are needed, they are linked
+      to internally.
 
 config GUNZIP
     bool "gunzip"
-    default n
+    default y
     help
       gunzip is used to decompress archives created by gzip.
@@ -106 +175 @@
       an archive, without decompressing it.
 
-config FEATURE_GUNZIP_UNCOMPRESS
-    bool "Uncompress support"
-    default n
-    depends on GUNZIP
-    help
-      Enable if you want gunzip to have the ability to decompress
-      archives created by the program compress (not much
-      used anymore).
-
 config GZIP
     bool "gzip"
-    default n
+    default y
     help
       gzip is used to compress files.
       It's probably the most widely used UNIX compression program.
 
+config FEATURE_GZIP_LONG_OPTIONS
+    bool "Enable long options"
+    default y
+    depends on GZIP && LONG_OPTS
+    help
+      Enable use of long options, increases size by about 106 Bytes
+
+config LZOP
+    bool "lzop"
+    default y
+    help
+      Lzop compression/decompresion.
+
+config LZOP_COMPR_HIGH
+    bool "lzop compression levels 7,8,9 (not very useful)"
+    default n
+    depends on LZOP
+    help
+      High levels (7,8,9) of lzop compression. These levels
+      are actually slower than gzip at equivalent compression ratios
+      and take up 3.2K of code.
+
 config RPM2CPIO
     bool "rpm2cpio"
-    default n
-    help
-      Converts an RPM file into a CPIO archive.
+    default y
+    help
+      Converts a RPM file into a CPIO archive.
 
 config RPM
     bool "rpm"
-    default n
+    default y
     help
       Mini RPM applet - queries and extracts RPM packages.
-
-config FEATURE_RPM_BZ2
-    bool "Enable handling of rpms with bzip2-compressed data inside"
-    default n
-    depends on RPM
-    help
-      Enable handling of rpms with bzip2-compressed data inside.
 
 config TAR
     bool "tar"
-    default n
+    default y
     help
       tar is an archiving program. It's commonly used with gzip to
@@ -157 +232 @@
       tar archives using the `-c' option.
 
-config FEATURE_TAR_BZIP2
-    bool "Enable -j option to handle .tar.bz2 files"
-    default n
-    depends on TAR
-    help
-      If you enable this option you'll be able to extract
-      archives compressed with bzip2.
-
-config FEATURE_TAR_LZMA
-    bool "Enable -a option to handle .tar.lzma files"
-    default n
-    depends on TAR
-    help
-      If you enable this option you'll be able to extract
-      archives compressed with lzma.
+config FEATURE_TAR_AUTODETECT
+    bool "Autodetect compressed tarballs"
+    default y
+    depends on TAR && (FEATURE_SEAMLESS_Z || FEATURE_SEAMLESS_GZ || FEATURE_SEAMLESS_BZ2 || FEATURE_SEAMLESS_LZMA || FEATURE_SEAMLESS_XZ)
+    help
+      With this option tar can automatically detect compressed
+      tarballs. Currently it works only on files (not pipes etc).
 
 config FEATURE_TAR_FROM
     bool "Enable -X (exclude from) and -T (include from) options)"
-    default n
+    default y
     depends on TAR
     help
@@ -181 +248 @@
       a list of files to include or exclude from an archive.
 
-config FEATURE_TAR_GZIP
-    bool "Enable -z option"
-    default y
-    depends on TAR
-    help
-      If you enable this option tar will be able to call gzip,
-      when creating or extracting tar gziped archives.
-
-config FEATURE_TAR_COMPRESS
-    bool "Enable -Z option"
-    default n
-    depends on TAR
-    help
-      If you enable this option tar will be able to call uncompress,
-      when extracting .tar.Z archives.
-
 config FEATURE_TAR_OLDGNU_COMPATIBILITY
-    bool "Enable support for old tar header format"
-    default N
-    depends on TAR
+    bool "Support for old tar header format"
+    default y
+    depends on TAR || DPKG
     help
       This option is required to unpack archives created in
@@ -208 +259 @@
 config FEATURE_TAR_OLDSUN_COMPATIBILITY
     bool "Enable untarring of tarballs with checksums produced by buggy Sun tar"
-    default N
-    depends on TAR
+    default y
+    depends on TAR || DPKG
     help
       This option is required to unpack archives created by some old
-      version of Sun's tar (it was calculating checksum using signed arithmetic).
-      It is said to be fixed in newer Sun tar, but "old" tarballs still exist.
+      version of Sun's tar (it was calculating checksum using signed
+      arithmetic). It is said to be fixed in newer Sun tar, but "old"
+      tarballs still exist.
 
 config FEATURE_TAR_GNU_EXTENSIONS
-    bool "Enable support for some GNU tar extensions"
-    default y
-    depends on TAR
+    bool "Support for GNU tar extensions (long filenames)"
+    default y
+    depends on TAR || DPKG
     help
       With this option busybox supports GNU long filenames and
@@ -225 +277 @@
 config FEATURE_TAR_LONG_OPTIONS
     bool "Enable long options"
-    default n
-    depends on TAR && GETOPT_LONG
-    help
-        Enable use of long options, increases size by about 400 Bytes
+    default y
+    depends on TAR && LONG_OPTS
+    help
+      Enable use of long options, increases size by about 400 Bytes
+
+config FEATURE_TAR_TO_COMMAND
+    bool "Support for writing to an external program"
+    default y
+    depends on TAR && FEATURE_TAR_LONG_OPTIONS
+    help
+      If you enable this option you'll be able to instruct tar to send
+      the contents of each extracted file to the standard input of an
+      external program.
+
+config FEATURE_TAR_UNAME_GNAME
+    bool "Enable use of user and group names"
+    default y
+    depends on TAR
+    help
+      Enables use of user and group names in tar. This affects contents
+      listings (-t) and preserving permissions when unpacking (-p).
+      +200 bytes.
+
+config FEATURE_TAR_NOPRESERVE_TIME
+    bool "Enable -m (do not preserve time) option"
+    default y
+    depends on TAR
+    help
+      With this option busybox supports GNU tar -m
+      (do not preserve time) option.
+
+config FEATURE_TAR_SELINUX
+    bool "Support for extracting SELinux labels"
+    default n
+    depends on TAR && SELINUX
+    help
+      With this option busybox supports restoring SELinux labels
+      when extracting files from tar archives.
 
 config UNCOMPRESS
@@ -239 +325 @@
 config UNLZMA
     bool "unlzma"
-    default n
+    default y
     help
       unlzma is a compression utility using the Lempel-Ziv-Markov chain
-      compression algorithm, and range coding.  Compression
+      compression algorithm, and range coding. Compression
       is generally considerably better than that achieved by the bzip2
       compressors.
@@ -253 +339 @@
 
 config FEATURE_LZMA_FAST
-    bool "Optimze unlzma for speed"
-    default n
+    bool "Optimize unlzma for speed"
+    default y
     depends on UNLZMA
     help
-      This option reduces decompression time by about 33% at the cost of
-      a 2K bigger binary.
+      This option reduces decompression time by about 25% at the cost of
+      a 1K bigger binary.
+
+config LZMA
+    bool "Provide lzma alias which supports only unpacking"
+    default y
+    depends on UNLZMA
+    help
+      Enable this option if you want commands like "lzma -d" to work.
+      IOW: you'll get lzma applet, but it will always require -d option.
+
+config UNXZ
+    bool "unxz"
+    default y
+    help
+      unxz is a unlzma successor.
+
+config XZ
+    bool "Provide xz alias which supports only unpacking"
+    default y
+    depends on UNXZ
+    help
+      Enable this option if you want commands like "xz -d" to work.
+      IOW: you'll get xz applet, but it will always require -d option.
 
 config UNZIP
     bool "unzip"
-    default n
+    default y
     help
       unzip will list or extract files from a ZIP archive,
@@ -270 +378 @@
       directory of your choice.
 
-comment "Common options for cpio and tar"
-    depends on CPIO || TAR
-
-config FEATURE_UNARCHIVE_TAPE
-    bool "Enable tape drive support"
-    default n
-    depends on CPIO || TAR
-    help
-      I don't think this is needed anymore.
-
-comment "Common options for dpkg and dpkg_deb"
-    depends on DPKG || DPKG_DEB
-
-config FEATURE_DEB_TAR_GZ
-    bool "gzip debian packages (normal)"
-    default y if DPKG || DPKG_DEB
-    depends on DPKG || DPKG_DEB
-    help
-      This is the default compression method inside the debian ar file.
-
-      If you want compatibility with standard .deb's you should say yes here.
-
-config FEATURE_DEB_TAR_BZ2
-    bool "bzip2 debian packages"
-    default n
-    depends on DPKG || DPKG_DEB
-    help
-      This allows dpkg and dpkg-deb to extract deb's that are compressed internally
-      with bzip2 instead of gzip.
-
-      You only want this if you are creating your own custom debian packages that
-      use an internal control.tar.bz2 or data.tar.bz2.
-
-config FEATURE_DEB_TAR_LZMA
-    bool "lzma debian packages"
-    default n
-    depends on DPKG || DPKG_DEB
-    help
-      This allows dpkg and dpkg-deb to extract deb's that are compressed
-      internally with lzma instead of gzip.
-
-      You only want this if you are creating your own custom debian
-      packages that use an internal control.tar.lzma or data.tar.lzma.
-
 endmenu

branches/2.2.9/mindi-busybox/archival/Kbuild

@@ +1 @@
+# DO NOT EDIT. This file is generated from Kbuild.src
 # Makefile for busybox
 #
 # Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
 #
-# Licensed under the GPL v2, see the file LICENSE in this tarball.
+# Licensed under GPLv2, see file LICENSE in this source tree.
 
-libs-y              += libunarchive/
+libs-y              += libarchive/
 
 lib-y:=
+
+
+
 lib-$(CONFIG_AR)        += ar.o
-lib-$(CONFIG_BUNZIP2)       += bbunzip.o
-lib-$(CONFIG_UNLZMA)        += bbunzip.o
 lib-$(CONFIG_CPIO)      += cpio.o
 lib-$(CONFIG_DPKG)      += dpkg.o
 lib-$(CONFIG_DPKG_DEB)      += dpkg_deb.o
-lib-$(CONFIG_GUNZIP)        += bbunzip.o
-lib-$(CONFIG_GZIP)      += gzip.o bbunzip.o
 lib-$(CONFIG_RPM2CPIO)      += rpm2cpio.o
 lib-$(CONFIG_RPM)       += rpm.o
 lib-$(CONFIG_TAR)       += tar.o
+lib-$(CONFIG_UNZIP)     += unzip.o
+
+lib-$(CONFIG_LZOP)      += lzop.o bbunzip.o
+lib-$(CONFIG_GZIP)      += gzip.o bbunzip.o
+lib-$(CONFIG_BZIP2)     += bzip2.o bbunzip.o
+
+lib-$(CONFIG_UNXZ)      += bbunzip.o
+lib-$(CONFIG_UNLZMA)        += bbunzip.o
+lib-$(CONFIG_BUNZIP2)       += bbunzip.o
+lib-$(CONFIG_GUNZIP)        += bbunzip.o
 lib-$(CONFIG_UNCOMPRESS)    += bbunzip.o
-lib-$(CONFIG_UNZIP)     += unzip.o

branches/2.2.9/mindi-busybox/archival/ar.c

@@ -4 +4 @@
  *
  * Copyright (C) 2000 by Glenn McGrath
- * Written by Glenn McGrath <bug1@iinet.net.au> 1 June 2000
  *
  * Based in part on BusyBox tar, Debian dpkg-deb and GNU ar.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ *
+ * Archive creation support:
+ * Copyright (C) 2010 Nokia Corporation. All rights reserved.
+ * Written by Alexander Shishkin.
  *
  * There is no single standard to adhere to so ar may not portable
@@ -16 +19 @@
 
 #include "libbb.h"
-#include "unarchive.h"
-
-static void header_verbose_list_ar(const file_header_t *file_header)
+#include "archive.h"
+#include "ar.h"
+
+#if ENABLE_FEATURE_AR_CREATE
+/* filter out entries with same names as specified on the command line */
+static char FAST_FUNC filter_replaceable(archive_handle_t *handle)
+{
+    if (find_list_entry(handle->accept, handle->file_header->name))
+        return EXIT_FAILURE;
+
+    return EXIT_SUCCESS;
+}
+
+static void output_ar_header(archive_handle_t *handle)
+{
+    /* GNU ar 2.19.51.0.14 creates malformed archives
+     * if input files are >10G. It also truncates files >4GB
+     * (uses "size mod 4G"). We abort in this case:
+     * We could add support for up to 10G files, but this is unlikely to be useful.
+     * Note that unpacking side limits all fields to "unsigned int" data type,
+     * and treats "all ones" as an error indicator. Thus max we allow here is UINT_MAX-1.
+     */
+    enum {
+        /* for 2nd field: mtime */
+        MAX11CHARS = UINT_MAX > 0xffffffff ? (unsigned)99999999999 : UINT_MAX-1,
+        /* for last field: filesize */
+        MAX10CHARS = UINT_MAX > 0xffffffff ? (unsigned)9999999999 : UINT_MAX-1,
+    };
+
+    struct file_header_t *fh = handle->file_header;
+
+    if (handle->offset & 1) {
+        xwrite(handle->src_fd, "\n", 1);
+        handle->offset++;
+    }
+
+    /* Careful! The widths should be exact. Fields must be separated */
+    if (sizeof(off_t) > 4 && fh->size > (off_t)MAX10CHARS) {
+        bb_error_msg_and_die("'%s' is bigger than ar can handle", fh->name);
+    }
+    fdprintf(handle->src_fd, "%-16.16s%-12lu%-6u%-6u%-8o%-10"OFF_FMT"u`\n",
+            fh->name,
+            (sizeof(time_t) > 4 && fh->mtime > MAX11CHARS) ? (long)0 : (long)fh->mtime,
+            fh->uid > 99999 ? 0 : (int)fh->uid,
+            fh->gid > 99999 ? 0 : (int)fh->gid,
+            (int)fh->mode & 07777777,
+            fh->size
+    );
+
+    handle->offset += AR_HEADER_LEN;
+}
+
+/*
+ * when replacing files in an existing archive, copy from the the
+ * original archive those files that are to be left intact
+ */
+static void FAST_FUNC copy_data(archive_handle_t *handle)
+{
+    archive_handle_t *out_handle = handle->ar__out;
+    struct file_header_t *fh = handle->file_header;
+
+    out_handle->file_header = fh;
+    output_ar_header(out_handle);
+
+    bb_copyfd_exact_size(handle->src_fd, out_handle->src_fd, fh->size);
+    out_handle->offset += fh->size;
+}
+
+static int write_ar_header(archive_handle_t *handle)
+{
+    char *fn;
+    char fn_h[17]; /* 15 + "/" + NUL */
+    struct stat st;
+    int fd;
+
+    fn = llist_pop(&handle->accept);
+    if (!fn)
+        return -1;
+
+    xstat(fn, &st);
+
+    handle->file_header->mtime = st.st_mtime;
+    handle->file_header->uid = st.st_uid;
+    handle->file_header->gid = st.st_gid;
+    handle->file_header->mode = st.st_mode;
+    handle->file_header->size = st.st_size;
+    handle->file_header->name = fn_h;
+//TODO: if ENABLE_FEATURE_AR_LONG_FILENAMES...
+    sprintf(fn_h, "%.15s/", bb_basename(fn));
+
+    output_ar_header(handle);
+
+    fd = xopen(fn, O_RDONLY);
+    bb_copyfd_exact_size(fd, handle->src_fd, st.st_size);
+    close(fd);
+    handle->offset += st.st_size;
+
+    return 0;
+}
+
+static int write_ar_archive(archive_handle_t *handle)
+{
+    struct stat st;
+    archive_handle_t *out_handle;
+
+    xfstat(handle->src_fd, &st, handle->ar__name);
+
+    /* if archive exists, create a new handle for output.
+     * we create it in place of the old one.
+     */
+    if (st.st_size != 0) {
+        out_handle = init_handle();
+        xunlink(handle->ar__name);
+        out_handle->src_fd = xopen(handle->ar__name, O_WRONLY | O_CREAT | O_TRUNC);
+        out_handle->accept = handle->accept;
+    } else {
+        out_handle = handle;
+    }
+
+    handle->ar__out = out_handle;
+
+    xwrite(out_handle->src_fd, AR_MAGIC "\n", AR_MAGIC_LEN + 1);
+    out_handle->offset += AR_MAGIC_LEN + 1;
+
+    /* skip to the end of the archive if we have to append stuff */
+    if (st.st_size != 0) {
+        handle->filter = filter_replaceable;
+        handle->action_data = copy_data;
+        unpack_ar_archive(handle);
+    }
+
+    while (write_ar_header(out_handle) == 0)
+        continue;
+
+    /* optional, since we exit right after we return */
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        close(handle->src_fd);
+        if (out_handle->src_fd != handle->src_fd)
+            close(out_handle->src_fd);
+    }
+
+    return EXIT_SUCCESS;
+}
+#endif /* FEATURE_AR_CREATE */
+
+static void FAST_FUNC header_verbose_list_ar(const file_header_t *file_header)
 {
     const char *mode = bb_mode_string(file_header->mode);
@@ -27 +173 @@
     memmove(&mtime[17], &mtime[20], 4);
     mtime[21] = '\0';
-    printf("%s %d/%d%7d %s %s\n", &mode[1], file_header->uid, file_header->gid,
-            (int) file_header->size, &mtime[4], file_header->name);
-}
-
-#define AR_CTX_PRINT        0x01
-#define AR_CTX_LIST     0x02
-#define AR_CTX_EXTRACT      0x04
-#define AR_OPT_PRESERVE_DATE    0x08
-#define AR_OPT_VERBOSE      0x10
-#define AR_OPT_CREATE       0x20
-#define AR_OPT_INSERT       0x40
-
-int ar_main(int argc, char **argv);
-int ar_main(int argc, char **argv)
-{
-    static const char msg_unsupported_err[] ALIGN1 =
-        "archive %s is not supported";
-
+    printf("%s %u/%u%7"OFF_FMT"u %s %s\n", &mode[1],
+            (int)file_header->uid, (int)file_header->gid,
+            file_header->size,
+            &mtime[4], file_header->name
+    );
+}
+
+#define AR_OPT_VERBOSE          (1 << 0)
+#define AR_OPT_PRESERVE_DATE    (1 << 1)
+/* "ar r" implies create, but warns about it. c suppresses warning.
+ * bbox accepts but ignores it: */
+#define AR_OPT_CREATE           (1 << 2)
+
+#define AR_CMD_PRINT            (1 << 3)
+#define FIRST_CMD               AR_CMD_PRINT
+#define AR_CMD_LIST             (1 << 4)
+#define AR_CMD_EXTRACT          (1 << 5)
+#define AR_CMD_INSERT           (1 << 6)
+
+int ar_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int ar_main(int argc UNUSED_PARAM, char **argv)
+{
     archive_handle_t *archive_handle;
-    unsigned opt;
-    char magic[8];
+    unsigned opt, t;
 
     archive_handle = init_handle();
 
-    /* Prepend '-' to the first argument if required */
-    opt_complementary = "--:p:t:x:-1:p--tx:t--px:x--pt";
-    opt = getopt32(argv, "ptxovcr");
-
-    if (opt & AR_CTX_PRINT) {
+    /* --: prepend '-' to the first argument if required */
+    /* -1: at least one param is reqd */
+    /* one of p,t,x[,r] is required */
+    opt_complementary = "--:-1:p:t:x"IF_FEATURE_AR_CREATE(":r");
+    opt = getopt32(argv, "voc""ptx"IF_FEATURE_AR_CREATE("r"));
+    argv += optind;
+
+    t = opt / FIRST_CMD;
+    if (t & (t-1)) /* more than one of p,t,x[,r] are specified */
+        bb_show_usage();
+
+    if (opt & AR_CMD_PRINT) {
         archive_handle->action_data = data_extract_to_stdout;
     }
-    if (opt & AR_CTX_LIST) {
+    if (opt & AR_CMD_LIST) {
         archive_handle->action_header = header_list;
     }
-    if (opt & AR_CTX_EXTRACT) {
+    if (opt & AR_CMD_EXTRACT) {
         archive_handle->action_data = data_extract_all;
     }
     if (opt & AR_OPT_PRESERVE_DATE) {
-        archive_handle->flags |= ARCHIVE_PRESERVE_DATE;
+        archive_handle->ah_flags |= ARCHIVE_RESTORE_DATE;
     }
     if (opt & AR_OPT_VERBOSE) {
         archive_handle->action_header = header_verbose_list_ar;
     }
-    if (opt & AR_OPT_CREATE) {
-        bb_error_msg_and_die(msg_unsupported_err, "creation");
-    }
-    if (opt & AR_OPT_INSERT) {
-        bb_error_msg_and_die(msg_unsupported_err, "insertion");
-    }
-
-    archive_handle->src_fd = xopen(argv[optind++], O_RDONLY);
-
-    while (optind < argc) {
+#if ENABLE_FEATURE_AR_CREATE
+    archive_handle->ar__name = *argv;
+#endif
+    archive_handle->src_fd = xopen(*argv++,
+            (opt & AR_CMD_INSERT)
+                ? O_RDWR | O_CREAT
+                : O_RDONLY
+    );
+
+    if (*argv)
         archive_handle->filter = filter_accept_list;
-        llist_add_to(&(archive_handle->accept), argv[optind++]);
-    }
-
-    xread(archive_handle->src_fd, 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)
-        continue;
+    while (*argv) {
+        llist_add_to_end(&archive_handle->accept, *argv++);
+    }
+
+#if ENABLE_FEATURE_AR_CREATE
+    if (opt & AR_CMD_INSERT)
+        return write_ar_archive(archive_handle);
+#endif
+
+    unpack_ar_archive(archive_handle);
 
     return EXIT_SUCCESS;

branches/2.2.9/mindi-busybox/archival/bbunzip.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- *  Common code for gunzip-like applets
- *
- *  Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
- */
-
+ * Common code for gunzip-like applets
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
 #include "libbb.h"
-#include "unarchive.h"
+#include "archive.h"
 
 enum {
-    OPT_STDOUT = 0x1,
-    OPT_FORCE = 0x2,
-/* gunzip only: */
-    OPT_VERBOSE = 0x4,
-    OPT_DECOMPRESS = 0x8,
-    OPT_TEST = 0x10,
+    OPT_STDOUT     = 1 << 0,
+    OPT_FORCE      = 1 << 1,
+    /* only some decompressors: */
+    OPT_VERBOSE    = 1 << 2,
+    OPT_DECOMPRESS = 1 << 3,
+    OPT_TEST       = 1 << 4,
 };
 
@@ -29 +28 @@
 }
 
-int bbunpack(char **argv,
-    char* (*make_new_name)(char *filename),
-    USE_DESKTOP(long long) int (*unpacker)(void)
+char* FAST_FUNC append_ext(char *filename, const char *expected_ext)
+{
+    return xasprintf("%s.%s", filename, expected_ext);
+}
+
+int FAST_FUNC bbunpack(char **argv,
+    IF_DESKTOP(long long) int FAST_FUNC (*unpacker)(unpack_info_t *info),
+    char* FAST_FUNC (*make_new_name)(char *filename, const char *expected_ext),
+    const char *expected_ext
 )
 {
     struct stat stat_buf;
-    USE_DESKTOP(long long) int status;
+    IF_DESKTOP(long long) int status;
     char *filename, *new_name;
     smallint exitcode = 0;
+    unpack_info_t info;
 
     do {
@@ -50 +56 @@
         if (filename) {
             if (stat(filename, &stat_buf) != 0) {
-                bb_perror_msg("%s", filename);
+                bb_simple_perror_msg(filename);
  err:
                 exitcode = 1;
@@ -69 +75 @@
         /* Open dst if we are going to unpack to file */
         if (filename) {
-            new_name = make_new_name(filename);
+            new_name = make_new_name(filename, expected_ext);
             if (!new_name) {
                 bb_error_msg("%s: unknown suffix - ignored", filename);
                 goto err;
             }
+
+            /* -f: overwrite existing output files */
+            if (option_mask32 & OPT_FORCE) {
+                unlink(new_name);
+            }
+
             /* O_EXCL: "real" bunzip2 doesn't overwrite files */
-            /* GNU gunzip goes not bail out, but goes to next file */
+            /* GNU gunzip does not bail out, but goes to next file */
             if (open_to_or_warn(STDOUT_FILENO, new_name, O_WRONLY | O_CREAT | O_EXCL,
                     stat_buf.st_mode))
@@ -87 +99 @@
         }
 
-        status = unpacker();
+        /* memset(&info, 0, sizeof(info)); */
+        info.mtime = 0; /* so far it has one member only */
+        status = unpacker(&info);
         if (status < 0)
             exitcode = 1;
+        xclose(STDOUT_FILENO); /* with error check! */
 
         if (filename) {
             char *del = new_name;
             if (status >= 0) {
-                /* TODO: restore user/group/times here? */
+                /* TODO: restore other things? */
+                if (info.mtime) {
+                    struct timeval times[2];
+
+                    times[1].tv_sec = times[0].tv_sec = info.mtime;
+                    times[1].tv_usec = times[0].tv_usec = 0;
+                    /* Note: we closed it first.
+                     * On some systems calling utimes
+                     * then closing resets the mtime
+                     * back to current time. */
+                    utimes(new_name, times); /* ignoring errors */
+                }
+
                 /* Delete _compressed_ file */
                 del = filename;
@@ -120 +147 @@
 }
 
-#if ENABLE_BUNZIP2 || ENABLE_UNLZMA || ENABLE_UNCOMPRESS
-
-static
-char* make_new_name_generic(char *filename, const char *expected_ext)
+#if ENABLE_UNCOMPRESS || ENABLE_BUNZIP2 || ENABLE_UNLZMA || ENABLE_UNXZ
+static
+char* FAST_FUNC make_new_name_generic(char *filename, const char *expected_ext)
 {
     char *extension = strrchr(filename, '.');
@@ -134 +160 @@
     return filename;
 }
-
-#endif
-
-
-/*
- *  Modified for busybox by Glenn McGrath <bug1@iinet.net.au>
- *  Added support output to stdout by Thomas Lundquist <thomasez@zelow.no>
- *
- *  Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
- */
-
-#if ENABLE_BUNZIP2
-
-static
-char* make_new_name_bunzip2(char *filename)
-{
-    return make_new_name_generic(filename, "bz2");
-}
-
-static
-USE_DESKTOP(long long) int unpack_bunzip2(void)
-{
-    return unpack_bz2_stream(STDIN_FILENO, STDOUT_FILENO);
-}
-
-int bunzip2_main(int argc, char **argv);
-int bunzip2_main(int argc, char **argv)
+#endif
+
+
+/*
+ * Uncompress applet for busybox (c) 2002 Glenn McGrath
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+#if ENABLE_UNCOMPRESS
+static
+IF_DESKTOP(long long) int FAST_FUNC unpack_uncompress(unpack_info_t *info UNUSED_PARAM)
+{
+    IF_DESKTOP(long long) int status = -1;
+
+    if ((xread_char(STDIN_FILENO) != 0x1f) || (xread_char(STDIN_FILENO) != 0x9d)) {
+        bb_error_msg("invalid magic");
+    } else {
+        status = unpack_Z_stream(STDIN_FILENO, STDOUT_FILENO);
+    }
+    return status;
+}
+int uncompress_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int uncompress_main(int argc UNUSED_PARAM, char **argv)
 {
     getopt32(argv, "cf");
     argv += optind;
-    if (applet_name[2] == 'c')
-        option_mask32 |= OPT_STDOUT;
-
-    return bbunpack(argv, make_new_name_bunzip2, unpack_bunzip2);
-}
-
+
+    return bbunpack(argv, unpack_uncompress, make_new_name_generic, "Z");
+}
 #endif
 
@@ -186 +205 @@
  *
  * General cleanup to better adhere to the style guide and make use of standard
- * busybox functions by Glenn McGrath <bug1@iinet.net.au>
- *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * busybox functions by Glenn McGrath
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
@@ -200 +219 @@
  * See the file algorithm.doc for the compression algorithms and file formats.
  */
-
 #if ENABLE_GUNZIP
-
-static
-char* make_new_name_gunzip(char *filename)
+static
+char* FAST_FUNC make_new_name_gunzip(char *filename, const char *expected_ext UNUSED_PARAM)
 {
     char *extension = strrchr(filename, '.');
@@ -213 +230 @@
     extension++;
     if (strcmp(extension, "tgz" + 1) == 0
-#if ENABLE_FEATURE_GUNZIP_UNCOMPRESS
-     || strcmp(extension, "Z") == 0
+#if ENABLE_FEATURE_SEAMLESS_Z
+     || (extension[0] == 'Z' && extension[1] == '\0')
 #endif
     ) {
@@ -228 +245 @@
     return filename;
 }
-
-static
-USE_DESKTOP(long long) int unpack_gunzip(void)
-{
-    USE_DESKTOP(long long) int status = -1;
+static
+IF_DESKTOP(long long) int FAST_FUNC unpack_gunzip(unpack_info_t *info)
+{
+    IF_DESKTOP(long long) int status = -1;
 
     /* do the decompression, and cleanup */
@@ -239 +255 @@
 
         magic2 = xread_char(STDIN_FILENO);
-        if (ENABLE_FEATURE_GUNZIP_UNCOMPRESS && magic2 == 0x9d) {
-            status = uncompress(STDIN_FILENO, STDOUT_FILENO);
+        if (ENABLE_FEATURE_SEAMLESS_Z && magic2 == 0x9d) {
+            status = unpack_Z_stream(STDIN_FILENO, STDOUT_FILENO);
         } else if (magic2 == 0x8b) {
-            check_header_gzip_or_die(STDIN_FILENO);
-            status = unpack_gz_stream(STDIN_FILENO, STDOUT_FILENO);
+            status = unpack_gz_stream_with_info(STDIN_FILENO, STDOUT_FILENO, info);
         } else {
             goto bad_magic;
@@ -257 +272 @@
     return status;
 }
-
-int gunzip_main(int argc, char **argv);
-int gunzip_main(int argc, char **argv)
-{
-    getopt32(argv, "cfvdt");
+/*
+ * Linux kernel build uses gzip -d -n. We accept and ignore it.
+ * Man page says:
+ * -n --no-name
+ * gzip: do not save the original file name and time stamp.
+ * (The original name is always saved if the name had to be truncated.)
+ * gunzip: do not restore the original file name/time even if present
+ * (remove only the gzip suffix from the compressed file name).
+ * This option is the default when decompressing.
+ * -N --name
+ * gzip: always save the original file name and time stamp (this is the default)
+ * gunzip: restore the original file name and time stamp if present.
+ */
+int gunzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int gunzip_main(int argc UNUSED_PARAM, char **argv)
+{
+    getopt32(argv, "cfvdtn");
     argv += optind;
     /* if called as zcat */
@@ -267 +294 @@
         option_mask32 |= OPT_STDOUT;
 
-    return bbunpack(argv, make_new_name_gunzip, unpack_gunzip);
-}
-
+    return bbunpack(argv, unpack_gunzip, make_new_name_gunzip, /*unused:*/ NULL);
+}
+#endif
+
+
+/*
+ * Modified for busybox by Glenn McGrath
+ * Added support output to stdout by Thomas Lundquist <thomasez@zelow.no>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+//usage:#define bunzip2_trivial_usage
+//usage:       "[-cf] [FILE]..."
+//usage:#define bunzip2_full_usage "\n\n"
+//usage:       "Decompress FILEs (or stdin)\n"
+//usage:     "\nOptions:"
+//usage:     "\n    -c  Write to stdout"
+//usage:     "\n    -f  Force"
+//usage:#define bzcat_trivial_usage
+//usage:       "FILE"
+//usage:#define bzcat_full_usage "\n\n"
+//usage:       "Decompress to stdout"
+//applet:IF_BUNZIP2(APPLET(bunzip2, _BB_DIR_USR_BIN, _BB_SUID_DROP))
+//applet:IF_BUNZIP2(APPLET_ODDNAME(bzcat, bunzip2, _BB_DIR_USR_BIN, _BB_SUID_DROP, bzcat))
+#if ENABLE_BUNZIP2
+static
+IF_DESKTOP(long long) int FAST_FUNC unpack_bunzip2(unpack_info_t *info UNUSED_PARAM)
+{
+    return unpack_bz2_stream_prime(STDIN_FILENO, STDOUT_FILENO);
+}
+int bunzip2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int bunzip2_main(int argc UNUSED_PARAM, char **argv)
+{
+    getopt32(argv, "cfvdt");
+    argv += optind;
+    if (applet_name[2] == 'c') /* bzcat */
+        option_mask32 |= OPT_STDOUT;
+
+    return bbunpack(argv, unpack_bunzip2, make_new_name_generic, "bz2");
+}
 #endif
 
@@ -279 +343 @@
  * Based on bunzip.c from busybox
  *
- * Licensed under GPL v2, see file LICENSE in this tarball for details.
- */
-
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
 #if ENABLE_UNLZMA
-
-static
-char* make_new_name_unlzma(char *filename)
-{
-    return make_new_name_generic(filename, "lzma");
-}
-
-static
-USE_DESKTOP(long long) int unpack_unlzma(void)
+static
+IF_DESKTOP(long long) int FAST_FUNC unpack_unlzma(unpack_info_t *info UNUSED_PARAM)
 {
     return unpack_lzma_stream(STDIN_FILENO, STDOUT_FILENO);
 }
-
-int unlzma_main(int argc, char **argv);
-int unlzma_main(int argc, char **argv)
-{
-    getopt32(argv, "cf");
+int unlzma_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int unlzma_main(int argc UNUSED_PARAM, char **argv)
+{
+    IF_LZMA(int opts =) getopt32(argv, "cfvdt");
+# if ENABLE_LZMA
+    /* lzma without -d or -t? */
+    if (applet_name[2] == 'm' && !(opts & (OPT_DECOMPRESS|OPT_TEST)))
+        bb_show_usage();
+# endif
+    /* lzcat? */
+    if (applet_name[2] == 'c')
+        option_mask32 |= OPT_STDOUT;
+
     argv += optind;
-    /* lzmacat? */
-    if (applet_name[4] == 'c')
+    return bbunpack(argv, unpack_unlzma, make_new_name_generic, "lzma");
+}
+#endif
+
+
+#if ENABLE_UNXZ
+static
+IF_DESKTOP(long long) int FAST_FUNC unpack_unxz(unpack_info_t *info UNUSED_PARAM)
+{
+    struct {
+        uint32_t v1;
+        uint16_t v2;
+    } magic;
+    xread(STDIN_FILENO, &magic, 6);
+    if (magic.v1 != XZ_MAGIC1a || magic.v2 != XZ_MAGIC2a) {
+        bb_error_msg("invalid magic");
+        return -1;
+    }
+    return unpack_xz_stream(STDIN_FILENO, STDOUT_FILENO);
+}
+int unxz_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int unxz_main(int argc UNUSED_PARAM, char **argv)
+{
+    IF_XZ(int opts =) getopt32(argv, "cfvdt");
+# if ENABLE_XZ
+    /* xz without -d or -t? */
+    if (applet_name[2] == '\0' && !(opts & (OPT_DECOMPRESS|OPT_TEST)))
+        bb_show_usage();
+# endif
+    /* xzcat? */
+    if (applet_name[2] == 'c')
         option_mask32 |= OPT_STDOUT;
 
-    return bbunpack(argv, make_new_name_unlzma, unpack_unlzma);
-}
-
-#endif
-
-
-/*
- *  Uncompress applet for busybox (c) 2002 Glenn McGrath
- *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
- */
-
-#if ENABLE_UNCOMPRESS
-
-static
-char* make_new_name_uncompress(char *filename)
-{
-    return make_new_name_generic(filename, "Z");
-}
-
-static
-USE_DESKTOP(long long) int unpack_uncompress(void)
-{
-    USE_DESKTOP(long long) int status = -1;
-
-    if ((xread_char(STDIN_FILENO) != 0x1f) || (xread_char(STDIN_FILENO) != 0x9d)) {
-        bb_error_msg("invalid magic");
-    } else {
-        status = uncompress(STDIN_FILENO, STDOUT_FILENO);
-    }
-    return status;
-}
-
-int uncompress_main(int argc, char **argv);
-int uncompress_main(int argc, char **argv)
-{
-    getopt32(argv, "cf");
     argv += optind;
-
-    return bbunpack(argv, make_new_name_uncompress, unpack_uncompress);
-}
-
-#endif
+    return bbunpack(argv, unpack_unxz, make_new_name_generic, "xz");
+}
+#endif

branches/2.2.9/mindi-busybox/archival/cpio.c

@@ -5 +5 @@
  * Copyright (C) 2001 by Glenn McGrath
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * Limitations:
- *      Doesn't check CRC's
- *      Only supports new ASCII and CRC formats
+ * Doesn't check CRC's
+ * Only supports new ASCII and CRC formats
  *
  */
 #include "libbb.h"
-#include "unarchive.h"
-
-#define CPIO_OPT_EXTRACT                0x01
-#define CPIO_OPT_TEST                   0x02
-#define CPIO_OPT_UNCONDITIONAL          0x04
-#define CPIO_OPT_VERBOSE                0x08
-#define CPIO_OPT_FILE                   0x10
-#define CPIO_OPT_CREATE_LEADING_DIR     0x20
-#define CPIO_OPT_PRESERVE_MTIME         0x40
-
-int cpio_main(int argc, char **argv);
-int cpio_main(int argc, char **argv)
+#include "archive.h"
+
+/* GNU cpio 2.9 --help (abridged):
+
+ Modes:
+  -t, --list                 List the archive
+  -i, --extract              Extract files from an archive
+  -o, --create               Create the archive
+  -p, --pass-through         Copy-pass mode [was ist das?!]
+
+ Options valid in any mode:
+      --block-size=SIZE      I/O block size = SIZE * 512 bytes
+  -B                         I/O block size = 5120 bytes
+  -c                         Use the old portable (ASCII) archive format
+  -C, --io-size=NUMBER       I/O block size in bytes
+  -f, --nonmatching          Only copy files that do not match given pattern
+  -F, --file=FILE            Use FILE instead of standard input or output
+  -H, --format=FORMAT        Use given archive FORMAT
+  -M, --message=STRING       Print STRING when the end of a volume of the
+                             backup media is reached
+  -n, --numeric-uid-gid      If -v, show numeric UID and GID
+      --quiet                Do not print the number of blocks copied
+      --rsh-command=COMMAND  Use remote COMMAND instead of rsh
+  -v, --verbose              Verbosely list the files processed
+  -V, --dot                  Print a "." for each file processed
+  -W, --warning=FLAG         Control warning display: 'none','truncate','all';
+                             multiple options accumulate
+
+ Options valid only in --extract mode:
+  -b, --swap                 Swap both halfwords of words and bytes of
+                             halfwords in the data (equivalent to -sS)
+  -r, --rename               Interactively rename files
+  -s, --swap-bytes           Swap the bytes of each halfword in the files
+  -S, --swap-halfwords       Swap the halfwords of each word (4 bytes)
+      --to-stdout            Extract files to standard output
+  -E, --pattern-file=FILE    Read additional patterns specifying filenames to
+                             extract or list from FILE
+      --only-verify-crc      Verify CRC's, don't actually extract the files
+
+ Options valid only in --create mode:
+  -A, --append               Append to an existing archive
+  -O FILE                    File to use instead of standard output
+
+ Options valid only in --pass-through mode:
+  -l, --link                 Link files instead of copying them, when possible
+
+ Options valid in --extract and --create modes:
+      --absolute-filenames   Do not strip file system prefix components from
+                             the file names
+      --no-absolute-filenames Create all files relative to the current dir
+
+ Options valid in --create and --pass-through modes:
+  -0, --null                 A list of filenames is terminated by a NUL
+  -a, --reset-access-time    Reset the access times of files after reading them
+  -I FILE                    File to use instead of standard input
+  -L, --dereference          Dereference symbolic links (copy the files
+                             that they point to instead of copying the links)
+  -R, --owner=[USER][:.][GROUP] Set owner of created files
+
+ Options valid in --extract and --pass-through modes:
+  -d, --make-directories     Create leading directories where needed
+  -m, --preserve-modification-time  Retain mtime when creating files
+      --no-preserve-owner    Do not change the ownership of the files
+      --sparse               Write files with blocks of zeros as sparse files
+  -u, --unconditional        Replace all files unconditionally
+ */
+enum {
+    CPIO_OPT_EXTRACT            = (1 << 0),
+    CPIO_OPT_TEST               = (1 << 1),
+    CPIO_OPT_NUL_TERMINATED     = (1 << 2),
+    CPIO_OPT_UNCONDITIONAL      = (1 << 3),
+    CPIO_OPT_VERBOSE            = (1 << 4),
+    CPIO_OPT_CREATE_LEADING_DIR = (1 << 5),
+    CPIO_OPT_PRESERVE_MTIME     = (1 << 6),
+    CPIO_OPT_DEREF              = (1 << 7),
+    CPIO_OPT_FILE               = (1 << 8),
+    OPTBIT_FILE = 8,
+    IF_FEATURE_CPIO_O(OPTBIT_CREATE     ,)
+    IF_FEATURE_CPIO_O(OPTBIT_FORMAT     ,)
+    IF_FEATURE_CPIO_P(OPTBIT_PASSTHROUGH,)
+    IF_LONG_OPTS(     OPTBIT_QUIET      ,)
+    IF_LONG_OPTS(     OPTBIT_2STDOUT    ,)
+    CPIO_OPT_CREATE             = IF_FEATURE_CPIO_O((1 << OPTBIT_CREATE     )) + 0,
+    CPIO_OPT_FORMAT             = IF_FEATURE_CPIO_O((1 << OPTBIT_FORMAT     )) + 0,
+    CPIO_OPT_PASSTHROUGH        = IF_FEATURE_CPIO_P((1 << OPTBIT_PASSTHROUGH)) + 0,
+    CPIO_OPT_QUIET              = IF_LONG_OPTS(     (1 << OPTBIT_QUIET      )) + 0,
+    CPIO_OPT_2STDOUT            = IF_LONG_OPTS(     (1 << OPTBIT_2STDOUT    )) + 0,
+};
+
+#define OPTION_STR "it0uvdmLF:"
+
+#if ENABLE_FEATURE_CPIO_O
+static off_t cpio_pad4(off_t size)
+{
+    int i;
+
+    i = (- size) & 3;
+    size += i;
+    while (--i >= 0)
+        bb_putchar('\0');
+    return size;
+}
+
+/* Return value will become exit code.
+ * It's ok to exit instead of return. */
+static NOINLINE int cpio_o(void)
+{
+    static const char trailer[] ALIGN1 = "TRAILER!!!";
+    struct name_s {
+        struct name_s *next;
+        char name[1];
+    };
+    struct inodes_s {
+        struct inodes_s *next;
+        struct name_s *names;
+        struct stat st;
+    };
+
+    struct inodes_s *links = NULL;
+    off_t bytes = 0; /* output bytes count */
+
+    while (1) {
+        const char *name;
+        char *line;
+        struct stat st;
+
+        line = (option_mask32 & CPIO_OPT_NUL_TERMINATED)
+                ? bb_get_chunk_from_file(stdin, NULL)
+                : xmalloc_fgetline(stdin);
+
+        if (line) {
+            /* Strip leading "./[./]..." from the filename */
+            name = line;
+            while (name[0] == '.' && name[1] == '/') {
+                while (*++name == '/')
+                    continue;
+            }
+            if (!*name) { /* line is empty */
+                free(line);
+                continue;
+            }
+            if ((option_mask32 & CPIO_OPT_DEREF)
+                    ? stat(name, &st)
+                    : lstat(name, &st)
+            ) {
+ abort_cpio_o:
+                bb_simple_perror_msg_and_die(name);
+            }
+
+            if (!(S_ISLNK(st.st_mode) || S_ISREG(st.st_mode)))
+                st.st_size = 0; /* paranoia */
+
+            /* Store hardlinks for later processing, dont output them */
+            if (!S_ISDIR(st.st_mode) && st.st_nlink > 1) {
+                struct name_s *n;
+                struct inodes_s *l;
+
+                /* Do we have this hardlink remembered? */
+                l = links;
+                while (1) {
+                    if (l == NULL) {
+                        /* Not found: add new item to "links" list */
+                        l = xzalloc(sizeof(*l));
+                        l->st = st;
+                        l->next = links;
+                        links = l;
+                        break;
+                    }
+                    if (l->st.st_ino == st.st_ino) {
+                        /* found */
+                        break;
+                    }
+                    l = l->next;
+                }
+                /* Add new name to "l->names" list */
+                n = xmalloc(sizeof(*n) + strlen(name));
+                strcpy(n->name, name);
+                n->next = l->names;
+                l->names = n;
+
+                free(line);
+                continue;
+            }
+
+        } else { /* line == NULL: EOF */
+ next_link:
+            if (links) {
+                /* Output hardlink's data */
+                st = links->st;
+                name = links->names->name;
+                links->names = links->names->next;
+                /* GNU cpio is reported to emit file data
+                 * only for the last instance. Mimic that. */
+                if (links->names == NULL)
+                    links = links->next;
+                else
+                    st.st_size = 0;
+                /* NB: we leak links->names and/or links,
+                 * this is intended (we exit soon anyway) */
+            } else {
+                /* If no (more) hardlinks to output,
+                 * output "trailer" entry */
+                name = trailer;
+                /* st.st_size == 0 is a must, but for uniformity
+                 * in the output, we zero out everything */
+                memset(&st, 0, sizeof(st));
+                /* st.st_nlink = 1; - GNU cpio does this */
+            }
+        }
+
+        bytes += printf("070701"
+                        "%08X%08X%08X%08X%08X%08X%08X"
+                        "%08X%08X%08X%08X" /* GNU cpio uses uppercase hex */
+                /* strlen+1: */ "%08X"
+                /* chksum: */   "00000000" /* (only for "070702" files) */
+                /* name,NUL: */ "%s%c",
+                        (unsigned)(uint32_t) st.st_ino,
+                        (unsigned)(uint32_t) st.st_mode,
+                        (unsigned)(uint32_t) st.st_uid,
+                        (unsigned)(uint32_t) st.st_gid,
+                        (unsigned)(uint32_t) st.st_nlink,
+                        (unsigned)(uint32_t) st.st_mtime,
+                        (unsigned)(uint32_t) st.st_size,
+                        (unsigned)(uint32_t) major(st.st_dev),
+                        (unsigned)(uint32_t) minor(st.st_dev),
+                        (unsigned)(uint32_t) major(st.st_rdev),
+                        (unsigned)(uint32_t) minor(st.st_rdev),
+                        (unsigned)(strlen(name) + 1),
+                        name, '\0');
+        bytes = cpio_pad4(bytes);
+
+        if (st.st_size) {
+            if (S_ISLNK(st.st_mode)) {
+                char *lpath = xmalloc_readlink_or_warn(name);
+                if (!lpath)
+                    goto abort_cpio_o;
+                bytes += printf("%s", lpath);
+                free(lpath);
+            } else { /* S_ISREG */
+                int fd = xopen(name, O_RDONLY);
+                fflush_all();
+                /* We must abort if file got shorter too! */
+                bb_copyfd_exact_size(fd, STDOUT_FILENO, st.st_size);
+                bytes += st.st_size;
+                close(fd);
+            }
+            bytes = cpio_pad4(bytes);
+        }
+
+        if (!line) {
+            if (name != trailer)
+                goto next_link;
+            /* TODO: GNU cpio pads trailer to 512 bytes, do we want that? */
+            return EXIT_SUCCESS;
+        }
+
+        free(line);
+    } /* end of "while (1)" */
+}
+#endif
+
+int cpio_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int cpio_main(int argc UNUSED_PARAM, char **argv)
 {
     archive_handle_t *archive_handle;
-    char *cpio_filename = NULL;
+    char *cpio_filename;
+    IF_FEATURE_CPIO_O(const char *cpio_fmt = "";)
     unsigned opt;
 
-    /* Initialise */
+#if ENABLE_LONG_OPTS
+    applet_long_options =
+        "extract\0"      No_argument       "i"
+        "list\0"         No_argument       "t"
+#if ENABLE_FEATURE_CPIO_O
+        "create\0"       No_argument       "o"
+        "format\0"       Required_argument "H"
+#if ENABLE_FEATURE_CPIO_P
+        "pass-through\0" No_argument       "p"
+#endif
+#endif
+        "verbose\0"      No_argument       "v"
+        "quiet\0"        No_argument       "\xff"
+        "to-stdout\0"    No_argument       "\xfe"
+        ;
+#endif
+
     archive_handle = init_handle();
-    archive_handle->src_fd = STDIN_FILENO;
-    archive_handle->seek = seek_by_read;
-    archive_handle->flags = ARCHIVE_EXTRACT_NEWER | ARCHIVE_PRESERVE_DATE;
-
-    opt = getopt32(argv, "ituvF:dm", &cpio_filename);
+    /* archive_handle->src_fd = STDIN_FILENO; - done by init_handle */
+    archive_handle->ah_flags = ARCHIVE_EXTRACT_NEWER;
+
+    /* As of now we do not enforce this: */
+    /* -i,-t,-o,-p are mutually exclusive */
+    /* -u,-d,-m make sense only with -i or -p */
+    /* -L makes sense only with -o or -p */
+
+#if !ENABLE_FEATURE_CPIO_O
+    opt = getopt32(argv, OPTION_STR, &cpio_filename);
+    argv += optind;
+    if (opt & CPIO_OPT_FILE) { /* -F */
+        xmove_fd(xopen(cpio_filename, O_RDONLY), STDIN_FILENO);
+    }
+#else
+    opt = getopt32(argv, OPTION_STR "oH:" IF_FEATURE_CPIO_P("p"), &cpio_filename, &cpio_fmt);
+    argv += optind;
+    if ((opt & (CPIO_OPT_FILE|CPIO_OPT_CREATE)) == CPIO_OPT_FILE) { /* -F without -o */
+        xmove_fd(xopen(cpio_filename, O_RDONLY), STDIN_FILENO);
+    }
+    if (opt & CPIO_OPT_PASSTHROUGH) {
+        pid_t pid;
+        struct fd_pair pp;
+
+        if (argv[0] == NULL)
+            bb_show_usage();
+        if (opt & CPIO_OPT_CREATE_LEADING_DIR)
+            mkdir(argv[0], 0777);
+        /* Crude existence check:
+         * close(xopen(argv[0], O_RDONLY | O_DIRECTORY));
+         * We can also xopen, fstat, IS_DIR, later fchdir.
+         * This would check for existence earlier and cleaner.
+         * As it stands now, if we fail xchdir later,
+         * child dies on EPIPE, unless it caught
+         * a diffrerent problem earlier.
+         * This is good enough for now.
+         */
+#if !BB_MMU
+        pp.rd = 3;
+        pp.wr = 4;
+        if (!re_execed) {
+            close(3);
+            close(4);
+            xpiped_pair(pp);
+        }
+#else
+        xpiped_pair(pp);
+#endif
+        pid = fork_or_rexec(argv - optind);
+        if (pid == 0) { /* child */
+            close(pp.rd);
+            xmove_fd(pp.wr, STDOUT_FILENO);
+            goto dump;
+        }
+        /* parent */
+        xchdir(*argv++);
+        close(pp.wr);
+        xmove_fd(pp.rd, STDIN_FILENO);
+        //opt &= ~CPIO_OPT_PASSTHROUGH;
+        opt |= CPIO_OPT_EXTRACT;
+        goto skip;
+    }
+    /* -o */
+    if (opt & CPIO_OPT_CREATE) {
+        if (cpio_fmt[0] != 'n') /* we _require_ "-H newc" */
+            bb_show_usage();
+        if (opt & CPIO_OPT_FILE) {
+            xmove_fd(xopen(cpio_filename, O_WRONLY | O_CREAT | O_TRUNC), STDOUT_FILENO);
+        }
+ dump:
+        return cpio_o();
+    }
+ skip:
+#endif
 
     /* One of either extract or test options must be given */
@@ -45 +382 @@
     if (opt & CPIO_OPT_TEST) {
         /* if both extract and test options are given, ignore extract option */
-        if (opt & CPIO_OPT_EXTRACT) {
-            opt &= ~CPIO_OPT_EXTRACT;
-        }
+        opt &= ~CPIO_OPT_EXTRACT;
         archive_handle->action_header = header_list;
     }
     if (opt & CPIO_OPT_EXTRACT) {
         archive_handle->action_data = data_extract_all;
+        if (opt & CPIO_OPT_2STDOUT)
+            archive_handle->action_data = data_extract_to_stdout;
     }
     if (opt & CPIO_OPT_UNCONDITIONAL) {
-        archive_handle->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
-        archive_handle->flags &= ~ARCHIVE_EXTRACT_NEWER;
+        archive_handle->ah_flags |= ARCHIVE_UNLINK_OLD;
+        archive_handle->ah_flags &= ~ARCHIVE_EXTRACT_NEWER;
     }
     if (opt & CPIO_OPT_VERBOSE) {
@@ -64 +401 @@
         }
     }
-    if (cpio_filename) { /* CPIO_OPT_FILE */
-        archive_handle->src_fd = xopen(cpio_filename, O_RDONLY);
-        archive_handle->seek = seek_by_jump;
-    }
     if (opt & CPIO_OPT_CREATE_LEADING_DIR) {
-        archive_handle->flags |= ARCHIVE_CREATE_LEADING_DIRS;
-    }
-
-    while (optind < argc) {
+        archive_handle->ah_flags |= ARCHIVE_CREATE_LEADING_DIRS;
+    }
+    if (opt & CPIO_OPT_PRESERVE_MTIME) {
+        archive_handle->ah_flags |= ARCHIVE_RESTORE_DATE;
+    }
+
+    while (*argv) {
         archive_handle->filter = filter_accept_list;
-        llist_add_to(&(archive_handle->accept), argv[optind]);
-        optind++;
-    }
-
-    while (get_header_cpio(archive_handle) == EXIT_SUCCESS);
+        llist_add_to(&archive_handle->accept, *argv);
+        argv++;
+    }
+
+    /* see get_header_cpio */
+    archive_handle->cpio__blocks = (off_t)-1;
+    while (get_header_cpio(archive_handle) == EXIT_SUCCESS)
+        continue;
+
+    if (archive_handle->cpio__blocks != (off_t)-1
+     && !(opt & CPIO_OPT_QUIET)
+    ) {
+        fprintf(stderr, "%"OFF_FMT"u blocks\n", archive_handle->cpio__blocks);
+    }
 
     return EXIT_SUCCESS;

branches/2.2.9/mindi-busybox/archival/dpkg.c

@@ -7 +7 @@
  *  copyright (c) 2001 by glenn mcgrath
  *
+ *  parts of the version comparison code is plucked from the real dpkg
+ *  application which is licensed GPLv2 and
+ *  copyright (c) 1995 Ian Jackson <ian@chiark.greenend.org.uk>
+ *
  *  started life as a busybox implementation of udpkg
  *
- * licensed under gplv2 or later, see file license in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -26 +30 @@
 
 #include "libbb.h"
-#include "unarchive.h"
+#include <fnmatch.h>
+#include "archive.h"
 
 /* note: if you vary hash_prime sizes be aware,
@@ -76 +81 @@
 } status_node_t;
 
-/* Were statically declared here, but such a big bss is nommu-unfriendly */
-static char **name_hashtable;             /* [NAME_HASH_PRIME + 1] */
-static common_node_t **package_hashtable; /* [PACKAGE_HASH_PRIME + 1] */
-static status_node_t **status_hashtable;  /* [STATUS_HASH_PRIME + 1] */
+
+/* Globals */
+struct globals {
+    char          *name_hashtable[NAME_HASH_PRIME + 1];
+    common_node_t *package_hashtable[PACKAGE_HASH_PRIME + 1];
+    status_node_t *status_hashtable[STATUS_HASH_PRIME + 1];
+};
+#define G (*ptr_to_globals)
+#define name_hashtable    (G.name_hashtable   )
+#define package_hashtable (G.package_hashtable)
+#define status_hashtable  (G.status_hashtable )
+#define INIT_G() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+} while (0)
+
 
 /* Even numbers are for 'extras', like ored dependencies or null */
@@ -124 +140 @@
          * shift amount is mod 24 because long int is 32 bit and data
          * to be shifted is 8, don't want to shift data to where it has
-         * no effect*/
-        hash_num += ((key[i] + key[i-1]) << ((key[i] * i) % 24));
+         * no effect */
+        hash_num += (key[i] + key[i-1]) << ((key[i] * i) % 24);
     }
     *start = (unsigned) hash_num % hash_prime;
@@ -134 +150 @@
 static int search_name_hashtable(const char *key)
 {
-    unsigned probe_address = 0;
-    unsigned probe_decrement = 0;
+    unsigned probe_address;
+    unsigned probe_decrement;
 
     make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME);
@@ -156 +172 @@
 static unsigned search_status_hashtable(const char *key)
 {
-    unsigned probe_address = 0;
-    unsigned probe_decrement = 0;
+    unsigned probe_address;
+    unsigned probe_decrement;
 
     make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME);
@@ -172 +188 @@
 }
 
-/* Need to rethink version comparison, maybe the official dpkg has something i can use ? */
-static 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;
-
-    if (version1 == NULL) {
-        version1 = xstrdup("");
-    }
-    if (version2 == NULL) {
-        version2 = 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 = xstrndup(&version1[len1], tmp_int);
-        len1 += tmp_int;
-        tmp_int = strcspn(&version2[len2], "0123456789");
-        name2_char = 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) {
-            return tmp_int;
-        }
-
-        /* Compare digits */
-        tmp_int = strspn(&version1[len1], "0123456789");
-        name1_char = xstrndup(&version1[len1], tmp_int);
-        len1 += tmp_int;
-        tmp_int = strspn(&version2[len2], "0123456789");
-        name2_char = 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) {
+static int order(char x)
+{
+    return (x == '~' ? -1
+        : x == '\0' ? 0
+        : isdigit(x) ? 0
+        : isalpha(x) ? x
+        : (unsigned char)x + 256
+    );
+}
+
+/* This code is taken from dpkg and modified slightly to work with busybox */
+static int version_compare_part(const char *val, const char *ref)
+{
+    if (!val) val = "";
+    if (!ref) ref = "";
+
+    while (*val || *ref) {
+        int first_diff;
+
+        while ((*val && !isdigit(*val)) || (*ref && !isdigit(*ref))) {
+            int vc = order(*val);
+            int rc = order(*ref);
+            if (vc != rc)
+                return vc - rc;
+            val++;
+            ref++;
+        }
+
+        while (*val == '0')
+            val++;
+        while (*ref == '0')
+            ref++;
+
+        first_diff = 0;
+        while (isdigit(*val) && isdigit(*ref)) {
+            if (first_diff == 0)
+                first_diff = *val - *ref;
+            val++;
+            ref++;
+        }
+        if (isdigit(*val))
+            return 1;
+        if (isdigit(*ref))
             return -1;
-        }
-        if (ver_num1 > ver_num2) {
-            return 1;
-        }
+        if (first_diff)
+            return first_diff;
     }
     return 0;
@@ -238 +246 @@
     char *ch_ver1 = name_hashtable[ver1];
     char *ch_ver2 = name_hashtable[ver2];
-
-    char epoch1, epoch2;
+    unsigned epoch1 = 0, epoch2 = 0;
+    char *colon;
     char *deb_ver1, *deb_ver2;
-    char *ver1_ptr, *ver2_ptr;
     char *upstream_ver1;
     char *upstream_ver2;
@@ -247 +254 @@
 
     /* 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;
+    colon = strchr(ch_ver1, ':');
+    if (colon) {
+        epoch1 = atoi(ch_ver1);
+        ch_ver1 = colon + 1;
+    }
+    colon = strchr(ch_ver2, ':');
+    if (colon) {
+        epoch2 = atoi(ch_ver2);
+        ch_ver2 = colon + 1;
     }
     if (epoch1 < epoch2) {
         return -1;
     }
-    else if (epoch1 > epoch2) {
+    if (epoch1 > epoch2) {
         return 1;
     }
 
     /* Compare upstream version */
-    upstream_ver1 = xstrdup(ver1_ptr);
-    upstream_ver2 = xstrdup(ver2_ptr);
+    upstream_ver1 = xstrdup(ch_ver1);
+    upstream_ver2 = xstrdup(ch_ver2);
 
     /* Chop off debian version, and store for later use */
@@ -276 +279 @@
     deb_ver2 = strrchr(upstream_ver2, '-');
     if (deb_ver1) {
-        deb_ver1[0] = '\0';
-        deb_ver1++;
+        *deb_ver1++ = '\0';
     }
     if (deb_ver2) {
-        deb_ver2[0] = '\0';
-        deb_ver2++;
+        *deb_ver2++ = '\0';
     }
     result = version_compare_part(upstream_ver1, upstream_ver2);
-    if (!result)
+    if (result == 0) {
         /* Compare debian versions */
         result = version_compare_part(deb_ver1, deb_ver2);
+    }
 
     free(upstream_ver1);
@@ -313 +315 @@
 }
 
-
 static int search_package_hashtable(const unsigned name, const unsigned version, const unsigned operator)
 {
-    unsigned probe_address = 0;
-    unsigned probe_decrement = 0;
+    unsigned probe_address;
+    unsigned probe_decrement;
 
     make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME);
@@ -373 +374 @@
 static void add_edge_to_node(common_node_t *node, edge_t *edge)
 {
-    node->num_of_edges++;
-    node->edge = xrealloc(node->edge, sizeof(edge_t) * (node->num_of_edges + 1));
-    node->edge[node->num_of_edges - 1] = edge;
+    node->edge = xrealloc_vector(node->edge, 2, node->num_of_edges);
+    node->edge[node->num_of_edges++] = edge;
 }
 
@@ -411 +411 @@
          && (strcmp(field, field2) != 0)
         ) {
-            or_edge = xmalloc(sizeof(edge_t));
+            or_edge = xzalloc(sizeof(edge_t));
             or_edge->type = edge_type + 1;
             or_edge->name = search_name_hashtable(field);
-            or_edge->version = 0; // tracks the number of alternatives
+            //or_edge->version = 0; // tracks the number of alternatives
             add_edge_to_node(parent_node, or_edge);
         }
@@ -440 +440 @@
                     if (strncmp(version, "=", offset_ch) == 0) {
                         edge->operator = VER_EQUAL;
-                    }
-                    else if (strncmp(version, "<<", offset_ch) == 0) {
+                    } else if (strncmp(version, "<<", offset_ch) == 0) {
                         edge->operator = VER_LESS;
-                    }
-                    else if (strncmp(version, "<=", offset_ch) == 0) {
+                    } else if (strncmp(version, "<=", offset_ch) == 0) {
                         edge->operator = VER_LESS_EQUAL;
-                    }
-                    else if (strncmp(version, ">>", offset_ch) == 0) {
+                    } else if (strncmp(version, ">>", offset_ch) == 0) {
                         edge->operator = VER_MORE;
-                    }
-                    else if (strncmp(version, ">=", offset_ch) == 0) {
+                    } else if (strncmp(version, ">=", offset_ch) == 0) {
                         edge->operator = VER_MORE_EQUAL;
                     } else {
@@ -497 +493 @@
 
 /*
- * Gets the next package field from package_buffer, seperated into the field name
+ * Gets the next package field from package_buffer, separated into the field name
  * and field value, it returns the int offset to the first character of the next field
  */
@@ -603 +599 @@
 
         if (field_name == NULL) {
-            goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement! */
+            goto fill_package_struct_cleanup;
         }
 
@@ -736 +732 @@
 }
 
-
 static void index_status_file(const char *filename)
 {
@@ -745 +740 @@
     unsigned status_num;
 
-    status_file = xfopen(filename, "r");
-    while ((control_buffer = xmalloc_fgets_str(status_file, "\n\n")) != NULL) {
+    status_file = xfopen_for_read(filename);
+    while ((control_buffer = xmalloc_fgetline_str(status_file, "\n\n")) != NULL) {
         const unsigned package_num = fill_package_struct(control_buffer);
         if (package_num != -1) {
@@ -787 +782 @@
 static void write_status_file(deb_file_t **deb_file)
 {
-    FILE *old_status_file = xfopen("/var/lib/dpkg/status", "r");
-    FILE *new_status_file = xfopen("/var/lib/dpkg/status.udeb", "w");
+    FILE *old_status_file = xfopen_for_read("/var/lib/dpkg/status");
+    FILE *new_status_file = xfopen_for_write("/var/lib/dpkg/status.udeb");
     char *package_name;
     char *status_from_file;
@@ -799 +794 @@
 
     /* Update previously known packages */
-    while ((control_buffer = xmalloc_fgets_str(old_status_file, "\n\n")) != NULL) {
+    while ((control_buffer = xmalloc_fgetline_str(old_status_file, "\n\n")) != NULL) {
         tmp_string = strstr(control_buffer, "Package:");
         if (tmp_string == NULL) {
@@ -811 +806 @@
         tmp_string = strstr(control_buffer, "Status:");
         if (tmp_string != NULL) {
-            /* Seperate the status value from the control buffer */
+            /* Separate the status value from the control buffer */
             tmp_string += 7;
             tmp_string += strspn(tmp_string, " \n\t");
@@ -863 +858 @@
                             break;
                         }
-                        if ((strcmp(field_name, "Priority") == 0) ||
-                            (strcmp(field_name, "Section") == 0)) {
+                        if ((strcmp(field_name, "Priority") == 0)
+                         || (strcmp(field_name, "Section") == 0)
+                        ) {
                             fprintf(new_status_file, "%s: %s\n", field_name, field_value);
                         }
@@ -871 +867 @@
                     fputs("\n", new_status_file);
                 }
-                else if (strcmp("config-files", name_hashtable[state_status]) == 0) {
+                else if (strcmp("config-files", name_hashtable[state_status]) == 0) {
                     /* only change the status line */
                     while (1) {
@@ -914 +910 @@
     fclose(new_status_file);
 
-
     /* Create a separate backfile to dpkg */
     if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
-        struct stat stat_buf;
-        xstat("/var/lib/dpkg/status", &stat_buf);
+        if (errno != ENOENT)
+            bb_error_msg_and_die("can't create backup status file");
         /* Its ok if renaming the status file fails because status
          * file doesnt exist, maybe we are starting from scratch */
@@ -924 +919 @@
     }
 
-    if (rename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status") == -1) {
-        bb_error_msg_and_die("DANGER: cannot create status file, "
-            "you need to manually repair your status file");
-    }
+    xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
 }
 
@@ -948 +940 @@
 
     switch (depend_type) {
-    case EDGE_PRE_DEPENDS:  return get_status(status_num, 3) == search_name_hashtable("installed");
-    case EDGE_DEPENDS:  return get_status(status_num, 1) == search_name_hashtable("install");
+    case EDGE_PRE_DEPENDS: return get_status(status_num, 3) == search_name_hashtable("installed");
+    case EDGE_DEPENDS:     return get_status(status_num, 1) == search_name_hashtable("install");
     }
     return 0;
 }
 
-static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
+static int check_deps(deb_file_t **deb_file, int deb_start /*, int dep_max_count - ?? */)
 {
     int *conflicts = NULL;
@@ -972 +964 @@
     while (deb_file[i] != NULL) {
         const unsigned package_num = deb_file[i]->package;
-        conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
+        conflicts = xrealloc_vector(conflicts, 2, conflicts_num);
         conflicts[conflicts_num] = package_num;
         conflicts_num++;
         /* add provides to conflicts list */
-        for (j = 0; j < package_hashtable[package_num]->num_of_edges; j++) {
+        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(
@@ -989 +981 @@
                     package_hashtable[conflicts_package_num] = new_node;
                 }
-                conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
+                conflicts = xrealloc_vector(conflicts, 2, conflicts_num);
                 conflicts[conflicts_num] = conflicts_package_num;
                 conflicts_num++;
@@ -1076 +1068 @@
             if (package_edge->type == EDGE_OR_PRE_DEPENDS
              || package_edge->type == EDGE_OR_DEPENDS
-            ) { /* start an EDGE_OR_ list */
+            ) {
+                /* start an EDGE_OR_ list */
                 number_of_alternatives = package_edge->version;
                 root_of_alternatives = package_edge;
                 continue;
             }
-            if (number_of_alternatives == 0) {  /* not in the middle of an EDGE_OR_ list */
+            if (number_of_alternatives == 0) {  /* not in the middle of an EDGE_OR_ list */
                 number_of_alternatives = 1;
                 root_of_alternatives = NULL;
@@ -1088 +1081 @@
             package_num = search_package_hashtable(package_edge->name, package_edge->version, package_edge->operator);
 
-            if (package_edge->type == EDGE_PRE_DEPENDS ||
-                package_edge->type == EDGE_DEPENDS) {
+            if (package_edge->type == EDGE_PRE_DEPENDS
+             || package_edge->type == EDGE_DEPENDS
+            ) {
                 int result=1;
                 status_num = 0;
@@ -1157 +1151 @@
 {
     FILE *list_stream;
-    char **file_list = NULL;
-    char *line = NULL;
-    int count = 0;
+    char **file_list;
+    char *line;
+    int count;
 
     /* don't use [xw]fopen here, handle error ourself */
-    list_stream = fopen(filename, "r");
+    list_stream = fopen_for_read(filename);
     if (list_stream == NULL) {
         return NULL;
     }
 
-    while ((line = xmalloc_getline(list_stream)) != NULL) {
-        file_list = xrealloc(file_list, sizeof(char *) * (count + 2));
-        file_list[count] = line;
-        count++;
+    file_list = NULL;
+    count = 0;
+    while ((line = xmalloc_fgetline(list_stream)) != NULL) {
+        file_list = xrealloc_vector(file_list, 2, count);
+        file_list[count++] = line;
+        /*file_list[count] = NULL; - xrealloc_vector did it */
     }
     fclose(list_stream);
 
-    if (count == 0) {
-        return NULL;
-    }
-    file_list[count] = NULL;
     return file_list;
 }
@@ -1214 +1206 @@
 }
 
-static int run_package_script(const char *package_name, const char *script_type)
-{
-    struct stat path_stat;
+static void run_package_script_or_die(const char *package_name, const char *script_type)
+{
     char *script_path;
     int result;
@@ -1222 +1213 @@
     script_path = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, script_type);
 
-    /* If the file doesnt exist is isnt a fatal */
-    result = lstat(script_path, &path_stat) < 0 ? EXIT_SUCCESS : system(script_path);
+    /* If the file doesnt exist is isnt fatal */
+    result = access(script_path, F_OK) ? EXIT_SUCCESS : system(script_path);
     free(script_path);
-    return result;
-}
-
+    if (result)
+        bb_error_msg_and_die("%s failed, exit code %d", script_type, result);
+}
+
+/*
+The policy manual defines what scripts get called when and with
+what arguments. I realize that busybox does not support all of
+these scenarios, but it does support some of them; it does not,
+however, run them with any parameters in run_package_script_or_die().
+Here are the scripts:
+
+preinst install
+preinst install <old_version>
+preinst upgrade <old_version>
+preinst abort_upgrade <new_version>
+postinst configure <most_recent_version>
+postinst abort-upgade <new_version>
+postinst abort-remove
+postinst abort-remove in-favour <package> <version>
+postinst abort-deconfigure in-favor <failed_install_package> removing <conflicting_package> <version>
+prerm remove
+prerm upgrade <new_version>
+prerm failed-upgrade <old_version>
+prerm remove in-favor <package> <new_version>
+prerm deconfigure in-favour <package> <version> removing <package> <version>
+postrm remove
+postrm purge
+postrm upgrade <new_version>
+postrm failed-upgrade <old_version>
+postrm abort-install
+postrm abort-install <old_version>
+postrm abort-upgrade <old_version>
+postrm disappear <overwriter> <version>
+*/
 static const char *const all_control_files[] = {
     "preinst", "postinst", "prerm", "postrm",
     "list", "md5sums", "shlibs", "conffiles",
-    "config", "templates", NULL
+    "config", "templates"
 };
 
@@ -1240 +1262 @@
 
     /* Create a list of all /var/lib/dpkg/info/<package> files */
-    remove_files = xzalloc(sizeof(all_control_files));
-    while (all_control_files[i]) {
-        remove_files[i] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, all_control_files[i]);
+    remove_files = xzalloc(sizeof(all_control_files) + sizeof(char*));
+    while (i < ARRAY_SIZE(all_control_files)) {
+        remove_files[i] = xasprintf("/var/lib/dpkg/info/%s.%s",
+                package_name, all_control_files[i]);
         i++;
     }
@@ -1265 +1288 @@
  * scanning the status file. The resulting list, however, is unsorted.
  */
-static void list_packages(void)
+static void list_packages(const char *pattern)
 {
     int i;
@@ -1286 +1309 @@
             vers_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->version];
 
+            if (pattern && fnmatch(pattern, name_str, 0) != 0)
+                continue;
+
             /* get abbreviation for status field 1 */
             s1 = stat_str[0] == 'i' ? 'i' : 'r';
@@ -1315 +1341 @@
         printf("Removing %s (%s)...\n", package_name, package_version);
 
-    /* run prerm script */
-    if (run_package_script(package_name, "prerm") != 0) {
-        bb_error_msg_and_die("script failed, prerm failure");
-    }
+    /* Run prerm script */
+    run_package_script_or_die(package_name, "prerm");
 
     /* Create a list of files to remove, and a separate list of those to keep */
-    sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name);
+    sprintf(list_name, "/var/lib/dpkg/info/%s.%s", package_name, "list");
     remove_files = create_list(list_name);
 
-    sprintf(conffile_name, "/var/lib/dpkg/info/%s.conffiles", package_name);
+    sprintf(conffile_name, "/var/lib/dpkg/info/%s.%s", package_name, "conffiles");
     exclude_files = create_list(conffile_name);
 
     /* Some directories can't be removed straight away, so do multiple passes */
-    while (remove_file_array(remove_files, exclude_files)) /*repeat */;
+    while (remove_file_array(remove_files, exclude_files))
+        continue;
     free_array(exclude_files);
     free_array(remove_files);
 
-    /* Create a list of files in /var/lib/dpkg/info/<package>.* to keep  */
-    exclude_files = xzalloc(sizeof(char*) * 3);
+    /* Create a list of files in /var/lib/dpkg/info/<package>.* to keep */
+    exclude_files = xzalloc(sizeof(exclude_files[0]) * 3);
     exclude_files[0] = xstrdup(conffile_name);
-    exclude_files[1] = xasprintf("/var/lib/dpkg/info/%s.postrm", package_name);
+    exclude_files[1] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "postrm");
 
     /* Create a list of all /var/lib/dpkg/info/<package> files */
@@ -1344 +1369 @@
     free_array(exclude_files);
 
-    /* rename <package>.conffile to <package>.list */
+    /* rename <package>.conffiles to <package>.list
+     * The conffiles control file isn't required in Debian packages, so don't
+     * error out if it's missing.  */
     rename(conffile_name, list_name);
 
@@ -1362 +1389 @@
     printf("Purging %s (%s)...\n", package_name, package_version);
 
-    /* run prerm script */
-    if (run_package_script(package_name, "prerm") != 0) {
-        bb_error_msg_and_die("script failed, prerm failure");
-    }
+    /* Run prerm script */
+    run_package_script_or_die(package_name, "prerm");
 
     /* Create a list of files to remove */
-    sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name);
+    sprintf(list_name, "/var/lib/dpkg/info/%s.%s", package_name, "list");
     remove_files = create_list(list_name);
 
-    exclude_files = xzalloc(sizeof(char*));
-
     /* Some directories cant be removed straight away, so do multiple passes */
-    while (remove_file_array(remove_files, exclude_files)) /* repeat */;
+    while (remove_file_array(remove_files, NULL))
+        continue;
     free_array(remove_files);
 
     /* Create a list of all /var/lib/dpkg/info/<package> files */
     remove_files = all_control_list(package_name);
+
+    /* Delete all of them except the postrm script */
+    exclude_files = xzalloc(sizeof(exclude_files[0]) * 2);
+    exclude_files[0] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "postrm");
     remove_file_array(remove_files, exclude_files);
+    free_array(exclude_files);
+
+    /* Run and remove postrm script */
+    run_package_script_or_die(package_name, "postrm");
+    remove_file_array(remove_files, NULL);
+
     free_array(remove_files);
-    free(exclude_files);
-
-    /* run postrm script */
-    if (run_package_script(package_name, "postrm") != 0) {
-        bb_error_msg_and_die("postrm failure.. set status to what?");
-    }
 
     /* Change package status */
@@ -1413 +1441 @@
 
     /* We don't care about data.tar.* or debian-binary, just control.tar.* */
-#if ENABLE_FEATURE_DEB_TAR_GZ
+#if ENABLE_FEATURE_SEAMLESS_GZ
     llist_add_to(&(ar_handle->accept), (char*)"control.tar.gz");
 #endif
-#if ENABLE_FEATURE_DEB_TAR_BZ2
+#if ENABLE_FEATURE_SEAMLESS_BZ2
     llist_add_to(&(ar_handle->accept), (char*)"control.tar.bz2");
 #endif
 
     /* Assign the tar handle as a subarchive of the ar handle */
-    ar_handle->sub_archive = tar_handle;
+    ar_handle->dpkg__sub_archive = tar_handle;
 }
 
@@ -1433 +1461 @@
 
     /* We don't care about control.tar.* or debian-binary, just data.tar.* */
-#if ENABLE_FEATURE_DEB_TAR_GZ
+#if ENABLE_FEATURE_SEAMLESS_GZ
     llist_add_to(&(ar_handle->accept), (char*)"data.tar.gz");
 #endif
-#if ENABLE_FEATURE_DEB_TAR_BZ2
+#if ENABLE_FEATURE_SEAMLESS_BZ2
     llist_add_to(&(ar_handle->accept), (char*)"data.tar.bz2");
 #endif
 
     /* Assign the tar handle as a subarchive of the ar handle */
-    ar_handle->sub_archive = tar_handle;
+    ar_handle->dpkg__sub_archive = tar_handle;
+}
+
+static void FAST_FUNC data_extract_to_buffer(archive_handle_t *archive_handle)
+{
+    unsigned size = archive_handle->file_header->size;
+
+    archive_handle->dpkg__buffer = xzalloc(size + 1);
+    xread(archive_handle->src_fd, archive_handle->dpkg__buffer, size);
 }
 
 static char *deb_extract_control_file_to_buffer(archive_handle_t *ar_handle, llist_t *myaccept)
 {
-    ar_handle->sub_archive->action_data = data_extract_to_buffer;
-    ar_handle->sub_archive->accept = myaccept;
-    ar_handle->sub_archive->filter = filter_accept_list;
+    ar_handle->dpkg__sub_archive->action_data = data_extract_to_buffer;
+    ar_handle->dpkg__sub_archive->accept = myaccept;
+    ar_handle->dpkg__sub_archive->filter = filter_accept_list;
 
     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)
+    return ar_handle->dpkg__sub_archive->dpkg__buffer;
+}
+
+static void append_control_file_to_llist(const char *package_name, const char *control_name, llist_t **ll)
+{
+    FILE *fp;
+    char *filename, *line;
+
+    filename = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, control_name);
+    fp = fopen_for_read(filename);
+    free(filename);
+    if (fp != NULL) {
+        while ((line = xmalloc_fgetline(fp)) != NULL)
+            llist_add_to(ll, line);
+        fclose(fp);
+    }
+}
+
+static char FAST_FUNC filter_rename_config(archive_handle_t *archive_handle)
+{
+    int fd;
+    char *name_ptr = archive_handle->file_header->name + 1;
+
+    /* Is this file marked as config file? */
+    if (!find_list_entry(archive_handle->accept, name_ptr))
+        return EXIT_SUCCESS; /* no */
+
+    fd = open(name_ptr, O_RDONLY);
+    if (fd >= 0) {
+        md5_ctx_t md5;
+        char *md5line, *buf;
+        int count;
+
+        /* Calculate MD5 of existing file */
+        buf = xmalloc(4096);
+        md5_begin(&md5);
+        while ((count = safe_read(fd, buf, 4096)) > 0)
+            md5_hash(&md5, buf, count);
+        md5_end(&md5, buf); /* using buf as result storage */
+        close(fd);
+
+        md5line = xmalloc(16 * 2 + 2 + strlen(name_ptr) + 1);
+        sprintf(bin2hex(md5line, buf, 16), "  %s", name_ptr);
+        free(buf);
+
+        /* Is it changed after install? */
+        if (find_list_entry(archive_handle->accept, md5line) == NULL) {
+            printf("Warning: Creating %s as %s.dpkg-new\n", name_ptr, name_ptr);
+            archive_handle->file_header->name = xasprintf("%s.dpkg-new", archive_handle->file_header->name);
+        }
+        free(md5line);
+    }
+    return EXIT_SUCCESS;
+}
+
+static void FAST_FUNC data_extract_all_prefix(archive_handle_t *archive_handle)
 {
     char *name_ptr = archive_handle->file_header->name;
 
-    name_ptr += strspn(name_ptr, "./");
+    /* Skip all leading "/" */
+    while (*name_ptr == '/')
+        name_ptr++;
+    /* Skip all leading "./" and "../" */
+    while (name_ptr[0] == '.') {
+        if (name_ptr[1] == '.')
+            name_ptr++;
+        if (name_ptr[1] != '/')
+            break;
+        name_ptr += 2;
+    }
+
     if (name_ptr[0] != '\0') {
-        archive_handle->file_header->name = xasprintf("%s%s", archive_handle->buffer, name_ptr);
+        archive_handle->file_header->name = xasprintf("%s%s", archive_handle->dpkg__buffer, name_ptr);
         data_extract_all(archive_handle);
-    }
-}
+        if (fnmatch("*.dpkg-new", archive_handle->file_header->name, 0) == 0) {
+            /* remove .dpkg-new suffix */
+            archive_handle->file_header->name[strlen(archive_handle->file_header->name) - 9] = '\0';
+        }
+    }
+}
+
+enum {
+    /* Commands */
+    OPT_configure            = (1 << 0),
+    OPT_install              = (1 << 1),
+    OPT_list_installed       = (1 << 2),
+    OPT_purge                = (1 << 3),
+    OPT_remove               = (1 << 4),
+    OPT_unpack               = (1 << 5),
+    OPTMASK_cmd              = (1 << 6) - 1,
+    /* Options */
+    OPT_force                = (1 << 6),
+    OPT_force_ignore_depends = (1 << 7),
+    OPT_force_confnew        = (1 << 8),
+    OPT_force_confold        = (1 << 9),
+};
 
 static void unpack_package(deb_file_t *deb_file)
@@ -1476 +1595 @@
     archive_handle_t *archive_handle;
     FILE *out_stream;
-    llist_t *accept_list = NULL;
-    int i = 0;
+    llist_t *accept_list;
+    llist_t *conffile_list;
+    int i;
 
     /* If existing version, remove it first */
+    conffile_list = NULL;
     if (strcmp(name_hashtable[get_status(status_num, 3)], "installed") == 0) {
         /* Package is already installed, remove old version first */
@@ -1485 +1606 @@
             name_hashtable[package_hashtable[status_package_num]->version],
             deb_file->filename);
+
+        /* Read md5sums from old package */
+        if (!(option_mask32 & OPT_force_confold))
+            append_control_file_to_llist(package_name, "md5sums", &conffile_list);
+
         remove_package(status_package_num, 0);
     } else {
@@ -1491 +1617 @@
 
     /* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
-    info_prefix = xasprintf("/var/lib/dpkg/info/%s.", package_name);
+    info_prefix = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "");
     archive_handle = init_archive_deb_ar(deb_file->filename);
     init_archive_deb_control(archive_handle);
 
-    while (all_control_files[i]) {
+    accept_list = NULL;
+    i = 0;
+    while (i < ARRAY_SIZE(all_control_files)) {
         char *c = xasprintf("./%s", all_control_files[i]);
         llist_add_to(&accept_list, c);
         i++;
     }
-    archive_handle->sub_archive->accept = accept_list;
-    archive_handle->sub_archive->filter = filter_accept_list;
-    archive_handle->sub_archive->action_data = data_extract_all_prefix;
-    archive_handle->sub_archive->buffer = info_prefix;
-    archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+    archive_handle->dpkg__sub_archive->accept = accept_list;
+    archive_handle->dpkg__sub_archive->filter = filter_accept_list;
+    archive_handle->dpkg__sub_archive->action_data = data_extract_all_prefix;
+    archive_handle->dpkg__sub_archive->dpkg__buffer = info_prefix;
+    archive_handle->dpkg__sub_archive->ah_flags |= ARCHIVE_UNLINK_OLD;
     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");
-    }
+    run_package_script_or_die(package_name, "preinst");
+
+    /* Don't overwrite existing config files */
+    if (!(option_mask32 & OPT_force_confnew))
+        append_control_file_to_llist(package_name, "conffiles", &conffile_list);
 
     /* Extract data.tar.gz to the root directory */
     archive_handle = init_archive_deb_ar(deb_file->filename);
     init_archive_deb_data(archive_handle);
-    archive_handle->sub_archive->action_data = data_extract_all_prefix;
-    archive_handle->sub_archive->buffer = (char*)"/"; /* huh? */
-    archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+    archive_handle->dpkg__sub_archive->accept = conffile_list;
+    archive_handle->dpkg__sub_archive->filter = filter_rename_config;
+    archive_handle->dpkg__sub_archive->action_data = data_extract_all_prefix;
+    archive_handle->dpkg__sub_archive->dpkg__buffer = (char*)"/"; /* huh? */
+    archive_handle->dpkg__sub_archive->ah_flags |= ARCHIVE_UNLINK_OLD;
     unpack_ar_archive(archive_handle);
 
     /* Create the list file */
-    list_filename = xasprintf("/var/lib/dpkg/info/%s.list", package_name);
-    out_stream = xfopen(list_filename, "w");
-    while (archive_handle->sub_archive->passed) {
+    list_filename = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "list");
+    out_stream = xfopen_for_write(list_filename);
+    while (archive_handle->dpkg__sub_archive->passed) {
         /* the leading . has been stripped by data_extract_all_prefix already */
-        fputs(archive_handle->sub_archive->passed->data, out_stream);
+        fputs(archive_handle->dpkg__sub_archive->passed->data, out_stream);
         fputc('\n', out_stream);
-        archive_handle->sub_archive->passed = archive_handle->sub_archive->passed->link;
+        archive_handle->dpkg__sub_archive->passed = archive_handle->dpkg__sub_archive->passed->link;
     }
     fclose(out_stream);
@@ -1549 +1680 @@
 
     /* Run the postinst script */
-    if (run_package_script(package_name, "postinst") != 0) {
-        /* TODO: handle failure gracefully */
-        bb_error_msg_and_die("postinst failure.. set status to what?");
-    }
+    /* TODO: handle failure gracefully */
+    run_package_script_or_die(package_name, "postinst");
+
     /* Change status to reflect success */
     set_status(status_num, "install", 1);
@@ -1558 +1688 @@
 }
 
-int dpkg_main(int argc, char **argv);
-int dpkg_main(int argc, char **argv)
+int dpkg_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int dpkg_main(int argc UNUSED_PARAM, char **argv)
 {
     deb_file_t **deb_file = NULL;
@@ -1570 +1700 @@
     int status_num;
     int i;
-    enum {
-        OPT_configure = 0x1,
-        OPT_force_ignore_depends = 0x2,
-        OPT_install = 0x4,
-        OPT_list_installed = 0x8,
-        OPT_purge = 0x10,
-        OPT_remove = 0x20,
-        OPT_unpack = 0x40,
-    };
-
-    opt = getopt32(argv, "CF:ilPru", &str_f);
+#if ENABLE_LONG_OPTS
+    static const char dpkg_longopts[] ALIGN1 =
+// FIXME: we use -C non-compatibly, should be:
+// "-C|--audit Check for broken package(s)"
+        "configure\0"      No_argument        "C"
+        "force\0"          Required_argument  "F"
+        "install\0"        No_argument        "i"
+        "list\0"           No_argument        "l"
+        "purge\0"          No_argument        "P"
+        "remove\0"         No_argument        "r"
+        "unpack\0"         No_argument        "u"
+        "force-depends\0"  No_argument        "\xff"
+        "force-confnew\0"  No_argument        "\xfe"
+        "force-confold\0"  No_argument        "\xfd"
+        ;
+#endif
+
+    INIT_G();
+
+    IF_LONG_OPTS(applet_long_options = dpkg_longopts);
+    opt = getopt32(argv, "CilPruF:", &str_f);
+    argv += optind;
     //if (opt & OPT_configure) ... // -C
-    if (opt & OPT_force_ignore_depends) { // -F (--force in official dpkg)
-        if (strcmp(str_f, "depends"))
-            opt &= ~OPT_force_ignore_depends;
+    if (opt & OPT_force) { // -F (--force in official dpkg)
+        if (strcmp(str_f, "depends") == 0)
+            opt |= OPT_force_ignore_depends;
+        else if (strcmp(str_f, "confnew") == 0)
+            opt |= OPT_force_confnew;
+        else if (strcmp(str_f, "confold") == 0)
+            opt |= OPT_force_confold;
+        else
+            bb_show_usage();
+        option_mask32 = opt;
     }
     //if (opt & OPT_install) ... // -i
@@ -1591 +1739 @@
     //if (opt & OPT_remove) ... // -r
     //if (opt & OPT_unpack) ... // -u (--unpack in official dpkg)
-    argc -= optind;
-    argv += optind;
-    /* check for non-option argument if expected  */
-    if (!opt || (!argc && !(opt && OPT_list_installed)))
+    if (!(opt & OPTMASK_cmd) /* no cmd */
+     || ((opt & OPTMASK_cmd) & ((opt & OPTMASK_cmd)-1)) /* more than one cmd */
+    ) {
         bb_show_usage();
-
-    name_hashtable = xzalloc(sizeof(name_hashtable[0]) * (NAME_HASH_PRIME + 1));
-    package_hashtable = xzalloc(sizeof(package_hashtable[0]) * (PACKAGE_HASH_PRIME + 1));
-    status_hashtable = xzalloc(sizeof(status_hashtable[0]) * (STATUS_HASH_PRIME + 1));
+    }
 
 /*  puts("(Reading database ... xxxxx files and directories installed.)"); */
@@ -1606 +1750 @@
     /* if the list action was given print the installed packages and exit */
     if (opt & OPT_list_installed) {
-        list_packages();
+        list_packages(argv[0]); /* param can be NULL */
         return EXIT_SUCCESS;
     }
@@ -1613 +1757 @@
     while (*argv) {
         /* 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[0]) * (deb_count + 2));
+        deb_file = xrealloc_vector(deb_file, 2, deb_count);
         deb_file[deb_count] = xzalloc(sizeof(deb_file[0][0]));
         if (opt & (OPT_install | OPT_unpack)) {
@@ -1626 +1770 @@
             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("cannot extract control file");
+                bb_error_msg_and_die("can't extract control file");
             }
             deb_file[deb_count]->filename = xstrdup(argv[0]);
@@ -1694 +1838 @@
     /* Check that the deb file arguments are installable */
     if (!(opt & OPT_force_ignore_depends)) {
-        if (!check_deps(deb_file, 0, deb_count)) {
+        if (!check_deps(deb_file, 0 /*, deb_count*/)) {
             bb_error_msg_and_die("dependency check failed");
         }

branches/2.2.9/mindi-busybox/archival/dpkg_deb.c

@@ -3 +3 @@
  * dpkg-deb packs, unpacks and provides information about Debian archives.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 #include "libbb.h"
-#include "unarchive.h"
+#include "archive.h"
 
-#define DPKG_DEB_OPT_CONTENTS   1
-#define DPKG_DEB_OPT_CONTROL    2
-#define DPKG_DEB_OPT_FIELD  4
-#define DPKG_DEB_OPT_EXTRACT    8
-#define DPKG_DEB_OPT_EXTRACT_VERBOSE    16
+#define DPKG_DEB_OPT_CONTENTS         1
+#define DPKG_DEB_OPT_CONTROL          2
+#define DPKG_DEB_OPT_FIELD            4
+#define DPKG_DEB_OPT_EXTRACT          8
+#define DPKG_DEB_OPT_EXTRACT_VERBOSE 16
 
-int dpkg_deb_main(int argc, char **argv);
+int dpkg_deb_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int dpkg_deb_main(int argc, char **argv)
 {
@@ -21 +21 @@
     llist_t *control_tar_llist = NULL;
     unsigned opt;
-    const char *extract_dir = NULL;
-    short argcount = 1;
+    const char *extract_dir;
+    int need_args;
 
     /* Setup the tar archive handle */
@@ -29 +29 @@
     /* Setup an ar archive handle that refers to the gzip sub archive */
     ar_archive = init_handle();
-    ar_archive->sub_archive = tar_archive;
+    ar_archive->dpkg__sub_archive = tar_archive;
     ar_archive->filter = filter_accept_list_reassign;
 
-#if ENABLE_FEATURE_DEB_TAR_GZ
-    llist_add_to(&(ar_archive->accept), (char*)"data.tar.gz");
+#if ENABLE_FEATURE_SEAMLESS_GZ
+    llist_add_to(&ar_archive->accept, (char*)"data.tar.gz");
     llist_add_to(&control_tar_llist, (char*)"control.tar.gz");
 #endif
-
-#if ENABLE_FEATURE_DEB_TAR_BZ2
-    llist_add_to(&(ar_archive->accept), (char*)"data.tar.bz2");
+#if ENABLE_FEATURE_SEAMLESS_BZ2
+    llist_add_to(&ar_archive->accept, (char*)"data.tar.bz2");
     llist_add_to(&control_tar_llist, (char*)"control.tar.bz2");
 #endif
+#if ENABLE_FEATURE_SEAMLESS_LZMA
+    llist_add_to(&ar_archive->accept, (char*)"data.tar.lzma");
+    llist_add_to(&control_tar_llist, (char*)"control.tar.lzma");
+#endif
 
-    opt_complementary = "?c--efXx:e--cfXx:f--ceXx:X--cefx:x--cefX";
+    opt_complementary = "c--efXx:e--cfXx:f--ceXx:X--cefx:x--cefX";
     opt = getopt32(argv, "cefXx");
+    argv += optind;
+    argc -= optind;
 
     if (opt & DPKG_DEB_OPT_CONTENTS) {
         tar_archive->action_header = header_verbose_list;
     }
+    extract_dir = NULL;
+    need_args = 1;
     if (opt & DPKG_DEB_OPT_CONTROL) {
         ar_archive->accept = control_tar_llist;
         tar_archive->action_data = data_extract_all;
-        if (optind + 1 == argc) {
+        if (1 == argc) {
             extract_dir = "./DEBIAN";
         } else {
-            argcount++;
+            need_args++;
         }
     }
@@ -71 +78 @@
     if (opt & (DPKG_DEB_OPT_EXTRACT_VERBOSE | DPKG_DEB_OPT_EXTRACT)) {
         tar_archive->action_data = data_extract_all;
-        argcount = 2;
+        need_args = 2;
     }
 
-    if ((optind + argcount) != argc) {
+    if (need_args != argc) {
         bb_show_usage();
     }
 
-    tar_archive->src_fd = ar_archive->src_fd = xopen(argv[optind++], O_RDONLY);
+    tar_archive->src_fd = ar_archive->src_fd = xopen(argv[0], O_RDONLY);
 
-    /* Workout where to extract the files */
+    /* Work out where to extract the files */
     /* 2nd argument is a dir name */
-    if (argv[optind]) {
-        extract_dir = argv[optind];
+    if (argv[1]) {
+        extract_dir = argv[1];
     }
     if (extract_dir) {
@@ -89 +96 @@
         xchdir(extract_dir);
     }
+
+    /* Do it */
     unpack_ar_archive(ar_archive);
 
     /* Cleanup */
-    close(ar_archive->src_fd);
+    if (ENABLE_FEATURE_CLEAN_UP)
+        close(ar_archive->src_fd);
 
     return EXIT_SUCCESS;

branches/2.2.9/mindi-busybox/archival/gzip.c

@@ -14 +14 @@
  * command line handling.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -41 +41 @@
 
 #include "libbb.h"
+#include "archive.h"
 
 
@@ -68 +69 @@
 #define SMALL_MEM
 
-#ifndef INBUFSIZ
+#ifndef INBUFSIZ
 #  ifdef SMALL_MEM
 #    define INBUFSIZ  0x2000    /* input buffer size */
@@ -76 +77 @@
 #endif
 
-#ifndef OUTBUFSIZ
+#ifndef OUTBUFSIZ
 #  ifdef SMALL_MEM
 #    define OUTBUFSIZ   8192    /* output buffer size */
@@ -267 +268 @@
     type * array
 #define ALLOC(type, array, size) \
-    array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type));
+    array = xzalloc((size_t)(((size)+1L)/2) * 2*sizeof(type))
 #define FREE(array) \
     do { free(array); array = NULL; } while (0)
@@ -340 +341 @@
 #endif
 
-    uint32_t *crc_32_tab;
+    /*uint32_t *crc_32_tab;*/
     uint32_t crc;   /* shift register contents */
 };
@@ -389 +390 @@
 
 /* ===========================================================================
- * Clear input and output buffers
- */
-static void clear_bufs(void)
-{
-    G1.outcnt = 0;
-#ifdef DEBUG
-    G1.insize = 0;
-#endif
-    G1.isize = 0;
-}
-
-
-/* ===========================================================================
  * 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 uint32_t updcrc(uch * s, unsigned n)
-{
-    uint32_t c = G1.crc;
-    while (n) {
-        c = G1.crc_32_tab[(uch)(c ^ *s++)] ^ (c >> 8);
-        n--;
-    }
-    G1.crc = c;
-    return c;
+static void updcrc(uch * s, unsigned n)
+{
+    G1.crc = crc32_block_endian0(G1.crc, s, n, global_crc32_table /*G1.crc_32_tab*/);
 }
 
@@ -633 +615 @@
          * 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])
+        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
@@ -687 +671 @@
         bb_error_msg("\\[%d,%d]", start - match, length);
         do {
-            putc(G1.window[start++], stderr);
+            bb_putchar_stderr(G1.window[start++]);
         } while (--length != 0);
     }
@@ -975 +959 @@
 #  define SEND_CODE(c, tree) \
 { \
-    if (verbose > 1) bb_error_msg("\ncd %3d ",(c)); \
+    if (verbose > 1) bb_error_msg("\ncd %3d ", (c)); \
     send_bits(tree[c].Code, tree[c].Len); \
 }
@@ -1186 +1170 @@
         Tracec(tree != G2.static_ltree,
                (stderr, "\nn %3d %c l %2d c %4x (%x) ", n,
-                (isgraph(n) ? n : ' '), len, tree[n].Code,
+                (n > ' ' ? n : ' '), len, tree[n].Code,
                 next_code[len] - 1));
     }
@@ -1554 +1538 @@
         if ((flag & 1) == 0) {
             SEND_CODE(lc, ltree);   /* send a literal byte */
-            Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
+            Tracecv(lc > ' ', (stderr, " '%c' ", lc));
         } else {
             /* Here, lc is the match length - MIN_MATCH */
@@ -2009 +1993 @@
 /* ======================================================================== */
 static
-char* make_new_name_gzip(char *filename)
-{
-    return xasprintf("%s.gz", filename);
-}
-
-static
-USE_DESKTOP(long long) int pack_gzip(void)
+IF_DESKTOP(long long) int FAST_FUNC pack_gzip(unpack_info_t *info UNUSED_PARAM)
 {
     struct stat s;
 
-    clear_bufs();
-    s.st_ctime = 0;
-    fstat(STDIN_FILENO, &s);
-    zip(s.st_ctime);
-    return 0;
-}
-
-int gzip_main(int argc, char **argv);
-int gzip_main(int argc, char **argv)
-{
-    unsigned opt;
-
-    /* Must match bbunzip's constants OPT_STDOUT, OPT_FORCE! */
-    opt = getopt32(argv, "cfv" USE_GUNZIP("d") "q123456789" );
-    option_mask32 &= 0x7; /* Clear -d, ignore -q, -0..9 */
-    //if (opt & 0x1) // -c
-    //if (opt & 0x2) // -f
-    //if (opt & 0x4) // -v
-#if ENABLE_GUNZIP /* gunzip_main may not be visible... */
-    if (opt & 0x8) { // -d
-        return gunzip_main(argc, argv);
-    }
-#endif
-    argv += optind;
-
-    PTR_TO_GLOBALS = xzalloc(sizeof(struct globals) + sizeof(struct globals2))
-            + sizeof(struct globals);
-    G2.l_desc.dyn_tree    = G2.dyn_ltree;
-    G2.l_desc.static_tree = G2.static_ltree;
-    G2.l_desc.extra_bits  = extra_lbits;
-    G2.l_desc.extra_base  = LITERALS + 1;
-    G2.l_desc.elems       = L_CODES;
-    G2.l_desc.max_length  = MAX_BITS;
-    //G2.l_desc.max_code    = 0;
-
-    G2.d_desc.dyn_tree    = G2.dyn_dtree;
-    G2.d_desc.static_tree = G2.static_dtree;
-    G2.d_desc.extra_bits  = extra_dbits;
-    //G2.d_desc.extra_base  = 0;
-    G2.d_desc.elems       = D_CODES;
-    G2.d_desc.max_length  = MAX_BITS;
-    //G2.d_desc.max_code    = 0;
-
+    /* Clear input and output buffers */
+    G1.outcnt = 0;
+#ifdef DEBUG
+    G1.insize = 0;
+#endif
+    G1.isize = 0;
+
+    /* Reinit G2.xxx */
+    memset(&G2, 0, sizeof(G2));
+    G2.l_desc.dyn_tree     = G2.dyn_ltree;
+    G2.l_desc.static_tree  = G2.static_ltree;
+    G2.l_desc.extra_bits   = extra_lbits;
+    G2.l_desc.extra_base   = LITERALS + 1;
+    G2.l_desc.elems        = L_CODES;
+    G2.l_desc.max_length   = MAX_BITS;
+    //G2.l_desc.max_code     = 0;
+    G2.d_desc.dyn_tree     = G2.dyn_dtree;
+    G2.d_desc.static_tree  = G2.static_dtree;
+    G2.d_desc.extra_bits   = extra_dbits;
+    //G2.d_desc.extra_base   = 0;
+    G2.d_desc.elems        = D_CODES;
+    G2.d_desc.max_length   = MAX_BITS;
+    //G2.d_desc.max_code     = 0;
     G2.bl_desc.dyn_tree    = G2.bl_tree;
     //G2.bl_desc.static_tree = NULL;
@@ -2070 +2028 @@
     //G2.bl_desc.max_code    = 0;
 
+    s.st_ctime = 0;
+    fstat(STDIN_FILENO, &s);
+    zip(s.st_ctime);
+    return 0;
+}
+
+#if ENABLE_FEATURE_GZIP_LONG_OPTIONS
+static const char gzip_longopts[] ALIGN1 =
+    "stdout\0"              No_argument       "c"
+    "to-stdout\0"           No_argument       "c"
+    "force\0"               No_argument       "f"
+    "verbose\0"             No_argument       "v"
+#if ENABLE_GUNZIP
+    "decompress\0"          No_argument       "d"
+    "uncompress\0"          No_argument       "d"
+    "test\0"                No_argument       "t"
+#endif
+    "quiet\0"               No_argument       "q"
+    "fast\0"                No_argument       "1"
+    "best\0"                No_argument       "9"
+    ;
+#endif
+
+/*
+ * Linux kernel build uses gzip -d -n. We accept and ignore -n.
+ * Man page says:
+ * -n --no-name
+ * gzip: do not save the original file name and time stamp.
+ * (The original name is always saved if the name had to be truncated.)
+ * gunzip: do not restore the original file name/time even if present
+ * (remove only the gzip suffix from the compressed file name).
+ * This option is the default when decompressing.
+ * -N --name
+ * gzip: always save the original file name and time stamp (this is the default)
+ * gunzip: restore the original file name and time stamp if present.
+ */
+
+int gzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+#if ENABLE_GUNZIP
+int gzip_main(int argc, char **argv)
+#else
+int gzip_main(int argc UNUSED_PARAM, char **argv)
+#endif
+{
+    unsigned opt;
+
+#if ENABLE_FEATURE_GZIP_LONG_OPTIONS
+    applet_long_options = gzip_longopts;
+#endif
+    /* Must match bbunzip's constants OPT_STDOUT, OPT_FORCE! */
+    opt = getopt32(argv, "cfv" IF_GUNZIP("dt") "q123456789n");
+#if ENABLE_GUNZIP /* gunzip_main may not be visible... */
+    if (opt & 0x18) // -d and/or -t
+        return gunzip_main(argc, argv);
+#endif
+    option_mask32 &= 0x7; /* ignore -q, -0..9 */
+    //if (opt & 0x1) // -c
+    //if (opt & 0x2) // -f
+    //if (opt & 0x4) // -v
+    argv += optind;
+
+    SET_PTR_TO_GLOBALS((char *)xzalloc(sizeof(struct globals)+sizeof(struct globals2))
+            + sizeof(struct globals));
+
     /* Allocate all global buffers (for DYN_ALLOC option) */
     ALLOC(uch, G1.l_buf, INBUFSIZ);
@@ -2077 +2099 @@
     ALLOC(ush, G1.prev, 1L << BITS);
 
-    /* Initialise the CRC32 table */
-    G1.crc_32_tab = crc32_filltable(NULL, 0);
-
-    return bbunpack(argv, make_new_name_gzip, pack_gzip);
-}
+    /* Initialize the CRC32 table */
+    global_crc32_table = crc32_filltable(NULL, 0);
+
+    return bbunpack(argv, pack_gzip, append_ext, "gz");
+}

branches/2.2.9/mindi-busybox/archival/rpm.c

@@ -5 +5 @@
  * Copyright (C) 2001,2002 by Laurence Anderson
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #include "libbb.h"
-#include "unarchive.h"
-
-#define RPM_HEADER_MAGIC        "\216\255\350"
+#include "archive.h"
+#include "rpm.h"
+
 #define RPM_CHAR_TYPE           1
 #define RPM_INT8_TYPE           2
@@ -47 +47 @@
 #define TAG_BASENAMES           1117
 #define TAG_DIRNAMES            1118
+
 #define RPMFILE_CONFIG          (1 << 0)
 #define RPMFILE_DOC             (1 << 1)
@@ -71 +72 @@
 static int tagcount;
 
-static void extract_cpio_gz(int fd);
+static void extract_cpio(int fd, const char *source_rpm);
 static rpm_index **rpm_gettags(int fd, int *num_tags);
 static int bsearch_rpmtag(const void *key, const void *item);
@@ -81 +82 @@
 static void loop_through_files(int filetag, void (*fileaction)(char *filename, int fileref));
 
-int rpm_main(int argc, char **argv);
+int rpm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int rpm_main(int argc, char **argv)
 {
@@ -116 +117 @@
     }
     argv += optind;
-    argc -= optind;
-    if (!argc) bb_show_usage();
+    //argc -= optind;
+    if (!argv[0]) {
+        bb_show_usage();
+    }
 
     while (*argv) {
+        const char *source_rpm;
+
         rpm_fd = xopen(*argv++, O_RDONLY);
         mytags = rpm_gettags(rpm_fd, &tagcount);
@@ -128 +133 @@
         map = mmap(0, offset > pagesize ? (offset + offset % pagesize) : pagesize, PROT_READ, MAP_PRIVATE, rpm_fd, 0);
 
+        source_rpm = rpm_getstr(TAG_SOURCERPM, 0);
+
         if (func & rpm_install) {
             /* Backup any config files */
             loop_through_files(TAG_BASENAMES, fileaction_dobackup);
             /* Extact the archive */
-            extract_cpio_gz(rpm_fd);
+            extract_cpio(rpm_fd, source_rpm);
             /* Set the correct file uid/gid's */
             loop_through_files(TAG_BASENAMES, fileaction_setowngrp);
@@ -144 +151 @@
                 /* Do the nice printout */
                 time_t bdate_time;
-                struct tm *bdate;
+                struct tm *bdate_ptm;
                 char bdatestring[50];
-                printf("Name        : %-29sRelocations: %s\n", rpm_getstr(TAG_NAME, 0), rpm_getstr(TAG_PREFIXS, 0) ? rpm_getstr(TAG_PREFIXS, 0) : "(not relocateable)");
-                printf("Version     : %-34sVendor: %s\n", rpm_getstr(TAG_VERSION, 0), rpm_getstr(TAG_VENDOR, 0) ? rpm_getstr(TAG_VENDOR, 0) : "(none)");
+                const char *p;
+
+                p = rpm_getstr(TAG_PREFIXS, 0);
+                if (!p) p = "(not relocateable)";
+                printf("Name        : %-29sRelocations: %s\n", rpm_getstr(TAG_NAME, 0), p);
+                p = rpm_getstr(TAG_VENDOR, 0);
+                if (!p) p = "(none)";
+                printf("Version     : %-34sVendor: %s\n", rpm_getstr(TAG_VERSION, 0), p);
                 bdate_time = rpm_getint(TAG_BUILDTIME, 0);
-                bdate = localtime((time_t *) &bdate_time);
-                strftime(bdatestring, 50, "%a %d %b %Y %T %Z", bdate);
+                bdate_ptm = localtime(&bdate_time);
+                strftime(bdatestring, 50, "%a %d %b %Y %T %Z", bdate_ptm);
                 printf("Release     : %-30sBuild Date: %s\n", rpm_getstr(TAG_RELEASE, 0), bdatestring);
                 printf("Install date: %-30sBuild Host: %s\n", "(not installed)", rpm_getstr(TAG_BUILDHOST, 0));
-                printf("Group       : %-30sSource RPM: %s\n", rpm_getstr(TAG_GROUP, 0), rpm_getstr(TAG_SOURCERPM, 0));
+                printf("Group       : %-30sSource RPM: %s\n", rpm_getstr(TAG_GROUP, 0), source_rpm);
                 printf("Size        : %-33dLicense: %s\n", rpm_getint(TAG_SIZE, 0), rpm_getstr(TAG_LICENSE, 0));
                 printf("URL         : %s\n", rpm_getstr(TAG_URL, 0));
@@ -186 +199 @@
 }
 
-static void extract_cpio_gz(int fd)
+static void extract_cpio(int fd, const char *source_rpm)
 {
     archive_handle_t *archive_handle;
-    unsigned char magic[2];
-#if BB_MMU
-    USE_DESKTOP(long long) int (*xformer)(int src_fd, int dst_fd);
-    enum { xformer_prog = 0 };
-#else
-    enum { xformer = 0 };
-    const char *xformer_prog;
-#endif
+
+    if (source_rpm != NULL) {
+        /* Binary rpm (it was built from some SRPM), install to root */
+        xchdir("/");
+    } /* else: SRPM, install to current dir */
 
     /* Initialize */
     archive_handle = init_handle();
     archive_handle->seek = seek_by_read;
-    //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;
+#if 0 /* For testing (rpm -i only lists the files in internal cpio): */
+    archive_handle->action_header = header_list;
+    archive_handle->action_data = data_skip;
+#endif
+    archive_handle->ah_flags = ARCHIVE_RESTORE_DATE | ARCHIVE_CREATE_LEADING_DIRS
+        /* compat: overwrite existing files.
+         * try "rpm -i foo.src.rpm" few times in a row -
+         * standard rpm will not complain.
+         * (TODO? real rpm creates "file;1234" and then renames it) */
+        | ARCHIVE_UNLINK_OLD;
     archive_handle->src_fd = fd;
-    archive_handle->offset = 0;
-
-    xread(archive_handle->src_fd, &magic, 2);
-#if BB_MMU
-    xformer = unpack_gz_stream;
-#else
-    xformer_prog = "gunzip";
-#endif
-    if ((magic[0] != 0x1f) || (magic[1] != 0x8b)) {
-        if (ENABLE_FEATURE_RPM_BZ2
-         && (magic[0] == 0x42) && (magic[1] == 0x5a)) {
-#if BB_MMU
-            xformer = unpack_bz2_stream;
-#else
-            xformer_prog = "bunzip2";
-#endif
-    /* We can do better, need modifying unpack_bz2_stream to not require
-     * first 2 bytes. Not very hard to do... I mean, TODO :) */
-            xlseek(archive_handle->src_fd, -2, SEEK_CUR);
-        } else
-            bb_error_msg_and_die("no gzip"
-                USE_FEATURE_RPM_BZ2("/bzip")
-                " magic");
-    } else {
-        check_header_gzip_or_die(archive_handle->src_fd);
-#if !BB_MMU
-        /* NOMMU version of open_transformer execs an external unzipper that should
-         * have the file position at the start of the file */
-        xlseek(archive_handle->src_fd, 0, SEEK_SET);
-#endif
-    }
-
-    xchdir("/"); /* Install RPM's to root */
-    archive_handle->src_fd = open_transformer(archive_handle->src_fd, xformer, xformer_prog, xformer_prog, "-cf", "-", NULL);
-    archive_handle->offset = 0;
+    /*archive_handle->offset = 0; - init_handle() did it */
+
+    setup_unzip_on_fd(archive_handle->src_fd /*, fail_if_not_detected: 1*/);
     while (get_header_cpio(archive_handle) == EXIT_SUCCESS)
         continue;
 }
 
-
 static rpm_index **rpm_gettags(int fd, int *num_tags)
 {
-    /* We should never need mode than 200, and realloc later */
-    rpm_index **tags = xzalloc(200 * sizeof(struct rpmtag *));
+    /* We should never need more than 200 (shrink via realloc later) */
+    rpm_index **tags = xzalloc(200 * sizeof(tags[0]));
     int pass, tagindex = 0;
 
@@ -256 +240 @@
     /* 1st pass is the signature headers, 2nd is the main stuff */
     for (pass = 0; pass < 2; pass++) {
-        struct {
-            char magic[3]; /* 3 byte magic: 0x8e 0xad 0xe8 */
-            uint8_t version; /* 1 byte version number */
-            uint32_t reserved; /* 4 bytes reserved */
-            uint32_t entries; /* Number of entries in header (4 bytes) */
-            uint32_t size; /* Size of store (4 bytes) */
-        } header;
+        struct rpm_header header;
         rpm_index *tmpindex;
         int storepos;
 
         xread(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 */
+        if (header.magic_and_ver != htonl(RPM_HEADER_MAGICnVER))
+            return NULL; /* Invalid magic, or not version 1 */
         header.size = ntohl(header.size);
         header.entries = ntohl(header.entries);
-        storepos = xlseek(fd,0,SEEK_CUR) + header.entries * 16;
+        storepos = xlseek(fd, 0, SEEK_CUR) + header.entries * 16;
 
         while (header.entries--) {
-            tmpindex = tags[tagindex++] = xmalloc(sizeof(rpm_index));
-            xread(fd, tmpindex, sizeof(rpm_index));
+            tmpindex = tags[tagindex++] = xmalloc(sizeof(*tmpindex));
+            xread(fd, tmpindex, sizeof(*tmpindex));
             tmpindex->tag = ntohl(tmpindex->tag);
             tmpindex->type = ntohl(tmpindex->type);
             tmpindex->count = ntohl(tmpindex->count);
             tmpindex->offset = storepos + ntohl(tmpindex->offset);
-            if (pass==0)
+            if (pass == 0)
                 tmpindex->tag -= 743;
         }
-        xlseek(fd, header.size, SEEK_CUR); /* Seek past store */
+        storepos = xlseek(fd, header.size, SEEK_CUR); /* Seek past store */
         /* Skip padding to 8 byte boundary after reading signature headers */
-        if (pass==0)
-            xlseek(fd, (8 - (xlseek(fd,0,SEEK_CUR) % 8)) % 8, SEEK_CUR);
-    }
-    tags = xrealloc(tags, tagindex * sizeof(struct rpmtag *)); /* realloc tags to save space */
+        if (pass == 0)
+            xlseek(fd, (-storepos) & 0x7, SEEK_CUR);
+    }
+    /* realloc tags to save space */
+    tags = xrealloc(tags, tagindex * sizeof(tags[0]));
     *num_tags = tagindex;
-    return tags; /* All done, leave the file at the start of the gzipped cpio archive */
+    /* All done, leave the file at the start of the gzipped cpio archive */
+    return tags;
 }
 
@@ -317 +295 @@
     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) {
+    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++)
+        char *tmpstr = (char *) map + found[0]->offset;
+        for (n = 0; n < itemindex; n++)
             tmpstr = tmpstr + strlen(tmpstr) + 1;
         return tmpstr;
@@ -338 +319 @@
         return -1;
 
-    tmpint = (int *) (map + found[0]->offset);
+    tmpint = (int *) ((char *) map + found[0]->offset);
 
     if (found[0]->type == RPM_INT32_TYPE) {
@@ -381 +362 @@
 static void fileaction_setowngrp(char *filename, int fileref)
 {
-    int uid, gid;
-    uid = xuname2uid(rpm_getstr(TAG_FILEUSERNAME, fileref));
-    gid = xgroup2gid(rpm_getstr(TAG_FILEGROUPNAME, fileref));
+    /* real rpm warns: "user foo does not exist - using <you>" */
+    struct passwd *pw = getpwnam(rpm_getstr(TAG_FILEUSERNAME, fileref));
+    int uid = pw ? pw->pw_uid : getuid(); /* or euid? */
+    struct group *gr = getgrnam(rpm_getstr(TAG_FILEGROUPNAME, fileref));
+    int gid = gr ? gr->gr_gid : getgid();
     chown(filename, uid, gid);
 }

branches/2.2.9/mindi-busybox/archival/rpm2cpio.c

@@ -5 +5 @@
  * Copyright (C) 2001 by Laurence Anderson
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 #include "libbb.h"
-#include "unarchive.h"
+#include "archive.h"
+#include "rpm.h"
 
-#define RPM_MAGIC "\355\253\356\333"
-#define RPM_HEADER_MAGIC "\216\255\350"
+enum { rpm_fd = STDIN_FILENO };
 
-struct rpm_lead {
-    unsigned char magic[4];
-    uint8_t major, minor;
-    uint16_t type;
-    uint16_t archnum;
-    char name[66];
-    uint16_t osnum;
-    uint16_t signature_type;
-    char reserved[16];
-};
-
-struct rpm_header {
-    char magic[3]; /* 3 byte magic: 0x8e 0xad 0xe8 */
-    uint8_t version; /* 1 byte version number */
-    uint32_t reserved; /* 4 bytes reserved */
-    uint32_t entries; /* Number of entries in header (4 bytes) */
-    uint32_t size; /* Size of store (4 bytes) */
-};
-
-static void skip_header(int rpm_fd)
+static unsigned skip_header(void)
 {
     struct rpm_header header;
+    unsigned len;
 
-    xread(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 */
+    xread(rpm_fd, &header, sizeof(header));
+//  if (strncmp((char *) &header.magic, RPM_HEADER_MAGIC_STR, 3) != 0) {
+//      bb_error_msg_and_die("invalid RPM header magic");
+//  }
+//  if (header.version != 1) {
+//      bb_error_msg_and_die("unsupported RPM header version");
+//  }
+    if (header.magic_and_ver != htonl(RPM_HEADER_MAGICnVER)) {
+        bb_error_msg_and_die("invalid RPM header magic or unsupported version");
+        // ": %x != %x", header.magic_and_ver, htonl(RPM_HEADER_MAGICnVER));
     }
-    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 */
+
+    /* Seek past index entries, and past store */
+    len = 16 * ntohl(header.entries) + ntohl(header.size);
+    seek_by_jump(rpm_fd, len);
+
+    return sizeof(header) + len;
 }
 
 /* No getopt required */
-int rpm2cpio_main(int argc, char **argv);
-int rpm2cpio_main(int argc, char **argv)
+int rpm2cpio_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int rpm2cpio_main(int argc UNUSED_PARAM, char **argv)
 {
     struct rpm_lead lead;
-    int rpm_fd;
-    unsigned char magic[2];
+    unsigned pos;
 
-    if (argc == 1) {
-        rpm_fd = STDIN_FILENO;
-    } else {
-        rpm_fd = xopen(argv[1], O_RDONLY);
+    if (argv[1]) {
+        xmove_fd(xopen(argv[1], O_RDONLY), rpm_fd);
+    }
+    xread(rpm_fd, &lead, sizeof(lead));
+
+    /* Just check the magic, the rest is irrelevant */
+    if (lead.magic != htonl(RPM_LEAD_MAGIC)) {
+        bb_error_msg_and_die("invalid RPM magic");
     }
 
-    xread(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 signature header, align to 8 bytes */
+    pos = skip_header();
+    seek_by_jump(rpm_fd, (-(int)pos) & 7);
 
     /* Skip the main header */
-    skip_header(rpm_fd);
+    skip_header();
 
-    xread(rpm_fd, &magic, 2);
-    if ((magic[0] != 0x1f) || (magic[1] != 0x8b)) {
-        bb_error_msg_and_die("invalid gzip magic");
+#if 0
+    /* This works, but doesn't report uncompress errors (they happen in child) */
+    setup_unzip_on_fd(rpm_fd /*fail_if_not_detected: 1*/);
+    if (bb_copyfd_eof(rpm_fd, STDOUT_FILENO) < 0)
+        bb_error_msg_and_die("error unpacking");
+#else
+    /* BLOAT */
+    {
+        union {
+            uint8_t b[4];
+            uint16_t b16[2];
+            uint32_t b32[1];
+        } magic;
+        IF_DESKTOP(long long) int FAST_FUNC (*unpack)(int src_fd, int dst_fd);
+
+        xread(rpm_fd, magic.b16, sizeof(magic.b16[0]));
+        if (magic.b16[0] == GZIP_MAGIC) {
+            unpack = unpack_gz_stream;
+        } else
+        if (ENABLE_FEATURE_SEAMLESS_BZ2
+         && magic.b16[0] == BZIP2_MAGIC
+        ) {
+            unpack = unpack_bz2_stream;
+        } else
+        if (ENABLE_FEATURE_SEAMLESS_XZ
+         && magic.b16[0] == XZ_MAGIC1
+        ) {
+            xread(rpm_fd, magic.b32, sizeof(magic.b32[0]));
+            if (magic.b32[0] != XZ_MAGIC2)
+                goto no_magic;
+            /* unpack_xz_stream wants fd at position 6, no need to seek */
+            //xlseek(rpm_fd, -6, SEEK_CUR);
+            unpack = unpack_xz_stream;
+        } else {
+ no_magic:
+            bb_error_msg_and_die("no gzip"
+                    IF_FEATURE_SEAMLESS_BZ2("/bzip2")
+                    IF_FEATURE_SEAMLESS_XZ("/xz")
+                    " magic");
+        }
+        if (unpack(rpm_fd, STDOUT_FILENO) < 0)
+            bb_error_msg_and_die("error unpacking");
     }
+#endif
 
-    check_header_gzip_or_die(rpm_fd);
-    if (unpack_gz_stream(rpm_fd, STDOUT_FILENO) < 0) {
-        bb_error_msg("error inflating");
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        close(rpm_fd);
     }
-
-    close(rpm_fd);
 
     return 0;

branches/2.2.9/mindi-busybox/archival/tar.c

@@ -4 +4 @@
  *
  * Modified to use common extraction code used by ar, cpio, dpkg-deb, dpkg
- *  Glenn McGrath <bug1@iinet.net.au>
+ *  by Glenn McGrath
  *
  * Note, that as of BusyBox-0.43, tar has been completely rewritten from the
@@ -16 +16 @@
  *  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.
+ *  Permission to distribute sash derived code under GPL has been granted.
  *
  * Based in part on the tar implementation from busybox-0.28
  *  Copyright (C) 1995 Bruce Perens
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #include <fnmatch.h>
-#include <getopt.h>
 #include "libbb.h"
-#include "unarchive.h"
+#include "archive.h"
+/* FIXME: Stop using this non-standard feature */
+#ifndef FNM_LEADING_DIR
+# define FNM_LEADING_DIR 0
+#endif
+
+
+//#define DBG(fmt, ...) bb_error_msg("%s: " fmt, __func__, ## __VA_ARGS__)
+#define DBG(...) ((void)0)
+
 
 #define block_buf bb_common_bufsiz1
 
+
+#if !ENABLE_FEATURE_SEAMLESS_GZ && !ENABLE_FEATURE_SEAMLESS_BZ2
+/* Do not pass gzip flag to writeTarFile() */
+#define writeTarFile(tar_fd, verboseFlag, dereferenceFlag, include, exclude, gzip) \
+    writeTarFile(tar_fd, verboseFlag, dereferenceFlag, include, exclude)
+#endif
+
+
 #if ENABLE_FEATURE_TAR_CREATE
-
-/* Tar file constants  */
-
-#define TAR_BLOCK_SIZE      512
-
-/* POSIX tar Header Block, from POSIX 1003.1-1990  */
-#define NAME_SIZE      100
-#define NAME_SIZE_STR "100"
-typedef struct TarHeader TarHeader;
-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) */
-};
 
 /*
@@ -66 +54 @@
 ** 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) */
-};
+typedef struct HardLinkInfo {
+    struct 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) */
+} HardLinkInfo;
 
 /* Some info to be carried along when creating a new tarball */
-typedef struct TarBallInfo TarBallInfo;
-struct TarBallInfo {
-    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 {
+    int tarFd;                      /* Open-for-write file descriptor
+                                     * for the tarball */
+    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 */
+//TODO: save only st_dev + st_ino
+    struct stat tarFileStatBuf;     /* 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 */
+} TarBallInfo;
 
 /* A nice enum with all the possible tar file content types */
-enum TarFileType {
+enum {
     REGTYPE = '0',      /* regular file */
     REGTYPE0 = '\0',    /* regular file (ancient bug compat) */
@@ -104 +91 @@
     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 void addHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr,
+static void addHardLinkInfo(HardLinkInfo **hlInfoHeadPtr,
                     struct stat *statbuf,
                     const char *fileName)
@@ -119 +105 @@
     hlInfo->dev = statbuf->st_dev;
     hlInfo->ino = statbuf->st_ino;
-    hlInfo->linkCount = statbuf->st_nlink;
+//  hlInfo->linkCount = statbuf->st_nlink;
     strcpy(hlInfo->name, fileName);
 }
 
-static void freeHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr)
+static void freeHardLinkInfo(HardLinkInfo **hlInfoHeadPtr)
 {
     HardLinkInfo *hlInfo;
@@ -139 +125 @@
 }
 
-/* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
-static HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, struct stat *statbuf)
+/* Might be faster (and bigger) if the dev/ino were stored in numeric order ;) */
+static HardLinkInfo *findHardLinkInfo(HardLinkInfo *hlInfo, struct stat *statbuf)
 {
     while (hlInfo) {
-        if ((statbuf->st_ino == hlInfo->ino) && (statbuf->st_dev == hlInfo->dev))
+        if (statbuf->st_ino == hlInfo->ino
+         && statbuf->st_dev == hlInfo->dev
+        ) {
+            DBG("found hardlink:'%s'", hlInfo->name);
             break;
+        }
         hlInfo = hlInfo->next;
     }
@@ -155 +145 @@
 static void putOctal(char *cp, int len, off_t value)
 {
-    char tempBuffer[sizeof(off_t)*3+1];
+    char tempBuffer[sizeof(off_t)*3 + 1];
     char *tempString = tempBuffer;
     int width;
@@ -173 +163 @@
 #define PUT_OCTAL(a, b) putOctal((a), sizeof(a), (b))
 
-static void chksum_and_xwrite(int fd, struct TarHeader* hp)
+static void chksum_and_xwrite(int fd, struct tar_header_t* hp)
 {
     /* POSIX says that checksum is done on unsigned bytes
@@ -215 +205 @@
         "00000000000",
     };
-    struct TarHeader header;
+    struct tar_header_t header;
     int size;
 
@@ -242 +232 @@
 
 /* Write out a tar header for the specified file/directory/whatever */
-void BUG_tar_header_size(void);
 static int writeTarHeader(struct TarBallInfo *tbInfo,
         const char *header_name, const char *fileName, struct stat *statbuf)
 {
-    struct TarHeader header;
-
-    if (sizeof(header) != 512)
-        BUG_tar_header_size();
-
-    memset(&header, 0, sizeof(struct TarHeader));
+    struct tar_header_t header;
+
+    memset(&header, 0, sizeof(header));
 
     strncpy(header.name, header_name, sizeof(header.name));
@@ -315 +301 @@
          && statbuf->st_size > (off_t)0777777777777LL
         ) {
-            bb_error_msg_and_die("cannot store file '%s' "
-                "of size %"OFF_FMT"d, aborting",
+            bb_error_msg_and_die("can't store file '%s' "
+                "of size %"OFF_FMT"u, aborting",
                 fileName, statbuf->st_size);
         }
@@ -341 +327 @@
         FILE *vbFd = stdout;
 
-        if (tbInfo->tarFd == STDOUT_FILENO) /* If the archive goes to stdout, verbose to stderr */
+        /* If archive goes to stdout, verbose goes to stderr */
+        if (tbInfo->tarFd == STDOUT_FILENO)
             vbFd = stderr;
         /* GNU "tar cvvf" prints "extended" listing a-la "ls -l" */
@@ -359 +346 @@
         if (excluded_files->data[0] == '/') {
             if (fnmatch(excluded_files->data, file,
-                        FNM_PATHNAME | FNM_LEADING_DIR) == 0)
+                    FNM_PATHNAME | FNM_LEADING_DIR) == 0)
                 return 1;
         } else {
@@ -365 +352 @@
 
             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)
+                if ((p == file || p[-1] == '/')
+                 && p[0] != '/'
+                 && fnmatch(excluded_files->data, p,
+                        FNM_PATHNAME | FNM_LEADING_DIR) == 0
+                ) {
                     return 1;
+                }
             }
         }
@@ -377 +367 @@
 }
 #else
-#define exclude_file(excluded_files, file) 0
-#endif
-
-static int writeFileToTarball(const char *fileName, struct stat *statbuf,
-            void *userData, int depth ATTRIBUTE_UNUSED)
+# define exclude_file(excluded_files, file) 0
+#endif
+
+static int FAST_FUNC writeFileToTarball(const char *fileName, struct stat *statbuf,
+            void *userData, int depth UNUSED_PARAM)
 {
     struct TarBallInfo *tbInfo = (struct TarBallInfo *) userData;
     const char *header_name;
     int inputFileFd = -1;
+
+    DBG("writeFileToTarball('%s')", fileName);
+
+    /* Strip leading '/' (must be before memorizing hardlink's name) */
+    header_name = fileName;
+    while (header_name[0] == '/') {
+        static smallint warned;
+
+        if (!warned) {
+            bb_error_msg("removing leading '/' from member names");
+            warned = 1;
+        }
+        header_name++;
+    }
+
+    if (header_name[0] == '\0')
+        return TRUE;
+
+    /* It is against the rules to archive a socket */
+    if (S_ISSOCK(statbuf->st_mode)) {
+        bb_error_msg("%s: socket ignored", fileName);
+        return TRUE;
+    }
 
     /*
@@ -395 +408 @@
      */
     tbInfo->hlInfo = NULL;
-    if (statbuf->st_nlink > 1) {
+    if (!S_ISDIR(statbuf->st_mode) && statbuf->st_nlink > 1) {
+        DBG("'%s': st_nlink > 1", header_name);
         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;
+        if (tbInfo->hlInfo == NULL) {
+            DBG("'%s': addHardLinkInfo", header_name);
+            addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, header_name);
+        }
     }
 
@@ -410 +420 @@
      * 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) {
+    if (tbInfo->tarFileStatBuf.st_dev == statbuf->st_dev
+     && tbInfo->tarFileStatBuf.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 smallint warned;
-
-        if (!warned) {
-            bb_error_msg("removing leading '/' from member names");
-            warned = 1;
-        }
-        header_name++;
-    }
+    if (exclude_file(tbInfo->excludeList, header_name))
+        return SKIP;
 
 #if !ENABLE_FEATURE_TAR_GNU_EXTENSIONS
-    if (strlen(fileName) >= NAME_SIZE) {
+    if (strlen(header_name) >= NAME_SIZE) {
         bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
         return TRUE;
     }
 #endif
-
-    if (header_name[0] == '\0')
-        return TRUE;
-
-    if (exclude_file(tbInfo->excludeList, header_name))
-        return SKIP;
 
     /* Is this a regular file? */
@@ -485 +482 @@
 }
 
-static int writeTarFile(const int tar_fd, const int verboseFlag,
-    const unsigned long dereferenceFlag, const llist_t *include,
-    const llist_t *exclude, const int gzip)
-{
-    pid_t gzipPid = 0;
+#if ENABLE_FEATURE_SEAMLESS_GZ || ENABLE_FEATURE_SEAMLESS_BZ2
+# if !(ENABLE_FEATURE_SEAMLESS_GZ && ENABLE_FEATURE_SEAMLESS_BZ2)
+#  define vfork_compressor(tar_fd, gzip) vfork_compressor(tar_fd)
+# endif
+/* Don't inline: vfork scares gcc and pessimizes code */
+static void NOINLINE vfork_compressor(int tar_fd, int gzip)
+{
+    pid_t gzipPid;
+# if ENABLE_FEATURE_SEAMLESS_GZ && ENABLE_FEATURE_SEAMLESS_BZ2
+    const char *zip_exec = (gzip == 1) ? "gzip" : "bzip2";
+# elif ENABLE_FEATURE_SEAMLESS_GZ
+    const char *zip_exec = "gzip";
+# else /* only ENABLE_FEATURE_SEAMLESS_BZ2 */
+    const char *zip_exec = "bzip2";
+# endif
+    // On Linux, vfork never unpauses parent early, although standard
+    // allows for that. Do we want to waste bytes checking for it?
+# define WAIT_FOR_CHILD 0
+    volatile int vfork_exec_errno = 0;
+    struct fd_pair gzipDataPipe;
+# if WAIT_FOR_CHILD
+    struct fd_pair gzipStatusPipe;
+    xpiped_pair(gzipStatusPipe);
+# endif
+    xpiped_pair(gzipDataPipe);
+
+    signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
+
+# if defined(__GNUC__) && __GNUC__
+    /* Avoid vfork clobbering */
+    (void) &zip_exec;
+# endif
+
+    gzipPid = xvfork();
+
+    if (gzipPid == 0) {
+        /* child */
+        /* NB: close _first_, then move fds! */
+        close(gzipDataPipe.wr);
+# if WAIT_FOR_CHILD
+        close(gzipStatusPipe.rd);
+        /* gzipStatusPipe.wr will close only on exec -
+         * parent waits for this close to happen */
+        fcntl(gzipStatusPipe.wr, F_SETFD, FD_CLOEXEC);
+# endif
+        xmove_fd(gzipDataPipe.rd, 0);
+        xmove_fd(tar_fd, 1);
+        /* exec gzip/bzip2 program/applet */
+        BB_EXECLP(zip_exec, zip_exec, "-f", NULL);
+        vfork_exec_errno = errno;
+        _exit(EXIT_FAILURE);
+    }
+
+    /* parent */
+    xmove_fd(gzipDataPipe.wr, tar_fd);
+    close(gzipDataPipe.rd);
+# if WAIT_FOR_CHILD
+    close(gzipStatusPipe.wr);
+    while (1) {
+        char buf;
+        int n;
+
+        /* Wait until child execs (or fails to) */
+        n = full_read(gzipStatusPipe.rd, &buf, 1);
+        if (n < 0 /* && errno == EAGAIN */)
+            continue;   /* try it again */
+    }
+    close(gzipStatusPipe.rd);
+# endif
+    if (vfork_exec_errno) {
+        errno = vfork_exec_errno;
+        bb_perror_msg_and_die("can't execute '%s'", zip_exec);
+    }
+}
+#endif /* ENABLE_FEATURE_SEAMLESS_GZ || ENABLE_FEATURE_SEAMLESS_BZ2 */
+
+
+/* gcc 4.2.1 inlines it, making code bigger */
+static NOINLINE int writeTarFile(int tar_fd, int verboseFlag,
+    int dereferenceFlag, const llist_t *include,
+    const llist_t *exclude, int gzip)
+{
     int errorFlag = FALSE;
     struct TarBallInfo tbInfo;
 
     tbInfo.hlInfoHead = NULL;
-
-    fchmod(tar_fd, 0644);
     tbInfo.tarFd = tar_fd;
     tbInfo.verboseFlag = verboseFlag;
@@ -501 +573 @@
     /* Store the stat info for the tarball's file, so
      * can avoid including the tarball into itself....  */
-    if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
-        bb_perror_msg_and_die("cannot stat tar file");
-
-    if ((ENABLE_FEATURE_TAR_GZIP || ENABLE_FEATURE_TAR_BZIP2) && gzip) {
-        int gzipDataPipe[2] = { -1, -1 };
-        int gzipStatusPipe[2] = { -1, -1 };
-        volatile int vfork_exec_errno = 0;
-        const char *zip_exec = (gzip == 1) ? "gzip" : "bzip2";
-
-        xpipe(gzipDataPipe);
-        xpipe(gzipStatusPipe);
-
-        signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
-
-#if defined(__GNUC__) && __GNUC__
-        /* Avoid vfork clobbering */
-        (void) &include;
-        (void) &errorFlag;
-        (void) &zip_exec;
-#endif
-
-        gzipPid = vfork();
-
-        if (gzipPid == 0) {
-            dup2(gzipDataPipe[0], 0);
-            close(gzipDataPipe[1]);
-
-            dup2(tbInfo.tarFd, 1);
-
-            close(gzipStatusPipe[0]);
-            fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC);  /* close on exec shows success */
-
-            BB_EXECLP(zip_exec, zip_exec, "-f", NULL);
-            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 = full_read(gzipStatusPipe[0], &buf, 1);
-
-                if (n == 0 && vfork_exec_errno != 0) {
-                    errno = vfork_exec_errno;
-                    bb_perror_msg_and_die("cannot exec %s", zip_exec);
-                } 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("vfork gzip");
-    }
+    xfstat(tbInfo.tarFd, &tbInfo.tarFileStatBuf, "can't stat tar file");
+
+#if ENABLE_FEATURE_SEAMLESS_GZ || ENABLE_FEATURE_SEAMLESS_BZ2
+    if (gzip)
+        vfork_compressor(tbInfo.tarFd, gzip);
+#endif
 
     tbInfo.excludeList = exclude;
@@ -566 +586 @@
         if (!recursive_action(include->data, ACTION_RECURSE |
                 (dereferenceFlag ? ACTION_FOLLOWLINKS : 0),
-                writeFileToTarball, writeFileToTarball, &tbInfo, 0))
-        {
+                writeFileToTarball, writeFileToTarball, &tbInfo, 0)
+        ) {
             errorFlag = TRUE;
         }
@@ -591 +611 @@
         bb_error_msg("error exit delayed from previous errors");
 
-    if (gzipPid) {
+#if ENABLE_FEATURE_SEAMLESS_GZ || ENABLE_FEATURE_SEAMLESS_BZ2
+    if (gzip) {
         int status;
-        if (waitpid(gzipPid, &status, 0) == -1)
+        if (safe_waitpid(-1, &status, 0) == -1)
             bb_perror_msg("waitpid");
         else if (!WIFEXITED(status) || WEXITSTATUS(status))
@@ -599 +620 @@
             errorFlag = TRUE;
     }
+#endif
     return errorFlag;
 }
 #else
-int writeTarFile(const int tar_fd, const int verboseFlag,
-    const unsigned long dereferenceFlag, const llist_t *include,
-    const llist_t *exclude, const int gzip);
+int writeTarFile(int tar_fd, int verboseFlag,
+    int dereferenceFlag, const llist_t *include,
+    const llist_t *exclude, int gzip);
 #endif /* FEATURE_TAR_CREATE */
 
@@ -611 +633 @@
 {
     FILE *src_stream;
-    llist_t *cur = list;
-    llist_t *tmp;
     char *line;
     llist_t *newlist = NULL;
 
-    while (cur) {
-        src_stream = xfopen(cur->data, "r");
-        tmp = cur;
-        cur = cur->link;
-        free(tmp);
-        while ((line = xmalloc_getline(src_stream)) != NULL) {
+    while (list) {
+        src_stream = xfopen_for_read(llist_pop(&list));
+        while ((line = xmalloc_fgetline(src_stream)) != NULL) {
             /* kill trailing '/' unless the string is just "/" */
             char *cp = last_char_is(line, '/');
@@ -633 +650 @@
 }
 #else
-#define append_file_list_to_list(x) 0
-#endif
-
-#if ENABLE_FEATURE_TAR_COMPRESS
-static char get_header_tar_Z(archive_handle_t *archive_handle)
+# define append_file_list_to_list(x) 0
+#endif
+
+#if ENABLE_FEATURE_SEAMLESS_Z
+static char FAST_FUNC get_header_tar_Z(archive_handle_t *archive_handle)
 {
     /* Can't lseek over pipes */
@@ -649 +666 @@
     }
 
-    archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress, "uncompress", "uncompress", "-cf", "-", NULL);
+    open_transformer(archive_handle->src_fd, unpack_Z_stream, "uncompress");
     archive_handle->offset = 0;
     while (get_header_tar(archive_handle) == EXIT_SUCCESS)
-        /* nothing */;
+        continue;
 
     /* Can only do one file at a time */
@@ -658 +675 @@
 }
 #else
-#define get_header_tar_Z NULL
+# define get_header_tar_Z NULL
 #endif
 
@@ -671 +688 @@
 
     /* Wait for any child without blocking */
-    if (waitpid(-1, &status, WNOHANG) < 0)
+    if (wait_any_nohang(&status) < 0)
         /* wait failed?! I'm confused... */
         return;
 
-    if (WIFEXITED(status) && WEXITSTATUS(status)==0)
+    if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
         /* child exited with 0 */
         return;
@@ -684 +701 @@
 #endif
 
+//usage:#define tar_trivial_usage
+//usage:       "-[" IF_FEATURE_TAR_CREATE("c") "xt" IF_FEATURE_SEAMLESS_GZ("z")
+//usage:    IF_FEATURE_SEAMLESS_BZ2("j") IF_FEATURE_SEAMLESS_LZMA("a")
+//usage:    IF_FEATURE_SEAMLESS_Z("Z") IF_FEATURE_TAR_NOPRESERVE_TIME("m") "vO] "
+//usage:    IF_FEATURE_TAR_FROM("[-X FILE] ")
+//usage:       "[-f TARFILE] [-C DIR] [FILE]..."
+//usage:#define tar_full_usage "\n\n"
+//usage:    IF_FEATURE_TAR_CREATE("Create, extract, ")
+//usage:    IF_NOT_FEATURE_TAR_CREATE("Extract ")
+//usage:    "or list files from a tar file\n"
+//usage:     "\nOperation:"
+//usage:    IF_FEATURE_TAR_CREATE(
+//usage:     "\n    c   Create"
+//usage:    )
+//usage:     "\n    x   Extract"
+//usage:     "\n    t   List"
+//usage:     "\nOptions:"
+//usage:     "\n    f   Name of TARFILE ('-' for stdin/out)"
+//usage:     "\n    C   Change to DIR before operation"
+//usage:     "\n    v   Verbose"
+//usage:    IF_FEATURE_SEAMLESS_GZ(
+//usage:     "\n    z   (De)compress using gzip"
+//usage:    )
+//usage:    IF_FEATURE_SEAMLESS_BZ2(
+//usage:     "\n    j   (De)compress using bzip2"
+//usage:    )
+//usage:    IF_FEATURE_SEAMLESS_LZMA(
+//usage:     "\n    a   (De)compress using lzma"
+//usage:    )
+//usage:    IF_FEATURE_SEAMLESS_Z(
+//usage:     "\n    Z   (De)compress using compress"
+//usage:    )
+//usage:     "\n    O   Extract to stdout"
+//usage:    IF_FEATURE_TAR_CREATE(
+//usage:     "\n    h   Follow symlinks"
+//usage:    )
+//usage:    IF_FEATURE_TAR_NOPRESERVE_TIME(
+//usage:     "\n    m   Don't restore mtime"
+//usage:    )
+//usage:    IF_FEATURE_TAR_FROM(
+//usage:    IF_FEATURE_TAR_LONG_OPTIONS(
+//usage:     "\n    exclude File to exclude"
+//usage:    )
+//usage:     "\n    X   File with names to exclude"
+//usage:     "\n    T   File with names to include"
+//usage:    )
+//usage:
+//usage:#define tar_example_usage
+//usage:       "$ zcat /tmp/tarball.tar.gz | tar -xf -\n"
+//usage:       "$ tar -cf /tmp/tarball.tar /usr/local\n"
+
+// Supported but aren't in --help:
+//  o   no-same-owner
+//  p   same-permissions
+//  k   keep-old
+//  numeric-owner
+//  no-same-permissions
+//  overwrite
+//IF_FEATURE_TAR_TO_COMMAND(
+//  to-command
+//)
+
 enum {
-    OPTBIT_KEEP_OLD = 7,
-    USE_FEATURE_TAR_CREATE(  OPTBIT_CREATE      ,)
-    USE_FEATURE_TAR_CREATE(  OPTBIT_DEREFERENCE ,)
-    USE_FEATURE_TAR_BZIP2(   OPTBIT_BZIP2       ,)
-    USE_FEATURE_TAR_LZMA(    OPTBIT_LZMA        ,)
-    USE_FEATURE_TAR_FROM(    OPTBIT_INCLUDE_FROM,)
-    USE_FEATURE_TAR_FROM(    OPTBIT_EXCLUDE_FROM,)
-    USE_FEATURE_TAR_GZIP(    OPTBIT_GZIP        ,)
-    USE_FEATURE_TAR_COMPRESS(OPTBIT_COMPRESS    ,)
-    OPTBIT_NOPRESERVE_OWN,
+    OPTBIT_KEEP_OLD = 8,
+    IF_FEATURE_TAR_CREATE(   OPTBIT_CREATE      ,)
+    IF_FEATURE_TAR_CREATE(   OPTBIT_DEREFERENCE ,)
+    IF_FEATURE_SEAMLESS_BZ2( OPTBIT_BZIP2       ,)
+    IF_FEATURE_SEAMLESS_LZMA(OPTBIT_LZMA        ,)
+    IF_FEATURE_TAR_FROM(     OPTBIT_INCLUDE_FROM,)
+    IF_FEATURE_TAR_FROM(     OPTBIT_EXCLUDE_FROM,)
+    IF_FEATURE_SEAMLESS_GZ(  OPTBIT_GZIP        ,)
+    IF_FEATURE_SEAMLESS_Z(   OPTBIT_COMPRESS    ,) // 16th bit
+    IF_FEATURE_TAR_NOPRESERVE_TIME(OPTBIT_NOPRESERVE_TIME,)
+#if ENABLE_FEATURE_TAR_LONG_OPTIONS
+    IF_FEATURE_TAR_TO_COMMAND(OPTBIT_2COMMAND   ,)
+    OPTBIT_NUMERIC_OWNER,
     OPTBIT_NOPRESERVE_PERM,
+    OPTBIT_OVERWRITE,
+#endif
     OPT_TEST         = 1 << 0, // t
     OPT_EXTRACT      = 1 << 1, // x
@@ -701 +785 @@
     OPT_TARNAME      = 1 << 3, // f
     OPT_2STDOUT      = 1 << 4, // O
-    OPT_P            = 1 << 5, // p
-    OPT_VERBOSE      = 1 << 6, // v
-    OPT_KEEP_OLD     = 1 << 7, // k
-    OPT_CREATE       = USE_FEATURE_TAR_CREATE(  (1<<OPTBIT_CREATE      )) + 0, // c
-    OPT_DEREFERENCE  = USE_FEATURE_TAR_CREATE(  (1<<OPTBIT_DEREFERENCE )) + 0, // h
-    OPT_BZIP2        = USE_FEATURE_TAR_BZIP2(   (1<<OPTBIT_BZIP2       )) + 0, // j
-    OPT_LZMA         = USE_FEATURE_TAR_LZMA(    (1<<OPTBIT_LZMA        )) + 0, // a
-    OPT_INCLUDE_FROM = USE_FEATURE_TAR_FROM(    (1<<OPTBIT_INCLUDE_FROM)) + 0, // T
-    OPT_EXCLUDE_FROM = USE_FEATURE_TAR_FROM(    (1<<OPTBIT_EXCLUDE_FROM)) + 0, // X
-    OPT_GZIP         = USE_FEATURE_TAR_GZIP(    (1<<OPTBIT_GZIP        )) + 0, // z
-    OPT_COMPRESS     = USE_FEATURE_TAR_COMPRESS((1<<OPTBIT_COMPRESS    )) + 0, // Z
-    OPT_NOPRESERVE_OWN  = 1 << OPTBIT_NOPRESERVE_OWN , // no-same-owner
-    OPT_NOPRESERVE_PERM = 1 << OPTBIT_NOPRESERVE_PERM, // no-same-permissions
+    OPT_NOPRESERVE_OWNER = 1 << 5, // o == no-same-owner
+    OPT_P            = 1 << 6, // p
+    OPT_VERBOSE      = 1 << 7, // v
+    OPT_KEEP_OLD     = 1 << 8, // k
+    OPT_CREATE       = IF_FEATURE_TAR_CREATE(   (1 << OPTBIT_CREATE      )) + 0, // c
+    OPT_DEREFERENCE  = IF_FEATURE_TAR_CREATE(   (1 << OPTBIT_DEREFERENCE )) + 0, // h
+    OPT_BZIP2        = IF_FEATURE_SEAMLESS_BZ2( (1 << OPTBIT_BZIP2       )) + 0, // j
+    OPT_LZMA         = IF_FEATURE_SEAMLESS_LZMA((1 << OPTBIT_LZMA        )) + 0, // a
+    OPT_INCLUDE_FROM = IF_FEATURE_TAR_FROM(     (1 << OPTBIT_INCLUDE_FROM)) + 0, // T
+    OPT_EXCLUDE_FROM = IF_FEATURE_TAR_FROM(     (1 << OPTBIT_EXCLUDE_FROM)) + 0, // X
+    OPT_GZIP         = IF_FEATURE_SEAMLESS_GZ(  (1 << OPTBIT_GZIP        )) + 0, // z
+    OPT_COMPRESS     = IF_FEATURE_SEAMLESS_Z(   (1 << OPTBIT_COMPRESS    )) + 0, // Z
+    OPT_NOPRESERVE_TIME = IF_FEATURE_TAR_NOPRESERVE_TIME((1 << OPTBIT_NOPRESERVE_TIME)) + 0, // m
+    OPT_2COMMAND        = IF_FEATURE_TAR_TO_COMMAND(  (1 << OPTBIT_2COMMAND       )) + 0, // to-command
+    OPT_NUMERIC_OWNER   = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_NUMERIC_OWNER  )) + 0, // numeric-owner
+    OPT_NOPRESERVE_PERM = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_NOPRESERVE_PERM)) + 0, // no-same-permissions
+    OPT_OVERWRITE       = IF_FEATURE_TAR_LONG_OPTIONS((1 << OPTBIT_OVERWRITE      )) + 0, // overwrite
 };
 #if ENABLE_FEATURE_TAR_LONG_OPTIONS
@@ -722 +810 @@
     "file\0"                Required_argument "f"
     "to-stdout\0"           No_argument       "O"
+    /* do not restore owner */
+    /* Note: GNU tar handles 'o' as no-same-owner only on extract,
+     * on create, 'o' is --old-archive. We do not support --old-archive. */
+    "no-same-owner\0"       No_argument       "o"
     "same-permissions\0"    No_argument       "p"
     "verbose\0"             No_argument       "v"
@@ -729 +821 @@
     "dereference\0"         No_argument       "h"
 # endif
-# if ENABLE_FEATURE_TAR_BZIP2
+# if ENABLE_FEATURE_SEAMLESS_BZ2
     "bzip2\0"               No_argument       "j"
 # endif
-# if ENABLE_FEATURE_TAR_LZMA
+# if ENABLE_FEATURE_SEAMLESS_LZMA
     "lzma\0"                No_argument       "a"
 # endif
@@ -739 +831 @@
     "exclude-from\0"        Required_argument "X"
 # endif
-# if ENABLE_FEATURE_TAR_GZIP
+# if ENABLE_FEATURE_SEAMLESS_GZ
     "gzip\0"                No_argument       "z"
 # endif
-# if ENABLE_FEATURE_TAR_COMPRESS
+# if ENABLE_FEATURE_SEAMLESS_Z
     "compress\0"            No_argument       "Z"
 # endif
-    "no-same-owner\0"       No_argument       "\xfd"
-    "no-same-permissions\0" No_argument       "\xfe"
+# if ENABLE_FEATURE_TAR_NOPRESERVE_TIME
+    "touch\0"               No_argument       "m"
+# endif
+# if ENABLE_FEATURE_TAR_TO_COMMAND
+    "to-command\0"      Required_argument "\xfb"
+# endif
+    /* use numeric uid/gid from tar header, not textual */
+    "numeric-owner\0"       No_argument       "\xfc"
+    /* do not restore mode */
+    "no-same-permissions\0" No_argument       "\xfd"
+    /* on unpack, open with O_TRUNC and !O_EXCL */
+    "overwrite\0"           No_argument       "\xfe"
     /* --exclude takes next bit position in option mask, */
-    /* therefore we have to either put it _after_ --no-same-perm */
-    /* or add OPT[BIT]_EXCLUDE before OPT[BIT]_NOPRESERVE_OWN */
+    /* therefore we have to put it _after_ --no-same-permissions */
 # if ENABLE_FEATURE_TAR_FROM
     "exclude\0"             Required_argument "\xff"
@@ -756 +857 @@
 #endif
 
-int tar_main(int argc, char **argv);
-int tar_main(int argc, char **argv)
-{
-    char (*get_header_ptr)(archive_handle_t *) = get_header_tar;
+int tar_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int tar_main(int argc UNUSED_PARAM, char **argv)
+{
+    char FAST_FUNC (*get_header_ptr)(archive_handle_t *) = get_header_tar;
     archive_handle_t *tar_handle;
     char *base_dir = NULL;
@@ -771 +872 @@
     /* Initialise default values */
     tar_handle = init_handle();
-    tar_handle->flags = ARCHIVE_CREATE_LEADING_DIRS
-                      | ARCHIVE_PRESERVE_DATE
-                      | ARCHIVE_EXTRACT_UNCONDITIONAL;
+    tar_handle->ah_flags = ARCHIVE_CREATE_LEADING_DIRS
+                         | ARCHIVE_RESTORE_DATE
+                         | ARCHIVE_UNLINK_OLD;
+
+    /* Apparently only root's tar preserves perms (see bug 3844) */
+    if (getuid() != 0)
+        tar_handle->ah_flags |= ARCHIVE_DONT_RESTORE_PERM;
 
     /* Prepend '-' to the first argument if required */
@@ -783 +888 @@
         "\xff::" // cumulative lists for --exclude
 #endif
-        USE_FEATURE_TAR_CREATE("c:") "t:x:" // at least one of these is reqd
-        USE_FEATURE_TAR_CREATE("c--tx:t--cx:x--ct") // mutually exclusive
-        SKIP_FEATURE_TAR_CREATE("t--x:x--t"); // mutually exclusive
+        IF_FEATURE_TAR_CREATE("c:") "t:x:" // at least one of these is reqd
+        IF_FEATURE_TAR_CREATE("c--tx:t--cx:x--ct") // mutually exclusive
+        IF_NOT_FEATURE_TAR_CREATE("t--x:x--t"); // mutually exclusive
 #if ENABLE_FEATURE_TAR_LONG_OPTIONS
     applet_long_options = tar_longopts;
 #endif
+#if ENABLE_DESKTOP
+    if (argv[1] && argv[1][0] != '-') {
+        /* Compat:
+         * 1st argument without dash handles options with parameters
+         * differently from dashed one: it takes *next argv[i]*
+         * as paramenter even if there are more chars in 1st argument:
+         *  "tar fx TARFILE" - "x" is not taken as f's param
+         *  but is interpreted as -x option
+         *  "tar -xf TARFILE" - dashed equivalent of the above
+         *  "tar -fx ..." - "x" is taken as f's param
+         * getopt32 wouldn't handle 1st command correctly.
+         * Unfortunately, people do use such commands.
+         * We massage argv[1] to work around it by moving 'f'
+         * to the end of the string.
+         * More contrived "tar fCx TARFILE DIR" still fails,
+         * but such commands are much less likely to be used.
+         */
+        char *f = strchr(argv[1], 'f');
+        if (f) {
+            while (f[1] != '\0') {
+                *f = f[1];
+                f++;
+            }
+            *f = 'f';
+        }
+    }
+#endif
     opt = getopt32(argv,
-        "txC:f:Opvk"
-        USE_FEATURE_TAR_CREATE(  "ch"  )
-        USE_FEATURE_TAR_BZIP2(   "j"   )
-        USE_FEATURE_TAR_LZMA(    "a"   )
-        USE_FEATURE_TAR_FROM(    "T:X:")
-        USE_FEATURE_TAR_GZIP(    "z"   )
-        USE_FEATURE_TAR_COMPRESS("Z"   )
+        "txC:f:Oopvk"
+        IF_FEATURE_TAR_CREATE(   "ch"  )
+        IF_FEATURE_SEAMLESS_BZ2( "j"   )
+        IF_FEATURE_SEAMLESS_LZMA("a"   )
+        IF_FEATURE_TAR_FROM(     "T:X:")
+        IF_FEATURE_SEAMLESS_GZ(  "z"   )
+        IF_FEATURE_SEAMLESS_Z(   "Z"   )
+        IF_FEATURE_TAR_NOPRESERVE_TIME("m")
         , &base_dir // -C dir
         , &tar_filename // -f filename
-        USE_FEATURE_TAR_FROM(, &(tar_handle->accept)) // T
-        USE_FEATURE_TAR_FROM(, &(tar_handle->reject)) // X
+        IF_FEATURE_TAR_FROM(, &(tar_handle->accept)) // T
+        IF_FEATURE_TAR_FROM(, &(tar_handle->reject)) // X
+        IF_FEATURE_TAR_TO_COMMAND(, &(tar_handle->tar__to_command)) // --to-command
 #if ENABLE_FEATURE_TAR_LONG_OPTIONS && ENABLE_FEATURE_TAR_FROM
         , &excludes // --exclude
@@ -807 +941 @@
         , &verboseFlag // combined count for -t and -v
         );
+    //bb_error_msg("opt:%08x", opt);
+    argv += optind;
 
     if (verboseFlag) tar_handle->action_header = header_verbose_list;
@@ -817 +953 @@
         tar_handle->action_data = data_extract_to_stdout;
 
+    if (opt & OPT_2COMMAND) {
+        putenv((char*)"TAR_FILETYPE=f");
+        signal(SIGPIPE, SIG_IGN);
+        tar_handle->action_data = data_extract_to_command;
+    }
+
     if (opt & OPT_KEEP_OLD)
-        tar_handle->flags &= ~ARCHIVE_EXTRACT_UNCONDITIONAL;
-
-    if (opt & OPT_NOPRESERVE_OWN)
-        tar_handle->flags |= ARCHIVE_NOPRESERVE_OWN;
+        tar_handle->ah_flags &= ~ARCHIVE_UNLINK_OLD;
+
+    if (opt & OPT_NUMERIC_OWNER)
+        tar_handle->ah_flags |= ARCHIVE_NUMERIC_OWNER;
+
+    if (opt & OPT_NOPRESERVE_OWNER)
+        tar_handle->ah_flags |= ARCHIVE_DONT_RESTORE_OWNER;
 
     if (opt & OPT_NOPRESERVE_PERM)
-        tar_handle->flags |= ARCHIVE_NOPRESERVE_PERM;
+        tar_handle->ah_flags |= ARCHIVE_DONT_RESTORE_PERM;
+
+    if (opt & OPT_OVERWRITE) {
+        tar_handle->ah_flags &= ~ARCHIVE_UNLINK_OLD;
+        tar_handle->ah_flags |= ARCHIVE_O_TRUNC;
+    }
 
     if (opt & OPT_GZIP)
@@ -838 +988 @@
         get_header_ptr = get_header_tar_Z;
 
+    if (opt & OPT_NOPRESERVE_TIME)
+        tar_handle->ah_flags &= ~ARCHIVE_RESTORE_DATE;
+
 #if ENABLE_FEATURE_TAR_FROM
     tar_handle->reject = append_file_list_to_list(tar_handle->reject);
-#if ENABLE_FEATURE_TAR_LONG_OPTIONS
+# if ENABLE_FEATURE_TAR_LONG_OPTIONS
     /* Append excludes to reject */
     while (excludes) {
@@ -848 +1001 @@
         excludes = next;
     }
-#endif
+# endif
     tar_handle->accept = append_file_list_to_list(tar_handle->accept);
 #endif
 
-    /* Check if we are reading from stdin */
-    if (argv[optind] && *argv[optind] == '-') {
-        /* Default is to read from stdin, so just skip to next arg */
-        optind++;
-    }
-
     /* Setup an array of filenames to work with */
-    /* TODO: This is the same as in ar, separate function ? */
-    while (optind < argc) {
+    /* TODO: This is the same as in ar, make a separate function? */
+    while (*argv) {
         /* kill trailing '/' unless the string is just "/" */
-        char *cp = last_char_is(argv[optind], '/');
-        if (cp > argv[optind])
+        char *cp = last_char_is(*argv, '/');
+        if (cp > *argv)
             *cp = '\0';
-        llist_add_to_end(&tar_handle->accept, argv[optind]);
-        optind++;
+        llist_add_to_end(&tar_handle->accept, *argv);
+        argv++;
     }
 
@@ -874 +1021 @@
     /* Open the tar file */
     {
-        FILE *tar_stream;
-        int flags;
+        int tar_fd = STDIN_FILENO;
+        int flags = O_RDONLY;
 
         if (opt & OPT_CREATE) {
-            /* Make sure there is at least one file to tar up.  */
+            /* Make sure there is at least one file to tar up */
             if (tar_handle->accept == NULL)
                 bb_error_msg_and_die("empty archive");
 
-            tar_stream = stdout;
+            tar_fd = STDOUT_FILENO;
             /* Mimicking GNU tar 1.15.1: */
-            flags = O_WRONLY|O_CREAT|O_TRUNC;
-        /* was doing unlink; open(O_WRONLY|O_CREAT|O_EXCL); why? */
-        } else {
-            tar_stream = stdin;
-            flags = O_RDONLY;
+            flags = O_WRONLY | O_CREAT | O_TRUNC;
         }
 
         if (LONE_DASH(tar_filename)) {
-            tar_handle->src_fd = fileno(tar_stream);
+            tar_handle->src_fd = tar_fd;
             tar_handle->seek = seek_by_read;
         } else {
-            tar_handle->src_fd = xopen(tar_filename, flags);
+            if (ENABLE_FEATURE_TAR_AUTODETECT
+             && flags == O_RDONLY
+             && get_header_ptr == get_header_tar
+            ) {
+                tar_handle->src_fd = open_zipped(tar_filename);
+                if (tar_handle->src_fd < 0)
+                    bb_perror_msg_and_die("can't open '%s'", tar_filename);
+            } else {
+                tar_handle->src_fd = xopen(tar_filename, flags);
+            }
         }
     }
@@ -907 +1059 @@
 #endif
 
-    /* create an archive */
+    /* Create an archive */
     if (opt & OPT_CREATE) {
+#if ENABLE_FEATURE_SEAMLESS_GZ || ENABLE_FEATURE_SEAMLESS_BZ2
         int zipMode = 0;
-        if (ENABLE_FEATURE_TAR_GZIP && get_header_ptr == get_header_tar_gz)
+        if (ENABLE_FEATURE_SEAMLESS_GZ && (opt & OPT_GZIP))
             zipMode = 1;
-        if (ENABLE_FEATURE_TAR_BZIP2 && get_header_ptr == get_header_tar_bz2)
+        if (ENABLE_FEATURE_SEAMLESS_BZ2 && (opt & OPT_BZIP2))
             zipMode = 2;
+#endif
         /* NB: writeTarFile() closes tar_handle->src_fd */
         return writeTarFile(tar_handle->src_fd, verboseFlag, opt & OPT_DEREFERENCE,
@@ -921 +1075 @@
 
     while (get_header_ptr(tar_handle) == EXIT_SUCCESS)
-        /* nothing */;
+        continue;
 
     /* Check that every file that should have been extracted was */

branches/2.2.9/mindi-busybox/archival/unzip.c

@@ -8 +8 @@
  * All options and features should work in this version.
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -17 +17 @@
 
 /* TODO
- * Endian issues
  * Zip64 + other methods
- * Improve handling of zip format, ie.
- * - deferred CRC, comp. & uncomp. lengths (zip header flags bit 3)
- * - unix file permissions, etc.
- * - central directory
  */
 
 #include "libbb.h"
-#include "unarchive.h"
-
-#define ZIP_FILEHEADER_MAGIC        SWAP_LE32(0x04034b50)
-#define ZIP_CDS_MAGIC           SWAP_LE32(0x02014b50)
-#define ZIP_CDS_END_MAGIC       SWAP_LE32(0x06054b50)
-#define ZIP_DD_MAGIC            SWAP_LE32(0x08074b50)
+#include "archive.h"
+
+enum {
+#if BB_BIG_ENDIAN
+    ZIP_FILEHEADER_MAGIC = 0x504b0304,
+    ZIP_CDF_MAGIC        = 0x504b0102, /* central directory's file header */
+    ZIP_CDE_MAGIC        = 0x504b0506, /* "end of central directory" record */
+    ZIP_DD_MAGIC         = 0x504b0708,
+#else
+    ZIP_FILEHEADER_MAGIC = 0x04034b50,
+    ZIP_CDF_MAGIC        = 0x02014b50,
+    ZIP_CDE_MAGIC        = 0x06054b50,
+    ZIP_DD_MAGIC         = 0x08074b50,
+#endif
+};
+
+#define ZIP_HEADER_LEN 26
 
 typedef union {
-    unsigned char raw[26];
+    uint8_t raw[ZIP_HEADER_LEN];
     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 */
-    } formatted ATTRIBUTE_PACKED;
-} zip_header_t;
-
-static void unzip_skip(int fd, off_t skip)
+        uint16_t version;               /* 0-1 */
+        uint16_t zip_flags;             /* 2-3 */
+        uint16_t method;                /* 4-5 */
+        uint16_t modtime;               /* 6-7 */
+        uint16_t moddate;               /* 8-9 */
+        uint32_t crc32 PACKED;          /* 10-13 */
+        uint32_t cmpsize PACKED;        /* 14-17 */
+        uint32_t ucmpsize PACKED;       /* 18-21 */
+        uint16_t filename_len;          /* 22-23 */
+        uint16_t extra_len;             /* 24-25 */
+    } formatted PACKED;
+} zip_header_t; /* PACKED - gcc 4.2.1 doesn't like it (spews warning) */
+
+/* Check the offset of the last element, not the length.  This leniency
+ * allows for poor packing, whereby the overall struct may be too long,
+ * even though the elements are all in the right place.
+ */
+struct BUG_zip_header_must_be_26_bytes {
+    char BUG_zip_header_must_be_26_bytes[
+        offsetof(zip_header_t, formatted.extra_len) + 2
+            == ZIP_HEADER_LEN ? 1 : -1];
+};
+
+#define FIX_ENDIANNESS_ZIP(zip_header) do { \
+    (zip_header).formatted.version      = SWAP_LE16((zip_header).formatted.version     ); \
+    (zip_header).formatted.method       = SWAP_LE16((zip_header).formatted.method      ); \
+    (zip_header).formatted.modtime      = SWAP_LE16((zip_header).formatted.modtime     ); \
+    (zip_header).formatted.moddate      = SWAP_LE16((zip_header).formatted.moddate     ); \
+    (zip_header).formatted.crc32        = SWAP_LE32((zip_header).formatted.crc32       ); \
+    (zip_header).formatted.cmpsize      = SWAP_LE32((zip_header).formatted.cmpsize     ); \
+    (zip_header).formatted.ucmpsize     = SWAP_LE32((zip_header).formatted.ucmpsize    ); \
+    (zip_header).formatted.filename_len = SWAP_LE16((zip_header).formatted.filename_len); \
+    (zip_header).formatted.extra_len    = SWAP_LE16((zip_header).formatted.extra_len   ); \
+} while (0)
+
+#define CDF_HEADER_LEN 42
+
+typedef union {
+    uint8_t raw[CDF_HEADER_LEN];
+    struct {
+        /* uint32_t signature; 50 4b 01 02 */
+        uint16_t version_made_by;       /* 0-1 */
+        uint16_t version_needed;        /* 2-3 */
+        uint16_t cdf_flags;             /* 4-5 */
+        uint16_t method;                /* 6-7 */
+        uint16_t mtime;                 /* 8-9 */
+        uint16_t mdate;                 /* 10-11 */
+        uint32_t crc32;                 /* 12-15 */
+        uint32_t cmpsize;               /* 16-19 */
+        uint32_t ucmpsize;              /* 20-23 */
+        uint16_t file_name_length;      /* 24-25 */
+        uint16_t extra_field_length;    /* 26-27 */
+        uint16_t file_comment_length;   /* 28-29 */
+        uint16_t disk_number_start;     /* 30-31 */
+        uint16_t internal_file_attributes; /* 32-33 */
+        uint32_t external_file_attributes PACKED; /* 34-37 */
+        uint32_t relative_offset_of_local_header PACKED; /* 38-41 */
+    } formatted PACKED;
+} cdf_header_t;
+
+struct BUG_cdf_header_must_be_42_bytes {
+    char BUG_cdf_header_must_be_42_bytes[
+        offsetof(cdf_header_t, formatted.relative_offset_of_local_header) + 4
+            == CDF_HEADER_LEN ? 1 : -1];
+};
+
+#define FIX_ENDIANNESS_CDF(cdf_header) do { \
+    (cdf_header).formatted.crc32        = SWAP_LE32((cdf_header).formatted.crc32       ); \
+    (cdf_header).formatted.cmpsize      = SWAP_LE32((cdf_header).formatted.cmpsize     ); \
+    (cdf_header).formatted.ucmpsize     = SWAP_LE32((cdf_header).formatted.ucmpsize    ); \
+    (cdf_header).formatted.file_name_length = SWAP_LE16((cdf_header).formatted.file_name_length); \
+    (cdf_header).formatted.extra_field_length = SWAP_LE16((cdf_header).formatted.extra_field_length); \
+    (cdf_header).formatted.file_comment_length = SWAP_LE16((cdf_header).formatted.file_comment_length); \
+    IF_DESKTOP( \
+    (cdf_header).formatted.version_made_by = SWAP_LE16((cdf_header).formatted.version_made_by); \
+    (cdf_header).formatted.external_file_attributes = SWAP_LE32((cdf_header).formatted.external_file_attributes); \
+    ) \
+} while (0)
+
+#define CDE_HEADER_LEN 16
+
+typedef union {
+    uint8_t raw[CDE_HEADER_LEN];
+    struct {
+        /* uint32_t signature; 50 4b 05 06 */
+        uint16_t this_disk_no;
+        uint16_t disk_with_cdf_no;
+        uint16_t cdf_entries_on_this_disk;
+        uint16_t cdf_entries_total;
+        uint32_t cdf_size;
+        uint32_t cdf_offset;
+        /* uint16_t file_comment_length; */
+        /* .ZIP file comment (variable size) */
+    } formatted PACKED;
+} cde_header_t;
+
+struct BUG_cde_header_must_be_16_bytes {
+    char BUG_cde_header_must_be_16_bytes[
+        sizeof(cde_header_t) == CDE_HEADER_LEN ? 1 : -1];
+};
+
+#define FIX_ENDIANNESS_CDE(cde_header) do { \
+    (cde_header).formatted.cdf_offset = SWAP_LE32((cde_header).formatted.cdf_offset); \
+} while (0)
+
+enum { zip_fd = 3 };
+
+
+#if ENABLE_DESKTOP
+
+#define PEEK_FROM_END 16384
+
+/* NB: does not preserve file position! */
+static uint32_t find_cdf_offset(void)
 {
-    if (lseek(fd, skip, SEEK_CUR) == (off_t)-1) {
-        if (errno != ESPIPE)
-            bb_error_msg_and_die("seek failure");
-        bb_copyfd_exact_size(fd, -1, skip);
-    }
+    cde_header_t cde_header;
+    unsigned char *p;
+    off_t end;
+    unsigned char *buf = xzalloc(PEEK_FROM_END);
+
+    end = xlseek(zip_fd, 0, SEEK_END);
+    end -= PEEK_FROM_END;
+    if (end < 0)
+        end = 0;
+    xlseek(zip_fd, end, SEEK_SET);
+    full_read(zip_fd, buf, PEEK_FROM_END);
+
+    p = buf;
+    while (p <= buf + PEEK_FROM_END - CDE_HEADER_LEN - 4) {
+        if (*p != 'P') {
+            p++;
+            continue;
+        }
+        if (*++p != 'K')
+            continue;
+        if (*++p != 5)
+            continue;
+        if (*++p != 6)
+            continue;
+        /* we found CDE! */
+        memcpy(cde_header.raw, p + 1, CDE_HEADER_LEN);
+        FIX_ENDIANNESS_CDE(cde_header);
+        free(buf);
+        return cde_header.formatted.cdf_offset;
+    }
+    //free(buf);
+    bb_error_msg_and_die("can't find file table");
+};
+
+static uint32_t read_next_cdf(uint32_t cdf_offset, cdf_header_t *cdf_ptr)
+{
+    off_t org;
+
+    org = xlseek(zip_fd, 0, SEEK_CUR);
+
+    if (!cdf_offset)
+        cdf_offset = find_cdf_offset();
+
+    xlseek(zip_fd, cdf_offset + 4, SEEK_SET);
+    xread(zip_fd, cdf_ptr->raw, CDF_HEADER_LEN);
+    FIX_ENDIANNESS_CDF(*cdf_ptr);
+    cdf_offset += 4 + CDF_HEADER_LEN
+        + cdf_ptr->formatted.file_name_length
+        + cdf_ptr->formatted.extra_field_length
+        + cdf_ptr->formatted.file_comment_length;
+
+    xlseek(zip_fd, org, SEEK_SET);
+    return cdf_offset;
+};
+#endif
+
+static void unzip_skip(off_t skip)
+{
+    if (lseek(zip_fd, skip, SEEK_CUR) == (off_t)-1)
+        bb_copyfd_exact_size(zip_fd, -1, skip);
 }
 
-static void unzip_create_leading_dirs(char *fn)
+static void unzip_create_leading_dirs(const char *fn)
 {
     /* Create all leading directories */
@@ -68 +229 @@
 }
 
-static int unzip_extract(zip_header_t *zip_header, int src_fd, int dst_fd)
+static void unzip_extract(zip_header_t *zip_header, int dst_fd)
 {
     if (zip_header->formatted.method == 0) {
@@ -74 +235 @@
         off_t size = zip_header->formatted.ucmpsize;
         if (size)
-            bb_copyfd_exact_size(src_fd, dst_fd, size);
+            bb_copyfd_exact_size(zip_fd, dst_fd, size);
     } else {
         /* Method 8 - inflate */
         inflate_unzip_result res;
-        /* err = */ inflate_unzip(&res, zip_header->formatted.cmpsize, src_fd, dst_fd);
-// we should check for -1 error return
+        if (inflate_unzip(&res, zip_header->formatted.cmpsize, zip_fd, dst_fd) < 0)
+            bb_error_msg_and_die("inflate error");
         /* Validate decompression - crc */
         if (zip_header->formatted.crc32 != (res.crc ^ 0xffffffffL)) {
-            bb_error_msg("invalid compressed data--%s error", "crc");
-            return 1;
+            bb_error_msg_and_die("crc error");
         }
         /* Validate decompression - size */
         if (zip_header->formatted.ucmpsize != res.bytes_out) {
-            bb_error_msg("invalid compressed data--%s error", "length");
-            return 1;
-        }
-    }
-    return 0;
+            /* Don't die. Who knows, maybe len calculation
+             * was botched somewhere. After all, crc matched! */
+            bb_error_msg("bad length");
+        }
+    }
 }
 
-int unzip_main(int argc, char **argv);
+int unzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int unzip_main(int argc, char **argv)
 {
+    enum { O_PROMPT, O_NEVER, O_ALWAYS };
+
     zip_header_t zip_header;
-    enum {v_silent, v_normal, v_list} verbosity = v_normal;
-    enum {o_prompt, o_never, o_always} overwrite = o_prompt;
-    unsigned int total_size = 0;
-    unsigned int total_entries = 0;
-    int src_fd = -1, dst_fd = -1;
-    char *src_fn = NULL, *dst_fn = NULL;
+    smallint quiet = 0;
+    IF_NOT_DESKTOP(const) smallint verbose = 0;
+    smallint listing = 0;
+    smallint overwrite = O_PROMPT;
+#if ENABLE_DESKTOP
+    uint32_t cdf_offset;
+#endif
+    unsigned long total_usize;
+    unsigned long total_size;
+    unsigned total_entries;
+    int dst_fd = -1;
+    char *src_fn = NULL;
+    char *dst_fn = NULL;
     llist_t *zaccept = NULL;
     llist_t *zreject = NULL;
     char *base_dir = NULL;
-    int failed, i, opt, opt_range = 0, list_header_done = 0;
-    char key_buf[512];
+    int i, opt;
+    int opt_range = 0;
+    char key_buf[80];
     struct stat stat_buf;
 
-    while ((opt = getopt(argc, argv, "-d:lnopqx")) != -1) {
+/* -q, -l and -v: UnZip 5.52 of 28 February 2005, by Info-ZIP:
+ *
+ * # /usr/bin/unzip -qq -v decompress_unlzma.i.zip
+ *   204372  Defl:N    35278  83%  09-06-09 14:23  0d056252  decompress_unlzma.i
+ * # /usr/bin/unzip -q -v decompress_unlzma.i.zip
+ *  Length   Method    Size  Ratio   Date   Time   CRC-32    Name
+ * --------  ------  ------- -----   ----   ----   ------    ----
+ *   204372  Defl:N    35278  83%  09-06-09 14:23  0d056252  decompress_unlzma.i
+ * --------          -------  ---                            -------
+ *   204372            35278  83%                            1 file
+ * # /usr/bin/unzip -v decompress_unlzma.i.zip
+ * Archive:  decompress_unlzma.i.zip
+ *  Length   Method    Size  Ratio   Date   Time   CRC-32    Name
+ * --------  ------  ------- -----   ----   ----   ------    ----
+ *   204372  Defl:N    35278  83%  09-06-09 14:23  0d056252  decompress_unlzma.i
+ * --------          -------  ---                            -------
+ *   204372            35278  83%                            1 file
+ * # unzip -v decompress_unlzma.i.zip
+ * Archive:  decompress_unlzma.i.zip
+ *   Length     Date   Time    Name
+ *  --------    ----   ----    ----
+ *    204372  09-06-09 14:23   decompress_unlzma.i
+ *  --------                   -------
+ *    204372                   1 files
+ * # /usr/bin/unzip -l -qq decompress_unlzma.i.zip
+ *    204372  09-06-09 14:23   decompress_unlzma.i
+ * # /usr/bin/unzip -l -q decompress_unlzma.i.zip
+ *   Length     Date   Time    Name
+ *  --------    ----   ----    ----
+ *    204372  09-06-09 14:23   decompress_unlzma.i
+ *  --------                   -------
+ *    204372                   1 file
+ * # /usr/bin/unzip -l decompress_unlzma.i.zip
+ * Archive:  decompress_unlzma.i.zip
+ *   Length     Date   Time    Name
+ *  --------    ----   ----    ----
+ *    204372  09-06-09 14:23   decompress_unlzma.i
+ *  --------                   -------
+ *    204372                   1 file
+ */
+
+    /* '-' makes getopt return 1 for non-options */
+    while ((opt = getopt(argc, argv, "-d:lnopqxv")) != -1) {
         switch (opt_range) {
         case 0: /* Options */
             switch (opt) {
             case 'l': /* List */
-                verbosity = v_list;
+                listing = 1;
                 break;
 
             case 'n': /* Never overwrite existing files */
-                overwrite = o_never;
+                overwrite = O_NEVER;
                 break;
 
             case 'o': /* Always overwrite existing files */
-                overwrite = o_always;
+                overwrite = O_ALWAYS;
                 break;
 
@@ -131 +343 @@
 
             case 'q': /* Be quiet */
-                verbosity = (verbosity == v_normal) ? v_silent : verbosity;
-                break;
-
-            case 1 : /* The zip file */
-                src_fn = xmalloc(strlen(optarg)+4);
+                quiet++;
+                break;
+
+            case 'v': /* Verbose list */
+                IF_DESKTOP(verbose++;)
+                listing = 1;
+                break;
+
+            case 1: /* The zip file */
+                /* +5: space for ".zip" and NUL */
+                src_fn = xmalloc(strlen(optarg) + 5);
                 strcpy(src_fn, optarg);
                 opt_range++;
@@ -142 +360 @@
             default:
                 bb_show_usage();
-
             }
             break;
@@ -149 +366 @@
             if (opt == 1) {
                 llist_add_to(&zaccept, optarg);
-
-            } else if (opt == 'd') {
+                break;
+            }
+            if (opt == 'd') {
                 base_dir = optarg;
                 opt_range += 2;
-
-            } else if (opt == 'x') {
+                break;
+            }
+            if (opt == 'x') {
                 opt_range++;
-
-            } else {
-                bb_show_usage();
-            }
-            break;
+                break;
+            }
+            bb_show_usage();
 
         case 2 : /* Exclude files */
             if (opt == 1) {
                 llist_add_to(&zreject, optarg);
-
-            } else if (opt == 'd') { /* Extract to base directory */
+                break;
+            }
+            if (opt == 'd') { /* Extract to base directory */
                 base_dir = optarg;
                 opt_range++;
-
-            } else {
-                bb_show_usage();
-            }
-            break;
+                break;
+            }
+            /* fall through */
 
         default:
@@ -186 +402 @@
     /* Open input file */
     if (LONE_DASH(src_fn)) {
-        src_fd = STDIN_FILENO;
+        xdup2(STDIN_FILENO, zip_fd);
         /* Cannot use prompt mode since zip data is arriving on STDIN */
-        overwrite = (overwrite == o_prompt) ? o_never : overwrite;
+        if (overwrite == O_PROMPT)
+            overwrite = O_NEVER;
     } else {
-        static const char *const extn[] = {"", ".zip", ".ZIP"};
+        static const char extn[][5] = {"", ".zip", ".ZIP"};
         int orig_src_fn_len = strlen(src_fn);
+        int src_fd = -1;
+
         for (i = 0; (i < 3) && (src_fd == -1); i++) {
             strcpy(src_fn + orig_src_fn_len, extn[i]);
@@ -198 +417 @@
         if (src_fd == -1) {
             src_fn[orig_src_fn_len] = '\0';
-            bb_error_msg_and_die("cannot open %s, %s.zip, %s.ZIP", src_fn, src_fn, src_fn);
-        }
+            bb_error_msg_and_die("can't open %s, %s.zip, %s.ZIP", src_fn, src_fn, src_fn);
+        }
+        xmove_fd(src_fd, zip_fd);
     }
 
@@ -206 +426 @@
         xchdir(base_dir);
 
-    if (verbosity != v_silent)
-        printf("Archive:  %s\n", src_fn);
-
-    failed = 0;
-
+    if (quiet <= 1) { /* not -qq */
+        if (quiet == 0)
+            printf("Archive:  %s\n", src_fn);
+        if (listing) {
+            puts(verbose ?
+                " Length   Method    Size  Ratio   Date   Time   CRC-32    Name\n"
+                "--------  ------  ------- -----   ----   ----   ------    ----"
+                :
+                "  Length     Date   Time    Name\n"
+                " --------    ----   ----    ----"
+                );
+        }
+    }
+
+/* Example of an archive with one 0-byte long file named 'z'
+ * created by Zip 2.31 on Unix:
+ * 0000 [50 4b]03 04 0a 00 00 00 00 00 42 1a b8 3c 00 00 |PK........B..<..|
+ *       sig........ vneed flags compr mtime mdate crc32>
+ * 0010  00 00 00 00 00 00 00 00 00 00 01 00 15 00 7a 55 |..............zU|
+ *      >..... csize...... usize...... fnlen exlen fn ex>
+ * 0020  54 09 00 03 cc d3 f9 4b cc d3 f9 4b 55 78 04 00 |T......K...KUx..|
+ *      >tra_field......................................
+ * 0030  00 00 00 00[50 4b]01 02 17 03 0a 00 00 00 00 00 |....PK..........|
+ *       ........... sig........ vmade vneed flags compr
+ * 0040  42 1a b8 3c 00 00 00 00 00 00 00 00 00 00 00 00 |B..<............|
+ *       mtime mdate crc32...... csize...... usize......
+ * 0050  01 00 0d 00 00 00 00 00 00 00 00 00 a4 81 00 00 |................|
+ *       fnlen exlen clen. dnum. iattr eattr...... relofs> (eattr = rw-r--r--)
+ * 0060  00 00 7a 55 54 05 00 03 cc d3 f9 4b 55 78 00 00 |..zUT......KUx..|
+ *      >..... fn extra_field...........................
+ * 0070 [50 4b]05 06 00 00 00 00 01 00 01 00 3c 00 00 00 |PK..........<...|
+ * 0080  34 00 00 00 00 00                               |4.....|
+ */
+    total_usize = 0;
+    total_size = 0;
+    total_entries = 0;
+#if ENABLE_DESKTOP
+    cdf_offset = 0;
+#endif
     while (1) {
-        unsigned int magic;
+        uint32_t magic;
+        mode_t dir_mode = 0777;
+#if ENABLE_DESKTOP
+        mode_t file_mode = 0666;
+#endif
 
         /* Check magic number */
-        xread(src_fd, &magic, 4);
-        if (magic == ZIP_CDS_MAGIC) {
+        xread(zip_fd, &magic, 4);
+        /* Central directory? It's at the end, so exit */
+        if (magic == ZIP_CDF_MAGIC)
             break;
-        } else if (magic != ZIP_FILEHEADER_MAGIC) {
-            bb_error_msg_and_die("invalid zip magic %08X", magic);
-        }
+#if ENABLE_DESKTOP
+        /* Data descriptor? It was a streaming file, go on */
+        if (magic == ZIP_DD_MAGIC) {
+            /* skip over duplicate crc32, cmpsize and ucmpsize */
+            unzip_skip(3 * 4);
+            continue;
+        }
+#endif
+        if (magic != ZIP_FILEHEADER_MAGIC)
+            bb_error_msg_and_die("invalid zip magic %08X", (int)magic);
 
         /* Read the file header */
-        xread(src_fd, zip_header.raw, 26);
-        zip_header.formatted.version = SWAP_LE32(zip_header.formatted.version);
-        zip_header.formatted.flags = SWAP_LE32(zip_header.formatted.flags);
-        zip_header.formatted.method = SWAP_LE32(zip_header.formatted.method);
-        zip_header.formatted.modtime = SWAP_LE32(zip_header.formatted.modtime);
-        zip_header.formatted.moddate = SWAP_LE32(zip_header.formatted.moddate);
-        zip_header.formatted.crc32 = SWAP_LE32(zip_header.formatted.crc32);
-        zip_header.formatted.cmpsize = SWAP_LE32(zip_header.formatted.cmpsize);
-        zip_header.formatted.ucmpsize = SWAP_LE32(zip_header.formatted.ucmpsize);
-        zip_header.formatted.filename_len = SWAP_LE32(zip_header.formatted.filename_len);
-        zip_header.formatted.extra_len = SWAP_LE32(zip_header.formatted.extra_len);
+        xread(zip_fd, zip_header.raw, ZIP_HEADER_LEN);
+        FIX_ENDIANNESS_ZIP(zip_header);
         if ((zip_header.formatted.method != 0) && (zip_header.formatted.method != 8)) {
-            bb_error_msg_and_die("unsupported compression method %d", zip_header.formatted.method);
-        }
+            bb_error_msg_and_die("unsupported method %d", zip_header.formatted.method);
+        }
+#if !ENABLE_DESKTOP
+        if (zip_header.formatted.zip_flags & SWAP_LE16(0x0009)) {
+            bb_error_msg_and_die("zip flags 1 and 8 are not supported");
+        }
+#else
+        if (zip_header.formatted.zip_flags & SWAP_LE16(0x0001)) {
+            /* 0x0001 - encrypted */
+            bb_error_msg_and_die("zip flag 1 (encryption) is not supported");
+        }
+
+        {
+            cdf_header_t cdf_header;
+            cdf_offset = read_next_cdf(cdf_offset, &cdf_header);
+            if (zip_header.formatted.zip_flags & SWAP_LE16(0x0008)) {
+                /* 0x0008 - streaming. [u]cmpsize can be reliably gotten
+                 * only from Central Directory. See unzip_doc.txt */
+                zip_header.formatted.crc32    = cdf_header.formatted.crc32;
+                zip_header.formatted.cmpsize  = cdf_header.formatted.cmpsize;
+                zip_header.formatted.ucmpsize = cdf_header.formatted.ucmpsize;
+            }
+            if ((cdf_header.formatted.version_made_by >> 8) == 3) {
+                /* this archive is created on Unix */
+                dir_mode = file_mode = (cdf_header.formatted.external_file_attributes >> 16);
+            }
+        }
+#endif
 
         /* Read filename */
         free(dst_fn);
         dst_fn = xzalloc(zip_header.formatted.filename_len + 1);
-        xread(src_fd, dst_fn, zip_header.formatted.filename_len);
+        xread(zip_fd, dst_fn, zip_header.formatted.filename_len);
 
         /* Skip extra header bytes */
-        unzip_skip(src_fd, zip_header.formatted.extra_len);
-
-        if ((verbosity == v_list) && !list_header_done){
-            puts("  Length     Date   Time    Name\n"
-                 " --------    ----   ----    ----");
-            list_header_done = 1;
-        }
+        unzip_skip(zip_header.formatted.extra_len);
 
         /* Filter zip entries */
-        if (find_list_entry(zreject, dst_fn) ||
-            (zaccept && !find_list_entry(zaccept, dst_fn))) { /* Skip entry */
+        if (find_list_entry(zreject, dst_fn)
+         || (zaccept && !find_list_entry(zaccept, dst_fn))
+        ) { /* Skip entry */
             i = 'n';
 
         } else { /* Extract entry */
-            total_size += zip_header.formatted.ucmpsize;
-
-            if (verbosity == v_list) { /* List entry */
-                unsigned int dostime = zip_header.formatted.modtime | (zip_header.formatted.moddate << 16);
-                printf("%9u  %02u-%02u-%02u %02u:%02u   %s\n",
-                       zip_header.formatted.ucmpsize,
-                       (dostime & 0x01e00000) >> 21,
-                       (dostime & 0x001f0000) >> 16,
-                       (((dostime & 0xfe000000) >> 25) + 1980) % 100,
-                       (dostime & 0x0000f800) >> 11,
-                       (dostime & 0x000007e0) >> 5,
-                       dst_fn);
-                total_entries++;
+            if (listing) { /* List entry */
+                unsigned dostime = zip_header.formatted.modtime | (zip_header.formatted.moddate << 16);
+                if (!verbose) {
+                    //      "  Length     Date   Time    Name\n"
+                    //      " --------    ----   ----    ----"
+                    printf(       "%9u  %02u-%02u-%02u %02u:%02u   %s\n",
+                        (unsigned)zip_header.formatted.ucmpsize,
+                        (dostime & 0x01e00000) >> 21,
+                        (dostime & 0x001f0000) >> 16,
+                        (((dostime & 0xfe000000) >> 25) + 1980) % 100,
+                        (dostime & 0x0000f800) >> 11,
+                        (dostime & 0x000007e0) >> 5,
+                        dst_fn);
+                    total_usize += zip_header.formatted.ucmpsize;
+                } else {
+                    unsigned long percents = zip_header.formatted.ucmpsize - zip_header.formatted.cmpsize;
+                    percents = percents * 100;
+                    if (zip_header.formatted.ucmpsize)
+                        percents /= zip_header.formatted.ucmpsize;
+                    //      " Length   Method    Size  Ratio   Date   Time   CRC-32    Name\n"
+                    //      "--------  ------  ------- -----   ----   ----   ------    ----"
+                    printf(      "%8u  Defl:N"    "%9u%4u%%  %02u-%02u-%02u %02u:%02u  %08x  %s\n",
+                        (unsigned)zip_header.formatted.ucmpsize,
+                        (unsigned)zip_header.formatted.cmpsize,
+                        (unsigned)percents,
+                        (dostime & 0x01e00000) >> 21,
+                        (dostime & 0x001f0000) >> 16,
+                        (((dostime & 0xfe000000) >> 25) + 1980) % 100,
+                        (dostime & 0x0000f800) >> 11,
+                        (dostime & 0x000007e0) >> 5,
+                        zip_header.formatted.crc32,
+                        dst_fn);
+                    total_usize += zip_header.formatted.ucmpsize;
+                    total_size += zip_header.formatted.cmpsize;
+                }
                 i = 'n';
             } else if (dst_fd == STDOUT_FILENO) { /* Extracting to STDOUT */
@@ -277 +577 @@
                 if (stat(dst_fn, &stat_buf) == -1) {
                     if (errno != ENOENT) {
-                        bb_perror_msg_and_die("cannot stat '%s'",dst_fn);
+                        bb_perror_msg_and_die("can't stat '%s'", dst_fn);
                     }
-                    if (verbosity == v_normal) {
+                    if (!quiet) {
                         printf("   creating: %s\n", dst_fn);
                     }
                     unzip_create_leading_dirs(dst_fn);
-                    if (bb_make_directory(dst_fn, 0777, 0)) {
+                    if (bb_make_directory(dst_fn, dir_mode, 0)) {
                         bb_error_msg_and_die("exiting");
                     }
@@ -294 +594 @@
 
             } else {  /* Extract file */
- _check_file:
+ check_file:
                 if (stat(dst_fn, &stat_buf) == -1) { /* File does not exist */
                     if (errno != ENOENT) {
-                        bb_perror_msg_and_die("cannot stat '%s'",dst_fn);
+                        bb_perror_msg_and_die("can't stat '%s'", dst_fn);
                     }
                     i = 'y';
                 } else { /* File already exists */
-                    if (overwrite == o_never) {
+                    if (overwrite == O_NEVER) {
                         i = 'n';
                     } else if (S_ISREG(stat_buf.st_mode)) { /* File is regular file */
-                        if (overwrite == o_always) {
+                        if (overwrite == O_ALWAYS) {
                             i = 'y';
                         } else {
                             printf("replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ", dst_fn);
-                            if (!fgets(key_buf, 512, stdin)) {
-                                bb_perror_msg_and_die("cannot read input");
+                            if (!fgets(key_buf, sizeof(key_buf), stdin)) {
+                                bb_perror_msg_and_die("can't read input");
                             }
                             i = key_buf[0];
                         }
                     } else { /* File is not regular file */
-                        bb_error_msg_and_die("'%s' exists but is not regular file",dst_fn);
+                        bb_error_msg_and_die("'%s' exists but is not regular file", dst_fn);
                     }
                 }
@@ -322 +622 @@
         switch (i) {
         case 'A':
-            overwrite = o_always;
+            overwrite = O_ALWAYS;
         case 'y': /* Open file and fall into unzip */
             unzip_create_leading_dirs(dst_fn);
+#if ENABLE_DESKTOP
+            dst_fd = xopen3(dst_fn, O_WRONLY | O_CREAT | O_TRUNC, file_mode);
+#else
             dst_fd = xopen(dst_fn, O_WRONLY | O_CREAT | O_TRUNC);
+#endif
         case -1: /* Unzip */
-            if (verbosity == v_normal) {
+            if (!quiet) {
                 printf("  inflating: %s\n", dst_fn);
             }
-            if (unzip_extract(&zip_header, src_fd, dst_fd)) {
-                failed = 1;
-            }
+            unzip_extract(&zip_header, dst_fd);
             if (dst_fd != STDOUT_FILENO) {
                 /* closing STDOUT is potentially bad for future business */
@@ -340 +642 @@
 
         case 'N':
-            overwrite = o_never;
+            overwrite = O_NEVER;
         case 'n':
             /* Skip entry data */
-            unzip_skip(src_fd, zip_header.formatted.cmpsize);
+            unzip_skip(zip_header.formatted.cmpsize);
             break;
 
@@ -349 +651 @@
             /* Prompt for new name */
             printf("new name: ");
-            if (!fgets(key_buf, 512, stdin)) {
-                bb_perror_msg_and_die("cannot read input");
+            if (!fgets(key_buf, sizeof(key_buf), stdin)) {
+                bb_perror_msg_and_die("can't read input");
             }
             free(dst_fn);
             dst_fn = xstrdup(key_buf);
             chomp(dst_fn);
-            goto _check_file;
+            goto check_file;
 
         default:
-            printf("error: invalid response [%c]\n",(char)i);
-            goto _check_file;
-        }
-
-        /* Data descriptor section */
-        if (zip_header.formatted.flags & 4) {
-            /* skip over duplicate crc, compressed size and uncompressed size */
-            unzip_skip(src_fd, 12);
-        }
-    }
-
-    if (verbosity == v_list) {
-        printf(" --------                   -------\n"
-               "%9d                   %d files\n", total_size, total_entries);
-    }
-
-    return failed;
+            printf("error: invalid response [%c]\n", (char)i);
+            goto check_file;
+        }
+
+        total_entries++;
+    }
+
+    if (listing && quiet <= 1) {
+        if (!verbose) {
+            //      "  Length     Date   Time    Name\n"
+            //      " --------    ----   ----    ----"
+            printf( " --------                   -------\n"
+                "%9lu"   "                   %u files\n",
+                total_usize, total_entries);
+        } else {
+            unsigned long percents = total_usize - total_size;
+            percents = percents * 100;
+            if (total_usize)
+                percents /= total_usize;
+            //      " Length   Method    Size  Ratio   Date   Time   CRC-32    Name\n"
+            //      "--------  ------  ------- -----   ----   ----   ------    ----"
+            printf( "--------          -------  ---                            -------\n"
+                "%8lu"              "%17lu%4u%%                            %u files\n",
+                total_usize, total_size, (unsigned)percents,
+                total_entries);
+        }
+    }
+
+    return 0;
 }