Merge branch 'busybox' into merge

9 files changed, 123 insertions, 54 deletions

diff --git a/archival/libarchive/data_extract_all.c b/archival/libarchive/data_extract_all.c
index 3f67b835f..45776dcbe 100644
--- a/archival/libarchive/data_extract_all.c
+++ b/archival/libarchive/data_extract_all.c
@@ -106,15 +106,28 @@ void FAST_FUNC data_extract_all(archive_handle_t *archive_handle)
         switch (file_header->mode & S_IFMT) {
         case S_IFREG: {
                 /* Regular file */
+                char *dst_name;
                 int flags = O_WRONLY | O_CREAT | O_EXCL;
                 if (archive_handle->ah_flags & ARCHIVE_O_TRUNC)
                         flags = O_WRONLY | O_CREAT | O_TRUNC;
-                dst_fd = xopen3(file_header->name,
+                dst_name = file_header->name;
+#ifdef ARCHIVE_REPLACE_VIA_RENAME
+                if (archive_handle->ah_flags & ARCHIVE_REPLACE_VIA_RENAME)
+                        /* rpm-style temp file name */
+                        dst_name = xasprintf("%s;%x", dst_name, (int)getpid());
+#endif
+                dst_fd = xopen3(dst_name,
                         flags,
                         file_header->mode
                         );
                 bb_copyfd_exact_size(archive_handle->src_fd, dst_fd, file_header->size);
                 close(dst_fd);
+#ifdef ARCHIVE_REPLACE_VIA_RENAME
+                if (archive_handle->ah_flags & ARCHIVE_REPLACE_VIA_RENAME) {
+                        xrename(dst_name, file_header->name);
+                        free(dst_name);
+                }
+#endif
                 break;
         }
         case S_IFDIR:
diff --git a/archival/libarchive/decompress_unlzma.c b/archival/libarchive/decompress_unlzma.c
index cfde8ea56..ca32bd82c 100644
--- a/archival/libarchive/decompress_unlzma.c
+++ b/archival/libarchive/decompress_unlzma.c
@@ -45,16 +45,16 @@ typedef struct {
 #define RC_MODEL_TOTAL_BITS 11
 
 
-/* Called twice: once at startup (LZMA_FAST only) and once in rc_normalize() */
-static size_inline void rc_read(rc_t *rc)
+/* Called once in rc_do_normalize() */
+static void rc_read(rc_t *rc)
 {
         int buffer_size = safe_read(rc->fd, RC_BUFFER, RC_BUFFER_SIZE);
 //TODO: return -1 instead
 //This will make unlzma delete broken unpacked file on unpack errors
         if (buffer_size <= 0)
                 bb_error_msg_and_die("unexpected EOF");
-        rc->ptr = RC_BUFFER;
         rc->buffer_end = RC_BUFFER + buffer_size;
+        rc->ptr = RC_BUFFER;
 }
 
 /* Called twice, but one callsite is in speed_inline'd rc_is_bit_1() */
@@ -65,6 +65,12 @@ static void rc_do_normalize(rc_t *rc)
         rc->range <<= 8;
         rc->code = (rc->code << 8) | *rc->ptr++;
 }
+static ALWAYS_INLINE void rc_normalize(rc_t *rc)
+{
+        if (rc->range < (1 << RC_TOP_BITS)) {
+                rc_do_normalize(rc);
+        }
+}
 
 /* Called once */
 static ALWAYS_INLINE rc_t* rc_init(int fd) /*, int buffer_size) */
@@ -78,15 +84,9 @@ static ALWAYS_INLINE rc_t* rc_init(int fd) /*, int buffer_size) */
         /* rc->ptr = rc->buffer_end; */
 
         for (i = 0; i < 5; i++) {
-#if ENABLE_FEATURE_LZMA_FAST
-                if (rc->ptr >= rc->buffer_end)
-                        rc_read(rc);
-                rc->code = (rc->code << 8) | *rc->ptr++;
-#else
                 rc_do_normalize(rc);
-#endif
         }
-        rc->range = 0xFFFFFFFF;
+        rc->range = 0xffffffff;
         return rc;
 }
 
@@ -96,13 +96,6 @@ static ALWAYS_INLINE void rc_free(rc_t *rc)
         free(rc);
 }
 
