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;
                }
            }

            /* 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	/* build code tables */
	438	state->next = state->codes;
	439	state->lencode = (code const FAR *)(state->next);
	440	state->lenbits = 9;
	441	ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
	442	&(state->lenbits), state->work);
	443	if (ret) {
	444	strm->msg = (char *)"invalid literal/lengths set";
	445	state->mode = BAD;
	446	break;
	447	}
	448	state->distcode = (code const FAR *)(state->next);
	449	state->distbits = 6;
	450	ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
	451	&(state->next), &(state->distbits), state->work);
	452	if (ret) {
	453	strm->msg = (char *)"invalid distances set";
	454	state->mode = BAD;
	455	break;
	456	}
	457	Tracev((stderr, "inflate: codes ok\n"));
	458	state->mode = LEN;
	459
	460	case LEN:
	461	/* use inflate_fast() if we have enough input and output */
	462	if (have >= 6 && left >= 258) {
	463	RESTORE();
	464	if (state->whave < state->wsize)
	465	state->whave = state->wsize - left;
	466	inflate_fast(strm, state->wsize);
	467	LOAD();
	468	break;
	469	}
	470
	471	/* get a literal, length, or end-of-block code */
	472	for (;;) {
	473	this = state->lencode[BITS(state->lenbits)];
	474	if ((unsigned)(this.bits) <= bits) break;
	475	PULLBYTE();
	476	}
	477	if (this.op && (this.op & 0xf0) == 0) {
	478	last = this;
	479	for (;;) {
	480	this = state->lencode[last.val +
	481	(BITS(last.bits + last.op) >> last.bits)];
	482	if ((unsigned)(last.bits + this.bits) <= bits) break;
	483	PULLBYTE();
	484	}
	485	DROPBITS(last.bits);
	486	}
	487	DROPBITS(this.bits);
	488	state->length = (unsigned)this.val;
	489
	490	/* process literal */
	491	if (this.op == 0) {
	492	Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
	493	"inflate: literal '%c'\n" :
	494	"inflate: literal 0x%02x\n", this.val));
	495	ROOM();
	496	*put++ = (unsigned char)(state->length);
	497	left--;
	498	state->mode = LEN;
	499	break;
	500	}
	501
	502	/* process end of block */
	503	if (this.op & 32) {
	504	Tracevv((stderr, "inflate: end of block\n"));
	505	state->mode = TYPE;
	506	break;
	507	}
	508
	509	/* invalid code */
	510	if (this.op & 64) {
	511	strm->msg = (char *)"invalid literal/length code";
	512	state->mode = BAD;
	513	break;
	514	}
	515
	516	/* length code -- get extra bits, if any */
	517	state->extra = (unsigned)(this.op) & 15;
	518	if (state->extra != 0) {
	519	NEEDBITS(state->extra);
	520	state->length += BITS(state->extra);
	521	DROPBITS(state->extra);
	522	}
	523	Tracevv((stderr, "inflate: length %u\n", state->length));
	524
	525	/* get distance code */
	526	for (;;) {
	527	this = state->distcode[BITS(state->distbits)];
	528	if ((unsigned)(this.bits) <= bits) break;
	529	PULLBYTE();
	530	}
	531	if ((this.op & 0xf0) == 0) {
	532	last = this;
	533	for (;;) {
	534	this = state->distcode[last.val +
	535	(BITS(last.bits + last.op) >> last.bits)];
	536	if ((unsigned)(last.bits + this.bits) <= bits) break;
	537	PULLBYTE();
	538	}
	539	DROPBITS(last.bits);
	540	}
	541	DROPBITS(this.bits);
	542	if (this.op & 64) {
	543	strm->msg = (char *)"invalid distance code";
	544	state->mode = BAD;
	545	break;
	546	}
	547	state->offset = (unsigned)this.val;
	548
	549	/* get distance extra bits, if any */
	550	state->extra = (unsigned)(this.op) & 15;
	551	if (state->extra != 0) {
	552	NEEDBITS(state->extra);
	553	state->offset += BITS(state->extra);
	554	DROPBITS(state->extra);
	555	}
	556	if (state->offset > state->wsize - (state->whave < state->wsize ?
	557	left : 0)) {
	558	strm->msg = (char *)"invalid distance too far back";
	559	state->mode = BAD;
	560	break;
	561	}
	562	Tracevv((stderr, "inflate: distance %u\n", state->offset));
	563
	564	/* copy match from window to output */
	565	do {
	566	ROOM();
	567	copy = state->wsize - state->offset;
	568	if (copy < left) {
	569	from = put + copy;
	570	copy = left - copy;
	571	}
	572	else {
	573	from = put - state->offset;
	574	copy = left;
	575	}
	576	if (copy > state->length) copy = state->length;
	577	state->length -= copy;
	578	left -= copy;
	579	do {
	580	put++ = from++;
	581	} while (--copy);
	582	} while (state->length != 0);
	583	break;
	584
	585	case DONE:
	586	/* inflate stream terminated properly -- write leftover output */
	587	ret = Z_STREAM_END;
	588	if (left < state->wsize) {
	589	if (out(out_desc, state->window, state->wsize - left))
	590	ret = Z_BUF_ERROR;
	591	}
	592	goto inf_leave;
	593
	594	case BAD:
	595	ret = Z_DATA_ERROR;
	596	goto inf_leave;
	597
	598	default: /* can't happen, but makes compilers happy */
	599	ret = Z_STREAM_ERROR;
	600	goto inf_leave;
	601	}
	602
	603	/* Return unused input */
	604	inf_leave:
	605	strm->next_in = next;
	606	strm->avail_in = have;
	607	return ret;
	608	}
	609
	610	int ZEXPORT inflateBackEnd(strm)
	611	z_stream FAR *strm;
	612	{
	613	if (strm == Z_NULL \|\| strm->state == Z_NULL \|\| strm->zfree == (free_func)0)
	614	return Z_STREAM_ERROR;
	615	ZFREE(strm, strm->state);
	616	strm->state = Z_NULL;
	617	Tracev((stderr, "inflate: end\n"));
	618	return Z_OK;
	619	}