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 static int gunzip_dst_fd;
85 unsigned int gunzip_bytes_out; /* number of output bytes */
86 static unsigned int gunzip_outbuf_count; /* bytes in output buffer */
88 /* This is used to sanify any unused bits from the bitbuffer
89 * so they arent skipped when reading trailers (trailing headers) */
90 unsigned char gunzip_in_buffer_count;
91 unsigned char *gunzip_in_buffer;
93 /* gunzip_window size--must be a power of two, and
94 * at least 32K for zip's deflate method */
95 static const int gunzip_wsize = 0x8000;
97 static unsigned char *gunzip_window;
98 static unsigned int *gunzip_crc_table;
99 unsigned int gunzip_crc;
101 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
102 #define BMAX 16 /* maximum bit length of any code (16 for explode) */
103 #define N_MAX 288 /* maximum number of codes in any set */
105 static unsigned int gunzip_hufts; /* track memory usage */
106 static unsigned int gunzip_bb; /* bit buffer */
107 static unsigned char gunzip_bk; /* bits in bit buffer */
109 static const unsigned short mask_bits[] = {
110 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
111 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
114 /* Copy lengths for literal codes 257..285 */
115 static const unsigned short cplens[] = {
116 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
117 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
120 /* note: see note #13 above about the 258 in this list. */
121 /* Extra bits for literal codes 257..285 */
122 static const unsigned char cplext[] = {
123 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,
127 /* Copy offsets for distance codes 0..29 */
128 static const unsigned short cpdist[] = {
129 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
130 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
133 /* Extra bits for distance codes */
134 static const unsigned char cpdext[] = {
135 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
136 11, 11, 12, 12, 13, 13
139 /* Tables for deflate from PKZIP's appnote.txt. */
140 /* Order of the bit length code lengths */
141 static const unsigned char border[] = {
142 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
145 static unsigned int fill_bitbuffer(unsigned int bitbuffer, unsigned int *current, const unsigned int required)
147 while (*current < required) {
148 bitbuffer |= ((unsigned int) xread_char(gunzip_src_fd)) << *current;
155 static void abort_gzip(void)
157 error_msg("gzip aborted\n");
161 static void make_gunzip_crc_table(void)
163 const unsigned int poly = 0xedb88320; /* polynomial exclusive-or pattern */
164 unsigned short i; /* counter for all possible eight bit values */
166 /* initial shift register value */
167 gunzip_crc = 0xffffffffL;
168 gunzip_crc_table = (unsigned int *) malloc(256 * sizeof(unsigned int));
170 /* Compute and print table of CRC's, five per line */
171 for (i = 0; i < 256; i++) {
172 unsigned int table_entry; /* crc shift register */
173 unsigned char k; /* byte being shifted into crc apparatus */
176 /* The idea to initialize the register with the byte instead of
177 * zero was stolen from Haruhiko Okumura's ar002
179 for (k = 8; k; k--) {
180 if (table_entry & 1) {
181 table_entry = (table_entry >> 1) ^ poly;
186 gunzip_crc_table[i] = table_entry;
191 * Free the malloc'ed tables built by huft_build(), which makes a linked
192 * list of the tables it made, with the links in a dummy first entry of
196 static int huft_free(huft_t * t)
201 /* Go through linked list, freeing from the malloced (t[-1]) address. */
203 while (p != (huft_t *) NULL) {
211 /* Given a list of code lengths and a maximum table size, make a set of
212 * tables to decode that set of codes. Return zero on success, one if
213 * the given code set is incomplete (the tables are still built in this
214 * case), two if the input is invalid (all zero length codes or an
215 * oversubscribed set of lengths), and three if not enough memory.
217 * b: code lengths in bits (all assumed <= BMAX)
218 * n: number of codes (assumed <= N_MAX)
219 * s: number of simple-valued codes (0..s-1)
220 * d: list of base values for non-simple codes
221 * e: list of extra bits for non-simple codes
222 * t: result: starting table
223 * m: maximum lookup bits, returns actual
225 static int huft_build(unsigned int *b, const unsigned int n,
226 const unsigned int s, const unsigned short *d,
227 const unsigned char *e, huft_t ** t, int *m)
229 unsigned a; /* counter for codes of length k */
230 unsigned c[BMAX + 1]; /* bit length count table */
231 unsigned f; /* i repeats in table every f entries */
232 int g; /* maximum code length */
233 int h; /* table level */
234 register unsigned i; /* counter, current code */
235 register unsigned j; /* counter */
236 register int k; /* number of bits in current code */
237 int l; /* bits per table (returned in m) */
238 register unsigned *p; /* pointer into c[], b[], or v[] */
239 register huft_t *q; /* points to current table */
240 huft_t r; /* table entry for structure assignment */
241 huft_t *u[BMAX]; /* table stack */
242 unsigned v[N_MAX]; /* values in order of bit length */
243 register int w; /* bits before this table == (l * h) */
244 unsigned x[BMAX + 1]; /* bit offsets, then code stack */
245 unsigned *xp; /* pointer into x */
246 int y; /* number of dummy codes added */
247 unsigned z; /* number of entries in current table */
249 /* Generate counts for each bit length */
250 memset((void *) (c), 0, sizeof(c));
254 c[*p]++; /* assume all entries <= BMAX */
255 p++; /* Can't combine with above line (Solaris bug) */
257 if (c[0] == n) { /* null input--all zero length codes */
258 *t = (huft_t *) NULL;
263 /* Find minimum and maximum length, bound *m by those */
265 for (j = 1; j <= BMAX; j++) {
270 k = j; /* minimum code length */
271 if ((unsigned) l < j) {
274 for (i = BMAX; i; i--) {
279 g = i; /* maximum code length */
280 if ((unsigned) l > i) {
285 /* Adjust last length count to fill out codes, if needed */
286 for (y = 1 << j; j < i; j++, y <<= 1) {
287 if ((y -= c[j]) < 0) {
288 return 2; /* bad input: more codes than bits */
291 if ((y -= c[i]) < 0) {
296 /* Generate starting offsets into the value table for each length */
300 while (--i) { /* note that i == g from above */
304 /* Make a table of values in order of bit lengths */
308 if ((j = *p++) != 0) {
313 /* Generate the Huffman codes and for each, make the table entries */
314 x[0] = i = 0; /* first Huffman code is zero */
315 p = v; /* grab values in bit order */
316 h = -1; /* no tables yet--level -1 */
317 w = -l; /* bits decoded == (l * h) */
318 u[0] = (huft_t *) NULL; /* just to keep compilers happy */
319 q = (huft_t *) NULL; /* ditto */
322 /* go through the bit lengths (k already is bits in shortest code) */
323 for (; k <= g; k++) {
326 /* here i is the Huffman code of length k bits for value *p */
327 /* make tables up to required level */
330 w += l; /* previous table always l bits */
332 /* compute minimum size table less than or equal to l bits */
333 z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
334 if ((f = 1 << (j = k - w)) > a + 1) { /* try a k-w bit table *//* too few codes for k-w bit table */
335 f -= a + 1; /* deduct codes from patterns left */
337 while (++j < z) { /* try smaller tables up to z bits */
338 if ((f <<= 1) <= *++xp) {
339 break; /* enough codes to use up j bits */
341 f -= *xp; /* else deduct codes from patterns */
344 z = 1 << j; /* table entries for j-bit table */
346 /* allocate and link in new table */
347 q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t));
349 gunzip_hufts += z + 1; /* track memory usage */
350 *t = q + 1; /* link to list for huft_free() */
351 *(t = &(q->v.t)) = NULL;
352 u[h] = ++q; /* table starts after link */
354 /* connect to last table, if there is one */
356 x[h] = i; /* save pattern for backing up */
357 r.b = (unsigned char) l; /* bits to dump before this table */
358 r.e = (unsigned char) (16 + j); /* bits in this table */
359 r.v.t = q; /* pointer to this table */
360 j = i >> (w - l); /* (get around Turbo C bug) */
361 u[h - 1][j] = r; /* connect to last table */
365 /* set up table entry in r */
366 r.b = (unsigned char) (k - w);
368 r.e = 99; /* out of values--invalid code */
370 r.e = (unsigned char) (*p < 256 ? 16 : 15); /* 256 is end-of-block code */
371 r.v.n = (unsigned short) (*p); /* simple code is just the value */
372 p++; /* one compiler does not like *p++ */
374 r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */
378 /* fill code-like entries with r */
380 for (j = i >> w; j < z; j += f) {
384 /* backwards increment the k-bit code i */
385 for (j = 1 << (k - 1); i & j; j >>= 1) {
390 /* backup over finished tables */
391 while ((i & ((1 << w) - 1)) != x[h]) {
392 h--; /* don't need to update q */
397 /* Return true (1) if we were given an incomplete table */
398 return y != 0 && g != 1;
401 /* ===========================================================================
402 * Write the output gunzip_window gunzip_window[0..gunzip_outbuf_count-1] and update crc and gunzip_bytes_out.
403 * (Used for the decompressed data only.)
405 static void flush_gunzip_window(void)
409 for (n = 0; n < gunzip_outbuf_count; n++) {
410 gunzip_crc = gunzip_crc_table[((int) gunzip_crc ^ (gunzip_window[n])) & 0xff] ^ (gunzip_crc >> 8);
413 if (write(gunzip_dst_fd, gunzip_window, gunzip_outbuf_count) != gunzip_outbuf_count) {
414 error_msg_and_die("Couldnt write");
416 gunzip_bytes_out += gunzip_outbuf_count;
417 gunzip_outbuf_count = 0;
421 * inflate (decompress) the codes in a deflated (compressed) block.
422 * Return an error code or zero if it all goes ok.
424 * tl, td: literal/length and distance decoder tables
425 * bl, bd: number of bits decoded by tl[] and td[]
427 static int inflate_codes(huft_t * tl, huft_t * td, const unsigned int bl, const unsigned int bd)
429 unsigned int e; /* table entry flag/number of extra bits */
430 unsigned int n, d; /* length and index for copy */
431 unsigned int w; /* current gunzip_window position */
432 huft_t *t; /* pointer to table entry */
433 unsigned int ml, md; /* masks for bl and bd bits */
434 unsigned int b; /* bit buffer */
435 unsigned int k; /* number of bits in bit buffer */
437 /* make local copies of globals */
438 b = gunzip_bb; /* initialize bit buffer */
440 w = gunzip_outbuf_count; /* initialize gunzip_window position */
442 /* inflate the coded data */
443 ml = mask_bits[bl]; /* precompute masks for speed */
445 while (1) { /* do until end of block */
446 b = fill_bitbuffer(b, &k, bl);
447 if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
455 b = fill_bitbuffer(b, &k, e);
457 (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
460 if (e == 16) { /* then it's a literal */
461 gunzip_window[w++] = (unsigned char) t->v.n;
462 if (w == gunzip_wsize) {
463 gunzip_outbuf_count = (w);
464 flush_gunzip_window();
467 } else { /* it's an EOB or a length */
469 /* exit if end of block */
474 /* get length of block to copy */
475 b = fill_bitbuffer(b, &k, e);
476 n = t->v.n + ((unsigned) b & mask_bits[e]);
480 /* decode distance of block to copy */
481 b = fill_bitbuffer(b, &k, bd);
482 if ((e = (t = td + ((unsigned) b & md))->e) > 16)
489 b = fill_bitbuffer(b, &k, e);
492 t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
495 b = fill_bitbuffer(b, &k, e);
496 d = w - t->v.n - ((unsigned) b & mask_bits[e]);
504 gunzip_wsize - ((d &= gunzip_wsize - 1) > w ? d : w)) > n ? n : e);
505 /* copy to new buffer to prevent possible overwrite */
506 if (w - d >= e) { /* (this test assumes unsigned comparison) */
507 memcpy(gunzip_window + w, gunzip_window + d, e);
511 /* do it slow to avoid memcpy() overlap */
514 gunzip_window[w++] = gunzip_window[d++];
517 if (w == gunzip_wsize) {
518 gunzip_outbuf_count = (w);
519 flush_gunzip_window();
527 /* restore the globals from the locals */
528 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */
529 gunzip_bb = b; /* restore global bit buffer */
537 * decompress an inflated block
540 * GLOBAL VARIABLES: bb, kk,
542 static int inflate_block(int *e)
544 unsigned t; /* block type */
545 register unsigned int b; /* bit buffer */
546 unsigned int k; /* number of bits in bit buffer */
548 /* make local bit buffer */
553 /* read in last block bit */
554 b = fill_bitbuffer(b, &k, 1);
559 /* read in block type */
560 b = fill_bitbuffer(b, &k, 2);
561 t = (unsigned) b & 3;
565 /* restore the global bit buffer */
569 /* inflate that block type */
571 case 0: /* Inflate stored */
573 unsigned int n; /* number of bytes in block */
574 unsigned int w; /* current gunzip_window position */
575 unsigned int b_stored; /* bit buffer */
576 unsigned int k_stored; /* number of bits in bit buffer */
578 /* make local copies of globals */
579 b_stored = gunzip_bb; /* initialize bit buffer */
580 k_stored = gunzip_bk;
581 w = gunzip_outbuf_count; /* initialize gunzip_window position */
583 /* go to byte boundary */
588 /* get the length and its complement */
589 b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
590 n = ((unsigned) b_stored & 0xffff);
594 b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
595 if (n != (unsigned) ((~b_stored) & 0xffff)) {
596 return 1; /* error in compressed data */
601 /* read and output the compressed data */
603 b_stored = fill_bitbuffer(b_stored, &k_stored, 8);
604 gunzip_window[w++] = (unsigned char) b_stored;
605 if (w == (unsigned int) gunzip_wsize) {
606 gunzip_outbuf_count = (w);
607 flush_gunzip_window();
614 /* restore the globals from the locals */
615 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */
616 gunzip_bb = b_stored; /* restore global bit buffer */
617 gunzip_bk = k_stored;
620 case 1: /* Inflate fixed
621 * decompress an inflated type 1 (fixed Huffman codes) block. We should
622 * either replace this with a custom decoder, or at least precompute the
626 int i; /* temporary variable */
627 huft_t *tl; /* literal/length code table */
628 huft_t *td; /* distance code table */
629 unsigned int bl; /* lookup bits for tl */
630 unsigned int bd; /* lookup bits for td */
631 unsigned int l[288]; /* length list for huft_build */
633 /* set up literal table */
634 for (i = 0; i < 144; i++) {
637 for (; i < 256; i++) {
640 for (; i < 280; i++) {
643 for (; i < 288; i++) { /* make a complete, but wrong code set */
647 if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
651 /* set up distance table */
652 for (i = 0; i < 30; i++) { /* make an incomplete code set */
656 if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
661 /* decompress until an end-of-block code */
662 if (inflate_codes(tl, td, bl, bd)) {
666 /* free the decoding tables, return */
671 case 2: /* Inflate dynamic */
673 const int dbits = 6; /* bits in base distance lookup table */
674 const int lbits = 9; /* bits in base literal/length lookup table */
676 huft_t *tl; /* literal/length code table */
677 huft_t *td; /* distance code table */
678 unsigned int i; /* temporary variables */
680 unsigned int l; /* last length */
681 unsigned int m; /* mask for bit lengths table */
682 unsigned int n; /* number of lengths to get */
683 unsigned int bl; /* lookup bits for tl */
684 unsigned int bd; /* lookup bits for td */
685 unsigned int nb; /* number of bit length codes */
686 unsigned int nl; /* number of literal/length codes */
687 unsigned int nd; /* number of distance codes */
689 unsigned int ll[286 + 30]; /* literal/length and distance code lengths */
690 unsigned int b_dynamic; /* bit buffer */
691 unsigned int k_dynamic; /* number of bits in bit buffer */
693 /* make local bit buffer */
694 b_dynamic = gunzip_bb;
695 k_dynamic = gunzip_bk;
697 /* read in table lengths */
698 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
699 nl = 257 + ((unsigned int) b_dynamic & 0x1f); /* number of literal/length codes */
703 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
704 nd = 1 + ((unsigned int) b_dynamic & 0x1f); /* number of distance codes */
708 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 4);
709 nb = 4 + ((unsigned int) b_dynamic & 0xf); /* number of bit length codes */
713 if (nl > 286 || nd > 30) {
714 return 1; /* bad lengths */
717 /* read in bit-length-code lengths */
718 for (j = 0; j < nb; j++) {
719 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
720 ll[border[j]] = (unsigned int) b_dynamic & 7;
724 for (; j < 19; j++) {
728 /* build decoding table for trees--single level, 7 bit lookup */
730 i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl);
735 return i; /* incomplete code set */
738 /* read in literal and distance code lengths */
742 while ((unsigned int) i < n) {
743 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, (unsigned int)bl);
744 j = (td = tl + ((unsigned int) b_dynamic & m))->b;
748 if (j < 16) { /* length of code in bits (0..15) */
749 ll[i++] = l = j; /* save last length in l */
750 } else if (j == 16) { /* repeat last length 3 to 6 times */
751 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 2);
752 j = 3 + ((unsigned int) b_dynamic & 3);
755 if ((unsigned int) i + j > n) {
761 } else if (j == 17) { /* 3 to 10 zero length codes */
762 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
763 j = 3 + ((unsigned int) b_dynamic & 7);
766 if ((unsigned int) i + j > n) {
773 } else { /* j == 18: 11 to 138 zero length codes */
774 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 7);
775 j = 11 + ((unsigned int) b_dynamic & 0x7f);
778 if ((unsigned int) i + j > n) {
788 /* free decoding table for trees */
791 /* restore the global bit buffer */
792 gunzip_bb = b_dynamic;
793 gunzip_bk = k_dynamic;
795 /* build the decoding tables for literal/length and distance codes */
798 if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
800 error_msg_and_die("Incomplete literal tree");
803 return i; /* incomplete code set */
807 if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
809 error_msg_and_die("incomplete distance tree");
813 return i; /* incomplete code set */
816 /* decompress until an end-of-block code */
817 if (inflate_codes(tl, td, bl, bd)) {
821 /* free the decoding tables, return */
828 error_msg("bad block type %d\n", t);
834 * decompress an inflated entry
836 * GLOBAL VARIABLES: gunzip_outbuf_count, bk, gunzip_bb, hufts, inptr
838 extern int inflate(int in, int out)
840 typedef void (*sig_type) (int);
841 int e; /* last block flag */
842 int r; /* result code */
843 unsigned h = 0; /* maximum struct huft's malloc'ed */
845 /* Allocate all global buffers (for DYN_ALLOC option) */
846 gunzip_window = xmalloc(0x8000);
847 gunzip_outbuf_count = 0;
848 gunzip_bytes_out = 0;
853 gunzip_in_buffer = malloc(8);
855 if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
856 (void) signal(SIGINT, (sig_type) abort_gzip);
859 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
860 (void) signal(SIGHUP, (sig_type) abort_gzip);
864 /* initialize gunzip_window, bit buffer */
868 /* Create the crc table */
869 make_gunzip_crc_table();
871 /* decompress until the last block */
874 r = inflate_block(&e);
876 error_msg_and_die("inflate error %d", r);
879 if (gunzip_hufts > h) {
884 /* write any buffered uncompressed data */
885 flush_gunzip_window();
889 free(gunzip_crc_table);
891 /* Store unused bytes in a global buffer so calling applets can access it */
892 gunzip_in_buffer_count = 0;
893 if (gunzip_bk >= 8) {
894 /* Undo too much lookahead. The next read will be byte aligned
895 * so we can discard unused bits in the last meaningful byte. */
896 gunzip_in_buffer[gunzip_in_buffer_count] = gunzip_bb & 0xff;
897 gunzip_in_buffer_count++;