/* vi: set sw=4 ts=4: *//* * gunzip implementation for busybox * * Based on GNU gzip v1.2.4 Copyright (C) 1992-1993 Jean-loup Gailly. * * Originally adjusted for busybox by Sven Rudolph <sr1@inf.tu-dresden.de> * based on gzip sources * * Adjusted further by Erik Andersen <andersee@debian.org> to support * files as well as stdin/stdout, and to generally behave itself wrt * command line handling. * * General cleanup to better adhere to the style guide and make use of * standard busybox functions by Glenn McGrath <bug1@optushome.com.au> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * * gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface * Copyright (C) 1992-1993 Jean-loup Gailly * The unzip code was written and put in the public domain by Mark Adler. * Portions of the lzw code are derived from the public domain 'compress' * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies, * Ken Turkowski, Dave Mack and Peter Jannesen. * * See the license_msg below and the file COPYING for the software license. * See the file algorithm.doc for the compression algorithms and file formats. */#if 0static char *license_msg[] = {	"   Copyright (C) 1992-1993 Jean-loup Gailly",	"   This program is free software; you can redistribute it and/or modify",	"   it under the terms of the GNU General Public License as published by",	"   the Free Software Foundation; either version 2, or (at your option)",	"   any later version.",	"",	"   This program is distributed in the hope that it will be useful,",	"   but WITHOUT ANY WARRANTY; without even the implied warranty of",	"   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the",	"   GNU General Public License for more details.",	"",	"   You should have received a copy of the GNU General Public License",	"   along with this program; if not, write to the Free Software",	"   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",	0};#endif#include <sys/types.h>#include <sys/wait.h>#include <signal.h>#include <stdlib.h>#include <string.h>#include "libbb.h"static FILE *in_file, *out_file;/* these are freed by gz_close */static unsigned char *window;static unsigned long *crc_table;static unsigned long crc; /* shift register contents *//* Return codes from gzip */static const int ERROR = 1;/* * window size--must be a power of two, and *  at least 32K for zip's deflate method  */static const int WSIZE = 0x8000;/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */static const int BMAX = 16;		/* maximum bit length of any code (16 for explode) */static const int N_MAX = 288;		/* maximum number of codes in any set */static long bytes_out;		/* number of output bytes */static unsigned long outcnt;	/* bytes in output buffer */static unsigned hufts;		/* track memory usage */static unsigned long bb;			/* bit buffer */static unsigned bk;		/* bits in bit buffer */typedef struct huft_s {	unsigned char e;		/* number of extra bits or operation */	unsigned char b;		/* number of bits in this code or subcode */	union {		unsigned short n;		/* literal, length base, or distance base */		struct huft_s *t;	/* pointer to next level of table */	} v;} huft_t;static const unsigned short mask_bits[] = {	0x0000,	0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,	0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff};//static int error_number = 0;/* ======================================================================== * Signal and error handler. */ static void abort_gzip(){	error_msg("gzip aborted\n");	exit(ERROR);}static void make_crc_table(){	unsigned long table_entry;      /* crc shift register */	unsigned long poly = 0;      /* polynomial exclusive-or pattern */	int i;                /* counter for all possible eight bit values */	int k;                /* byte being shifted into crc apparatus */	/* terms of polynomial defining this crc (except x^32): */	static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};	/* initial shift register value */	crc = 0xffffffffL;		crc_table = (unsigned long *) malloc(256 * sizeof(unsigned long));	/* Make exclusive-or pattern from polynomial (0xedb88320) */	for (i = 0; i < sizeof(p)/sizeof(int); i++)		poly |= 1L << (31 - p[i]);	/* Compute and print table of CRC's, five per line */	for (i = 0; i < 256; i++) {		table_entry = i;	   /* The idea to initialize the register with the byte instead of	     * zero was stolen from Haruhiko Okumura's ar002	     */		for (k = 8; k; k--) {			table_entry = table_entry & 1 ? (table_entry >> 1) ^ poly : table_entry >> 1;		}		crc_table[i]=table_entry;	}}/* =========================================================================== * Write the output window window[0..outcnt-1] and update crc and bytes_out. * (Used for the decompressed data only.) */static void flush_window(void){	int n;	if (outcnt == 0)		return;	for (n = 0; n < outcnt; n++) {		crc = crc_table[((int) crc ^ (window[n])) & 0xff] ^ (crc >> 8);	}	if (fwrite(window, 1, outcnt, out_file) != outcnt) {		error_msg_and_die("Couldnt write");	}	bytes_out += (unsigned long) outcnt;	outcnt = 0;}/* * Free the malloc'ed tables built by huft_build(), which makes a linked * list of the tables it made, with the links in a dummy first entry of * each table.  * t: table to free */static int huft_free(huft_t *t){	huft_t *p, *q;	/* Go through linked list, freeing from the malloced (t[-1]) address. */	p = t;	while (p != (huft_t *) NULL) {		q = (--p)->v.t;		free((char *) p);		p = q;	}	return 0;}/* Given a list of code lengths and a maximum table size, make a set of * tables to decode that set of codes.  Return zero on success, one if * the given code set is incomplete (the tables are still built in this * case), two if the input is invalid (all zero length codes or an * oversubscribed set of lengths), and three if not enough memory. * * b:	code lengths in bits (all assumed <= BMAX) * n:	number of codes (assumed <= N_MAX) * s:	number of simple-valued codes (0..s-1) * d:	list of base values for non-simple codes * e:	list of extra bits for non-simple codes * t:	result: starting table * m:	maximum lookup bits, returns actual */static int huft_build(unsigned int *b, const unsigned int n, const unsigned int s, 	const unsigned short *d, const unsigned short *e, huft_t **t, int *m){	unsigned a;		/* counter for codes of length k */	unsigned c[BMAX + 1];	/* bit length count table */	unsigned f;		/* i repeats in table every f entries */	int g;			/* maximum code length */	int h;			/* table level */	register unsigned i;	/* counter, current code */	register unsigned j;	/* counter */	register int k;		/* number of bits in current code */	int l;			/* bits per table (returned in m) */	register unsigned *p;		/* pointer into c[], b[], or v[] */	register huft_t *q;	/* points to current table */	huft_t r;		/* table entry for structure assignment */	huft_t *u[BMAX];	/* table stack */	unsigned v[N_MAX];	/* values in order of bit length */	register int w;		/* bits before this table == (l * h) */	unsigned x[BMAX + 1];	/* bit offsets, then code stack */	unsigned *xp;		/* pointer into x */	int y;			/* number of dummy codes added */	unsigned z;		/* number of entries in current table */	/* Generate counts for each bit length */	memset ((void *)(c), 0, sizeof(c));	p = b;	i = n;	do {		c[*p]++;	/* assume all entries <= BMAX */		p++;		/* Can't combine with above line (Solaris bug) */	} while (--i);	if (c[0] == n) {	/* null input--all zero length codes */		*t = (huft_t *) NULL;		*m = 0;		return 0;	}	/* Find minimum and maximum length, bound *m by those */	l = *m;	for (j = 1; j <= BMAX; j++)		if (c[j])			break;	k = j;				/* minimum code length */	if ((unsigned) l < j)		l = j;	for (i = BMAX; i; i--)		if (c[i])			break;	g = i;				/* maximum code length */	if ((unsigned) l > i)		l = i;	*m = l;	/* Adjust last length count to fill out codes, if needed */	for (y = 1 << j; j < i; j++, y <<= 1)		if ((y -= c[j]) < 0)			return 2;	/* bad input: more codes than bits */	if ((y -= c[i]) < 0)		return 2;	c[i] += y;	/* Generate starting offsets into the value table for each length */	x[1] = j = 0;	p = c + 1;	xp = x + 2;	while (--i) {			/* note that i == g from above */		*xp++ = (j += *p++);	}	/* Make a table of values in order of bit lengths */	p = b;	i = 0;	do {		if ((j = *p++) != 0)			v[x[j]++] = i;	} while (++i < n);	/* Generate the Huffman codes and for each, make the table entries */	x[0] = i = 0;			/* first Huffman code is zero */	p = v;				/* grab values in bit order */	h = -1;				/* no tables yet--level -1 */	w = -l;				/* bits decoded == (l * h) */	u[0] = (huft_t *) NULL;	/* just to keep compilers happy */	q = (huft_t *) NULL;	/* ditto */	z = 0;				/* ditto */	/* go through the bit lengths (k already is bits in shortest code) */	for (; k <= g; k++) {		a = c[k];		while (a--) {			/* here i is the Huffman code of length k bits for value *p */			/* make tables up to required level */			while (k > w + l) {				h++;				w += l;		/* previous table always l bits */				/* compute minimum size table less than or equal to l bits */				z = (z = g - w) > (unsigned) l ? l : z;	/* upper limit on table size */				if ((f = 1 << (j = k - w)) > a + 1) {	/* try a k-w bit table *//* too few codes for k-w bit table */					f -= a + 1;	/* deduct codes from patterns left */					xp = c + k;					while (++j < z) {	/* try smaller tables up to z bits */						if ((f <<= 1) <= *++xp)							break;	/* enough codes to use up j bits */						f -= *xp;	/* else deduct codes from patterns */					}				}				z = 1 << j;		/* table entries for j-bit table */				/* allocate and link in new table */				if ((q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t))) == NULL) {					if (h) {						huft_free(u[0]);					}					return 3;	/* not enough memory */				}				hufts += z + 1;	/* track memory usage */				*t = q + 1;		/* link to list for huft_free() */				*(t = &(q->v.t)) = NULL;				u[h] = ++q;		/* table starts after link */				/* connect to last table, if there is one */				if (h) {					x[h] = i;	/* save pattern for backing up */					r.b = (unsigned char) l;	/* bits to dump before this table */					r.e = (unsigned char) (16 + j);	/* bits in this table */					r.v.t = q;	/* pointer to this table */					j = i >> (w - l);	/* (get around Turbo C bug) */					u[h - 1][j] = r;	/* connect to last table */				}			}			/* set up table entry in r */			r.b = (unsigned char) (k - w);			if (p >= v + n)				r.e = 99;		/* out of values--invalid code */			else if (*p < s) {				r.e = (unsigned char) (*p < 256 ? 16 : 15);	/* 256 is end-of-block code */				r.v.n = (unsigned short) (*p);	/* simple code is just the value */				p++;			/* one compiler does not like *p++ */			} else {				r.e = (unsigned char) e[*p - s];	/* non-simple--look up in lists */				r.v.n = d[*p++ - s];			}			/* fill code-like entries with r */			f = 1 << (k - w);			for (j = i >> w; j < z; j += f)				q[j] = r;			/* backwards increment the k-bit code i */