Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/archival/libarchive/open_transformer.c

Timestamp:

Dec 20, 2016, 4:07:32 PM (7 years ago)

Author:

Bruno Cornec

Message:

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.

Location:

branches/3.3

Files:

• . (copied) (copied from branches/3.2 )
• mindi-busybox/archival/libarchive/open_transformer.c (modified) (13 diffs)

branches/3.3/mindi-busybox/archival/libarchive/open_transformer.c

@@ -7 +7 @@
 #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) {
+void FAST_FUNC init_transformer_state(transformer_state_t *xstate)
+{
+    memset(xstate, 0, sizeof(*xstate));
+}
+
+int FAST_FUNC check_signature16(transformer_state_t *xstate, unsigned magic16)
+{
+    if (!xstate->signature_skipped) {
         uint16_t magic2;
-        if (full_read(src_fd, &magic2, 2) != 2 || magic2 != magic16) {
+        if (full_read(xstate->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;
         }
+        xstate->signature_skipped = 2;
     }
     return 0;
+}
+
+ssize_t FAST_FUNC transformer_write(transformer_state_t *xstate, const void *buf, size_t bufsize)
+{
+    ssize_t nwrote;
+
+    if (xstate->mem_output_size_max != 0) {
+        size_t pos = xstate->mem_output_size;
+        size_t size;
+
+        size = (xstate->mem_output_size += bufsize);
+        if (size > xstate->mem_output_size_max) {
+            free(xstate->mem_output_buf);
+            xstate->mem_output_buf = NULL;
+            bb_perror_msg("buffer %u too small", (unsigned)xstate->mem_output_size_max);
+            nwrote = -1;
+            goto ret;
+        }
+        xstate->mem_output_buf = xrealloc(xstate->mem_output_buf, size + 1);
+        memcpy(xstate->mem_output_buf + pos, buf, bufsize);
+        xstate->mem_output_buf[size] = '\0';
+        nwrote = bufsize;
+    } else {
+        nwrote = full_write(xstate->dst_fd, buf, bufsize);
+        if (nwrote != (ssize_t)bufsize) {
+            bb_perror_msg("write");
+            nwrote = -1;
+            goto ret;
+        }
+    }
+ ret:
+    return nwrote;
+}
+
+ssize_t FAST_FUNC xtransformer_write(transformer_state_t *xstate, const void *buf, size_t bufsize)
+{
+    ssize_t nwrote = transformer_write(xstate, buf, bufsize);
+    if (nwrote != (ssize_t)bufsize) {
+        xfunc_die();
+    }
+    return nwrote;
 }
 
@@ -35 +73 @@
         /* block waiting for any child */
         if (wait(&status) < 0)
+//FIXME: check EINTR?
             return; /* probably there are no children */
         goto check_status;
@@ -42 +81 @@
     for (;;) {
         if (wait_any_nohang(&status) < 0)
+//FIXME: check EINTR?
             /* wait failed?! I'm confused... */
             return;
  check_status:
-        if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
+        /*if (WIFEXITED(status) && WEXITSTATUS(status) == 0)*/
+        /* On Linux, the above can be checked simply as: */
+        if (status == 0)
             /* this child exited with 0 */
             continue;
-        /* Cannot happen?
-        if (!WIFSIGNALED(status) && !WIFEXITED(status)) ???; */
+        /* Cannot happen:
+        if (!WIFSIGNALED(status) && !WIFEXITED(status)) ???;
+         */
         bb_got_signal = 1;
     }
@@ -56 +99 @@
 /* transformer(), more than meets the eye */
 #if BB_MMU
-void FAST_FUNC open_transformer(int fd,
-    int check_signature,
-    IF_DESKTOP(long long) int FAST_FUNC (*transformer)(transformer_aux_data_t *aux, int src_fd, int dst_fd)
+void FAST_FUNC fork_transformer(int fd,
+    int signature_skipped,
+    IF_DESKTOP(long long) int FAST_FUNC (*transformer)(transformer_state_t *xstate)
 )
 #else
-void FAST_FUNC open_transformer(int fd, const char *transform_prog)
+void FAST_FUNC fork_transformer(int fd, const char *transform_prog)
 #endif
 {
@@ -75 +118 @@
 #if BB_MMU
         {
-            transformer_aux_data_t aux;
-            init_transformer_aux_data(&aux);
-            aux.check_signature = check_signature;
-            transformer(&aux, fd, fd_pipe.wr);
+            IF_DESKTOP(long long) int r;
+            transformer_state_t xstate;
+            init_transformer_state(&xstate);
+            xstate.signature_skipped = signature_skipped;
+            xstate.src_fd = fd;
+            xstate.dst_fd = fd_pipe.wr;
+            r = transformer(&xstate);
             if (ENABLE_FEATURE_CLEAN_UP) {
                 close(fd_pipe.wr); /* send EOF */
@@ -84 +130 @@
             }
             /* must be _exit! bug was actually seen here */
-            _exit(EXIT_SUCCESS);
+            _exit(/*error if:*/ r < 0);
         }
 #else
@@ -113 +159 @@
  * 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)
+static transformer_state_t *setup_transformer_on_fd(int fd, int fail_if_not_compressed)
 {
     union {
@@ -120 +166 @@
         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;)
+    transformer_state_t *xstate;
+
+    xstate = xzalloc(sizeof(*xstate));
+    xstate->src_fd = fd;
+    xstate->signature_skipped = 2;
 
     /* .gz and .bz2 both have 2-byte signature, and their
@@ -130 +178 @@
      && magic.b16[0] == GZIP_MAGIC
     ) {
-        USE_FOR_MMU(xformer = unpack_gz_stream;)
-        USE_FOR_NOMMU(xformer_prog = "gunzip";)
+        xstate->xformer = unpack_gz_stream;
+        USE_FOR_NOMMU(xstate->xformer_prog = "gunzip";)
+        goto found_magic;
+    }
+    if (ENABLE_FEATURE_SEAMLESS_Z
+     && magic.b16[0] == COMPRESS_MAGIC
+    ) {
+        xstate->xformer = unpack_Z_stream;
+        USE_FOR_NOMMU(xstate->xformer_prog = "uncompress";)
         goto found_magic;
     }
@@ -137 +192 @@
      && magic.b16[0] == BZIP2_MAGIC
     ) {
-        USE_FOR_MMU(xformer = unpack_bz2_stream;)
-        USE_FOR_NOMMU(xformer_prog = "bunzip2";)
+        xstate->xformer = unpack_bz2_stream;
+        USE_FOR_NOMMU(xstate->xformer_prog = "bunzip2";)
         goto found_magic;
     }
@@ -144 +199 @@
      && magic.b16[0] == XZ_MAGIC1
     ) {
-        offset = -6;
+        xstate->signature_skipped = 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";)
+            xstate->xformer = unpack_xz_stream;
+            USE_FOR_NOMMU(xstate->xformer_prog = "unxz";)
             goto found_magic;
         }
@@ -154 +209 @@
 
     /* No known magic seen */
-    if (fail_if_not_detected)
+    if (fail_if_not_compressed)
         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;
+
+    /* Some callers expect this function to "consume" fd
+     * even if data is not compressed. In this case,
+     * we return a state with trivial transformer.
+     */
+//  USE_FOR_MMU(xstate->xformer = copy_stream;)
+//  USE_FOR_NOMMU(xstate->xformer_prog = "cat";)
 
  found_magic:
+    return xstate;
+}
+
+/* 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_compressed)
+{
+    transformer_state_t *xstate = setup_transformer_on_fd(fd, fail_if_not_compressed);
+
+    if (!xstate || !xstate->xformer) {
+        free(xstate);
+        return 1;
+    }
+
 # if BB_MMU
-    open_transformer_with_no_sig(fd, xformer);
+    fork_transformer_with_no_sig(xstate->src_fd, xstate->xformer);
 # else
-    /* NOMMU version of open_transformer execs
+    /* NOMMU version of fork_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);
+     * file position at the start of the file.
+     */
+    xlseek(fd, - xstate->signature_skipped, SEEK_CUR);
+    xstate->signature_skipped = 0;
+    fork_transformer_with_sig(xstate->src_fd, xstate->xformer, xstate->xformer_prog);
 # endif
+    free(xstate);
     return 0;
 }
 
-int FAST_FUNC open_zipped(const char *fname)
-{
-    char *sfx;
+static transformer_state_t *open_transformer(const char *fname, int fail_if_not_compressed)
+{
+    transformer_state_t *xstate;
     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 NULL;
+
+    if (ENABLE_FEATURE_SEAMLESS_LZMA) {
+        /* .lzma has no header/signature, can only detect it by extension */
+        char *sfx = strrchr(fname, '.');
+        if (sfx && strcmp(sfx+1, "lzma") == 0) {
+            xstate = xzalloc(sizeof(*xstate));
+            xstate->src_fd = fd;
+            xstate->xformer = unpack_lzma_stream;
+            USE_FOR_NOMMU(xstate->xformer_prog = "unlzma";)
+            return xstate;
+        }
+    }
+
+    xstate = setup_transformer_on_fd(fd, fail_if_not_compressed);
+
+    return xstate;
+}
+
+int FAST_FUNC open_zipped(const char *fname, int fail_if_not_compressed)
+{
+    int fd;
+    transformer_state_t *xstate;
+
+    xstate = open_transformer(fname, fail_if_not_compressed);
+    if (!xstate)
+        return -1;
+
+    fd = xstate->src_fd;
+# if BB_MMU
+    if (xstate->xformer) {
+        fork_transformer_with_no_sig(fd, xstate->xformer);
+    } else {
+        /* the file is not compressed */
+        xlseek(fd, - xstate->signature_skipped, SEEK_CUR);
+        xstate->signature_skipped = 0;
+    }
+# else
+    /* NOMMU can't avoid the seek :( */
+    xlseek(fd, - xstate->signature_skipped, SEEK_CUR);
+    xstate->signature_skipped = 0;
+    if (xstate->xformer) {
+        fork_transformer_with_sig(fd, xstate->xformer, xstate->xformer_prog);
+    } /* else: the file is not compressed */
+# endif
+
+    free(xstate);
     return fd;
 }
 
-#endif /* SEAMLESS_COMPRESSION */
-
 void* FAST_FUNC xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p)
 {
+# if 1
+    transformer_state_t *xstate;
+    char *image;
+
+    xstate = open_transformer(fname, /*fail_if_not_compressed:*/ 0);
+    if (!xstate) /* file open error */
+        return NULL;
+
+    image = NULL;
+    if (xstate->xformer) {
+        /* In-memory decompression */
+        xstate->mem_output_size_max = maxsz_p ? *maxsz_p : (size_t)(INT_MAX - 4095);
+        xstate->xformer(xstate);
+        if (xstate->mem_output_buf) {
+            image = xstate->mem_output_buf;
+            if (maxsz_p)
+                *maxsz_p = xstate->mem_output_size;
+        }
+    } else {
+        /* File is not compressed */
+//FIXME: avoid seek
+        xlseek(xstate->src_fd, - xstate->signature_skipped, SEEK_CUR);
+        xstate->signature_skipped = 0;
+        image = xmalloc_read(xstate->src_fd, maxsz_p);
+    }
+
+    if (!image)
+        bb_perror_msg("read error from '%s'", fname);
+    close(xstate->src_fd);
+    free(xstate);
+    return image;
+# else
+    /* This version forks a subprocess - much more expensive */
     int fd;
     char *image;
 
-    fd = open_zipped(fname);
+    fd = open_zipped(fname, /*fail_if_not_compressed:*/ 0);
     if (fd < 0)
         return NULL;
@@ -217 +356 @@
         bb_perror_msg("read error from '%s'", fname);
     close(fd);
-
     return image;
-}
+# endif
+}
+
+#endif /* SEAMLESS_COMPRESSION */