/*
* inflate.c -- Not copyrighted 1992,1993 by Mark Adler
* Latest hacking on this version by Colin Plumb
* version p3, 19 Oct 1995
*
* $Id: pgpZInflate.c,v 1.2 1997/01/24 23:35:54 mhw Exp $
*/


/*
* You can do whatever you like with this source file, though I would
* prefer that if you modify it and redistribute it that you include
* comments to that effect with your name and the date. Thank you.
	*
	* History:
	* vers	date	who	what
	* ----  ---------  --------------  ------------------------------------
	* a ~~ Feb 92 M. Adler	used full (large, one-step) lookup table
	* b1 21 Mar 92 M. Adler	first version with partial lookup tables
	* b2 21 Mar 92 M. Adler	fixed bug in fixed-code blocks
	* b3 22 Mar 92 M. Adler	sped up match copies, cleaned up some
	* b4 25 Mar 92 M. Adler	added prototypes; removed window[] (now
	*	is the responsibility of unzip.h--also
	*	changed name to slide[]), so needs diffs
	*	for unzip.c and unzip.h (this allows
	*	compiling in the small model on MSDOS);
	*	fixed cast of q in huft_build();
	* b5 26 Mar 92 M. Adler	got rid of unintended macro recursion.
	* b6 27 Mar 92 M. Adler	got rid of nextbyte() routine. fixed
	*	bug in inflate_fixed().
	* c1 30 Mar 92 M. Adler	removed lbits, dbits environment variables.
	*	changed BMAX to 16 for explode. Removed
	*	OUTB usage, and replaced it with flush()--
	*	this was a 20% speed improvement! Added
	*	an explode.c (to replace unimplode.c) that
	*	uses the huft routines here. Removed
	*	register union.
	* c2	4 Apr 92 M. Adler fixed bug for file sizes a multiple of 32k.
	* c3 10 Apr 92 M. Adler	reduced memory of code tables made by
	*	huft_build significantly (factor of two to
	*	three).
	* c4 15 Apr 92 M. Adler	added NOMEMCPY do kill use of memcpy().
	*	worked around a Turbo C optimization bug.
	* c5 21 Apr 92 M. Adler	added the WSIZE #define to allow reducing
	*	the 32K window size for specialized
	*	applications.
	* c6 31 May 92 M. Adler	added some typecasts to eliminate warnings
	* c7 27 Jun 92 G. Roelofs	added some more typecasts (444: MSC bug).
	* c8 5 Oct 92 J-l. Gailly	added ifdef'd code to deal with PKZIP bug.
	* c9 9 Oct 92 M. Adler	removed a memory error message (~line 416).
	* c10 17 Oct 92 G. Roelofs	changed ULONG/UWORD/byte to ulg/ush/uch,
	*	removed old inflate, renamed inflate_entry
	*	to inflate, added Mark's fix to a comment.
	* c11 2 Jan 93 M. Adler	fixed bug in detection of incomplete
	*	tables, and removed assumption that EOB is
	*	the longest code (bad assumption).
	* c12 3 Jan 93 M. Adler	make tables for fixed blocks only once.
	* c13 5 Jan 93 M. Adler	allow all zero length codes (pkzip 2.04c
	*	outputs one zero length code for an empty
	*	distance tree).
	* c14 12 Mar 93 M. Adler	made inflate.c standalone with the
	*	introduction of inflate.h.
	* d0 25 Apr 93 M. Adler	several speedups in inflate_codes of
	*	almost 20% (suggested by Urban Mueller)--
	*	now requires the use of backfill.[ch]
	* d1 4 May 93 M. Adler deleted extraneous statement in cheap loop,
	* optimized common copy a little more.
	* d2 5 May 93 M. Adler calculate number of cheap loops, a few
	* other small optimizations.
	* p1 Nov 93 C. Plumb Adpated to be able to suspend itself.
	* Pretty massive reorganization.
	* Many comments added.
	* p2 18 Oct 95 C. Plumb	Improved interface some more. Now
	*	nicely re-entrant. Still more comments.
	* p3 19 Oct 95 C. Plumb	Changed infInflate core function so that
	*	it sucks the input completely dry before
	*	returning. This gets rid of the old ad-hoc
	*	technique for flushing out the last little
	*	bit of a compressed file by padding it
	*	with some dummy data, which was ugly.
*/


/*
* 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 (16-bit) 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. Similarily, 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.
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h> /* for memset() */

#include "pgpDebug.h"
#include "pgpMem.h"
#include "pgpUsuals.h"
#include "pgpZInflate.h"

/* Increasing these only wastes space, so they can be changed if necessary */
typedef word16 ush;
typedef word32 ulg;

/* Private context structure for use by all functions. */
struct InflateContext {
		/* Major state information */
		int state;
		int substate;
		int lastblock;

		/* Output-related information */
		unsigned char *slide; /* Circular output buffer */
		unsigned char *slideend;
		unsigned slidelen; /* slideend-slide - MUST BE POWER OF 2 */
		unsigned slidemask; /* slidelen-1 */
		unsigned char *outptr; /* Pointer into slide */
		unsigned char const *readptr; /* Pointer into slide for reading */

		/* Input-related information */
		unsigned char const *inptr; /* Input pointer */
		int inlen;  /* Input length */
		ulg bitbuffer;
		unsigned bufbits;

