5 files changed, 143 insertions, 193 deletions

diff --git a/archival/cpio.c b/archival/cpio.c
index 858e59b30..e0ca7fa5c 100644
--- a/archival/cpio.c
+++ b/archival/cpio.c
@@ -311,6 +311,7 @@ int cpio_main(int argc UNUSED_PARAM, char **argv)
         /* no parameters */
         opt_complementary = "=0";
         opt = getopt32(argv, OPTION_STR, &cpio_filename);
+        argv += optind;
         if (opt & CPIO_OPT_FILE) { /* -F */
                 xmove_fd(xopen(cpio_filename, O_RDONLY), STDIN_FILENO);
         }
@@ -424,7 +425,7 @@ int cpio_main(int argc UNUSED_PARAM, char **argv)
         if (archive_handle->cpio__blocks != (off_t)-1
          && !(opt & CPIO_OPT_QUIET)
         ) {
-                printf("%"OFF_FMT"u blocks\n", archive_handle->cpio__blocks);
+                fprintf(stderr, "%"OFF_FMT"u blocks\n", archive_handle->cpio__blocks);
         }
 
         return EXIT_SUCCESS;
diff --git a/archival/libunarchive/get_header_tar.c b/archival/libunarchive/get_header_tar.c
index adb4c157b..fcddcb834 100644
--- a/archival/libunarchive/get_header_tar.c
+++ b/archival/libunarchive/get_header_tar.c
@@ -18,87 +18,45 @@ typedef uint32_t aliased_uint32_t FIX_ALIASING;
 typedef off_t    aliased_off_t    FIX_ALIASING;
 
 
-/*
- * GNU tar uses "base-256 encoding" for very large numbers (>8 billion).
- * Encoding is binary, with highest bit always set as a marker
- * and sign in next-highest bit:
- * 80 00 .. 00 - zero
- * bf ff .. ff - largest positive number
- * ff ff .. ff - minus 1
- * c0 00 .. 00 - smallest negative number
- *
- * We expect it only in size field, where negative numbers don't make sense.
- */
-static off_t getBase256_len12(const char *str)
-{
-        off_t value;
-        int len;
-
-        /* if (*str & 0x40) error; - caller prevents this */
-
-        if (sizeof(off_t) >= 12) {
-                /* Probably 128-bit (16 byte) off_t. Can be optimized. */
-                len = 12;
-                value = *str++ & 0x3f;
-                while (--len)
-                        value = (value << 8) + (unsigned char) *str++;
-                return value;
-        }
-
-#ifdef CHECK_FOR_OVERFLOW
-        /* Can be optimized to eat 32-bit chunks */
-        char c = *str++ & 0x3f;
-        len = 12;
-        while (1) {
-                if (c)
-                        bb_error_msg_and_die("overflow in base-256 encoded file size");
-                if (--len == sizeof(off_t))
-                        break;
-                c = *str++;
-        }
-#else
-        str += (12 - sizeof(off_t));
-#endif
-
-/* Now str points to sizeof(off_t) least significant bytes.
- *
- * Example of tar file with 8914993153 (0x213600001) byte file.
- * Field starts at offset 7c:
- * 00070  30 30 30 00 30 30 30 30  30 30 30 00 80 00 00 00  |000.0000000.....|
- * 00080  00 00 00 02 13 60 00 01  31 31 31 32 30 33 33 36  |.....`..11120336|
- *
- * str is at offset 80 or 84 now (64-bit or 32-bit off_t).
- * We (ab)use the fact that value happens to be aligned,
- * and fetch it in one go:
- */
-        if (sizeof(off_t) == 8) {
-                value = *(aliased_off_t*)str;
-                value = SWAP_BE64(value);
-        } else if (sizeof(off_t) == 4) {
-                value = *(aliased_off_t*)str;
-                value = SWAP_BE32(value);
-        } else {
-                value = 0;
-                len = sizeof(off_t);
-                while (--len)
-                        value = (value << 8) + (unsigned char) *str++;
-        }
-        return value;
-}
-
 /* NB: _DESTROYS_ str[len] character! */
 static unsigned long long getOctal(char *str, int len)
 {
         unsigned long long v;
+        char *end;
         /* NB: leading spaces are allowed. Using strtoull to handle that.
          * The downside is that we accept e.g. "-123" too :(
          */
         str[len] = '\0';
-        v = strtoull(str, &str, 8);
+        v = strtoull(str, &end, 8);
         /* std: "Each numeric field is terminated by one or more
          * <space> or NUL characters". We must support ' '! */
-        if (*str != '\0' && *str != ' ')
-                bb_error_msg_and_die("corrupted octal value in tar header");
+        if (*end != '\0' && *end != ' ') {
+                int8_t first = str[0];
+                if (!(first & 0x80))
+                        bb_error_msg_and_die("corrupted octal value in tar header");
+                /*
+                 * GNU tar uses "base-256 encoding" for very large numbers.
+                 * Encoding is binary, with highest bit always set as a marker
+                 * and sign in next-highest bit:
+                 * 80 00 .. 00 - zero
+                 * bf ff .. ff - largest positive number
+                 * ff ff .. ff - minus 1
+                 * c0 00 .. 00 - smallest negative number
+                 *
+                 * Example of tar file with 8914993153 (0x213600001) byte file.
+                 * Field starts at offset 7c:
+                 * 00070  30 30 30 00 30 30 30 30  30 30 30 00 80 00 00 00  |000.0000000.....|
+                 * 00080  00 00 00 02 13 60 00 01  31 31 31 32 30 33 33 36  |.....`..11120336|
+                 *
+                 * NB: tarballs with NEGATIVE unix times encoded that way were seen!
+                 */
+                v = first;
+                /* Sign-extend using 6th bit: */
+                v <<= sizeof(unsigned long long)*8 - 7;
+                v = (long long)v >> (sizeof(unsigned long long)*8 - 7);
+                while (--len != 0)
+                        v = (v << 8) + (unsigned char) *str++;
+        }
         return v;
 }
 #define GET_OCTAL(a) getOctal((a), sizeof(a))
