6 files changed, 152 insertions, 115 deletions

diff --git a/archival/bbunzip.c b/archival/bbunzip.c
index 24033c9f5..da6f031e3 100644
--- a/archival/bbunzip.c
+++ b/archival/bbunzip.c
@@ -538,6 +538,7 @@ int unlzma_main(int argc UNUSED_PARAM, char **argv)
 //usage:     "\n        -c      Write to stdout"
 //usage:     "\n        -f      Force"
 //usage:     "\n        -k      Keep input files"
+//usage:     "\n        -t      Test file integrity"
 //usage:
 //usage:#define xz_trivial_usage
 //usage:       "-d [-cfk] [FILE]..."
@@ -547,6 +548,7 @@ int unlzma_main(int argc UNUSED_PARAM, char **argv)
 //usage:     "\n        -c      Write to stdout"
 //usage:     "\n        -f      Force"
 //usage:     "\n        -k      Keep input files"
+//usage:     "\n        -t      Test file integrity"
 //usage:
 //usage:#define xzcat_trivial_usage
 //usage:       "[FILE]..."
diff --git a/archival/gzip.c b/archival/gzip.c
index 17341de45..d9c730f13 100644
--- a/archival/gzip.c
+++ b/archival/gzip.c
@@ -52,7 +52,7 @@ aa:      85.1% -- replaced with aa.gz
 //config:       help
 //config:       Enable support for compression levels 4-9. The default level
 //config:       is 6. If levels 1-3 are specified, 4 is used.
-//config:       If this option is not selected, -N options are ignored and -9
+//config:       If this option is not selected, -N options are ignored and -6
 //config:       is used.
 //config:
 //config:config FEATURE_GZIP_DECOMPRESS
