lib/zlib_inflate/inflate.c

   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         case DICT:
 386             if (state->havedict == 0) {
 387                 RESTORE();
 388                 return Z_NEED_DICT;
 389             }
 390             strm->adler = state->check = zlib_adler32(0L, NULL, 0);
 391             state->mode = TYPE;
 392         case TYPE:
 393             if (flush == Z_BLOCK) goto inf_leave;
 394         case TYPEDO:
 395             if (state->last) {
 396                 BYTEBITS();
 397                 state->mode = CHECK;
 398                 break;
 399             }
 400             NEEDBITS(3);
 401             state->last = BITS(1);
 402             DROPBITS(1);
 403             switch (BITS(2)) {
 404             case 0:                             /* stored block */
 405                 state->mode = STORED;
 406                 break;
 407             case 1:                             /* fixed block */
 408                 zlib_fixedtables(state);
 409                 state->mode = LEN;              /* decode codes */
 410                 break;
 411             case 2:                             /* dynamic block */
 412                 state->mode = TABLE;
 413                 break;
 414             case 3:
 415                 strm->msg = (char *)"invalid block type";
 416                 state->mode = BAD;
 417             }
 418             DROPBITS(2);
 419             break;
 420         case STORED:
 421             BYTEBITS();                         /* go to byte boundary */
 422             NEEDBITS(32);
 423             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 424                 strm->msg = (char *)"invalid stored block lengths";
 425                 state->mode = BAD;
 426                 break;
 427             }
 428             state->length = (unsigned)hold & 0xffff;
 429             INITBITS();
 430             state->mode = COPY;
 431         case COPY:
 432             copy = state->length;
 433             if (copy) {
 434                 if (copy > have) copy = have;
 435                 if (copy > left) copy = left;
 436                 if (copy == 0) goto inf_leave;
 437                 memcpy(put, next, copy);
 438                 have -= copy;
 439                 next += copy;
 440                 left -= copy;
 441                 put += copy;
 442                 state->length -= copy;
 443                 break;
 444             }
 445             state->mode = TYPE;
 446             break;
 447         case TABLE:
 448             NEEDBITS(14);
 449             state->nlen = BITS(5) + 257;
 450             DROPBITS(5);
 451             state->ndist = BITS(5) + 1;
 452             DROPBITS(5);
 453             state->ncode = BITS(4) + 4;
 454             DROPBITS(4);
 455 #ifndef PKZIP_BUG_WORKAROUND
 456             if (state->nlen > 286 || state->ndist > 30) {
 457                 strm->msg = (char *)"too many length or distance symbols";
 458                 state->mode = BAD;
 459                 break;
 460             }
 461 #endif
 462             state->have = 0;
 463             state->mode = LENLENS;
 464         case LENLENS:
 465             while (state->have < state->ncode) {
 466                 NEEDBITS(3);
 467                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
 468                 DROPBITS(3);
 469             }
 470             while (state->have < 19)
 471                 state->lens[order[state->have++]] = 0;
 472             state->next = state->codes;
 473             state->lencode = (code const *)(state->next);
 474             state->lenbits = 7;
 475             ret = zlib_inflate_table(CODES, state->lens, 19, &(state->next),
 476                                 &(state->lenbits), state->work);
 477             if (ret) {
 478                 strm->msg = (char *)"invalid code lengths set";
 479                 state->mode = BAD;
 480                 break;
 481             }
 482             state->have = 0;
 483             state->mode = CODELENS;
 484         case CODELENS:
 485             while (state->have < state->nlen + state->ndist) {
 486                 for (;;) {
 487                     this = state->lencode[BITS(state->lenbits)];
 488                     if ((unsigned)(this.bits) <= bits) break;
 489                     PULLBYTE();
 490                 }
 491                 if (this.val < 16) {
 492                     NEEDBITS(this.bits);
 493                     DROPBITS(this.bits);
 494                     state->lens[state->have++] = this.val;
 495                 }
 496                 else {
 497                     if (this.val == 16) {
 498                         NEEDBITS(this.bits + 2);
 499                         DROPBITS(this.bits);
 500                         if (state->have == 0) {
 501                             strm->msg = (char *)"invalid bit length repeat";
 502                             state->mode = BAD;
 503                             break;
 504                         }
 505                         len = state->lens[state->have - 1];
 506                         copy = 3 + BITS(2);
 507                         DROPBITS(2);
 508                     }
 509                     else if (this.val == 17) {
 510                         NEEDBITS(this.bits + 3);
 511                         DROPBITS(this.bits);
 512                         len = 0;
 513                         copy = 3 + BITS(3);
 514                         DROPBITS(3);
 515                     }
 516                     else {
 517                         NEEDBITS(this.bits + 7);
 518                         DROPBITS(this.bits);
 519                         len = 0;
 520                         copy = 11 + BITS(7);
 521                         DROPBITS(7);
 522                     }
 523                     if (state->have + copy > state->nlen + state->ndist) {
 524                         strm->msg = (char *)"invalid bit length repeat";
 525                         state->mode = BAD;
 526                         break;
 527                     }
 528                     while (copy--)
 529                         state->lens[state->have++] = (unsigned short)len;
 530                 }
 531             }
 532
 533             /* handle error breaks in while */
 534             if (state->mode == BAD) break;
 535
 536             /* build code tables */
 537             state->next = state->codes;
 538             state->lencode = (code const *)(state->next);
 539             state->lenbits = 9;
 540             ret = zlib_inflate_table(LENS, state->lens, state->nlen, &(state->next),
 541                                 &(state->lenbits), state->work);
 542             if (ret) {
 543                 strm->msg = (char *)"invalid literal/lengths set";
 544                 state->mode = BAD;
 545                 break;
 546             }
 547             state->distcode = (code const *)(state->next);
 548             state->distbits = 6;
 549             ret = zlib_inflate_table(DISTS, state->lens + state->nlen, state->ndist,
 550                             &(state->next), &(state->distbits), state->work);
 551             if (ret) {
 552                 strm->msg = (char *)"invalid distances set";
 553                 state->mode = BAD;
 554                 break;
 555             }
 556             state->mode = LEN;
 557         case LEN:
 558             if (have >= 6 && left >= 258) {
 559                 RESTORE();
 560                 inflate_fast(strm, out);
 561                 LOAD();
 562                 break;
 563             }
 564             for (;;) {
 565                 this = state->lencode[BITS(state->lenbits)];
 566                 if ((unsigned)(this.bits) <= bits) break;
 567                 PULLBYTE();
 568             }
 569             if (this.op && (this.op & 0xf0) == 0) {
 570                 last = this;
 571                 for (;;) {
 572                     this = state->lencode[last.val +
 573                             (BITS(last.bits + last.op) >> last.bits)];
 574                     if ((unsigned)(last.bits + this.bits) <= bits) break;
 575                     PULLBYTE();
 576                 }
 577                 DROPBITS(last.bits);
 578             }
 579             DROPBITS(this.bits);
 580             state->length = (unsigned)this.val;
 581             if ((int)(this.op) == 0) {
 582                 state->mode = LIT;
 583                 break;
 584             }
 585             if (this.op & 32) {
 586                 state->mode = TYPE;
 587                 break;
 588             }
 589             if (this.op & 64) {
 590                 strm->msg = (char *)"invalid literal/length code";
 591                 state->mode = BAD;
 592                 break;
 593             }
 594             state->extra = (unsigned)(this.op) & 15;
 595             state->mode = LENEXT;
 596         case LENEXT:
 597             if (state->extra) {
 598                 NEEDBITS(state->extra);
 599                 state->length += BITS(state->extra);
 600                 DROPBITS(state->extra);
 601             }
 602             state->mode = DIST;
 603         case DIST:
 604             for (;;) {
 605                 this = state->distcode[BITS(state->distbits)];
 606                 if ((unsigned)(this.bits) <= bits) break;
 607                 PULLBYTE();
 608             }
 609             if ((this.op & 0xf0) == 0) {
 610                 last = this;
 611                 for (;;) {
 612                     this = state->distcode[last.val +
 613                             (BITS(last.bits + last.op) >> last.bits)];
 614                     if ((unsigned)(last.bits + this.bits) <= bits) break;
 615                     PULLBYTE();
 616                 }
 617                 DROPBITS(last.bits);
 618             }
 619             DROPBITS(this.bits);
 620             if (this.op & 64) {
 621                 strm->msg = (char *)"invalid distance code";
 622                 state->mode = BAD;
 623                 break;
 624             }
 625             state->offset = (unsigned)this.val;
 626             state->extra = (unsigned)(this.op) & 15;
 627             state->mode = DISTEXT;
 628         case DISTEXT:
 629             if (state->extra) {
 630                 NEEDBITS(state->extra);
 631                 state->offset += BITS(state->extra);
 632                 DROPBITS(state->extra);
 633             }
 634 #ifdef INFLATE_STRICT
 635             if (state->offset > state->dmax) {
 636                 strm->msg = (char *)"invalid distance too far back";
 637                 state->mode = BAD;
 638                 break;
 639             }
 640 #endif
 641             if (state->offset > state->whave + out - left) {
 642                 strm->msg = (char *)"invalid distance too far back";
 643                 state->mode = BAD;
 644                 break;
 645             }
 646             state->mode = MATCH;
 647         case MATCH:
 648             if (left == 0) goto inf_leave;
 649             copy = out - left;
 650             if (state->offset > copy) {         /* copy from window */
 651                 copy = state->offset - copy;
 652                 if (copy > state->write) {
 653                     copy -= state->write;
 654                     from = state->window + (state->wsize - copy);
 655                 }
 656                 else
 657                     from = state->window + (state->write - copy);
 658                 if (copy > state->length) copy = state->length;
 659             }
 660             else {                              /* copy from output */
 661                 from = put - state->offset;
 662                 copy = state->length;
 663             }
 664             if (copy > left) copy = left;
 665             left -= copy;
 666             state->length -= copy;
 667             do {
 668                 *put++ = *from++;
 669             } while (--copy);
 670             if (state->length == 0) state->mode = LEN;
 671             break;
 672         case LIT:
 673             if (left == 0) goto inf_leave;
 674             *put++ = (unsigned char)(state->length);
 675             left--;
 676             state->mode = LEN;
 677             break;
 678         case CHECK:
 679             if (state->wrap) {
 680                 NEEDBITS(32);
 681                 out -= left;
 682                 strm->total_out += out;
 683                 state->total += out;
 684                 if (out)
 685                     strm->adler = state->check =
 686                         UPDATE(state->check, put - out, out);
 687                 out = left;
 688                 if ((
 689                      REVERSE(hold)) != state->check) {
 690                     strm->msg = (char *)"incorrect data check";
 691                     state->mode = BAD;
 692                     break;
 693                 }
 694                 INITBITS();
 695             }
 696             state->mode = DONE;
 697         case DONE:
 698             ret = Z_STREAM_END;
 699             goto inf_leave;
 700         case BAD:
 701             ret = Z_DATA_ERROR;
 702             goto inf_leave;
 703         case MEM:
 704             return Z_MEM_ERROR;
 705         case SYNC:
 706         default:
 707             return Z_STREAM_ERROR;
 708         }
 709
 710     /*
 711        Return from inflate(), updating the total counts and the check value.
 712        If there was no progress during the inflate() call, return a buffer
 713        error.  Call zlib_updatewindow() to create and/or update the window state.
 714      */
 715   inf_leave:
 716     RESTORE();
 717     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
 718         zlib_updatewindow(strm, out);
 719
 720     in -= strm->avail_in;
 721     out -= strm->avail_out;
 722     strm->total_in += in;
 723     strm->total_out += out;
 724     state->total += out;
 725     if (state->wrap && out)
 726         strm->adler = state->check =
 727             UPDATE(state->check, strm->next_out - out, out);
 728
 729     strm->data_type = state->bits + (state->last ? 64 : 0) +
 730                       (state->mode == TYPE ? 128 : 0);
 731
 732     if (flush == Z_PACKET_FLUSH && ret == Z_OK &&
 733             strm->avail_out != 0 && strm->avail_in == 0)
 734                 return zlib_inflateSyncPacket(strm);
 735
 736     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
 737         ret = Z_BUF_ERROR;
 738
 739     return ret;
 740 }
 741
 742 int zlib_inflateEnd(z_streamp strm)
 743 {
 744     if (strm == NULL || strm->state == NULL)
 745         return Z_STREAM_ERROR;
 746     return Z_OK;
 747 }
 748
 749 /*
 750  * This subroutine adds the data at next_in/avail_in to the output history
 751  * without performing any output.  The output buffer must be "caught up";
 752  * i.e. no pending output but this should always be the case. The state must
 753  * be waiting on the start of a block (i.e. mode == TYPE or HEAD).  On exit,
 754  * the output will also be caught up, and the checksum will have been updated
 755  * if need be.
 756  */
 757 int zlib_inflateIncomp(z_stream *z)
 758 {
 759     struct inflate_state *state = (struct inflate_state *)z->state;
 760     Byte *saved_no = z->next_out;
 761     uInt saved_ao = z->avail_out;
 762
 763     if (state->mode != TYPE && state->mode != HEAD)
 764         return Z_DATA_ERROR;
 765
 766     /* Setup some variables to allow misuse of updateWindow */
 767     z->avail_out = 0;
 768     z->next_out = (unsigned char*)z->next_in + z->avail_in;
 769
 770     zlib_updatewindow(z, z->avail_in);
 771
 772     /* Restore saved variables */
 773     z->avail_out = saved_ao;
 774     z->next_out = saved_no;
 775
 776     z->adler = state->check =
 777         UPDATE(state->check, z->next_in, z->avail_in);
 778
 779     z->total_out += z->avail_in;
 780     z->total_in += z->avail_in;
 781     z->next_in += z->avail_in;
 782     state->total += z->avail_in;
 783     z->avail_in = 0;
 784
 785     return Z_OK;
 786 }