@@ -358,15 +316,8 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
         file_header->tar__uname = tar.uname[0] ? xstrndup(tar.uname, sizeof(tar.uname)) : NULL;
         file_header->tar__gname = tar.gname[0] ? xstrndup(tar.gname, sizeof(tar.gname)) : NULL;
 #endif
-        /* mtime: rudimentally handle GNU tar's "base256 encoding"
-         * People report tarballs with NEGATIVE unix times encoded that way */
-        file_header->mtime = (tar.mtime[0] & 0x80) /* base256? */
-                        ? 0 /* bogus */
-                        : GET_OCTAL(tar.mtime);
-        /* size: handle GNU tar's "base256 encoding" */
-        file_header->size = (tar.size[0] & 0xc0) == 0x80 /* positive base256? */
-                        ? getBase256_len12(tar.size)
-                        : GET_OCTAL(tar.size);
+        file_header->mtime = GET_OCTAL(tar.mtime);
+        file_header->size = GET_OCTAL(tar.size);
         file_header->gid = GET_OCTAL(tar.gid);
         file_header->uid = GET_OCTAL(tar.uid);
         /* Set bits 0-11 of the files mode */
diff --git a/archival/rpm.c b/archival/rpm.c
index 6c1e341cd..38ec20ef5 100644
--- a/archival/rpm.c
+++ b/archival/rpm.c
@@ -9,8 +9,8 @@
 
 #include "libbb.h"
 #include "unarchive.h"
+#include "rpm.h"
 
-#define RPM_HEADER_MAGIC        "\216\255\350"
 #define RPM_CHAR_TYPE           1
 #define RPM_INT8_TYPE           2
 #define RPM_INT16_TYPE          3
@@ -46,6 +46,7 @@
 #define TAG_DIRINDEXES          1116
 #define TAG_BASENAMES           1117
 #define TAG_DIRNAMES            1118
+
 #define RPMFILE_CONFIG          (1 << 0)
 #define RPMFILE_DOC             (1 << 1)
 
@@ -70,7 +71,7 @@ static void *map;
 static rpm_index **mytags;
 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);
 static char *rpm_getstr(int tag, int itemindex);
@@ -121,6 +122,8 @@ int rpm_main(int argc, char **argv)
         }
 
         while (*argv) {
+                const char *source_rpm;
+
                 rpm_fd = xopen(*argv++, O_RDONLY);
                 mytags = rpm_gettags(rpm_fd, &tagcount);
                 if (!mytags)
@@ -129,11 +132,13 @@ int rpm_main(int argc, char **argv)
                 /* Mimimum is one page */
                 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);
                 }
