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