[pcsx_rearmed.git] / deps / infback.c

/* infback.c -- inflate using a call-back interface
 * Copyright (C) 1995-2011 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_(z_streamp 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) {
#ifdef Z_SOLO
      return Z_STREAM_ERROR;
#else
      strm->zalloc = zcalloc;
      strm->opaque = (voidpf)0;
#endif
   }
   if (strm->zfree == Z_NULL)
#ifdef Z_SOLO
      return Z_STREAM_ERROR;
#else
   strm->zfree = zcfree;
#endif
   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 = (struct internal_state FAR *)state;
   state->dmax = 32768U;
   state->wbits = windowBits;
   state->wsize = 1U << windowBits;
   state->window = window;
   state->wnext = 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(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(z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)
{
   struct inflate_state FAR *state;
   z_const 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 here;                  /* 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 (;;) {
                  here = state->lencode[BITS(state->lenbits)];
                  if ((unsigned)(here.bits) <= bits) break;
                  PULLBYTE();
               }
               if (here.val < 16) {
                  DROPBITS(here.bits);
                  state->lens[state->have++] = here.val;
               }
               else {
                  if (here.val == 16) {
                     NEEDBITS(here.bits + 2);
                     DROPBITS(here.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 (here.val == 17) {
                     NEEDBITS(here.bits + 3);
                     DROPBITS(here.bits);
                     len = 0;
                     copy = 3 + BITS(3);
                     DROPBITS(3);
                  }
                  else {
                     NEEDBITS(here.bits + 7);
                     DROPBITS(here.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;
               }
            }

            /* handle error breaks in while */
            if (state->mode == BAD) break;

            /* check for end-of-block code (better have one) */
            if (state->lens[256] == 0) {
               strm->msg = (char *)"invalid code -- missing end-of-block";
               state->mode = BAD;
               break;
            }

            /* build code tables -- note: do not change the lenbits or distbits
               values here (9 and 6) without reading the comments in inftrees.h
               concerning the ENOUGH constants, which depend on those values */
            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 (;;) {
               here = state->lencode[BITS(state->lenbits)];
               if ((unsigned)(here.bits) <= bits) break;
               PULLBYTE();
            }
            if (here.op && (here.op & 0xf0) == 0) {
               last = here;
               for (;;) {
                  here = state->lencode[last.val +
                     (BITS(last.bits + last.op) >> last.bits)];
                  if ((unsigned)(last.bits + here.bits) <= bits) break;
                  PULLBYTE();
               }
               DROPBITS(last.bits);
            }
            DROPBITS(here.bits);
            state->length = (unsigned)here.val;

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

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

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

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

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