src/zlib/infback.c

/* infback.c -- inflate using a call-back interface
 * Copyright (C) 1995-2003 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
   This code is largely copied from inflate.c.  Normally either infback.o or
   inflate.o would be linked into an application--not both.  The interface
   with inffast.c is retained so that optimized assembler-coded versions of
   inflate_fast() can be used with either inflate.c or infback.c.
 */

#include "zutil.h"
#include "inftrees.h"
#include "inflate.h"
#include "inffast.h"

/* function prototypes */
local void fixedtables OF((struct inflate_state FAR *state));

/*
   strm provides memory allocation functions in zalloc and zfree, or
   Z_NULL to use the library memory allocation functions.

   windowBits is in the range 8..15, and window is a user-supplied
   window and output buffer that is 2**windowBits bytes.
 */
int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
z_stream FAR *strm;
int windowBits;
unsigned char FAR *window;
const char *version;
int stream_size;
{
    struct inflate_state FAR *state;

    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
        stream_size != (int)(sizeof(z_stream)))
        return Z_VERSION_ERROR;
    if (strm == Z_NULL || window == Z_NULL ||
        windowBits < 8 || windowBits > 15)
        return Z_STREAM_ERROR;
    strm->msg = Z_NULL;                 /* in case we return an error */
    if (strm->zalloc == (alloc_func)0) {
        strm->zalloc = zcalloc;
        strm->opaque = (voidpf)0;
    }
    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
                                               sizeof(struct inflate_state));
    if (state == Z_NULL) return Z_MEM_ERROR;
    Tracev((stderr, "inflate: allocated\n"));
    strm->state = (voidpf)state;
    state->wbits = windowBits;
    state->wsize = 1U << windowBits;
    state->window = window;
    state->write = 0;
    state->whave = 0;
    return Z_OK;
}

/*
   Return state with length and distance decoding tables and index sizes set to
   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
   If BUILDFIXED is defined, then instead this routine builds the tables the
   first time it's called, and returns those tables the first time and
   thereafter.  This reduces the size of the code by about 2K bytes, in
   exchange for a little execution time.  However, BUILDFIXED should not be
   used for threaded applications, since the rewriting of the tables and virgin
   may not be thread-safe.
 */
local void fixedtables(state)
struct inflate_state FAR *state;
{
#ifdef BUILDFIXED
    static int virgin = 1;
    static code *lenfix, *distfix;
    static code fixed[544];

    /* build fixed huffman tables if first call (may not be thread safe) */
    if (virgin) {
        unsigned sym, bits;
        static code *next;

        /* literal/length table */
        sym = 0;
        while (sym < 144) state->lens[sym++] = 8;
        while (sym < 256) state->lens[sym++] = 9;
        while (sym < 280) state->lens[sym++] = 7;
        while (sym < 288) state->lens[sym++] = 8;
        next = fixed;
        lenfix = next;
        bits = 9;
        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);

        /* distance table */
        sym = 0;
        while (sym < 32) state->lens[sym++] = 5;
        distfix = next;
        bits = 5;
        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);

        /* do this just once */
        virgin = 0;
    }
#else /* !BUILDFIXED */
#   include "inffixed.h"
#endif /* BUILDFIXED */
    state->lencode = lenfix;
    state->lenbits = 9;
    state->distcode = distfix;
    state->distbits = 5;
}

/* Macros for inflateBack(): */

/* Load returned state from inflate_fast() */
#define LOAD() \
    do { \
        put = strm->next_out; \
        left = strm->avail_out; \
        next = strm->next_in; \
        have = strm->avail_in; \
        hold = state->hold; \
        bits = state->bits; \
    } while (0)

/* Set state from registers for inflate_fast() */
#define RESTORE() \
    do { \
        strm->next_out = put; \
        strm->avail_out = left; \
        strm->next_in = next; \
        strm->avail_in = have; \
        state->hold = hold; \
        state->bits = bits; \
    } while (0)

/* Clear the input bit accumulator */
#define INITBITS() \
    do { \
        hold = 0; \
        bits = 0; \
    } while (0)

/* Assure that some input is available.  If input is requested, but denied,
   then return a Z_BUF_ERROR from inflateBack(). */
#define PULL() \
    do { \
        if (have == 0) { \
            have = in(in_desc, &next); \
            if (have == 0) { \
                next = Z_NULL; \
                ret = Z_BUF_ERROR; \
                goto inf_leave; \
            } \
        } \
    } while (0)

/* Get a byte of input into the bit accumulator, or return from inflateBack()
   with an error if there is no input available. */
#define PULLBYTE() \
    do { \
        PULL(); \
        have--; \
        hold += (unsigned long)(*next++) << bits; \
        bits += 8; \
    } while (0)

/* Assure that there are at least n bits in the bit accumulator.  If there is
   not enough available input to do that, then return from inflateBack() with
   an error. */
#define NEEDBITS(n) \
    do { \
        while (bits < (unsigned)(n)) \
            PULLBYTE(); \
    } while (0)