-static ALWAYS_INLINE void rc_normalize(rc_t *rc)
-{
-        if (rc->range < (1 << RC_TOP_BITS)) {
-                rc_do_normalize(rc);
-        }
-}
-
 /* rc_is_bit_1 is called 9 times */
 static speed_inline int rc_is_bit_1(rc_t *rc, uint16_t *p)
 {
@@ -120,7 +113,7 @@ static speed_inline int rc_is_bit_1(rc_t *rc, uint16_t *p)
 }
 
 /* Called 4 times in unlzma loop */
-static speed_inline int rc_get_bit(rc_t *rc, uint16_t *p, int *symbol)
+static ALWAYS_INLINE int rc_get_bit(rc_t *rc, uint16_t *p, int *symbol)
 {
         int ret = rc_is_bit_1(rc, p);
         *symbol = *symbol * 2 + ret;
diff --git a/archival/libarchive/decompress_unxz.c b/archival/libarchive/decompress_unxz.c
index 79b48a152..986b7b191 100644
--- a/archival/libarchive/decompress_unxz.c
+++ b/archival/libarchive/decompress_unxz.c
@@ -30,8 +30,8 @@ static uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc)
 /* We use arch-optimized unaligned accessors */
 #define get_unaligned_le32(buf) ({ uint32_t v; move_from_unaligned32(v, buf); SWAP_LE32(v); })
 #define get_unaligned_be32(buf) ({ uint32_t v; move_from_unaligned32(v, buf); SWAP_BE32(v); })
-#define put_unaligned_le32(val, buf) move_to_unaligned16(buf, SWAP_LE32(val))
-#define put_unaligned_be32(val, buf) move_to_unaligned16(buf, SWAP_BE32(val))
+#define put_unaligned_le32(val, buf) move_to_unaligned32(buf, SWAP_LE32(val))
+#define put_unaligned_be32(val, buf) move_to_unaligned32(buf, SWAP_BE32(val))
 
 #include "unxz/xz_dec_bcj.c"
 #include "unxz/xz_dec_lzma2.c"
