Merge branch 'busybox' into merge

Conflicts:
	Makefile.flags

13 files changed, 309 insertions, 158 deletions

diff --git a/archival/libarchive/Kbuild.src b/archival/libarchive/Kbuild.src
index b0bc4e5aa..39c18f264 100644
--- a/archival/libarchive/Kbuild.src
+++ b/archival/libarchive/Kbuild.src
@@ -28,10 +28,13 @@ COMMON_FILES:= \
         init_handle.o
 
 DPKG_FILES:= \
-        get_header_ar.o \
         unpack_ar_archive.o \
+        filter_accept_list_reassign.o \
+        get_header_ar.o \
         get_header_tar.o \
-        filter_accept_list_reassign.o
+        get_header_tar_gz.o \
+        get_header_tar_bz2.o \
+        get_header_tar_lzma.o \
 
 INSERT
 
@@ -42,18 +45,18 @@ lib-$(CONFIG_UNXZ)                      += decompress_unxz.o
 lib-$(CONFIG_CPIO)                      += get_header_cpio.o
 lib-$(CONFIG_DPKG)                      += $(DPKG_FILES)
 lib-$(CONFIG_DPKG_DEB)                  += $(DPKG_FILES)
-lib-$(CONFIG_GUNZIP)                    += decompress_unzip.o
-lib-$(CONFIG_RPM2CPIO)                  += decompress_unzip.o get_header_cpio.o
-lib-$(CONFIG_RPM)                       += open_transformer.o decompress_unzip.o get_header_cpio.o
+lib-$(CONFIG_GUNZIP)                    += decompress_gunzip.o
+lib-$(CONFIG_RPM2CPIO)                  += decompress_gunzip.o get_header_cpio.o
+lib-$(CONFIG_RPM)                       += open_transformer.o decompress_gunzip.o get_header_cpio.o
 lib-$(CONFIG_TAR)                       += get_header_tar.o
 lib-$(CONFIG_UNCOMPRESS)                += decompress_uncompress.o
-lib-$(CONFIG_UNZIP)                     += decompress_unzip.o
+lib-$(CONFIG_UNZIP)                     += decompress_gunzip.o
 lib-$(CONFIG_LZOP)                      += lzo1x_1.o lzo1x_1o.o lzo1x_d.o
 lib-$(CONFIG_LZOP_COMPR_HIGH)           += lzo1x_9x.o
 lib-$(CONFIG_FEATURE_SEAMLESS_Z)        += open_transformer.o decompress_uncompress.o
-lib-$(CONFIG_FEATURE_SEAMLESS_GZ)       += open_transformer.o decompress_unzip.o get_header_tar_gz.o
-lib-$(CONFIG_FEATURE_SEAMLESS_BZ2)      += open_transformer.o decompress_bunzip2.o get_header_tar_bz2.o
-lib-$(CONFIG_FEATURE_SEAMLESS_LZMA)     += open_transformer.o decompress_unlzma.o get_header_tar_lzma.o
+lib-$(CONFIG_FEATURE_SEAMLESS_GZ)       += open_transformer.o decompress_gunzip.o
+lib-$(CONFIG_FEATURE_SEAMLESS_BZ2)      += open_transformer.o decompress_bunzip2.o
+lib-$(CONFIG_FEATURE_SEAMLESS_LZMA)     += open_transformer.o decompress_unlzma.o
 lib-$(CONFIG_FEATURE_SEAMLESS_XZ)       += open_transformer.o decompress_unxz.o
 lib-$(CONFIG_FEATURE_COMPRESS_USAGE)    += decompress_bunzip2.o
 lib-$(CONFIG_FEATURE_COMPRESS_BBCONFIG) += decompress_bunzip2.o
diff --git a/archival/libarchive/data_extract_all.c b/archival/libarchive/data_extract_all.c
index f565e5471..3f67b835f 100644
--- a/archival/libarchive/data_extract_all.c
+++ b/archival/libarchive/data_extract_all.c
@@ -13,13 +13,13 @@ void FAST_FUNC data_extract_all(archive_handle_t *archive_handle)
         int res;
 
 #if ENABLE_FEATURE_TAR_SELINUX
-        char *sctx = archive_handle->tar__next_file_sctx;
+        char *sctx = archive_handle->tar__sctx[PAX_NEXT_FILE];
         if (!sctx)
-                sctx = archive_handle->tar__global_sctx;
+                sctx = archive_handle->tar__sctx[PAX_GLOBAL];
         if (sctx) { /* setfscreatecon is 4 syscalls, avoid if possible */
                 setfscreatecon(sctx);
-                free(archive_handle->tar__next_file_sctx);
-                archive_handle->tar__next_file_sctx = NULL;
+                free(archive_handle->tar__sctx[PAX_NEXT_FILE]);
+                archive_handle->tar__sctx[PAX_NEXT_FILE] = NULL;
         }
 #endif
 