/* Return the low n bits of the bit accumulator (n < 16) */
#define BITS(n) \
    ((unsigned)hold & ((1U << (n)) - 1))

/* Remove n bits from the bit accumulator */
#define DROPBITS(n) \
    do { \
        hold >>= (n); \
        bits -= (unsigned)(n); \
    } while (0)

/* Remove zero to seven bits as needed to go to a byte boundary */
#define BYTEBITS() \
    do { \
        hold >>= bits & 7; \
        bits -= bits & 7; \
    } while (0)

/* Assure that some output space is available, by writing out the window
   if it's full.  If the write fails, return from inflateBack() with a
   Z_BUF_ERROR. */
#define ROOM() \
    do { \
        if (left == 0) { \
            put = state->window; \
            left = state->wsize; \
            state->whave = left; \
            if (out(out_desc, put, left)) { \
                ret = Z_BUF_ERROR; \
                goto inf_leave; \
            } \
        } \
    } while (0)

/*
   strm provides the memory allocation functions and window buffer on input,
   and provides information on the unused input on return.  For Z_DATA_ERROR
   returns, strm will also provide an error message.

   in() and out() are the call-back input and output functions.  When
   inflateBack() needs more input, it calls in().  When inflateBack() has
   filled the window with output, or when it completes with data in the
   window, it calls out() to write out the data.  The application must not
   change the provided input until in() is called again or inflateBack()
   returns.  The application must not change the window/output buffer until
   inflateBack() returns.

   in() and out() are called with a descriptor parameter provided in the
   inflateBack() call.  This parameter can be a structure that provides the
   information required to do the read or write, as well as accumulated
   information on the input and output such as totals and check values.

   in() should return zero on failure.  out() should return non-zero on
   failure.  If either in() or out() fails, than inflateBack() returns a
   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
   was in() or out() that caused in the error.  Otherwise,  inflateBack()
   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
   error, or Z_MEM_ERROR if it could not allocate memory for the state.
   inflateBack() can also return Z_STREAM_ERROR if the input parameters
   are not correct, i.e. strm is Z_NULL or the state was not initialized.
 */