		/* The literal/length tree - also used for the bit-length tree */
		struct huft *tree1;
		unsigned bits1;

		/* The distance tree */
		struct huft *tree2;
		unsigned bits2;

		/* Encoded huffman tree */
		unsigned char bitlen[286+30];

		/* For dynamic trees */
		unsigned bitlengths;
		unsigned litcodes;
		unsigned distcodes;

		/* Used in various places */
		struct huft const *t;
		unsigned copylen;
		int distbase;
		int numbits; /* # of bits in dyn. tree repeat and after dist. code*/
		unsigned index; /* Position in dynamic tree bit lengths we've read to*/
	};

/* Options for behaviour */
	#ifndef SECURE
	#define SECURE 1	/* Wipe memory before freeing it? */
	#endif

	#ifndef WSIZE
	#define WSIZE 32768	/* Window size - 32768 for PKZIP compatibility */
	#endif

	#ifndef STRICT
	#define STRICT 1	/* Require unused bits to be zero? */
	#endif

	/*
* 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 == 32 is EOB (end of block), e == 16
* means that v is a literal, e < 0 means that v is a pointer to the next
* table, which codes -e bits, and lastly e == -128 indicates an unused
* code. If a code with e == -128 is looked up, this implies an error in
* the data.
*/
struct huft {
		union {
			struct {
			 signed char exop; /* # of extra bits or operation */
			 char bits; /* # of bits in this code/subcode */
			} what;
			char *pad;	/* pad structure to a power of 2 (4 bytes for*/
		} word; 		/* 16-bit, 8 bytes for 32-bit machines) */
		union {
			ush base;	/* literal, length base, or distance base */
			struct huft *next; /* pointer to next level of table */
		} more;
	};

#define base more.base
#define next more.next
#define exop word.what.exop
#define bits word.what.bits


/* Function prototypes */
#ifndef OF
# if defined(__STDC__) || defined(__cplusplus)
# define OF(a) a
# else
# define OF(a) ()
# endif
#endif

static int huft_build OF((unsigned char const *, unsigned, unsigned,
ush const *, ush const *, struct huft **,
unsigned *));
static int huft_free OF((struct huft *));

/*
* The inflate algorithm uses a sliding 32K byte window on the uncompressed
* stream to find repeated byte strings. This is implemented here as a
* circular buffer. The index is updated simply by incrementing and then
* and'ing with 0x7fff (32K-1).
*/

/* Tables for deflate from PKZIP's appnote.txt. */
static unsigned const 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 ush const cplens[] = { /* Copy lengths for literal codes 257..285 */
 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 21, 25, 29,
 33, 41, 49, 57, 65, 81, 97, 113, 129, 161, 193, 225, 256, 0, 0};
 /* actually lengths - 2; also see note #13 above about 258 */

static ush const 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, 128, 128}; /* 128==invalid */

static ush const 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 ush const 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};

/* And'ing with mask[n] masks the lower n bits */
static unsigned const mask[17] = {
0x0000,
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};


/* Macros for inflate() bit peeking and grabbing.
* The usage is:
*
*	NEEDBITS(j)
*	x = b & mask[j];
*	DUMPBITS(j)
*
* where 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.
*
* It is allowed for more bits to be requested than actually used.
* The remainder stay in the bit buffer. NOTE that a few more
* bytes than necessary may be grabbed at the end of input.
* This should not be fatal as long as the grabbed bits stay
* in the bit buffer. The wrapup functions should check for this.

* There is also the macro GRABBITS which is like NEEDBITS, but uses
* *g++ to get the byte without checking availability. This requires
* using AVAILBYTES first to assure that the needed bytes are there
* already. g is set to inptr and then inptr is restored to g around
* this usage.
*/

/*
* Variable usage:
* b = bit buffer, k least-significant bits valid
* k = # of bits in bit buffer
* g = grab bits pointer (pointer to next byte to add: b |= *g++ << k)
* s = # of bytes available
* ctx = InflateContext
*/

/* Functions to save the state of the bit buffer before returning */
#define LOADBITBUF \
 (b=ctx->bitbuffer, k=ctx->bufbits, g=ctx->inptr, s=ctx->inlen)
#define SAVEBITBUF \
 (ctx->bitbuffer=b, ctx->bufbits=k, ctx->inptr=g, ctx->inlen=s)
#define SAVEBITBUFEMPTY \
 (ctx->bitbuffer=b, ctx->bufbits=k, ctx->inptr=g, ctx->inlen=0)

/*
* A simple macro to ensure that at least "x" bits are in the bit buffer.
* Does NOT check for input underflow (s < 0).
*/
#define GRABBITS(x) \
		while (k < x) { \
			--s; \
			b |= (ulg)*g++ << k; \
			k += 8; \
		}

/*
* Get "x" bits in the input buffer or execute the "whatif" code.
* NOTE NOTE NOTE that if the "whatif" code is executed, s is set to -1!
* (This is faster on a lot of machines.) You will usually have to
* reset it to 0 manually.
*/
#define GETBITSOR(x, whatif) \
		while (k < (unsigned)(x)) { \
			if (--s < 0) { \
			 whatif; \
			} \
			b |= (ulg)*g++ << k; \
			k += 8; \
		}

