PageRenderTime 113ms CodeModel.GetById 26ms app.highlight 75ms RepoModel.GetById 1ms app.codeStats 1ms

/src/zlib/inflate.c

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

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