int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
z_stream FAR *strm;
in_func in;
void FAR *in_desc;
out_func out;
void FAR *out_desc;
{
    struct inflate_state FAR *state;
    unsigned char FAR *next;    /* next input */
    unsigned char FAR *put;     /* next output */
    unsigned have, left;        /* available input and output */
    unsigned long hold;         /* bit buffer */
    unsigned bits;              /* bits in bit buffer */
    unsigned copy;              /* number of stored or match bytes to copy */
    unsigned char FAR *from;    /* where to copy match bytes from */
    code this;                  /* current decoding table entry */
    code last;                  /* parent table entry */
    unsigned len;               /* length to copy for repeats, bits to drop */
    int ret;                    /* return code */
    static const unsigned short order[19] = /* permutation of code lengths */
        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

    /* Check that the strm exists and that the state was initialized */
    if (strm == Z_NULL || strm->state == Z_NULL)
        return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;

    /* Reset the state */
    strm->msg = Z_NULL;
    state->mode = TYPE;
    state->last = 0;
    state->whave = 0;
    next = strm->next_in;
    have = next != Z_NULL ? strm->avail_in : 0;
    hold = 0;
    bits = 0;
    put = state->window;
    left = state->wsize;

    /* Inflate until end of block marked as last */
    for (;;)
        switch (state->mode) {
        case TYPE:
            /* determine and dispatch block type */
            if (state->last) {
                BYTEBITS();
                state->mode = DONE;
                break;
            }
            NEEDBITS(3);
            state->last = BITS(1);
            DROPBITS(1);
            switch (BITS(2)) {
            case 0:                             /* stored block */
                Tracev((stderr, "inflate:     stored block%s\n",
                        state->last ? " (last)" : ""));
                state->mode = STORED;
                break;
            case 1:                             /* fixed block */
                fixedtables(state);
                Tracev((stderr, "inflate:     fixed codes block%s\n",
                        state->last ? " (last)" : ""));
                state->mode = LEN;              /* decode codes */
                break;
            case 2:                             /* dynamic block */
                Tracev((stderr, "inflate:     dynamic codes block%s\n",
                        state->last ? " (last)" : ""));
                state->mode = TABLE;
                break;
            case 3:
                strm->msg = (char *)"invalid block type";
                state->mode = BAD;
            }
            DROPBITS(2);
            break;

        case STORED:
            /* get and verify stored block length */
            BYTEBITS();                         /* go to byte boundary */
            NEEDBITS(32);
            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
                strm->msg = (char *)"invalid stored block lengths";
                state->mode = BAD;
                break;
            }
            state->length = (unsigned)hold & 0xffff;
            Tracev((stderr, "inflate:       stored length %u\n",
                    state->length));
            INITBITS();

            /* copy stored block from input to output */
            while (state->length != 0) {
                copy = state->length;
                PULL();
                ROOM();
                if (copy > have) copy = have;
                if (copy > left) copy = left;
                zmemcpy(put, next, copy);
                have -= copy;
                next += copy;
                left -= copy;
                put += copy;
                state->length -= copy;
            }
            Tracev((stderr, "inflate:       stored end\n"));
            state->mode = TYPE;
            break;

        case TABLE:
            /* get dynamic table entries descriptor */
            NEEDBITS(14);
            state->nlen = BITS(5) + 257;
            DROPBITS(5);
            state->ndist = BITS(5) + 1;
            DROPBITS(5);
            state->ncode = BITS(4) + 4;
            DROPBITS(4);
#ifndef PKZIP_BUG_WORKAROUND
            if (state->nlen > 286 || state->ndist > 30) {
                strm->msg = (char *)"too many length or distance symbols";
                state->mode = BAD;
                break;
            }
#endif
            Tracev((stderr, "inflate:       table sizes ok\n"));

            /* get code length code lengths (not a typo) */
            state->have = 0;
            while (state->have < state->ncode) {
                NEEDBITS(3);
                state->lens[order[state->have++]] = (unsigned short)BITS(3);
                DROPBITS(3);
            }
            while (state->have < 19)
                state->lens[order[state->have++]] = 0;
            state->next = state->codes;
            state->lencode = (code const FAR *)(state->next);
            state->lenbits = 7;
            ret = inflate_table(CODES, state->lens, 19, &(state->next),
                                &(state->lenbits), state->work);
            if (ret) {
                strm->msg = (char *)"invalid code lengths set";
                state->mode = BAD;
                break;
            }
            Tracev((stderr, "inflate:       code lengths ok\n"));

            /* get length and distance code code lengths */
            state->have = 0;
            while (state->have < state->nlen + state->ndist) {
                for (;;) {
                    this = state->lencode[BITS(state->lenbits)];
                    if ((unsigned)(this.bits) <= bits) break;
                    PULLBYTE();
                }
                if (this.val < 16) {
                    NEEDBITS(this.bits);
                    DROPBITS(this.bits);
                    state->lens[state->have++] = this.val;
                }
                else {
                    if (this.val == 16) {
                        NEEDBITS(this.bits + 2);
                        DROPBITS(this.bits);
                        if (state->have == 0) {
                            strm->msg = (char *)"invalid bit length repeat";
                            state->mode = BAD;
                            break;
                        }
                        len = (unsigned)(state->lens[state->have - 1]);
                        copy = 3 + BITS(2);
                        DROPBITS(2);
                    }
                    else if (this.val == 17) {
                        NEEDBITS(this.bits + 3);
                        DROPBITS(this.bits);
                        len = 0;
                        copy = 3 + BITS(3);
                        DROPBITS(3);
                    }
                    else {
                        NEEDBITS(this.bits + 7);
                        DROPBITS(this.bits);
                        len = 0;
                        copy = 11 + BITS(7);
                        DROPBITS(7);
                    }
                    if (state->have + copy > state->nlen + state->ndist) {
                        strm->msg = (char *)"invalid bit length repeat";
                        state->mode = BAD;
                        break;
                    }
                    while (copy--)
                        state->lens[state->have++] = (unsigned short)len;
                }
            }

            if (state->mode == BAD)
                break;

            /* build code tables */
            state->next = state->codes;
            state->lencode = (code const FAR *)(state->next);
            state->lenbits = 9;
            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
                                &(state->lenbits), state->work);
            if (ret) {
                strm->msg = (char *)"invalid literal/lengths set";
                state->mode = BAD;
                break;
            }
            state->distcode = (code const FAR *)(state->next);
            state->distbits = 6;
            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
                            &(state->next), &(state->distbits), state->work);
            if (ret) {
                strm->msg = (char *)"invalid distances set";
                state->mode = BAD;
                break;
            }
            Tracev((stderr, "inflate:       codes ok\n"));
            state->mode = LEN;

        case LEN:
            /* use inflate_fast() if we have enough input and output */
            if (have >= 6 && left >= 258) {
                RESTORE();
                if (state->whave < state->wsize)
                    state->whave = state->wsize - left;
                inflate_fast(strm, state->wsize);
                LOAD();
                break;
            }

            /* get a literal, length, or end-of-block code */
            for (;;) {
                this = state->lencode[BITS(state->lenbits)];
                if ((unsigned)(this.bits) <= bits) break;
                PULLBYTE();
            }
            if (this.op && (this.op & 0xf0) == 0) {
                last = this;
                for (;;) {
                    this = state->lencode[last.val +
                            (BITS(last.bits + last.op) >> last.bits)];
                    if ((unsigned)(last.bits + this.bits) <= bits) break;
                    PULLBYTE();
                }
                DROPBITS(last.bits);
            }
            DROPBITS(this.bits);
            state->length = (unsigned)this.val;

            /* process literal */
            if (this.op == 0) {
                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
                        "inflate:         literal '%c'\n" :
                        "inflate:         literal 0x%02x\n", this.val));
                ROOM();
                *put++ = (unsigned char)(state->length);
                left--;
                state->mode = LEN;
                break;
            }

            /* process end of block */
            if (this.op & 32) {
                Tracevv((stderr, "inflate:         end of block\n"));
                state->mode = TYPE;
                break;
            }

            /* invalid code */
            if (this.op & 64) {
                strm->msg = (char *)"invalid literal/length code";
                state->mode = BAD;
                break;
            }

            /* length code -- get extra bits, if any */
            state->extra = (unsigned)(this.op) & 15;
            if (state->extra != 0) {
                NEEDBITS(state->extra);
                state->length += BITS(state->extra);
                DROPBITS(state->extra);
            }
            Tracevv((stderr, "inflate:         length %u\n", state->length));

            /* get distance code */
            for (;;) {
                this = state->distcode[BITS(state->distbits)];
                if ((unsigned)(this.bits) <= bits) break;
                PULLBYTE();
            }
            if ((this.op & 0xf0) == 0) {
                last = this;
                for (;;) {
                    this = state->distcode[last.val +
                            (BITS(last.bits + last.op) >> last.bits)];
                    if ((unsigned)(last.bits + this.bits) <= bits) break;
                    PULLBYTE();
                }
                DROPBITS(last.bits);
            }
            DROPBITS(this.bits);
            if (this.op & 64) {
                strm->msg = (char *)"invalid distance code";
                state->mode = BAD;
                break;
            }
            state->offset = (unsigned)this.val;

            /* get distance extra bits, if any */
            state->extra = (unsigned)(this.op) & 15;
            if (state->extra != 0) {
                NEEDBITS(state->extra);
                state->offset += BITS(state->extra);
                DROPBITS(state->extra);
            }
            if (state->offset > state->wsize - (state->whave < state->wsize ?
                                                left : 0)) {
                strm->msg = (char *)"invalid distance too far back";
                state->mode = BAD;
                break;
            }
            Tracevv((stderr, "inflate:         distance %u\n", state->offset));

            /* copy match from window to output */
            do {
                ROOM();
                copy = state->wsize - state->offset;
                if (copy < left) {
                    from = put + copy;
                    copy = left - copy;
                }
                else {
                    from = put - state->offset;
                    copy = left;
                }
                if (copy > state->length) copy = state->length;
                state->length -= copy;
                left -= copy;
                do {
                    *put++ = *from++;
                } while (--copy);
            } while (state->length != 0);
            break;

        case DONE:
            /* inflate stream terminated properly -- write leftover output */
            ret = Z_STREAM_END;
            if (left < state->wsize) {
                if (out(out_desc, state->window, state->wsize - left))
                    ret = Z_BUF_ERROR;
            }
            goto inf_leave;

        case BAD:
            ret = Z_DATA_ERROR;
            goto inf_leave;

        default:                /* can't happen, but makes compilers happy */
            ret = Z_STREAM_ERROR;
            goto inf_leave;
        }

    /* Return unused input */
  inf_leave:
    strm->next_in = next;
    strm->avail_in = have;
    return ret;
}

