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>
52 static FILE *in_file
, *out_file
;
54 static unsigned char *window
;
55 static unsigned long *crc_table
= NULL
;
57 static unsigned long crc
; /* shift register contents */
60 * window size--must be a power of two, and
61 * at least 32K for zip's deflate method
63 static const int WSIZE
= 0x8000;
65 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
66 static const int BMAX
= 16; /* maximum bit length of any code (16 for explode) */
67 static const int N_MAX
= 288; /* maximum number of codes in any set */
69 static long bytes_out
; /* number of output bytes */
70 static unsigned long outcnt
; /* bytes in output buffer */
72 static unsigned hufts
; /* track memory usage */
73 static unsigned long bb
; /* bit buffer */
74 static unsigned bk
; /* bits in bit buffer */
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 const unsigned short mask_bits
[] = {
87 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
88 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
91 //static int error_number = 0;
92 /* ========================================================================
93 * Signal and error handler.
96 static void abort_gzip()
98 error_msg("gzip aborted\n");
102 static void make_crc_table()
104 unsigned long table_entry
; /* crc shift register */
105 unsigned long poly
= 0; /* polynomial exclusive-or pattern */
106 int i
; /* counter for all possible eight bit values */
107 int k
; /* byte being shifted into crc apparatus */
109 /* terms of polynomial defining this crc (except x^32): */
110 static int p
[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
112 /* initial shift register value */
114 crc_table
= (unsigned long *) xmalloc(256 * sizeof(unsigned long));
116 /* Make exclusive-or pattern from polynomial (0xedb88320) */
117 for (i
= 0; i
< sizeof(p
)/sizeof(int); i
++)
118 poly
|= 1L << (31 - p
[i
]);
120 /* Compute and print table of CRC's, five per line */
121 for (i
= 0; i
< 256; i
++) {
123 /* The idea to initialize the register with the byte instead of
124 * zero was stolen from Haruhiko Okumura's ar002
126 for (k
= 8; k
; k
--) {
127 table_entry
= table_entry
& 1 ? (table_entry
>> 1) ^ poly
: table_entry
>> 1;
129 crc_table
[i
]=table_entry
;
133 /* ===========================================================================
134 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
135 * (Used for the decompressed data only.)
137 static void flush_window(void)
144 for (n
= 0; n
< outcnt
; n
++) {
145 crc
= crc_table
[((int) crc
^ (window
[n
])) & 0xff] ^ (crc
>> 8);
148 if (fwrite(window
, 1, outcnt
, out_file
) != outcnt
) {
150 * The Parent process may not be interested in all the data we have,
151 * in which case it will rudely close its end of the pipe and
152 * wait for us to exit.
157 error_msg("Couldnt write");
160 bytes_out
+= (unsigned long) outcnt
;
165 * Free the malloc'ed tables built by huft_build(), which makes a linked
166 * list of the tables it made, with the links in a dummy first entry of
170 static int huft_free(huft_t
*t
)
174 /* Go through linked list, freeing from the malloced (t[-1]) address. */
176 while (p
!= (huft_t
*) NULL
) {
184 /* Given a list of code lengths and a maximum table size, make a set of
185 * tables to decode that set of codes. Return zero on success, one if
186 * the given code set is incomplete (the tables are still built in this
187 * case), two if the input is invalid (all zero length codes or an
188 * oversubscribed set of lengths), and three if not enough memory.
190 * b: code lengths in bits (all assumed <= BMAX)
191 * n: number of codes (assumed <= N_MAX)
192 * s: number of simple-valued codes (0..s-1)
193 * d: list of base values for non-simple codes
194 * e: list of extra bits for non-simple codes
195 * t: result: starting table
196 * m: maximum lookup bits, returns actual
198 static int huft_build(unsigned int *b
, const unsigned int n
, const unsigned int s
,
199 const unsigned short *d
, const unsigned short *e
, huft_t
**t
, int *m
)
201 unsigned a
; /* counter for codes of length k */
202 unsigned c
[BMAX
+ 1]; /* bit length count table */
203 unsigned f
; /* i repeats in table every f entries */
204 int g
; /* maximum code length */
205 int h
; /* table level */
206 unsigned i
; /* counter, current code */
207 unsigned j
; /* counter */
208 int k
; /* number of bits in current code */
209 int l
; /* bits per table (returned in m) */
210 unsigned *p
; /* pointer into c[], b[], or v[] */
211 huft_t
*q
; /* points to current table */
212 huft_t r
; /* table entry for structure assignment */
213 huft_t
*u
[BMAX
]; /* table stack */
214 unsigned v
[N_MAX
]; /* values in order of bit length */
215 int w
; /* bits before this table == (l * h) */
216 unsigned x
[BMAX
+ 1]; /* bit offsets, then code stack */
217 unsigned *xp
; /* pointer into x */
218 int y
; /* number of dummy codes added */
219 unsigned z
; /* number of entries in current table */
221 /* Generate counts for each bit length */
222 memset ((void *)(c
), 0, sizeof(c
));
226 c
[*p
]++; /* assume all entries <= BMAX */
227 p
++; /* Can't combine with above line (Solaris bug) */
229 if (c
[0] == n
) { /* null input--all zero length codes */
230 *t
= (huft_t
*) NULL
;
235 /* Find minimum and maximum length, bound *m by those */
237 for (j
= 1; j
<= BMAX
; j
++)
240 k
= j
; /* minimum code length */
241 if ((unsigned) l
< j
)
243 for (i
= BMAX
; i
; i
--)
246 g
= i
; /* maximum code length */
247 if ((unsigned) l
> i
)
251 /* Adjust last length count to fill out codes, if needed */
252 for (y
= 1 << j
; j
< i
; j
++, y
<<= 1)
254 return 2; /* bad input: more codes than bits */
259 /* Generate starting offsets into the value table for each length */
263 while (--i
) { /* note that i == g from above */
267 /* Make a table of values in order of bit lengths */
275 /* Generate the Huffman codes and for each, make the table entries */
276 x
[0] = i
= 0; /* first Huffman code is zero */
277 p
= v
; /* grab values in bit order */
278 h
= -1; /* no tables yet--level -1 */
279 w
= -l
; /* bits decoded == (l * h) */
280 u
[0] = (huft_t
*) NULL
; /* just to keep compilers happy */
281 q
= (huft_t
*) NULL
; /* ditto */
284 /* go through the bit lengths (k already is bits in shortest code) */
285 for (; k
<= g
; k
++) {
288 /* here i is the Huffman code of length k bits for value *p */
289 /* make tables up to required level */
292 w
+= l
; /* previous table always l bits */
294 /* compute minimum size table less than or equal to l bits */
295 z
= (z
= g
- w
) > (unsigned) l
? l
: z
; /* upper limit on table size */
296 if ((f
= 1 << (j
= k
- w
)) > a
+ 1) { /* try a k-w bit table *//* too few codes for k-w bit table */
297 f
-= a
+ 1; /* deduct codes from patterns left */
299 while (++j
< z
) { /* try smaller tables up to z bits */
300 if ((f
<<= 1) <= *++xp
)
301 break; /* enough codes to use up j bits */
302 f
-= *xp
; /* else deduct codes from patterns */
305 z
= 1 << j
; /* table entries for j-bit table */
307 /* allocate and link in new table */
308 if ((q
= (huft_t
*) xmalloc((z
+ 1) * sizeof(huft_t
))) == NULL
) {
312 return 3; /* not enough memory */
314 hufts
+= z
+ 1; /* track memory usage */
315 *t
= q
+ 1; /* link to list for huft_free() */
316 *(t
= &(q
->v
.t
)) = NULL
;
317 u
[h
] = ++q
; /* table starts after link */
319 /* connect to last table, if there is one */
321 x
[h
] = i
; /* save pattern for backing up */
322 r
.b
= (unsigned char) l
; /* bits to dump before this table */
323 r
.e
= (unsigned char) (16 + j
); /* bits in this table */
324 r
.v
.t
= q
; /* pointer to this table */
325 j
= i
>> (w
- l
); /* (get around Turbo C bug) */
326 u
[h
- 1][j
] = r
; /* connect to last table */
330 /* set up table entry in r */
331 r
.b
= (unsigned char) (k
- w
);
333 r
.e
= 99; /* out of values--invalid code */
335 r
.e
= (unsigned char) (*p
< 256 ? 16 : 15); /* 256 is end-of-block code */
336 r
.v
.n
= (unsigned short) (*p
); /* simple code is just the value */
337 p
++; /* one compiler does not like *p++ */
339 r
.e
= (unsigned char) e
[*p
- s
]; /* non-simple--look up in lists */
343 /* fill code-like entries with r */
345 for (j
= i
>> w
; j
< z
; j
+= f
)
348 /* backwards increment the k-bit code i */
349 for (j
= 1 << (k
- 1); i
& j
; j
>>= 1)
353 /* backup over finished tables */
354 while ((i
& ((1 << w
) - 1)) != x
[h
]) {
355 h
--; /* don't need to update q */
360 /* Return true (1) if we were given an incomplete table */
361 return y
!= 0 && g
!= 1;
365 * inflate (decompress) the codes in a deflated (compressed) block.
366 * Return an error code or zero if it all goes ok.
368 * tl, td: literal/length and distance decoder tables
369 * bl, bd: number of bits decoded by tl[] and td[]
371 static int inflate_codes(huft_t
*tl
, huft_t
*td
, int bl
, int bd
)
373 unsigned long e
; /* table entry flag/number of extra bits */
374 unsigned long n
, d
; /* length and index for copy */
375 unsigned long w
; /* current window position */
376 huft_t
*t
; /* pointer to table entry */
377 unsigned ml
, md
; /* masks for bl and bd bits */
378 unsigned long b
; /* bit buffer */
379 unsigned k
; /* number of bits in bit buffer */
381 /* make local copies of globals */
382 b
= bb
; /* initialize bit buffer */
384 w
= outcnt
; /* initialize window position */
386 /* inflate the coded data */
387 ml
= mask_bits
[bl
]; /* precompute masks for speed */
389 for (;;) { /* do until end of block */
390 while (k
< (unsigned) bl
) {
391 b
|= ((unsigned long)fgetc(in_file
)) << k
;
394 if ((e
= (t
= tl
+ ((unsigned) b
& ml
))->e
) > 16)
403 b
|= ((unsigned long)fgetc(in_file
)) << k
;
406 } while ((e
= (t
= t
->v
.t
+ ((unsigned) b
& mask_bits
[e
]))->e
) > 16);
409 if (e
== 16) { /* then it's a literal */
410 window
[w
++] = (unsigned char) t
->v
.n
;
416 } else { /* it's an EOB or a length */
418 /* exit if end of block */
423 /* get length of block to copy */
425 b
|= ((unsigned long)fgetc(in_file
)) << k
;
428 n
= t
->v
.n
+ ((unsigned) b
& mask_bits
[e
]);
432 /* decode distance of block to copy */
433 while (k
< (unsigned) bd
) {
434 b
|= ((unsigned long)fgetc(in_file
)) << k
;
438 if ((e
= (t
= td
+ ((unsigned) b
& md
))->e
) > 16)
446 b
|= ((unsigned long)fgetc(in_file
)) << k
;
449 } while ((e
= (t
= t
->v
.t
+ ((unsigned) b
& mask_bits
[e
]))->e
) > 16);
453 b
|= ((unsigned long)fgetc(in_file
)) << k
;
456 d
= w
- t
->v
.n
- ((unsigned) b
& mask_bits
[e
]);
462 n
-= (e
= (e
= WSIZE
- ((d
&= WSIZE
- 1) > w
? d
: w
)) > n
? n
: e
);
463 #if !defined(NOMEMCPY) && !defined(DEBUG)
464 if (w
- d
>= e
) { /* (this test assumes unsigned comparison) */
465 memcpy(window
+ w
, window
+ d
, e
);
468 } else /* do it slow to avoid memcpy() overlap */
469 #endif /* !NOMEMCPY */
471 window
[w
++] = window
[d
++];
482 /* restore the globals from the locals */
483 outcnt
= w
; /* restore global window pointer */
484 bb
= b
; /* restore global bit buffer */
492 * decompress an inflated block
495 * GLOBAL VARIABLES: bb, kk,
497 static int inflate_block(int *e
)
499 unsigned t
; /* block type */
500 unsigned long b
; /* bit buffer */
501 unsigned k
; /* number of bits in bit buffer */
502 static unsigned short cplens
[] = { /* Copy lengths for literal codes 257..285 */
503 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
504 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
506 /* note: see note #13 above about the 258 in this list. */
507 static unsigned short cplext
[] = { /* Extra bits for literal codes 257..285 */
508 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
509 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
511 static unsigned short cpdist
[] = { /* Copy offsets for distance codes 0..29 */
512 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
513 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
514 8193, 12289, 16385, 24577
516 static unsigned short cpdext
[] = { /* Extra bits for distance codes */
517 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
518 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
522 /* make local bit buffer */
526 /* read in last block bit */
528 b
|= ((unsigned long)fgetc(in_file
)) << k
;
535 /* read in block type */
537 b
|= ((unsigned long)fgetc(in_file
)) << k
;
540 t
= (unsigned) b
& 3;
544 /* restore the global bit buffer */
548 /* inflate that block type */
550 case 0: /* Inflate stored */
552 unsigned long n
; /* number of bytes in block */
553 unsigned long w
; /* current window position */
554 unsigned long b_stored
; /* bit buffer */
555 unsigned long k_stored
; /* number of bits in bit buffer */
557 /* make local copies of globals */
558 b_stored
= bb
; /* initialize bit buffer */
560 w
= outcnt
; /* initialize window position */
562 /* go to byte boundary */
567 /* get the length and its complement */
568 while (k_stored
< 16) {
569 b_stored
|= ((unsigned long)fgetc(in_file
)) << k_stored
;
572 n
= ((unsigned) b_stored
& 0xffff);
575 while (k_stored
< 16) {
576 b_stored
|= ((unsigned long)fgetc(in_file
)) << k_stored
;
579 if (n
!= (unsigned) ((~b_stored
) & 0xffff)) {
580 return 1; /* error in compressed data */
585 /* read and output the compressed data */
587 while (k_stored
< 8) {
588 b_stored
|= ((unsigned long)fgetc(in_file
)) << k_stored
;
591 window
[w
++] = (unsigned char) b_stored
;
592 if (w
== (unsigned long)WSIZE
) {
601 /* restore the globals from the locals */
602 outcnt
= w
; /* restore global window pointer */
603 bb
= b_stored
; /* restore global bit buffer */
607 case 1: /* Inflate fixed
608 * decompress an inflated type 1 (fixed Huffman codes) block. We should
609 * either replace this with a custom decoder, or at least precompute the
613 int i
; /* temporary variable */
614 huft_t
*tl
; /* literal/length code table */
615 huft_t
*td
; /* distance code table */
616 int bl
; /* lookup bits for tl */
617 int bd
; /* lookup bits for td */
618 unsigned int l
[288]; /* length list for huft_build */
620 /* set up literal table */
621 for (i
= 0; i
< 144; i
++) {
624 for (; i
< 256; i
++) {
627 for (; i
< 280; i
++) {
630 for (; i
< 288; i
++) { /* make a complete, but wrong code set */
634 if ((i
= huft_build(l
, 288, 257, cplens
, cplext
, &tl
, &bl
)) != 0) {
638 /* set up distance table */
639 for (i
= 0; i
< 30; i
++) { /* make an incomplete code set */
643 if ((i
= huft_build(l
, 30, 0, cpdist
, cpdext
, &td
, &bd
)) > 1) {
648 /* decompress until an end-of-block code */
649 if (inflate_codes(tl
, td
, bl
, bd
)) {
655 /* free the decoding tables, return */
660 case 2: /* Inflate dynamic */
662 /* Tables for deflate from PKZIP's appnote.txt. */
663 static unsigned border
[] = { /* Order of the bit length code lengths */
664 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
666 int dbits
= 6; /* bits in base distance lookup table */
667 int lbits
= 9; /* bits in base literal/length lookup table */
669 int i
; /* temporary variables */
671 unsigned l
; /* last length */
672 unsigned m
; /* mask for bit lengths table */
673 unsigned n
; /* number of lengths to get */
674 huft_t
*tl
; /* literal/length code table */
675 huft_t
*td
; /* distance code table */
676 int bl
; /* lookup bits for tl */
677 int bd
; /* lookup bits for td */
678 unsigned nb
; /* number of bit length codes */
679 unsigned nl
; /* number of literal/length codes */
680 unsigned nd
; /* number of distance codes */
682 unsigned ll
[286 + 30]; /* literal/length and distance code lengths */
683 unsigned long b_dynamic
; /* bit buffer */
684 unsigned k_dynamic
; /* number of bits in bit buffer */
686 /* make local bit buffer */
690 /* read in table lengths */
691 while (k_dynamic
< 5) {
692 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
695 nl
= 257 + ((unsigned) b_dynamic
& 0x1f); /* number of literal/length codes */
698 while (k_dynamic
< 5) {
699 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
702 nd
= 1 + ((unsigned) b_dynamic
& 0x1f); /* number of distance codes */
705 while (k_dynamic
< 4) {
706 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
709 nb
= 4 + ((unsigned) b_dynamic
& 0xf); /* number of bit length codes */
712 if (nl
> 286 || nd
> 30) {
713 return 1; /* bad lengths */
716 /* read in bit-length-code lengths */
717 for (j
= 0; j
< nb
; j
++) {
718 while (k_dynamic
< 3) {
719 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
722 ll
[border
[j
]] = (unsigned) b_dynamic
& 7;
726 for (; j
< 19; j
++) {
730 /* build decoding table for trees--single level, 7 bit lookup */
732 if ((i
= huft_build(ll
, 19, 19, NULL
, NULL
, &tl
, &bl
)) != 0) {
736 return i
; /* incomplete code set */
739 /* read in literal and distance code lengths */
743 while ((unsigned) i
< n
) {
744 while (k_dynamic
< (unsigned) bl
) {
745 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
748 j
= (td
= tl
+ ((unsigned) b_dynamic
& m
))->b
;
752 if (j
< 16) { /* length of code in bits (0..15) */
753 ll
[i
++] = l
= j
; /* save last length in l */
755 else if (j
== 16) { /* repeat last length 3 to 6 times */
756 while (k_dynamic
< 2) {
757 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
760 j
= 3 + ((unsigned) b_dynamic
& 3);
763 if ((unsigned) i
+ j
> n
) {
769 } else if (j
== 17) { /* 3 to 10 zero length codes */
770 while (k_dynamic
< 3) {
771 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
774 j
= 3 + ((unsigned) b_dynamic
& 7);
777 if ((unsigned) i
+ j
> n
) {
784 } else { /* j == 18: 11 to 138 zero length codes */
785 while (k_dynamic
< 7) {
786 b_dynamic
|= ((unsigned long)fgetc(in_file
)) << k_dynamic
;
789 j
= 11 + ((unsigned) b_dynamic
& 0x7f);
792 if ((unsigned) i
+ j
> n
) {
802 /* free decoding table for trees */
805 /* restore the global bit buffer */
809 /* build the decoding tables for literal/length and distance codes */
811 if ((i
= huft_build(ll
, nl
, 257, cplens
, cplext
, &tl
, &bl
)) != 0) {
813 error_msg("Incomplete literal tree");
816 return i
; /* incomplete code set */
819 if ((i
= huft_build(ll
+ nl
, nd
, 0, cpdist
, cpdext
, &td
, &bd
)) != 0) {
821 error_msg("incomplete distance tree");
825 return i
; /* incomplete code set */
828 /* decompress until an end-of-block code */
829 if (inflate_codes(tl
, td
, bl
, bd
)) {
835 /* free the decoding tables, return */
847 * decompress an inflated entry
849 * GLOBAL VARIABLES: outcnt, bk, bb, hufts, inptr
853 int e
; /* last block flag */
854 int r
; /* result code */
855 unsigned h
= 0; /* maximum struct huft's malloc'ed */
857 /* initialize window, bit buffer */
862 /* decompress until the last block */
865 if ((r
= inflate_block(&e
)) != 0) {
873 /* Undo too much lookahead. The next read will be byte aligned so we
874 * can discard unused bits in the last meaningful byte. */
877 ungetc((bb
<< bk
), in_file
);
880 /* flush out window */
887 /* ===========================================================================
888 * Unzip in to out. This routine works on both gzip and pkzip files.
890 * IN assertions: the buffer inbuf contains already the beginning of
891 * the compressed data, from offsets inptr to insize-1 included.
892 * The magic header has already been checked. The output buffer is cleared.
893 * in, out: input and output file descriptors
895 extern int unzip(FILE *l_in_file
, FILE *l_out_file
)
897 const int extra_field
= 0x04; /* bit 2 set: extra field present */
898 const int orig_name
= 0x08; /* bit 3 set: original file name present */
899 const int comment
= 0x10; /* bit 4 set: file comment present */
900 unsigned char buf
[8]; /* extended local header */
901 unsigned char flags
; /* compression flags */
902 char magic
[2]; /* magic header */
904 typedef void (*sig_type
) (int);
905 int exit_code
=0; /* program exit code */
909 out_file
= l_out_file
;
911 if (signal(SIGINT
, SIG_IGN
) != SIG_IGN
) {
912 (void) signal(SIGINT
, (sig_type
) abort_gzip
);
915 // if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
916 // (void) signal(SIGTERM, (sig_type) abort_gzip);
920 if (signal(SIGHUP
, SIG_IGN
) != SIG_IGN
) {
921 (void) signal(SIGHUP
, (sig_type
) abort_gzip
);
925 signal(SIGPIPE
, SIG_IGN
);
927 /* Allocate all global buffers (for DYN_ALLOC option) */
928 window
= xmalloc((size_t)(((2L*WSIZE
)+1L)*sizeof(unsigned char)));
932 magic
[0] = fgetc(in_file
);
933 magic
[1] = fgetc(in_file
);
935 /* Magic header for gzip files, 1F 8B = \037\213 */
936 if (memcmp(magic
, "\037\213", 2) != 0) {
937 error_msg("Invalid gzip magic");
941 method
= (int) fgetc(in_file
);
943 error_msg("unknown method %d -- get newer version of gzip", method
);
948 flags
= (unsigned char) fgetc(in_file
);
950 /* Ignore time stamp(4), extra flags(1), OS type(1) */
951 for (i
= 0; i
< 6; i
++)
954 if ((flags
& extra_field
) != 0) {
956 extra
= fgetc(in_file
);
957 extra
+= fgetc(in_file
) << 8;
959 for (i
= 0; i
< extra
; i
++)
963 /* Discard original name if any */
964 if ((flags
& orig_name
) != 0) {
965 while (fgetc(in_file
) != 0); /* null */
968 /* Discard file comment if any */
969 if ((flags
& comment
) != 0) {
970 while (fgetc(in_file
) != 0); /* null */
985 perror_msg("inflate");
987 } else if (res
!= 0) {
988 error_msg("invalid compressed data--format violated");
993 error_msg("internal error, invalid method");
997 /* Get the crc and original length
998 * crc32 (see algorithm.doc)
999 * uncompressed input size modulo 2^32
1001 fread(buf
, 1, 8, in_file
);
1003 /* Validate decompression - crc */
1004 if (!exit_code
&& (unsigned int)((buf
[0] | (buf
[1] << 8)) |((buf
[2] | (buf
[3] << 8)) << 16)) != (crc
^ 0xffffffffL
)) {
1005 error_msg("invalid compressed data--crc error");
1008 /* Validate decompression - size */
1009 if (!exit_code
&& ((buf
[4] | (buf
[5] << 8)) |((buf
[6] | (buf
[7] << 8)) << 16)) != (unsigned long) bytes_out
) {
1010 error_msg("invalid compressed data--length error");