diff options
Diffstat (limited to 'inflate.c')
| -rw-r--r-- | inflate.c | 1318 |
1 files changed, 1318 insertions, 0 deletions
diff --git a/inflate.c b/inflate.c new file mode 100644 index 0000000..e2c5dbe --- /dev/null +++ b/inflate.c @@ -0,0 +1,1318 @@ +/* + * inflate.c - inflate decompression routine + * + * Version 1.1 + */ + +/* + * Copyright (c) 1995, Edward B. Hamrick + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that + * + * (i) the above copyright notice and the text in this "C" comment block + * appear in all copies of the software and related documentation, and + * + * (ii) any modifications to this source file must be sent, via e-mail + * to the copyright owner (currently hamrick@primenet.com) within + * 30 days of such modification. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL EDWARD B. HAMRICK BE LIABLE FOR ANY SPECIAL, INCIDENTAL, + * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF + * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * inflate.c is based on the public-domain (non-copyrighted) version + * written by Mark Adler, version c14o, 23 August 1994. It has been + * modified to be reentrant, more portable, and to be data driven. + */ + +/* + * 1) All file i/o is done externally to these routines + * 2) Routines are symmetrical so inflate can feed into deflate + * 3) Routines can be easily integrated into wide range of applications + * 4) Routines are very portable, and use only ANSI C + * 5) No #defines in inflate.h to conflict with external #defines + * 6) No external routines need be called by these routines + * 7) Buffers are owned by the calling routine + * 8) No static non-constant variables are allowed + */ + +/* + * Note that for each call to InflatePutBuffer, there will be + * 0 or more calls to (*putbuffer_ptr). Before InflatePutBuffer + * returns, it will have output as much uncompressed data as + * is possible. + */ + +#ifdef MEMCPY +#include <mem.h> +#endif + +#include "inflate.h" + +/* + * Macros for constants + */ + +#ifndef NULL +#define NULL ((void *) 0) +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef WINDOWSIZE +#define WINDOWSIZE 0x8000 +#endif + +#ifndef WINDOWMASK +#define WINDOWMASK 0x7fff +#endif + +#ifndef BUFFERSIZE +#define BUFFERSIZE 0x4000 +#endif + +#ifndef BUFFERMASK +#define BUFFERMASK 0x3fff +#endif + +#ifndef INFLATESTATETYPE +#define INFLATESTATETYPE 0xabcdabcdL +#endif + +/* + * typedefs + */ + +typedef unsigned long ulg; +typedef unsigned short ush; +typedef unsigned char uch; + +/* Structure to hold state for inflating zip files */ +struct InflateState { + + unsigned long runtimetypeid1; /* to detect run-time errors */ + int errorencountered; /* error encountered flag */ + + /* Decoding state */ + int state; /* -1 -> need block type */ + /* 0 -> need stored setup */ + /* 1 -> need fixed setup */ + /* 2 -> need dynamic setup */ + /* 10 -> need stored data */ + /* 11 -> need fixed data */ + /* 12 -> need dynamic data */ + +/* State for decoding fixed & dynamic data */ + struct huft *tl; /* literal/length decoder tbl */ + struct huft *td; /* distance decoder table */ + int bl; /* bits decoded by tl */ + int bd; /* bits decoded by td */ + + /* State for decoding stored data */ + unsigned int storelength; + + /* State to keep track that last block has been encountered */ + int lastblock; /* current block is last */ + + /* Input buffer state (circular) */ + ulg bb; /* input buffer bits */ + unsigned int bk; /* input buffer count of bits */ + unsigned int bp; /* input buffer pointer */ + unsigned int bs; /* input buffer size */ + unsigned char buffer[BUFFERSIZE]; /* input buffer data */ + + /* Storage for try/catch */ + ulg catch_bb; /* bit buffer */ + unsigned int catch_bk; /* bits in bit buffer */ + unsigned int catch_bp; /* buffer pointer */ + unsigned int catch_bs; /* buffer size */ + + /* Output window state (circular) */ + unsigned int wp; /* output window pointer */ + unsigned int wf; /* output window flush-from */ + unsigned char window[WINDOWSIZE]; /* output window data */ + + /* Application state */ + void *AppState; /* opaque ptr for callout */ + + /* pointers to call-outs */ + int (*putbuffer_ptr)( /* returns 0 on success */ + void *AppState, /* opaque ptr from Initialize */ + unsigned char *buffer, /* buffer to put */ + long length /* length of buffer */ + ); + + void *(*malloc_ptr)(long length); /* utility routine */ + + void (*free_ptr)(void *buffer); /* utility routine */ + + unsigned long runtimetypeid2; /* to detect run-time errors */ +}; + +/* + * Error handling macro + */ + +#define ERROREXIT(is) {(is)->errorencountered = TRUE; return TRUE;} + +/* + * Macros for handling data in the input buffer + * + * Note that the NEEDBITS and DUMPBITS macros + * need to be bracketed by the TRY/CATCH macros + * + * The usage is: + * + * TRY + * { + * NEEDBITS(j) + * x = b & mask_bits[j]; + * DUMPBITS(j) + * } + * CATCH_BEGIN + * cleanup code + * CATCH_END + * + * Note that there can only be one TRY/CATCH pair per routine + * because of the use of goto in the implementation of the macros. + * + * NEEDBITS makes sure that b has at least j bits in it, and + * DUMPBITS removes the bits from b. The macros use the variable k + * for the number of bits in b. Normally, b and k are register + * variables for speed, and are initialized at the beginning of a + * routine that uses these macros from a global bit buffer and count. + * + * In order to not ask for more bits than there are in the compressed + * stream, the Huffman tables are constructed to only ask for just + * enough bits to make up the end-of-block code (value 256). Then no + * bytes need to be "returned" to the buffer at the end of the last + * block. See the huft_build() routine. + */ + +#define TRY \ + is->catch_bb = b; \ + is->catch_bk = k; \ + is->catch_bp = is->bp; \ + is->catch_bs = is->bs; + +#define CATCH_BEGIN \ + goto cleanup_done; \ + cleanup: \ + b = is->catch_bb; \ + k = is->catch_bk; \ + is->bb = b; \ + is->bk = k; \ + is->bp = is->catch_bp; \ + is->bs = is->catch_bs; + +#define CATCH_END \ + cleanup_done: ; + +#define NEEDBITS(n) \ +{ \ + while (k < (n)) \ + { \ + if (is->bs <= 0) \ + { \ + goto cleanup; \ + } \ + b |= ((ulg) (is->buffer[is->bp & BUFFERMASK])) << k; \ + is->bs--; \ + is->bp++; \ + k += 8; \ + } \ +} + +#define DUMPBITS(n) \ +{ \ + b >>= (n); \ + k -= (n); \ +} + +/* + * Macro for flushing the output window to the putbuffer callout. + * + * Note that the window is always flushed when it fills to 32K, + * and before returning to the application. + */ + +#define FLUSHWINDOW(w, now) \ +if ((now && (is->wp > is->wf)) || ((w) >= WINDOWSIZE)) \ +{ \ + is->wp = (w); \ + if ((*(is->putbuffer_ptr)) \ + (is->AppState, is->window+is->wf, is->wp-is->wf)) \ + ERROREXIT(is); \ + is->wp &= WINDOWMASK; \ + is->wf = is->wp; \ + (w) = is->wp; \ +} + +/* + * Inflate deflated (PKZIP's method 8 compressed) data. The compression + * method searches for as much of the current string of bytes (up to a + * length of 258) in the previous 32K bytes. If it doesn't find any + * matches (of at least length 3), it codes the next byte. Otherwise, it + * codes the length of the matched string and its distance backwards from + * the current position. There is a single Huffman code that codes both + * single bytes (called "literals") and match lengths. A second Huffman + * code codes the distance information, which follows a length code. Each + * length or distance code actually represents a base value and a number + * of "extra" (sometimes zero) bits to get to add to the base value. At + * the end of each deflated block is a special end-of-block (EOB) literal/ + * length code. The decoding process is basically: get a literal/length + * code; if EOB then done; if a literal, emit the decoded byte; if a + * length then get the distance and emit the referred-to bytes from the + * sliding window of previously emitted data. + * + * There are (currently) three kinds of inflate blocks: stored, fixed, and + * dynamic. The compressor outputs a chunk of data at a time and decides + * which method to use on a chunk-by-chunk basis. A chunk might typically + * be 32K to 64K, uncompressed. If the chunk is uncompressible, then the + * "stored" method is used. In this case, the bytes are simply stored as + * is, eight bits per byte, with none of the above coding. The bytes are + * preceded by a count, since there is no longer an EOB code. + * + * If the data is compressible, then either the fixed or dynamic methods + * are used. In the dynamic method, the compressed data is preceded by + * an encoding of the literal/length and distance Huffman codes that are + * to be used to decode this block. The representation is itself Huffman + * coded, and so is preceded by a description of that code. These code + * descriptions take up a little space, and so for small blocks, there is + * a predefined set of codes, called the fixed codes. The fixed method is + * used if the block ends up smaller that way (usually for quite small + * chunks); otherwise the dynamic method is used. In the latter case, the + * codes are customized to the probabilities in the current block and so + * can code it much better than the pre-determined fixed codes can. + * + * The Huffman codes themselves are decoded using a mutli-level table + * lookup, in order to maximize the speed of decoding plus the speed of + * building the decoding tables. See the comments below that precede the + * lbits and dbits tuning parameters. + */ + +/* + * Notes beyond the 1.93a appnote.txt: + * + * 1. Distance pointers never point before the beginning of the output + * stream. + * 2. Distance pointers can point back across blocks, up to 32k away. + * 3. There is an implied maximum of 7 bits for the bit length table and + * 15 bits for the actual data. + * 4. If only one code exists, then it is encoded using one bit. (Zero + * would be more efficient, but perhaps a little confusing.) If two + * codes exist, they are coded using one bit each (0 and 1). + * 5. There is no way of sending zero distance codes--a dummy must be + * sent if there are none. (History: a pre 2.0 version of PKZIP would + * store blocks with no distance codes, but this was discovered to be + * too harsh a criterion.) Valid only for 1.93a. 2.04c does allow + * zero distance codes, which is sent as one code of zero bits in + * length. + * 6. There are up to 286 literal/length codes. Code 256 represents the + * end-of-block. Note however that the static length tree defines + * 288 codes just to fill out the Huffman codes. Codes 286 and 287 + * cannot be used though, since there is no length base or extra bits + * defined for them. Similarly, there are up to 30 distance codes. + * However, static trees define 32 codes (all 5 bits) to fill out the + * Huffman codes, but the last two had better not show up in the data. + * 7. Unzip can check dynamic Huffman blocks for complete code sets. + * The exception is that a single code would not be complete (see #4). + * 8. The five bits following the block type is really the number of + * literal codes sent minus 257. + * 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits + * (1+6+6). Therefore, to output three times the length, you output + * three codes (1+1+1), whereas to output four times the same length, + * you only need two codes (1+3). Hmm. + *10. In the tree reconstruction algorithm, Code = Code + Increment + * only if BitLength(i) is not zero. (Pretty obvious.) + *11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) + *12. Note: length code 284 can represent 227-258, but length code 285 + * really is 258. The last length deserves its own, short code + * since it gets used a lot in very redundant files. The length + * 258 is special since 258 - 3 (the min match length) is 255. + *13. The literal/length and distance code bit lengths are read as a + * single stream of lengths. It is possible (and advantageous) for + * a repeat code (16, 17, or 18) to go across the boundary between + * the two sets of lengths. + */ + +/* + * Huffman code lookup table entry--this entry is four bytes for machines + * that have 16-bit pointers (e.g. PC's in the small or medium model). + * Valid extra bits are 0..13. e == 15 is EOB (end of block), e == 16 + * means that v is a literal, 16 < e < 32 means that v is a pointer to + * the next table, which codes e - 16 bits, and lastly e == 99 indicates + * an unused code. If a code with e == 99 is looked up, this implies an + * error in the data. + */ + +struct huft { + uch e; /* number of extra bits or operation */ + uch b; /* number of bits in this code or subcode */ + union { + ush n; /* literal, length base, or distance base */ + struct huft *t; /* pointer to next level of table */ + } v; +}; + +/* + * Tables for deflate from PKZIP's appnote.txt. + */ + +static const unsigned border[] = { /* Order of the bit length code lengths */ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + +static const ush cplens[] = { /* Copy lengths for literal codes 257..285 */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + /* note: see note #13 above about the 258 in this list. */ + +static const ush cplext[] = { /* Extra bits for literal codes 257..285 */ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */ + +static const ush cpdist[] = { /* Copy offsets for distance codes 0..29 */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577}; + +static const ush cpdext[] = { /* Extra bits for distance codes */ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, + 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, + 12, 12, 13, 13}; + +/* + * Constants for run-time computation of mask + */ + +static const ush mask_bits[] = { + 0x0000, + 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, + 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff +}; + +/* + * Huffman code decoding is performed using a multi-level table lookup. + * The fastest way to decode is to simply build a lookup table whose + * size is determined by the longest code. However, the time it takes + * to build this table can also be a factor if the data being decoded + * is not very long. The most common codes are necessarily the + * shortest codes, so those codes dominate the decoding time, and hence + * the speed. The idea is you can have a shorter table that decodes the + * shorter, more probable codes, and then point to subsidiary tables for + * the longer codes. The time it costs to decode the longer codes is + * then traded against the time it takes to make longer tables. + * + * This results of this trade are in the variables lbits and dbits + * below. lbits is the number of bits the first level table for literal/ + * length codes can decode in one step, and dbits is the same thing for + * the distance codes. Subsequent tables are also less than or equal to + * those sizes. These values may be adjusted either when all of the + * codes are shorter than that, in which case the longest code length in + * bits is used, or when the shortest code is *longer* than the requested + * table size, in which case the length of the shortest code in bits is + * used. + * + * There are two different values for the two tables, since they code a + * different number of possibilities each. The literal/length table + * codes 286 possible values, or in a flat code, a little over eight + * bits. The distance table codes 30 possible values, or a little less + * than five bits, flat. The optimum values for speed end up being + * about one bit more than those, so lbits is 8+1 and dbits is 5+1. + * The optimum values may differ though from machine to machine, and + * possibly even between compilers. Your mileage may vary. + */ + +static const int lbits = 9; /* bits in base literal/length lookup table */ +static const int dbits = 6; /* bits in base distance lookup table */ + +/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */ +#define BMAX 16 /* maximum bit length of any code (16 for explode) */ +#define N_MAX 288 /* maximum number of codes in any set */ + +/* + * 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. + */ + +static int huft_free( + struct InflateState *is, /* Inflate state */ + struct huft *t /* table to free */ +) +{ + struct huft *p, *q; + + /* Go through linked list, freeing from the malloced (t[-1]) address. */ + p = t; + while (p != (struct huft *)NULL) + { + q = (--p)->v.t; + (*is->free_ptr)((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. + * The code with value 256 is special, and the tables are constructed + * so that no bits beyond that code are fetched when that code is + * decoded. + */ + +static int huft_build( + struct InflateState *is, /* Inflate state */ + unsigned *b, /* code lengths in bits (all assumed <= BMAX) */ + unsigned n, /* number of codes (assumed <= N_MAX) */ + unsigned s, /* number of simple-valued codes (0..s-1) */ + const ush *d, /* list of base values for non-simple codes */ + const ush *e, /* list of extra bits for non-simple codes */ + struct huft **t, /* result: starting table */ + int *m /* maximum lookup bits, returns actual */ +) +{ + unsigned a; /* counter for codes of length k */ + unsigned c[BMAX+1]; /* bit length count table */ + unsigned el; /* length of EOB code (value 256) */ + unsigned f; /* i repeats in table every f entries */ + int g; /* maximum code length */ + int h; /* table level */ + unsigned i; /* counter, current code */ + unsigned j; /* counter */ + int k; /* number of bits in current code */ + int lx[BMAX+1]; /* memory for l[-1..BMAX-1] */ + int *l = lx+1; /* stack of bits per table */ + unsigned *p; /* pointer into c[], b[], or v[] */ + struct huft *q; /* points to current table */ + struct huft r; /* table entry for structure assignment */ + struct huft *u[BMAX]; /* table stack */ + unsigned v[N_MAX]; /* values in order of bit length */ + 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 */ + + /* clear the bit length count table */ + for (i=0; i<(BMAX+1); i++) + { + c[i] = 0; + } + + /* Generate counts for each bit length */ + el = n > 256 ? b[256] : BMAX; /* set length of EOB code, if any */ + p = b; i = n; + do { + c[*p]++; p++; /* assume all entries <= BMAX */ + } while (--i); + if (c[0] == n) /* null input--all zero length codes */ + { + *t = (struct huft *)NULL; + *m = 0; + return 0; + } + + /* Find minimum and maximum length, bound *m by those */ + for (j = 1; j <= BMAX; j++) + if (c[j]) + break; + k = j; /* minimum code length */ + if ((unsigned)*m < j) + *m = j; + for (i = BMAX; i; i--) + if (c[i]) + break; + g = i; /* maximum code length */ + if ((unsigned)*m > i) + *m = i; + + /* 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[-1] = 0; /* no bits decoded yet */ + u[0] = (struct huft *)NULL; /* just to keep compilers happy */ + q = (struct huft *)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[h++]; /* add bits already decoded */ + + /* compute minimum size table less than or equal to *m bits */ + z = (z = g - w) > (unsigned)*m ? *m : z; /* upper limit */ + 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 */ + } + } + if ((unsigned)w + j > el && (unsigned)w < el) + j = el - w; /* make EOB code end at table */ + z = 1 << j; /* table entries for j-bit table */ + l[h] = j; /* set table size in stack */ + + /* allocate and link in new table */ + if ((q = (struct huft *) + ((*is->malloc_ptr)((z + 1)*sizeof(struct huft)))) == + (struct huft *)NULL) + { + if (h) + huft_free(is, u[0]); + return 3; /* not enough memory */ + } + *t = q + 1; /* link to list for huft_free() */ + *(t = &(q->v.t)) = (struct huft *)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 = (uch)l[h-1]; /* bits to dump before this table */ + r.e = (uch)(16 + j); /* bits in this table */ + r.v.t = q; /* pointer to this table */ + j = (i & ((1 << w) - 1)) >> (w - l[h-1]); + u[h-1][j] = r; /* connect to last table */ + } + } + + /* set up table entry in r */ + r.b = (uch)(k - w); + if (p >= v + n) + r.e = 99; /* out of values--invalid code */ + else if (*p < s) + { + r.e = (uch)(*p < 256 ? 16 : 15); /* 256 is end-of-block code */ + r.v.n = (ush) *p++; /* simple code is just the value */ + } + else + { + r.e = (uch)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 */ + for (j = 1 << (k - 1); i & j; j >>= 1) + i ^= j; + i ^= j; + + /* backup over finished tables */ + while ((i & ((1 << w) - 1)) != x[h]) + w -= l[--h]; /* don't need to update q */ + } + } + + /* return actual size of base table */ + *m = l[0]; + + /* Return true (1) if we were given an incomplete table */ + return y != 0 && g != 1; +} + +/* + * inflate (decompress) the codes in a stored (uncompressed) block. + * Return an error code or zero if it all goes ok. + */ + +static int inflate_stored( + struct InflateState *is /* Inflate state */ +) +{ + ulg b; /* bit buffer */ + unsigned k; /* number of bits in bit buffer */ + unsigned w; /* current window position */ + + /* make local copies of state */ + b = is->bb; /* initialize bit buffer */ + k = is->bk; /* initialize bit count */ + w = is->wp; /* initialize window position */ + + /* + * Note that this code knows that NEEDBITS jumps to cleanup + */ + + while (is->storelength > 0) /* do until end of block */ + { + NEEDBITS(8) + is->window[w++] = (uch) b; + DUMPBITS(8) + FLUSHWINDOW(w, FALSE); + is->storelength--; + } + + cleanup: + + /* restore the state from the locals */ + is->bb = b; /* restore bit buffer */ + is->bk = k; /* restore bit count */ + is->wp = w; /* restore window pointer */ + + if (is->storelength > 0) + return -1; + else + return 0; +} + +static int inflate_codes( + struct InflateState *is, /* Inflate state */ + struct huft *tl, /* literal/length decoder table */ + struct huft *td, /* distance decoder table */ + int bl, /* number of bits decoded by tl[] */ + int bd /* number of bits decoded by td[] */ +) +{ + unsigned e; /* table entry flag/number of extra bits */ + unsigned n, d; /* length and index for copy */ + unsigned w; /* current window position */ + struct huft *t; /* pointer to table entry */ + unsigned ml, md; /* masks for bl and bd bits */ + ulg b; /* bit buffer */ + unsigned k; /* number of bits in bit buffer */ + + /* make local copies of state */ + b = is->bb; /* initialize bit buffer */ + k = is->bk; /* initialize bit count */ + w = is->wp; /* initialize window position */ + + /* inflate the coded data */ + ml = mask_bits[bl]; /* precompute masks for speed */ + md = mask_bits[bd]; + for (;;) /* do until end of block */ + { + TRY + { + NEEDBITS((unsigned)bl) + if ((e = (t = tl + ((unsigned)b & ml))->e) > 16) + do { + if (e == 99) + return 1; + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16); + DUMPBITS(t->b) + + if (e == 16) /* it's a literal */ + { + is->window[w++] = (uch)t->v.n; + FLUSHWINDOW(w, FALSE); + } + else if (e == 15) /* it's an EOB */ + { + break; + } + else /* it's a length */ + { + /* get length of block to copy */ + NEEDBITS(e) + n = t->v.n + ((unsigned)b & mask_bits[e]); + DUMPBITS(e); + + /* decode distance of block to copy */ + NEEDBITS((unsigned)bd) + if ((e = (t = td + ((unsigned)b & md))->e) > 16) + do { + if (e == 99) + return 1; + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16); + DUMPBITS(t->b) + NEEDBITS(e) + d = w - t->v.n - ((unsigned)b & mask_bits[e]); + DUMPBITS(e) + + /* do the copy */ + do { + n -= (e = ((e = WINDOWSIZE - ((d &= WINDOWMASK) > w ? d : w)) > n) + ? n : e + ); +#if defined(MEMCPY) + if (w - d >= e) /* (this test assumes unsigned comparison) */ + { + memcpy(is->window + w, is->window + d, e); + w += e; + d += e; + } + else /* do it slow to avoid memcpy() overlap */ +#endif /* MEMCPY */ + do { + is->window[w++] = is->window[d++]; + } while (--e); + FLUSHWINDOW(w, FALSE); + } while (n); + } + } + CATCH_BEGIN + is->wp = w; /* restore window pointer */ + return -1; + CATCH_END + } + + /* restore the state from the locals */ + is->bb = b; /* restore bit buffer */ + is->bk = k; /* restore bit count */ + is->wp = w; /* restore window pointer */ + + /* done */ + return 0; +} + +/* + * "decompress" an inflated type 0 (stored) block. + */ + +static int inflate_stored_setup( + struct InflateState *is /* Inflate state */ +) +{ + unsigned n; /* number of bytes in block */ + ulg b; /* bit buffer */ + unsigned k; /* number of bits in bit buffer */ + + /* make local copies of state */ + b = is->bb; /* initialize bit buffer */ + k = is->bk; /* initialize bit count */ + + TRY + { + /* go to byte boundary */ + n = k & 7; + DUMPBITS(n); + + /* get the length and its complement */ + NEEDBITS(16) + n = ((unsigned)b & 0xffff); + DUMPBITS(16) + NEEDBITS(16) + if (n != (unsigned)((~b) & 0xffff)) + return 1; /* error in compressed data */ + DUMPBITS(16) + } + CATCH_BEGIN + return -1; + CATCH_END + + /* Save store state for this block */ + is->storelength = n; + + /* restore the state from the locals */ + is->bb = b; /* restore bit buffer */ + is->bk = k; /* restore bit count */ + + return 0; +} + +/* + * decompress an inflated type 1 (fixed Huffman codes) block. We should + * either replace this with a custom decoder, or at least precompute the + * Huffman tables. + */ + +static int inflate_fixed_setup( + struct InflateState *is /* Inflate state */ +) +{ + int i; /* temporary variable */ + struct huft *tl; /* literal/length code table */ + struct huft *td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned l[288]; /* length list for huft_build */ + + /* set up literal table */ + for (i = 0; i < 144; i++) + l[i] = 8; + for (; i < 256; i++) + l[i] = 9; + for (; i < 280; i++) + l[i] = 7; + for (; i < 288; i++) /* make a complete, but wrong code set */ + l[i] = 8; + bl = 7; + if ((i = huft_build(is, l, 288, 257, cplens, cplext, &tl, &bl)) != 0) + return i; + + /* set up distance table */ + for (i = 0; i < 30; i++) /* make an incomplete code set */ + l[i] = 5; + bd = 5; + if ((i = huft_build(is, l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) + { + huft_free(is, tl); + return i; + } + + /* Save inflate state for this block */ + is->tl = tl; + is->td = td; + is->bl = bl; + is->bd = bd; + + return 0; +} + +/* + * decompress an inflated type 2 (dynamic Huffman codes) block. + */ + +#define PKZIP_BUG_WORKAROUND + +static int inflate_dynamic_setup( + struct InflateState *is /* Inflate state */ +) +{ + int i; /* temporary variables */ + unsigned j; + unsigned l; /* last length */ + unsigned m; /* mask for bit lengths table */ + unsigned n; /* number of lengths to get */ + struct huft *tl; /* literal/length code table */ + struct huft *td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned nb; /* number of bit length codes */ + unsigned nl; /* number of literal/length codes */ + unsigned nd; /* number of distance codes */ +#ifdef PKZIP_BUG_WORKAROUND + unsigned ll[288+32]; /* literal/length and distance code lengths */ +#else + unsigned ll[286+30]; /* literal/length and distance code lengths */ +#endif + ulg b; /* bit buffer */ + unsigned k; /* number of bits in bit buffer */ + + /* make local copies of state */ + b = is->bb; /* initialize bit buffer */ + k = is->bk; /* initialize bit count */ + + /* initialize tl for cleanup */ + tl = NULL; + + TRY + { + /* read in table lengths */ + NEEDBITS(5) + nl = 257 + ((unsigned)b & 0x1f); /* number of literal/length codes */ + DUMPBITS(5) + NEEDBITS(5) + nd = 1 + ((unsigned)b & 0x1f); /* number of distance codes */ + DUMPBITS(5) + NEEDBITS(4) + nb = 4 + ((unsigned)b & 0xf); /* number of bit length codes */ + DUMPBITS(4) +#ifdef PKZIP_BUG_WORKAROUND + if (nl > 288 || nd > 32) +#else + if (nl > 286 || nd > 30) +#endif + return 1; /* bad lengths */ + + /* read in bit-length-code lengths */ + for (j = 0; j < 19; j++) ll[j] = 0; + for (j = 0; j < nb; j++) + { + NEEDBITS(3) + ll[border[j]] = (unsigned)b & 7; + DUMPBITS(3) + } + + /* build decoding table for trees--single level, 7 bit lookup */ + bl = 7; + if ((i = huft_build(is, ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) + { + if (i == 1) + huft_free(is, tl); + return i; /* incomplete code set */ + } + + /* read in literal and distance code lengths */ + n = nl + nd; + m = mask_bits[bl]; + i = l = 0; + while ((unsigned)i < n) + { + NEEDBITS((unsigned)bl) + j = (td = tl + ((unsigned)b & m))->b; + DUMPBITS(j) + j = td->v.n; + if (j < 16) /* length of code in bits (0..15) */ + ll[i++] = l = j; /* save last length in l */ + else if (j == 16) /* repeat last length 3 to 6 times */ + { + NEEDBITS(2) + j = 3 + ((unsigned)b & 3); + DUMPBITS(2) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = l; + } + else if (j == 17) /* 3 to 10 zero length codes */ + { + NEEDBITS(3) + j = 3 + ((unsigned)b & 7); + DUMPBITS(3) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = 0; + l = 0; + } + else /* j == 18: 11 to 138 zero length codes */ + { + NEEDBITS(7) + j = 11 + ((unsigned)b & 0x7f); + DUMPBITS(7) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = 0; + l = 0; + } + } + + /* free decoding table for trees */ + huft_free(is, tl); + } + CATCH_BEGIN + if (tl) huft_free(is, tl); + return -1; + CATCH_END + + /* restore the state from the locals */ + is->bb = b; /* restore bit buffer */ + is->bk = k; /* restore bit count */ + + /* build the decoding tables for literal/length and distance codes */ + bl = lbits; + if ((i = huft_build(is, ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) + { + if (i == 1) { + /* incomplete literal tree */ + huft_free(is, tl); + } + return i; /* incomplete code set */ + } + bd = dbits; + if ((i = huft_build(is, ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) + { + if (i == 1) { + /* incomplete distance tree */ +#ifdef PKZIP_BUG_WORKAROUND + } +#else + huft_free(is, td); + } + huft_free(is, tl); + return i; /* incomplete code set */ +#endif + } + + /* Save inflate state for this block */ + is->tl = tl; + is->td = td; + is->bl = bl; + is->bd = bd; + + return 0; +} + +/* Routine to initialize inflate decompression */ +void *InflateInitialize( /* returns InflateState */ + void *AppState, /* for passing to putbuffer */ + int (*putbuffer_ptr)( /* returns 0 on success */ + void *AppState, /* opaque ptr from Initialize */ + unsigned char *buffer, /* buffer to put */ + long length /* length of buffer */ + ), + void *(*malloc_ptr)(long length), /* utility routine */ + void (*free_ptr)(void *buffer) /* utility routine */ +) +{ + struct InflateState *is; + + /* Do some argument checking */ + if ((!putbuffer_ptr) || (!malloc_ptr) || (!free_ptr)) return NULL; + + /* Allocate the InflateState memory area */ + is = (struct InflateState *) (*malloc_ptr)(sizeof(struct InflateState)); + if (!is) return NULL; + + /* Set up the initial values of the inflate state */ + is->runtimetypeid1 = INFLATESTATETYPE; + is->errorencountered = FALSE; + + is->bb = 0; + is->bk = 0; + is->bp = 0; + is->bs = 0; + + is->wp = 0; + is->wf = 0; + + is->state = -1; + is->lastblock = FALSE; + + is->AppState = AppState; + + is->putbuffer_ptr = putbuffer_ptr; + is->malloc_ptr = malloc_ptr; + is->free_ptr = free_ptr; + + is->runtimetypeid2 = INFLATESTATETYPE; + + /* Return this state info to the caller */ + return is; +} + +/* Call-in routine to put a buffer into inflate decompression */ +int InflatePutBuffer( /* returns 0 on success */ + void *InflateState, /* opaque ptr from Initialize */ + unsigned char *buffer, /* buffer to put */ + long length /* length of buffer */ +) +{ + struct InflateState *is; + + int beginstate; + + /* Get (and check) the InflateState structure */ + is = (struct InflateState *) InflateState; + if (!is || (is->runtimetypeid1 != INFLATESTATETYPE) + || (is->runtimetypeid2 != INFLATESTATETYPE)) return TRUE; + if (is->errorencountered) return TRUE; + + do + { + int size, i; + + + if ((is->state == -1) && (is->lastblock)) break; + + /* Save the beginning state */ + beginstate = is->state; + + /* Push as much as possible into input buffer */ + size = BUFFERSIZE - is->bs; + if (size > length) size = (int) length; + i = is->bp + is->bs; + + while (size-- > 0) + { + is->buffer[i++ & BUFFERMASK] = *buffer; + is->bs++; + buffer++; + length--; + } + + /* Process some more data */ + if (is->state == -1) + { + int e; /* last block flag */ + unsigned t; /* block type */ + + ulg b; /* bit buffer */ + unsigned k; /* number of bits in bit buffer */ + + /* make local copies of state */ + b = is->bb; /* initialize bit buffer */ + k = is->bk; /* initialize bit count */ + + TRY + { + /* read in last block bit */ + NEEDBITS(1) + e = (int)b & 1; + DUMPBITS(1) + + /* read in block type */ + NEEDBITS(2) + t = (unsigned)b & 3; + DUMPBITS(2) + + if (t <= 2) + { + is->state = t; + is->lastblock = e; + } + else + { + ERROREXIT(is); + } + } + CATCH_BEGIN + CATCH_END + + /* restore the state from the locals */ + is->bb = b; /* restore bit buffer */ + is->bk = k; /* restore bit count */ + } + else if (is->state == 0) + { + int ret; + + ret = inflate_stored_setup(is); + + if (ret > 0) + ERROREXIT(is); + + if (ret == 0) is->state += 10; + } + else if (is->state == 1) + { + int ret; + + ret = inflate_fixed_setup(is); + + if (ret > 0) + ERROREXIT(is); + + if (ret == 0) is->state += 10; + } + else if (is->state == 2) + { + int ret; + + ret = inflate_dynamic_setup(is); + + if (ret > 0) + ERROREXIT(is); + + if (ret == 0) is->state += 10; + } + else if (is->state == 10) + { + int ret; + + ret = inflate_stored(is); + + if (ret > 0) + ERROREXIT(is); + + if (ret == 0) + { + is->state = -1; + } + } + else if ((is->state == 11) || + (is->state == 12) ) + { + int ret; + + ret = inflate_codes(is, is->tl, is->td, is->bl, is->bd); + + if (ret > 0) + ERROREXIT(is); + + if (ret == 0) + { + /* free the decoding tables */ + huft_free(is, is->tl); + huft_free(is, is->td); + is->state = -1; + } + } + else + { + ERROREXIT(is); + } + } + while (length || (is->state != beginstate)); + + FLUSHWINDOW(is->wp, TRUE); + + return is->errorencountered; +} + +/* Routine to terminate inflate decompression */ +int InflateTerminate( /* returns 0 on success */ + void *InflateState /* opaque ptr from Initialize */ +) +{ + int err; + void (*free_ptr)(void *buffer); + + struct InflateState *is; + + /* Get (and check) the InflateState structure */ + is = (struct InflateState *) InflateState; + if (!is || (is->runtimetypeid1 != INFLATESTATETYPE) + || (is->runtimetypeid2 != INFLATESTATETYPE)) return TRUE; + + /* save the error return */ + err = is->errorencountered || (is->bs > 0) + || (is->state != -1) + || (!is->lastblock); + + /* save the address of the free routine */ + free_ptr = is->free_ptr; + + /* Deallocate everything */ + (*free_ptr)(is); + + return err; +} |