diff --git a/archival/libarchive/data_extract_to_command.c b/archival/libarchive/data_extract_to_command.c
index cc2ff7798..a2ce33b51 100644
--- a/archival/libarchive/data_extract_to_command.c
+++ b/archival/libarchive/data_extract_to_command.c
@@ -64,13 +64,13 @@ void FAST_FUNC data_extract_to_command(archive_handle_t *archive_handle)
         file_header_t *file_header = archive_handle->file_header;
 
 #if 0 /* do we need this? ENABLE_FEATURE_TAR_SELINUX */
-        char *sctx = archive_handle->tar__next_file_sctx;
+        char *sctx = archive_handle->tar__sctx[PAX_NEXT_FILE];
         if (!sctx)
-                sctx = archive_handle->tar__global_sctx;
+                sctx = archive_handle->tar__sctx[PAX_GLOBAL];
         if (sctx) { /* setfscreatecon is 4 syscalls, avoid if possible */
                 setfscreatecon(sctx);
-                free(archive_handle->tar__next_file_sctx);
-                archive_handle->tar__next_file_sctx = NULL;
+                free(archive_handle->tar__sctx[PAX_NEXT_FILE]);
+                archive_handle->tar__sctx[PAX_NEXT_FILE] = NULL;
         }
 #endif
 
diff --git a/archival/libarchive/decompress_bunzip2.c b/archival/libarchive/decompress_bunzip2.c
index c4640d489..dc252bb82 100644
--- a/archival/libarchive/decompress_bunzip2.c
+++ b/archival/libarchive/decompress_bunzip2.c
@@ -721,7 +721,7 @@ void FAST_FUNC dealloc_bunzip(bunzip_data *bd)
 
 /* Decompress src_fd to dst_fd.  Stops at end of bzip data, not end of file. */
 IF_DESKTOP(long long) int FAST_FUNC