/*
* A macro to ensure that there are at least "x" bits available in the
* bit buffer. If there are not, the bit buffer is saved back into the
* context, and any code in "savestate" is run to save any additional
* context that might be needed. Then, "return 1" means that more input is
* needed.
*/
#define NEEDBITS(x, savestate) \
 GETBITSOR(x, savestate; SAVEBITBUFEMPTY; return 1)

/*
* NEEDBITS2 uses two figures for the number of bits required. The first,
* x, is cheap to compute and is used unless we run out of input data.
* If that happens, the more expensive value, x2, is used.
*/
#define NEEDBITS2(x, x2, savestate) \
 NEEDBITS(x, if (k >= (unsigned)(x2)) {s=0; break;} savestate)

#define DUMPBITS(x) (b >>= x, k -= x)

/*
* 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 values 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.
*/

#define LBITS 9 /* bits in base literal/length lookup table */
#define 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 15 /* maximum bit length of any code (16 for explode) */
#define N_MAX 288 /* maximum number of codes in any set */

#if defined(__STDC__) || defined(__cplusplus)
static int
huft_build(unsigned char const *b, unsigned n, unsigned s, ush const *d,
 ush const *e, struct huft **t, unsigned *m)
#else
static int
huft_build(b, n, s, d, e, t, m)
unsigned char *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) */
	ush const *d;	/* list of base values for non-simple codes */
	ush const *e;	/* list of extra bits for non-simple codes */
	struct huft **t;	/* result: starting table */
	unsigned *m;	/* suggested lookup bits, returns actual */
	#endif
