archival/libunarchive/unzip.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * gunzip implementation for busybox
   4  *
   5  * Based on GNU gzip v1.2.4 Copyright (C) 1992-1993 Jean-loup Gailly.
   6  *
   7  * Originally adjusted for busybox by Sven Rudolph <sr1@inf.tu-dresden.de>
   8  * based on gzip sources
   9  *
  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.
  13  *
  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>
  16  *
  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.
  21  *
  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.
  26  *
  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
  30  *
  31  *
  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.
  38  *
  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.
  41  */
  42
  43 #if 0
  44 static char *license_msg[] = {
  45         "   Copyright (C) 1992-1993 Jean-loup Gailly",
  46         "   This program is free software; you can redistribute it and/or modify",
  47         "   it under the terms of the GNU General Public License as published by",
  48         "   the Free Software Foundation; either version 2, or (at your option)",
  49         "   any later version.",
  50         "",
  51         "   This program is distributed in the hope that it will be useful,",
  52         "   but WITHOUT ANY WARRANTY; without even the implied warranty of",
  53         "   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the",
  54         "   GNU General Public License for more details.",
  55         "",
  56         "   You should have received a copy of the GNU General Public License",
  57         "   along with this program; if not, write to the Free Software",
  58         "   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",
  59         0
  60 };
  61 #endif
  62
  63 #include <sys/types.h>
  64 #include <sys/wait.h>
  65 #include <signal.h>
  66 #include <stdlib.h>
  67 #include <string.h>
  68 #include "config.h"
  69 #include "libbb.h"
  70
  71 #ifdef CONFIG_FEATURE_UNCOMPRESS
  72 int uncompress(FILE * in, FILE * out);
  73 #endif
  74
  75 static FILE *in_file, *out_file;
  76
  77 /* these are freed by gz_close */
  78 static unsigned char *window;
  79 static unsigned long *crc_table;
  80
  81 static unsigned long crc;       /* shift register contents */
  82
  83 /* Return codes from gzip */
  84 #define ERROR 1
  85
  86 /*
  87  * window size--must be a power of two, and
  88  *  at least 32K for zip's deflate method
  89  */
  90 #define WSIZE 0x8000
  91
  92 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
  93 #define BMAX 16 /* maximum bit length of any code (16 for explode) */
  94 #define N_MAX 288       /* maximum number of codes in any set */
  95
  96 static long bytes_out;  /* number of output bytes */
  97 static unsigned long outcnt;    /* bytes in output buffer */
  98
  99 static unsigned hufts;  /* track memory usage */
 100 static unsigned long bb;        /* bit buffer */
 101 static unsigned bk;             /* bits in bit buffer */
 102
 103 typedef struct huft_s {
 104         unsigned char e;        /* number of extra bits or operation */
 105         unsigned char b;        /* number of bits in this code or subcode */
 106         union {
 107                 unsigned short n;       /* literal, length base, or distance base */
 108                 struct huft_s *t;       /* pointer to next level of table */
 109         } v;
 110 } huft_t;
 111
 112 static const unsigned short mask_bits[] = {
 113         0x0000,
 114         0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
 115         0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
 116 };
 117
 118 /* static int error_number = 0; */
 119 /* ========================================================================
 120  * Signal and error handler.
 121  */
 122
 123 static void abort_gzip(void)
 124 {
 125         error_msg("gzip aborted\n");
 126         exit(ERROR);
 127 }
 128
 129 static void make_crc_table(void)
 130 {
 131         const unsigned long poly = 0xedb88320;  /* polynomial exclusive-or pattern */
 132         unsigned short i;       /* counter for all possible eight bit values */
 133
 134         /* initial shift register value */
 135         crc = 0xffffffffL;
 136         crc_table = (unsigned long *) malloc(256 * sizeof(unsigned long));
 137
 138         /* Compute and print table of CRC's, five per line */
 139         for (i = 0; i < 256; i++) {
 140                 unsigned long table_entry;      /* crc shift register */
 141                 char k;                 /* byte being shifted into crc apparatus */
 142
 143                 table_entry = i;
 144                 /* The idea to initialize the register with the byte instead of
 145                    * zero was stolen from Haruhiko Okumura's ar002
 146                  */
 147                 for (k = 8; k; k--) {
 148                         table_entry =
 149                                 table_entry & 1 ? (table_entry >> 1) ^ poly : table_entry >>
 150                                 1;
 151                 }
 152                 crc_table[i] = table_entry;
 153         }
 154 }
 155
 156 /* ===========================================================================
 157  * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 158  * (Used for the decompressed data only.)
 159  */
 160 static void flush_window(void)
 161 {
 162         int n;
 163
 164         if (outcnt == 0)
 165                 return;
 166
 167         for (n = 0; n < outcnt; n++) {
 168                 crc = crc_table[((int) crc ^ (window[n])) & 0xff] ^ (crc >> 8);
 169         }
 170
 171         if (fwrite(window, 1, outcnt, out_file) != outcnt) {
 172                 error_msg_and_die("Couldnt write");
 173         }
 174         bytes_out += (unsigned long) outcnt;
 175         outcnt = 0;
 176 }
 177
 178 /*
 179  * Free the malloc'ed tables built by huft_build(), which makes a linked
 180  * list of the tables it made, with the links in a dummy first entry of
 181  * each table.
 182  * t: table to free
 183  */
 184 static int huft_free(huft_t * t)
 185 {
 186         huft_t *p, *q;
 187
 188         /* Go through linked list, freeing from the malloced (t[-1]) address. */
 189         p = t;
 190         while (p != (huft_t *) NULL) {
 191                 q = (--p)->v.t;
 192                 free((char *) p);
 193                 p = q;
 194         }
 195         return 0;
 196 }
 197
 198 typedef unsigned char extra_bits_t;
 199
 200 /* Given a list of code lengths and a maximum table size, make a set of
 201  * tables to decode that set of codes.  Return zero on success, one if
 202  * the given code set is incomplete (the tables are still built in this
 203  * case), two if the input is invalid (all zero length codes or an
 204  * oversubscribed set of lengths), and three if not enough memory.
 205  *
 206  * b:   code lengths in bits (all assumed <= BMAX)
 207  * n:   number of codes (assumed <= N_MAX)
 208  * s:   number of simple-valued codes (0..s-1)
 209  * d:   list of base values for non-simple codes
 210  * e:   list of extra bits for non-simple codes
 211  * t:   result: starting table
 212  * m:   maximum lookup bits, returns actual
 213  */
 214 static int huft_build(unsigned int *b, const unsigned int n,
 215                                           const unsigned int s, const unsigned short *d,
 216                                           const extra_bits_t * e, huft_t ** t, int *m)
 217 {
 218         unsigned a;                     /* counter for codes of length k */
 219         unsigned c[BMAX + 1];   /* bit length count table */
 220         unsigned f;                     /* i repeats in table every f entries */
 221         int g;                          /* maximum code length */
 222         int h;                          /* table level */
 223         register unsigned i;    /* counter, current code */
 224         register unsigned j;    /* counter */
 225         register int k;         /* number of bits in current code */
 226         int l;                          /* bits per table (returned in m) */
 227         register unsigned *p;   /* pointer into c[], b[], or v[] */
 228         register huft_t *q;     /* points to current table */
 229         huft_t r;                       /* table entry for structure assignment */
 230         huft_t *u[BMAX];        /* table stack */
 231         unsigned v[N_MAX];      /* values in order of bit length */
 232         register int w;         /* bits before this table == (l * h) */
 233         unsigned x[BMAX + 1];   /* bit offsets, then code stack */
 234         unsigned *xp;           /* pointer into x */
 235         int y;                          /* number of dummy codes added */
 236         unsigned z;                     /* number of entries in current table */
 237
 238         /* Generate counts for each bit length */
 239         memset((void *) (c), 0, sizeof(c));
 240         p = b;
 241         i = n;
 242         do {
 243                 c[*p]++;                /* assume all entries <= BMAX */
 244                 p++;                    /* Can't combine with above line (Solaris bug) */
 245         } while (--i);
 246         if (c[0] == n) {        /* null input--all zero length codes */
 247                 *t = (huft_t *) NULL;
 248                 *m = 0;
 249                 return 0;
 250         }
 251
 252         /* Find minimum and maximum length, bound *m by those */
 253         l = *m;
 254         for (j = 1; j <= BMAX; j++)
 255                 if (c[j])
 256                         break;
 257         k = j;                          /* minimum code length */
 258         if ((unsigned) l < j)
 259                 l = j;
 260         for (i = BMAX; i; i--)
 261                 if (c[i])
 262                         break;
 263         g = i;                          /* maximum code length */
 264         if ((unsigned) l > i)
 265                 l = i;
 266         *m = l;
 267
 268         /* Adjust last length count to fill out codes, if needed */
 269         for (y = 1 << j; j < i; j++, y <<= 1)
 270                 if ((y -= c[j]) < 0)
 271                         return 2;       /* bad input: more codes than bits */
 272         if ((y -= c[i]) < 0)
 273                 return 2;
 274         c[i] += y;
 275
 276         /* Generate starting offsets into the value table for each length */
 277         x[1] = j = 0;
 278         p = c + 1;
 279         xp = x + 2;
 280         while (--i) {           /* note that i == g from above */
 281                 *xp++ = (j += *p++);
 282         }
 283
 284         /* Make a table of values in order of bit lengths */
 285         p = b;
 286         i = 0;
 287         do {
 288                 if ((j = *p++) != 0)
 289                         v[x[j]++] = i;
 290         } while (++i < n);
 291
 292         /* Generate the Huffman codes and for each, make the table entries */
 293         x[0] = i = 0;           /* first Huffman code is zero */
 294         p = v;                          /* grab values in bit order */
 295         h = -1;                         /* no tables yet--level -1 */
 296         w = -l;                         /* bits decoded == (l * h) */
 297         u[0] = (huft_t *) NULL; /* just to keep compilers happy */
 298         q = (huft_t *) NULL;    /* ditto */
 299         z = 0;                          /* ditto */
 300
 301         /* go through the bit lengths (k already is bits in shortest code) */
 302         for (; k <= g; k++) {
 303                 a = c[k];
 304                 while (a--) {
 305                         /* here i is the Huffman code of length k bits for value *p */
 306                         /* make tables up to required level */
 307                         while (k > w + l) {
 308                                 h++;
 309                                 w += l; /* previous table always l bits */
 310
 311                                 /* compute minimum size table less than or equal to l bits */
 312                                 z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
 313                                 if ((f = 1 << (j = k - w)) > a + 1) {   /* try a k-w bit table *//* too few codes for k-w bit table */
 314                                         f -= a + 1;     /* deduct codes from patterns left */
 315                                         xp = c + k;
 316                                         while (++j < z) {       /* try smaller tables up to z bits */
 317                                                 if ((f <<= 1) <= *++xp)
 318                                                         break;  /* enough codes to use up j bits */
 319                                                 f -= *xp;       /* else deduct codes from patterns */
 320                                         }
 321                                 }
 322                                 z = 1 << j;     /* table entries for j-bit table */
 323
 324                                 /* allocate and link in new table */
 325                                 q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t));
 326
 327                                 hufts += z + 1; /* track memory usage */
 328                                 *t = q + 1;     /* link to list for huft_free() */
 329                                 *(t = &(q->v.t)) = NULL;
 330                                 u[h] = ++q;     /* table starts after link */
 331
 332                                 /* connect to last table, if there is one */
 333                                 if (h) {
 334                                         x[h] = i;       /* save pattern for backing up */
 335                                         r.b = (unsigned char) l;        /* bits to dump before this table */
 336                                         r.e = (unsigned char) (16 + j); /* bits in this table */
 337                                         r.v.t = q;      /* pointer to this table */
 338                                         j = i >> (w - l);       /* (get around Turbo C bug) */
 339                                         u[h - 1][j] = r;        /* connect to last table */
 340                                 }
 341                         }
 342
 343                         /* set up table entry in r */
 344                         r.b = (unsigned char) (k - w);
 345                         if (p >= v + n)
 346                                 r.e = 99;       /* out of values--invalid code */
 347                         else if (*p < s) {
 348                                 r.e = (unsigned char) (*p < 256 ? 16 : 15);     /* 256 is end-of-block code */
 349                                 r.v.n = (unsigned short) (*p);  /* simple code is just the value */
 350                                 p++;    /* one compiler does not like *p++ */
 351                         } else {
 352                                 r.e = (unsigned char) e[*p - s];        /* non-simple--look up in lists */
 353                                 r.v.n = d[*p++ - s];
 354                         }
 355
 356                         /* fill code-like entries with r */
 357                         f = 1 << (k - w);
 358                         for (j = i >> w; j < z; j += f)
 359                                 q[j] = r;
 360
 361                         /* backwards increment the k-bit code i */
 362                         for (j = 1 << (k - 1); i & j; j >>= 1)
 363                                 i ^= j;
 364                         i ^= j;
 365
 366                         /* backup over finished tables */
 367                         while ((i & ((1 << w) - 1)) != x[h]) {
 368                                 h--;    /* don't need to update q */
 369                                 w -= l;
 370                         }
 371                 }
 372         }
 373         /* Return true (1) if we were given an incomplete table */
 374         return y != 0 && g != 1;
 375 }
 376
 377 /*
 378  * inflate (decompress) the codes in a deflated (compressed) block.
 379  * Return an error code or zero if it all goes ok.
 380  *
 381  * tl, td: literal/length and distance decoder tables
 382  * bl, bd: number of bits decoded by tl[] and td[]
 383  */
 384 static int inflate_codes(huft_t * tl, huft_t * td, int bl, int bd)
 385 {
 386         register unsigned long e;       /* table entry flag/number of extra bits */
 387         unsigned long n, d;     /* length and index for copy */
 388         unsigned long w;        /* current window position */
 389         huft_t *t;                      /* pointer to table entry */
 390         unsigned ml, md;        /* masks for bl and bd bits */
 391         register unsigned long b;       /* bit buffer */
 392         register unsigned k;    /* number of bits in bit buffer */
 393         register int input_char;
 394
 395         /* make local copies of globals */
 396         b = bb;                         /* initialize bit buffer */
 397         k = bk;
 398         w = outcnt;                     /* initialize window position */
 399
 400         /* inflate the coded data */
 401         ml = mask_bits[bl];     /* precompute masks for speed */
 402         md = mask_bits[bd];
 403         for (;;) {                      /* do until end of block */
 404                 while (k < (unsigned) bl) {
 405                         input_char = fgetc(in_file);
 406                         if (input_char == EOF) return 1;
 407                         b |= ((unsigned long)input_char) << k;
 408                         k += 8;
 409                 }
 410                 if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
 411                         do {
 412                                 if (e == 99) {
 413                                         return 1;
 414                                 }
 415                                 b >>= t->b;
 416                                 k -= t->b;
 417                                 e -= 16;
 418                                 while (k < e) {
 419                                         input_char = fgetc(in_file);
 420                                         if (input_char == EOF) return 1;
 421                                         b |= ((unsigned long)input_char) << k;
 422                                         k += 8;
 423                                 }
 424                         } while ((e =
 425                                           (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
 426                 b >>= t->b;
 427                 k -= t->b;
 428                 if (e == 16) {  /* then it's a literal */
 429                         window[w++] = (unsigned char) t->v.n;
 430                         if (w == WSIZE) {
 431                                 outcnt = (w), flush_window();
 432                                 w = 0;
 433                         }
 434                 } else {                /* it's an EOB or a length */
 435
 436                         /* exit if end of block */
 437                         if (e == 15) {
 438                                 break;
 439                         }
 440
 441                         /* get length of block to copy */
 442                         while (k < e) {
 443                                 input_char = fgetc(in_file);
 444                                 if (input_char == EOF) return 1;
 445                                 b |= ((unsigned long)input_char) << k;
 446                                 k += 8;
 447                         }
 448                         n = t->v.n + ((unsigned) b & mask_bits[e]);
 449                         b >>= e;
 450                         k -= e;
 451
 452                         /* decode distance of block to copy */
 453                         while (k < (unsigned) bd) {
 454                                 input_char = fgetc(in_file);
 455                                 if (input_char == EOF) return 1;
 456                                 b |= ((unsigned long)input_char) << k;
 457                                 k += 8;
 458                         }
 459
 460                         if ((e = (t = td + ((unsigned) b & md))->e) > 16)
 461                                 do {
 462                                         if (e == 99)
 463                                                 return 1;
 464                                         b >>= t->b;
 465                                         k -= t->b;
 466                                         e -= 16;
 467                                         while (k < e) {
 468                                                 input_char = fgetc(in_file);
 469                                                 if (input_char == EOF) return 1;
 470                                                 b |= ((unsigned long)input_char) << k;
 471                                                 k += 8;
 472                                         }
 473                                 } while ((e =
 474                                                   (t =
 475                                                    t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
 476                         b >>= t->b;
 477                         k -= t->b;
 478                         while (k < e) {
 479                                 input_char = fgetc(in_file);
 480                                 if (input_char == EOF) return 1;
 481                                 b |= ((unsigned long)input_char) << k;
 482                                 k += 8;
 483                         }
 484                         d = w - t->v.n - ((unsigned) b & mask_bits[e]);
 485                         b >>= e;
 486                         k -= e;
 487
 488                         /* do the copy */
 489                         do {
 490                                 n -= (e =
 491                                           (e =
 492                                            WSIZE - ((d &= WSIZE - 1) > w ? d : w)) > n ? n : e);
 493 #if !defined(NOMEMCPY) && !defined(DEBUG)
 494                                 if (w - d >= e) {       /* (this test assumes unsigned comparison) */
 495                                         memcpy(window + w, window + d, e);
 496                                         w += e;
 497                                         d += e;
 498                                 } else  /* do it slow to avoid memcpy() overlap */
 499 #endif                                                  /* !NOMEMCPY */
 500                                         do {
 501                                                 window[w++] = window[d++];
 502                                         } while (--e);
 503                                 if (w == WSIZE) {
 504                                         outcnt = (w), flush_window();
 505                                         w = 0;
 506                                 }
 507                         } while (n);
 508                 }
 509         }
 510
 511         /* restore the globals from the locals */
 512         outcnt = w;                     /* restore global window pointer */
 513         bb = b;                         /* restore global bit buffer */
 514         bk = k;
 515
 516         /* done */
 517         return 0;
 518 }
 519
 520 static const unsigned short cplens[] = {        /* Copy lengths for literal codes 257..285 */
 521         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
 522         35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
 523 };
 524
 525 /* note: see note #13 above about the 258 in this list. */
 526 static const extra_bits_t cplext[] = {  /* Extra bits for literal codes 257..285 */
 527         0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
 528         3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
 529 };                                              /* 99==invalid */
 530 static const unsigned short cpdist[] = {        /* Copy offsets for distance codes 0..29 */
 531         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
 532         257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
 533         8193, 12289, 16385, 24577
 534 };
 535 static const extra_bits_t cpdext[] = {  /* Extra bits for distance codes */
 536         0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
 537         7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
 538         12, 12, 13, 13
 539 };
 540
 541 /* Tables for deflate from PKZIP's appnote.txt. */
 542 static const extra_bits_t border[] = {  /* Order of the bit length code lengths */
 543         16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
 544 };
 545
 546 /*
 547  * decompress an inflated block
 548  * e: last block flag
 549  *
 550  * GLOBAL VARIABLES: bb, kk,
 551  */
 552 static int inflate_block(int *e)
 553 {
 554         unsigned t;                     /* block type */
 555         register unsigned long b;       /* bit buffer */
 556         register unsigned k;    /* number of bits in bit buffer */
 557         int input_char;
 558
 559         /* make local bit buffer */
 560         b = bb;
 561         k = bk;
 562
 563         /* read in last block bit */
 564         while (k < 1) {
 565                 input_char = fgetc(in_file);
 566                 if (input_char == EOF) return 1;
 567                 b |= ((unsigned long)input_char) << k;
 568                 k += 8;
 569         }
 570         *e = (int) b & 1;
 571         b >>= 1;
 572         k -= 1;
 573
 574         /* read in block type */
 575         while (k < 2) {
 576                 input_char = fgetc(in_file);
 577                 if (input_char == EOF) return 1;
 578                 b |= ((unsigned long)input_char) << k;
 579                 k += 8;
 580         }
 581         t = (unsigned) b & 3;
 582         b >>= 2;
 583         k -= 2;
 584
 585         /* restore the global bit buffer */
 586         bb = b;
 587         bk = k;
 588
 589         /* inflate that block type */
 590         switch (t) {
 591         case 0:                 /* Inflate stored */
 592         {
 593                 unsigned long n;        /* number of bytes in block */
 594                 unsigned long w;        /* current window position */
 595                 register unsigned long b_stored;        /* bit buffer */
 596                 register unsigned long k_stored;        /* number of bits in bit buffer */
 597
 598                 /* make local copies of globals */
 599                 b_stored = bb;  /* initialize bit buffer */
 600                 k_stored = bk;
 601                 w = outcnt;             /* initialize window position */
 602
 603                 /* go to byte boundary */
 604                 n = k_stored & 7;
 605                 b_stored >>= n;
 606                 k_stored -= n;
 607
 608                 /* get the length and its complement */
 609                 while (k_stored < 16) {
 610                         input_char = fgetc(in_file);
 611                         if (input_char == EOF) return 1;
 612                         b_stored |= ((unsigned long)input_char) << k_stored;
 613                         k_stored += 8;
 614                 }
 615                 n = ((unsigned) b_stored & 0xffff);
 616                 b_stored >>= 16;
 617                 k_stored -= 16;
 618                 while (k_stored < 16) {
 619                         input_char = fgetc(in_file);
 620                         if (input_char == EOF) return 1;
 621                         b_stored |= ((unsigned long)input_char) << k_stored;
 622                         k_stored += 8;
 623                 }
 624                 if (n != (unsigned) ((~b_stored) & 0xffff)) {
 625                         return 1;       /* error in compressed data */
 626                 }
 627                 b_stored >>= 16;
 628                 k_stored -= 16;
 629
 630                 /* read and output the compressed data */
 631                 while (n--) {
 632                         while (k_stored < 8) {
 633                                 input_char = fgetc(in_file);
 634                                 if (input_char == EOF) return 1;
 635                                 b_stored |= ((unsigned long)input_char) << k_stored;
 636                                 k_stored += 8;
 637                         }
 638                         window[w++] = (unsigned char) b_stored;
 639                         if (w == (unsigned long) WSIZE) {
 640                                 outcnt = (w), flush_window();
 641                                 w = 0;
 642                         }
 643                         b_stored >>= 8;
 644                         k_stored -= 8;
 645                 }
 646
 647                 /* restore the globals from the locals */
 648                 outcnt = w;             /* restore global window pointer */
 649                 bb = b_stored;  /* restore global bit buffer */
 650                 bk = k_stored;
 651                 return 0;
 652         }
 653         case 1:                 /* Inflate fixed
 654                                                    * decompress an inflated type 1 (fixed Huffman codes) block.  We should
 655                                                    * either replace this with a custom decoder, or at least precompute the
 656                                                    * Huffman tables.
 657                                                  */
 658         {
 659                 int i;                  /* temporary variable */
 660                 huft_t *tl;             /* literal/length code table */
 661                 huft_t *td;             /* distance code table */
 662                 int bl;                 /* lookup bits for tl */
 663                 int bd;                 /* lookup bits for td */
 664                 unsigned int l[288];    /* length list for huft_build */
 665
 666                 /* set up literal table */
 667                 for (i = 0; i < 144; i++) {
 668                         l[i] = 8;
 669                 }
 670                 for (; i < 256; i++) {
 671                         l[i] = 9;
 672                 }
 673                 for (; i < 280; i++) {
 674                         l[i] = 7;
 675                 }
 676                 for (; i < 288; i++) {  /* make a complete, but wrong code set */
 677                         l[i] = 8;
 678                 }
 679                 bl = 7;
 680                 if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
 681                         return i;
 682                 }
 683
 684                 /* set up distance table */
 685                 for (i = 0; i < 30; i++) {      /* make an incomplete code set */
 686                         l[i] = 5;
 687                 }
 688                 bd = 5;
 689                 if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
 690                         huft_free(tl);
 691                         return i;
 692                 }
 693
 694                 /* decompress until an end-of-block code */
 695                 if (inflate_codes(tl, td, bl, bd))
 696                         return 1;
 697
 698                 /* free the decoding tables, return */
 699                 huft_free(tl);
 700                 huft_free(td);
 701                 return 0;
 702         }
 703         case 2:                 /* Inflate dynamic */
 704         {
 705                 const int dbits = 6;    /* bits in base distance lookup table */
 706                 const int lbits = 9;    /* bits in base literal/length lookup table */
 707
 708                 int i;                  /* temporary variables */
 709                 unsigned j;
 710                 unsigned l;             /* last length */
 711                 unsigned m;             /* mask for bit lengths table */
 712                 unsigned n;             /* number of lengths to get */
 713                 huft_t *tl;             /* literal/length code table */
 714                 huft_t *td;             /* distance code table */
 715                 int bl;                 /* lookup bits for tl */
 716                 int bd;                 /* lookup bits for td */
 717                 unsigned nb;    /* number of bit length codes */
 718                 unsigned nl;    /* number of literal/length codes */
 719                 unsigned nd;    /* number of distance codes */
 720
 721                 unsigned ll[286 + 30];  /* literal/length and distance code lengths */
 722                 register unsigned long b_dynamic;       /* bit buffer */
 723                 register unsigned k_dynamic;    /* number of bits in bit buffer */
 724
 725                 /* make local bit buffer */
 726                 b_dynamic = bb;
 727                 k_dynamic = bk;
 728
 729                 /* read in table lengths */
 730                 while (k_dynamic < 5) {
 731                         input_char = fgetc(in_file);
 732                         if (input_char == EOF) return 1;
 733                         b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 734                         k_dynamic += 8;
 735                 }
 736                 nl = 257 + ((unsigned) b_dynamic & 0x1f);       /* number of literal/length codes */
 737                 b_dynamic >>= 5;
 738                 k_dynamic -= 5;
 739                 while (k_dynamic < 5) {
 740                         input_char = fgetc(in_file);
 741                         if (input_char == EOF) return 1;
 742                         b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 743                         k_dynamic += 8;
 744                 }
 745                 nd = 1 + ((unsigned) b_dynamic & 0x1f); /* number of distance codes */
 746                 b_dynamic >>= 5;
 747                 k_dynamic -= 5;
 748                 while (k_dynamic < 4) {
 749                         input_char = fgetc(in_file);
 750                         if (input_char == EOF) return 1;
 751                         b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 752                         k_dynamic += 8;
 753                 }
 754                 nb = 4 + ((unsigned) b_dynamic & 0xf);  /* number of bit length codes */
 755                 b_dynamic >>= 4;
 756                 k_dynamic -= 4;
 757                 if (nl > 286 || nd > 30) {
 758                         return 1;       /* bad lengths */
 759                 }
 760
 761                 /* read in bit-length-code lengths */
 762                 for (j = 0; j < nb; j++) {
 763                         while (k_dynamic < 3) {
 764                                 input_char = fgetc(in_file);
 765                                 if (input_char == EOF) return 1;
 766                                 b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 767                                 k_dynamic += 8;
 768                         }
 769                         ll[border[j]] = (unsigned) b_dynamic & 7;
 770                         b_dynamic >>= 3;
 771                         k_dynamic -= 3;
 772                 }
 773                 for (; j < 19; j++) {
 774                         ll[border[j]] = 0;
 775                 }
 776
 777                 /* build decoding table for trees--single level, 7 bit lookup */
 778                 bl = 7;
 779                 if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) {
 780                         if (i == 1) {
 781                                 huft_free(tl);
 782                         }
 783                         return i;       /* incomplete code set */
 784                 }
 785
 786                 /* read in literal and distance code lengths */
 787                 n = nl + nd;
 788                 m = mask_bits[bl];
 789                 i = l = 0;
 790                 while ((unsigned) i < n) {
 791                         while (k_dynamic < (unsigned) bl) {
 792                                 input_char = fgetc(in_file);
 793                                 if (input_char == EOF) return 1;
 794                                 b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 795                                 k_dynamic += 8;
 796                         }
 797                         j = (td = tl + ((unsigned) b_dynamic & m))->b;
 798                         b_dynamic >>= j;
 799                         k_dynamic -= j;
 800                         j = td->v.n;
 801                         if (j < 16) {   /* length of code in bits (0..15) */
 802                                 ll[i++] = l = j;        /* save last length in l */
 803                         } else if (j == 16) {   /* repeat last length 3 to 6 times */
 804                                 while (k_dynamic < 2) {
 805                                         input_char = fgetc(in_file);
 806                                         if (input_char == EOF) return 1;
 807                                         b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 808                                         k_dynamic += 8;
 809                                 }
 810                                 j = 3 + ((unsigned) b_dynamic & 3);
 811                                 b_dynamic >>= 2;
 812                                 k_dynamic -= 2;
 813                                 if ((unsigned) i + j > n) {
 814                                         return 1;
 815                                 }
 816                                 while (j--) {
 817                                         ll[i++] = l;
 818                                 }
 819                         } else if (j == 17) {   /* 3 to 10 zero length codes */
 820                                 while (k_dynamic < 3) {
 821                                         input_char = fgetc(in_file);
 822                                         if (input_char == EOF) return 1;
 823                                         b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 824                                         k_dynamic += 8;
 825                                 }
 826                                 j = 3 + ((unsigned) b_dynamic & 7);
 827                                 b_dynamic >>= 3;
 828                                 k_dynamic -= 3;
 829                                 if ((unsigned) i + j > n) {
 830                                         return 1;
 831                                 }
 832                                 while (j--) {
 833                                         ll[i++] = 0;
 834                                 }
 835                                 l = 0;
 836                         } else {        /* j == 18: 11 to 138 zero length codes */
 837                                 while (k_dynamic < 7) {
 838                                         input_char = fgetc(in_file);
 839                                         if (input_char == EOF) return 1;
 840                                         b_dynamic |= ((unsigned long)input_char) << k_dynamic;
 841                                         k_dynamic += 8;
 842                                 }
 843                                 j = 11 + ((unsigned) b_dynamic & 0x7f);
 844                                 b_dynamic >>= 7;
 845                                 k_dynamic -= 7;
 846                                 if ((unsigned) i + j > n) {
 847                                         return 1;
 848                                 }
 849                                 while (j--) {
 850                                         ll[i++] = 0;
 851                                 }
 852                                 l = 0;
 853                         }
 854                 }
 855
 856                 /* free decoding table for trees */
 857                 huft_free(tl);
 858
 859                 /* restore the global bit buffer */
 860                 bb = b_dynamic;
 861                 bk = k_dynamic;
 862
 863                 /* build the decoding tables for literal/length and distance codes */
 864                 bl = lbits;
 865                 if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
 866                         if (i == 1) {
 867                                 error_msg("Incomplete literal tree");
 868                                 huft_free(tl);
 869                         }
 870                         return i;       /* incomplete code set */
 871                 }
 872                 bd = dbits;
 873                 if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
 874                         if (i == 1) {
 875                                 error_msg("incomplete distance tree");
 876                                 huft_free(td);
 877                         }
 878                         huft_free(tl);
 879                         return i;       /* incomplete code set */
 880                 }
 881
 882                 /* decompress until an end-of-block code */
 883                 if (inflate_codes(tl, td, bl, bd))
 884                         return 1;
 885
 886                 /* free the decoding tables, return */
 887                 huft_free(tl);
 888                 huft_free(td);
 889                 return 0;
 890         }
 891         default:
 892                 /* bad block type */
 893                 return 2;
 894         }
 895 }
 896
 897 /*
 898  * decompress an inflated entry
 899  *
 900  * GLOBAL VARIABLES: outcnt, bk, bb, hufts, inptr
 901  */
 902 extern int inflate(FILE * in, FILE * out)
 903 {
 904         int e;                          /* last block flag */
 905         int r;                          /* result code */
 906         unsigned h = 0;         /* maximum struct huft's malloc'ed */
 907
 908         /* initialize window, bit buffer */
 909         outcnt = 0;
 910         bk = 0;
 911         bb = 0;
 912
 913         in_file = in;
 914         out_file = out;
 915
 916         /* Allocate all global buffers (for DYN_ALLOC option) */
 917         window = xmalloc((size_t) (((2L * WSIZE) + 1L) * sizeof(unsigned char)));
 918         bytes_out = 0L;
 919
 920         /* Create the crc table */
 921         make_crc_table();
 922
 923         /* decompress until the last block */
 924         do {
 925                 hufts = 0;
 926                 if ((r = inflate_block(&e)) != 0) {
 927                         return r;
 928                 }
 929                 if (hufts > h) {
 930                         h = hufts;
 931                 }
 932         } while (!e);
 933
 934         /* Undo too much lookahead. The next read will be byte aligned so we
 935          * can discard unused bits in the last meaningful byte.
 936          */
 937         while (bk >= 8) {
 938                 bk -= 8;
 939                 ungetc((bb << bk), in_file);
 940         }
 941
 942         /* flush out window */
 943         flush_window();
 944         free(window);
 945         free(crc_table);
 946
 947         /* return success */
 948         return 0;
 949 }
 950
 951 /* ===========================================================================
 952  * Unzip in to out.  This routine works on gzip files only.
 953  *
 954  * IN assertions: the buffer inbuf contains already the beginning of
 955  *   the compressed data, from offsets inptr to insize-1 included.
 956  *   The magic header has already been checked. The output buffer is cleared.
 957  * in, out: input and output file descriptors
 958  */
 959 extern int unzip(FILE * l_in_file, FILE * l_out_file)
 960 {
 961         unsigned char buf[8];   /* extended local header */
 962         unsigned char flags;    /* compression flags */
 963         typedef void (*sig_type) (int);
 964         unsigned short i;
 965         unsigned char magic[2];
 966
 967         if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
 968                 (void) signal(SIGINT, (sig_type) abort_gzip);
 969         }
 970 #ifdef SIGHUP
 971         if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
 972                 (void) signal(SIGHUP, (sig_type) abort_gzip);
 973         }
 974 #endif
 975
 976         magic[0] = fgetc(l_in_file);
 977         magic[1] = fgetc(l_in_file);
 978
 979 #ifdef CONFIG_FEATURE_UNCOMPRESS
 980         /* Magic header for compress files, 1F 9d = \037\235 */
 981         if ((magic[0] == 0x1F) && (magic[1] == 0x9d)) {
 982                 return uncompress(l_in_file, l_out_file);
 983         }
 984 #endif
 985
 986         /* Magic header for gzip files, 1F 8B = \037\213 */
 987         if ((magic[0] != 0x1F) || (magic[1] != 0x8b)) {
 988                 error_msg("Invalid gzip magic");
 989                 return EXIT_FAILURE;
 990         }
 991
 992         /* Check the compression method */
 993         if (fgetc(l_in_file) != 8) /* also catches EOF */ {
 994                 error_msg("Unknown compression method");
 995                 return (-1);
 996         }
 997
 998         flags = (unsigned char) fgetc(l_in_file);
 999