-unpack_bz2_stream(int src_fd, int dst_fd)
+unpack_bz2_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
 {
         IF_DESKTOP(long long total_written = 0;)
         bunzip_data *bd;
@@ -729,6 +729,9 @@ unpack_bz2_stream(int src_fd, int dst_fd)
         int i;
         unsigned len;
 
+        if (check_signature16(aux, src_fd, BZIP2_MAGIC))
+                return -1;
+
         outbuf = xmalloc(IOBUF_SIZE);
         len = 0;
         while (1) { /* "Process one BZ... stream" loop */
@@ -794,17 +797,6 @@ unpack_bz2_stream(int src_fd, int dst_fd)
         return i ? i : IF_DESKTOP(total_written) + 0;
 }
 
-IF_DESKTOP(long long) int FAST_FUNC
-unpack_bz2_stream_prime(int src_fd, int dst_fd)
-{
-        uint16_t magic2;
-        xread(src_fd, &magic2, 2);
-        if (magic2 != BZIP2_MAGIC) {
-                bb_error_msg_and_die("invalid magic");
-        }
-        return unpack_bz2_stream(src_fd, dst_fd);
-}
-
 #ifdef TESTING
 
 static char *const bunzip_errors[] = {
@@ -819,7 +811,7 @@ int main(int argc, char **argv)
         int i;
         char c;
 
-        int i = unpack_bz2_stream_prime(0, 1);
+        int i = unpack_bz2_stream(0, 1);
         if (i < 0)
                 fprintf(stderr, "%s\n", bunzip_errors[-i]);
         else if (read(STDIN_FILENO, &c, 1))
diff --git a/archival/libarchive/decompress_unzip.c b/archival/libarchive/decompress_gunzip.c
index aa5d22d0a..2d5ab3eb3 100644
--- a/archival/libarchive/decompress_unzip.c
+++ b/archival/libarchive/decompress_gunzip.c
@@ -1034,22 +1034,22 @@ inflate_unzip_internal(STATE_PARAM int in, int out)
 /* For unzip */
 
 IF_DESKTOP(long long) int FAST_FUNC
-inflate_unzip(inflate_unzip_result *res, off_t compr_size, int in, int out)
+inflate_unzip(transformer_aux_data_t *aux, int in, int out)
 {
         IF_DESKTOP(long long) int n;
         DECLARE_STATE;
 
         ALLOC_STATE;
 
-        to_read = compr_size;
+        to_read = aux->bytes_in;
 //      bytebuffer_max = 0x8000;
         bytebuffer_offset = 4;
         bytebuffer = xmalloc(bytebuffer_max);
         n = inflate_unzip_internal(PASS_STATE in, out);
         free(bytebuffer);
 
-        res->crc = gunzip_crc;
-        res->bytes_out = gunzip_bytes_out;
+        aux->crc32 = gunzip_crc;
+        aux->bytes_out = gunzip_bytes_out;
         DEALLOC_STATE;
         return n;
 }
@@ -1107,7 +1107,7 @@ static uint32_t buffer_read_le_u32(STATE_PARAM_ONLY)
         return res;
 }
 
-static int check_header_gzip(STATE_PARAM unpack_info_t *info)
+static int check_header_gzip(STATE_PARAM transformer_aux_data_t *aux)
 {
         union {
                 unsigned char raw[8];
@@ -1169,8 +1169,8 @@ static int check_header_gzip(STATE_PARAM unpack_info_t *info)
                 }
         }
 
-        if (info)
-                info->mtime = SWAP_LE32(header.formatted.mtime);
+        if (aux)
+                aux->mtime = SWAP_LE32(header.formatted.mtime);
 
         /* Read the header checksum */
         if (header.formatted.flags & 0x02) {
@@ -1182,33 +1182,58 @@ static int check_header_gzip(STATE_PARAM unpack_info_t *info)
 }
 
 IF_DESKTOP(long long) int FAST_FUNC
-unpack_gz_stream_with_info(int in, int out, unpack_info_t *info)
+unpack_gz_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
 {
         uint32_t v32;
-        IF_DESKTOP(long long) int n;
+        IF_DESKTOP(long long) int total, n;
         DECLARE_STATE;
 
-        n = 0;
+#if !ENABLE_FEATURE_SEAMLESS_Z
+        if (check_signature16(aux, src_fd, GZIP_MAGIC))
+                return -1;
+#else
+        if (aux && aux->check_signature) {
+                uint16_t magic2;
+
+                if (full_read(src_fd, &magic2, 2) != 2) {
+ bad_magic:
+                        bb_error_msg("invalid magic");
+                        return -1;
+                }
+                if (magic2 == COMPRESS_MAGIC) {
+                        aux->check_signature = 0;
+                        return unpack_Z_stream(aux, src_fd, dst_fd);
+                }
+                if (magic2 != GZIP_MAGIC)
+                        goto bad_magic;
+        }
+#endif
+
+        total = 0;
 
         ALLOC_STATE;
         to_read = -1;
 //      bytebuffer_max = 0x8000;
         bytebuffer = xmalloc(bytebuffer_max);
-        gunzip_src_fd = in;
+        gunzip_src_fd = src_fd;
 
  again:
-        if (!check_header_gzip(PASS_STATE info)) {
+        if (!check_header_gzip(PASS_STATE aux)) {
                 bb_error_msg("corrupted data");
-                n = -1;
+                total = -1;
                 goto ret;
         }
-        n += inflate_unzip_internal(PASS_STATE in, out);
-        if (n < 0)
+
+        n = inflate_unzip_internal(PASS_STATE src_fd, dst_fd);
+        if (n < 0) {
+                total = -1;
                 goto ret;
+        }
+        total += n;
 
         if (!top_up(PASS_STATE 8)) {
                 bb_error_msg("corrupted data");
-                n = -1;
+                total = -1;
                 goto ret;
         }
 
@@ -1216,7 +1241,7 @@ unpack_gz_stream_with_info(int in, int out, unpack_info_t *info)
         v32 = buffer_read_le_u32(PASS_STATE_ONLY);
         if ((~gunzip_crc) != v32) {
                 bb_error_msg("crc error");
-                n = -1;
+                total = -1;
                 goto ret;
         }
 
@@ -1224,7 +1249,7 @@ unpack_gz_stream_with_info(int in, int out, unpack_info_t *info)
         v32 = buffer_read_le_u32(PASS_STATE_ONLY);
         if ((uint32_t)gunzip_bytes_out != v32) {
                 bb_error_msg("incorrect length");
-                n = -1;
+                total = -1;
         }
 
         if (!top_up(PASS_STATE 2))
@@ -1242,11 +1267,5 @@ unpack_gz_stream_with_info(int in, int out, unpack_info_t *info)
  ret:
         free(bytebuffer);
         DEALLOC_STATE;
-        return n;
-}
-
-IF_DESKTOP(long long) int FAST_FUNC
-unpack_gz_stream(int in, int out)
-{
-        return unpack_gz_stream_with_info(in, out, NULL);
+        return total;
 }
diff --git a/archival/libarchive/decompress_uncompress.c b/archival/libarchive/decompress_uncompress.c
index c6040d04b..e9bbfb9bd 100644
--- a/archival/libarchive/decompress_uncompress.c
+++ b/archival/libarchive/decompress_uncompress.c
@@ -73,7 +73,7 @@
  */
 
 IF_DESKTOP(long long) int FAST_FUNC
-unpack_Z_stream(int fd_in, int fd_out)
+unpack_Z_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
 {
         IF_DESKTOP(long long total_written = 0;)
         IF_DESKTOP(long long) int retval = -1;
@@ -103,16 +103,19 @@ unpack_Z_stream(int fd_in, int fd_out)
         /* block compress mode -C compatible with 2.0 */
         int block_mode; /* = BLOCK_MODE; */
 
+        if (check_signature16(aux, src_fd, COMPRESS_MAGIC))
+                return -1;
+
         inbuf = xzalloc(IBUFSIZ + 64);
         outbuf = xzalloc(OBUFSIZ + 2048);
-        htab = xzalloc(HSIZE);  /* wsn't zeroed out before, maybe can xmalloc? */
+        htab = xzalloc(HSIZE);  /* wasn't zeroed out before, maybe can xmalloc? */
         codetab = xzalloc(HSIZE * sizeof(codetab[0]));
 
         insize = 0;
 
         /* xread isn't good here, we have to return - caller may want
          * to do some cleanup (e.g. delete incomplete unpacked file etc) */
-        if (full_read(fd_in, inbuf, 1) != 1) {
+        if (full_read(src_fd, inbuf, 1) != 1) {
                 bb_error_msg("short read");
                 goto err;
         }
@@ -162,7 +165,7 @@ unpack_Z_stream(int fd_in, int fd_out)
                 }
 
                 if (insize < (int) (IBUFSIZ + 64) - IBUFSIZ) {
-                        rsize = safe_read(fd_in, inbuf + insize, IBUFSIZ);
+                        rsize = safe_read(src_fd, inbuf + insize, IBUFSIZ);
                         if (rsize < 0)
                                 bb_error_msg_and_die(bb_msg_read_error);
                         insize += rsize;
@@ -268,7 +271,7 @@ unpack_Z_stream(int fd_in, int fd_out)
                                                 }
 
                                                 if (outpos >= OBUFSIZ) {
-                                                        xwrite(fd_out, outbuf, outpos);
+                                                        xwrite(dst_fd, outbuf, outpos);
                                                         IF_DESKTOP(total_written += outpos;)
                                                         outpos = 0;
                                                 }
@@ -296,7 +299,7 @@ unpack_Z_stream(int fd_in, int fd_out)
         } while (rsize > 0);
 
         if (outpos > 0) {
-                xwrite(fd_out, outbuf, outpos);
+                xwrite(dst_fd, outbuf, outpos);
                 IF_DESKTOP(total_written += outpos;)
         }
 
diff --git a/archival/libarchive/decompress_unlzma.c b/archival/libarchive/decompress_unlzma.c
index 3631b50cc..cfde8ea56 100644
--- a/archival/libarchive/decompress_unlzma.c
+++ b/archival/libarchive/decompress_unlzma.c
@@ -213,7 +213,7 @@ enum {
 
 
 IF_DESKTOP(long long) int FAST_FUNC
-unpack_lzma_stream(int src_fd, int dst_fd)
+unpack_lzma_stream(transformer_aux_data_t *aux UNUSED_PARAM, int src_fd, int dst_fd)
 {
         IF_DESKTOP(long long total_written = 0;)
         lzma_header_t header;
diff --git a/archival/libarchive/decompress_unxz.c b/archival/libarchive/decompress_unxz.c
index 3e5d4edca..79b48a152 100644
--- a/archival/libarchive/decompress_unxz.c
+++ b/archival/libarchive/decompress_unxz.c
@@ -38,7 +38,7 @@ static uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc)
 #include "unxz/xz_dec_stream.c"
 
 IF_DESKTOP(long long) int FAST_FUNC
-unpack_xz_stream(int src_fd, int dst_fd)
+unpack_xz_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
 {
         struct xz_buf iobuf;
         struct xz_dec *state;
@@ -49,13 +49,17 @@ unpack_xz_stream(int src_fd, int dst_fd)
                 global_crc32_table = crc32_filltable(NULL, /*endian:*/ 0);
 
         memset(&iobuf, 0, sizeof(iobuf));
-        /* Preload XZ file signature */
-        membuf = (void*) strcpy(xmalloc(2 * BUFSIZ), HEADER_MAGIC);
+        membuf = xmalloc(2 * BUFSIZ);
         iobuf.in = membuf;
-        iobuf.in_size = HEADER_MAGIC_SIZE;
         iobuf.out = membuf + BUFSIZ;
         iobuf.out_size = BUFSIZ;
 
+        if (!aux || aux->check_signature == 0) {
+                /* Preload XZ file signature */
+                strcpy((char*)membuf, HEADER_MAGIC);
+                iobuf.in_size = HEADER_MAGIC_SIZE;
+        } /* else: let xz code read & check it */
+
         /* Limit memory usage to about 64 MiB. */
         state = xz_dec_init(XZ_DYNALLOC, 64*1024*1024);
 
diff --git a/archival/libarchive/get_header_tar.c b/archival/libarchive/get_header_tar.c
index a63c0fb01..80a709144 100644
--- a/archival/libarchive/get_header_tar.c
+++ b/archival/libarchive/get_header_tar.c
@@ -90,23 +90,20 @@ static unsigned long long getOctal(char *str, int len)
 }
 #define GET_OCTAL(a) getOctal((a), sizeof(a))
 
-#if ENABLE_FEATURE_TAR_SELINUX
-/* Scan a PAX header for SELinux contexts, via "RHT.security.selinux" keyword.
- * This is what Red Hat's patched version of tar uses.
- */
-# define SELINUX_CONTEXT_KEYWORD "RHT.security.selinux"
-static char *get_selinux_sctx_from_pax_hdr(archive_handle_t *archive_handle, unsigned sz)
+/* "global" is 0 or 1 */
+static void process_pax_hdr(archive_handle_t *archive_handle, unsigned sz, int global)
 {
         char *buf, *p;
-        char *result;
+        unsigned blk_sz;
+
+        blk_sz = (sz + 511) & (~511);
+        p = buf = xmalloc(blk_sz + 1);
+        xread(archive_handle->src_fd, buf, blk_sz);
+        archive_handle->offset += blk_sz;
 
-        p = buf = xmalloc(sz + 1);
         /* prevent bb_strtou from running off the buffer */
         buf[sz] = '\0';
-        xread(archive_handle->src_fd, buf, sz);
-        archive_handle->offset += sz;
 
-        result = NULL;
         while (sz != 0) {
                 char *end, *value;
                 unsigned len;
@@ -133,19 +130,33 @@ static char *get_selinux_sctx_from_pax_hdr(archive_handle_t *archive_handle, uns
                  * (we do not bother to check that it *was* a newline)
                  */
                 p[-1] = '\0';
-                /* Is it selinux security context? */
                 value = end + 1;
+
+#if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
+                if (!global && strncmp(value, "path=", sizeof("path=") - 1) == 0) {
+                        value += sizeof("path=") - 1;
+                        free(archive_handle->tar__longname);
+                        archive_handle->tar__longname = xstrdup(value);
+                        continue;
+                }
+#endif
+
+#if ENABLE_FEATURE_TAR_SELINUX
+                /* Scan for SELinux contexts, via "RHT.security.selinux" keyword.
+                 * This is what Red Hat's patched version of tar uses.
+                 */
+# define SELINUX_CONTEXT_KEYWORD "RHT.security.selinux"
                 if (strncmp(value, SELINUX_CONTEXT_KEYWORD"=", sizeof(SELINUX_CONTEXT_KEYWORD"=") - 1) == 0) {
                         value += sizeof(SELINUX_CONTEXT_KEYWORD"=") - 1;
-                        result = xstrdup(value);
-                        break;
+                        free(archive_handle->tar__sctx[global]);
+                        archive_handle->tar__sctx[global] = xstrdup(value);
+                        continue;
                 }
+#endif
         }
 
         free(buf);
-        return result;
 }
-#endif
 
 char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
 {
@@ -224,43 +235,18 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
              || memcmp(tar.magic, "\0\0\0\0", 5) != 0)
         ) {
 #if ENABLE_FEATURE_TAR_AUTODETECT
-                char FAST_FUNC (*get_header_ptr)(archive_handle_t *);
-                uint16_t magic2;
-
  autodetect:
-                magic2 = *(bb__aliased_uint16_t*)tar.name;
-                /* tar gz/bz autodetect: check for gz/bz2 magic.
-                 * If we see the magic, and it is the very first block,
-                 * we can switch to get_header_tar_gz/bz2/lzma().
-                 * Needs seekable fd. I wish recv(MSG_PEEK) works
-                 * on any fd... */
-# if ENABLE_FEATURE_SEAMLESS_GZ
-                if (magic2 == GZIP_MAGIC) {
-                        get_header_ptr = get_header_tar_gz;
-                } else
-# endif
-# if ENABLE_FEATURE_SEAMLESS_BZ2
-                if (magic2 == BZIP2_MAGIC
-                 && tar.name[2] == 'h' && isdigit(tar.name[3])
-                ) { /* bzip2 */
-                        get_header_ptr = get_header_tar_bz2;
-                } else
-# endif
-# if ENABLE_FEATURE_SEAMLESS_XZ
-                //TODO: if (magic2 == XZ_MAGIC1)...
-                //else
-# endif
-                        goto err;
                 /* Two different causes for lseek() != 0:
                  * unseekable fd (would like to support that too, but...),
                  * or not first block (false positive, it's not .gz/.bz2!) */
                 if (lseek(archive_handle->src_fd, -i, SEEK_CUR) != 0)
                         goto err;
-                while (get_header_ptr(archive_handle) == EXIT_SUCCESS)
-                        continue;
-                return EXIT_FAILURE;
+                if (setup_unzip_on_fd(archive_handle->src_fd, /*fail_if_not_detected:*/ 0) != 0)
  err:
-#endif /* FEATURE_TAR_AUTODETECT */
+                        bb_error_msg_and_die("invalid tar magic");
+                archive_handle->offset = 0;
+                goto again_after_align;
+#endif
                 bb_error_msg_and_die("invalid tar magic");
         }
 
@@ -418,12 +404,14 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
         case 'S':       /* Sparse file */
         case 'V':       /* Volume header */
 #endif
-#if !ENABLE_FEATURE_TAR_SELINUX
         case 'g':       /* pax global header */
-        case 'x':       /* pax extended header */
-#else
+        case 'x': {     /* pax extended header */
+                if ((uoff_t)file_header->size > 0xfffff) /* paranoia */
+                        goto skip_ext_hdr;
+                process_pax_hdr(archive_handle, file_header->size, (tar.typeflag == 'g'));
+                goto again_after_align;
+        }
  skip_ext_hdr:
-#endif
         {
                 off_t sz;
                 bb_error_msg("warning: skipping header '%c'", tar.typeflag);
@@ -435,18 +423,6 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
                 /* return get_header_tar(archive_handle); */
                 goto again_after_align;
         }
-#if ENABLE_FEATURE_TAR_SELINUX
-        case 'g':       /* pax global header */
-        case 'x': {     /* pax extended header */
-                char **pp;
-                if ((uoff_t)file_header->size > 0xfffff) /* paranoia */
-                        goto skip_ext_hdr;
-                pp = (tar.typeflag == 'g') ? &archive_handle->tar__global_sctx : &archive_handle->tar__next_file_sctx;
-                free(*pp);
-                *pp = get_selinux_sctx_from_pax_hdr(archive_handle, file_header->size);
-                goto again;
-        }
-#endif
         default:
                 bb_error_msg_and_die("unknown typeflag: 0x%x", tar.typeflag);
         }
diff --git a/archival/libarchive/get_header_tar_bz2.c b/archival/libarchive/get_header_tar_bz2.c
index e012dec3b..0ee00df53 100644
--- a/archival/libarchive/get_header_tar_bz2.c
+++ b/archival/libarchive/get_header_tar_bz2.c
@@ -11,7 +11,7 @@ char FAST_FUNC get_header_tar_bz2(archive_handle_t *archive_handle)
         /* Can't lseek over pipes */
         archive_handle->seek = seek_by_read;
 
-        open_transformer(archive_handle->src_fd, unpack_bz2_stream_prime, "bunzip2");
+        open_transformer_with_sig(archive_handle->src_fd, unpack_bz2_stream, "bunzip2");
         archive_handle->offset = 0;
         while (get_header_tar(archive_handle) == EXIT_SUCCESS)
                 continue;
diff --git a/archival/libarchive/get_header_tar_gz.c b/archival/libarchive/get_header_tar_gz.c
index b9679b0bd..03284342b 100644
--- a/archival/libarchive/get_header_tar_gz.c
+++ b/archival/libarchive/get_header_tar_gz.c
@@ -8,25 +8,10 @@
 
 char FAST_FUNC get_header_tar_gz(archive_handle_t *archive_handle)
 {
-#if BB_MMU
-        uint16_t magic;
-#endif
-
         /* Can't lseek over pipes */
         archive_handle->seek = seek_by_read;
 
-        /* Check gzip magic only if open_transformer will invoke unpack_gz_stream (MMU case).
-         * Otherwise, it will invoke an external helper "gunzip -cf" (NOMMU case) which will
-         * need the header. */
-#if BB_MMU
-        xread(archive_handle->src_fd, &magic, 2);
-        /* Can skip this check, but error message will be less clear */
-        if (magic != GZIP_MAGIC) {
-                bb_error_msg_and_die("invalid gzip magic");
-        }
-#endif
-
-        open_transformer(archive_handle->src_fd, unpack_gz_stream, "gunzip");
+        open_transformer_with_sig(archive_handle->src_fd, unpack_gz_stream, "gunzip");
         archive_handle->offset = 0;
         while (get_header_tar(archive_handle) == EXIT_SUCCESS)
                 continue;
diff --git a/archival/libarchive/get_header_tar_lzma.c b/archival/libarchive/get_header_tar_lzma.c
index 666700729..d565a217d 100644
--- a/archival/libarchive/get_header_tar_lzma.c
+++ b/archival/libarchive/get_header_tar_lzma.c
@@ -14,7 +14,7 @@ char FAST_FUNC get_header_tar_lzma(archive_handle_t *archive_handle)
         /* Can't lseek over pipes */
         archive_handle->seek = seek_by_read;
 
-        open_transformer(archive_handle->src_fd, unpack_lzma_stream, "unlzma");
+        open_transformer_with_sig(archive_handle->src_fd, unpack_lzma_stream, "unlzma");
         archive_handle->offset = 0;
         while (get_header_tar(archive_handle) == EXIT_SUCCESS)
                 continue;
diff --git a/archival/libarchive/open_transformer.c b/archival/libarchive/open_transformer.c
index aa8c1021c..f2edc2a2b 100644
--- a/archival/libarchive/open_transformer.c
+++ b/archival/libarchive/open_transformer.c
@@ -6,14 +6,64 @@
 #include "libbb.h"
 #include "bb_archive.h"
 
+void FAST_FUNC init_transformer_aux_data(transformer_aux_data_t *aux)
+{
+        memset(aux, 0, sizeof(*aux));
+}
+
+int FAST_FUNC check_signature16(transformer_aux_data_t *aux, int src_fd, unsigned magic16)
+{
+        if (aux && aux->check_signature) {
+                uint16_t magic2;
+                if (full_read(src_fd, &magic2, 2) != 2 || magic2 != magic16) {
+                        bb_error_msg("invalid magic");
+#if 0 /* possible future extension */
+                        if (aux->check_signature > 1)
+                                xfunc_die();
+#endif
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+#if !ENABLE_PLATFORM_MINGW32
+void check_errors_in_children(int signo)
+{
+        int status;
+
+        if (!signo) {
+                /* block waiting for any child */
+                if (wait(&status) < 0)
+                        return; /* probably there are no children */
+                goto check_status;
+        }
+
+        /* Wait for any child without blocking */
+        for (;;) {
+                if (wait_any_nohang(&status) < 0)
+                        /* wait failed?! I'm confused... */
+                        return;
+ check_status:
+                if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
+                        /* this child exited with 0 */
+                        continue;
+                /* Cannot happen?
+                if (!WIFSIGNALED(status) && !WIFEXITED(status)) ???; */
+                bb_got_signal = 1;
+        }
+}
+#endif
+
 /* transformer(), more than meets the eye */
-/*
- * On MMU machine, the transform_prog is removed by macro magic
- * in include/archive.h. On NOMMU, transformer is removed.
- */
+#if BB_MMU
 void FAST_FUNC open_transformer(int fd,
-        IF_DESKTOP(long long) int FAST_FUNC (*transformer)(int src_fd, int dst_fd),
-        const char *transform_prog)
+        int check_signature,
+        IF_DESKTOP(long long) int FAST_FUNC (*transformer)(transformer_aux_data_t *aux, int src_fd, int dst_fd)
+)
+#else
+void FAST_FUNC open_transformer(int fd, const char *transform_prog)
+#endif
 {
         struct fd_pair fd_pipe;
         int pid;
@@ -25,13 +75,18 @@ void FAST_FUNC open_transformer(int fd,
                 close(fd_pipe.rd); /* we don't want to read from the parent */
                 // FIXME: error check?
 #if BB_MMU
-                transformer(fd, fd_pipe.wr);
-                if (ENABLE_FEATURE_CLEAN_UP) {
-                        close(fd_pipe.wr); /* send EOF */
-                        close(fd);
+                {
+                        transformer_aux_data_t aux;
+                        init_transformer_aux_data(&aux);
+                        aux.check_signature = check_signature;
+                        transformer(&aux, fd, fd_pipe.wr);
+                        if (ENABLE_FEATURE_CLEAN_UP) {
+                                close(fd_pipe.wr); /* send EOF */
+                                close(fd);
+                        }
+                        /* must be _exit! bug was actually seen here */
+                        _exit(EXIT_SUCCESS);
                 }
-                /* must be _exit! bug was actually seen here */
-                _exit(EXIT_SUCCESS);
 #else
                 {
                         char *argv[4];
@@ -52,3 +107,117 @@ void FAST_FUNC open_transformer(int fd,
         close(fd_pipe.wr); /* don't want to write to the child */
         xmove_fd(fd_pipe.rd, fd);
 }
+
+
+#if SEAMLESS_COMPRESSION
+
+/* Used by e.g. rpm which gives us a fd without filename,
+ * thus we can't guess the format from filename's extension.
+ */
+int FAST_FUNC setup_unzip_on_fd(int fd, int fail_if_not_detected)
+{
+        union {
+                uint8_t b[4];
+                uint16_t b16[2];
+                uint32_t b32[1];
+        } magic;
+        int offset = -2;
+        USE_FOR_MMU(IF_DESKTOP(long long) int FAST_FUNC (*xformer)(transformer_aux_data_t *aux, int src_fd, int dst_fd);)
+        USE_FOR_NOMMU(const char *xformer_prog;)
+
+        /* .gz and .bz2 both have 2-byte signature, and their
+         * unpack_XXX_stream wants this header skipped. */
+        xread(fd, magic.b16, sizeof(magic.b16[0]));
+        if (ENABLE_FEATURE_SEAMLESS_GZ
+         && magic.b16[0] == GZIP_MAGIC
+        ) {
+                USE_FOR_MMU(xformer = unpack_gz_stream;)
+                USE_FOR_NOMMU(xformer_prog = "gunzip";)
+                goto found_magic;
+        }
+        if (ENABLE_FEATURE_SEAMLESS_BZ2
+         && magic.b16[0] == BZIP2_MAGIC
+        ) {
+                USE_FOR_MMU(xformer = unpack_bz2_stream;)
+                USE_FOR_NOMMU(xformer_prog = "bunzip2";)
+                goto found_magic;
+        }
+        if (ENABLE_FEATURE_SEAMLESS_XZ
+         && magic.b16[0] == XZ_MAGIC1
+        ) {
+                offset = -6;
+                xread(fd, magic.b32, sizeof(magic.b32[0]));
+                if (magic.b32[0] == XZ_MAGIC2) {
+                        USE_FOR_MMU(xformer = unpack_xz_stream;)
+                        USE_FOR_NOMMU(xformer_prog = "unxz";)
+                        goto found_magic;
+                }
+        }
+
+        /* No known magic seen */
+        if (fail_if_not_detected)
+                bb_error_msg_and_die("no gzip"
+                        IF_FEATURE_SEAMLESS_BZ2("/bzip2")
+                        IF_FEATURE_SEAMLESS_XZ("/xz")
+                        " magic");
+        xlseek(fd, offset, SEEK_CUR);
+        return 1;
+
+ found_magic:
+# if BB_MMU
+        open_transformer_with_no_sig(fd, xformer);
+# else
+        /* NOMMU version of open_transformer execs
+         * an external unzipper that wants
+         * file position at the start of the file */
+        xlseek(fd, offset, SEEK_CUR);
+        open_transformer_with_sig(fd, xformer, xformer_prog);
+# endif
+        return 0;
+}
+
+int FAST_FUNC open_zipped(const char *fname)
+{
+        char *sfx;
+        int fd;
+
+        fd = open(fname, O_RDONLY);
+        if (fd < 0)
+                return fd;
+
+        sfx = strrchr(fname, '.');
+        if (sfx) {
+                sfx++;
+                if (ENABLE_FEATURE_SEAMLESS_LZMA && strcmp(sfx, "lzma") == 0)
+                        /* .lzma has no header/signature, just trust it */
+                        open_transformer_with_sig(fd, unpack_lzma_stream, "unlzma");
+                else
+                if ((ENABLE_FEATURE_SEAMLESS_GZ && strcmp(sfx, "gz") == 0)
+                 || (ENABLE_FEATURE_SEAMLESS_BZ2 && strcmp(sfx, "bz2") == 0)
+                 || (ENABLE_FEATURE_SEAMLESS_XZ && strcmp(sfx, "xz") == 0)
+                ) {
+                        setup_unzip_on_fd(fd, /*fail_if_not_detected:*/ 1);
+                }
+        }
+
+        return fd;
+}
+
+#endif /* SEAMLESS_COMPRESSION */
+
+void* FAST_FUNC xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p)
+{
+        int fd;
+        char *image;
+
+        fd = open_zipped(fname);
+        if (fd < 0)
+                return NULL;
+
+        image = xmalloc_read(fd, maxsz_p);
+        if (!image)
+                bb_perror_msg("read error from '%s'", fname);
+        close(fd);
+
+        return image;
+}