/*
* Given a list of code lengths and a maximum table size, make a set of
* tables to decode that set of codes. Return values:
* 0 = success
* 1 = the given code set is incomplete
* (the tables are still built in this case)
* 2 = the input is invalid
* (all zero length codes or an oversubscribed set of lengths)
* 3 = not enough memory.
*/
{
	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 char const *bp; /* pointer into b[] */
	register unsigned *p;	/* pointer into c[] or v[] */
	register 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 */
	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(c, 0, sizeof(c));
	bp = b; i = n;
	do {
	c[*bp++]++;	/* 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 */
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 */
		bp = b; i = 0;
		do {
		if ((j = *bp++) != 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] = (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; /* 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 = (struct huft *)pgpMemAlloc((z + 1)*sizeof(struct huft))) ==
		(struct huft *)NULL)
		{
		if (h)
		huft_free(u[0]);
			return 3;		/* not enough memory */
		}
#if SECURE
		q->bits = (char)j;			/* Track size for free */
	#endif
		*t = q + 1;			/* link to list for huft_free() */
		*(t = &(q->next)) = (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.bits = (char)l;		/* bits to dump before this table */
			r.exop = -(char)j;		/* bits in this table */
			r.next = 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.bits = (char)(k - w);
		if (p >= v + n) {
		r.exop = -128; /* out of values--invalid code */
		} else if (*p < s) {
		r.exop = (char)(*p < 256 ? 16 : 32); /* 256 is end-of-block code */
		r.base = *p++; /* simple code is just the value */
		} else {
		r.exop = (char)e[*p - s]; /* non-simple--look up in lists */
		r.base = 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;

		/* back up over finished tables */
		while ((i & ((1 << w) - 1)) != x[h]) {
		h--; /* don't need to update q */
		w -= l;
		}
	}
}


/* Return true (1) if we were given an incomplete table */
return y != 0 && g != 1;
}


#if defined(__STDC__) || defined(__cplusplus)
static int
huft_free(struct huft *t)
#else
	static int
	huft_free(t)
	struct huft *t;	/* table to free */
	#endif
/*
* 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 -1st entry of
* each table.
*/
{
register struct huft *p, *q;

/* Go through linked list, freeing from the malloced (t[-1]) address. */
p = t;
while (p != (struct huft *)NULL)
{
q = (--p)->next;
#if SECURE
memset(p, 0, (1+(1<<p->bits)) * sizeof(*p));
#endif
pgpMemFree(p);
	p = q;
}
return 0;
}


/*
* Colin's new code.
*/

#define STATE_START 0
#define STATE_STOREDLEN 1
#define STATE_STORED 2
#define STATE_DYN_HDR 3
#define STATE_DYN_BITS 4
#define STATE_DYN_TREE 5
#define STATE_INFLATE 6
#define STATE_DONE 7
#define STATE_STOP 8

/*
* All these functions return
* 2 if the output buffer is full
* 1 if the input buffer is empty
* 0 if things should continue with the new ctx->state, and
* <0 on error.
*/

static int
infStoredLen(struct InflateContext *ctx)
	{
	ulg b;
		unsigned k;
		int s;
		unsigned char const *g;
		unsigned t;

		LOADBITBUF;
		t = k & 7;
#if STRICT
		if (b & mask[t])	/* Require unused bits are zero */
		 return INFERR_BADINPUT;
	#endif
		DUMPBITS(t);

		NEEDBITS(32, (void)0);

		/* At this point, k is exactly 32 */

		ctx->copylen = (unsigned)b & 0xffff;
		t = ~(unsigned)(b>>16) & 0xffff;
		b = 0;
		k = 0;

		SAVEBITBUF;
		if (t != ctx->copylen)
		 return INFERR_BADINPUT; /* Two lengths not identical */

		ctx->state = STATE_STORED;
		ctx->substate = 0;

		return 0;
}

/*
* Process the data in a stored block. Copy the input data to
* the circular buffer, flushing it as necessary.
*/
static int
infStored(struct InflateContext *ctx)
{
int len; /* # of bytes to copy */
 int retval = 1; /* Out of memory */

 pgpAssert(ctx->bufbits == 0);

		len = ctx->inlen;
		if ((unsigned)len >= ctx->copylen) {
		len = ctx->copylen; /* Copy done! */
		 ctx->state = STATE_START;
		 retval = 0;
		}
		if (len > ctx->slideend-ctx->outptr) {
		 len = (int)(ctx->slideend-ctx->outptr);
		 retval = 2; /* Output buffer full */
		}

		memcpy(ctx->outptr, ctx->inptr, len);
		ctx->inptr += len;
		ctx->inlen -= len;
		ctx->outptr += len;
		ctx->copylen -= (unsigned)len;

		/* Return 2 if output full, 1 if input empty, 0 otherwise (copy done)*/
		return retval;
	}

static int
infDynHdr(struct InflateContext *ctx)
	{
		ulg b;
		unsigned k;
		int s;
		unsigned char const *g;

LOADBITBUF;
NEEDBITS(14, (void)0);

ctx->litcodes = 257 + ((unsigned)b & 0x1f);
DUMPBITS(5);
ctx->distcodes = 1 + ((unsigned)b & 0x1f);
DUMPBITS(5);
ctx->bitlengths = 4 + ((unsigned)b & 0xf);
DUMPBITS(4);

SAVEBITBUF;

#ifndef PKZIP_BUG_WORKAROUND
		if (ctx->litcodes > 286 || ctx->distcodes > 30)
		 return INFERR_BADINPUT; /* Bad lengths */
	#endif
		ctx->state = STATE_DYN_BITS;
		return 0;
	}

/* Load up the ctx->bitlen array with the bit lengths for the encoded
* trees. Unpermute them according to the border[] array.
*/
static int
infDynBits(struct InflateContext *ctx)
{
 ulg b;
 unsigned k;
 int s;
		unsigned char const *g;
		struct huft *t;
		int i, lim;

		LOADBITBUF;
		i = ctx->substate;
		lim = ctx->bitlengths;

		while (i < lim) {
		 NEEDBITS(3, ctx->substate=i)
		 ctx->bitlen[border[i++]] = (unsigned)b & 7;
		 DUMPBITS(3);
		}
		SAVEBITBUF;

		while (i < 19)
		 ctx->bitlen[border[i++]] = 0;

		k = 7; /* Bits in tree table */

		i = huft_build(ctx->bitlen, 19, 19, NULL, NULL, &t, &k);
		if (i) {
		 if (i == 1)
		  huft_free(t); /* Incomplete code set */
		 return i == 3 ? INFERR_NOMEM : INFERR_BADINPUT;
		}
		ctx->tree1 = t;
		ctx->bits1 = k;

		ctx->state = STATE_DYN_TREE;
		ctx->substate = 0;

		return 0;
}

/* The static tree (built on demand) */
static struct huft *fixed_tl = NULL;
static struct huft *fixed_td;
static unsigned fixed_bl, fixed_bd;

static int
infFixedTree(void)
{
		int i;
		unsigned char l[288];

		if (fixed_tl)
		 return 0;	/* All okay */

		/* 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;
fixed_bl = 7;
i = huft_build(l, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl);
	if (i != 0) {
	 fixed_tl = NULL;
	return INFERR_NOMEM;
	}

	/* distance table */
	for (i = 0; i < 30; i++)	/* make an incomplete code set */
	 l[i] = 5;
	fixed_bd = 5;
i = huft_build(l, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd);
if (i > 1) {
 huft_free(fixed_tl);
 fixed_tl = NULL;
 return INFERR_NOMEM;
}

return 0;
}

static int
infDynTree(struct InflateContext *ctx)
{
ulg b;
unsigned k;
int s;
unsigned char const *g;
struct huft *tl, *td;
unsigned bl, bd;
unsigned i, j, l, m, lim;

LOADBITBUF;
i = ctx->index;
l = ctx->numbits; /* Previous # of bits for repeat code use */
lim = ctx->litcodes + ctx->distcodes;
tl = ctx->tree1;
bl = ctx->bits1;
m = mask[bl];

	 switch(ctx->substate) {
	 case 0:
			i = 0;
			l = 0;
			/*FALLTHROUGH*/
			case 1:
			while (i < lim) {
			NEEDBITS2(bl, tl[(unsigned)b & m].bits,
			 ctx->index=i; ctx->numbits=l; ctx->substate=1)
			td = tl + ((unsigned)b & m);
			j = td->bits;
			DUMPBITS(j);
			j = td->base;
			if (j < 16) {
			 ctx->bitlen[i++] = l = j;
			} else if (j == 16) { /* 3 to 6 repeats */
			 /*FALLTHROUGH*/
		case 2:
				NEEDBITS(2, ctx->index=i; ctx->numbits=l;
				   ctx->substate=2)
				j = 3 + ((unsigned)b & 3);
				DUMPBITS(2);
				if (i + j > lim)
				 return INFERR_BADINPUT;
				do {
				 ctx->bitlen[i++] = (unsigned char)l;
				} while (--j);
				} else if (j == 17) { /* 3 to 10 zeros */
					/*FALLTHROUGH*/
			case 3:
					NEEDBITS(3, ctx->index=i; ctx->substate=3)
					j = 3 + ((unsigned)b & 7);
					DUMPBITS(3);
					if (i + j > lim)
					 return INFERR_BADINPUT;
					do {
					 ctx->bitlen[i++] = 0;
					} while (--j);
					l = 0;
				} else { /* j == 18 -- 11 to 138 zeros */
					pgpAssert(j == 18);
					/*FALLTHROUGH*/
			case 4:
					NEEDBITS(7, ctx->index=i; ctx->substate=4)
					j = 11 + ((unsigned)b & 127);
					DUMPBITS(7);
					if (i + j > lim)
					 return INFERR_BADINPUT;
					do {
					 ctx->bitlen[i++] = 0;
					} while (--j);
					l = 0;
				}
			}
		}

		/* Input finished */
		SAVEBITBUF;
		huft_free(tl);
		ctx->tree1 = 0;

		/* Now build the trees - literal/length, then distance */

		bl = LBITS;
		i = huft_build(ctx->bitlen, ctx->litcodes, 257,
			cplens, cplext, &tl, &bl);
		if (i != 0) {
		 if (i == 1)
		  huft_free(tl);
		 return i == 3 ? INFERR_NOMEM : INFERR_BADINPUT;
		}
		bd = DBITS;
		i = huft_build(ctx->bitlen+ctx->litcodes, ctx->distcodes, 0,
		 cpdist, cpdext, &td, &bd);
#ifdef PKZIP_BUG_WORKAROUND
 if (i > 1) {
#else
		if (i != 0) {
			if (i == 1)
			 huft_free(td);
	#endif
			huft_free(tl);
			return i == 3 ? INFERR_NOMEM : INFERR_BADINPUT;
		}
		ctx->tree1 = tl;
		ctx->bits1 = bl;
		ctx->tree2 = td;
		ctx->bits2 = bd;

		ctx->state = STATE_INFLATE;
		ctx->substate = 0;

		return 0;
}

/*
* This is the heart of ZIP inflation. The code is heavily optimized
* for speed, including for many brain-damaged compilers that can only
* optimize one statement at a time. To generate better code from
* such idiot compilers (which are distressingly common on platforms
* such as MS-DOS), expressions are made big and complex, and intermediate
* results are ssigned to variables in the expression where possible
* so the compiler won't try to use a disjoint temporary and have to
* spill. This makes the code a little hard to follow at times.
* Sorry.
*
* Also, due to the deep nesting (it's all in one function, again, for
* speed even on systems that can't inline), the indent amount is only
* two spaces and variable names are very short.
*
* This does NOT currently detect a reference to before the beginning of
* the file. It just blindly uses the circular buffer.
*/
static int
infInflate(struct InflateContext *ctx)
{
ulg b;  /* Bit buffer info - bit buffer itself */
unsigned k;  /* Number of low0order bits of b that are valid */
int s;  /* Bytes of valid input remaining */
unsigned char const *g; /* Input buffer pointer */

unsigned char *w; /* Window output write pointer */
unsigned r;  /* Space available after w (always >0) */

struct huft *tl, *td; /* Tree info (const except for EOB processing) */
unsigned bl, bd;
unsigned ml, md;
struct huft const *t; /* Temporary tree pointer */

unsigned char const *p; /* Copy source pointer */
int i;
int e;
unsigned n;  /* Copy length */
unsigned d;  /* Copy distance */

	LOADBITBUF; 	/* Load b, k, s, g */

w = ctx->outptr;
r = ctx->slideend-w;
pgpAssert(r);

	tl = ctx->tree1;	/* Literal/length tree */
	bl = ctx->bits1;	/* Number of bits in top-level table */
	ml = mask[bl];	/* Mask of that many bits */

	td = ctx->tree2;	/* Distance tree */
	bd = ctx->bits2;	/* Number of bits in top-level table */
	md = mask[bd];	/* Mask of that many bits */

/*
* We don't always need all of these, but it's easier to always
* load them than to do it conditionally.
*/
t = ctx->t;
n = ctx->copylen;
d = ctx->distbase;
e = ctx->numbits;

switch (ctx->substate) {
case 0:
	for (;;) {	/* do until end of block */
/*
* This cheap loop does no input or output checking.
* At most 258 bytes of output are produced per iteration,
* so we must do no more than r/258 iterations.
* Also, at most 15+5+15+13 = 48 bits = 6 bytes are consumed
* every iteration, so we can do no more than s/6 iterations.
* Also, to allow for starting with an empty bit buffer and
* ending with a full one, subtract 4 bytes, so it's (s-4)/6.
*
* These are approximated by r/256-1 and (s-2)/8, respectively.
* Note: for a file that compresses to 258 bytes per symbol (e.g. all
* the same character), that approximation would break down if
*
* r/256-1 > r/258
* thus, 258 * r - 256 * 258 > 256*r
* thus, 2 * r > 256 * 258
* thus, r > 128 * 258 = 33024 > 32768
*
* Of course, the window is <= 32768, so it's not a concern.
*
* For the input approximation to break down, you'd have to have
*
* (s-2)/8 > (s-4)/6
* thus, 6*s - 12 > 8*s - 32
* thus, 20 > 2*s
* thus, 10 > s
*
* But for s<10, both approximations (since this is integer math)
* return 0, so it's not a problem. The r/258 limit is usually
* hit first, so the crudeness of this approximation is acceptable.
*/
		while (r >= 512 && s >= 10) {
		/* Compute number of iterations we can do, worst-case */
		if ((e = (s - 2) >> 3) < (i = (r >> 8) - 1))
		i = e;
		/*
		* This is the cheap loop, which is performed i times before
		* the available buffer space is re-evaluated. If you want to
		* understand how the inflation process works, this is the best
		* part of the code to read, since it isn't cluttered up with
		* error checking. First comes a literal/length code, which
		* can be either a literal (0-255), an end of block code (256),
		*/
		do {
		GRABBITS(20) /* max bits for literal/length code */
		t = tl + ((unsigned)b & ml);
		if ((e = t->exop) < 0) {
		do {
		if (e == -128)
				return INFERR_BADINPUT;
				DUMPBITS(t->bits);
				e = -e;
				t = t->next + ((unsigned)b & mask[e]);
				} while ((e = t->exop) < 0);
			}
			DUMPBITS(t->bits);
			if (e & 16) { /* then it's a literal */
			*w++ = (unsigned char)t->base;
			continue;
			}
			if (e & 32)  /* EOB */
			goto EOB; /* At end of function */

			/* Else length code */

			/* get length of block to copy */
			n = t->base + ((unsigned)b & mask[e]);
			DUMPBITS(e);

			/* decode distance of block to copy */
			GRABBITS(15);
			t = td + ((unsigned)b & md);
			if ((e = t->exop) < 0) {
			do {
			if (e == -128)
			return INFERR_BADINPUT;
			DUMPBITS(t->bits);
			e = -e;
			t = t->next + ((unsigned)b & mask[e]);
			} while ((e = t->exop) < 0);
			}
			DUMPBITS(t->bits);
			GRABBITS((unsigned)e) /* get up to 13 extra bits */
			d = t->base + ((unsigned)b & mask[e]);
			DUMPBITS((unsigned)e);

#if WSIZE < 32768
 if (d > ctx->slidelen)
 return INFERR_BADINPUT;
#endif

			/* do the copy */
			if ((unsigned)(w - ctx->slide) >= d) {
			p = w - d;
			*w++ = *p++;
			*w++ = *p++;
			do {
			*w++ = *p++;
			} while (--n);
			} else {
			n += 2;
			p = w - d + ctx->slidelen;
			do {
			n -= (e = (unsigned)(e = ctx->slideend - (p>w?p:w)) > n ? n : e);
			do {
			*w++ = *p++;
			} while (--e);
			if (p == ctx->slideend)
			p = ctx->slide;
			} while (n);
			}
		} while (--i);

		r = ctx->slideend - w;
		} /* while (we can use the cheap loop) */

		/*
		* Okay, we've fallen through from the cheap loop to the
		* expensive loop. This one checks each time it gets bits
		* from the input or writes bytes to the output that there
		* is enough room. However, there are two versions of
		* much of *this*, too! The first uses worst-case figures
		* for the amount of input data needed, and obtains one batch of
		* input bits for several uses.
		* The second carefully avoids asking for any more bits than it really
		* needs. When it gives up and returns, it is really not possible
		* to extract any more symbols from the input data.
		*/
		/* Pessimistic estimate of bits for literal/length: 15+5 */
		GETBITSOR(20, goto getlitlength2)
		t = tl + ((unsigned)b & ml);
		if ((e = t->exop) < 0) {
		do {
		if (e == -128)
		return INFERR_BADINPUT;
		DUMPBITS(t->bits);
		e = -e;
		t = t->next + ((unsigned)b & mask[e]);
		} while ((e = t->exop) < 0);
		}
		DUMPBITS(t->bits);
		if (e & 16) { /* then it's a literal */
		*w++ = (unsigned char)t->base;
		if (--r == 0) {
		SAVEBITBUF;
		ctx->outptr = w;
		ctx->substate = 0; /* Restart at top of loop */
		return 2; /* Output buffer full */
		}
		continue;
		}

		if (e & 32)
		break; /* Leave infinite loop */

goto gotlength;

getlitlength2:
		/* Method 2: We don't even have 20 bits available - do it bit-by-bit. */
		t = tl + ((unsigned)b & ml);
		/*
		* See if higher-order bits we're missing actually matter.
		* We don't have to try to fill the bit buffer, because we only get
		* here if s (number of following input bytes) is supposed to be zero.
		*/
		if (k < (unsigned)t->bits) {
		ctx->outptr = w;
		ctx->substate = 0;
		SAVEBITBUFEMPTY;
		return 1;
		}
		/* Actually, s is set (see GETBITSOR comment) to -1, so reset it */
		s = 0;
		if ((e = t->exop) < 0) {
		do {
		if (e == -128)
		return INFERR_BADINPUT;
		DUMPBITS(t->bits);
		e = -e;
		t = t->next;
		case 1:
		NEEDBITS2(e, t[(unsigned)b & mask[e]].bits,
		ctx->t=t; ctx->outptr=w; ctx->numbits=e; ctx->substate=1)
		t += (unsigned)b & mask[e];
		} while ((e = t->exop) < 0);
		}
		DUMPBITS(t->bits);
		if (e & 16) { /* then it's a literal */
		*w++ = (unsigned char)t->base;
		if (--r == 0) {
		/* We just filled the output buffer - return */
		SAVEBITBUF;
		ctx->outptr = w;
		ctx->substate = 0; /* Restart at top of loop */
		return 2; /* Output buffer full */
		}
		continue;
		}

		if (e & 32) /* EOB */
		break; /* Leave infinite loop */

		/*FALLTHROUGH*/
		case 2:
		NEEDBITS(e, ctx->t = t; ctx->outptr=w; ctx->numbits=e; ctx->substate=2)

gotlength:

/* All data is available - compute total length of block to copy */
n = t->base + ((unsigned)b & mask[e]);
DUMPBITS((unsigned)e);

	/*FALLTHROUGH*/
case 3:
/* Get distance code - 15 is maximum code size */
GETBITSOR(15, goto getdistance2)
t = td + ((unsigned)b & md);
/* Negative t->exop means there's a subtable of 2^-e entries */
		if ((e = t->exop) < 0) {
		do {
		if (e == -128)
		return INFERR_BADINPUT;	/* Invalid code (static table case) */
		DUMPBITS(t->bits);
		e = -e;
		t = t->next + ((unsigned)b & mask[e]);
		} while ((e = t->exop) < 0);
		}
		goto gotdistance;

getdistance2:
/* We don't even have 15 bits available - do it bit-by-bit. */
t = td + ((unsigned)b & md);
/*
* See if higher-order bits we're missing actually matter.
* We don't have to try to fill the bit buffer, because we only get
* here if s (number of following input bytes) is supposed to be zero.
	*/
if (k < (unsigned)t->bits) {
ctx->outptr = w;
ctx->copylen = n;
ctx->substate = 3;
SAVEBITBUFEMPTY;
return 1;
}
/* Actually (see GETBITSOR comment) s is set to -1, so reset it */
s = 0;
/* Negative t->exop means there's a subtable of 2^-e entries */
		if ((e = t->exop) < 0) {
		do {
		if (e == -128)
		return INFERR_BADINPUT;	/* Invalid code (static table case) */
		DUMPBITS(t->bits);
		e = -e;
		t = t->next;
	case 4:
NEEDBITS2(e, t[(unsigned)b & mask[e]].bits, ctx->t=t; ctx->outptr=w;
ctx->copylen = n; ctx->numbits=e; ctx->substate=4)
		t += (unsigned)b & mask[e];
		} while ((e = t->exop) < 0);
		}

gotdistance:
/* All data is available - compute the base distance */
DUMPBITS(t->bits);
d = t->base;
/*FALLTHROUGH*/
case 5:
/* e is number of bits extra following distance code (0..13) */
NEEDBITS(e, ctx->outptr=w; ctx->copylen=n; ctx->distbase=d;
	ctx->numbits=e; ctx->substate=5)
d += ((unsigned)b & mask[e]);
DUMPBITS((unsigned)e);

#if WSIZE < 32768
		if (d > ctx->slidelen)
		return INFERR_BADINPUT;
	#endif

		/* do the copy, with handling for wrapping around end of buffer */
		if ((unsigned)(w - ctx->slide) >= d && w + n < ctx->slideend - 2) {
		/* Simple case - neither source nor dest cross end of buffer */
		p = w - d;
		r -= n + 2;
		*w++ = *p++;
		*w++ = *p++;
		do {
		*w++ = *p++;
		} while (--n);
		} else {
		n += 2; /* # of bytes to copy */
		p = ctx->slide + ((w - ctx->slide - d) & ctx->slidemask); /* src */
		do {
		/* Set e to number of bytes we can copy at once */
		n -= (e = (unsigned)(e = ctx->slideend - (p>w?p:w)) > n ? n : e);
		r -= e;
		do {
		*w++ = *p++;
		} while (--e);
		if (r == 0) { /* Did we just write everything we could? */
		SAVEBITBUF;
		ctx->outptr = w;
		ctx->copylen = n;
		ctx->distbase = d; /* Save copy distance to recompute p */
		ctx->substate = 6;
		return 2; /* Need more output space */
case 6:
		p = ctx->slide + ((w - ctx->slide - d) & ctx->slidemask);
		}
		if (p == ctx->slideend)
		p = ctx->slide;
		} while (n);
	}
} /* for(;;) */
} /* switch(ctx->subcase) */

EOB:
/* End of Block */
ctx->outptr = w;
SAVEBITBUF;
ctx->state = STATE_START;
ctx->substate = 0;

if (tl && tl != fixed_tl)
huft_free(tl);
if (td && td != fixed_td)
huft_free(td);
ctx->tree1 = 0;
ctx->tree2 = 0;

return 0;
}


/*
* Start state - read 3 bits, which are last block flag (set to 1 on
* last block), and 2 bits of block type.
*/
static int
infStart(struct InflateContext *ctx)
	{
		ulg b;
		unsigned k;
		int s;
		unsigned char const *g;
		int retval = 0;

		if (ctx->lastblock) {
		 ctx->state = STATE_DONE;
		 return 0;
		}

		LOADBITBUF;
		NEEDBITS(3, (void)0);

		ctx->lastblock = (int)(b & 1);
		DUMPBITS(1);

		switch(b & 3) {
		case 0: /* Stored */
		 ctx->state = STATE_STOREDLEN;
		 break;
		case 1: /* Static - build fixed trees and start decoding */
			retval = infFixedTree();
			ctx->tree1 = fixed_tl;
			ctx->bits1 = fixed_bl;
			ctx->tree2 = fixed_td;
			ctx->bits2 = fixed_bd;
			ctx->state = STATE_INFLATE;
			break;
		case 2: /* Dynamic */
		 ctx->state = STATE_DYN_HDR;
		 break;
		case 3: /* Illegal */
		 retval = INFERR_BADINPUT;
		 break;
		}

		DUMPBITS(2);
		SAVEBITBUF;

 ctx->substate = 0;
 return retval;
}

/*
* Get a pointer to available data in the output buffer
*/
unsigned char const *
infGetBytes(struct InflateContext *ctx, unsigned *len)
	{
		*len = ctx->outptr - ctx->readptr;
		return *len ? ctx->readptr : 0;
	}

/*
* Mark data in the output buffer as already read. We don't start
* accepting new data until the entire output buffer has been read,
* at which point the outptr is set back to the beginning of the
* buffer.
*/
void
infSkipBytes(struct InflateContext *ctx, unsigned len)
	{
		pgpAssert(len <= (unsigned)(ctx->outptr - ctx->readptr));

	   ctx->readptr += len;

/* If at end of buffer, recirculate */
if (ctx->readptr == ctx->slideend) {
		pgpAssert(ctx->outptr == ctx->slideend);
		ctx->readptr = ctx->outptr = ctx->slide;
	}
}


/*
 * Returns number of bytes written.
 * *error < 0 on error, == 0 if no error (done with input or output full)
 */
size_t
infWrite(struct InflateContext *ctx, unsigned char const *buf, size_t len,
int *error)
{
int i;

if (ctx->outptr == ctx->slideend) {
 *error = (ctx->state == STATE_STOP) ? 0 : ctx->substate;
 return 0; /* Out of output space! */
}

		ctx->inptr = buf;
		/* Decompression code can't handle more than INT_MAX bytes at a time */
		ctx->inlen = len > INT_MAX ? INT_MAX : (int)len;

		do {
		 switch(ctx->state) {
		 case STATE_START:
				i = infStart(ctx);
				break;
				case STATE_STOREDLEN:
				i = infStoredLen(ctx);
				break;
				case STATE_STORED:
				i = infStored(ctx);
				break;
				case STATE_DYN_HDR:
				i = infDynHdr(ctx);
				break;
				case STATE_DYN_BITS:
				i = infDynBits(ctx);
				break;
				case STATE_DYN_TREE:
				i = infDynTree(ctx);
				break;
				case STATE_INFLATE:
				i = infInflate(ctx);
				break;
				case STATE_DONE:
				if (ctx->inlen || ctx->bufbits > 7)
				 i = INFERR_LONG;
#if STRICT
				else if (ctx->bitbuffer & mask[ctx->bufbits])
				i = INFERR_BADINPUT; /* Unused bits != 0 */
	#endif
				else
					i = 2; /* Read output, please */
				break;
				case STATE_STOP:
				i = ctx->substate;
				break;
				default:
				pgpAssert(i=0); /* To shut up compiler warnings */
			}
		} while (i == 0);

if (i < 0) {
ctx->state = STATE_STOP;
ctx->substate = i;
*error = i;
} else {
*error = 0;
}

pgpAssert((size_t)(ctx->inptr - buf) == len - ctx->inlen);
return (size_t)(ctx->inptr - buf); /* Bytes read */
}

/*
* Signal EOF, detecting truncated messages.
* If another error has been reported, this just repeats it.
*/
/* New version, hopefully useful. */
int
infEOF(struct InflateContext *ctx)
{
/* If processing is halted, just return the last error (if any) */
if (ctx->state == STATE_STOP)
 return ctx->substate;

/* If expecting still more input, we're short */
if (ctx->state != STATE_DONE)
 return INFERR_SHORT;

/* Otherwise, all is well. */
 return 0;
}

struct InflateContext *
infAlloc(void)
{
struct InflateContext *ctx;
unsigned char *slide;

slide = (unsigned char *)pgpMemAlloc(WSIZE);
if (!slide)
 return 0;
ctx = (struct InflateContext *)pgpMemAlloc(sizeof(*ctx));
if (!ctx) {
 pgpMemFree(slide);
 return 0;
}
ctx->slide = slide;
ctx->slideend = slide+WSIZE;
ctx->slidelen = WSIZE;
ctx->slidemask = WSIZE-1;

ctx->outptr = slide;
ctx->readptr = slide;

ctx->state = STATE_START;
ctx->substate = 0;
ctx->inlen = 0;
ctx->bitbuffer = 0;
ctx->bufbits = 0;
ctx->lastblock = 0;

ctx->tree1 = 0;
ctx->tree2 = 0;

return ctx;
}

void
infFree(struct InflateContext *ctx)
	{
		if (ctx->tree1 && ctx->tree1 != fixed_tl)
		 huft_free(ctx->tree1);
		if (ctx->tree2 && ctx->tree2 != fixed_td)
		 huft_free(ctx->tree2);

		if (ctx->slide) {
#if SECURE
		memset(ctx->slide, 0, ctx->slidelen);
#endif
  pgpMemFree(ctx->slide);
 }
#if SECURE
 memset(ctx, 0, sizeof(*ctx));
#endif
 pgpMemFree(ctx);
}