@@ -40,6 +40,7 @@ static uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc)
 IF_DESKTOP(long long) int FAST_FUNC
 unpack_xz_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
 {
+        enum xz_ret xz_result;
         struct xz_buf iobuf;
         struct xz_dec *state;
         unsigned char *membuf;
@@ -63,9 +64,8 @@ unpack_xz_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
         /* Limit memory usage to about 64 MiB. */
         state = xz_dec_init(XZ_DYNALLOC, 64*1024*1024);
 
+        xz_result = X_OK;
         while (1) {
-                enum xz_ret r;
-
                 if (iobuf.in_pos == iobuf.in_size) {
                         int rd = safe_read(src_fd, membuf, BUFSIZ);
                         if (rd < 0) {
@@ -73,28 +73,57 @@ unpack_xz_stream(transformer_aux_data_t *aux, int src_fd, int dst_fd)
                                 total = -1;
                                 break;
                         }
+                        if (rd == 0 && xz_result == XZ_STREAM_END)
+                                break;
                         iobuf.in_size = rd;
                         iobuf.in_pos = 0;
                 }
+                if (xz_result == XZ_STREAM_END) {
+                        /*
+                         * Try to start decoding next concatenated stream.
+                         * Stream padding must always be a multiple of four
+                         * bytes to preserve four-byte alignment. To keep the
+                         * code slightly smaller, we aren't as strict here as
+                         * the .xz spec requires. We just skip all zero-bytes
+                         * without checking the alignment and thus can accept
+                         * files that aren't valid, e.g. the XZ utils test
+                         * files bad-0pad-empty.xz and bad-0catpad-empty.xz.
+                         */
+                        do {
+                                if (membuf[iobuf.in_pos] != 0) {
+                                        xz_dec_reset(state);
+                                        goto do_run;
+                                }
+                                iobuf.in_pos++;
+                        } while (iobuf.in_pos < iobuf.in_size);
+                }
+ do_run:
 //              bb_error_msg(">in pos:%d size:%d out pos:%d size:%d",
 //                              iobuf.in_pos, iobuf.in_size, iobuf.out_pos, iobuf.out_size);
-                r = xz_dec_run(state, &iobuf);
+                xz_result = xz_dec_run(state, &iobuf);
 //              bb_error_msg("<in pos:%d size:%d out pos:%d size:%d r:%d",
-//                              iobuf.in_pos, iobuf.in_size, iobuf.out_pos, iobuf.out_size, r);
+//                              iobuf.in_pos, iobuf.in_size, iobuf.out_pos, iobuf.out_size, xz_result);
                 if (iobuf.out_pos) {
                         xwrite(dst_fd, iobuf.out, iobuf.out_pos);
                         IF_DESKTOP(total += iobuf.out_pos;)
                         iobuf.out_pos = 0;
                 }
-                if (r == XZ_STREAM_END) {
-                        break;
+                if (xz_result == XZ_STREAM_END) {
+                        /*
+                         * Can just "break;" here, if not for concatenated
+                         * .xz streams.
+                         * Checking for padding may require buffer
+                         * replenishment. Can't do it here.
+                         */
+                        continue;
                 }
-                if (r != XZ_OK && r != XZ_UNSUPPORTED_CHECK) {
+                if (xz_result != XZ_OK && xz_result != XZ_UNSUPPORTED_CHECK) {
                         bb_error_msg("corrupted data");
                         total = -1;
                         break;
                 }
         }
+
         xz_dec_end(state);
         free(membuf);
 
diff --git a/archival/libarchive/open_transformer.c b/archival/libarchive/open_transformer.c
index f2edc2a2b..841e9dce9 100644
--- a/archival/libarchive/open_transformer.c
+++ b/archival/libarchive/open_transformer.c
@@ -35,6 +35,7 @@ void check_errors_in_children(int signo)
         if (!signo) {
                 /* block waiting for any child */
                 if (wait(&status) < 0)
+//FIXME: check EINTR?
                         return; /* probably there are no children */
                 goto check_status;
         }
@@ -42,14 +43,18 @@ void check_errors_in_children(int signo)
         /* Wait for any child without blocking */
         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;
         }
 }
diff --git a/archival/libarchive/unxz/README b/archival/libarchive/unxz/README
index c5972f6b8..a84912035 100644
--- a/archival/libarchive/unxz/README
+++ b/archival/libarchive/unxz/README
@@ -7,7 +7,7 @@ XZ Embedded
 
     XZ Embedded was written for use in the Linux kernel, but the code can
     be easily used in other environments too, including regular userspace
-    applications.
+    applications. See userspace/xzminidec.c for an example program.
 
     This README contains information that is useful only when the copy
     of XZ Embedded isn't part of the Linux kernel tree. You should also
@@ -55,7 +55,7 @@ Compiler requirements
     code is modified not to support large files, which needs some more
     care than just using 32-bit integer instead of 64-bit).
 
-    If you use GCC, try to use a recent version. For example, on x86,
+    If you use GCC, try to use a recent version. For example, on x86-32,
     xz_dec_lzma2.c compiled with GCC 3.3.6 is 15-25 % slower than when
     compiled with GCC 4.3.3.
 
@@ -93,7 +93,7 @@ BCJ filter support
     them always #defined doesn't hurt either.
 
         #define             Instruction set     BCJ filter endianness
-        XZ_DEC_X86          x86 or x86-64       Little endian only
+        XZ_DEC_X86          x86-32 or x86-64    Little endian only
         XZ_DEC_POWERPC      PowerPC             Big endian only
         XZ_DEC_IA64         Itanium (IA-64)     Big or little endian
         XZ_DEC_ARM          ARM                 Little endian only
diff --git a/archival/libarchive/unxz/xz.h b/archival/libarchive/unxz/xz.h
index c6c071c4a..e0b22db56 100644
--- a/archival/libarchive/unxz/xz.h
+++ b/archival/libarchive/unxz/xz.h
@@ -19,6 +19,10 @@
 #       include <stdint.h>
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* In Linux, this is used to make extern functions static when needed. */
 #ifndef XZ_EXTERN
 #       define XZ_EXTERN extern
