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
--) {
128 table_entry
& 1 ? (table_entry
>> 1) ^ poly
:
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
) {
152 * The Parent process may not be interested in all the data we have,
153 * in which case it will rudely close its end of the pipe and
154 * wait for us to exit.
159 error_msg("Couldnt write");
162 bytes_out
+= (unsigned long)outcnt
;
167 * Free the malloc'ed tables built by huft_build(), which makes a linked
168 * list of the tables it made, with the links in a dummy first entry of
172 static int huft_free(huft_t
* t
)
176 /* Go through linked list, freeing from the malloced (t[-1]) address. */
178 while (p
!= (huft_t
*) NULL
) {
186 /* Given a list of code lengths and a maximum table size, make a set of
187 * tables to decode that set of codes. Return zero on success, one if
188 * the given code set is incomplete (the tables are still built in this
189 * case), two if the input is invalid (all zero length codes or an
190 * oversubscribed set of lengths), and three if not enough memory.
192 * b: code lengths in bits (all assumed <= BMAX)
193 * n: number of codes (assumed <= N_MAX)
194 * s: number of simple-valued codes (0..s-1)
195 * d: list of base values for non-simple codes
196 * e: list of extra bits for non-simple codes
197 * t: result: starting table
198 * m: maximum lookup bits, returns actual
200 static int huft_build(unsigned int *b
, const unsigned int n
,
201 const unsigned int s
, const unsigned short *d
,
202 const unsigned short *e
, huft_t
** t
, int *m
)
204 unsigned a
; /* counter for codes of length k */
205 unsigned c
[BMAX
+ 1]; /* bit length count table */
206 unsigned f
; /* i repeats in table every f entries */
207 int g
; /* maximum code length */
208 int h
; /* table level */
209 unsigned i
; /* counter, current code */
210 unsigned j
; /* counter */
211 int k
; /* number of bits in current code */
212 int l
; /* bits per table (returned in m) */
213 unsigned *p
; /* pointer into c[], b[], or v[] */
214 huft_t
*q
; /* points to current table */
215 huft_t r
; /* table entry for structure assignment */
216 huft_t
*u
[BMAX
]; /* table stack */
217 unsigned v
[N_MAX
]; /* values in order of bit length */
218 int w
; /* bits before this table == (l * h) */
219 unsigned x
[BMAX
+ 1]; /* bit offsets, then code stack */
220 unsigned *xp
; /* pointer into x */
221 int y
; /* number of dummy codes added */
222 unsigned z
; /* number of entries in current table */
224 /* Generate counts for each bit length */
225 memset((void *)(c
), 0, sizeof(c
));
229 c
[*p
]++; /* assume all entries <= BMAX */
230 p
++; /* Can't combine with above line (Solaris bug) */
232 if (c
[0] == n
) { /* null input--all zero length codes */
233 *t
= (huft_t
*) NULL
;
238 /* Find minimum and maximum length, bound *m by those */
240 for (j
= 1; j
<= BMAX
; j
++)
243 k
= j
; /* minimum code length */
246 for (i
= BMAX
; i
; i
--)
249 g
= i
; /* maximum code length */
254 /* Adjust last length count to fill out codes, if needed */
255 for (y
= 1 << j
; j
< i
; j
++, y
<<= 1)
257 return 2; /* bad input: more codes than bits */
262 /* Generate starting offsets into the value table for each length */
266 while (--i
) { /* note that i == g from above */
270 /* Make a table of values in order of bit lengths */
278 /* Generate the Huffman codes and for each, make the table entries */
279 x
[0] = i
= 0; /* first Huffman code is zero */
280 p
= v
; /* grab values in bit order */
281 h
= -1; /* no tables yet--level -1 */
282 w
= -l
; /* bits decoded == (l * h) */
283 u
[0] = (huft_t
*) NULL
; /* just to keep compilers happy */
284 q
= (huft_t
*) NULL
; /* ditto */
287 /* go through the bit lengths (k already is bits in shortest code) */
288 for (; k
<= g
; k
++) {
291 /* here i is the Huffman code of length k bits for value *p */
292 /* make tables up to required level */
295 w
+= l
; /* previous table always l bits */
297 /* compute minimum size table less than or equal to l bits */
298 z
= (z
= g
- w
) > (unsigned)l
? l
: z
; /* upper limit on table size */
299 if ((f
= 1 << (j
= k
- w
)) > a
+ 1) { /* try a k-w bit table *//* too few codes for k-w bit table */
300 f
-= a
+ 1; /* deduct codes from patterns left */
302 while (++j
< z
) { /* try smaller tables up to z bits */
303 if ((f
<<= 1) <= *++xp
)
304 break; /* enough codes to use up j bits */
305 f
-= *xp
; /* else deduct codes from patterns */
308 z
= 1 << j
; /* table entries for j-bit table */
310 /* allocate and link in new table */
312 (huft_t
*) xmalloc((z
+ 1) *
318 return 3; /* not enough memory */
320 hufts
+= z
+ 1; /* track memory usage */
321 *t
= q
+ 1; /* link to list for huft_free() */
322 *(t
= &(q
->v
.t
)) = NULL
;
323 u
[h
] = ++q
; /* table starts after link */
325 /* connect to last table, if there is one */
327 x
[h
] = i
; /* save pattern for backing up */
328 r
.b
= (unsigned char)l
; /* bits to dump before this table */
329 r
.e
= (unsigned char)(16 + j
); /* bits in this table */
330 r
.v
.t
= q
; /* pointer to this table */
331 j
= i
>> (w
- l
); /* (get around Turbo C bug) */
332 u
[h
- 1][j
] = r
; /* connect to last table */
336 /* set up table entry in r */
337 r
.b
= (unsigned char)(k
- w
);
339 r
.e
= 99; /* out of values--invalid code */
341 r
.e
= (unsigned char)(*p
< 256 ? 16 : 15); /* 256 is end-of-block code */
342 r
.v
.n
= (unsigned short)(*p
); /* simple code is just the value */
343 p
++; /* one compiler does not like *p++ */
345 r
.e
= (unsigned char)e
[*p
- s
]; /* non-simple--look up in lists */
349 /* fill code-like entries with r */
351 for (j
= i
>> w
; j
< z
; j
+= f
)
354 /* backwards increment the k-bit code i */
355 for (j
= 1 << (k
- 1); i
& j
; j
>>= 1)
359 /* backup over finished tables */
360 while ((i
& ((1 << w
) - 1)) != x
[h
]) {
361 h
--; /* don't need to update q */
366 /* Return true (1) if we were given an incomplete table */
367 return y
!= 0 && g
!= 1;
371 * inflate (decompress) the codes in a deflated (compressed) block.
372 * Return an error code or zero if it all goes ok.
374 * tl, td: literal/length and distance decoder tables
375 * bl, bd: number of bits decoded by tl[] and td[]
377 static int inflate_codes(huft_t
* tl
, huft_t
* td
, int bl
, int bd
)
379 unsigned long e
; /* table entry flag/number of extra bits */
380 unsigned long n
, d
; /* length and index for copy */
381 unsigned long w
; /* current window position */
382 huft_t
*t
; /* pointer to table entry */
383 unsigned ml
, md
; /* masks for bl and bd bits */
384 unsigned long b
; /* bit buffer */
385 unsigned k
; /* number of bits in bit buffer */
387 /* make local copies of globals */
388 b
= bb
; /* initialize bit buffer */
390 w
= outcnt
; /* initialize window position */
392 /* inflate the coded data */
393 ml
= mask_bits
[bl
]; /* precompute masks for speed */
395 for (;;) { /* do until end of block */
396 while (k
< (unsigned)bl
) {
397 b
|= ((unsigned long)fgetc(in_file
)) << k
;
400 if ((e
= (t
= tl
+ ((unsigned)b
& ml
))->e
) > 16)
409 b
|= ((unsigned long)fgetc(in_file
)) <<
415 t
->v
.t
+ ((unsigned)b
& mask_bits
[e
]))->e
) >
419 if (e
== 16) { /* then it's a literal */
420 window
[w
++] = (unsigned char)t
->v
.n
;
422 outcnt
= (w
), flush_window();
425 } else { /* it's an EOB or a length */
427 /* exit if end of block */
432 /* get length of block to copy */
434 b
|= ((unsigned long)fgetc(in_file
)) << k
;
437 n
= t
->v
.n
+ ((unsigned)b
& mask_bits
[e
]);
441 /* decode distance of block to copy */
442 while (k
< (unsigned)bd
) {
443 b
|= ((unsigned long)fgetc(in_file
)) << k
;
447 if ((e
= (t
= td
+ ((unsigned)b
& md
))->e
) > 16)
455 b
|= ((unsigned long)
456 fgetc(in_file
)) << k
;
462 ((unsigned)b
& mask_bits
[e
]))->e
) >
467 b
|= ((unsigned long)fgetc(in_file
)) << k
;
470 d
= w
- t
->v
.n
- ((unsigned)b
& mask_bits
[e
]);
478 WSIZE
- ((d
&= WSIZE
- 1) > w
? d
: w
)) >
480 #if !defined(NOMEMCPY) && !defined(DEBUG)
481 if (w
- d
>= e
) { /* (this test assumes unsigned comparison) */
482 memcpy(window
+ w
, window
+ d
, e
);
485 } else /* do it slow to avoid memcpy() overlap */
486 #endif /* !NOMEMCPY */
488 window
[w
++] = window
[d
++];
491 outcnt
= (w
), flush_window();
498 /* restore the globals from the locals */
499 outcnt
= w
; /* restore global window pointer */
500 bb
= b
; /* restore global bit buffer */
508 * decompress an inflated block
511 * GLOBAL VARIABLES: bb, kk,
513 static int inflate_block(int *e
)
515 unsigned t
; /* block type */
516 unsigned long b
; /* bit buffer */
517 unsigned k
; /* number of bits in bit buffer */
518 static unsigned short cplens
[] = { /* Copy lengths for literal codes 257..285 */
519 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
520 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
522 /* note: see note #13 above about the 258 in this list. */
523 static unsigned short cplext
[] = { /* Extra bits for literal codes 257..285 */
524 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
525 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
527 static unsigned short cpdist
[] = { /* Copy offsets for distance codes 0..29 */
528 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
529 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
530 8193, 12289, 16385, 24577
532 static unsigned short cpdext
[] = { /* Extra bits for distance codes */
533 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
534 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
538 /* make local bit buffer */
542 /* read in last block bit */
544 b
|= ((unsigned long)fgetc(in_file
)) << k
;
551 /* read in block type */
553 b
|= ((unsigned long)fgetc(in_file
)) << k
;
560 /* restore the global bit buffer */
564 /* inflate that block type */
566 case 0: /* Inflate stored */
568 unsigned long n
; /* number of bytes in block */
569 unsigned long w
; /* current window position */
570 unsigned long b_stored
; /* bit buffer */
571 unsigned long k_stored
; /* number of bits in bit buffer */
573 /* make local copies of globals */
574 b_stored
= bb
; /* initialize bit buffer */
576 w
= outcnt
; /* initialize window position */
578 /* go to byte boundary */
583 /* get the length and its complement */
584 while (k_stored
< 16) {
586 ((unsigned long)fgetc(in_file
)) << k_stored
;
589 n
= ((unsigned)b_stored
& 0xffff);
592 while (k_stored
< 16) {
594 ((unsigned long)fgetc(in_file
)) << k_stored
;
597 if (n
!= (unsigned)((~b_stored
) & 0xffff)) {
598 return 1; /* error in compressed data */
603 /* read and output the compressed data */
605 while (k_stored
< 8) {
607 ((unsigned long)fgetc(in_file
)) <<
611 window
[w
++] = (unsigned char)b_stored
;
612 if (w
== (unsigned long)WSIZE
) {
613 outcnt
= (w
), flush_window();
620 /* restore the globals from the locals */
621 outcnt
= w
; /* restore global window pointer */
622 bb
= b_stored
; /* restore global bit buffer */
626 case 1: /* Inflate fixed
627 * decompress an inflated type 1 (fixed Huffman codes) block. We should
628 * either replace this with a custom decoder, or at least precompute the
632 int i
; /* temporary variable */
633 huft_t
*tl
; /* literal/length code table */
634 huft_t
*td
; /* distance code table */
635 int bl
; /* lookup bits for tl */
636 int bd
; /* lookup bits for td */
637 unsigned int l
[288]; /* length list for huft_build */
639 /* set up literal table */
640 for (i
= 0; i
< 144; i
++) {
643 for (; i
< 256; i
++) {
646 for (; i
< 280; i
++) {
649 for (; i
< 288; i
++) { /* make a complete, but wrong code set */
654 huft_build(l
, 288, 257, cplens
, cplext
, &tl
,
659 /* set up distance table */
660 for (i
= 0; i
< 30; i
++) { /* make an incomplete code set */
665 huft_build(l
, 30, 0, cpdist
, cpdext
, &td
,
671 /* decompress until an end-of-block code */
672 if (inflate_codes(tl
, td
, bl
, bd
)) {
678 /* free the decoding tables, return */
683 case 2: /* Inflate dynamic */
685 /* Tables for deflate from PKZIP's appnote.txt. */
686 static unsigned border
[] = { /* Order of the bit length code lengths */
687 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3,
690 int dbits
= 6; /* bits in base distance lookup table */
691 int lbits
= 9; /* bits in base literal/length lookup table */
693 int i
; /* temporary variables */
695 unsigned l
; /* last length */
696 unsigned m
; /* mask for bit lengths table */
697 unsigned n
; /* number of lengths to get */
698 huft_t
*tl
; /* literal/length code table */
699 huft_t
*td
; /* distance code table */
700 int bl
; /* lookup bits for tl */
701 int bd
; /* lookup bits for td */
702 unsigned nb
; /* number of bit length codes */
703 unsigned nl
; /* number of literal/length codes */
704 unsigned nd
; /* number of distance codes */
706 unsigned ll
[286 + 30]; /* literal/length and distance code lengths */
707 unsigned long b_dynamic
; /* bit buffer */
708 unsigned k_dynamic
; /* number of bits in bit buffer */
710 /* make local bit buffer */
714 /* read in table lengths */
715 while (k_dynamic
< 5) {
717 ((unsigned long)fgetc(in_file
)) <<
721 nl
= 257 + ((unsigned)b_dynamic
& 0x1f); /* number of literal/length codes */
724 while (k_dynamic
< 5) {
726 ((unsigned long)fgetc(in_file
)) <<
730 nd
= 1 + ((unsigned)b_dynamic
& 0x1f); /* number of distance codes */
733 while (k_dynamic
< 4) {
735 ((unsigned long)fgetc(in_file
)) <<
739 nb
= 4 + ((unsigned)b_dynamic
& 0xf); /* number of bit length codes */
742 if (nl
> 286 || nd
> 30) {
743 return 1; /* bad lengths */
746 /* read in bit-length-code lengths */
747 for (j
= 0; j
< nb
; j
++) {
748 while (k_dynamic
< 3) {
750 ((unsigned long)fgetc(in_file
)) <<
754 ll
[border
[j
]] = (unsigned)b_dynamic
& 7;
758 for (; j
< 19; j
++) {
762 /* build decoding table for trees--single level, 7 bit lookup */
765 huft_build(ll
, 19, 19, NULL
, NULL
, &tl
,
770 return i
; /* incomplete code set */
773 /* read in literal and distance code lengths */
777 while ((unsigned)i
< n
) {
778 while (k_dynamic
< (unsigned)bl
) {
780 ((unsigned long)fgetc(in_file
)) <<
784 j
= (td
= tl
+ ((unsigned)b_dynamic
& m
))->b
;
788 if (j
< 16) { /* length of code in bits (0..15) */
789 ll
[i
++] = l
= j
; /* save last length in l */
790 } else if (j
== 16) { /* repeat last length 3 to 6 times */
791 while (k_dynamic
< 2) {
798 j
= 3 + ((unsigned)b_dynamic
& 3);
801 if ((unsigned)i
+ j
> n
) {
807 } else if (j
== 17) { /* 3 to 10 zero length codes */
808 while (k_dynamic
< 3) {
815 j
= 3 + ((unsigned)b_dynamic
& 7);
818 if ((unsigned)i
+ j
> n
) {
825 } else { /* j == 18: 11 to 138 zero length codes */
826 while (k_dynamic
< 7) {
833 j
= 11 + ((unsigned)b_dynamic
& 0x7f);
836 if ((unsigned)i
+ j
> n
) {
846 /* free decoding table for trees */
849 /* restore the global bit buffer */
853 /* build the decoding tables for literal/length and distance codes */
856 huft_build(ll
, nl
, 257, cplens
, cplext
, &tl
,
859 error_msg("Incomplete literal tree");
862 return i
; /* incomplete code set */
866 huft_build(ll
+ nl
, nd
, 0, cpdist
, cpdext
, &td
,
869 error_msg("incomplete distance tree");
873 return i
; /* incomplete code set */
876 /* decompress until an end-of-block code */
877 if (inflate_codes(tl
, td
, bl
, bd
)) {
883 /* free the decoding tables, return */
895 * decompress an inflated entry
897 * GLOBAL VARIABLES: outcnt, bk, bb, hufts, inptr
901 int e
; /* last block flag */
902 int r
; /* result code */
903 unsigned h
= 0; /* maximum struct huft's malloc'ed */
905 /* initialize window, bit buffer */
910 /* decompress until the last block */
913 if ((r
= inflate_block(&e
)) != 0) {
921 /* Undo too much lookahead. The next read will be byte aligned so we
922 * can discard unused bits in the last meaningful byte. */
925 ungetc((bb
<< bk
), in_file
);
928 /* flush out window */
935 /* ===========================================================================
936 * Unzip in to out. This routine works on both gzip and pkzip files.
938 * IN assertions: the buffer inbuf contains already the beginning of
939 * the compressed data, from offsets inptr to insize-1 included.
940 * The magic header has already been checked. The output buffer is cleared.
941 * in, out: input and output file descriptors
943 extern int unzip(FILE * l_in_file
, FILE * l_out_file
)
945 const int extra_field
= 0x04; /* bit 2 set: extra field present */
946 const int orig_name
= 0x08; /* bit 3 set: original file name present */
947 const int comment
= 0x10; /* bit 4 set: file comment present */
948 unsigned char buf
[8]; /* extended local header */
949 unsigned char flags
; /* compression flags */
950 char magic
[2]; /* magic header */
952 typedef void (*sig_type
) (int);
953 int exit_code
= 0; /* program exit code */
957 out_file
= l_out_file
;
959 if (signal(SIGINT
, SIG_IGN
) != SIG_IGN
) {
960 (void)signal(SIGINT
, (sig_type
) abort_gzip
);
963 // if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
964 // (void) signal(SIGTERM, (sig_type) abort_gzip);
968 if (signal(SIGHUP
, SIG_IGN
) != SIG_IGN
) {
969 (void)signal(SIGHUP
, (sig_type
) abort_gzip
);
973 signal(SIGPIPE
, SIG_IGN
);
975 /* Allocate all global buffers (for DYN_ALLOC option) */
977 xmalloc((size_t) (((2L * WSIZE
) + 1L) * sizeof(unsigned char)));
981 magic
[0] = fgetc(in_file
);
982 magic
[1] = fgetc(in_file
);
984 /* Magic header for gzip files, 1F 8B = \037\213 */
985 if (memcmp(magic
, "\037\213", 2) != 0) {
986 error_msg("Invalid gzip magic");
990 method
= (int)fgetc(in_file
);
992 error_msg("unknown method %d -- get newer version of gzip",
998 flags
= (unsigned char)fgetc(in_file
);
1000 /* Ignore time stamp(4), extra flags(1), OS type(1) */
1001 for (i
= 0; i
< 6; i
++)
1004 if ((flags
& extra_field
) != 0) {
1006 extra
= fgetc(in_file
);
1007 extra
+= fgetc(in_file
) << 8;
1009 for (i
= 0; i
< extra
; i
++)
1013 /* Discard original name if any */
1014 if ((flags
& orig_name
) != 0) {
1015 while (fgetc(in_file
) != 0) ; /* null */
1018 /* Discard file comment if any */
1019 if ((flags
& comment
) != 0) {
1020 while (fgetc(in_file
) != 0) ; /* null */
1032 int res
= inflate();
1035 perror_msg("inflate");
1037 } else if (res
!= 0) {
1038 error_msg("invalid compressed data--format violated");
1043 error_msg("internal error, invalid method");
1047 /* Get the crc and original length
1048 * crc32 (see algorithm.doc)
1049 * uncompressed input size modulo 2^32
1051 fread(buf
, 1, 8, in_file
);
1053 /* Validate decompression - crc */
1055 && (unsigned int)((buf
[0] | (buf
[1] << 8)) |
1056 ((buf
[2] | (buf
[3] << 8)) << 16)) !=
1057 (crc
^ 0xffffffffL
)) {
1058 error_msg("invalid compressed data--crc error");
1061 /* Validate decompression - size */
1063 && ((buf
[4] | (buf
[5] << 8)) | ((buf
[6] | (buf
[7] << 8)) << 16)) !=
1064 (unsigned long)bytes_out
) {
1065 error_msg("invalid compressed data--length error");