root/lib/zlib_inflate/inflate.c

DEFINITIONS

1. zlib_inflate_workspacesize
2. zlib_inflateReset
3. zlib_inflateInit2
4. zlib_fixedtables
5. zlib_updatewindow
6. zlib_inflateSyncPacket
7. zlib_inflate
8. zlib_inflateEnd
9. zlib_inflateIncomp

   1 /* inflate.c -- zlib decompression
   2  * Copyright (C) 1995-2005 Mark Adler
   3  * For conditions of distribution and use, see copyright notice in zlib.h
   4  *
   5  * Based on zlib 1.2.3 but modified for the Linux Kernel by
   6  * Richard Purdie <richard@openedhand.com>
   7  *
   8  * Changes mainly for static instead of dynamic memory allocation
   9  *
  10  */
  11 
  12 #include <linux/zutil.h>
  13 #include "inftrees.h"
  14 #include "inflate.h"
  15 #include "inffast.h"
  16 #include "infutil.h"
  17 
  18 int zlib_inflate_workspacesize(void)
  19 {
  20     return sizeof(struct inflate_workspace);
  21 }
  22 
  23 int zlib_inflateReset(z_streamp strm)
  24 {
  25     struct inflate_state *state;
  26 
  27     if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
  28     state = (struct inflate_state *)strm->state;
  29     strm->total_in = strm->total_out = state->total = 0;
  30     strm->msg = NULL;
  31     strm->adler = 1;        /* to support ill-conceived Java test suite */
  32     state->mode = HEAD;
  33     state->last = 0;
  34     state->havedict = 0;
  35     state->dmax = 32768U;
  36     state->hold = 0;
  37     state->bits = 0;
  38     state->lencode = state->distcode = state->next = state->codes;
  39 
  40     /* Initialise Window */
  41     state->wsize = 1U << state->wbits;
  42     state->write = 0;
  43     state->whave = 0;
  44 
  45     return Z_OK;
  46 }
  47 
  48 int zlib_inflateInit2(z_streamp strm, int windowBits)
  49 {
  50     struct inflate_state *state;
  51 
  52     if (strm == NULL) return Z_STREAM_ERROR;
  53     strm->msg = NULL;                 /* in case we return an error */
  54 
  55     state = &WS(strm)->inflate_state;
  56     strm->state = (struct internal_state *)state;
  57 
  58     if (windowBits < 0) {
  59         state->wrap = 0;
  60         windowBits = -windowBits;
  61     }
  62     else {
  63         state->wrap = (windowBits >> 4) + 1;
  64     }
  65     if (windowBits < 8 || windowBits > 15) {
  66         return Z_STREAM_ERROR;
  67     }
  68     state->wbits = (unsigned)windowBits;
  69     state->window = &WS(strm)->working_window[0];
  70 
  71     return zlib_inflateReset(strm);
  72 }
  73 
  74 /*
  75    Return state with length and distance decoding tables and index sizes set to
  76    fixed code decoding.  This returns fixed tables from inffixed.h.
  77  */
  78 static void zlib_fixedtables(struct inflate_state *state)
  79 {
  80 #   include "inffixed.h"
  81     state->lencode = lenfix;
  82     state->lenbits = 9;
  83     state->distcode = distfix;
  84     state->distbits = 5;
  85 }
  86 
  87 
  88 /*
  89    Update the window with the last wsize (normally 32K) bytes written before
  90    returning. This is only called when a window is already in use, or when
  91    output has been written during this inflate call, but the end of the deflate
  92    stream has not been reached yet. It is also called to window dictionary data
  93    when a dictionary is loaded.
  94 
  95    Providing output buffers larger than 32K to inflate() should provide a speed
  96    advantage, since only the last 32K of output is copied to the sliding window
  97    upon return from inflate(), and since all distances after the first 32K of
  98    output will fall in the output data, making match copies simpler and faster.
  99    The advantage may be dependent on the size of the processor's data caches.
 100  */
 101 static void zlib_updatewindow(z_streamp strm, unsigned out)
 102 {
 103     struct inflate_state *state;
 104     unsigned copy, dist;
 105 
 106     state = (struct inflate_state *)strm->state;
 107 
 108     /* copy state->wsize or less output bytes into the circular window */
 109     copy = out - strm->avail_out;
 110     if (copy >= state->wsize) {
 111         memcpy(state->window, strm->next_out - state->wsize, state->wsize);
 112         state->write = 0;
 113         state->whave = state->wsize;
 114     }
 115     else {
 116         dist = state->wsize - state->write;
 117         if (dist > copy) dist = copy;
 118         memcpy(state->window + state->write, strm->next_out - copy, dist);
 119         copy -= dist;
 120         if (copy) {
 121             memcpy(state->window, strm->next_out - copy, copy);
 122             state->write = copy;
 123             state->whave = state->wsize;
 124         }
 125         else {
 126             state->write += dist;
 127             if (state->write == state->wsize) state->write = 0;
 128             if (state->whave < state->wsize) state->whave += dist;
 129         }
 130     }
 131 }
 132 
 133 
 134 /*
 135  * At the end of a Deflate-compressed PPP packet, we expect to have seen
 136  * a `stored' block type value but not the (zero) length bytes.
 137  */
 138 /*
 139    Returns true if inflate is currently at the end of a block generated by
 140    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
 141    implementation to provide an additional safety check. PPP uses
 142    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
 143    block. When decompressing, PPP checks that at the end of input packet,
 144    inflate is waiting for these length bytes.
 145  */
 146 static int zlib_inflateSyncPacket(z_streamp strm)
 147 {
 148     struct inflate_state *state;
 149 
 150     if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
 151     state = (struct inflate_state *)strm->state;
 152 
 153     if (state->mode == STORED && state->bits == 0) {
 154         state->mode = TYPE;
 155         return Z_OK;
 156     }
 157     return Z_DATA_ERROR;
 158 }
 159 
 160 /* Macros for inflate(): */
 161 
 162 /* check function to use adler32() for zlib or crc32() for gzip */
 163 #define UPDATE(check, buf, len) zlib_adler32(check, buf, len)
 164 
 165 /* Load registers with state in inflate() for speed */
 166 #define LOAD() \
 167     do { \
 168         put = strm->next_out; \
 169         left = strm->avail_out; \
 170         next = strm->next_in; \
 171         have = strm->avail_in; \
 172         hold = state->hold; \
 173         bits = state->bits; \
 174     } while (0)
 175 
 176 /* Restore state from registers in inflate() */
 177 #define RESTORE() \
 178     do { \
 179         strm->next_out = put; \
 180         strm->avail_out = left; \
 181         strm->next_in = next; \
 182         strm->avail_in = have; \
 183         state->hold = hold; \
 184         state->bits = bits; \
 185     } while (0)
 186 
 187 /* Clear the input bit accumulator */
 188 #define INITBITS() \
 189     do { \
 190         hold = 0; \
 191         bits = 0; \
 192     } while (0)
 193 
 194 /* Get a byte of input into the bit accumulator, or return from inflate()
 195    if there is no input available. */
 196 #define PULLBYTE() \
 197     do { \
 198         if (have == 0) goto inf_leave; \
 199         have--; \
 200         hold += (unsigned long)(*next++) << bits; \
 201         bits += 8; \
 202     } while (0)
 203 
 204 /* Assure that there are at least n bits in the bit accumulator.  If there is
 205    not enough available input to do that, then return from inflate(). */
 206 #define NEEDBITS(n) \
 207     do { \
 208         while (bits < (unsigned)(n)) \
 209             PULLBYTE(); \
 210     } while (0)
 211 
 212 /* Return the low n bits of the bit accumulator (n < 16) */
 213 #define BITS(n) \
 214     ((unsigned)hold & ((1U << (n)) - 1))
 215 
 216 /* Remove n bits from the bit accumulator */
 217 #define DROPBITS(n) \
 218     do { \
 219         hold >>= (n); \
 220         bits -= (unsigned)(n); \
 221     } while (0)
 222 
 223 /* Remove zero to seven bits as needed to go to a byte boundary */
 224 #define BYTEBITS() \
 225     do { \
 226         hold >>= bits & 7; \
 227         bits -= bits & 7; \
 228     } while (0)
 229 
 230 /* Reverse the bytes in a 32-bit value */
 231 #define REVERSE(q) \
 232     ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
 233      (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
 234 
 235 /*
 236    inflate() uses a state machine to process as much input data and generate as
 237    much output data as possible before returning.  The state machine is
 238    structured roughly as follows:
 239 
 240     for (;;) switch (state) {
 241     ...
 242     case STATEn:
 243         if (not enough input data or output space to make progress)
 244             return;
 245         ... make progress ...
 246         state = STATEm;
 247         break;
 248     ...
 249     }
 250 
 251    so when inflate() is called again, the same case is attempted again, and
 252    if the appropriate resources are provided, the machine proceeds to the
 253    next state.  The NEEDBITS() macro is usually the way the state evaluates
 254    whether it can proceed or should return.  NEEDBITS() does the return if
 255    the requested bits are not available.  The typical use of the BITS macros
 256    is:
 257 
 258         NEEDBITS(n);
 259         ... do something with BITS(n) ...
 260         DROPBITS(n);
 261 
 262    where NEEDBITS(n) either returns from inflate() if there isn't enough
 263    input left to load n bits into the accumulator, or it continues.  BITS(n)
 264    gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
 265    the low n bits off the accumulator.  INITBITS() clears the accumulator
 266    and sets the number of available bits to zero.  BYTEBITS() discards just
 267    enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
 268    and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
 269 
 270    NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
 271    if there is no input available.  The decoding of variable length codes uses
 272    PULLBYTE() directly in order to pull just enough bytes to decode the next
 273    code, and no more.
 274 
 275    Some states loop until they get enough input, making sure that enough
 276    state information is maintained to continue the loop where it left off
 277    if NEEDBITS() returns in the loop.  For example, want, need, and keep
 278    would all have to actually be part of the saved state in case NEEDBITS()
 279    returns:
 280 
 281     case STATEw:
 282         while (want < need) {
 283             NEEDBITS(n);
 284             keep[want++] = BITS(n);
 285             DROPBITS(n);
 286         }
 287         state = STATEx;
 288     case STATEx:
 289 
 290    As shown above, if the next state is also the next case, then the break
 291    is omitted.
 292 
 293    A state may also return if there is not enough output space available to
 294    complete that state.  Those states are copying stored data, writing a
 295    literal byte, and copying a matching string.
 296 
 297    When returning, a "goto inf_leave" is used to update the total counters,
 298    update the check value, and determine whether any progress has been made
 299    during that inflate() call in order to return the proper return code.
 300    Progress is defined as a change in either strm->avail_in or strm->avail_out.
 301    When there is a window, goto inf_leave will update the window with the last
 302    output written.  If a goto inf_leave occurs in the middle of decompression
 303    and there is no window currently, goto inf_leave will create one and copy
 304    output to the window for the next call of inflate().
 305 
 306    In this implementation, the flush parameter of inflate() only affects the
 307    return code (per zlib.h).  inflate() always writes as much as possible to
 308    strm->next_out, given the space available and the provided input--the effect
 309    documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
 310    the allocation of and copying into a sliding window until necessary, which
 311    provides the effect documented in zlib.h for Z_FINISH when the entire input
 312    stream available.  So the only thing the flush parameter actually does is:
 313    when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
 314    will return Z_BUF_ERROR if it has not reached the end of the stream.
 315  */
 316 
 317 int zlib_inflate(z_streamp strm, int flush)
 318 {
 319     struct inflate_state *state;
 320     const unsigned char *next;  /* next input */
 321     unsigned char *put;         /* next output */
 322     unsigned have, left;        /* available input and output */
 323     unsigned long hold;         /* bit buffer */
 324     unsigned bits;              /* bits in bit buffer */
 325     unsigned in, out;           /* save starting available input and output */
 326     unsigned copy;              /* number of stored or match bytes to copy */
 327     unsigned char *from;        /* where to copy match bytes from */
 328     code this;                  /* current decoding table entry */
 329     code last;                  /* parent table entry */
 330     unsigned len;               /* length to copy for repeats, bits to drop */
 331     int ret;                    /* return code */
 332     static const unsigned short order[19] = /* permutation of code lengths */
 333         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 334 
 335     /* Do not check for strm->next_out == NULL here as ppc zImage
 336        inflates to strm->next_out = 0 */
 337 
 338     if (strm == NULL || strm->state == NULL ||
 339         (strm->next_in == NULL && strm->avail_in != 0))
 340         return Z_STREAM_ERROR;
 341 
 342     state = (struct inflate_state *)strm->state;
 343 
 344     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
 345     LOAD();
 346     in = have;
 347     out = left;
 348     ret = Z_OK;
 349     for (;;)
 350         switch (state->mode) {
 351         case HEAD:
 352             if (state->wrap == 0) {
 353                 state->mode = TYPEDO;
 354                 break;
 355             }
 356             NEEDBITS(16);
 357             if (
 358                 ((BITS(8) << 8) + (hold >> 8)) % 31) {
 359                 strm->msg = (char *)"incorrect header check";
 360                 state->mode = BAD;
 361                 break;
 362             }
 363             if (BITS(4) != Z_DEFLATED) {
 364                 strm->msg = (char *)"unknown compression method";
 365                 state->mode = BAD;
 366                 break;
 367             }
 368             DROPBITS(4);
 369             len = BITS(4) + 8;
 370             if (len > state->wbits) {
 371                 strm->msg = (char *)"invalid window size";
 372                 state->mode = BAD;
 373                 break;
 374             }
 375             state->dmax = 1U << len;
 376             strm->adler = state->check = zlib_adler32(0L, NULL, 0);
 377             state->mode = hold & 0x200 ? DICTID : TYPE;
 378             INITBITS();
 379             break;
 380         case DICTID:
 381             NEEDBITS(32);
 382             strm->adler = state->check = REVERSE(hold);
 383             INITBITS();
 384             state->mode = DICT;
 385             /* fall through */
 386         case DICT:
 387             if (state->havedict == 0) {
 388                 RESTORE();
 389                 return Z_NEED_DICT;
 390             }
 391             strm->adler = state->check = zlib_adler32(0L, NULL, 0);
 392             state->mode = TYPE;
 393             /* fall through */
 394         case TYPE:
 395             if (flush == Z_BLOCK) goto inf_leave;
 396             /* fall through */
 397         case TYPEDO:
 398             if (state->last) {
 399                 BYTEBITS();
 400                 state->mode = CHECK;
 401                 break;
 402             }
 403             NEEDBITS(3);
 404             state->last = BITS(1);
 405             DROPBITS(1);
 406             switch (BITS(2)) {
 407             case 0:                             /* stored block */
 408                 state->mode = STORED;
 409                 break;
 410             case 1:                             /* fixed block */
 411                 zlib_fixedtables(state);
 412                 state->mode = LEN;              /* decode codes */
 413                 break;
 414             case 2:                             /* dynamic block */
 415                 state->mode = TABLE;
 416                 break;
 417             case 3:
 418                 strm->msg = (char *)"invalid block type";
 419                 state->mode = BAD;
 420             }
 421             DROPBITS(2);
 422             break;
 423         case STORED:
 424             BYTEBITS();                         /* go to byte boundary */
 425             NEEDBITS(32);
 426             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 427                 strm->msg = (char *)"invalid stored block lengths";
 428                 state->mode = BAD;
 429                 break;
 430             }
 431             state->length = (unsigned)hold & 0xffff;
 432             INITBITS();
 433             state->mode = COPY;
 434             /* fall through */
 435         case COPY:
 436             copy = state->length;
 437             if (copy) {
 438                 if (copy > have) copy = have;
 439                 if (copy > left) copy = left;
 440                 if (copy == 0) goto inf_leave;
 441                 memcpy(put, next, copy);
 442                 have -= copy;
 443                 next += copy;
 444                 left -= copy;
 445                 put += copy;
 446                 state->length -= copy;
 447                 break;
 448             }
 449             state->mode = TYPE;
 450             break;
 451         case TABLE:
 452             NEEDBITS(14);
 453             state->nlen = BITS(5) + 257;
 454             DROPBITS(5);
 455             state->ndist = BITS(5) + 1;
 456             DROPBITS(5);
 457             state->ncode = BITS(4) + 4;
 458             DROPBITS(4);
 459 #ifndef PKZIP_BUG_WORKAROUND
 460             if (state->nlen > 286 || state->ndist > 30) {
 461                 strm->msg = (char *)"too many length or distance symbols";
 462                 state->mode = BAD;
 463                 break;
 464             }
 465 #endif
 466             state->have = 0;
 467             state->mode = LENLENS;
 468             /* fall through */
 469         case LENLENS:
 470             while (state->have < state->ncode) {
 471                 NEEDBITS(3);
 472                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
 473                 DROPBITS(3);
 474             }
 475             while (state->have < 19)
 476                 state->lens[order[state->have++]] = 0;
 477             state->next = state->codes;
 478             state->lencode = (code const *)(state->next);
 479             state->lenbits = 7;
 480             ret = zlib_inflate_table(CODES, state->lens, 19, &(state->next),
 481                                 &(state->lenbits), state->work);
 482             if (ret) {
 483                 strm->msg = (char *)"invalid code lengths set";
 484                 state->mode = BAD;
 485                 break;
 486             }
 487             state->have = 0;
 488             state->mode = CODELENS;
 489             /* fall through */
 490         case CODELENS:
 491             while (state->have < state->nlen + state->ndist) {
 492                 for (;;) {
 493                     this = state->lencode[BITS(state->lenbits)];
 494                     if ((unsigned)(this.bits) <= bits) break;
 495                     PULLBYTE();
 496                 }
 497                 if (this.val < 16) {
 498                     NEEDBITS(this.bits);
 499                     DROPBITS(this.bits);
 500                     state->lens[state->have++] = this.val;
 501                 }
 502                 else {
 503                     if (this.val == 16) {
 504                         NEEDBITS(this.bits + 2);
 505                         DROPBITS(this.bits);
 506                         if (state->have == 0) {
 507                             strm->msg = (char *)"invalid bit length repeat";
 508                             state->mode = BAD;
 509                             break;
 510                         }
 511                         len = state->lens[state->have - 1];
 512                         copy = 3 + BITS(2);
 513                         DROPBITS(2);
 514                     }
 515                     else if (this.val == 17) {
 516                         NEEDBITS(this.bits + 3);
 517                         DROPBITS(this.bits);
 518                         len = 0;
 519                         copy = 3 + BITS(3);
 520                         DROPBITS(3);
 521                     }
 522                     else {
 523                         NEEDBITS(this.bits + 7);
 524                         DROPBITS(this.bits);
 525                         len = 0;
 526                         copy = 11 + BITS(7);
 527                         DROPBITS(7);
 528                     }
 529                     if (state->have + copy > state->nlen + state->ndist) {
 530                         strm->msg = (char *)"invalid bit length repeat";
 531                         state->mode = BAD;
 532                         break;
 533                     }
 534                     while (copy--)
 535                         state->lens[state->have++] = (unsigned short)len;
 536                 }
 537             }
 538 
 539             /* handle error breaks in while */
 540             if (state->mode == BAD) break;
 541 
 542             /* build code tables */
 543             state->next = state->codes;
 544             state->lencode = (code const *)(state->next);
 545             state->lenbits = 9;
 546             ret = zlib_inflate_table(LENS, state->lens, state->nlen, &(state->next),
 547                                 &(state->lenbits), state->work);
 548             if (ret) {
 549                 strm->msg = (char *)"invalid literal/lengths set";
 550                 state->mode = BAD;
 551                 break;
 552             }
 553             state->distcode = (code const *)(state->next);
 554             state->distbits = 6;
 555             ret = zlib_inflate_table(DISTS, state->lens + state->nlen, state->ndist,
 556                             &(state->next), &(state->distbits), state->work);
 557             if (ret) {
 558                 strm->msg = (char *)"invalid distances set";
 559                 state->mode = BAD;
 560                 break;
 561             }
 562             state->mode = LEN;
 563             /* fall through */
 564         case LEN:
 565             if (have >= 6 && left >= 258) {
 566                 RESTORE();
 567                 inflate_fast(strm, out);
 568                 LOAD();
 569                 break;
 570             }
 571             for (;;) {
 572                 this = state->lencode[BITS(state->lenbits)];
 573                 if ((unsigned)(this.bits) <= bits) break;
 574                 PULLBYTE();
 575             }
 576             if (this.op && (this.op & 0xf0) == 0) {
 577                 last = this;
 578                 for (;;) {
 579                     this = state->lencode[last.val +
 580                             (BITS(last.bits + last.op) >> last.bits)];
 581                     if ((unsigned)(last.bits + this.bits) <= bits) break;
 582                     PULLBYTE();
 583                 }
 584                 DROPBITS(last.bits);
 585             }
 586             DROPBITS(this.bits);
 587             state->length = (unsigned)this.val;
 588             if ((int)(this.op) == 0) {
 589                 state->mode = LIT;
 590                 break;
 591             }
 592             if (this.op & 32) {
 593                 state->mode = TYPE;
 594                 break;
 595             }
 596             if (this.op & 64) {
 597                 strm->msg = (char *)"invalid literal/length code";
 598                 state->mode = BAD;
 599                 break;
 600             }
 601             state->extra = (unsigned)(this.op) & 15;
 602             state->mode = LENEXT;
 603             /* fall through */
 604         case LENEXT:
 605             if (state->extra) {
 606                 NEEDBITS(state->extra);
 607                 state->length += BITS(state->extra);
 608                 DROPBITS(state->extra);
 609             }
 610             state->mode = DIST;
 611             /* fall through */
 612         case DIST:
 613             for (;;) {
 614                 this = state->distcode[BITS(state->distbits)];
 615                 if ((unsigned)(this.bits) <= bits) break;
 616                 PULLBYTE();
 617             }
 618             if ((this.op & 0xf0) == 0) {
 619                 last = this;
 620                 for (;;) {
 621                     this = state->distcode[last.val +
 622                             (BITS(last.bits + last.op) >> last.bits)];
 623                     if ((unsigned)(last.bits + this.bits) <= bits) break;
 624                     PULLBYTE();
 625                 }
 626                 DROPBITS(last.bits);
 627             }
 628             DROPBITS(this.bits);
 629             if (this.op & 64) {
 630                 strm->msg = (char *)"invalid distance code";
 631                 state->mode = BAD;
 632                 break;
 633             }
 634             state->offset = (unsigned)this.val;
 635             state->extra = (unsigned)(this.op) & 15;
 636             state->mode = DISTEXT;
 637             /* fall through */
 638         case DISTEXT:
 639             if (state->extra) {
 640                 NEEDBITS(state->extra);
 641                 state->offset += BITS(state->extra);
 642                 DROPBITS(state->extra);
 643             }
 644 #ifdef INFLATE_STRICT
 645             if (state->offset > state->dmax) {
 646                 strm->msg = (char *)"invalid distance too far back";
 647                 state->mode = BAD;
 648                 break;
 649             }
 650 #endif
 651             if (state->offset > state->whave + out - left) {
 652                 strm->msg = (char *)"invalid distance too far back";
 653                 state->mode = BAD;
 654                 break;
 655             }
 656             state->mode = MATCH;
 657             /* fall through */
 658         case MATCH:
 659             if (left == 0) goto inf_leave;
 660             copy = out - left;
 661             if (state->offset > copy) {         /* copy from window */
 662                 copy = state->offset - copy;
 663                 if (copy > state->write) {
 664                     copy -= state->write;
 665                     from = state->window + (state->wsize - copy);
 666                 }
 667                 else
 668                     from = state->window + (state->write - copy);
 669                 if (copy > state->length) copy = state->length;
 670             }
 671             else {                              /* copy from output */
 672                 from = put - state->offset;
 673                 copy = state->length;
 674             }
 675             if (copy > left) copy = left;
 676             left -= copy;
 677             state->length -= copy;
 678             do {
 679                 *put++ = *from++;
 680             } while (--copy);
 681             if (state->length == 0) state->mode = LEN;
 682             break;
 683         case LIT:
 684             if (left == 0) goto inf_leave;
 685             *put++ = (unsigned char)(state->length);
 686             left--;
 687             state->mode = LEN;
 688             break;
 689         case CHECK:
 690             if (state->wrap) {
 691                 NEEDBITS(32);
 692                 out -= left;
 693                 strm->total_out += out;
 694                 state->total += out;
 695                 if (out)
 696                     strm->adler = state->check =
 697                         UPDATE(state->check, put - out, out);
 698                 out = left;
 699                 if ((
 700                      REVERSE(hold)) != state->check) {
 701                     strm->msg = (char *)"incorrect data check";
 702                     state->mode = BAD;
 703                     break;
 704                 }
 705                 INITBITS();
 706             }
 707             state->mode = DONE;
 708             /* fall through */
 709         case DONE:
 710             ret = Z_STREAM_END;
 711             goto inf_leave;
 712         case BAD:
 713             ret = Z_DATA_ERROR;
 714             goto inf_leave;
 715         case MEM:
 716             return Z_MEM_ERROR;
 717         case SYNC:
 718         default:
 719             return Z_STREAM_ERROR;
 720         }
 721 
 722     /*
 723        Return from inflate(), updating the total counts and the check value.
 724        If there was no progress during the inflate() call, return a buffer
 725        error.  Call zlib_updatewindow() to create and/or update the window state.
 726      */
 727   inf_leave:
 728     RESTORE();
 729     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
 730         zlib_updatewindow(strm, out);
 731 
 732     in -= strm->avail_in;
 733     out -= strm->avail_out;
 734     strm->total_in += in;
 735     strm->total_out += out;
 736     state->total += out;
 737     if (state->wrap && out)
 738         strm->adler = state->check =
 739             UPDATE(state->check, strm->next_out - out, out);
 740 
 741     strm->data_type = state->bits + (state->last ? 64 : 0) +
 742                       (state->mode == TYPE ? 128 : 0);
 743 
 744     if (flush == Z_PACKET_FLUSH && ret == Z_OK &&
 745             strm->avail_out != 0 && strm->avail_in == 0)
 746                 return zlib_inflateSyncPacket(strm);
 747 
 748     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
 749         ret = Z_BUF_ERROR;
 750 
 751     return ret;
 752 }
 753 
 754 int zlib_inflateEnd(z_streamp strm)
 755 {
 756     if (strm == NULL || strm->state == NULL)
 757         return Z_STREAM_ERROR;
 758     return Z_OK;
 759 }
 760 
 761 /*
 762  * This subroutine adds the data at next_in/avail_in to the output history
 763  * without performing any output.  The output buffer must be "caught up";
 764  * i.e. no pending output but this should always be the case. The state must
 765  * be waiting on the start of a block (i.e. mode == TYPE or HEAD).  On exit,
 766  * the output will also be caught up, and the checksum will have been updated
 767  * if need be.
 768  */
 769 int zlib_inflateIncomp(z_stream *z)
 770 {
 771     struct inflate_state *state = (struct inflate_state *)z->state;
 772     Byte *saved_no = z->next_out;
 773     uInt saved_ao = z->avail_out;
 774 
 775     if (state->mode != TYPE && state->mode != HEAD)
 776         return Z_DATA_ERROR;
 777 
 778     /* Setup some variables to allow misuse of updateWindow */
 779     z->avail_out = 0;
 780     z->next_out = (unsigned char*)z->next_in + z->avail_in;
 781 
 782     zlib_updatewindow(z, z->avail_in);
 783 
 784     /* Restore saved variables */
 785     z->avail_out = saved_ao;
 786     z->next_out = saved_no;
 787 
 788     z->adler = state->check =
 789         UPDATE(state->check, z->next_in, z->avail_in);
 790 
 791     z->total_out += z->avail_in;
 792     z->total_in += z->avail_in;
 793     z->next_in += z->avail_in;
 794     state->total += z->avail_in;
 795     z->avail_in = 0;
 796 
 797     return Z_OK;
 798 }