@@ -70,7 +74,7 @@ enum xz_mode {
  * @XZ_UNSUPPORTED_CHECK:   Integrity check type is not supported. Decoding
  *                          is still possible in multi-call mode by simply
  *                          calling xz_dec_run() again.
- *                          NOTE: This return value is used only if
+ *                          Note that this return value is used only if
  *                          XZ_DEC_ANY_CHECK was defined at build time,
  *                          which is not used in the kernel. Unsupported
  *                          check types return XZ_OPTIONS_ERROR if
@@ -105,7 +109,7 @@ enum xz_mode {
  * stream that is truncated or otherwise corrupt.
  *
  * In single-call mode, XZ_BUF_ERROR is returned only when the output buffer
- * is too small, or the compressed input is corrupt in a way that makes the
+ * is too small or the compressed input is corrupt in a way that makes the
  * decoder produce more output than the caller expected. When it is
  * (relatively) clear that the compressed input is truncated, XZ_DATA_ERROR
  * is used instead of XZ_BUF_ERROR.
@@ -207,8 +211,8 @@ XZ_EXTERN struct xz_dec * XZ_FUNC xz_dec_init(
  * The possible return values depend on build options and operation mode.
  * See enum xz_ret for details.
  *
- * NOTE: If an error occurs in single-call mode (return value is not
- * XZ_STREAM_END), b->in_pos and b->out_pos are not modified, and the
+ * Note that if an error occurs in single-call mode (return value is not
+ * XZ_STREAM_END), b->in_pos and b->out_pos are not modified and the
  * contents of the output buffer from b->out[b->out_pos] onward are
  * undefined. This is true even after XZ_BUF_ERROR, because with some filter
  * chains, there may be a second pass over the output buffer, and this pass
@@ -268,4 +272,9 @@ XZ_EXTERN void XZ_FUNC xz_crc32_init(void);
 XZ_EXTERN uint32_t XZ_FUNC xz_crc32(
                 const uint8_t *buf, size_t size, uint32_t crc);
 #endif
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/archival/libarchive/unxz/xz_dec_bcj.c b/archival/libarchive/unxz/xz_dec_bcj.c
index 09162b51f..e0f913a94 100644
--- a/archival/libarchive/unxz/xz_dec_bcj.c
+++ b/archival/libarchive/unxz/xz_dec_bcj.c
@@ -77,10 +77,13 @@ struct xz_dec_bcj {
 
 #ifdef XZ_DEC_X86
 /*
- * This is macro used to test the most significant byte of a memory address
+ * This is used to test the most significant byte of a memory address
  * in an x86 instruction.
  */
-#define bcj_x86_test_msbyte(b) ((b) == 0x00 || (b) == 0xFF)
+static inline int bcj_x86_test_msbyte(uint8_t b)
+{
+        return b == 0x00 || b == 0xFF;
+}
 
 static noinline_for_stack size_t XZ_FUNC bcj_x86(
                 struct xz_dec_bcj *s, uint8_t *buf, size_t size)
@@ -443,8 +446,12 @@ XZ_EXTERN enum xz_ret XZ_FUNC xz_dec_bcj_run(struct xz_dec_bcj *s,
          * next filter in the chain. Apply the BCJ filter on the new data
          * in the output buffer. If everything cannot be filtered, copy it
          * to temp and rewind the output buffer position accordingly.
+         *
+         * This needs to be always run when temp.size == 0 to handle a special
+         * case where the output buffer is full and the next filter has no
+         * more output coming but hasn't returned XZ_STREAM_END yet.
          */
-        if (s->temp.size < b->out_size - b->out_pos) {
+        if (s->temp.size < b->out_size - b->out_pos || s->temp.size == 0) {
                 out_start = b->out_pos;
                 memcpy(b->out + b->out_pos, s->temp.buf, s->temp.size);
                 b->out_pos += s->temp.size;
@@ -467,16 +474,25 @@ XZ_EXTERN enum xz_ret XZ_FUNC xz_dec_bcj_run(struct xz_dec_bcj *s,
                 s->temp.size = b->out_pos - out_start;
                 b->out_pos -= s->temp.size;
                 memcpy(s->temp.buf, b->out + b->out_pos, s->temp.size);
+
+                /*
+                 * If there wasn't enough input to the next filter to fill
+                 * the output buffer with unfiltered data, there's no point
+                 * to try decoding more data to temp.
+                 */
+                if (b->out_pos + s->temp.size < b->out_size)
+                        return XZ_OK;
         }
 
         /*
-         * If we have unfiltered data in temp, try to fill by decoding more
-         * data from the next filter. Apply the BCJ filter on temp. Then we
-         * hopefully can fill the actual output buffer by copying filtered
-         * data from temp. A mix of filtered and unfiltered data may be left
-         * in temp; it will be taken care on the next call to this function.
+         * We have unfiltered data in temp. If the output buffer isn't full
+         * yet, try to fill the temp buffer by decoding more data from the
+         * next filter. Apply the BCJ filter on temp. Then we hopefully can
+         * fill the actual output buffer by copying filtered data from temp.
+         * A mix of filtered and unfiltered data may be left in temp; it will
+         * be taken care on the next call to this function.
          */
-        if (s->temp.size > 0) {
+        if (b->out_pos < b->out_size) {
                 /* Make b->out{,_pos,_size} temporarily point to s->temp. */
                 s->out = b->out;
                 s->out_pos = b->out_pos;
diff --git a/archival/libarchive/unxz/xz_dec_lzma2.c b/archival/libarchive/unxz/xz_dec_lzma2.c
index da71cb4d4..3c2dc88b7 100644
--- a/archival/libarchive/unxz/xz_dec_lzma2.c
+++ b/archival/libarchive/unxz/xz_dec_lzma2.c
@@ -407,7 +407,6 @@ static void XZ_FUNC dict_uncompressed(
 
                 b->out_pos += copy_size;
                 b->in_pos += copy_size;
-
         }
 }
 
@@ -972,6 +971,9 @@ XZ_EXTERN NOINLINE enum xz_ret XZ_FUNC xz_dec_lzma2_run(
                          */
                         tmp = b->in[b->in_pos++];
 
+                        if (tmp == 0x00)
+                                return XZ_STREAM_END;
+
                         if (tmp >= 0xE0 || tmp == 0x01) {
                                 s->lzma2.need_props = true;
                                 s->lzma2.need_dict_reset = false;
@@ -1004,9 +1006,6 @@ XZ_EXTERN NOINLINE enum xz_ret XZ_FUNC xz_dec_lzma2_run(
                                                 lzma_reset(s);
                                 }
                         } else {
-                                if (tmp == 0x00)
-                                        return XZ_STREAM_END;
-
                                 if (tmp > 0x02)
                                         return XZ_DATA_ERROR;
 
diff --git a/archival/libarchive/unxz/xz_stream.h b/archival/libarchive/unxz/xz_stream.h
index 36f2a7cbf..66cb5a705 100644
--- a/archival/libarchive/unxz/xz_stream.h
+++ b/archival/libarchive/unxz/xz_stream.h
@@ -25,15 +25,20 @@
 
 #define STREAM_HEADER_SIZE 12
 
-#define HEADER_MAGIC "\3757zXZ\0"
+#define HEADER_MAGIC "\3757zXZ"
 #define HEADER_MAGIC_SIZE 6
 
 #define FOOTER_MAGIC "YZ"
 #define FOOTER_MAGIC_SIZE 2
 
 /*
- * Variable-length integer can hold a 63-bit unsigned integer, or a special
- * value to indicate that the value is unknown.
+ * Variable-length integer can hold a 63-bit unsigned integer or a special
+ * value indicating that the value is unknown.
+ *
+ * Experimental: vli_type can be defined to uint32_t to save a few bytes
+ * in code size (no effect on speed). Doing so limits the uncompressed and
+ * compressed size of the file to less than 256 MiB and may also weaken
+ * error detection slightly.
  */
 typedef uint64_t vli_type;