contrib/zlib-1.2/inflate.c

   1 /* inflate.c -- zlib decompression
   2  * Copyright (C) 1995-2012 Mark Adler
   3  * For conditions of distribution and use, see copyright notice in zlib.h
   4  */
   5
   6 /*
   7  * Change history:
   8  *
   9  * 1.2.beta0    24 Nov 2002
  10  * - First version -- complete rewrite of inflate to simplify code, avoid
  11  *   creation of window when not needed, minimize use of window when it is
  12  *   needed, make inffast.c even faster, implement gzip decoding, and to
  13  *   improve code readability and style over the previous zlib inflate code
  14  *
  15  * 1.2.beta1    25 Nov 2002
  16  * - Use pointers for available input and output checking in inffast.c
  17  * - Remove input and output counters in inffast.c
  18  * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
  19  * - Remove unnecessary second byte pull from length extra in inffast.c
  20  * - Unroll direct copy to three copies per loop in inffast.c
  21  *
  22  * 1.2.beta2    4 Dec 2002
  23  * - Change external routine names to reduce potential conflicts
  24  * - Correct filename to inffixed.h for fixed tables in inflate.c
  25  * - Make hbuf[] unsigned char to match parameter type in inflate.c
  26  * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
  27  *   to avoid negation problem on Alphas (64 bit) in inflate.c
  28  *
  29  * 1.2.beta3    22 Dec 2002
  30  * - Add comments on state->bits assertion in inffast.c
  31  * - Add comments on op field in inftrees.h
  32  * - Fix bug in reuse of allocated window after inflateReset()
  33  * - Remove bit fields--back to byte structure for speed
  34  * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
  35  * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
  36  * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
  37  * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
  38  * - Use local copies of stream next and avail values, as well as local bit
  39  *   buffer and bit count in inflate()--for speed when inflate_fast() not used
  40  *
  41  * 1.2.beta4    1 Jan 2003
  42  * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
  43  * - Move a comment on output buffer sizes from inffast.c to inflate.c
  44  * - Add comments in inffast.c to introduce the inflate_fast() routine
  45  * - Rearrange window copies in inflate_fast() for speed and simplification
  46  * - Unroll last copy for window match in inflate_fast()
  47  * - Use local copies of window variables in inflate_fast() for speed
  48  * - Pull out common wnext == 0 case for speed in inflate_fast()
  49  * - Make op and len in inflate_fast() unsigned for consistency
  50  * - Add FAR to lcode and dcode declarations in inflate_fast()
  51  * - Simplified bad distance check in inflate_fast()
  52  * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
  53  *   source file infback.c to provide a call-back interface to inflate for
  54  *   programs like gzip and unzip -- uses window as output buffer to avoid
  55  *   window copying
  56  *
  57  * 1.2.beta5    1 Jan 2003
  58  * - Improved inflateBack() interface to allow the caller to provide initial
  59  *   input in strm.
  60  * - Fixed stored blocks bug in inflateBack()
  61  *
  62  * 1.2.beta6    4 Jan 2003
  63  * - Added comments in inffast.c on effectiveness of POSTINC
  64  * - Typecasting all around to reduce compiler warnings
  65  * - Changed loops from while (1) or do {} while (1) to for (;;), again to
  66  *   make compilers happy
  67  * - Changed type of window in inflateBackInit() to unsigned char *
  68  *
  69  * 1.2.beta7    27 Jan 2003
  70  * - Changed many types to unsigned or unsigned short to avoid warnings
  71  * - Added inflateCopy() function
  72  *
  73  * 1.2.0        9 Mar 2003
  74  * - Changed inflateBack() interface to provide separate opaque descriptors
  75  *   for the in() and out() functions
  76  * - Changed inflateBack() argument and in_func typedef to swap the length
  77  *   and buffer address return values for the input function
  78  * - Check next_in and next_out for Z_NULL on entry to inflate()
  79  *
  80  * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
  81  */
  82
  83 #include "zutil.h"
  84 #include "inftrees.h"
  85 #include "inflate.h"
  86 #include "inffast.h"
  87
  88 #ifdef MAKEFIXED
  89 #  ifndef BUILDFIXED
  90 #    define BUILDFIXED
  91 #  endif
  92 #endif
  93
  94 /* function prototypes */
  95 local void fixedtables OF((struct inflate_state FAR *state));
  96 local int updatewindow OF((z_streamp strm, unsigned out));
  97 #ifdef BUILDFIXED
  98    void makefixed OF((void));
  99 #endif
 100 local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
 101                               unsigned len));
 102
 103 int ZEXPORT inflateResetKeep(strm)
 104 z_streamp strm;
 105 {
 106     struct inflate_state FAR *state;
 107
 108     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
 109     state = (struct inflate_state FAR *)strm->state;
 110     strm->total_in = strm->total_out = state->total = 0;
 111     strm->msg = Z_NULL;
 112     if (state->wrap)        /* to support ill-conceived Java test suite */
 113         strm->adler = state->wrap & 1;
 114     state->mode = HEAD;
 115     state->last = 0;
 116     state->havedict = 0;
 117     state->dmax = 32768U;
 118     state->head = Z_NULL;
 119     state->hold = 0;
 120     state->bits = 0;
 121     state->lencode = state->distcode = state->next = state->codes;
 122     state->sane = 1;
 123     state->back = -1;
 124     Tracev((stderr, "inflate: reset\n"));
 125     return Z_OK;
 126 }
 127
 128 int ZEXPORT inflateReset(strm)
 129 z_streamp strm;
 130 {
 131     struct inflate_state FAR *state;
 132
 133     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
 134     state = (struct inflate_state FAR *)strm->state;
 135     state->wsize = 0;
 136     state->whave = 0;
 137     state->wnext = 0;
 138     return inflateResetKeep(strm);
 139 }
 140
 141 int ZEXPORT inflateReset2(strm, windowBits)
 142 z_streamp strm;
 143 int windowBits;
 144 {
 145     int wrap;
 146     struct inflate_state FAR *state;
 147
 148     /* get the state */
 149     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
 150     state = (struct inflate_state FAR *)strm->state;
 151
 152     /* extract wrap request from windowBits parameter */
 153     if (windowBits < 0) {
 154         wrap = 0;
 155         windowBits = -windowBits;
 156     }
 157     else {
 158         wrap = (windowBits >> 4) + 1;
 159 #ifdef GUNZIP
 160         if (windowBits < 48)
 161             windowBits &= 15;
 162 #endif
 163     }
 164
 165     /* set number of window bits, free window if different */
 166     if (windowBits && (windowBits < 8 || windowBits > 15))
 167         return Z_STREAM_ERROR;
 168     if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
 169         ZFREE(strm, state->window);
 170         state->window = Z_NULL;
 171     }
 172
 173     /* update state and reset the rest of it */
 174     state->wrap = wrap;
 175     state->wbits = (unsigned)windowBits;
 176     return inflateReset(strm);
 177 }
 178
 179 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
 180 z_streamp strm;
 181 int windowBits;
 182 const char *version;
 183 int stream_size;
 184 {
 185     int ret;
 186     struct inflate_state FAR *state;
 187
 188     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
 189         stream_size != (int)(sizeof(z_stream)))
 190         return Z_VERSION_ERROR;
 191     if (strm == Z_NULL) return Z_STREAM_ERROR;
 192     strm->msg = Z_NULL;                 /* in case we return an error */
 193     if (strm->zalloc == (alloc_func)0) {
 194 #ifdef Z_SOLO
 195         return Z_STREAM_ERROR;
 196 #else
 197         strm->zalloc = zcalloc;
 198         strm->opaque = (voidpf)0;
 199 #endif
 200     }
 201     if (strm->zfree == (free_func)0)
 202 #ifdef Z_SOLO
 203         return Z_STREAM_ERROR;
 204 #else
 205         strm->zfree = zcfree;
 206 #endif
 207     state = (struct inflate_state FAR *)
 208             ZALLOC(strm, 1, sizeof(struct inflate_state));
 209     if (state == Z_NULL) return Z_MEM_ERROR;
 210     Tracev((stderr, "inflate: allocated\n"));
 211     strm->state = (struct internal_state FAR *)state;
 212     state->window = Z_NULL;
 213     ret = inflateReset2(strm, windowBits);
 214     if (ret != Z_OK) {
 215         ZFREE(strm, state);
 216         strm->state = Z_NULL;
 217     }
 218     return ret;
 219 }
 220
 221 int ZEXPORT inflateInit_(strm, version, stream_size)
 222 z_streamp strm;
 223 const char *version;
 224 int stream_size;
 225 {
 226     return inflateInit2_(strm, DEF_WBITS, version, stream_size);
 227 }
 228
 229 int ZEXPORT inflatePrime(strm, bits, value)
 230 z_streamp strm;
 231 int bits;
 232 int value;
 233 {
 234     struct inflate_state FAR *state;
 235
 236     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
 237     state = (struct inflate_state FAR *)strm->state;
 238     if (bits < 0) {
 239         state->hold = 0;
 240         state->bits = 0;
 241         return Z_OK;
 242     }
 243     if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
 244     value &= (1L << bits) - 1;
 245     state->hold += value << state->bits;
 246     state->bits += bits;
 247     return Z_OK;
 248 }
 249
 250 /*
 251    Return state with length and distance decoding tables and index sizes set to
 252    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
 253    If BUILDFIXED is defined, then instead this routine builds the tables the
 254    first time it's called, and returns those tables the first time and
 255    thereafter.  This reduces the size of the code by about 2K bytes, in
 256    exchange for a little execution time.  However, BUILDFIXED should not be
 257    used for threaded applications, since the rewriting of the tables and virgin
 258    may not be thread-safe.
 259  */
 260 local void fixedtables(state)
 261 struct inflate_state FAR *state;
 262 {
 263 #ifdef BUILDFIXED
 264     static int virgin = 1;
 265     static code *lenfix, *distfix;
 266     static code fixed[544];
 267
 268     /* build fixed huffman tables if first call (may not be thread safe) */
 269     if (virgin) {
 270         unsigned sym, bits;
 271         static code *next;
 272
 273         /* literal/length table */
 274         sym = 0;
 275         while (sym < 144) state->lens[sym++] = 8;
 276         while (sym < 256) state->lens[sym++] = 9;
 277         while (sym < 280) state->lens[sym++] = 7;
 278         while (sym < 288) state->lens[sym++] = 8;
 279         next = fixed;
 280         lenfix = next;
 281         bits = 9;
 282         inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
 283
 284         /* distance table */
 285         sym = 0;
 286         while (sym < 32) state->lens[sym++] = 5;
 287         distfix = next;
 288         bits = 5;
 289         inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
 290
 291         /* do this just once */
 292         virgin = 0;
 293     }
 294 #else /* !BUILDFIXED */
 295 #   include "inffixed.h"
 296 #endif /* BUILDFIXED */
 297     state->lencode = lenfix;
 298     state->lenbits = 9;
 299     state->distcode = distfix;
 300     state->distbits = 5;
 301 }
 302
 303 #ifdef MAKEFIXED
 304 #include <stdio.h>
 305
 306 /*
 307    Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
 308    defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
 309    those tables to stdout, which would be piped to inffixed.h.  A small program
 310    can simply call makefixed to do this:
 311
 312     void makefixed(void);
 313
 314     int main(void)
 315     {
 316         makefixed();
 317         return 0;
 318     }
 319
 320    Then that can be linked with zlib built with MAKEFIXED defined and run:
 321
 322     a.out > inffixed.h
 323  */
 324 void makefixed()
 325 {
 326     unsigned low, size;
 327     struct inflate_state state;
 328
 329     fixedtables(&state);
 330     puts("    /* inffixed.h -- table for decoding fixed codes");
 331     puts("     * Generated automatically by makefixed().");
 332     puts("     */");
 333     puts("");
 334     puts("    /* WARNING: this file should *not* be used by applications.");
 335     puts("       It is part of the implementation of this library and is");
 336     puts("       subject to change. Applications should only use zlib.h.");
 337     puts("     */");
 338     puts("");
 339     size = 1U << 9;
 340     printf("    static const code lenfix[%u] = {", size);
 341     low = 0;
 342     for (;;) {
 343         if ((low % 7) == 0) printf("\n        ");
 344         printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
 345                state.lencode[low].bits, state.lencode[low].val);
 346         if (++low == size) break;
 347         putchar(',');
 348     }
 349     puts("\n    };");
 350     size = 1U << 5;
 351     printf("\n    static const code distfix[%u] = {", size);
 352     low = 0;
 353     for (;;) {
 354         if ((low % 6) == 0) printf("\n        ");
 355         printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
 356                state.distcode[low].val);
 357         if (++low == size) break;
 358         putchar(',');
 359     }
 360     puts("\n    };");
 361 }
 362 #endif /* MAKEFIXED */
 363
 364 /*
 365    Update the window with the last wsize (normally 32K) bytes written before
 366    returning.  If window does not exist yet, create it.  This is only called
 367    when a window is already in use, or when output has been written during this
 368    inflate call, but the end of the deflate stream has not been reached yet.
 369    It is also called to create a window for dictionary data when a dictionary
 370    is loaded.
 371
 372    Providing output buffers larger than 32K to inflate() should provide a speed
 373    advantage, since only the last 32K of output is copied to the sliding window
 374    upon return from inflate(), and since all distances after the first 32K of
 375    output will fall in the output data, making match copies simpler and faster.
 376    The advantage may be dependent on the size of the processor's data caches.
 377  */
 378 local int updatewindow(strm, out)
 379 z_streamp strm;
 380 unsigned out;
 381 {
 382     struct inflate_state FAR *state;
 383     unsigned copy, dist;
 384
 385     state = (struct inflate_state FAR *)strm->state;
 386
 387     /* if it hasn't been done already, allocate space for the window */
 388     if (state->window == Z_NULL) {
 389         state->window = (unsigned char FAR *)
 390                         ZALLOC(strm, 1U << state->wbits,
 391                                sizeof(unsigned char));
 392         if (state->window == Z_NULL) return 1;
 393     }
 394
 395     /* if window not in use yet, initialize */
 396     if (state->wsize == 0) {
 397         state->wsize = 1U << state->wbits;
 398         state->wnext = 0;
 399         state->whave = 0;
 400     }
 401
 402     /* copy state->wsize or less output bytes into the circular window */
 403     copy = out - strm->avail_out;
 404     if (copy >= state->wsize) {
 405         zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
 406         state->wnext = 0;
 407         state->whave = state->wsize;
 408     }
 409     else {
 410         dist = state->wsize - state->wnext;
 411         if (dist > copy) dist = copy;
 412         zmemcpy(state->window + state->wnext, strm->next_out - copy, dist);
 413         copy -= dist;
 414         if (copy) {
 415             zmemcpy(state->window, strm->next_out - copy, copy);
 416             state->wnext = copy;
 417             state->whave = state->wsize;
 418         }
 419         else {
 420             state->wnext += dist;
 421             if (state->wnext == state->wsize) state->wnext = 0;
 422             if (state->whave < state->wsize) state->whave += dist;
 423         }
 424     }
 425     return 0;
 426 }
 427
 428 /* Macros for inflate(): */
 429
 430 /* check function to use adler32() for zlib or crc32() for gzip */
 431 #ifdef GUNZIP
 432 #  define UPDATE(check, buf, len) \
 433     (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
 434 #else
 435 #  define UPDATE(check, buf, len) adler32(check, buf, len)
 436 #endif
 437
 438 /* check macros for header crc */
 439 #ifdef GUNZIP
 440 #  define CRC2(check, word) \
 441     do { \
 442         hbuf[0] = (unsigned char)(word); \
 443         hbuf[1] = (unsigned char)((word) >> 8); \
 444         check = crc32(check, hbuf, 2); \
 445     } while (0)
 446
 447 #  define CRC4(check, word) \
 448     do { \
 449         hbuf[0] = (unsigned char)(word); \
 450         hbuf[1] = (unsigned char)((word) >> 8); \
 451         hbuf[2] = (unsigned char)((word) >> 16); \
 452         hbuf[3] = (unsigned char)((word) >> 24); \
 453         check = crc32(check, hbuf, 4); \
 454     } while (0)
 455 #endif
 456
 457 /* Load registers with state in inflate() for speed */
 458 #define LOAD() \
 459     do { \
 460         put = strm->next_out; \
 461         left = strm->avail_out; \
 462         next = strm->next_in; \
 463         have = strm->avail_in; \
 464         hold = state->hold; \
 465         bits = state->bits; \
 466     } while (0)
 467
 468 /* Restore state from registers in inflate() */
 469 #define RESTORE() \
 470     do { \
 471         strm->next_out = put; \
 472         strm->avail_out = left; \
 473         strm->next_in = next; \
 474         strm->avail_in = have; \
 475         state->hold = hold; \
 476         state->bits = bits; \
 477     } while (0)
 478
 479 /* Clear the input bit accumulator */
 480 #define INITBITS() \
 481     do { \
 482         hold = 0; \
 483         bits = 0; \
 484     } while (0)
 485
 486 /* Get a byte of input into the bit accumulator, or return from inflate()
 487    if there is no input available. */
 488 #define PULLBYTE() \
 489     do { \
 490         if (have == 0) goto inf_leave; \
 491         have--; \
 492         hold += (unsigned long)(*next++) << bits; \
 493         bits += 8; \
 494     } while (0)
 495
 496 /* Assure that there are at least n bits in the bit accumulator.  If there is
 497    not enough available input to do that, then return from inflate(). */
 498 #define NEEDBITS(n) \
 499     do { \
 500         while (bits < (unsigned)(n)) \
 501             PULLBYTE(); \
 502     } while (0)
 503
 504 /* Return the low n bits of the bit accumulator (n < 16) */
 505 #define BITS(n) \
 506     ((unsigned)hold & ((1U << (n)) - 1))
 507
 508 /* Remove n bits from the bit accumulator */
 509 #define DROPBITS(n) \
 510     do { \
 511         hold >>= (n); \
 512         bits -= (unsigned)(n); \
 513     } while (0)
 514
 515 /* Remove zero to seven bits as needed to go to a byte boundary */
 516 #define BYTEBITS() \
 517     do { \
 518         hold >>= bits & 7; \
 519         bits -= bits & 7; \
 520     } while (0)
 521
 522 /*
 523    inflate() uses a state machine to process as much input data and generate as
 524    much output data as possible before returning.  The state machine is
 525    structured roughly as follows:
 526
 527     for (;;) switch (state) {
 528     ...
 529     case STATEn:
 530         if (not enough input data or output space to make progress)
 531             return;
 532         ... make progress ...
 533         state = STATEm;
 534         break;
 535     ...
 536     }
 537
 538    so when inflate() is called again, the same case is attempted again, and
 539    if the appropriate resources are provided, the machine proceeds to the
 540    next state.  The NEEDBITS() macro is usually the way the state evaluates
 541    whether it can proceed or should return.  NEEDBITS() does the return if
 542    the requested bits are not available.  The typical use of the BITS macros
 543    is:
 544
 545         NEEDBITS(n);
 546         ... do something with BITS(n) ...
 547         DROPBITS(n);
 548
 549    where NEEDBITS(n) either returns from inflate() if there isn't enough
 550    input left to load n bits into the accumulator, or it continues.  BITS(n)
 551    gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
 552    the low n bits off the accumulator.  INITBITS() clears the accumulator
 553    and sets the number of available bits to zero.  BYTEBITS() discards just
 554    enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
 555    and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
 556
 557    NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
 558    if there is no input available.  The decoding of variable length codes uses
 559    PULLBYTE() directly in order to pull just enough bytes to decode the next
 560    code, and no more.
 561
 562    Some states loop until they get enough input, making sure that enough
 563    state information is maintained to continue the loop where it left off
 564    if NEEDBITS() returns in the loop.  For example, want, need, and keep
 565    would all have to actually be part of the saved state in case NEEDBITS()
 566    returns:
 567
 568     case STATEw:
 569         while (want < need) {
 570             NEEDBITS(n);
 571             keep[want++] = BITS(n);
 572             DROPBITS(n);
 573         }
 574         state = STATEx;
 575     case STATEx:
 576
 577    As shown above, if the next state is also the next case, then the break
 578    is omitted.
 579
 580    A state may also return if there is not enough output space available to
 581    complete that state.  Those states are copying stored data, writing a
 582    literal byte, and copying a matching string.
 583
 584    When returning, a "goto inf_leave" is used to update the total counters,
 585    update the check value, and determine whether any progress has been made
 586    during that inflate() call in order to return the proper return code.
 587    Progress is defined as a change in either strm->avail_in or strm->avail_out.
 588    When there is a window, goto inf_leave will update the window with the last
 589    output written.  If a goto inf_leave occurs in the middle of decompression
 590    and there is no window currently, goto inf_leave will create one and copy
 591    output to the window for the next call of inflate().
 592
 593    In this implementation, the flush parameter of inflate() only affects the
 594    return code (per zlib.h).  inflate() always writes as much as possible to
 595    strm->next_out, given the space available and the provided input--the effect
 596    documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
 597    the allocation of and copying into a sliding window until necessary, which
 598    provides the effect documented in zlib.h for Z_FINISH when the entire input
 599    stream available.  So the only thing the flush parameter actually does is:
 600    when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
 601    will return Z_BUF_ERROR if it has not reached the end of the stream.
 602  */
 603
 604 int ZEXPORT inflate(strm, flush)
 605 z_streamp strm;
 606 int flush;
 607 {
 608     struct inflate_state FAR *state;
 609     unsigned char FAR *next;    /* next input */
 610     unsigned char FAR *put;     /* next output */
 611     unsigned have, left;        /* available input and output */
 612     unsigned long hold;         /* bit buffer */
 613     unsigned bits;              /* bits in bit buffer */
 614     unsigned in, out;           /* save starting available input and output */
 615     unsigned copy;              /* number of stored or match bytes to copy */
 616     unsigned char FAR *from;    /* where to copy match bytes from */
 617     code here;                  /* current decoding table entry */
 618     code last;                  /* parent table entry */
 619     unsigned len;               /* length to copy for repeats, bits to drop */
 620     int ret;                    /* return code */
 621 #ifdef GUNZIP
 622     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
 623 #endif
 624     static const unsigned short order[19] = /* permutation of code lengths */
 625         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 626
 627     if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
 628         (strm->next_in == Z_NULL && strm->avail_in != 0))
 629         return Z_STREAM_ERROR;
 630
 631     state = (struct inflate_state FAR *)strm->state;
 632     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
 633     LOAD();
 634     in = have;
 635     out = left;
 636     ret = Z_OK;
 637     for (;;)
 638         switch (state->mode) {
 639         case HEAD:
 640             if (state->wrap == 0) {
 641                 state->mode = TYPEDO;
 642                 break;
 643             }
 644             NEEDBITS(16);
 645 #ifdef GUNZIP
 646             if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
 647                 state->check = crc32(0L, Z_NULL, 0);
 648                 CRC2(state->check, hold);
 649                 INITBITS();
 650                 state->mode = FLAGS;
 651                 break;
 652             }
 653             state->flags = 0;           /* expect zlib header */
 654             if (state->head != Z_NULL)
 655                 state->head->done = -1;
 656             if (!(state->wrap & 1) ||   /* check if zlib header allowed */
 657 #else
 658             if (
 659 #endif
 660                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
 661                 strm->msg = (char *)"incorrect header check";
 662                 state->mode = BAD;
 663                 break;
 664             }
 665             if (BITS(4) != Z_DEFLATED) {
 666                 strm->msg = (char *)"unknown compression method";
 667                 state->mode = BAD;
 668                 break;
 669             }
 670             DROPBITS(4);
 671             len = BITS(4) + 8;
 672             if (state->wbits == 0)
 673                 state->wbits = len;
 674             else if (len > state->wbits) {
 675                 strm->msg = (char *)"invalid window size";
 676                 state->mode = BAD;
 677                 break;
 678             }
 679             state->dmax = 1U << len;
 680             Tracev((stderr, "inflate:   zlib header ok\n"));
 681             strm->adler = state->check = adler32(0L, Z_NULL, 0);
 682             state->mode = hold & 0x200 ? DICTID : TYPE;
 683             INITBITS();
 684             break;
 685 #ifdef GUNZIP
 686         case FLAGS:
 687             NEEDBITS(16);
 688             state->flags = (int)(hold);
 689             if ((state->flags & 0xff) != Z_DEFLATED) {
 690                 strm->msg = (char *)"unknown compression method";
 691                 state->mode = BAD;
 692                 break;
 693             }
 694             if (state->flags & 0xe000) {
 695                 strm->msg = (char *)"unknown header flags set";
 696                 state->mode = BAD;
 697                 break;
 698             }
 699             if (state->head != Z_NULL)
 700                 state->head->text = (int)((hold >> 8) & 1);
 701             if (state->flags & 0x0200) CRC2(state->check, hold);
 702             INITBITS();
 703             state->mode = TIME;
 704         case TIME:
 705             NEEDBITS(32);
 706             if (state->head != Z_NULL)
 707                 state->head->time = hold;
 708             if (state->flags & 0x0200) CRC4(state->check, hold);
 709             INITBITS();
 710             state->mode = OS;
 711         case OS:
 712             NEEDBITS(16);
 713             if (state->head != Z_NULL) {
 714                 state->head->xflags = (int)(hold & 0xff);
 715                 state->head->os = (int)(hold >> 8);
 716             }
 717             if (state->flags & 0x0200) CRC2(state->check, hold);
 718             INITBITS();
 719             state->mode = EXLEN;
 720         case EXLEN:
 721             if (state->flags & 0x0400) {
 722                 NEEDBITS(16);
 723                 state->length = (unsigned)(hold);
 724                 if (state->head != Z_NULL)
 725                     state->head->extra_len = (unsigned)hold;
 726                 if (state->flags & 0x0200) CRC2(state->check, hold);
 727                 INITBITS();
 728             }
 729             else if (state->head != Z_NULL)
 730                 state->head->extra = Z_NULL;
 731             state->mode = EXTRA;
 732         case EXTRA:
 733             if (state->flags & 0x0400) {
 734                 copy = state->length;
 735                 if (copy > have) copy = have;
 736                 if (copy) {
 737                     if (state->head != Z_NULL &&
 738                         state->head->extra != Z_NULL) {
 739                         len = state->head->extra_len - state->length;
 740                         zmemcpy(state->head->extra + len, next,
 741                                 len + copy > state->head->extra_max ?
 742                                 state->head->extra_max - len : copy);
 743                     }
 744                     if (state->flags & 0x0200)
 745                         state->check = crc32(state->check, next, copy);
 746                     have -= copy;
 747                     next += copy;
 748                     state->length -= copy;
 749                 }
 750                 if (state->length) goto inf_leave;
 751             }
 752             state->length = 0;
 753             state->mode = NAME;
 754         case NAME:
 755             if (state->flags & 0x0800) {
 756                 if (have == 0) goto inf_leave;
 757                 copy = 0;
 758                 do {
 759                     len = (unsigned)(next[copy++]);
 760                     if (state->head != Z_NULL &&
 761                             state->head->name != Z_NULL &&
 762                             state->length < state->head->name_max)
 763                         state->head->name[state->length++] = len;
 764                 } while (len && copy < have);
 765                 if (state->flags & 0x0200)
 766                     state->check = crc32(state->check, next, copy);
 767                 have -= copy;
 768                 next += copy;
 769                 if (len) goto inf_leave;
 770             }
 771             else if (state->head != Z_NULL)
 772                 state->head->name = Z_NULL;
 773             state->length = 0;
 774             state->mode = COMMENT;
 775         case COMMENT:
 776             if (state->flags & 0x1000) {
 777                 if (have == 0) goto inf_leave;
 778                 copy = 0;
 779                 do {
 780                     len = (unsigned)(next[copy++]);
 781                     if (state->head != Z_NULL &&
 782                             state->head->comment != Z_NULL &&
 783                             state->length < state->head->comm_max)
 784                         state->head->comment[state->length++] = len;
 785                 } while (len && copy < have);
 786                 if (state->flags & 0x0200)
 787                     state->check = crc32(state->check, next, copy);
 788                 have -= copy;
 789                 next += copy;
 790                 if (len) goto inf_leave;
 791             }
 792             else if (state->head != Z_NULL)
 793                 state->head->comment = Z_NULL;
 794             state->mode = HCRC;
 795         case HCRC:
 796             if (state->flags & 0x0200) {
 797                 NEEDBITS(16);
 798                 if (hold != (state->check & 0xffff)) {
 799                     strm->msg = (char *)"header crc mismatch";
 800                     state->mode = BAD;
 801                     break;
 802                 }
 803                 INITBITS();
 804             }
 805             if (state->head != Z_NULL) {
 806                 state->head->hcrc = (int)((state->flags >> 9) & 1);
 807                 state->head->done = 1;
 808             }
 809             strm->adler = state->check = crc32(0L, Z_NULL, 0);
 810             state->mode = TYPE;
 811             break;
 812 #endif
 813         case DICTID:
 814             NEEDBITS(32);
 815             strm->adler = state->check = ZSWAP32(hold);
 816             INITBITS();
 817             state->mode = DICT;
 818         case DICT:
 819             if (state->havedict == 0) {
 820                 RESTORE();
 821                 return Z_NEED_DICT;
 822             }
 823             strm->adler = state->check = adler32(0L, Z_NULL, 0);
 824             state->mode = TYPE;
 825         case TYPE:
 826             if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
 827         case TYPEDO:
 828             if (state->last) {
 829                 BYTEBITS();
 830                 state->mode = CHECK;
 831                 break;
 832             }
 833             NEEDBITS(3);
 834             state->last = BITS(1);
 835             DROPBITS(1);
 836             switch (BITS(2)) {
 837             case 0:                             /* stored block */
 838                 Tracev((stderr, "inflate:     stored block%s\n",
 839                         state->last ? " (last)" : ""));
 840                 state->mode = STORED;
 841                 break;
 842             case 1:                             /* fixed block */
 843                 fixedtables(state);
 844                 Tracev((stderr, "inflate:     fixed codes block%s\n",
 845                         state->last ? " (last)" : ""));
 846                 state->mode = LEN_;             /* decode codes */
 847                 if (flush == Z_TREES) {
 848                     DROPBITS(2);
 849                     goto inf_leave;
 850                 }
 851                 break;
 852             case 2:                             /* dynamic block */
 853                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
 854                         state->last ? " (last)" : ""));
 855                 state->mode = TABLE;
 856                 break;
 857             case 3:
 858                 strm->msg = (char *)"invalid block type";
 859                 state->mode = BAD;
 860             }
 861             DROPBITS(2);
 862             break;
 863         case STORED:
 864             BYTEBITS();                         /* go to byte boundary */
 865             NEEDBITS(32);
 866             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 867                 strm->msg = (char *)"invalid stored block lengths";
 868                 state->mode = BAD;
 869                 break;
 870             }
 871             state->length = (unsigned)hold & 0xffff;
 872             Tracev((stderr, "inflate:       stored length %u\n",
 873                     state->length));
 874             INITBITS();
 875             state->mode = COPY_;
 876             if (flush == Z_TREES) goto inf_leave;
 877         case COPY_:
 878             state->mode = COPY;
 879         case COPY:
 880             copy = state->length;
 881             if (copy) {
 882                 if (copy > have) copy = have;
 883                 if (copy > left) copy = left;
 884                 if (copy == 0) goto inf_leave;
 885                 zmemcpy(put, next, copy);
 886                 have -= copy;
 887                 next += copy;
 888                 left -= copy;
 889                 put += copy;
 890                 state->length -= copy;
 891                 break;
 892             }
 893             Tracev((stderr, "inflate:       stored end\n"));
 894             state->mode = TYPE;
 895             break;
 896         case TABLE:
 897             NEEDBITS(14);
 898             state->nlen = BITS(5) + 257;
 899             DROPBITS(5);
 900             state->ndist = BITS(5) + 1;
 901             DROPBITS(5);
 902             state->ncode = BITS(4) + 4;
 903             DROPBITS(4);
 904 #ifndef PKZIP_BUG_WORKAROUND
 905             if (state->nlen > 286 || state->ndist > 30) {
 906                 strm->msg = (char *)"too many length or distance symbols";
 907                 state->mode = BAD;
 908                 break;
 909             }
 910 #endif
 911             Tracev((stderr, "inflate:       table sizes ok\n"));
 912             state->have = 0;
 913             state->mode = LENLENS;
 914         case LENLENS:
 915             while (state->have < state->ncode) {
 916                 NEEDBITS(3);
 917                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
 918                 DROPBITS(3);
 919             }
 920             while (state->have < 19)
 921                 state->lens[order[state->have++]] = 0;
 922             state->next = state->codes;
 923             state->lencode = (code const FAR *)(state->next);
 924             state->lenbits = 7;
 925             ret = inflate_table(CODES, state->lens, 19, &(state->next),
 926                                 &(state->lenbits), state->work);
 927             if (ret) {
 928                 strm->msg = (char *)"invalid code lengths set";
 929                 state->mode = BAD;
 930                 break;
 931             }
 932             Tracev((stderr, "inflate:       code lengths ok\n"));
 933             state->have = 0;
 934             state->mode = CODELENS;
 935         case CODELENS:
 936             while (state->have < state->nlen + state->ndist) {
 937                 for (;;) {
 938                     here = state->lencode[BITS(state->lenbits)];
 939                     if ((unsigned)(here.bits) <= bits) break;
 940                     PULLBYTE();
 941                 }
 942                 if (here.val < 16) {
 943                     DROPBITS(here.bits);
 944                     state->lens[state->have++] = here.val;
 945                 }
 946                 else {
 947                     if (here.val == 16) {
 948                         NEEDBITS(here.bits + 2);
 949                         DROPBITS(here.bits);
 950                         if (state->have == 0) {
 951                             strm->msg = (char *)"invalid bit length repeat";
 952                             state->mode = BAD;
 953                             break;
 954                         }
 955                         len = state->lens[state->have - 1];
 956                         copy = 3 + BITS(2);
 957                         DROPBITS(2);
 958                     }
 959                     else if (here.val == 17) {
 960                         NEEDBITS(here.bits + 3);
 961                         DROPBITS(here.bits);
 962                         len = 0;
 963                         copy = 3 + BITS(3);
 964                         DROPBITS(3);
 965                     }
 966                     else {
 967                         NEEDBITS(here.bits + 7);
 968                         DROPBITS(here.bits);
 969                         len = 0;
 970                         copy = 11 + BITS(7);
 971                         DROPBITS(7);
 972                     }
 973                     if (state->have + copy > state->nlen + state->ndist) {
 974                         strm->msg = (char *)"invalid bit length repeat";
 975                         state->mode = BAD;
 976                         break;
 977                     }
 978                     while (copy--)
 979                         state->lens[state->have++] = (unsigned short)len;
 980                 }
 981             }
 982
 983             /* handle error breaks in while */
 984             if (state->mode == BAD) break;
 985
 986             /* check for end-of-block code (better have one) */
 987             if (state->lens[256] == 0) {
 988                 strm->msg = (char *)"invalid code -- missing end-of-block";
 989                 state->mode = BAD;
 990                 break;
 991             }
 992
 993             /* build code tables -- note: do not change the lenbits or distbits
 994                values here (9 and 6) without reading the comments in inftrees.h
 995                concerning the ENOUGH constants, which depend on those values */
 996             state->next = state->codes;
 997             state->lencode = (code const FAR *)(state->next);
 998             state->lenbits = 9;
 999             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1000                                 &(state->lenbits), state->work);
