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
15 * standard 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.
43 #include <sys/types.h>
50 static FILE *in_file, *out_file;
52 /* these are freed by gz_close */
53 static unsigned char *window;
54 static unsigned long *crc_table = NULL;
56 static unsigned long crc; /* shift register contents */
58 /* Return codes from gzip */
59 static const int ERROR = 1;
62 * window size--must be a power of two, and
63 * at least 32K for zip's deflate method
65 static const int WSIZE = 0x8000;
67 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
68 static const int BMAX = 16; /* maximum bit length of any code (16 for explode) */
69 static const int N_MAX = 288; /* maximum number of codes in any set */
71 static long bytes_out; /* number of output bytes */
72 static unsigned long outcnt; /* bytes in output buffer */
74 static unsigned hufts; /* track memory usage */
75 static unsigned long bb; /* bit buffer */
76 static unsigned bk; /* bits in bit buffer */
78 typedef struct huft_s {
79 unsigned char e; /* number of extra bits or operation */
80 unsigned char b; /* number of bits in this code or subcode */
82 unsigned short n; /* literal, length base, or distance base */
83 struct huft_s *t; /* pointer to next level of table */
87 static const unsigned short mask_bits[] = {
89 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
90 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
93 //static int error_number = 0;
94 /* ========================================================================
95 * Signal and error handler.
98 static void abort_gzip()
100 error_msg("gzip aborted\n");
104 static void make_crc_table()
106 unsigned long table_entry; /* crc shift register */
107 unsigned long poly = 0; /* polynomial exclusive-or pattern */
108 int i; /* counter for all possible eight bit values */
109 int k; /* byte being shifted into crc apparatus */
111 /* terms of polynomial defining this crc (except x^32): */
112 static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
114 /* initial shift register value */
116 crc_table = (unsigned long *) malloc(256 * sizeof(unsigned long));
118 /* Make exclusive-or pattern from polynomial (0xedb88320) */
119 for (i = 0; i < sizeof(p)/sizeof(int); i++)
120 poly |= 1L << (31 - p[i]);
122 /* Compute and print table of CRC's, five per line */
123 for (i = 0; i < 256; i++) {
125 /* The idea to initialize the register with the byte instead of
126 * zero was stolen from Haruhiko Okumura's ar002
128 for (k = 8; k; k--) {
129 table_entry = table_entry & 1 ? (table_entry >> 1) ^ poly : table_entry >> 1;
131 crc_table[i]=table_entry;
135 /* ===========================================================================
136 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
137 * (Used for the decompressed data only.)
139 static void flush_window(void)
146 for (n = 0; n < outcnt; n++) {
147 crc = crc_table[((int) crc ^ (window[n])) & 0xff] ^ (crc >> 8);
150 if (fwrite(window, 1, outcnt, out_file) != outcnt) {
151 error_msg_and_die("Couldnt write");
153 bytes_out += (unsigned long) outcnt;
158 * Free the malloc'ed tables built by huft_build(), which makes a linked
159 * list of the tables it made, with the links in a dummy first entry of
163 static int huft_free(huft_t *t)
167 /* Go through linked list, freeing from the malloced (t[-1]) address. */
169 while (p != (huft_t *) NULL) {
177 /* Given a list of code lengths and a maximum table size, make a set of
178 * tables to decode that set of codes. Return zero on success, one if
179 * the given code set is incomplete (the tables are still built in this
180 * case), two if the input is invalid (all zero length codes or an
181 * oversubscribed set of lengths), and three if not enough memory.
183 * b: code lengths in bits (all assumed <= BMAX)
184 * n: number of codes (assumed <= N_MAX)
185 * s: number of simple-valued codes (0..s-1)
186 * d: list of base values for non-simple codes
187 * e: list of extra bits for non-simple codes
188 * t: result: starting table
189 * m: maximum lookup bits, returns actual
191 static int huft_build(unsigned int *b, const unsigned int n, const unsigned int s,
192 const unsigned short *d, const unsigned short *e, huft_t **t, int *m)
194 unsigned a; /* counter for codes of length k */
195 unsigned c[BMAX + 1]; /* bit length count table */
196 unsigned f; /* i repeats in table every f entries */
197 int g; /* maximum code length */
198 int h; /* table level */
199 register unsigned i; /* counter, current code */
200 register unsigned j; /* counter */
201 register int k; /* number of bits in current code */
202 int l; /* bits per table (returned in m) */
203 register unsigned *p; /* pointer into c[], b[], or v[] */
204 register huft_t *q; /* points to current table */
205 huft_t r; /* table entry for structure assignment */
206 huft_t *u[BMAX]; /* table stack */
207 unsigned v[N_MAX]; /* values in order of bit length */
208 register int w; /* bits before this table == (l * h) */
209 unsigned x[BMAX + 1]; /* bit offsets, then code stack */
210 unsigned *xp; /* pointer into x */
211 int y; /* number of dummy codes added */
212 unsigned z; /* number of entries in current table */
214 /* Generate counts for each bit length */
215 memset ((void *)(c), 0, sizeof(c));
219 c[*p]++; /* assume all entries <= BMAX */
220 p++; /* Can't combine with above line (Solaris bug) */
222 if (c[0] == n) { /* null input--all zero length codes */
223 *t = (huft_t *) NULL;
228 /* Find minimum and maximum length, bound *m by those */
230 for (j = 1; j <= BMAX; j++)
233 k = j; /* minimum code length */
234 if ((unsigned) l < j)
236 for (i = BMAX; i; i--)
239 g = i; /* maximum code length */
240 if ((unsigned) l > i)
244 /* Adjust last length count to fill out codes, if needed */
245 for (y = 1 << j; j < i; j++, y <<= 1)
247 return 2; /* bad input: more codes than bits */
252 /* Generate starting offsets into the value table for each length */
256 while (--i) { /* note that i == g from above */
260 /* Make a table of values in order of bit lengths */
268 /* Generate the Huffman codes and for each, make the table entries */
269 x[0] = i = 0; /* first Huffman code is zero */
270 p = v; /* grab values in bit order */
271 h = -1; /* no tables yet--level -1 */
272 w = -l; /* bits decoded == (l * h) */
273 u[0] = (huft_t *) NULL; /* just to keep compilers happy */
274 q = (huft_t *) NULL; /* ditto */
277 /* go through the bit lengths (k already is bits in shortest code) */
278 for (; k <= g; k++) {
281 /* here i is the Huffman code of length k bits for value *p */
282 /* make tables up to required level */
285 w += l; /* previous table always l bits */
287 /* compute minimum size table less than or equal to l bits */
288 z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
289 if ((f = 1 << (j = k - w)) > a + 1) { /* try a k-w bit table *//* too few codes for k-w bit table */
290 f -= a + 1; /* deduct codes from patterns left */
292 while (++j < z) { /* try smaller tables up to z bits */
293 if ((f <<= 1) <= *++xp)
294 break; /* enough codes to use up j bits */
295 f -= *xp; /* else deduct codes from patterns */
298 z = 1 << j; /* table entries for j-bit table */
300 /* allocate and link in new table */
301 if ((q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t))) == NULL) {
305 return 3; /* not enough memory */
307 hufts += z + 1; /* track memory usage */
308 *t = q + 1; /* link to list for huft_free() */
309 *(t = &(q->v.t)) = NULL;
310 u[h] = ++q; /* table starts after link */
312 /* connect to last table, if there is one */
314 x[h] = i; /* save pattern for backing up */
315 r.b = (unsigned char) l; /* bits to dump before this table */
316 r.e = (unsigned char) (16 + j); /* bits in this table */
317 r.v.t = q; /* pointer to this table */
318 j = i >> (w - l); /* (get around Turbo C bug) */
319 u[h - 1][j] = r; /* connect to last table */
323 /* set up table entry in r */
324 r.b = (unsigned char) (k - w);
326 r.e = 99; /* out of values--invalid code */
328 r.e = (unsigned char) (*p < 256 ? 16 : 15); /* 256 is end-of-block code */
329 r.v.n = (unsigned short) (*p); /* simple code is just the value */
330 p++; /* one compiler does not like *p++ */
332 r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */
336 /* fill code-like entries with r */
338 for (j = i >> w; j < z; j += f)
341 /* backwards increment the k-bit code i */
342 for (j = 1 << (k - 1); i & j; j >>= 1)
346 /* backup over finished tables */
347 while ((i & ((1 << w) - 1)) != x[h]) {
348 h--; /* don't need to update q */
353 /* Return true (1) if we were given an incomplete table */
354 return y != 0 && g != 1;
358 * inflate (decompress) the codes in a deflated (compressed) block.
359 * Return an error code or zero if it all goes ok.
361 * tl, td: literal/length and distance decoder tables
362 * bl, bd: number of bits decoded by tl[] and td[]
364 static int inflate_codes(huft_t *tl, huft_t *td, int bl, int bd)
366 register unsigned long e; /* table entry flag/number of extra bits */
367 unsigned long n, d; /* length and index for copy */
368 unsigned long w; /* current window position */
369 huft_t *t; /* pointer to table entry */
370 unsigned ml, md; /* masks for bl and bd bits */
371 register unsigned long b; /* bit buffer */
372 register unsigned k; /* number of bits in bit buffer */
374 /* make local copies of globals */
375 b = bb; /* initialize bit buffer */
377 w = outcnt; /* initialize window position */
379 /* inflate the coded data */
380 ml = mask_bits[bl]; /* precompute masks for speed */
382 for (;;) { /* do until end of block */
383 while (k < (unsigned) bl) {
384 b |= ((unsigned long)fgetc(in_file)) << k;
387 if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
396 b |= ((unsigned long)fgetc(in_file)) << k;
399 } while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
402 if (e == 16) { /* then it's a literal */
403 window[w++] = (unsigned char) t->v.n;
409 } else { /* it's an EOB or a length */
411 /* exit if end of block */
416 /* get length of block to copy */
418 b |= ((unsigned long)fgetc(in_file)) << k;
421 n = t->v.n + ((unsigned) b & mask_bits[e]);
425 /* decode distance of block to copy */
426 while (k < (unsigned) bd) {
427 b |= ((unsigned long)fgetc(in_file)) << k;
431 if ((e = (t = td + ((unsigned) b & md))->e) > 16)
439 b |= ((unsigned long)fgetc(in_file)) << k;
442 } while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
446 b |= ((unsigned long)fgetc(in_file)) << k;
449 d = w - t->v.n - ((unsigned) b & mask_bits[e]);
455 n -= (e = (e = WSIZE - ((d &= WSIZE - 1) > w ? d : w)) > n ? n : e);
456 #if !defined(NOMEMCPY) && !defined(DEBUG)
457 if (w - d >= e) { /* (this test assumes unsigned comparison) */
458 memcpy(window + w, window + d, e);
461 } else /* do it slow to avoid memcpy() overlap */
462 #endif /* !NOMEMCPY */
464 window[w++] = window[d++];
475 /* restore the globals from the locals */
476 outcnt = w; /* restore global window pointer */
477 bb = b; /* restore global bit buffer */
485 * decompress an inflated block
488 * GLOBAL VARIABLES: bb, kk,
490 static int inflate_block(int *e)
492 unsigned t; /* block type */
493 register unsigned long b; /* bit buffer */
494 register unsigned k; /* number of bits in bit buffer */
495 static unsigned short cplens[] = { /* Copy lengths for literal codes 257..285 */
496 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
497 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
499 /* note: see note #13 above about the 258 in this list. */
500 static unsigned short cplext[] = { /* Extra bits for literal codes 257..285 */
501 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
502 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
504 static unsigned short cpdist[] = { /* Copy offsets for distance codes 0..29 */
505 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
506 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
507 8193, 12289, 16385, 24577
509 static unsigned short cpdext[] = { /* Extra bits for distance codes */
510 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
511 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
515 /* make local bit buffer */
519 /* read in last block bit */
521 b |= ((unsigned long)fgetc(in_file)) << k;
528 /* read in block type */
530 b |= ((unsigned long)fgetc(in_file)) << k;
533 t = (unsigned) b & 3;
537 /* restore the global bit buffer */
541 /* inflate that block type */
543 case 0: /* Inflate stored */
545 unsigned long n; /* number of bytes in block */
546 unsigned long w; /* current window position */
547 register unsigned long b_stored; /* bit buffer */
548 register unsigned long k_stored; /* number of bits in bit buffer */
550 /* make local copies of globals */
551 b_stored = bb; /* initialize bit buffer */
553 w = outcnt; /* initialize window position */
555 /* go to byte boundary */
560 /* get the length and its complement */
561 while (k_stored < 16) {
562 b_stored |= ((unsigned long)fgetc(in_file)) << k_stored;
565 n = ((unsigned) b_stored & 0xffff);
568 while (k_stored < 16) {
569 b_stored |= ((unsigned long)fgetc(in_file)) << k_stored;
572 if (n != (unsigned) ((~b_stored) & 0xffff)) {
573 return 1; /* error in compressed data */
578 /* read and output the compressed data */
580 while (k_stored < 8) {
581 b_stored |= ((unsigned long)fgetc(in_file)) << k_stored;
584 window[w++] = (unsigned char) b_stored;
585 if (w == (unsigned long)WSIZE) {
594 /* restore the globals from the locals */
595 outcnt = w; /* restore global window pointer */
596 bb = b_stored; /* restore global bit buffer */
600 case 1: /* Inflate fixed
601 * decompress an inflated type 1 (fixed Huffman codes) block. We should
602 * either replace this with a custom decoder, or at least precompute the
606 int i; /* temporary variable */
607 huft_t *tl; /* literal/length code table */
608 huft_t *td; /* distance code table */
609 int bl; /* lookup bits for tl */
610 int bd; /* lookup bits for td */
611 unsigned int l[288]; /* length list for huft_build */
613 /* set up literal table */
614 for (i = 0; i < 144; i++) {
617 for (; i < 256; i++) {
620 for (; i < 280; i++) {
623 for (; i < 288; i++) { /* make a complete, but wrong code set */
627 if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
631 /* set up distance table */
632 for (i = 0; i < 30; i++) { /* make an incomplete code set */
636 if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
641 /* decompress until an end-of-block code */
642 if (inflate_codes(tl, td, bl, bd))
645 /* free the decoding tables, return */
650 case 2: /* Inflate dynamic */
652 /* Tables for deflate from PKZIP's appnote.txt. */
653 static unsigned border[] = { /* Order of the bit length code lengths */
654 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
656 int dbits = 6; /* bits in base distance lookup table */
657 int lbits = 9; /* bits in base literal/length lookup table */
659 int i; /* temporary variables */
661 unsigned l; /* last length */
662 unsigned m; /* mask for bit lengths table */
663 unsigned n; /* number of lengths to get */
664 huft_t *tl; /* literal/length code table */
665 huft_t *td; /* distance code table */
666 int bl; /* lookup bits for tl */
667 int bd; /* lookup bits for td */
668 unsigned nb; /* number of bit length codes */
669 unsigned nl; /* number of literal/length codes */
670 unsigned nd; /* number of distance codes */
672 unsigned ll[286 + 30]; /* literal/length and distance code lengths */
673 register unsigned long b_dynamic; /* bit buffer */
674 register unsigned k_dynamic; /* number of bits in bit buffer */
676 /* make local bit buffer */
680 /* read in table lengths */
681 while (k_dynamic < 5) {
682 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
685 nl = 257 + ((unsigned) b_dynamic & 0x1f); /* number of literal/length codes */
688 while (k_dynamic < 5) {
689 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
692 nd = 1 + ((unsigned) b_dynamic & 0x1f); /* number of distance codes */
695 while (k_dynamic < 4) {
696 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
699 nb = 4 + ((unsigned) b_dynamic & 0xf); /* number of bit length codes */
702 if (nl > 286 || nd > 30) {
703 return 1; /* bad lengths */
706 /* read in bit-length-code lengths */
707 for (j = 0; j < nb; j++) {
708 while (k_dynamic < 3) {
709 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
712 ll[border[j]] = (unsigned) b_dynamic & 7;
716 for (; j < 19; j++) {
720 /* build decoding table for trees--single level, 7 bit lookup */
722 if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) {
726 return i; /* incomplete code set */
729 /* read in literal and distance code lengths */
733 while ((unsigned) i < n) {
734 while (k_dynamic < (unsigned) bl) {
735 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
738 j = (td = tl + ((unsigned) b_dynamic & m))->b;
742 if (j < 16) { /* length of code in bits (0..15) */
743 ll[i++] = l = j; /* save last length in l */
745 else if (j == 16) { /* repeat last length 3 to 6 times */
746 while (k_dynamic < 2) {
747 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
750 j = 3 + ((unsigned) b_dynamic & 3);
753 if ((unsigned) i + j > n) {
759 } else if (j == 17) { /* 3 to 10 zero length codes */
760 while (k_dynamic < 3) {
761 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
764 j = 3 + ((unsigned) b_dynamic & 7);
767 if ((unsigned) i + j > n) {
774 } else { /* j == 18: 11 to 138 zero length codes */
775 while (k_dynamic < 7) {
776 b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
779 j = 11 + ((unsigned) b_dynamic & 0x7f);
782 if ((unsigned) i + j > n) {
792 /* free decoding table for trees */
795 /* restore the global bit buffer */
799 /* build the decoding tables for literal/length and distance codes */
801 if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
803 error_msg("Incomplete literal tree");
806 return i; /* incomplete code set */
809 if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
811 error_msg("incomplete distance tree");
815 return i; /* incomplete code set */
818 /* decompress until an end-of-block code */
819 if (inflate_codes(tl, td, bl, bd))
822 /* free the decoding tables, return */
834 * decompress an inflated entry
836 * GLOBAL VARIABLES: outcnt, bk, bb, hufts, inptr
840 int e; /* last block flag */
841 int r; /* result code */
842 unsigned h = 0; /* maximum struct huft's malloc'ed */
844 /* initialize window, bit buffer */
849 /* decompress until the last block */
852 if ((r = inflate_block(&e)) != 0) {
860 /* Undo too much lookahead. The next read will be byte aligned so we
861 * can discard unused bits in the last meaningful byte. */
864 ungetc((bb << bk), in_file);
867 /* flush out window */
874 /* ===========================================================================
875 * Unzip in to out. This routine works on both gzip and pkzip files.
877 * IN assertions: the buffer inbuf contains already the beginning of
878 * the compressed data, from offsets inptr to insize-1 included.
879 * The magic header has already been checked. The output buffer is cleared.
880 * in, out: input and output file descriptors
882 extern int unzip(FILE *l_in_file, FILE *l_out_file)
884 const int extra_field = 0x04; /* bit 2 set: extra field present */
885 const int orig_name = 0x08; /* bit 3 set: original file name present */
886 const int comment = 0x10; /* bit 4 set: file comment present */
887 unsigned char buf[8]; /* extended local header */
888 unsigned char flags; /* compression flags */
889 char magic[2]; /* magic header */
891 typedef void (*sig_type) (int);
892 int exit_code=0; /* program exit code */
896 out_file = l_out_file;
898 if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
899 (void) signal(SIGINT, (sig_type) abort_gzip);
902 // if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
903 // (void) signal(SIGTERM, (sig_type) abort_gzip);
907 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
908 (void) signal(SIGHUP, (sig_type) abort_gzip);
912 /* Allocate all global buffers (for DYN_ALLOC option) */
913 window = xmalloc((size_t)(((2L*WSIZE)+1L)*sizeof(unsigned char)));
917 magic[0] = fgetc(in_file);
918 magic[1] = fgetc(in_file);
920 /* Magic header for gzip files, 1F 8B = \037\213 */
921 if (memcmp(magic, "\037\213", 2) != 0) {
922 error_msg("Invalid gzip magic");
926 method = (int) fgetc(in_file);
928 error_msg("unknown method %d -- get newer version of gzip", method);
933 flags = (unsigned char) fgetc(in_file);
935 /* Ignore time stamp(4), extra flags(1), OS type(1) */
936 for (i = 0; i < 6; i++)
939 if ((flags & extra_field) != 0) {
941 extra = fgetc(in_file);
942 extra += fgetc(in_file) << 8;
944 for (i = 0; i < extra; i++)
948 /* Discard original name if any */
949 if ((flags & orig_name) != 0) {
950 while (fgetc(in_file) != 0); /* null */
953 /* Discard file comment if any */
954 if ((flags & comment) != 0) {
955 while (fgetc(in_file) != 0); /* null */
959 printf("it failed\n");
960 return(exit_code); /* error message already emitted */
971 error_msg(memory_exhausted);
973 } else if (res != 0) {
974 error_msg("invalid compressed data--format violated");
979 error_msg("internal error, invalid method");
983 /* Get the crc and original length
984 * crc32 (see algorithm.doc)
985 * uncompressed input size modulo 2^32
987 fread(buf, 1, 8, in_file);
989 /* Validate decompression - crc */
990 if (!exit_code && (unsigned int)((buf[0] | (buf[1] << 8)) |((buf[2] | (buf[3] << 8)) << 16)) != (crc ^ 0xffffffffL)) {
991 error_msg("invalid compressed data--crc error");
994 /* Validate decompression - size */
995 if (!exit_code && ((buf[4] | (buf[5] << 8)) |((buf[6] | (buf[7] << 8)) << 16)) != (unsigned long) bytes_out) {
996 error_msg("invalid compressed data--length error");
1010 * This needs access to global variables wondow and crc_table, so its not in its own file.
1012 extern void gz_close(int gunzip_pid)
1014 if (kill(gunzip_pid, SIGTERM) == -1) {
1015 error_msg_and_die("*** Couldnt kill old gunzip process *** aborting");
1018 if (waitpid(gunzip_pid, NULL, 0) == -1) {
1019 printf("Couldnt wait ?");