@@ -259,12 +259,13 @@ enum {
 
 #if !ENABLE_FEATURE_GZIP_LEVELS
 
-        max_chain_length = 4096,
+        comp_level_minus4 = 6 - 4,
+        max_chain_length = 128,
 /* To speed up deflation, hash chains are never searched beyond this length.
  * A higher limit improves compression ratio but degrades the speed.
  */
 
-        max_lazy_match = 258,
+        max_lazy_match = 16,
 /* Attempt to find a better match only when the current match is strictly
  * smaller than this value. This mechanism is used only for compression
  * levels >= 4.
@@ -276,7 +277,7 @@ enum {
  * max_insert_length is used only for compression levels <= 3.
  */
 
-        good_match = 32,
+        good_match = 8,
 /* Use a faster search when the previous match is longer than this */
 
 /* Values for max_lazy_match, good_match and max_chain_length, depending on
@@ -285,7 +286,7 @@ enum {
  * found for specific files.
  */
 
-        nice_match = 258,       /* Stop searching when current match exceeds this */
+        nice_match = 128,       /* Stop searching when current match exceeds this */
 /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
  * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
  * meaning.
@@ -334,14 +335,16 @@ struct globals {
 #define head (G1.prev + WSIZE) /* hash head (see deflate.c) */
 
 #if ENABLE_FEATURE_GZIP_LEVELS
+        unsigned comp_level_minus4;     /* can be a byte */
         unsigned max_chain_length;
         unsigned max_lazy_match;
         unsigned good_match;
         unsigned nice_match;
-#define max_chain_length (G1.max_chain_length)
-#define max_lazy_match   (G1.max_lazy_match)
-#define good_match       (G1.good_match)
-#define nice_match       (G1.nice_match)
+#define comp_level_minus4 (G1.comp_level_minus4)
+#define max_chain_length  (G1.max_chain_length)
+#define max_lazy_match    (G1.max_lazy_match)
+#define good_match        (G1.good_match)
+#define nice_match        (G1.nice_match)
 #endif
 
 /* =========================================================================== */
@@ -504,7 +507,7 @@ static ALWAYS_INLINE void flush_outbuf_if_32bit_optimized(void)
  * pointer, then initialize the crc shift register contents instead.
  * Return the current crc in either case.
  */
-static void updcrc(uch * s, unsigned n)
+static void updcrc(uch *s, unsigned n)
 {
         G1.crc = crc32_block_endian0(G1.crc, s, n, global_crc32_table /*G1.crc_32_tab*/);
 }
@@ -607,7 +610,7 @@ static void bi_windup(void)
  * Copy a stored block to the zip file, storing first the length and its
  * one's complement if requested.
  */
-static void copy_block(char *buf, unsigned len, int header)
+static void copy_block(const char *buf, unsigned len, int header)
 {
         bi_windup();            /* align on byte boundary */
 
@@ -1007,7 +1010,8 @@ struct globals2 {
         tree_desc d_desc;
         tree_desc bl_desc;
 
-        ush bl_count[MAX_BITS + 1];
+        /* was "ush", but "unsigned" results in smaller code */
+        unsigned bl_count[MAX_BITS + 1];
 
 /* The lengths of the bit length codes are sent in order of decreasing
  * probability, to avoid transmitting the lengths for unused bit length codes.
@@ -1118,7 +1122,7 @@ static void init_block(void)
         (tree[n].Freq < tree[m].Freq \
         || (tree[n].Freq == tree[m].Freq && G2.depth[n] <= G2.depth[m]))
 
-static void pqdownheap(ct_data * tree, int k)
+static void pqdownheap(const ct_data *tree, int k)
 {
         int v = G2.heap[k];
         int j = k << 1;         /* left son of k */
@@ -1152,22 +1156,15 @@ static void pqdownheap(ct_data * tree, int k)
  *     The length opt_len is updated; static_len is also updated if stree is
  *     not null.
  */
-static void gen_bitlen(tree_desc * desc)
+static void gen_bitlen(const tree_desc *desc)
 {
-        ct_data *tree = desc->dyn_tree;
-        const uint8_t *extra = desc->extra_bits;
-        int base = desc->extra_base;
-        int max_code = desc->max_code;
-        int max_length = desc->max_length;
-        ct_data *stree = desc->static_tree;
-        int h;                          /* heap index */
-        int n, m;                       /* iterate over the tree elements */
-        int bits;                       /* bit length */
-        int xbits;                      /* extra bits */
-        ush f;                          /* frequency */
-        int overflow = 0;       /* number of elements with bit length too large */
-
-        for (bits = 0; bits <= MAX_BITS; bits++)
+#define tree desc->dyn_tree
+        int h;          /* heap index */
+        int n, m;       /* iterate over the tree elements */
+        int bits;       /* bit length */
+        int overflow;   /* number of elements with bit length too large */
+
+        for (bits = 0; bits < ARRAY_SIZE(G2.bl_count); bits++)
                 G2.bl_count[bits] = 0;
 
         /* In a first pass, compute the optimal bit lengths (which may
@@ -1175,28 +1172,32 @@ static void gen_bitlen(tree_desc * desc)
          */
         tree[G2.heap[G2.heap_max]].Len = 0;     /* root of the heap */
 
+        overflow = 0;
         for (h = G2.heap_max + 1; h < HEAP_SIZE; h++) {
+                ulg f;          /* frequency */
+                int xbits;      /* extra bits */
+
                 n = G2.heap[h];
                 bits = tree[tree[n].Dad].Len + 1;
-                if (bits > max_length) {
-                        bits = max_length;
+                if (bits > desc->max_length) {
+                        bits = desc->max_length;
                         overflow++;
                 }
                 tree[n].Len = (ush) bits;
                 /* We overwrite tree[n].Dad which is no longer needed */
 
-                if (n > max_code)
+                if (n > desc->max_code)
                         continue;       /* not a leaf node */
 
                 G2.bl_count[bits]++;
                 xbits = 0;
-                if (n >= base)
-                        xbits = extra[n - base];
+                if (n >= desc->extra_base)
+                        xbits = desc->extra_bits[n - desc->extra_base];
                 f = tree[n].Freq;
-                G2.opt_len += (ulg) f *(bits + xbits);
+                G2.opt_len += f * (bits + xbits);
 
-                if (stree)
-                        G2.static_len += (ulg) f * (stree[n].Len + xbits);
+                if (desc->static_tree)
+                        G2.static_len += f * (desc->static_tree[n].Len + xbits);
         }
         if (overflow == 0)
                 return;
@@ -1206,14 +1207,14 @@ static void gen_bitlen(tree_desc * desc)
 
         /* Find the first bit length which could increase: */
         do {
-                bits = max_length - 1;
+                bits = desc->max_length - 1;
                 while (G2.bl_count[bits] == 0)
                         bits--;
                 G2.bl_count[bits]--;    /* move one leaf down the tree */
                 G2.bl_count[bits + 1] += 2;     /* move one overflow item as its brother */
-                G2.bl_count[max_length]--;
+                G2.bl_count[desc->max_length]--;
                 /* The brother of the overflow item also moves one step up,
-                 * but this does not affect bl_count[max_length]
+                 * but this does not affect bl_count[desc->max_length]
                  */
                 overflow -= 2;
         } while (overflow > 0);
@@ -1223,11 +1224,11 @@ static void gen_bitlen(tree_desc * desc)
          * lengths instead of fixing only the wrong ones. This idea is taken
          * from 'ar' written by Haruhiko Okumura.)
          */
-        for (bits = max_length; bits != 0; bits--) {
+        for (bits = desc->max_length; bits != 0; bits--) {
                 n = G2.bl_count[bits];
                 while (n != 0) {
                         m = G2.heap[--h];
-                        if (m > max_code)
+                        if (m > desc->max_code)
                                 continue;
                         if (tree[m].Len != (unsigned) bits) {
                                 Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits));
@@ -1237,6 +1238,7 @@ static void gen_bitlen(tree_desc * desc)
                         n--;
                 }
         }
+#undef tree
 }
 
 /* ===========================================================================
@@ -1247,12 +1249,13 @@ static void gen_bitlen(tree_desc * desc)
  * OUT assertion: the field code is set for all tree elements of non
  *     zero code length.
  */
-static void gen_codes(ct_data * tree, int max_code)
+static void gen_codes(ct_data *tree, int max_code)
 {
-        ush next_code[MAX_BITS + 1];    /* next code value for each bit length */
-        ush code = 0;           /* running code value */
-        int bits;                       /* bit index */
-        int n;                          /* code index */
+        /* next_code[] and code used to be "ush", but "unsigned" results in smaller code */
+        unsigned next_code[MAX_BITS + 1]; /* next code value for each bit length */
+        unsigned code = 0;      /* running code value */
+        int bits;               /* bit index */
+        int n;                  /* code index */
 
         /* The distribution counts are first used to generate the code values
          * without bit reversal.
@@ -1304,7 +1307,7 @@ do { \
         pqdownheap(tree, SMALLEST); \
 } while (0)
 
-static void build_tree(tree_desc * desc)
+static void build_tree(tree_desc *desc)
 {
         ct_data *tree = desc->dyn_tree;
         ct_data *stree = desc->static_tree;
@@ -1382,10 +1385,10 @@ static void build_tree(tree_desc * desc)
         /* At this point, the fields freq and dad are set. We can now
          * generate the bit lengths.
          */
-        gen_bitlen((tree_desc *) desc);
+        gen_bitlen(desc);
 
         /* The field len is now set, we can generate the bit codes */
-        gen_codes((ct_data *) tree, max_code);
+        gen_codes(tree, max_code);
 }
 
 /* ===========================================================================
@@ -1394,7 +1397,7 @@ static void build_tree(tree_desc * desc)
  * counts. (The contribution of the bit length codes will be added later
  * during the construction of bl_tree.)
  */
-static void scan_tree(ct_data * tree, int max_code)
+static void scan_tree(ct_data *tree, int max_code)
 {
         int n;                          /* iterates over all tree elements */
         int prevlen = -1;       /* last emitted length */
@@ -1446,7 +1449,7 @@ static void scan_tree(ct_data * tree, int max_code)
  * Send a literal or distance tree in compressed form, using the codes in
  * bl_tree.
  */
-static void send_tree(ct_data * tree, int max_code)
+static void send_tree(const ct_data *tree, int max_code)
 {
         int n;                          /* iterates over all tree elements */
         int prevlen = -1;       /* last emitted length */
@@ -1622,7 +1625,7 @@ static int ct_tally(int dist, int lc)
 /* ===========================================================================
  * Send the block data compressed using the given Huffman trees
  */
-static void compress_block(ct_data * ltree, ct_data * dtree)
+static void compress_block(const ct_data *ltree, const ct_data *dtree)
 {
         unsigned dist;          /* distance of matched string */
         int lc;                 /* match length or unmatched char (if dist == 0) */
@@ -1672,7 +1675,7 @@ static void compress_block(ct_data * ltree, ct_data * dtree)
  * trees or store, and output the encoded block to the zip file. This function
  * returns the total compressed length for the file so far.
  */
-static void flush_block(char *buf, ulg stored_len, int eof)
+static void flush_block(const char *buf, ulg stored_len, int eof)
 {
         ulg opt_lenb, static_lenb;      /* opt_len and static_len in bytes */
         int max_blindex;                /* index of last bit length code of non zero freq */
@@ -1919,7 +1922,7 @@ static void bi_init(void)
 /* ===========================================================================
  * Initialize the "longest match" routines for a new file
  */
-static void lm_init(unsigned *flags16p)
+static void lm_init(void)
 {
         unsigned j;
 
@@ -1927,8 +1930,6 @@ static void lm_init(unsigned *flags16p)
         memset(head, 0, HASH_SIZE * sizeof(*head));
         /* prev will be initialized on the fly */
 
-        /* speed options for the general purpose bit flag */
-        *flags16p |= 2; /* FAST 4, SLOW 2 */
         /* ??? reduce max_chain_length for binary files */
 
         //G1.strstart = 0; // globals are zeroed in pack_gzip()
@@ -2076,10 +2077,16 @@ static void zip(void)
 
         bi_init();
         ct_init();
-        deflate_flags = 0;  /* pkzip -es, -en or -ex equivalent */
-        lm_init(&deflate_flags);
+        lm_init();
 
-        put_16bit(deflate_flags | 0x300); /* extra flags. OS id = 3 (Unix) */
+        deflate_flags = 0x300; /* extra flags. OS id = 3 (Unix) */
+#if ENABLE_FEATURE_GZIP_LEVELS
+        /* Note that comp_level < 4 do not exist in this version of gzip */
+        if (comp_level_minus4 == 9 - 4) {
+                deflate_flags |= 0x02; /* SLOW flag */
+        }
+#endif
+        put_16bit(deflate_flags);
 
         /* The above 32-bit misaligns outbuf (10 bytes are stored), flush it */
         flush_outbuf_if_32bit_optimized();
@@ -2222,8 +2229,11 @@ int gzip_main(int argc UNUSED_PARAM, char **argv)
 #if ENABLE_FEATURE_GZIP_LEVELS
         opt >>= (BBUNPK_OPTSTRLEN IF_FEATURE_GZIP_DECOMPRESS(+ 2) + 1); /* drop cfkvq[dt]n bits */
         if (opt == 0)
-                opt = 1 << 6; /* default: 6 */
+                opt = 1 << 5; /* default: 6 */
         opt = ffs(opt >> 4); /* Maps -1..-4 to [0], -5 to [1] ... -9 to [5] */
+
+        comp_level_minus4 = opt;
+
         max_chain_length = 1 << gzip_level_config[opt].chain_shift;
         good_match       = gzip_level_config[opt].good;
         max_lazy_match   = gzip_level_config[opt].lazy2 * 2;
diff --git a/archival/libarchive/decompress_gunzip.c b/archival/libarchive/decompress_gunzip.c
index cf07f71df..c0332d414 100644
--- a/archival/libarchive/decompress_gunzip.c
+++ b/archival/libarchive/decompress_gunzip.c
@@ -39,7 +39,8 @@ typedef struct huft_t {
         unsigned char e;        /* number of extra bits or operation */
         unsigned char b;        /* number of bits in this code or subcode */
         union {
-                unsigned short n;       /* literal, length base, or distance base */
+                unsigned n;     /* literal, length base, or distance base */
+                /* ^^^^^ was "unsigned short", but that results in larger code */
                 struct huft_t *t;       /* pointer to next level of table */
         } v;
 } huft_t;
@@ -184,29 +185,26 @@ static const uint16_t mask_bits[] ALIGN2 = {
         0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
 };
 
-/* Copy lengths for literal codes 257..285 */
-static const uint16_t cplens[] ALIGN2 = {
-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
-        67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
+/* Put lengths/offsets and extra bits in a struct of arrays
+ * to make calls to huft_build() have one fewer parameter.
+ */
+struct cp_ext {
+        uint16_t cp[31];
+        uint8_t ext[31];
 };
-
+/* Copy lengths and extra bits for literal codes 257..285 */
 /* note: see note #13 above about the 258 in this list. */
-/* Extra bits for literal codes 257..285 */
-static const uint8_t cplext[] ALIGN1 = {
-        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5,
-        5, 5, 5, 0, 99, 99
-}; /* 99 == invalid */
-
-/* Copy offsets for distance codes 0..29 */
-static const uint16_t cpdist[] ALIGN2 = {
-        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
-        769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
+static const struct cp_ext lit = {
+        /*257 258 259 260 261 262 263 264 265 266 267 268 269 270 271  272  273  274  275  276   277   278   279   280   281   282   283    284    285 */
+        /*0   1   2   3   4   5   6   7   8   9   10  11  12  13   14   15   16   17   18   19    20    21    22    23    24    25    26     27     28     29  30 */
+        { 3,  4,  5,  6,  7,  8,  9,  10, 11, 13, 15, 17, 19, 23,  27,  31,  35,  43,  51,  59,   67,   83,   99,  115,  131,  163,  195,   227,   258,     0, 0  },
+        { 0,  0,  0,  0,  0,  0,  0,   0,  1,  1,  1,  1,  2,  2,   2,   2,   3,   3,   3,   3,    4,    4,    4,    4,    5,    5,    5,     5,     0,    99, 99 } /* 99 == invalid */
 };
-
-/* Extra bits for distance codes */
-static const uint8_t cpdext[] ALIGN1 = {
-        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
-        11, 11, 12, 12, 13, 13
+/* Copy offsets and extra bits for distance codes 0..29 */
+static const struct cp_ext dist = {
+        /*0   1   2   3   4   5   6   7   8   9   10  11  12  13   14   15   16   17   18   19    20    21    22    23    24    25    26     27     28     29 */
+        { 1,  2,  3,  4,  5,  7,  9,  13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 },
+        { 0,  0,  0,  0,  1,  1,  2,   2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7,   8,   8,    9,    9,   10,   10,   11,   11,   12,    12,    13,    13 }
 };
 
 /* Tables for deflate from PKZIP's appnote.txt. */
@@ -277,22 +275,25 @@ static unsigned fill_bitbuffer(STATE_PARAM unsigned bitbuffer, unsigned *current
 
 
 /* Given a list of code lengths and a maximum table size, make a set of
- * tables to decode that set of codes.  Return zero on success, one if
- * the given code set is incomplete (the tables are still built in this
- * case), two if the input is invalid (an oversubscribed set of lengths)
- * - in this case stores NULL in *t.
+ * tables to decode that set of codes.
  *
  * b:   code lengths in bits (all assumed <= BMAX)
  * n:   number of codes (assumed <= N_MAX)
  * s:   number of simple-valued codes (0..s-1)
- * d:   list of base values for non-simple codes
- * e:   list of extra bits for non-simple codes
- * t:   result: starting table
+ * cp_ext->cp,ext: list of base values/extra bits for non-simple codes
  * m:   maximum lookup bits, returns actual
+ * result: starting table
+ *
+ * On error, returns a value with lowest-bit set on error.
+ * It can be just the value of 0x1,
+ * or a valid pointer to a Huffman table, ORed with 0x1 if incompete table
+ * is given: "fixed inflate" decoder feeds us such data.
  */
-static int huft_build(const unsigned *b, const unsigned n,
-                        const unsigned s, const unsigned short *d,
-                        const unsigned char *e, huft_t **t, unsigned *m)
+#define BAD_HUFT(p) ((uintptr_t)(p) & 1)
+#define ERR_RET     ((huft_t*)(uintptr_t)1)
+static huft_t* huft_build(const unsigned *b, const unsigned n,
+                        const unsigned s, const struct cp_ext *cp_ext,
+                        unsigned *m)
 {
         unsigned a;             /* counter for codes of length k */
         unsigned c[BMAX + 1];   /* bit length count table */
@@ -314,12 +315,12 @@ static int huft_build(const unsigned *b, const unsigned n,
         unsigned *xp;           /* pointer into x */
         int y;                  /* number of dummy codes added */
         unsigned z;             /* number of entries in current table */
+        huft_t *result;
+        huft_t **t;
 
         /* Length of EOB code, if any */
         eob_len = n > 256 ? b[256] : BMAX;
 
-        *t = NULL;
-
         /* Generate counts for each bit length */
         memset(c, 0, sizeof(c));
         p = b;
@@ -335,9 +336,8 @@ static int huft_build(const unsigned *b, const unsigned n,
                 q[1].b = 1;
                 q[2].e = 99;    /* invalid code marker */
                 q[2].b = 1;
-                *t = q + 1;
                 *m = 1;
-                return 0;
+                return q + 1;
         }
 
         /* Find minimum and maximum length, bound *m by those */
@@ -353,11 +353,11 @@ static int huft_build(const unsigned *b, const unsigned n,
         for (y = 1 << j; j < i; j++, y <<= 1) {
                 y -= c[j];
                 if (y < 0)
-                        return 2; /* bad input: more codes than bits */
+                        return ERR_RET; /* bad input: more codes than bits */
         }
         y -= c[i];
         if (y < 0)
-                return 2;
+                return ERR_RET;
         c[i] += y;
 
         /* Generate starting offsets into the value table for each length */
@@ -384,6 +384,8 @@ static int huft_build(const unsigned *b, const unsigned n,
         } while (++i < n);
 
         /* Generate the Huffman codes and for each, make the table entries */
+        result = ERR_RET;
+        t = &result;
         x[0] = i = 0;   /* first Huffman code is zero */
         p = v;          /* grab values in bit order */
         htl = -1;       /* no tables yet--level -1 */
@@ -449,8 +451,8 @@ static int huft_build(const unsigned *b, const unsigned n,
                                 r.e = (unsigned char) (*p < 256 ? 16 : 15);     /* 256 is EOB code */
                                 r.v.n = (unsigned short) (*p++); /* simple code is just the value */
                         } else {
-                                r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */
-                                r.v.n = d[*p++ - s];
+                                r.e = (unsigned char) cp_ext->ext[*p - s]; /* non-simple--look up in lists */
+                                r.v.n = cp_ext->cp[*p++ - s];
                         }
 
                         /* fill code-like entries with r */
@@ -475,8 +477,11 @@ static int huft_build(const unsigned *b, const unsigned n,
         /* return actual size of base table */
         *m = ws[1];
 
-        /* Return 1 if we were given an incomplete table */
-        return y != 0 && g != 1;
+        if (y != 0 && g != 1) /* we were given an incomplete table */
+                /* return "result" ORed with 1 */
+                return (void*)((uintptr_t)result | 1);
+
+        return result;
 }
 
 
@@ -777,14 +782,17 @@ static int inflate_block(STATE_PARAM smallint *e)
                 for (; i < 288; i++) /* make a complete, but wrong code set */
                         ll[i] = 8;
                 bl = 7;
-                huft_build(ll, 288, 257, cplens, cplext, &inflate_codes_tl, &bl);
-                /* huft_build() never return nonzero - we use known data */
+                inflate_codes_tl = huft_build(ll, 288, 257, &lit, &bl);
+                /* ^^^ never returns error here - we use known data */
 
                 /* set up distance table */
                 for (i = 0; i < 30; i++) /* make an incomplete code set */
                         ll[i] = 5;
                 bd = 5;
-                huft_build(ll, 30, 0, cpdist, cpdext, &inflate_codes_td, &bd);
+                inflate_codes_td = huft_build(ll, 30, 0, &dist, &bd);
+                /* ^^^ does return error here! (lsb bit is set) - we gave it incomplete code set */
+                /* clearing error bit: */
+                inflate_codes_td = (void*)((uintptr_t)inflate_codes_td & ~(uintptr_t)1);
 
                 /* set up data for inflate_codes() */
                 inflate_codes_setup(PASS_STATE bl, bd);
@@ -850,9 +858,9 @@ static int inflate_block(STATE_PARAM smallint *e)
 
                 /* build decoding table for trees - single level, 7 bit lookup */
                 bl = 7;
-                i = huft_build(ll, 19, 19, NULL, NULL, &inflate_codes_tl, &bl);
-                if (i != 0) {
-                        abort_unzip(PASS_STATE_ONLY); //return i;       /* incomplete code set */
+                inflate_codes_tl = huft_build(ll, 19, 19, NULL, &bl);
+                if (BAD_HUFT(inflate_codes_tl)) {
+                        abort_unzip(PASS_STATE_ONLY);   /* incomplete code set */
                 }
 
                 /* read in literal and distance code lengths */
@@ -915,14 +923,13 @@ static int inflate_block(STATE_PARAM smallint *e)
 
                 /* build the decoding tables for literal/length and distance codes */
                 bl = lbits;
-
-                i = huft_build(ll, nl, 257, cplens, cplext, &inflate_codes_tl, &bl);
-                if (i != 0) {
+                inflate_codes_tl = huft_build(ll, nl, 257, &lit, &bl);
+                if (BAD_HUFT(inflate_codes_tl)) {
                         abort_unzip(PASS_STATE_ONLY);
                 }
                 bd = dbits;
-                i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &inflate_codes_td, &bd);
-                if (i != 0) {
+                inflate_codes_td = huft_build(ll + nl, nd, 0, &dist, &bd);
+                if (BAD_HUFT(inflate_codes_td)) {
                         abort_unzip(PASS_STATE_ONLY);
                 }
 
diff --git a/archival/libarchive/decompress_unxz.c b/archival/libarchive/decompress_unxz.c
index f03341384..3dd9bbf49 100644
--- a/archival/libarchive/decompress_unxz.c
+++ b/archival/libarchive/decompress_unxz.c
@@ -96,6 +96,24 @@ unpack_xz_stream(transformer_state_t *xstate)
                          */
                         do {
                                 if (membuf[iobuf.in_pos] != 0) {
+                                        /* There is more data, but is it XZ data?
+                                         * Example: dpkg-deb -f busybox_1.30.1-4_amd64.deb
+                                         * reads control.tar.xz "control" file
+                                         * inside the ar archive, but tar.xz
+                                         * extraction code reaches end of xz data,
+                                         * reached this code and reads the beginning
+                                         * of data.tar.xz's ar header, which isn't xz data,
+                                         * and prints "corrupted data".
+                                         * The correct solution is to not read
+                                         * past nested archive (to simulate EOF).
+                                         * This is a workaround:
+                                         */
+                                        if (membuf[iobuf.in_pos] != 0xfd) {
+                                                /* It's definitely not a xz signature
+                                                 * (which is 0xfd,"7zXZ",0x00).
+                                                 */
+                                                goto end;
+                                        }
                                         xz_dec_reset(state);
                                         goto do_run;
                                 }
@@ -128,7 +146,7 @@ unpack_xz_stream(transformer_state_t *xstate)
                         break;
                 }
         }
-
+ end:
         xz_dec_end(state);
         free(membuf);
 
diff --git a/archival/libarchive/unxz/xz_stream.h b/archival/libarchive/unxz/xz_stream.h
index 66cb5a705..45056e42c 100644
--- a/archival/libarchive/unxz/xz_stream.h
+++ b/archival/libarchive/unxz/xz_stream.h
@@ -25,7 +25,7 @@
 
 #define STREAM_HEADER_SIZE 12
 
-#define HEADER_MAGIC "\3757zXZ"
+#define HEADER_MAGIC "\375""7zXZ"
 #define HEADER_MAGIC_SIZE 6
 
 #define FOOTER_MAGIC "YZ"
diff --git a/archival/tar.c b/archival/tar.c
index 6618c9ecc..c57bff779 100644
--- a/archival/tar.c
+++ b/archival/tar.c
@@ -1066,7 +1066,7 @@ int tar_main(int argc UNUSED_PARAM, char **argv)
                 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
-                ":\xf9+" // --strip-components=NUM
+                ":\xf8+" // --strip-components=NUM
 #endif
                 LONGOPTS
                 , &base_dir // -C dir