1 /* vi: set sw=4 ts=4: */
3 * gunzip implementation for busybox
5 * Based on GNU gzip v1.2.4 Copyright (C) 1992-1993 Jean-loup Gailly.
7 * Originally adjusted for busybox by Sven Rudolph <sr1@inf.tu-dresden.de>
8 * based on gzip sources
10 * Adjusted further by Erik Andersen <andersee@debian.org> to support
11 * files as well as stdin/stdout, and to generally behave itself wrt
12 * command line handling.
14 * General cleanup to better adhere to the style guide and make use of standard
15 * busybox functions by Glenn McGrath <bug1@optushome.com.au>
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
33 * Copyright (C) 1992-1993 Jean-loup Gailly
34 * The unzip code was written and put in the public domain by Mark Adler.
35 * Portions of the lzw code are derived from the public domain 'compress'
36 * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
37 * Ken Turkowski, Dave Mack and Peter Jannesen.
39 * See the license_msg below and the file COPYING for the software license.
40 * See the file algorithm.doc for the compression algorithms and file formats.
44 static char *license_msg[] = {
45 " Copyright (C) 1992-1993 Jean-loup Gailly",
46 " This program is free software; you can redistribute it and/or modify",
47 " it under the terms of the GNU General Public License as published by",
48 " the Free Software Foundation; either version 2, or (at your option)",
49 " any later version.",
51 " This program is distributed in the hope that it will be useful,",
52 " but WITHOUT ANY WARRANTY; without even the implied warranty of",
53 " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
54 " GNU General Public License for more details.",
56 " You should have received a copy of the GNU General Public License",
57 " along with this program; if not, write to the Free Software",
58 " Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",
63 #include <sys/types.h>
72 #include "unarchive.h"
74 typedef struct huft_s {
75 unsigned char e; /* number of extra bits or operation */
76 unsigned char b; /* number of bits in this code or subcode */
78 unsigned short n; /* literal, length base, or distance base */
79 struct huft_s *t; /* pointer to next level of table */
83 static int gunzip_src_fd;
84 unsigned int gunzip_bytes_out; /* number of output bytes */
85 static unsigned int gunzip_outbuf_count; /* bytes in output buffer */
87 /* This is used to sanify any unused bits from the bitbuffer
88 * so they arent skipped when reading trailers (trailing headers) */
89 unsigned char gunzip_in_buffer_count;
90 unsigned char *gunzip_in_buffer;
92 /* gunzip_window size--must be a power of two, and
93 * at least 32K for zip's deflate method */
94 static const int gunzip_wsize = 0x8000;
95 static int output_buffer_size = 0x8000; // gunzip_wsize initially
97 static unsigned char *gunzip_window;
98 static unsigned int *gunzip_crc_table;
99 unsigned int gunzip_crc;
101 static unsigned char *output_buffer;
102 static unsigned int output_buffer_len;
104 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
105 #define BMAX 16 /* maximum bit length of any code (16 for explode) */
106 #define N_MAX 288 /* maximum number of codes in any set */
108 static unsigned int gunzip_hufts; /* track memory usage */
109 static unsigned int gunzip_bb; /* bit buffer */
110 static unsigned char gunzip_bk; /* bits in bit buffer */
112 static const unsigned short mask_bits[] = {
113 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
114 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
117 /* Copy lengths for literal codes 257..285 */
118 static const unsigned short cplens[] = {
119 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
120 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
123 /* note: see note #13 above about the 258 in this list. */
124 /* Extra bits for literal codes 257..285 */
125 static const unsigned char cplext[] = {
126 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,
130 /* Copy offsets for distance codes 0..29 */
131 static const unsigned short cpdist[] = {
132 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
133 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
136 /* Extra bits for distance codes */
137 static const unsigned char cpdext[] = {
138 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
139 11, 11, 12, 12, 13, 13
142 /* Tables for deflate from PKZIP's appnote.txt. */
143 /* Order of the bit length code lengths */
144 static const unsigned char border[] = {
145 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
148 static unsigned int fill_bitbuffer(unsigned int bitbuffer, unsigned int *current, const unsigned int required)
150 while (*current < required) {
151 bitbuffer |= ((unsigned int) xread_char(gunzip_src_fd)) << *current;
158 static void make_gunzip_crc_table(void)
160 const unsigned int poly = 0xedb88320; /* polynomial exclusive-or pattern */
161 unsigned short i; /* counter for all possible eight bit values */
163 /* initial shift register value */
164 gunzip_crc = 0xffffffffL;
165 gunzip_crc_table = (unsigned int *) malloc(256 * sizeof(unsigned int));
167 /* Compute and print table of CRC's, five per line */
168 for (i = 0; i < 256; i++) {
169 unsigned int table_entry; /* crc shift register */
170 unsigned char k; /* byte being shifted into crc apparatus */
173 /* The idea to initialize the register with the byte instead of
174 * zero was stolen from Haruhiko Okumura's ar002
176 for (k = 8; k; k--) {
177 if (table_entry & 1) {
178 table_entry = (table_entry >> 1) ^ poly;
183 gunzip_crc_table[i] = table_entry;
188 * Free the malloc'ed tables built by huft_build(), which makes a linked
189 * list of the tables it made, with the links in a dummy first entry of
193 static int huft_free(huft_t * t)
198 /* Go through linked list, freeing from the malloced (t[-1]) address. */
200 while (p != (huft_t *) NULL) {
208 /* Given a list of code lengths and a maximum table size, make a set of
209 * tables to decode that set of codes. Return zero on success, one if
210 * the given code set is incomplete (the tables are still built in this
211 * case), two if the input is invalid (all zero length codes or an
212 * oversubscribed set of lengths), and three if not enough memory.
214 * b: code lengths in bits (all assumed <= BMAX)
215 * n: number of codes (assumed <= N_MAX)
216 * s: number of simple-valued codes (0..s-1)
217 * d: list of base values for non-simple codes
218 * e: list of extra bits for non-simple codes
219 * t: result: starting table
220 * m: maximum lookup bits, returns actual
222 static int huft_build(unsigned int *b, const unsigned int n,
223 const unsigned int s, const unsigned short *d,
224 const unsigned char *e, huft_t ** t, int *m)
226 unsigned a; /* counter for codes of length k */
227 unsigned c[BMAX + 1]; /* bit length count table */
228 unsigned f; /* i repeats in table every f entries */
229 int g; /* maximum code length */
230 int h; /* table level */
231 register unsigned i; /* counter, current code */
232 register unsigned j; /* counter */
233 register int k; /* number of bits in current code */
234 int l; /* bits per table (returned in m) */
235 register unsigned *p; /* pointer into c[], b[], or v[] */
236 register huft_t *q; /* points to current table */
237 huft_t r; /* table entry for structure assignment */
238 huft_t *u[BMAX]; /* table stack */
239 unsigned v[N_MAX]; /* values in order of bit length */
240 register int w; /* bits before this table == (l * h) */
241 unsigned x[BMAX + 1]; /* bit offsets, then code stack */
242 unsigned *xp; /* pointer into x */
243 int y; /* number of dummy codes added */
244 unsigned z; /* number of entries in current table */
246 /* Generate counts for each bit length */
247 memset((void *) (c), 0, sizeof(c));
251 c[*p]++; /* assume all entries <= BMAX */
252 p++; /* Can't combine with above line (Solaris bug) */
254 if (c[0] == n) { /* null input--all zero length codes */
255 *t = (huft_t *) NULL;
260 /* Find minimum and maximum length, bound *m by those */
262 for (j = 1; j <= BMAX; j++) {
267 k = j; /* minimum code length */
268 if ((unsigned) l < j) {
271 for (i = BMAX; i; i--) {
276 g = i; /* maximum code length */
277 if ((unsigned) l > i) {
282 /* Adjust last length count to fill out codes, if needed */
283 for (y = 1 << j; j < i; j++, y <<= 1) {
284 if ((y -= c[j]) < 0) {
285 return 2; /* bad input: more codes than bits */
288 if ((y -= c[i]) < 0) {
293 /* Generate starting offsets into the value table for each length */
297 while (--i) { /* note that i == g from above */
301 /* Make a table of values in order of bit lengths */
305 if ((j = *p++) != 0) {
310 /* Generate the Huffman codes and for each, make the table entries */
311 x[0] = i = 0; /* first Huffman code is zero */
312 p = v; /* grab values in bit order */
313 h = -1; /* no tables yet--level -1 */
314 w = -l; /* bits decoded == (l * h) */
315 u[0] = (huft_t *) NULL; /* just to keep compilers happy */
316 q = (huft_t *) NULL; /* ditto */
319 /* go through the bit lengths (k already is bits in shortest code) */
320 for (; k <= g; k++) {
323 /* here i is the Huffman code of length k bits for value *p */
324 /* make tables up to required level */
327 w += l; /* previous table always l bits */
329 /* compute minimum size table less than or equal to l bits */
330 z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
331 if ((f = 1 << (j = k - w)) > a + 1) { /* try a k-w bit table *//* too few codes for k-w bit table */
332 f -= a + 1; /* deduct codes from patterns left */
334 while (++j < z) { /* try smaller tables up to z bits */
335 if ((f <<= 1) <= *++xp) {
336 break; /* enough codes to use up j bits */
338 f -= *xp; /* else deduct codes from patterns */
341 z = 1 << j; /* table entries for j-bit table */
343 /* allocate and link in new table */
344 q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t));
346 gunzip_hufts += z + 1; /* track memory usage */
347 *t = q + 1; /* link to list for huft_free() */
348 *(t = &(q->v.t)) = NULL;
349 u[h] = ++q; /* table starts after link */
351 /* connect to last table, if there is one */
353 x[h] = i; /* save pattern for backing up */
354 r.b = (unsigned char) l; /* bits to dump before this table */
355 r.e = (unsigned char) (16 + j); /* bits in this table */
356 r.v.t = q; /* pointer to this table */
357 j = i >> (w - l); /* (get around Turbo C bug) */
358 u[h - 1][j] = r; /* connect to last table */
362 /* set up table entry in r */
363 r.b = (unsigned char) (k - w);
365 r.e = 99; /* out of values--invalid code */
367 r.e = (unsigned char) (*p < 256 ? 16 : 15); /* 256 is end-of-block code */
368 r.v.n = (unsigned short) (*p); /* simple code is just the value */
369 p++; /* one compiler does not like *p++ */
371 r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */
375 /* fill code-like entries with r */
377 for (j = i >> w; j < z; j += f) {
381 /* backwards increment the k-bit code i */
382 for (j = 1 << (k - 1); i & j; j >>= 1) {
387 /* backup over finished tables */
388 while ((i & ((1 << w) - 1)) != x[h]) {
389 h--; /* don't need to update q */
394 /* Return true (1) if we were given an incomplete table */
395 return y != 0 && g != 1;
398 /* ===========================================================================
399 * Write the output gunzip_window gunzip_window[0..gunzip_outbuf_count-1] and update crc and gunzip_bytes_out.
400 * (Used for the decompressed data only.)
402 static void flush_gunzip_window(void)
406 for (n = 0; n < gunzip_outbuf_count; n++) {
407 gunzip_crc = gunzip_crc_table[((int) gunzip_crc ^ (gunzip_window[n])) & 0xff] ^ (gunzip_crc >> 8);
410 if (output_buffer_len == 0) { // Our buffer is empty -> straight memcpy
411 memcpy(output_buffer, gunzip_window, gunzip_outbuf_count);
412 output_buffer_len = gunzip_outbuf_count;
413 } else { // Bit more complicated, append to end of output_buffer, realloc as necessary
414 int newlen = output_buffer_len + gunzip_outbuf_count;
415 if (newlen > output_buffer_size) {
416 output_buffer = xrealloc(output_buffer, newlen); // Could free later, but as we now have the memory...
417 //printf("Using %d byte output buffer\n", newlen);
418 output_buffer_size = newlen;
420 memcpy(output_buffer + output_buffer_len, gunzip_window, gunzip_outbuf_count);
421 output_buffer_len += gunzip_outbuf_count;
424 gunzip_bytes_out += gunzip_outbuf_count;
425 gunzip_outbuf_count = 0;
429 * inflate (decompress) the codes in a deflated (compressed) block.
430 * Return an error code or zero if it all goes ok.
432 * tl, td: literal/length and distance decoder tables
433 * bl, bd: number of bits decoded by tl[] and td[]
435 static int inflate_codes(huft_t * my_tl, huft_t * my_td, const unsigned int my_bl, const unsigned int my_bd, int setup)
437 static unsigned int e; /* table entry flag/number of extra bits */
438 static unsigned int n, d; /* length and index for copy */
439 static unsigned int w; /* current gunzip_window position */
440 static huft_t *t; /* pointer to table entry */
441 static unsigned int ml, md; /* masks for bl and bd bits */
442 static unsigned int b; /* bit buffer */
443 static unsigned int k; /* number of bits in bit buffer */
444 static huft_t *tl, *td;
445 static unsigned int bl, bd;
446 static int resumeCopy = 0;
448 if (setup) { // 1st time we are called, copy in variables
453 /* make local copies of globals */
454 b = gunzip_bb; /* initialize bit buffer */
456 w = gunzip_outbuf_count; /* initialize gunzip_window position */
458 /* inflate the coded data */
459 ml = mask_bits[bl]; /* precompute masks for speed */
461 return 0; // Don't actually do anything the first time
464 if (resumeCopy) goto do_copy;
466 while (1) { /* do until end of block */
467 b = fill_bitbuffer(b, &k, bl);
468 if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
476 b = fill_bitbuffer(b, &k, e);
478 (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
481 if (e == 16) { /* then it's a literal */
482 gunzip_window[w++] = (unsigned char) t->v.n;
483 if (w == gunzip_wsize) {
484 gunzip_outbuf_count = (w);
485 //flush_gunzip_window();
489 } else { /* it's an EOB or a length */
491 /* exit if end of block */
496 /* get length of block to copy */
497 b = fill_bitbuffer(b, &k, e);
498 n = t->v.n + ((unsigned) b & mask_bits[e]);
502 /* decode distance of block to copy */
503 b = fill_bitbuffer(b, &k, bd);
504 if ((e = (t = td + ((unsigned) b & md))->e) > 16)
511 b = fill_bitbuffer(b, &k, e);
514 t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
517 b = fill_bitbuffer(b, &k, e);
518 d = w - t->v.n - ((unsigned) b & mask_bits[e]);
526 gunzip_wsize - ((d &= gunzip_wsize - 1) > w ? d : w)) > n ? n : e);
527 /* copy to new buffer to prevent possible overwrite */
528 if (w - d >= e) { /* (this test assumes unsigned comparison) */
529 memcpy(gunzip_window + w, gunzip_window + d, e);
533 /* do it slow to avoid memcpy() overlap */
536 gunzip_window[w++] = gunzip_window[d++];
539 if (w == gunzip_wsize) {
540 gunzip_outbuf_count = (w);
541 if (n) resumeCopy = 1;
543 //flush_gunzip_window();
552 /* restore the globals from the locals */
553 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */
554 gunzip_bb = b; /* restore global bit buffer */
557 /* normally just after call to inflate_codes, but save code by putting it here */
558 /* free the decoding tables, return */
566 int inflate_stored(int my_n, int my_b_stored, int my_k_stored, int setup)
568 static int n, b_stored, k_stored, w;
571 b_stored = my_b_stored;
572 k_stored = my_k_stored;
573 w = gunzip_outbuf_count; /* initialize gunzip_window position */
574 return 0; // Don't do anything first time
577 /* read and output the compressed data */
579 b_stored = fill_bitbuffer(b_stored, &k_stored, 8);
580 gunzip_window[w++] = (unsigned char) b_stored;
581 if (w == (unsigned int) gunzip_wsize) {
582 gunzip_outbuf_count = (w);
583 //flush_gunzip_window();
587 return -1; // Means more stuff 2do
593 /* restore the globals from the locals */
594 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */
595 gunzip_bb = b_stored; /* restore global bit buffer */
596 gunzip_bk = k_stored;
597 return 0; // Finished
601 * decompress an inflated block
604 * GLOBAL VARIABLES: bb, kk,
606 // Return values: -1 = inflate_stored, -2 = inflate_codes
607 static int inflate_block(int *e)
609 unsigned t; /* block type */
610 register unsigned int b; /* bit buffer */
611 unsigned int k; /* number of bits in bit buffer */
613 /* make local bit buffer */
618 /* read in last block bit */
619 b = fill_bitbuffer(b, &k, 1);
624 /* read in block type */
625 b = fill_bitbuffer(b, &k, 2);
626 t = (unsigned) b & 3;
630 /* restore the global bit buffer */
634 /* inflate that block type */
636 case 0: /* Inflate stored */
638 unsigned int n; /* number of bytes in block */
639 unsigned int b_stored; /* bit buffer */
640 unsigned int k_stored; /* number of bits in bit buffer */
642 /* make local copies of globals */
643 b_stored = gunzip_bb; /* initialize bit buffer */
644 k_stored = gunzip_bk;
646 /* go to byte boundary */
651 /* get the length and its complement */
652 b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
653 n = ((unsigned) b_stored & 0xffff);
657 b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
658 if (n != (unsigned) ((~b_stored) & 0xffff)) {
659 return 1; /* error in compressed data */
664 inflate_stored(n, b_stored, k_stored, 1); // Setup inflate_stored
667 case 1: /* Inflate fixed
668 * decompress an inflated type 1 (fixed Huffman codes) block. We should
669 * either replace this with a custom decoder, or at least precompute the
673 int i; /* temporary variable */
674 huft_t *tl; /* literal/length code table */
675 huft_t *td; /* distance code table */
676 unsigned int bl; /* lookup bits for tl */
677 unsigned int bd; /* lookup bits for td */
678 unsigned int l[288]; /* length list for huft_build */
680 /* set up literal table */
681 for (i = 0; i < 144; i++) {
684 for (; i < 256; i++) {
687 for (; i < 280; i++) {
690 for (; i < 288; i++) { /* make a complete, but wrong code set */
694 if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
698 /* set up distance table */
699 for (i = 0; i < 30; i++) { /* make an incomplete code set */
703 if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
708 /* decompress until an end-of-block code */
709 inflate_codes(tl, td, bl, bd, 1); // Setup inflate_codes
711 /* huft_free code moved into inflate_codes */
715 case 2: /* Inflate dynamic */
717 const int dbits = 6; /* bits in base distance lookup table */
718 const int lbits = 9; /* bits in base literal/length lookup table */
720 huft_t *tl; /* literal/length code table */
721 huft_t *td; /* distance code table */
722 unsigned int i; /* temporary variables */
724 unsigned int l; /* last length */
725 unsigned int m; /* mask for bit lengths table */
726 unsigned int n; /* number of lengths to get */
727 unsigned int bl; /* lookup bits for tl */
728 unsigned int bd; /* lookup bits for td */
729 unsigned int nb; /* number of bit length codes */
730 unsigned int nl; /* number of literal/length codes */
731 unsigned int nd; /* number of distance codes */
733 unsigned int ll[286 + 30]; /* literal/length and distance code lengths */
734 unsigned int b_dynamic; /* bit buffer */
735 unsigned int k_dynamic; /* number of bits in bit buffer */
737 /* make local bit buffer */
738 b_dynamic = gunzip_bb;
739 k_dynamic = gunzip_bk;
741 /* read in table lengths */
742 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
743 nl = 257 + ((unsigned int) b_dynamic & 0x1f); /* number of literal/length codes */
747 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
748 nd = 1 + ((unsigned int) b_dynamic & 0x1f); /* number of distance codes */
752 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 4);
753 nb = 4 + ((unsigned int) b_dynamic & 0xf); /* number of bit length codes */
757 if (nl > 286 || nd > 30) {
758 return 1; /* bad lengths */
761 /* read in bit-length-code lengths */
762 for (j = 0; j < nb; j++) {
763 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
764 ll[border[j]] = (unsigned int) b_dynamic & 7;
768 for (; j < 19; j++) {
772 /* build decoding table for trees--single level, 7 bit lookup */
774 i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl);
779 return i; /* incomplete code set */
782 /* read in literal and distance code lengths */
786 while ((unsigned int) i < n) {
787 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, (unsigned int)bl);
788 j = (td = tl + ((unsigned int) b_dynamic & m))->b;
792 if (j < 16) { /* length of code in bits (0..15) */
793 ll[i++] = l = j; /* save last length in l */
794 } else if (j == 16) { /* repeat last length 3 to 6 times */
795 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 2);
796 j = 3 + ((unsigned int) b_dynamic & 3);
799 if ((unsigned int) i + j > n) {
805 } else if (j == 17) { /* 3 to 10 zero length codes */
806 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
807 j = 3 + ((unsigned int) b_dynamic & 7);
810 if ((unsigned int) i + j > n) {
817 } else { /* j == 18: 11 to 138 zero length codes */
818 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 7);
819 j = 11 + ((unsigned int) b_dynamic & 0x7f);
822 if ((unsigned int) i + j > n) {
832 /* free decoding table for trees */
835 /* restore the global bit buffer */
836 gunzip_bb = b_dynamic;
837 gunzip_bk = k_dynamic;
839 /* build the decoding tables for literal/length and distance codes */
842 if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
844 error_msg_and_die("Incomplete literal tree");
847 return i; /* incomplete code set */
851 if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
853 error_msg_and_die("incomplete distance tree");
857 return i; /* incomplete code set */
860 /* decompress until an end-of-block code */
861 inflate_codes(tl, td, bl, bd, 1); // Setup inflate_codes
863 /* huft_free code moved into inflate_codes */
869 error_msg("bad block type %d\n", t);
875 * decompress an inflated entry
877 * GLOBAL VARIABLES: gunzip_outbuf_count, bk, gunzip_bb, hufts, inptr
880 extern ssize_t read_gz(int fd, void *buf, size_t count)
882 static int e = 0; /* last block flag */
883 int r; /* result code */
884 unsigned h = 0; /* maximum struct huft's malloc'ed */
885 ssize_t written = count;
886 static char *output_buffer_ptr = 0;
888 while (output_buffer_len == 0) { // We need more data
889 if (e) return 0; // No more data here!
891 r = inflate_block(&e);
892 if (r == -1) { // Call inflate_stored while returning -1
893 while(inflate_stored(0,0,0,0) == -1) flush_gunzip_window();
894 } else if (r == -2) { // Call inflate_codes while returning -1
895 while(inflate_codes(0,0,0,0,0) == -1) flush_gunzip_window();
897 error_msg_and_die("inflate error %d", r);
900 if (gunzip_hufts > h) {
903 if (e) { // Ok finished uncompressing, get any buffered uncompressed data
904 flush_gunzip_window();
906 output_buffer_ptr = output_buffer;
908 if (count > output_buffer_len) written = output_buffer_len; // We're only giving them as much as we have!
909 memcpy(buf, output_buffer_ptr, written);
910 output_buffer_ptr += written;
911 output_buffer_len -= written;
916 extern void GZ_gzReadOpen(int fd, void *unused, int nUnused)
918 typedef void (*sig_type) (int);
920 /* Allocate all global buffers (for DYN_ALLOC option) */
921 gunzip_window = xmalloc(gunzip_wsize);
922 output_buffer = xmalloc(gunzip_wsize);
923 gunzip_outbuf_count = 0;
924 gunzip_bytes_out = 0;
927 gunzip_in_buffer = malloc(8);
929 /* initialize gunzip_window, bit buffer */
933 /* Create the crc table */
934 make_gunzip_crc_table();
937 extern void GZ_gzReadClose(void)
942 free(gunzip_crc_table);
944 /* Store unused bytes in a global buffer so calling applets can access it */
945 gunzip_in_buffer_count = 0;
946 if (gunzip_bk >= 8) {
947 /* Undo too much lookahead. The next read will be byte aligned
948 * so we can discard unused bits in the last meaningful byte. */
949 gunzip_in_buffer[gunzip_in_buffer_count] = gunzip_bb & 0xff;
950 gunzip_in_buffer_count++;
956 extern int inflate(int in, int out)
959 ssize_t nread, nwrote;
962 GZ_gzReadOpen(in, 0, 0);
963 while(1) { // Robbed from copyfd.c
964 nread = read_gz(in, buf, sizeof(buf));
965 if (nread == 0) break; // no data to write
966 else if (nread == -1) {
970 nwrote = full_write(out, buf, nread);