/* * inflate.c - inflate decompression routine * * Version 1.1.2 */ /* * Copyright (C) 1995, Edward B. Hamrick * * Permission to use, copy, modify, and distribute this software and * its documentation for any purpose and without fee is hereby granted, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear in * supporting documentation, and that the name of the copyright holders * not be used in advertising or publicity pertaining to distribution of * the software without specific, written prior permission. The copyright * holders makes no representations about the suitability of this software * for any purpose. It is provided "as is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, * IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT * OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ /* * Changes from 1.1 to 1.1.2: * Relicensed under the MIT license, with consent of the copyright holders. * Claudio Matsuoka (Jan 11 2011) */ /* * 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; }