PageRenderTime 106ms CodeModel.GetById 23ms app.highlight 71ms RepoModel.GetById 2ms app.codeStats 1ms

/src/FreeImage/Source/ZLib/inflate.c

https://bitbucket.org/cabalistic/ogredeps/
C | 1501 lines | 1152 code | 77 blank | 272 comment | 376 complexity | 5c40a49e22e4acf391c64d7092d1a799 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/* inflate.c -- zlib decompression
   2 * Copyright (C) 1995-2011 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 */
  95local void fixedtables OF((struct inflate_state FAR *state));
  96local int updatewindow OF((z_streamp strm, unsigned out));
  97#ifdef BUILDFIXED
  98   void makefixed OF((void));
  99#endif
 100local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
 101                              unsigned len));
 102
 103int ZEXPORT inflateResetKeep(strm)
 104z_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
 128int ZEXPORT inflateReset(strm)
 129z_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
 141int ZEXPORT inflateReset2(strm, windowBits)
 142z_streamp strm;
 143int 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
 179int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
 180z_streamp strm;
 181int windowBits;
 182const char *version;
 183int 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
 221int ZEXPORT inflateInit_(strm, version, stream_size)
 222z_streamp strm;
 223const char *version;
 224int stream_size;
 225{
 226    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
 227}
 228
 229int ZEXPORT inflatePrime(strm, bits, value)
 230z_streamp strm;
 231int bits;
 232int 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 */
 260local void fixedtables(state)
 261struct 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 */
 324void 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 */
 378local int updatewindow(strm, out)
 379z_streamp strm;
 380unsigned 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/* Reverse the bytes in a 32-bit value */
 523#define REVERSE(q) \
 524    ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
 525     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 526
 527/*
 528   inflate() uses a state machine to process as much input data and generate as
 529   much output data as possible before returning.  The state machine is
 530   structured roughly as follows:
 531
 532    for (;;) switch (state) {
 533    ...
 534    case STATEn:
 535        if (not enough input data or output space to make progress)
 536            return;
 537        ... make progress ...
 538        state = STATEm;
 539        break;
 540    ...
 541    }
 542
 543   so when inflate() is called again, the same case is attempted again, and
 544   if the appropriate resources are provided, the machine proceeds to the
 545   next state.  The NEEDBITS() macro is usually the way the state evaluates
 546   whether it can proceed or should return.  NEEDBITS() does the return if
 547   the requested bits are not available.  The typical use of the BITS macros
 548   is:
 549
 550        NEEDBITS(n);
 551        ... do something with BITS(n) ...
 552        DROPBITS(n);
 553
 554   where NEEDBITS(n) either returns from inflate() if there isn't enough
 555   input left to load n bits into the accumulator, or it continues.  BITS(n)
 556   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
 557   the low n bits off the accumulator.  INITBITS() clears the accumulator
 558   and sets the number of available bits to zero.  BYTEBITS() discards just
 559   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
 560   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
 561
 562   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
 563   if there is no input available.  The decoding of variable length codes uses
 564   PULLBYTE() directly in order to pull just enough bytes to decode the next
 565   code, and no more.
 566
 567   Some states loop until they get enough input, making sure that enough
 568   state information is maintained to continue the loop where it left off
 569   if NEEDBITS() returns in the loop.  For example, want, need, and keep
 570   would all have to actually be part of the saved state in case NEEDBITS()
 571   returns:
 572
 573    case STATEw:
 574        while (want < need) {
 575            NEEDBITS(n);
 576            keep[want++] = BITS(n);
 577            DROPBITS(n);
 578        }
 579        state = STATEx;
 580    case STATEx:
 581
 582   As shown above, if the next state is also the next case, then the break
 583   is omitted.
 584
 585   A state may also return if there is not enough output space available to
 586   complete that state.  Those states are copying stored data, writing a
 587   literal byte, and copying a matching string.
 588
 589   When returning, a "goto inf_leave" is used to update the total counters,
 590   update the check value, and determine whether any progress has been made
 591   during that inflate() call in order to return the proper return code.
 592   Progress is defined as a change in either strm->avail_in or strm->avail_out.
 593   When there is a window, goto inf_leave will update the window with the last
 594   output written.  If a goto inf_leave occurs in the middle of decompression
 595   and there is no window currently, goto inf_leave will create one and copy
 596   output to the window for the next call of inflate().
 597
 598   In this implementation, the flush parameter of inflate() only affects the
 599   return code (per zlib.h).  inflate() always writes as much as possible to
 600   strm->next_out, given the space available and the provided input--the effect
 601   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
 602   the allocation of and copying into a sliding window until necessary, which
 603   provides the effect documented in zlib.h for Z_FINISH when the entire input
 604   stream available.  So the only thing the flush parameter actually does is:
 605   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
 606   will return Z_BUF_ERROR if it has not reached the end of the stream.
 607 */
 608
 609int ZEXPORT inflate(strm, flush)
 610z_streamp strm;
 611int flush;
 612{
 613    struct inflate_state FAR *state;
 614    unsigned char FAR *next;    /* next input */
 615    unsigned char FAR *put;     /* next output */
 616    unsigned have, left;        /* available input and output */
 617    unsigned long hold;         /* bit buffer */
 618    unsigned bits;              /* bits in bit buffer */
 619    unsigned in, out;           /* save starting available input and output */
 620    unsigned copy;              /* number of stored or match bytes to copy */
 621    unsigned char FAR *from;    /* where to copy match bytes from */
 622    code here;                  /* current decoding table entry */
 623    code last;                  /* parent table entry */
 624    unsigned len;               /* length to copy for repeats, bits to drop */
 625    int ret;                    /* return code */
 626#ifdef GUNZIP
 627    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
 628#endif
 629    static const unsigned short order[19] = /* permutation of code lengths */
 630        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 631
 632    if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
 633        (strm->next_in == Z_NULL && strm->avail_in != 0))
 634        return Z_STREAM_ERROR;
 635
 636    state = (struct inflate_state FAR *)strm->state;
 637    if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
 638    LOAD();
 639    in = have;
 640    out = left;
 641    ret = Z_OK;
 642    for (;;)
 643        switch (state->mode) {
 644        case HEAD:
 645            if (state->wrap == 0) {
 646                state->mode = TYPEDO;
 647                break;
 648            }
 649            NEEDBITS(16);
 650#ifdef GUNZIP
 651            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
 652                state->check = crc32(0L, Z_NULL, 0);
 653                CRC2(state->check, hold);
 654                INITBITS();
 655                state->mode = FLAGS;
 656                break;
 657            }
 658            state->flags = 0;           /* expect zlib header */
 659            if (state->head != Z_NULL)
 660                state->head->done = -1;
 661            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
 662#else
 663            if (
 664#endif
 665                ((BITS(8) << 8) + (hold >> 8)) % 31) {
 666                strm->msg = (char *)"incorrect header check";
 667                state->mode = BAD;
 668                break;
 669            }
 670            if (BITS(4) != Z_DEFLATED) {
 671                strm->msg = (char *)"unknown compression method";
 672                state->mode = BAD;
 673                break;
 674            }
 675            DROPBITS(4);
 676            len = BITS(4) + 8;
 677            if (state->wbits == 0)
 678                state->wbits = len;
 679            else if (len > state->wbits) {
 680                strm->msg = (char *)"invalid window size";
 681                state->mode = BAD;
 682                break;
 683            }
 684            state->dmax = 1U << len;
 685            Tracev((stderr, "inflate:   zlib header ok\n"));
 686            strm->adler = state->check = adler32(0L, Z_NULL, 0);
 687            state->mode = hold & 0x200 ? DICTID : TYPE;
 688            INITBITS();
 689            break;
 690#ifdef GUNZIP
 691        case FLAGS:
 692            NEEDBITS(16);
 693            state->flags = (int)(hold);
 694            if ((state->flags & 0xff) != Z_DEFLATED) {
 695                strm->msg = (char *)"unknown compression method";
 696                state->mode = BAD;
 697                break;
 698            }
 699            if (state->flags & 0xe000) {
 700                strm->msg = (char *)"unknown header flags set";
 701                state->mode = BAD;
 702                break;
 703            }
 704            if (state->head != Z_NULL)
 705                state->head->text = (int)((hold >> 8) & 1);
 706            if (state->flags & 0x0200) CRC2(state->check, hold);
 707            INITBITS();
 708            state->mode = TIME;
 709        case TIME:
 710            NEEDBITS(32);
 711            if (state->head != Z_NULL)
 712                state->head->time = hold;
 713            if (state->flags & 0x0200) CRC4(state->check, hold);
 714            INITBITS();
 715            state->mode = OS;
 716        case OS:
 717            NEEDBITS(16);
 718            if (state->head != Z_NULL) {
 719                state->head->xflags = (int)(hold & 0xff);
 720                state->head->os = (int)(hold >> 8);
 721            }
 722            if (state->flags & 0x0200) CRC2(state->check, hold);
 723            INITBITS();
 724            state->mode = EXLEN;
 725        case EXLEN:
 726            if (state->flags & 0x0400) {
 727                NEEDBITS(16);
 728                state->length = (unsigned)(hold);
 729                if (state->head != Z_NULL)
 730                    state->head->extra_len = (unsigned)hold;
 731                if (state->flags & 0x0200) CRC2(state->check, hold);
 732                INITBITS();
 733            }
 734            else if (state->head != Z_NULL)
 735                state->head->extra = Z_NULL;
 736            state->mode = EXTRA;
 737        case EXTRA:
 738            if (state->flags & 0x0400) {
 739                copy = state->length;
 740                if (copy > have) copy = have;
 741                if (copy) {
 742                    if (state->head != Z_NULL &&
 743                        state->head->extra != Z_NULL) {
 744                        len = state->head->extra_len - state->length;
 745                        zmemcpy(state->head->extra + len, next,
 746                                len + copy > state->head->extra_max ?
 747                                state->head->extra_max - len : copy);
 748                    }
 749                    if (state->flags & 0x0200)
 750                        state->check = crc32(state->check, next, copy);
 751                    have -= copy;
 752                    next += copy;
 753                    state->length -= copy;
 754                }
 755                if (state->length) goto inf_leave;
 756            }
 757            state->length = 0;
 758            state->mode = NAME;
 759        case NAME:
 760            if (state->flags & 0x0800) {
 761                if (have == 0) goto inf_leave;
 762                copy = 0;
 763                do {
 764                    len = (unsigned)(next[copy++]);
 765                    if (state->head != Z_NULL &&
 766                            state->head->name != Z_NULL &&
 767                            state->length < state->head->name_max)
 768                        state->head->name[state->length++] = len;
 769                } while (len && copy < have);
 770                if (state->flags & 0x0200)
 771                    state->check = crc32(state->check, next, copy);
 772                have -= copy;
 773                next += copy;
 774                if (len) goto inf_leave;
 775            }
 776            else if (state->head != Z_NULL)
 777                state->head->name = Z_NULL;
 778            state->length = 0;
 779            state->mode = COMMENT;
 780        case COMMENT:
 781            if (state->flags & 0x1000) {
 782                if (have == 0) goto inf_leave;
 783                copy = 0;
 784                do {
 785                    len = (unsigned)(next[copy++]);
 786                    if (state->head != Z_NULL &&
 787                            state->head->comment != Z_NULL &&
 788                            state->length < state->head->comm_max)
 789                        state->head->comment[state->length++] = len;
 790                } while (len && copy < have);
 791                if (state->flags & 0x0200)
 792                    state->check = crc32(state->check, next, copy);
 793                have -= copy;
 794                next += copy;
 795                if (len) goto inf_leave;
 796            }
 797            else if (state->head != Z_NULL)
 798                state->head->comment = Z_NULL;
 799            state->mode = HCRC;
 800        case HCRC:
 801            if (state->flags & 0x0200) {
 802                NEEDBITS(16);
 803                if (hold != (state->check & 0xffff)) {
 804                    strm->msg = (char *)"header crc mismatch";
 805                    state->mode = BAD;
 806                    break;
 807                }
 808                INITBITS();
 809            }
 810            if (state->head != Z_NULL) {
 811                state->head->hcrc = (int)((state->flags >> 9) & 1);
 812                state->head->done = 1;
 813            }
 814            strm->adler = state->check = crc32(0L, Z_NULL, 0);
 815            state->mode = TYPE;
 816            break;
 817#endif
 818        case DICTID:
 819            NEEDBITS(32);
 820            strm->adler = state->check = REVERSE(hold);
 821            INITBITS();
 822            state->mode = DICT;
 823        case DICT:
 824            if (state->havedict == 0) {
 825                RESTORE();
 826                return Z_NEED_DICT;
 827            }
 828            strm->adler = state->check = adler32(0L, Z_NULL, 0);
 829            state->mode = TYPE;
 830        case TYPE:
 831            if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
 832        case TYPEDO:
 833            if (state->last) {
 834                BYTEBITS();
 835                state->mode = CHECK;
 836                break;
 837            }
 838            NEEDBITS(3);
 839            state->last = BITS(1);
 840            DROPBITS(1);
 841            switch (BITS(2)) {
 842            case 0:                             /* stored block */
 843                Tracev((stderr, "inflate:     stored block%s\n",
 844                        state->last ? " (last)" : ""));
 845                state->mode = STORED;
 846                break;
 847            case 1:                             /* fixed block */
 848                fixedtables(state);
 849                Tracev((stderr, "inflate:     fixed codes block%s\n",
 850                        state->last ? " (last)" : ""));
 851                state->mode = LEN_;             /* decode codes */
 852                if (flush == Z_TREES) {
 853                    DROPBITS(2);
 854                    goto inf_leave;
 855                }
 856                break;
 857            case 2:                             /* dynamic block */
 858                Tracev((stderr, "inflate:     dynamic codes block%s\n",
 859                        state->last ? " (last)" : ""));
 860                state->mode = TABLE;
 861                break;
 862            case 3:
 863                strm->msg = (char *)"invalid block type";
 864                state->mode = BAD;
 865            }
 866            DROPBITS(2);
 867            break;
 868        case STORED:
 869            BYTEBITS();                         /* go to byte boundary */
 870            NEEDBITS(32);
 871            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 872                strm->msg = (char *)"invalid stored block lengths";
 873                state->mode = BAD;
 874                break;
 875            }
 876            state->length = (unsigned)hold & 0xffff;
 877            Tracev((stderr, "inflate:       stored length %u\n",
 878                    state->length));
 879            INITBITS();
 880            state->mode = COPY_;
 881            if (flush == Z_TREES) goto inf_leave;
 882        case COPY_:
 883            state->mode = COPY;
 884        case COPY:
 885            copy = state->length;
 886            if (copy) {
 887                if (copy > have) copy = have;
 888                if (copy > left) copy = left;
 889                if (copy == 0) goto inf_leave;
 890                zmemcpy(put, next, copy);
 891                have -= copy;
 892                next += copy;
 893                left -= copy;
 894                put += copy;
 895                state->length -= copy;
 896                break;
 897            }
 898            Tracev((stderr, "inflate:       stored end\n"));
 899            state->mode = TYPE;
 900            break;
 901        case TABLE:
 902            NEEDBITS(14);
 903            state->nlen = BITS(5) + 257;
 904            DROPBITS(5);
 905            state->ndist = BITS(5) + 1;
 906            DROPBITS(5);
 907            state->ncode = BITS(4) + 4;
 908            DROPBITS(4);
 909#ifndef PKZIP_BUG_WORKAROUND
 910            if (state->nlen > 286 || state->ndist > 30) {
 911                strm->msg = (char *)"too many length or distance symbols";
 912                state->mode = BAD;
 913                break;
 914            }
 915#endif
 916            Tracev((stderr, "inflate:       table sizes ok\n"));
 917            state->have = 0;
 918            state->mode = LENLENS;
 919        case LENLENS:
 920            while (state->have < state->ncode) {
 921                NEEDBITS(3);
 922                state->lens[order[state->have++]] = (unsigned short)BITS(3);
 923                DROPBITS(3);
 924            }
 925            while (state->have < 19)
 926                state->lens[order[state->have++]] = 0;
 927            state->next = state->codes;
 928            state->lencode = (code const FAR *)(state->next);
 929            state->lenbits = 7;
 930            ret = inflate_table(CODES, state->lens, 19, &(state->next),
 931                                &(state->lenbits), state->work);
 932            if (ret) {
 933                strm->msg = (char *)"invalid code lengths set";
 934                state->mode = BAD;
 935                break;
 936            }
 937            Tracev((stderr, "inflate:       code lengths ok\n"));
 938            state->have = 0;
 939            state->mode = CODELENS;
 940        case CODELENS:
 941            while (state->have < state->nlen + state->ndist) {
 942                for (;;) {
 943                    here = state->lencode[BITS(state->lenbits)];
 944                    if ((unsigned)(here.bits) <= bits) break;
 945                    PULLBYTE();
 946                }
 947                if (here.val < 16) {
 948                    DROPBITS(here.bits);
 949                    state->lens[state->have++] = here.val;
 950                }
 951                else {
 952                    if (here.val == 16) {
 953                        NEEDBITS(here.bits + 2);
 954                        DROPBITS(here.bits);
 955                        if (state->have == 0) {
 956                            strm->msg = (char *)"invalid bit length repeat";
 957                            state->mode = BAD;
 958                            break;
 959                        }
 960                        len = state->lens[state->have - 1];
 961                        copy = 3 + BITS(2);
 962                        DROPBITS(2);
 963                    }
 964                    else if (here.val == 17) {
 965                        NEEDBITS(here.bits + 3);
 966                        DROPBITS(here.bits);
 967                        len = 0;
 968                        copy = 3 + BITS(3);
 969                        DROPBITS(3);
 970                    }
 971                    else {
 972                        NEEDBITS(here.bits + 7);
 973                        DROPBITS(here.bits);
 974                        len = 0;
 975                        copy = 11 + BITS(7);
 976                        DROPBITS(7);
 977                    }
 978                    if (state->have + copy > state->nlen + state->ndist) {
 979                        strm->msg = (char *)"invalid bit length repeat";
 980                        state->mode = BAD;
 981                        break;
 982                    }
 983                    while (copy--)
 984                        state->lens[state->have++] = (unsigned short)len;
 985                }
 986            }
 987
 988            /* handle error breaks in while */
 989            if (state->mode == BAD) break;
 990
 991            /* check for end-of-block code (better have one) */
 992            if (state->lens[256] == 0) {
 993                strm->msg = (char *)"invalid code -- missing end-of-block";
 994                state->mode = BAD;
 995                break;
 996            }
 997
 998            /* build code tables -- note: do not change the lenbits or distbits
 999               values here (9 and 6) without reading the comments in inftrees.h
1000               concerning the ENOUGH constants, which depend on those values */
1001            state->next = state->codes;
1002            state->lencode = (code const FAR *)(state->next);
1003            state->lenbits = 9;
1004            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1005                                &(state->lenbits), state->work);
1006            if (ret) {
1007                strm->msg = (char *)"invalid literal/lengths set";
1008                state->mode = BAD;
1009                break;
1010            }
1011            state->distcode = (code const FAR *)(state->next);
1012            state->distbits = 6;
1013            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1014                            &(state->next), &(state->distbits), state->work);
1015            if (ret) {
1016                strm->msg = (char *)"invalid distances set";
1017                state->mode = BAD;
1018                break;
1019            }
1020            Tracev((stderr, "inflate:       codes ok\n"));
1021            state->mode = LEN_;
1022            if (flush == Z_TREES) goto inf_leave;
1023        case LEN_:
1024            state->mode = LEN;
1025        case LEN:
1026            if (have >= 6 && left >= 258) {
1027                RESTORE();
1028                inflate_fast(strm, out);
1029                LOAD();
1030                if (state->mode == TYPE)
1031                    state->back = -1;
1032                break;
1033            }
1034            state->back = 0;
1035            for (;;) {
1036                here = state->lencode[BITS(state->lenbits)];
1037                if ((unsigned)(here.bits) <= bits) break;
1038                PULLBYTE();
1039            }
1040            if (here.op && (here.op & 0xf0) == 0) {
1041                last = here;
1042                for (;;) {
1043                    here = state->lencode[last.val +
1044                            (BITS(last.bits + last.op) >> last.bits)];
1045                    if ((unsigned)(last.bits + here.bits) <= bits) break;
1046                    PULLBYTE();
1047                }
1048                DROPBITS(last.bits);
1049                state->back += last.bits;
1050            }
1051            DROPBITS(here.bits);
1052            state->back += here.bits;
1053            state->length = (unsigned)here.val;
1054            if ((int)(here.op) == 0) {
1055                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
1056                        "inflate:         literal '%c'\n" :
1057                        "inflate:         literal 0x%02x\n", here.val));
1058                state->mode = LIT;
1059                break;
1060            }
1061            if (here.op & 32) {
1062                Tracevv((stderr, "inflate:         end of block\n"));
1063                state->back = -1;
1064                state->mode = TYPE;
1065                break;
1066            }
1067            if (here.op & 64) {
1068                strm->msg = (char *)"invalid literal/length code";
1069                state->mode = BAD;
1070                break;
1071            }
1072            state->extra = (unsigned)(here.op) & 15;
1073            state->mode = LENEXT;
1074        case LENEXT:
1075            if (state->extra) {
1076                NEEDBITS(state->extra);
1077                state->length += BITS(state->extra);
1078                DROPBITS(state->extra);
1079                state->back += state->extra;
1080            }
1081            Tracevv((stderr, "inflate:         length %u\n", state->length));
1082            state->was = state->length;
1083            state->mode = DIST;
1084        case DIST:
1085            for (;;) {
1086                here = state->distcode[BITS(state->distbits)];
1087                if ((unsigned)(here.bits) <= bits) break;
1088                PULLBYTE();
1089            }
1090            if ((here.op & 0xf0) == 0) {
1091                last = here;
1092                for (;;) {
1093                    here = state->distcode[last.val +
1094                            (BITS(last.bits + last.op) >> last.bits)];
1095                    if ((unsigned)(last.bits + here.bits) <= bits) break;
1096                    PULLBYTE();
1097                }
1098                DROPBITS(last.bits);
1099                state->back += last.bits;
1100            }
1101            DROPBITS(here.bits);
1102            state->back += here.bits;
1103            if (here.op & 64) {
1104                strm->msg = (char *)"invalid distance code";
1105                state->mode = BAD;
1106                break;
1107            }
1108            state->offset = (unsigned)here.val;
1109            state->extra = (unsigned)(here.op) & 15;
1110            state->mode = DISTEXT;
1111        case DISTEXT:
1112            if (state->extra) {
1113                NEEDBITS(state->extra);
1114                state->offset += BITS(state->extra);
1115                DROPBITS(state->extra);
1116                state->back += state->extra;
1117            }
1118#ifdef INFLATE_STRICT
1119            if (state->offset > state->dmax) {
1120                strm->msg = (char *)"invalid distance too far back";
1121                state->mode = BAD;
1122                break;
1123            }
1124#endif
1125            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
1126            state->mode = MATCH;
1127        case MATCH:
1128            if (left == 0) goto inf_leave;
1129            copy = out - left;
1130            if (state->offset > copy) {         /* copy from window */
1131                copy = state->offset - copy;
1132                if (copy > state->whave) {
1133                    if (state->sane) {
1134                        strm->msg = (char *)"invalid distance too far back";
1135                        state->mode = BAD;
1136                        break;
1137                    }
1138#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
1139                    Trace((stderr, "inflate.c too far\n"));
1140                    copy -= state->whave;
1141                    if (copy > state->length) copy = state->length;
1142                    if (copy > left) copy = left;
1143                    left -= copy;
1144                    state->length -= copy;
1145                    do {
1146                        *put++ = 0;
1147                    } while (--copy);
1148                    if (state->length == 0) state->mode = LEN;
1149                    break;
1150#endif
1151                }
1152                if (copy > state->wnext) {
1153                    copy -= state->wnext;
1154                    from = state->window + (state->wsize - copy);
1155                }
1156                else
1157                    from = state->window + (state->wnext - copy);
1158                if (copy > state->length) copy = state->length;
1159            }
1160            else {                              /* copy from output */
1161                from = put - state->offset;
1162                copy = state->length;
1163            }
1164            if (copy > left) copy = left;
1165            left -= copy;
1166            state->length -= copy;
1167            do {
1168                *put++ = *from++;
1169            } while (--copy);
1170            if (state->length == 0) state->mode = LEN;
1171            break;
1172        case LIT:
1173            if (left == 0) goto inf_leave;
1174            *put++ = (unsigned char)(state->length);
1175            left--;
1176            state->mode = LEN;
1177            break;
1178        case CHECK:
1179            if (state->wrap) {
1180                NEEDBITS(32);
1181                out -= left;
1182                strm->total_out += out;
1183                state->total += out;
1184                if (out)
1185                    strm->adler = state->check =
1186                        UPDATE(state->check, put - out, out);
1187                out = left;
1188                if ((
1189#ifdef GUNZIP
1190                     state->flags ? hold :
1191#endif
1192                     REVERSE(hold)) != state->check) {
1193                    strm->msg = (char *)"incorrect data check";
1194                    state->mode = BAD;
1195                    break;
1196                }
1197                INITBITS();
1198                Tracev((stderr, "inflate:   check matches trailer\n"));
1199            }
1200#ifdef GUNZIP
1201            state->mode = LENGTH;
1202        case LENGTH:
1203            if (state->wrap && state->flags) {
1204                NEEDBITS(32);
1205                if (hold != (state->total & 0xffffffffUL)) {
1206                    strm->msg = (char *)"incorrect length check";
1207                    state->mode = BAD;
1208                    break;
1209                }
1210                INITBITS();
1211                Tracev((stderr, "inflate:   length matches trailer\n"));
1212            }
1213#endif
1214            state->mode = DONE;
1215        case DONE:
1216            ret = Z_STREAM_END;
1217            goto inf_leave;
1218        case BAD:
1219            ret = Z_DATA_ERROR;
1220            goto inf_leave;
1221        case MEM:
1222            return Z_MEM_ERROR;
1223        case SYNC:
1224        default:
1225            return Z_STREAM_ERROR;
1226        }
1227
1228    /*
1229       Return from inflate(), updating the total counts and the check value.
1230       If there was no progress during the inflate() call, return a buffer
1231       error.  Call updatewindow() to create and/or update the window state.
1232       Note: a memory error from inflate() is non-recoverable.
1233     */
1234  inf_leave:
1235    RESTORE();
1236    if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1237            (state->mode < CHECK || flush != Z_FINISH)))
1238        if (updatewindow(strm, out)) {
1239            state->mode = MEM;
1240            return Z_MEM_ERROR;
1241        }
1242    in -= strm->avail_in;
1243    out -= strm->avail_out;
1244    strm->total_in += in;
1245    strm->total_out += out;
1246    state->total += out;
1247    if (state->wrap && out)
1248        strm->adler = state->check =
1249            UPDATE(state->check, strm->next_out - out, out);
1250    strm->data_type = state->bits + (state->last ? 64 : 0) +
1251                      (state->mode == TYPE ? 128 : 0) +
1252                      (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1253    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
1254        ret = Z_BUF_ERROR;
1255    return ret;
1256}
1257
1258int ZEXPORT inflateEnd(strm)
1259z_streamp strm;
1260{
1261    struct inflate_state FAR *state;
1262    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1263        return Z_STREAM_ERROR;
1264    state = (struct inflate_state FAR *)strm->state;
1265    if (state->window != Z_NULL) ZFREE(strm, state->window);
1266    ZFREE(strm, strm->state);
1267    strm->state = Z_NULL;
1268    Tracev((stderr, "inflate: end\n"));
1269    return Z_OK;
1270}
1271
1272int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
1273z_streamp strm;
1274const Bytef *dictionary;
1275uInt dictLength;
1276{
1277    struct inflate_state FAR *state;
1278    unsigned long id;
1279    unsigned char *next;
1280    unsigned avail;
1281    int ret;
1282
1283    /* check state */
1284    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1285    state = (struct inflate_state FAR *)strm->state;
1286    if (state->wrap != 0 && state->mode != DICT)
1287        return Z_STREAM_ERROR;
1288
1289    /* check for correct dictionary id */
1290    if (state->mode == DICT) {
1291        id = adler32(0L, Z_NULL, 0);
1292        id = adler32(id, dictionary, dictLength);
1293        if (id != state->check)
1294            return Z_DATA_ERROR;
1295    }
1296
1297    /* copy dictionary to window using updatewindow(), which will amend the
1298       existing dictionary if appropriate */
1299    next = strm->next_out;
1300    avail = strm->avail_out;
1301    strm->next_out = (Bytef *)dictionary + dictLength;
1302    strm->avail_out = 0;
1303    ret = updatewindow(strm, dictLength);
1304    strm->avail_out = avail;
1305    strm->next_out = next;
1306    if (ret) {
1307        state->mode = MEM;
1308        return Z_MEM_ERROR;
1309    }
1310    state->havedict = 1;
1311    Tracev((stderr, "inflate:   dictionary set\n"));
1312    return Z_OK;
1313}
1314
1315int ZEXPORT inflateGetHeader(strm, head)
1316z_streamp strm;
1317gz_headerp head;
1318{
1319    struct inflate_state FAR *state;
1320
1321    /* check state */
1322    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1323    state = (struct inflate_state FAR *)strm->state;
1324    if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1325
1326    /* save header structure */
1327    state->head = head;
1328    head->done = 0;
1329    return Z_OK;
1330}
1331
1332/*
1333   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
1334   or when out of input.  When called, *have is the number of pattern bytes
1335   found in order so far, in 0..3.  On return *have is updated to the new
1336   state.  If on return *have equals four, then the pattern was found and the
1337   return value is how many bytes were read including the last byte of the
1338   pattern.  If *have is less than four, then the pattern has not been found
1339   yet and the return value is len.  In the latter case, syncsearch() can be
1340   called again with more data and the *have state.  *have is initialized to
1341   zero for the first call.
1342 */
1343local unsigned syncsearch(have, buf, len)
1344unsigned FAR *have;
1345unsigned char FAR *buf;
1346unsigned len;
1347{
1348    unsigned got;
1349    unsigned next;
1350
1351    got = *have;
1352    next = 0;
1353    while (next < len && got < 4) {
1354        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
1355            got++;
1356        else if (buf[next])
1357            got = 0;
1358        else
1359            got = 4 - got;
1360        next++;
1361    }
1362    *have = got;
1363    return next;
1364}
1365
1366int ZEXPORT inflateSync(strm)
1367z_streamp strm;
1368{
1369    unsigned len;               /* number of bytes to look at or looked at */
1370    unsigned long in, out;      /* temporary to save total_in and total_out */
1371    unsigned char buf[4];       /* to restore bit buffer to byte string */
1372    struct inflate_state FAR *state;
1373
1374    /* check parameters */
1375    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1376    state = (struct inflate_state FAR *)strm->state;
1377    if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1378
1379    /* if first time, start search in bit buffer */
1380    if (state->mode != SYNC) {
1381        state->mode = SYNC;
1382        state->hold <<= state->bits & 7;
1383        state->bits -= state->bits & 7;
1384        len = 0;
1385        while (state->bits >= 8) {
1386            buf[len++] = (unsigned char)(state->hold);
1387            state->hold >>= 8;
1388            state->bits -= 8;
1389        }
1390        state->have = 0;
1391        syncsearch(&(state->have), buf, len);
1392    }
1393
1394    /* search available input */
1395    len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1396    strm->avail_in -= len;
1397    strm->next_in += len;
1398    strm->total_in += len;
1399
1400    /* return no joy or set up to restart inflate() on a new block */
1401    if (state->have != 4) return Z_DATA_ERROR;
1402    in = strm->total_in;  out = strm->total_out;
1403    inflateReset(strm);
1404  

Large files files are truncated, but you can click here to view the full file