1001             if (ret) {
1002                 strm->msg = (char *)"invalid literal/lengths set";
1003                 state->mode = BAD;
1004                 break;
1005             }
1006             state->distcode = (code const FAR *)(state->next);
1007             state->distbits = 6;
1008             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1009                             &(state->next), &(state->distbits), state->work);
1010             if (ret) {
1011                 strm->msg = (char *)"invalid distances set";
1012                 state->mode = BAD;
1013                 break;
1014             }
1015             Tracev((stderr, "inflate:       codes ok\n"));
1016             state->mode = LEN_;
1017             if (flush == Z_TREES) goto inf_leave;
1018         case LEN_:
1019             state->mode = LEN;
1020         case LEN:
1021             if (have >= 6 && left >= 258) {
1022                 RESTORE();
1023                 inflate_fast(strm, out);
1024                 LOAD();
1025                 if (state->mode == TYPE)
1026                     state->back = -1;
1027                 break;
1028             }
1029             state->back = 0;
1030             for (;;) {
1031                 here = state->lencode[BITS(state->lenbits)];
1032                 if ((unsigned)(here.bits) <= bits) break;
1033                 PULLBYTE();
1034             }
1035             if (here.op && (here.op & 0xf0) == 0) {
1036                 last = here;
1037                 for (;;) {
1038                     here = state->lencode[last.val +
1039                             (BITS(last.bits + last.op) >> last.bits)];
1040                     if ((unsigned)(last.bits + here.bits) <= bits) break;
1041                     PULLBYTE();
1042                 }
1043                 DROPBITS(last.bits);
1044                 state->back += last.bits;
1045             }
1046             DROPBITS(here.bits);
1047             state->back += here.bits;
1048             state->length = (unsigned)here.val;
1049             if ((int)(here.op) == 0) {
1050                 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
1051                         "inflate:         literal '%c'\n" :
1052                         "inflate:         literal 0x%02x\n", here.val));
1053                 state->mode = LIT;
1054                 break;
1055             }
1056             if (here.op & 32) {
1057                 Tracevv((stderr, "inflate:         end of block\n"));
1058                 state->back = -1;
1059                 state->mode = TYPE;
1060                 break;
1061             }
1062             if (here.op & 64) {
1063                 strm->msg = (char *)"invalid literal/length code";
1064                 state->mode = BAD;
1065                 break;
1066             }
1067             state->extra = (unsigned)(here.op) & 15;
1068             state->mode = LENEXT;
1069         case LENEXT:
1070             if (state->extra) {
1071                 NEEDBITS(state->extra);
1072                 state->length += BITS(state->extra);
1073                 DROPBITS(state->extra);
1074                 state->back += state->extra;
1075             }
1076             Tracevv((stderr, "inflate:         length %u\n", state->length));
1077             state->was = state->length;
1078             state->mode = DIST;
1079         case DIST:
1080             for (;;) {
1081                 here = state->distcode[BITS(state->distbits)];
1082                 if ((unsigned)(here.bits) <= bits) break;
1083                 PULLBYTE();
1084             }
1085             if ((here.op & 0xf0) == 0) {
1086                 last = here;
1087                 for (;;) {
1088                     here = state->distcode[last.val +
1089                             (BITS(last.bits + last.op) >> last.bits)];
1090                     if ((unsigned)(last.bits + here.bits) <= bits) break;
1091                     PULLBYTE();
1092                 }
1093                 DROPBITS(last.bits);
1094                 state->back += last.bits;
1095             }
1096             DROPBITS(here.bits);
1097             state->back += here.bits;
1098             if (here.op & 64) {
1099                 strm->msg = (char *)"invalid distance code";
1100                 state->mode = BAD;
1101                 break;
1102             }
1103             state->offset = (unsigned)here.val;
1104             state->extra = (unsigned)(here.op) & 15;
1105             state->mode = DISTEXT;
1106         case DISTEXT:
1107             if (state->extra) {
1108                 NEEDBITS(state->extra);
1109                 state->offset += BITS(state->extra);
1110                 DROPBITS(state->extra);
1111                 state->back += state->extra;
1112             }
1113 #ifdef INFLATE_STRICT
1114             if (state->offset > state->dmax) {
1115                 strm->msg = (char *)"invalid distance too far back";
1116                 state->mode = BAD;
1117                 break;
1118             }
1119 #endif
1120             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
1121             state->mode = MATCH;
1122         case MATCH:
1123             if (left == 0) goto inf_leave;
1124             copy = out - left;
1125             if (state->offset > copy) {         /* copy from window */
1126                 copy = state->offset - copy;
1127                 if (copy > state->whave) {
1128                     if (state->sane) {
1129                         strm->msg = (char *)"invalid distance too far back";
1130                         state->mode = BAD;
1131                         break;
1132                     }
1133 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1134                     Trace((stderr, "inflate.c too far\n"));
1135                     copy -= state->whave;
1136                     if (copy > state->length) copy = state->length;
1137                     if (copy > left) copy = left;
1138                     left -= copy;
1139                     state->length -= copy;
1140                     do {
1141                         *put++ = 0;
1142                     } while (--copy);
1143                     if (state->length == 0) state->mode = LEN;
1144                     break;
1145 #endif
1146                 }
1147                 if (copy > state->wnext) {
1148                     copy -= state->wnext;
1149                     from = state->window + (state->wsize - copy);
1150                 }
1151                 else
1152                     from = state->window + (state->wnext - copy);
1153                 if (copy > state->length) copy = state->length;
1154             }
1155             else {                              /* copy from output */
1156                 from = put - state->offset;
1157                 copy = state->length;
1158             }
1159             if (copy > left) copy = left;
1160             left -= copy;
1161             state->length -= copy;
1162             do {
1163                 *put++ = *from++;
1164             } while (--copy);
1165             if (state->length == 0) state->mode = LEN;
1166             break;
1167         case LIT:
1168             if (left == 0) goto inf_leave;
1169             *put++ = (unsigned char)(state->length);
1170             left--;
1171             state->mode = LEN;
1172             break;
1173         case CHECK:
1174             if (state->wrap) {
1175                 NEEDBITS(32);
1176                 out -= left;
1177                 strm->total_out += out;
1178                 state->total += out;
1179                 if (out)
1180                     strm->adler = state->check =
1181                         UPDATE(state->check, put - out, out);
1182                 out = left;
1183                 if ((
1184 #ifdef GUNZIP
1185                      state->flags ? hold :
1186 #endif
1187                      ZSWAP32(hold)) != state->check) {
1188                     strm->msg = (char *)"incorrect data check";
1189                     state->mode = BAD;
1190                     break;
1191                 }
1192                 INITBITS();
1193                 Tracev((stderr, "inflate:   check matches trailer\n"));
1194             }
1195 #ifdef GUNZIP
1196             state->mode = LENGTH;
1197         case LENGTH:
1198             if (state->wrap && state->flags) {
1199                 NEEDBITS(32);
1200                 if (hold != (state->total & 0xffffffffUL)) {
1201                     strm->msg = (char *)"incorrect length check";
1202                     state->mode = BAD;
1203                     break;
1204                 }
1205                 INITBITS();
1206                 Tracev((stderr, "inflate:   length matches trailer\n"));
1207             }
1208 #endif
1209             state->mode = DONE;
1210         case DONE:
1211             ret = Z_STREAM_END;
1212             goto inf_leave;
1213         case BAD:
1214             ret = Z_DATA_ERROR;
1215             goto inf_leave;
1216         case MEM:
1217             return Z_MEM_ERROR;
1218         case SYNC:
1219         default:
1220             return Z_STREAM_ERROR;
1221         }
1222
1223     /*
1224        Return from inflate(), updating the total counts and the check value.
1225        If there was no progress during the inflate() call, return a buffer
1226        error.  Call updatewindow() to create and/or update the window state.
1227        Note: a memory error from inflate() is non-recoverable.
1228      */
1229   inf_leave:
1230     RESTORE();
1231     if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1232             (state->mode < CHECK || flush != Z_FINISH)))
1233         if (updatewindow(strm, out)) {
1234             state->mode = MEM;
1235             return Z_MEM_ERROR;
1236         }
1237     in -= strm->avail_in;
1238     out -= strm->avail_out;
1239     strm->total_in += in;
1240     strm->total_out += out;
1241     state->total += out;
1242     if (state->wrap && out)
1243         strm->adler = state->check =
1244             UPDATE(state->check, strm->next_out - out, out);
1245     strm->data_type = state->bits + (state->last ? 64 : 0) +
1246                       (state->mode == TYPE ? 128 : 0) +
1247                       (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1248     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1249         ret = Z_BUF_ERROR;
1250     return ret;
1251 }
1252
1253 int ZEXPORT inflateEnd(strm)
1254 z_streamp strm;
1255 {
1256     struct inflate_state FAR *state;
1257     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1258         return Z_STREAM_ERROR;
1259     state = (struct inflate_state FAR *)strm->state;
1260     if (state->window != Z_NULL) ZFREE(strm, state->window);
1261     ZFREE(strm, strm->state);
1262     strm->state = Z_NULL;
1263     Tracev((stderr, "inflate: end\n"));
1264     return Z_OK;
1265 }
1266
1267 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1268 z_streamp strm;
1269 const Bytef *dictionary;
1270 uInt dictLength;
1271 {
1272     struct inflate_state FAR *state;
1273     unsigned long dictid;
1274     unsigned char *next;
1275     unsigned avail;
1276     int ret;
1277
1278     /* check state */
1279     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1280     state = (struct inflate_state FAR *)strm->state;
1281     if (state->wrap != 0 && state->mode != DICT)
1282         return Z_STREAM_ERROR;
1283
1284     /* check for correct dictionary identifier */
1285     if (state->mode == DICT) {
1286         dictid = adler32(0L, Z_NULL, 0);
1287         dictid = adler32(dictid, dictionary, dictLength);
1288         if (dictid != state->check)
1289             return Z_DATA_ERROR;
1290     }
1291
1292     /* copy dictionary to window using updatewindow(), which will amend the
1293        existing dictionary if appropriate */
1294     next = strm->next_out;
1295     avail = strm->avail_out;
1296     strm->next_out = (Bytef *)dictionary + dictLength;
1297     strm->avail_out = 0;
1298     ret = updatewindow(strm, dictLength);
1299     strm->avail_out = avail;
1300     strm->next_out = next;
1301     if (ret) {
1302         state->mode = MEM;
1303         return Z_MEM_ERROR;
1304     }
1305     state->havedict = 1;
1306     Tracev((stderr, "inflate:   dictionary set\n"));
1307     return Z_OK;
1308 }
1309
1310 int ZEXPORT inflateGetHeader(strm, head)
1311 z_streamp strm;
1312 gz_headerp head;
1313 {
1314     struct inflate_state FAR *state;
1315
1316     /* check state */
1317     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1318     state = (struct inflate_state FAR *)strm->state;
1319     if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1320
1321     /* save header structure */
1322     state->head = head;
1323     head->done = 0;
1324     return Z_OK;
1325 }
1326
1327 /*
1328    Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
1329    or when out of input.  When called, *have is the number of pattern bytes
1330    found in order so far, in 0..3.  On return *have is updated to the new
1331    state.  If on return *have equals four, then the pattern was found and the
1332    return value is how many bytes were read including the last byte of the
1333    pattern.  If *have is less than four, then the pattern has not been found
1334    yet and the return value is len.  In the latter case, syncsearch() can be
1335    called again with more data and the *have state.  *have is initialized to
1336    zero for the first call.
1337  */
1338 local unsigned syncsearch(have, buf, len)
1339 unsigned FAR *have;
1340 unsigned char FAR *buf;
1341 unsigned len;
1342 {
1343     unsigned got;
1344     unsigned next;
1345
1346     got = *have;
1347     next = 0;
1348     while (next < len && got < 4) {
1349         if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1350             got++;
1351         else if (buf[next])
1352             got = 0;
1353         else
1354             got = 4 - got;
1355         next++;
1356     }
1357     *have = got;
1358     return next;
1359 }
1360
1361 int ZEXPORT inflateSync(strm)
1362 z_streamp strm;
1363 {
1364     unsigned len;               /* number of bytes to look at or looked at */
1365     unsigned long in, out;      /* temporary to save total_in and total_out */
1366     unsigned char buf[4];       /* to restore bit buffer to byte string */
1367     struct inflate_state FAR *state;
1368
1369     /* check parameters */
1370     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1371     state = (struct inflate_state FAR *)strm->state;
1372     if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1373
1374     /* if first time, start search in bit buffer */
1375     if (state->mode != SYNC) {
1376         state->mode = SYNC;
1377         state->hold <<= state->bits & 7;
1378         state->bits -= state->bits & 7;
1379         len = 0;
1380         while (state->bits >= 8) {
1381             buf[len++] = (unsigned char)(state->hold);
1382             state->hold >>= 8;
1383             state->bits -= 8;
1384         }
1385         state->have = 0;
1386         syncsearch(&(state->have), buf, len);
1387     }
1388
1389     /* search available input */
1390     len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1391     strm->avail_in -= len;
1392     strm->next_in += len;
1393     strm->total_in += len;
1394
1395     /* return no joy or set up to restart inflate() on a new block */
1396     if (state->have != 4) return Z_DATA_ERROR;
1397     in = strm->total_in;  out = strm->total_out;
1398     inflateReset(strm);
1399     strm->total_in = in;  strm->total_out = out;
1400     state->mode = TYPE;
1401     return Z_OK;
1402 }
1403
1404 /*
1405    Returns true if inflate is currently at the end of a block generated by
1406    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1407    implementation to provide an additional safety check. PPP uses
1408    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1409    block. When decompressing, PPP checks that at the end of input packet,
1410    inflate is waiting for these length bytes.
1411  */
1412 int ZEXPORT inflateSyncPoint(strm)
1413 z_streamp strm;
1414 {
1415     struct inflate_state FAR *state;
1416
1417     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1418     state = (struct inflate_state FAR *)strm->state;
1419     return state->mode == STORED && state->bits == 0;
1420 }
1421
1422 int ZEXPORT inflateCopy(dest, source)
1423 z_streamp dest;
1424 z_streamp source;
1425 {
1426     struct inflate_state FAR *state;
1427     struct inflate_state FAR *copy;
1428     unsigned char FAR *window;
1429     unsigned wsize;
1430
1431     /* check input */
1432     if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1433         source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
1434         return Z_STREAM_ERROR;
1435     state = (struct inflate_state FAR *)source->state;
1436
1437     /* allocate space */
1438     copy = (struct inflate_state FAR *)
1439            ZALLOC(source, 1, sizeof(struct inflate_state));
1440     if (copy == Z_NULL) return Z_MEM_ERROR;
1441     window = Z_NULL;
1442     if (state->window != Z_NULL) {
1443         window = (unsigned char FAR *)
1444                  ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1445         if (window == Z_NULL) {
1446             ZFREE(source, copy);
1447             return Z_MEM_ERROR;
1448         }
1449     }
1450
1451     /* copy state */
1452     zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
1453     zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1454     if (state->lencode >= state->codes &&
1455         state->lencode <= state->codes + ENOUGH - 1) {
1456         copy->lencode = copy->codes + (state->lencode - state->codes);
1457         copy->distcode = copy->codes + (state->distcode - state->codes);
1458     }
1459     copy->next = copy->codes + (state->next - state->codes);
1460     if (window != Z_NULL) {
1461         wsize = 1U << state->wbits;
1462         zmemcpy(window, state->window, wsize);
1463     }
1464     copy->window = window;
1465     dest->state = (struct internal_state FAR *)copy;
1466     return Z_OK;
1467 }
1468
1469 int ZEXPORT inflateUndermine(strm, subvert)
1470 z_streamp strm;
1471 int subvert;
1472 {
1473     struct inflate_state FAR *state;
1474
1475     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1476     state = (struct inflate_state FAR *)strm->state;
1477     state->sane = !subvert;
1478 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1479     return Z_OK;
1480 #else
1481     state->sane = 1;
1482     return Z_DATA_ERROR;
1483 #endif
1484 }
1485
1486 long ZEXPORT inflateMark(strm)
1487 z_streamp strm;
1488 {
1489     struct inflate_state FAR *state;
1490
1491     if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
1492     state = (struct inflate_state FAR *)strm->state;
1493     return ((long)(state->back) << 16) +
1494         (state->mode == COPY ? state->length :
1495             (state->mode == MATCH ? state->was - state->length : 0));
1496 }