akaros/kern/lib/zlib_inflate/inflate.c
<<
>>
Prefs
   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 <zutil.h>
  13#include "inftrees.h"
  14#include "inflate.h"
  15#include "inffast.h"
  16#include "infutil.h"
  17
  18int zlib_inflate_workspacesize(void)
  19{
  20    return sizeof(struct inflate_workspace);
  21}
  22
  23int 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
  48int 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 */
  78static 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 */
 101static 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 */
 146static 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
 317int 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
 742int 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 */
 757int 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}
 787