int ZEXPORT inflateBackEnd(strm)
z_stream FAR *strm;
{
    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
        return Z_STREAM_ERROR;
    ZFREE(strm, strm->state);
    strm->state = Z_NULL;
    Tracev((stderr, "inflate: end\n"));
    return Z_OK;
}
Commit	Line	Data
	1	/* infback.c -- inflate using a call-back interface
	2	* Copyright (C) 1995-2003 Mark Adler
	3	* For conditions of distribution and use, see copyright notice in zlib.h
	4	*/
	5
	6	/*
	7	This code is largely copied from inflate.c. Normally either infback.o or
	8	inflate.o would be linked into an application--not both. The interface
	9	with inffast.c is retained so that optimized assembler-coded versions of
	10	inflate_fast() can be used with either inflate.c or infback.c.
	11	*/
	12
	13	#include "zutil.h"
	14	#include "inftrees.h"
	15	#include "inflate.h"
	16	#include "inffast.h"
	17
	18	/* function prototypes */
	19	local void fixedtables OF((struct inflate_state FAR *state));
	20
	21	/*
	22	strm provides memory allocation functions in zalloc and zfree, or
	23	Z_NULL to use the library memory allocation functions.
	24
	25	windowBits is in the range 8..15, and window is a user-supplied
	26	window and output buffer that is 2**windowBits bytes.
	27	*/
	28	int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
	29	z_stream FAR *strm;
	30	int windowBits;
	31	unsigned char FAR *window;
	32	const char *version;
	33	int stream_size;
	34	{
	35	struct inflate_state FAR *state;
	36
	37	if (version == Z_NULL \|\| version[0] != ZLIB_VERSION[0] \|\|
	38	stream_size != (int)(sizeof(z_stream)))
	39	return Z_VERSION_ERROR;
	40	if (strm == Z_NULL \|\| window == Z_NULL \|\|
	41	windowBits < 8 \|\| windowBits > 15)
	42	return Z_STREAM_ERROR;
	43	strm->msg = Z_NULL; /* in case we return an error */
	44	if (strm->zalloc == (alloc_func)0) {
	45	strm->zalloc = zcalloc;
	46	strm->opaque = (voidpf)0;
	47	}
	48	if (strm->zfree == (free_func)0) strm->zfree = zcfree;
	49	state = (struct inflate_state FAR *)ZALLOC(strm, 1,
	50	sizeof(struct inflate_state));
	51	if (state == Z_NULL) return Z_MEM_ERROR;
	52	Tracev((stderr, "inflate: allocated\n"));
	53	strm->state = (voidpf)state;
	54	state->wbits = windowBits;
	55	state->wsize = 1U << windowBits;
	56	state->window = window;
	57	state->write = 0;
	58	state->whave = 0;
	59	return Z_OK;
	60	}
	61
	62	/*
	63	Return state with length and distance decoding tables and index sizes set to
	64	fixed code decoding. Normally this returns fixed tables from inffixed.h.
	65	If BUILDFIXED is defined, then instead this routine builds the tables the
	66	first time it's called, and returns those tables the first time and
	67	thereafter. This reduces the size of the code by about 2K bytes, in
	68	exchange for a little execution time. However, BUILDFIXED should not be
	69	used for threaded applications, since the rewriting of the tables and virgin
	70	may not be thread-safe.
	71	*/
	72	local void fixedtables(state)
	73	struct inflate_state FAR *state;
	74	{
	75	#ifdef BUILDFIXED
	76	static int virgin = 1;
	77	static code lenfix, distfix;
	78	static code fixed[544];
	79
	80	/* build fixed huffman tables if first call (may not be thread safe) */
	81	if (virgin) {
	82	unsigned sym, bits;
	83	static code *next;
	84
	85	/* literal/length table */
	86	sym = 0;
	87	while (sym < 144) state->lens[sym++] = 8;
	88	while (sym < 256) state->lens[sym++] = 9;
	89	while (sym < 280) state->lens[sym++] = 7;
	90	while (sym < 288) state->lens[sym++] = 8;
	91	next = fixed;
	92	lenfix = next;
	93	bits = 9;
	94	inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
	95
	96	/* distance table */
	97	sym = 0;
	98	while (sym < 32) state->lens[sym++] = 5;
	99	distfix = next;
	100	bits = 5;
	101	inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
	102
	103	/* do this just once */
	104	virgin = 0;
	105	}
	106	#else /* !BUILDFIXED */
	107	# include "inffixed.h"
	108	#endif /* BUILDFIXED */
	109	state->lencode = lenfix;
	110	state->lenbits = 9;
	111	state->distcode = distfix;
	112	state->distbits = 5;
	113	}
	114
	115	/* Macros for inflateBack(): */
	116
	117	/* Load returned state from inflate_fast() */
	118	#define LOAD() \
	119	do { \
	120	put = strm->next_out; \
	121	left = strm->avail_out; \
	122	next = strm->next_in; \
	123	have = strm->avail_in; \
	124	hold = state->hold; \
	125	bits = state->bits; \
	126	} while (0)
	127
	128	/* Set state from registers for inflate_fast() */
	129	#define RESTORE() \
	130	do { \
	131	strm->next_out = put; \
	132	strm->avail_out = left; \
	133	strm->next_in = next; \
	134	strm->avail_in = have; \
	135	state->hold = hold; \
	136	state->bits = bits; \
	137	} while (0)
	138
	139	/* Clear the input bit accumulator */
	140	#define INITBITS() \
	141	do { \
	142	hold = 0; \
	143	bits = 0; \
	144	} while (0)
	145
	146	/* Assure that some input is available. If input is requested, but denied,
	147	then return a Z_BUF_ERROR from inflateBack(). */
	148	#define PULL() \
	149	do { \
	150	if (have == 0) { \
	151	have = in(in_desc, &next); \
	152	if (have == 0) { \
	153	next = Z_NULL; \
	154	ret = Z_BUF_ERROR; \
	155	goto inf_leave; \
	156	} \
	157	} \
	158	} while (0)
	159
	160	/* Get a byte of input into the bit accumulator, or return from inflateBack()
	161	with an error if there is no input available. */
	162	#define PULLBYTE() \
	163	do { \
	164	PULL(); \
	165	have--; \
	166	hold += (unsigned long)(*next++) << bits; \
	167	bits += 8; \
	168	} while (0)
	169
	170	/* Assure that there are at least n bits in the bit accumulator. If there is
	171	not enough available input to do that, then return from inflateBack() with
	172	an error. */
	173	#define NEEDBITS(n) \
	174	do { \
	175	while (bits < (unsigned)(n)) \
	176	PULLBYTE(); \
	177	} while (0)
	178
	179	/* Return the low n bits of the bit accumulator (n < 16) */
	180	#define BITS(n) \
	181	((unsigned)hold & ((1U << (n)) - 1))
	182
	183	/* Remove n bits from the bit accumulator */
	184	#define DROPBITS(n) \
	185	do { \
	186	hold >>= (n); \
	187	bits -= (unsigned)(n); \
	188	} while (0)
	189
	190	/* Remove zero to seven bits as needed to go to a byte boundary */
	191	#define BYTEBITS() \
	192	do { \
	193	hold >>= bits & 7; \
	194	bits -= bits & 7; \
	195	} while (0)
	196
	197	/* Assure that some output space is available, by writing out the window
	198	if it's full. If the write fails, return from inflateBack() with a
	199	Z_BUF_ERROR. */
	200	#define ROOM() \
	201	do { \
	202	if (left == 0) { \
	203	put = state->window; \
	204	left = state->wsize; \
	205	state->whave = left; \
	206	if (out(out_desc, put, left)) { \
	207	ret = Z_BUF_ERROR; \
	208	goto inf_leave; \
	209	} \
	210	} \
	211	} while (0)
	212
	213	/*
	214	strm provides the memory allocation functions and window buffer on input,
	215	and provides information on the unused input on return. For Z_DATA_ERROR
	216	returns, strm will also provide an error message.
	217
	218	in() and out() are the call-back input and output functions. When
	219	inflateBack() needs more input, it calls in(). When inflateBack() has
	220	filled the window with output, or when it completes with data in the
	221	window, it calls out() to write out the data. The application must not
	222	change the provided input until in() is called again or inflateBack()
	223	returns. The application must not change the window/output buffer until
	224	inflateBack() returns.
	225
	226	in() and out() are called with a descriptor parameter provided in the
	227	inflateBack() call. This parameter can be a structure that provides the
	228	information required to do the read or write, as well as accumulated
	229	information on the input and output such as totals and check values.
	230
	231	in() should return zero on failure. out() should return non-zero on
	232	failure. If either in() or out() fails, than inflateBack() returns a
	233	Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
	234	was in() or out() that caused in the error. Otherwise, inflateBack()
	235	returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
	236	error, or Z_MEM_ERROR if it could not allocate memory for the state.
	237	inflateBack() can also return Z_STREAM_ERROR if the input parameters
	238	are not correct, i.e. strm is Z_NULL or the state was not initialized.
	239	*/
	240	int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
	241	z_stream FAR *strm;
	242	in_func in;
	243	void FAR *in_desc;
	244	out_func out;
	245	void FAR *out_desc;
	246	{
	247	struct inflate_state FAR *state;
	248	unsigned char FAR next; / next input */
	249	unsigned char FAR put; / next output */
	250	unsigned have, left; /* available input and output */
	251	unsigned long hold; /* bit buffer */
	252	unsigned bits; /* bits in bit buffer */
	253	unsigned copy; /* number of stored or match bytes to copy */
	254	unsigned char FAR from; / where to copy match bytes from */
	255	code this; /* current decoding table entry */
	256	code last; /* parent table entry */
	257	unsigned len; /* length to copy for repeats, bits to drop */
	258	int ret; /* return code */
	259	static const unsigned short order[19] = /* permutation of code lengths */
	260	{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
	261
	262	/* Check that the strm exists and that the state was initialized */
	263	if (strm == Z_NULL \|\| strm->state == Z_NULL)
	264	return Z_STREAM_ERROR;
	265	state = (struct inflate_state FAR *)strm->state;
	266
	267	/* Reset the state */
	268	strm->msg = Z_NULL;
	269	state->mode = TYPE;
	270	state->last = 0;
	271	state->whave = 0;
	272	next = strm->next_in;
	273	have = next != Z_NULL ? strm->avail_in : 0;
	274	hold = 0;
	275	bits = 0;
	276	put = state->window;
	277	left = state->wsize;
	278
	279	/* Inflate until end of block marked as last */
	280	for (;;)
	281	switch (state->mode) {
	282	case TYPE:
	283	/* determine and dispatch block type */
	284	if (state->last) {
	285	BYTEBITS();
	286	state->mode = DONE;
	287	break;
	288	}
	289	NEEDBITS(3);
	290	state->last = BITS(1);
	291	DROPBITS(1);
	292	switch (BITS(2)) {
	293	case 0: /* stored block */
	294	Tracev((stderr, "inflate: stored block%s\n",
	295	state->last ? " (last)" : ""));
	296	state->mode = STORED;
	297	break;
	298	case 1: /* fixed block */
	299	fixedtables(state);
	300	Tracev((stderr, "inflate: fixed codes block%s\n",
	301	state->last ? " (last)" : ""));
	302	state->mode = LEN; /* decode codes */
	303	break;
	304	case 2: /* dynamic block */
	305	Tracev((stderr, "inflate: dynamic codes block%s\n",
	306	state->last ? " (last)" : ""));
	307	state->mode = TABLE;
	308	break;
	309	case 3:
	310	strm->msg = (char *)"invalid block type";
	311	state->mode = BAD;
	312	}
	313	DROPBITS(2);
	314	break;
	315
	316	case STORED:
	317	/* get and verify stored block length */
	318	BYTEBITS(); /* go to byte boundary */
	319	NEEDBITS(32);
	320	if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
	321	strm->msg = (char *)"invalid stored block lengths";
	322	state->mode = BAD;
	323	break;
	324	}
	325	state->length = (unsigned)hold & 0xffff;
	326	Tracev((stderr, "inflate: stored length %u\n",
	327	state->length));
	328	INITBITS();
	329
	330	/* copy stored block from input to output */
	331	while (state->length != 0) {
	332	copy = state->length;
	333	PULL();
	334	ROOM();
	335	if (copy > have) copy = have;
	336	if (copy > left) copy = left;
	337	zmemcpy(put, next, copy);
	338	have -= copy;
	339	next += copy;
	340	left -= copy;
	341	put += copy;
	342	state->length -= copy;
	343	}
	344	Tracev((stderr, "inflate: stored end\n"));
	345	state->mode = TYPE;
	346	break;
	347
	348	case TABLE:
	349	/* get dynamic table entries descriptor */
	350	NEEDBITS(14);
	351	state->nlen = BITS(5) + 257;
	352	DROPBITS(5);
	353	state->ndist = BITS(5) + 1;
	354	DROPBITS(5);
	355	state->ncode = BITS(4) + 4;
	356	DROPBITS(4);
	357	#ifndef PKZIP_BUG_WORKAROUND
	358	if (state->nlen > 286 \|\| state->ndist > 30) {
	359	strm->msg = (char *)"too many length or distance symbols";
	360	state->mode = BAD;
	361	break;
	362	}
	363	#endif
	364	Tracev((stderr, "inflate: table sizes ok\n"));
	365
	366	/* get code length code lengths (not a typo) */
	367	state->have = 0;
	368	while (state->have < state->ncode) {
	369	NEEDBITS(3);
	370	state->lens[order[state->have++]] = (unsigned short)BITS(3);
	371	DROPBITS(3);
	372	}
	373	while (state->have < 19)
	374	state->lens[order[state->have++]] = 0;
	375	state->next = state->codes;
	376	state->lencode = (code const FAR *)(state->next);
	377	state->lenbits = 7;
	378	ret = inflate_table(CODES, state->lens, 19, &(state->next),
	379	&(state->lenbits), state->work);
	380	if (ret) {
	381	strm->msg = (char *)"invalid code lengths set";
	382	state->mode = BAD;
	383	break;
	384	}
	385	Tracev((stderr, "inflate: code lengths ok\n"));
	386
	387	/* get length and distance code code lengths */
	388	state->have = 0;
	389	while (state->have < state->nlen + state->ndist) {
	390	for (;;) {
	391	this = state->lencode[BITS(state->lenbits)];
	392	if ((unsigned)(this.bits) <= bits) break;
	393	PULLBYTE();
	394	}
	395	if (this.val < 16) {
	396	NEEDBITS(this.bits);
	397	DROPBITS(this.bits);
	398	state->lens[state->have++] = this.val;
	399	}
	400	else {
	401	if (this.val == 16) {
	402	NEEDBITS(this.bits + 2);
	403	DROPBITS(this.bits);
	404	if (state->have == 0) {
	405	strm->msg = (char *)"invalid bit length repeat";
	406	state->mode = BAD;
	407	break;
	408	}
	409	len = (unsigned)(state->lens[state->have - 1]);
	410	copy = 3 + BITS(2);
	411	DROPBITS(2);
	412	}
	413	else if (this.val == 17) {
	414	NEEDBITS(this.bits + 3);
	415	DROPBITS(this.bits);
	416	len = 0;
	417	copy = 3 + BITS(3);
	418	DROPBITS(3);
	419	}
	420	else {
	421	NEEDBITS(this.bits + 7);
	422	DROPBITS(this.bits);
	423	len = 0;
	424	copy = 11 + BITS(7);
	425	DROPBITS(7);
	426	}
	427	if (state->have + copy > state->nlen + state->ndist) {
	428	strm->msg = (char *)"invalid bit length repeat";
	429	state->mode = BAD;
	430	break;
	431	}
	432	while (copy--)
	433	state->lens[state->have++] = (unsigned short)len;
	434	}
	435	}
	436
	437	if (state->mode == BAD)
	438	break;
	439
	440	/* build code tables */
	441	state->next = state->codes;
	442	state->lencode = (code const FAR *)(state->next);
	443	state->lenbits = 9;
	444	ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
	445	&(state->lenbits), state->work);
	446	if (ret) {
	447	strm->msg = (char *)"invalid literal/lengths set";
	448	state->mode = BAD;
	449	break;
	450	}
	451	state->distcode = (code const FAR *)(state->next);
	452	state->distbits = 6;
	453	ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
	454	&(state->next), &(state->distbits), state->work);
	455	if (ret) {
	456	strm->msg = (char *)"invalid distances set";
	457	state->mode = BAD;
	458	break;
	459	}
	460	Tracev((stderr, "inflate: codes ok\n"));
	461	state->mode = LEN;
	462
	463	case LEN:
	464	/* use inflate_fast() if we have enough input and output */
	465	if (have >= 6 && left >= 258) {
	466	RESTORE();
	467	if (state->whave < state->wsize)
	468	state->whave = state->wsize - left;
	469	inflate_fast(strm, state->wsize);
	470	LOAD();
	471	break;
	472	}
	473
	474	/* get a literal, length, or end-of-block code */
	475	for (;;) {
	476	this = state->lencode[BITS(state->lenbits)];
	477	if ((unsigned)(this.bits) <= bits) break;
	478	PULLBYTE();
	479	}
	480	if (this.op && (this.op & 0xf0) == 0) {
	481	last = this;
	482	for (;;) {
	483	this = state->lencode[last.val +
	484	(BITS(last.bits + last.op) >> last.bits)];
	485	if ((unsigned)(last.bits + this.bits) <= bits) break;
	486	PULLBYTE();
	487	}
	488	DROPBITS(last.bits);
	489	}
	490	DROPBITS(this.bits);
	491	state->length = (unsigned)this.val;
	492
	493	/* process literal */
	494	if (this.op == 0) {
	495	Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
	496	"inflate: literal '%c'\n" :
	497	"inflate: literal 0x%02x\n", this.val));
	498	ROOM();
	499	*put++ = (unsigned char)(state->length);
	500	left--;
	501	state->mode = LEN;
	502	break;
	503	}
	504
	505	/* process end of block */
	506	if (this.op & 32) {
	507	Tracevv((stderr, "inflate: end of block\n"));
	508	state->mode = TYPE;
	509	break;
	510	}
	511
	512	/* invalid code */
	513	if (this.op & 64) {
	514	strm->msg = (char *)"invalid literal/length code";
	515	state->mode = BAD;
	516	break;
	517	}
	518
	519	/* length code -- get extra bits, if any */
	520	state->extra = (unsigned)(this.op) & 15;
	521	if (state->extra != 0) {
	522	NEEDBITS(state->extra);
	523	state->length += BITS(state->extra);
	524	DROPBITS(state->extra);
	525	}
	526	Tracevv((stderr, "inflate: length %u\n", state->length));
	527
	528	/* get distance code */
	529	for (;;) {
	530	this = state->distcode[BITS(state->distbits)];
	531	if ((unsigned)(this.bits) <= bits) break;
	532	PULLBYTE();
	533	}
	534	if ((this.op & 0xf0) == 0) {
	535	last = this;
	536	for (;;) {
	537	this = state->distcode[last.val +
	538	(BITS(last.bits + last.op) >> last.bits)];
	539	if ((unsigned)(last.bits + this.bits) <= bits) break;
	540	PULLBYTE();
	541	}
	542	DROPBITS(last.bits);
	543	}
	544	DROPBITS(this.bits);
	545	if (this.op & 64) {
	546	strm->msg = (char *)"invalid distance code";
	547	state->mode = BAD;
	548	break;
	549	}
	550	state->offset = (unsigned)this.val;
	551
	552	/* get distance extra bits, if any */
	553	state->extra = (unsigned)(this.op) & 15;
	554	if (state->extra != 0) {
	555	NEEDBITS(state->extra);
	556	state->offset += BITS(state->extra);
	557	DROPBITS(state->extra);
	558	}
	559	if (state->offset > state->wsize - (state->whave < state->wsize ?
	560	left : 0)) {
	561	strm->msg = (char *)"invalid distance too far back";
	562	state->mode = BAD;
	563	break;
	564	}
	565	Tracevv((stderr, "inflate: distance %u\n", state->offset));
	566
	567	/* copy match from window to output */
	568	do {
	569	ROOM();
	570	copy = state->wsize - state->offset;
	571	if (copy < left) {
	572	from = put + copy;
	573	copy = left - copy;
	574	}
	575	else {
	576	from = put - state->offset;
	577	copy = left;
	578	}
	579	if (copy > state->length) copy = state->length;
	580	state->length -= copy;
	581	left -= copy;
	582	do {
	583	put++ = from++;
	584	} while (--copy);
	585	} while (state->length != 0);
	586	break;
	587
	588	case DONE:
	589	/* inflate stream terminated properly -- write leftover output */
	590	ret = Z_STREAM_END;
	591	if (left < state->wsize) {
	592	if (out(out_desc, state->window, state->wsize - left))
	593	ret = Z_BUF_ERROR;
	594	}
	595	goto inf_leave;
	596
	597	case BAD:
	598	ret = Z_DATA_ERROR;
	599	goto inf_leave;
	600
	601	default: /* can't happen, but makes compilers happy */
	602	ret = Z_STREAM_ERROR;
	603	goto inf_leave;
	604	}
	605
	606	/* Return unused input */
	607	inf_leave:
	608	strm->next_in = next;
	609	strm->avail_in = have;
	610	return ret;
	611	}
	612
	613	int ZEXPORT inflateBackEnd(strm)
	614	z_stream FAR *strm;
	615	{
	616	if (strm == Z_NULL \|\| strm->state == Z_NULL \|\| strm->zfree == (free_func)0)
	617	return Z_STREAM_ERROR;
	618	ZFREE(strm, strm->state);
	619	strm->state = Z_NULL;
	620	Tracev((stderr, "inflate: end\n"));
	621	return Z_OK;
	622	}