@@ -147,14 +152,20 @@ int rpm_main(int argc, char **argv)
                                 time_t bdate_time;
                                 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_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));
                                 printf("Summary     : %s\n", rpm_getstr(TAG_SUMMARY, 0));
@@ -187,23 +198,23 @@ int rpm_main(int argc, char **argv)
         return 0;
 }
 
-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
-        IF_DESKTOP(long long) int FAST_FUNC (*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;
+#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 -
@@ -213,46 +224,14 @@ static void extract_cpio_gz(int fd)
         archive_handle->src_fd = fd;
         /*archive_handle->offset = 0; - init_handle() did it */
 
-// TODO: open_zipped does the same
-
-        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_SEAMLESS_BZ2
-                 || magic[0] != 'B' || magic[1] != 'Z'
-                ) {
-                        bb_error_msg_and_die("no gzip"
-                                IF_FEATURE_SEAMLESS_BZ2("/bzip2")
-                                " magic");
-                }
-#if BB_MMU
-                xformer = unpack_bz2_stream;
-#else
-                xformer_prog = "bunzip2";
-#endif
-        } else {
-#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 */
-        open_transformer(archive_handle->src_fd, xformer, xformer_prog);
-        archive_handle->offset = 0;
+        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 */
+        /* We should never need more than 200 (shrink via realloc later) */
         rpm_index **tags = xzalloc(200 * sizeof(tags[0]));
         int pass, tagindex = 0;
 
@@ -260,27 +239,16 @@ static rpm_index **rpm_gettags(int fd, int *num_tags)
 
         /* 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 BUG_header {
-                        char BUG_header[sizeof(header) == 16 ? 1 : -1];
-                };
+                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(*tmpindex));
@@ -292,14 +260,16 @@ static rpm_index **rpm_gettags(int fd, int *num_tags)
                         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);
+                        xlseek(fd, (-storepos) & 0x7, SEEK_CUR);
         }
-        tags = xrealloc(tags, tagindex * sizeof(tags[0])); /* realloc tags to save space */
+        /* 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;
 }
 
 static int bsearch_rpmtag(const void *key, const void *item)
@@ -324,10 +294,13 @@ static char *rpm_getstr(int tag, int itemindex)
         found = bsearch(&tag, mytags, tagcount, sizeof(struct rpmtag *), bsearch_rpmtag);
         if (!found || itemindex >= found[0]->count)
                 return NULL;
-        if (found[0]->type == RPM_STRING_TYPE || found[0]->type == RPM_I18NSTRING_TYPE || found[0]->type == RPM_STRING_ARRAY_TYPE) {
+        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++)
+                for (n = 0; n < itemindex; n++)
                         tmpstr = tmpstr + strlen(tmpstr) + 1;
                 return tmpstr;
         }
diff --git a/archival/rpm.h b/archival/rpm.h
new file mode 100644
index 000000000..f7c6fc2fa
--- /dev/null
+++ b/archival/rpm.h
@@ -0,0 +1,38 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * RPM structs and consts
+ *
+ * Copyright (C) 2001 by Laurence Anderson
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+/* RPM file starts with this struct: */
+struct rpm_lead {
+        uint32_t magic;
+        uint8_t  major, minor;
+        uint16_t type;
+        uint16_t archnum;
+        char     name[66];
+        uint16_t osnum;
+        uint16_t signature_type;
+        char     reserved[16];
+};
+struct BUG_rpm_lead {
+        char bug[sizeof(struct rpm_lead) == 96 ? 1 : -1];
+};
+#define RPM_LEAD_MAGIC      0xedabeedb
+#define RPM_LEAD_MAGIC_STR  "\355\253\356\333"
+
+/* Then follows the header: */
+struct rpm_header {
+        uint32_t magic_and_ver; /* 3 byte magic: 0x8e 0xad 0xe8; 1 byte version: 0x01 */
+        uint32_t reserved;      /* 4 bytes reserved */
+        uint32_t entries;       /* Number of entries in header (4 bytes) */
+        uint32_t size;          /* Size of store (4 bytes) */
+};
+struct BUG_rpm_header {
+        char bug[sizeof(struct rpm_header) == 16 ? 1 : -1];
+};
+#define RPM_HEADER_MAGICnVER  0x8eade801
+#define RPM_HEADER_MAGIC_STR  "\216\255\350"
diff --git a/archival/rpm2cpio.c b/archival/rpm2cpio.c
index 5403aee02..4ed5b023b 100644
--- a/archival/rpm2cpio.c
+++ b/archival/rpm2cpio.c
@@ -8,30 +8,7 @@
  */
 #include "libbb.h"
 #include "unarchive.h"
-
-#define RPM_MAGIC            0xedabeedb
-#define RPM_MAGIC_STR        "\355\253\356\333"
-
-struct rpm_lead {
-        uint32_t magic;
-        uint8_t major, minor;
-        uint16_t type;
-        uint16_t archnum;
-        char name[66];
-        uint16_t osnum;
-        uint16_t signature_type;
-        char reserved[16];
-};
-
-#define RPM_HEADER_MAGICnVER 0x8eade801
-#define RPM_HEADER_MAGIC_STR "\216\255\350"
-
-struct rpm_header {
-        uint32_t magic_and_ver; /* 3 byte magic: 0x8e 0xad 0xe8; 1 byte version */
-        uint32_t reserved; /* 4 bytes reserved */
-        uint32_t entries; /* Number of entries in header (4 bytes) */
-        uint32_t size; /* Size of store (4 bytes) */
-};
+#include "rpm.h"
 
 enum { rpm_fd = STDIN_FILENO };
 
@@ -65,8 +42,6 @@ int rpm2cpio_main(int argc UNUSED_PARAM, char **argv)
 {
         struct rpm_lead lead;
         unsigned pos;
-        unsigned char magic[2];
-        IF_DESKTOP(long long) int FAST_FUNC (*unpack)(int src_fd, int dst_fd);
 
         if (argv[1]) {
                 xmove_fd(xopen(argv[1], O_RDONLY), rpm_fd);
@@ -74,33 +49,45 @@ int rpm2cpio_main(int argc UNUSED_PARAM, char **argv)
         xread(rpm_fd, &lead, sizeof(lead));
 
         /* Just check the magic, the rest is irrelevant */
-        if (lead.magic != htonl(RPM_MAGIC)) {
+        if (lead.magic != htonl(RPM_LEAD_MAGIC)) {
                 bb_error_msg_and_die("invalid RPM magic");
         }
 
         /* Skip the signature header, align to 8 bytes */
         pos = skip_header();
-        seek_by_jump(rpm_fd, (8 - pos) & 7);
+        seek_by_jump(rpm_fd, (-(int)pos) & 7);
 
         /* Skip the main header */
         skip_header();
 
-        xread(rpm_fd, &magic, 2);
-        unpack = unpack_gz_stream;
-        if (magic[0] != 0x1f || magic[1] != 0x8b) {
-                if (!ENABLE_FEATURE_SEAMLESS_BZ2
-                 || magic[0] != 'B' || magic[1] != 'Z'
-                ) {
-                        bb_error_msg_and_die("invalid gzip"
-                                        IF_FEATURE_SEAMLESS_BZ2("/bzip2")
-                                        " 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 */
+        {
+                unsigned char magic[2];
+                IF_DESKTOP(long long) int FAST_FUNC (*unpack)(int src_fd, int dst_fd);
+
+                xread(rpm_fd, &magic, 2);
+                unpack = unpack_gz_stream;
+                if (magic[0] != 0x1f || magic[1] != 0x8b) {
+                        if (!ENABLE_FEATURE_SEAMLESS_BZ2
+                         || magic[0] != 'B' || magic[1] != 'Z'
+                        ) {
+                                bb_error_msg_and_die("invalid gzip"
+                                                IF_FEATURE_SEAMLESS_BZ2("/bzip2")
+                                                " magic");
+                        }
+                        unpack = unpack_bz2_stream;
                 }
-                unpack = unpack_bz2_stream;
-        }
 
-        if (unpack(rpm_fd, STDOUT_FILENO) < 0) {
-                bb_error_msg_and_die("error unpacking");
+                if (unpack(rpm_fd, STDOUT_FILENO) < 0)
+                        bb_error_msg_and_die("error unpacking");
         }
+#endif
 
         if (ENABLE_FEATURE_CLEAN_UP) {
                 close(rpm_fd);