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 * read_gz interface + associated hacking by Laurence Anderson
19 * This program is free software; you can redistribute it and/or modify
20 * it under the terms of the GNU General Public License as published by
21 * the Free Software Foundation; either version 2 of the License, or
22 * (at your option) any later version.
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * General Public License for more details.
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
35 * Copyright (C) 1992-1993 Jean-loup Gailly
36 * The unzip code was written and put in the public domain by Mark Adler.
37 * Portions of the lzw code are derived from the public domain 'compress'
38 * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
39 * Ken Turkowski, Dave Mack and Peter Jannesen.
41 * See the license_msg below and the file COPYING for the software license.
42 * See the file algorithm.doc for the compression algorithms and file formats.
46 static char *license_msg[] = {
47 " Copyright (C) 1992-1993 Jean-loup Gailly",
48 " This program is free software; you can redistribute it and/or modify",
49 " it under the terms of the GNU General Public License as published by",
50 " the Free Software Foundation; either version 2, or (at your option)",
51 " any later version.",
53 " This program is distributed in the hope that it will be useful,",
54 " but WITHOUT ANY WARRANTY; without even the implied warranty of",
55 " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
56 " GNU General Public License for more details.",
58 " You should have received a copy of the GNU General Public License",
59 " along with this program; if not, write to the Free Software",
60 " Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",
65 #include <sys/types.h>
74 #include "unarchive.h"
76 typedef struct huft_s {
77 unsigned char e; /* number of extra bits or operation */
78 unsigned char b; /* number of bits in this code or subcode */
80 unsigned short n; /* literal, length base, or distance base */
81 struct huft_s *t; /* pointer to next level of table */
85 static int gunzip_src_fd;
86 unsigned int gunzip_bytes_out; /* number of output bytes */
87 static unsigned int gunzip_outbuf_count; /* bytes in output buffer */
89 /* gunzip_window size--must be a power of two, and
90 * at least 32K for zip's deflate method */
91 static const int gunzip_wsize = 0x8000;
92 static unsigned char *gunzip_window;
94 static unsigned int *gunzip_crc_table;
95 unsigned int gunzip_crc;
97 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
98 #define BMAX 16 /* maximum bit length of any code (16 for explode) */
99 #define N_MAX 288 /* maximum number of codes in any set */
102 static unsigned int gunzip_bb; /* bit buffer */
103 static unsigned char gunzip_bk; /* bits in bit buffer */
105 /* These control the size of the bytebuffer */
106 #define BYTEBUFFER_MAX 0x8000
107 static unsigned char *bytebuffer = NULL;
108 static unsigned int bytebuffer_offset = 0;
109 static unsigned int bytebuffer_size = 0;
111 static const unsigned short mask_bits[] = {
112 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
113 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
116 /* Copy lengths for literal codes 257..285 */
117 static const unsigned short cplens[] = {
118 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
119 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
122 /* note: see note #13 above about the 258 in this list. */
123 /* Extra bits for literal codes 257..285 */
124 static const unsigned char cplext[] = {
125 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,
129 /* Copy offsets for distance codes 0..29 */
130 static const unsigned short cpdist[] = {
131 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
132 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
135 /* Extra bits for distance codes */
136 static const unsigned char cpdext[] = {
137 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
138 11, 11, 12, 12, 13, 13
141 /* Tables for deflate from PKZIP's appnote.txt. */
142 /* Order of the bit length code lengths */
143 static const unsigned char border[] = {
144 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
147 static void fill_bytebuffer(void)
149 if (bytebuffer_offset >= bytebuffer_size) {
150 /* Leave the first 4 bytes empty so we can always unwind the bitbuffer
151 * to the front of the bytebuffer, leave 4 bytes free at end of tail
152 * so we can easily top up buffer in check_trailer_gzip() */
153 bytebuffer_size = 4 + xread(gunzip_src_fd, &bytebuffer[4], BYTEBUFFER_MAX - 8);
154 bytebuffer_offset = 4;
158 static unsigned int fill_bitbuffer(unsigned int bitbuffer, unsigned int *current, const unsigned int required)
160 while (*current < required) {
162 bitbuffer |= ((unsigned int) bytebuffer[bytebuffer_offset]) << *current;
169 static void make_gunzip_crc_table(void)
171 const unsigned int poly = 0xedb88320; /* polynomial exclusive-or pattern */
172 unsigned short i; /* counter for all possible eight bit values */
174 /* initial shift register value */
175 gunzip_crc = 0xffffffffL;
176 gunzip_crc_table = (unsigned int *) malloc(256 * sizeof(unsigned int));
178 /* Compute and print table of CRC's, five per line */
179 for (i = 0; i < 256; i++) {
180 unsigned int table_entry; /* crc shift register */
181 unsigned char k; /* byte being shifted into crc apparatus */
184 /* The idea to initialize the register with the byte instead of
185 * zero was stolen from Haruhiko Okumura's ar002
187 for (k = 8; k; k--) {
188 if (table_entry & 1) {
189 table_entry = (table_entry >> 1) ^ poly;
194 gunzip_crc_table[i] = table_entry;
199 * Free the malloc'ed tables built by huft_build(), which makes a linked
200 * list of the tables it made, with the links in a dummy first entry of
204 static int huft_free(huft_t * t)
209 /* Go through linked list, freeing from the malloced (t[-1]) address. */
211 while (p != (huft_t *) NULL) {
219 /* Given a list of code lengths and a maximum table size, make a set of
220 * tables to decode that set of codes. Return zero on success, one if
221 * the given code set is incomplete (the tables are still built in this
222 * case), two if the input is invalid (all zero length codes or an
223 * oversubscribed set of lengths), and three if not enough memory.
225 * b: code lengths in bits (all assumed <= BMAX)
226 * n: number of codes (assumed <= N_MAX)
227 * s: number of simple-valued codes (0..s-1)
228 * d: list of base values for non-simple codes
229 * e: list of extra bits for non-simple codes
230 * t: result: starting table
231 * m: maximum lookup bits, returns actual
233 static int huft_build(unsigned int *b, const unsigned int n,
234 const unsigned int s, const unsigned short *d,
235 const unsigned char *e, huft_t ** t, int *m)
237 unsigned a; /* counter for codes of length k */
238 unsigned c[BMAX + 1]; /* bit length count table */
239 unsigned f; /* i repeats in table every f entries */
240 int g; /* maximum code length */
241 int h; /* table level */
242 register unsigned i; /* counter, current code */
243 register unsigned j; /* counter */
244 register int k; /* number of bits in current code */
245 int l; /* bits per table (returned in m) */
246 register unsigned *p; /* pointer into c[], b[], or v[] */
247 register huft_t *q; /* points to current table */
248 huft_t r; /* table entry for structure assignment */
249 huft_t *u[BMAX]; /* table stack */
250 unsigned v[N_MAX]; /* values in order of bit length */
251 register int w; /* bits before this table == (l * h) */
252 unsigned x[BMAX + 1]; /* bit offsets, then code stack */
253 unsigned *xp; /* pointer into x */
254 int y; /* number of dummy codes added */
255 unsigned z; /* number of entries in current table */
257 /* Generate counts for each bit length */
258 memset((void *) (c), 0, sizeof(c));
262 c[*p]++; /* assume all entries <= BMAX */
263 p++; /* Can't combine with above line (Solaris bug) */
265 if (c[0] == n) { /* null input--all zero length codes */
266 *t = (huft_t *) NULL;
271 /* Find minimum and maximum length, bound *m by those */
273 for (j = 1; j <= BMAX; j++) {
278 k = j; /* minimum code length */
279 if ((unsigned) l < j) {
282 for (i = BMAX; i; i--) {
287 g = i; /* maximum code length */
288 if ((unsigned) l > i) {
293 /* Adjust last length count to fill out codes, if needed */
294 for (y = 1 << j; j < i; j++, y <<= 1) {
295 if ((y -= c[j]) < 0) {
296 return 2; /* bad input: more codes than bits */
299 if ((y -= c[i]) < 0) {
304 /* Generate starting offsets into the value table for each length */
308 while (--i) { /* note that i == g from above */
312 /* Make a table of values in order of bit lengths */
316 if ((j = *p++) != 0) {
321 /* Generate the Huffman codes and for each, make the table entries */
322 x[0] = i = 0; /* first Huffman code is zero */
323 p = v; /* grab values in bit order */
324 h = -1; /* no tables yet--level -1 */
325 w = -l; /* bits decoded == (l * h) */
326 u[0] = (huft_t *) NULL; /* just to keep compilers happy */
327 q = (huft_t *) NULL; /* ditto */
330 /* go through the bit lengths (k already is bits in shortest code) */
331 for (; k <= g; k++) {
334 /* here i is the Huffman code of length k bits for value *p */
335 /* make tables up to required level */
338 w += l; /* previous table always l bits */
340 /* compute minimum size table less than or equal to l bits */
341 z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
342 if ((f = 1 << (j = k - w)) > a + 1) { /* try a k-w bit table *//* too few codes for k-w bit table */
343 f -= a + 1; /* deduct codes from patterns left */
345 while (++j < z) { /* try smaller tables up to z bits */
346 if ((f <<= 1) <= *++xp) {
347 break; /* enough codes to use up j bits */
349 f -= *xp; /* else deduct codes from patterns */
352 z = 1 << j; /* table entries for j-bit table */
354 /* allocate and link in new table */
355 q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t));
357 *t = q + 1; /* link to list for huft_free() */
358 *(t = &(q->v.t)) = NULL;
359 u[h] = ++q; /* table starts after link */
361 /* connect to last table, if there is one */
363 x[h] = i; /* save pattern for backing up */
364 r.b = (unsigned char) l; /* bits to dump before this table */
365 r.e = (unsigned char) (16 + j); /* bits in this table */
366 r.v.t = q; /* pointer to this table */
367 j = i >> (w - l); /* (get around Turbo C bug) */
368 u[h - 1][j] = r; /* connect to last table */
372 /* set up table entry in r */
373 r.b = (unsigned char) (k - w);
375 r.e = 99; /* out of values--invalid code */
377 r.e = (unsigned char) (*p < 256 ? 16 : 15); /* 256 is end-of-block code */
378 r.v.n = (unsigned short) (*p); /* simple code is just the value */
379 p++; /* one compiler does not like *p++ */
381 r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */
385 /* fill code-like entries with r */
387 for (j = i >> w; j < z; j += f) {
391 /* backwards increment the k-bit code i */
392 for (j = 1 << (k - 1); i & j; j >>= 1) {
397 /* backup over finished tables */
398 while ((i & ((1 << w) - 1)) != x[h]) {
399 h--; /* don't need to update q */
404 /* Return true (1) if we were given an incomplete table */
405 return y != 0 && g != 1;
409 * inflate (decompress) the codes in a deflated (compressed) block.
410 * Return an error code or zero if it all goes ok.
412 * tl, td: literal/length and distance decoder tables
413 * bl, bd: number of bits decoded by tl[] and td[]
415 static int inflate_codes(huft_t * my_tl, huft_t * my_td, const unsigned int my_bl, const unsigned int my_bd, int setup)
417 static unsigned int e; /* table entry flag/number of extra bits */
418 static unsigned int n, d; /* length and index for copy */
419 static unsigned int w; /* current gunzip_window position */
420 static huft_t *t; /* pointer to table entry */
421 static unsigned int ml, md; /* masks for bl and bd bits */
422 static unsigned int b; /* bit buffer */
423 static unsigned int k; /* number of bits in bit buffer */
424 static huft_t *tl, *td;
425 static unsigned int bl, bd;
426 static int resumeCopy = 0;
428 if (setup) { // 1st time we are called, copy in variables
433 /* make local copies of globals */
434 b = gunzip_bb; /* initialize bit buffer */
436 w = gunzip_outbuf_count; /* initialize gunzip_window position */
438 /* inflate the coded data */
439 ml = mask_bits[bl]; /* precompute masks for speed */
441 return 0; // Don't actually do anything the first time
444 if (resumeCopy) goto do_copy;
446 while (1) { /* do until end of block */
447 b = fill_bitbuffer(b, &k, bl);
448 if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
451 error_msg_and_die("inflate_codes error 1");;
456 b = fill_bitbuffer(b, &k, e);
458 (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
461 if (e == 16) { /* then it's a literal */
462 gunzip_window[w++] = (unsigned char) t->v.n;
463 if (w == gunzip_wsize) {
464 gunzip_outbuf_count = (w);
465 //flush_gunzip_window();
467 return 1; // We have a block to read
469 } else { /* it's an EOB or a length */
471 /* exit if end of block */
476 /* get length of block to copy */
477 b = fill_bitbuffer(b, &k, e);
478 n = t->v.n + ((unsigned) b & mask_bits[e]);
482 /* decode distance of block to copy */
483 b = fill_bitbuffer(b, &k, bd);
484 if ((e = (t = td + ((unsigned) b & md))->e) > 16)
487 error_msg_and_die("inflate_codes error 2");;
491 b = fill_bitbuffer(b, &k, e);
494 t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
497 b = fill_bitbuffer(b, &k, e);
498 d = w - t->v.n - ((unsigned) b & mask_bits[e]);
506 gunzip_wsize - ((d &= gunzip_wsize - 1) > w ? d : w)) > n ? n : e);
507 /* copy to new buffer to prevent possible overwrite */
508 if (w - d >= e) { /* (this test assumes unsigned comparison) */
509 memcpy(gunzip_window + w, gunzip_window + d, e);
513 /* do it slow to avoid memcpy() overlap */
516 gunzip_window[w++] = gunzip_window[d++];
519 if (w == gunzip_wsize) {
520 gunzip_outbuf_count = (w);
521 if (n) resumeCopy = 1;
523 //flush_gunzip_window();
532 /* restore the globals from the locals */
533 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */
534 gunzip_bb = b; /* restore global bit buffer */
537 /* normally just after call to inflate_codes, but save code by putting it here */
538 /* free the decoding tables, return */
546 static int inflate_stored(int my_n, int my_b_stored, int my_k_stored, int setup)
548 static int n, b_stored, k_stored, w;
551 b_stored = my_b_stored;
552 k_stored = my_k_stored;
553 w = gunzip_outbuf_count; /* initialize gunzip_window position */
554 return 0; // Don't do anything first time
557 /* read and output the compressed data */
559 b_stored = fill_bitbuffer(b_stored, &k_stored, 8);
560 gunzip_window[w++] = (unsigned char) b_stored;
561 if (w == (unsigned int) gunzip_wsize) {
562 gunzip_outbuf_count = (w);
563 //flush_gunzip_window();
567 return 1; // We have a block
573 /* restore the globals from the locals */
574 gunzip_outbuf_count = w; /* restore global gunzip_window pointer */
575 gunzip_bb = b_stored; /* restore global bit buffer */
576 gunzip_bk = k_stored;
577 return 0; // Finished
581 * decompress an inflated block
584 * GLOBAL VARIABLES: bb, kk,
586 // Return values: -1 = inflate_stored, -2 = inflate_codes
587 static int inflate_block(int *e)
589 unsigned t; /* block type */
590 register unsigned int b; /* bit buffer */
591 unsigned int k; /* number of bits in bit buffer */
593 /* make local bit buffer */
598 /* read in last block bit */
599 b = fill_bitbuffer(b, &k, 1);
604 /* read in block type */
605 b = fill_bitbuffer(b, &k, 2);
606 t = (unsigned) b & 3;
610 /* restore the global bit buffer */
614 /* inflate that block type */
616 case 0: /* Inflate stored */
618 unsigned int n; /* number of bytes in block */
619 unsigned int b_stored; /* bit buffer */
620 unsigned int k_stored; /* number of bits in bit buffer */
622 /* make local copies of globals */
623 b_stored = gunzip_bb; /* initialize bit buffer */
624 k_stored = gunzip_bk;
626 /* go to byte boundary */
631 /* get the length and its complement */
632 b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
633 n = ((unsigned) b_stored & 0xffff);
637 b_stored = fill_bitbuffer(b_stored, &k_stored, 16);
638 if (n != (unsigned) ((~b_stored) & 0xffff)) {
639 return 1; /* error in compressed data */
644 inflate_stored(n, b_stored, k_stored, 1); // Setup inflate_stored
647 case 1: /* Inflate fixed
648 * decompress an inflated type 1 (fixed Huffman codes) block. We should
649 * either replace this with a custom decoder, or at least precompute the
653 int i; /* temporary variable */
654 huft_t *tl; /* literal/length code table */
655 huft_t *td; /* distance code table */
656 unsigned int bl; /* lookup bits for tl */
657 unsigned int bd; /* lookup bits for td */
658 unsigned int l[288]; /* length list for huft_build */
660 /* set up literal table */
661 for (i = 0; i < 144; i++) {
664 for (; i < 256; i++) {
667 for (; i < 280; i++) {
670 for (; i < 288; i++) { /* make a complete, but wrong code set */
674 if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
678 /* set up distance table */
679 for (i = 0; i < 30; i++) { /* make an incomplete code set */
683 if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
688 /* decompress until an end-of-block code */
689 inflate_codes(tl, td, bl, bd, 1); // Setup inflate_codes
691 /* huft_free code moved into inflate_codes */
695 case 2: /* Inflate dynamic */
697 const int dbits = 6; /* bits in base distance lookup table */
698 const int lbits = 9; /* bits in base literal/length lookup table */
700 huft_t *tl; /* literal/length code table */
701 huft_t *td; /* distance code table */
702 unsigned int i; /* temporary variables */
704 unsigned int l; /* last length */
705 unsigned int m; /* mask for bit lengths table */
706 unsigned int n; /* number of lengths to get */
707 unsigned int bl; /* lookup bits for tl */
708 unsigned int bd; /* lookup bits for td */
709 unsigned int nb; /* number of bit length codes */
710 unsigned int nl; /* number of literal/length codes */
711 unsigned int nd; /* number of distance codes */
713 unsigned int ll[286 + 30]; /* literal/length and distance code lengths */
714 unsigned int b_dynamic; /* bit buffer */
715 unsigned int k_dynamic; /* number of bits in bit buffer */
717 /* make local bit buffer */
718 b_dynamic = gunzip_bb;
719 k_dynamic = gunzip_bk;
721 /* read in table lengths */
722 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
723 nl = 257 + ((unsigned int) b_dynamic & 0x1f); /* number of literal/length codes */
727 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 5);
728 nd = 1 + ((unsigned int) b_dynamic & 0x1f); /* number of distance codes */
732 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 4);
733 nb = 4 + ((unsigned int) b_dynamic & 0xf); /* number of bit length codes */
737 if (nl > 286 || nd > 30) {
738 return 1; /* bad lengths */
741 /* read in bit-length-code lengths */
742 for (j = 0; j < nb; j++) {
743 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
744 ll[border[j]] = (unsigned int) b_dynamic & 7;
748 for (; j < 19; j++) {
752 /* build decoding table for trees--single level, 7 bit lookup */
754 i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl);
759 return i; /* incomplete code set */
762 /* read in literal and distance code lengths */
766 while ((unsigned int) i < n) {
767 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, (unsigned int)bl);
768 j = (td = tl + ((unsigned int) b_dynamic & m))->b;
772 if (j < 16) { /* length of code in bits (0..15) */
773 ll[i++] = l = j; /* save last length in l */
774 } else if (j == 16) { /* repeat last length 3 to 6 times */
775 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 2);
776 j = 3 + ((unsigned int) b_dynamic & 3);
779 if ((unsigned int) i + j > n) {
785 } else if (j == 17) { /* 3 to 10 zero length codes */
786 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 3);
787 j = 3 + ((unsigned int) b_dynamic & 7);
790 if ((unsigned int) i + j > n) {
797 } else { /* j == 18: 11 to 138 zero length codes */
798 b_dynamic = fill_bitbuffer(b_dynamic, &k_dynamic, 7);
799 j = 11 + ((unsigned int) b_dynamic & 0x7f);
802 if ((unsigned int) i + j > n) {
812 /* free decoding table for trees */
815 /* restore the global bit buffer */
816 gunzip_bb = b_dynamic;
817 gunzip_bk = k_dynamic;
819 /* build the decoding tables for literal/length and distance codes */
822 if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
824 error_msg_and_die("Incomplete literal tree");
827 return i; /* incomplete code set */
831 if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
833 error_msg_and_die("incomplete distance tree");
837 return i; /* incomplete code set */
840 /* decompress until an end-of-block code */
841 inflate_codes(tl, td, bl, bd, 1); // Setup inflate_codes
843 /* huft_free code moved into inflate_codes */
849 error_msg_and_die("bad block type %d\n", t);
853 static void calculate_gunzip_crc(void)
856 for (n = 0; n < gunzip_outbuf_count; n++) {
857 gunzip_crc = gunzip_crc_table[((int) gunzip_crc ^ (gunzip_window[n])) & 0xff] ^ (gunzip_crc >> 8);
859 gunzip_bytes_out += gunzip_outbuf_count;
862 static int inflate_get_next_window(void)
864 static int needAnotherBlock = 1;
865 static int method = -1; // Method == -1 for stored, -2 for codes
868 gunzip_outbuf_count = 0;
873 if (needAnotherBlock) {
875 calculate_gunzip_crc();
878 method = inflate_block(&e);
879 needAnotherBlock = 0;
883 case -1: ret = inflate_stored(0,0,0,0);
885 case -2: ret = inflate_codes(0,0,0,0,0);
887 default: error_msg_and_die("inflate error %d", method);
891 calculate_gunzip_crc();
892 return 1; // More data left
893 } else needAnotherBlock = 1; // End of that block
895 /* Doesnt get here */
901 * read_gz, GZ_gzReadOpen, GZ_gzReadClose, inflate
904 extern ssize_t read_gz(int fd, void *buf, size_t count)
906 static int morebytes = 0, finished = 0;
909 int bytesRead = morebytes > count ? count : morebytes;
910 memcpy(buf, gunzip_window + (gunzip_outbuf_count - morebytes), bytesRead);
911 morebytes -= bytesRead;
913 } else if (finished) {
915 } else if (count >= 0x8000) { // We can decompress direcly to the buffer, 32k at a time
916 // Could decompress to larger buffer, but it must be a power of 2, and calculating that is probably more expensive than the benefit
917 unsigned char *old_gunzip_window = gunzip_window; // Save old window
919 if (inflate_get_next_window() == 0) finished = 1;
920 gunzip_window = old_gunzip_window; // Restore old window
921 return gunzip_outbuf_count;
922 } else { // Oh well, need to split up the gunzip_window
924 if (inflate_get_next_window() == 0) finished = 1;
925 morebytes = gunzip_outbuf_count;
926 bytesRead = morebytes > count ? count : morebytes;
927 memcpy(buf, gunzip_window, bytesRead);
928 morebytes -= bytesRead;
934 extern void GZ_gzReadOpen(int fd, void *unused, int nUnused)
936 typedef void (*sig_type) (int);
938 /* Allocate all global buffers (for DYN_ALLOC option) */
939 gunzip_window = xmalloc(gunzip_wsize);
940 gunzip_outbuf_count = 0;
941 gunzip_bytes_out = 0;
945 bytebuffer = xmalloc(BYTEBUFFER_MAX);
947 /* initialize gunzip_window, bit buffer */
951 /* Create the crc table */
952 make_gunzip_crc_table();
955 extern void GZ_gzReadClose(void)
959 free(gunzip_crc_table);
961 /* Store unused bytes in a global buffer so calling applets can access it */
962 if (gunzip_bk >= 8) {
963 /* Undo too much lookahead. The next read will be byte aligned
964 * so we can discard unused bits in the last meaningful byte. */
966 bytebuffer[bytebuffer_offset] = gunzip_bb & 0xff;
972 /*extern int inflate(int in, int out) // Useful for testing read_gz
975 ssize_t nread, nwrote;
977 GZ_gzReadOpen(in, 0, 0);
978 while(1) { // Robbed from copyfd.c
979 nread = read_gz(in, buf, sizeof(buf));
980 if (nread == 0) break; // no data to write
981 else if (nread == -1) {
985 nwrote = full_write(out, buf, nread);
995 extern int inflate(int in, int out)
998 GZ_gzReadOpen(in, 0, 0);
1000 int ret = inflate_get_next_window();
1001 nwrote = full_write(out, gunzip_window, gunzip_outbuf_count);
1003 perror_msg("write");
1006 if (ret == 0) break;
1012 extern void check_trailer_gzip(int src_fd)
1014 unsigned int stored_crc = 0;
1015 unsigned char count;
1017 /* top up the input buffer with the rest of the trailer */
1018 count = bytebuffer_size - bytebuffer_offset;
1020 xread_all(src_fd, &bytebuffer[bytebuffer_size], 8 - count);
1021 bytebuffer_size += 8 - count;
1023 for (count = 0; count != 4; count++) {
1024 stored_crc |= (bytebuffer[bytebuffer_offset] << (count * 8));
1025 bytebuffer_offset++;
1028 /* Validate decompression - crc */
1029 if (stored_crc != (gunzip_crc ^ 0xffffffffL)) {
1030 error_msg_and_die("crc error");
1033 /* Validate decompression - size */
1034 if (gunzip_bytes_out !=
1035 (bytebuffer[bytebuffer_offset] | (bytebuffer[bytebuffer_offset+1] << 8) |
1036 (bytebuffer[bytebuffer_offset+2] << 16) | (bytebuffer[bytebuffer_offset+3] << 24))) {
1037 error_msg_and_die("Incorrect length, but crc is correct");