1000         /* Ignore time stamp(4), extra flags(1), OS type(1) */
1001         for (i = 0; i < 6; i++) {
1002                 fgetc(l_in_file);
1003         }
1004
1005         if (flags & 0x04) {
1006                 /* bit 2 set: extra field present */
1007                 const unsigned short extra =
1008                         fgetc(l_in_file) + (fgetc(l_in_file) << 8);
1009                 if (feof(in_file)) return 1;
1010                 for (i = 0; i < extra; i++) {
1011                         fgetc(l_in_file);
1012                 }
1013         }
1014
1015         /* Discard original name if any */
1016         if (flags & 0x08) {
1017                 /* bit 3 set: original file name present */
1018                 while (fgetc(l_in_file) != 0 && !feof(l_in_file));      /* null */
1019         }
1020
1021         /* Discard file comment if any */
1022         if (flags & 0x10) {
1023                 /* bit 4 set: file comment present */
1024                 while (fgetc(l_in_file) != 0 && !feof(l_in_file));      /* null */
1025         }
1026
1027         /* Decompress */
1028         if (inflate(l_in_file, l_out_file) != 0) {
1029                 error_msg("invalid compressed data--format violated");
1030         }
1031
1032         /* Get the crc and original length
1033          * crc32  (see algorithm.doc)
1034          * uncompressed input size modulo 2^32
1035          */
1036         fread(buf, 1, 8, l_in_file);
1037
1038         /* Validate decompression - crc */
1039         if ((unsigned int) ((buf[0] | (buf[1] << 8)) |
1040                                                 ((buf[2] | (buf[3] << 8)) << 16)) !=
1041                 (crc ^ 0xffffffffL)) {
1042                 error_msg("invalid compressed data--crc error");
1043         }
1044         /* Validate decompression - size */
1045         if (((buf[4] | (buf[5] << 8)) | ((buf[6] | (buf[7] << 8)) << 16)) !=
1046                 (unsigned long) bytes_out) {
1047                 error_msg("invalid compressed data--length error");
1048         }
1049
1050         return 0;
1051 }
1052
1053 /*
1054  * This needs access to global variables window and crc_table, so its not in its own file.
1055  */
1056 extern void gz_close(int gunzip_pid)
1057 {
1058         if (kill(gunzip_pid, SIGTERM) == -1) {
1059                 error_msg_and_die
1060                         ("***  Couldnt kill old gunzip process *** aborting");
1061         }
1062
1063         if (waitpid(gunzip_pid, NULL, 0) == -1) {
1064                 printf("Couldnt wait ?");
1065         }
1066
1067         free(window);
1068         free(crc_table);
1069 }