← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to zlib/infback.c

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
zlib/infback.c
 
1
/* infback.c -- inflate using a call-back interface
 
2
 * Copyright (C) 1995-2005 Mark Adler
 
3
 * For conditions of distribution and use, see copyright notice in zlib.h
 
4
 */
 
5
 
 
6
/*
 
7
   This code is largely copied from inflate.c.  Normally either infback.o or
 
8
   inflate.o would be linked into an application--not both.  The interface
 
9
   with inffast.c is retained so that optimized assembler-coded versions of
 
10
   inflate_fast() can be used with either inflate.c or infback.c.
 
11
 */
 
12
 
 
13
#include "zutil.h"
 
14
#include "inftrees.h"
 
15
#include "inflate.h"
 
16
#include "inffast.h"
 
17
 
 
18
/* function prototypes */
 
19
local void fixedtables OF((struct inflate_state FAR *state));
 
20
 
 
21
/*
 
22
   strm provides memory allocation functions in zalloc and zfree, or
 
23
   Z_NULL to use the library memory allocation functions.
 
24
 
 
25
   windowBits is in the range 8..15, and window is a user-supplied
 
26
   window and output buffer that is 2**windowBits bytes.
 
27
 */
 
28
int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
 
29
z_streamp strm;
 
30
int windowBits;
 
31
unsigned char FAR *window;
 
32
const char *version;
 
33
int stream_size;
 
34
{
 
35
    struct inflate_state FAR *state;
 
36
 
 
37
    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
 
38
        stream_size != (int)(sizeof(z_stream)))
 
39
        return Z_VERSION_ERROR;
 
40
    if (strm == Z_NULL || window == Z_NULL ||
 
41
        windowBits < 8 || windowBits > 15)
 
42
        return Z_STREAM_ERROR;
 
43
    strm->msg = Z_NULL;                 /* in case we return an error */
 
44
    if (strm->zalloc == (alloc_func)0) {
 
45
        strm->zalloc = zcalloc;
 
46
        strm->opaque = (voidpf)0;
 
47
    }
 
48
    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
 
49
    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
 
50
                                               sizeof(struct inflate_state));
 
51
    if (state == Z_NULL) return Z_MEM_ERROR;
 
52
    Tracev((stderr, "inflate: allocated\n"));
 
53
    strm->state = (struct internal_state FAR *)state;
 
54
    state->dmax = 32768U;
 
55
    state->wbits = windowBits;
 
56
    state->wsize = 1U << windowBits;
 
57
    state->window = window;
 
58
    state->write = 0;
 
59
    state->whave = 0;
 
60
    return Z_OK;
 
61
}
 
62
 
 
63
/*
 
64
   Return state with length and distance decoding tables and index sizes set to
 
65
   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
 
66
   If BUILDFIXED is defined, then instead this routine builds the tables the
 
67
   first time it's called, and returns those tables the first time and
 
68
   thereafter.  This reduces the size of the code by about 2K bytes, in
 
69
   exchange for a little execution time.  However, BUILDFIXED should not be
 
70
   used for threaded applications, since the rewriting of the tables and virgin
 
71
   may not be thread-safe.
 
72
 */
 
73
local void fixedtables(state)
 
74
struct inflate_state FAR *state;
 
75
{
 
76
#ifdef BUILDFIXED
 
77
    static int virgin = 1;
 
78
    static code *lenfix, *distfix;
 
79
    static code fixed[544];
 
80
 
 
81
    /* build fixed huffman tables if first call (may not be thread safe) */
 
82
    if (virgin) {
 
83
        unsigned sym, bits;
 
84
        static code *next;
 
85
 
 
86
        /* literal/length table */
 
87
        sym = 0;
 
88
        while (sym < 144) state->lens[sym++] = 8;
 
89
        while (sym < 256) state->lens[sym++] = 9;
 
90
        while (sym < 280) state->lens[sym++] = 7;
 
91
        while (sym < 288) state->lens[sym++] = 8;
 
92
        next = fixed;
 
93
        lenfix = next;
 
94
        bits = 9;
 
95
        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
 
96
 
 
97
        /* distance table */
 
98
        sym = 0;
 
99
        while (sym < 32) state->lens[sym++] = 5;
 
100
        distfix = next;
 
101
        bits = 5;
 
102
        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
 
103
 
 
104
        /* do this just once */
 
105
        virgin = 0;
 
106
    }
 
107
#else /* !BUILDFIXED */
 
108
#   include "inffixed.h"
 
109
#endif /* BUILDFIXED */
 
110
    state->lencode = lenfix;
 
111
    state->lenbits = 9;
 
112
    state->distcode = distfix;
 
113
    state->distbits = 5;
 
114
}
 
115
 
 
116
/* Macros for inflateBack(): */
 
117
 
 
118
/* Load returned state from inflate_fast() */
 
119
#define LOAD() \
 
120
    do { \
 
121
        put = strm->next_out; \
 
122
        left = strm->avail_out; \
 
123
        next = strm->next_in; \
 
124
        have = strm->avail_in; \
 
125
        hold = state->hold; \
 
126
        bits = state->bits; \
 
127
    } while (0)
 
128
 
 
129
/* Set state from registers for inflate_fast() */
 
130
#define RESTORE() \
 
131
    do { \
 
132
        strm->next_out = put; \
 
133
        strm->avail_out = left; \
 
134
        strm->next_in = next; \
 
135
        strm->avail_in = have; \
 
136
        state->hold = hold; \
 
137
        state->bits = bits; \
 
138
    } while (0)
 
139
 
 
140
/* Clear the input bit accumulator */
 
141
#define INITBITS() \
 
142
    do { \
 
143
        hold = 0; \
 
144
        bits = 0; \
 
145
    } while (0)
 
146
 
 
147
/* Assure that some input is available.  If input is requested, but denied,
 
148
   then return a Z_BUF_ERROR from inflateBack(). */
 
149
#define PULL() \
 
150
    do { \
 
151
        if (have == 0) { \
 
152
            have = in(in_desc, &next); \
 
153
            if (have == 0) { \
 
154
                next = Z_NULL; \
 
155
                ret = Z_BUF_ERROR; \
 
156
                goto inf_leave; \
 
157
            } \
 
158
        } \
 
159
    } while (0)
 
160
 
 
161
/* Get a byte of input into the bit accumulator, or return from inflateBack()
 
162
   with an error if there is no input available. */
 
163
#define PULLBYTE() \
 
164
    do { \
 
165
        PULL(); \
 
166
        have--; \
 
167
        hold += (unsigned long)(*next++) << bits; \
 
168
        bits += 8; \
 
169
    } while (0)
 
170
 
 
171
/* Assure that there are at least n bits in the bit accumulator.  If there is
 
172
   not enough available input to do that, then return from inflateBack() with
 
173
   an error. */
 
174
#define NEEDBITS(n) \
 
175
    do { \
 
176
        while (bits < (unsigned)(n)) \
 
177
            PULLBYTE(); \
 
178
    } while (0)
 
179
 
 
180
/* Return the low n bits of the bit accumulator (n < 16) */
 
181
#define BITS(n) \
 
182
    ((unsigned)hold & ((1U << (n)) - 1))
 
183
 
 
184
/* Remove n bits from the bit accumulator */
 
185
#define DROPBITS(n) \
 
186
    do { \
 
187
        hold >>= (n); \
 
188
        bits -= (unsigned)(n); \
 
189
    } while (0)
 
190
 
 
191
/* Remove zero to seven bits as needed to go to a byte boundary */
 
192
#define BYTEBITS() \
 
193
    do { \
 
194
        hold >>= bits & 7; \
 
195
        bits -= bits & 7; \
 
196
    } while (0)
 
197
 
 
198
/* Assure that some output space is available, by writing out the window
 
199
   if it's full.  If the write fails, return from inflateBack() with a
 
200
   Z_BUF_ERROR. */
 
201
#define ROOM() \
 
202
    do { \
 
203
        if (left == 0) { \
 
204
            put = state->window; \
 
205
            left = state->wsize; \
 
206
            state->whave = left; \
 
207
            if (out(out_desc, put, left)) { \
 
208
                ret = Z_BUF_ERROR; \
 
209
                goto inf_leave; \
 
210
            } \
 
211
        } \
 
212
    } while (0)
 
213
 
 
214
/*
 
215
   strm provides the memory allocation functions and window buffer on input,
 
216
   and provides information on the unused input on return.  For Z_DATA_ERROR
 
217
   returns, strm will also provide an error message.
 
218
 
 
219
   in() and out() are the call-back input and output functions.  When
 
220
   inflateBack() needs more input, it calls in().  When inflateBack() has
 
221
   filled the window with output, or when it completes with data in the
 
222
   window, it calls out() to write out the data.  The application must not
 
223
   change the provided input until in() is called again or inflateBack()
 
224
   returns.  The application must not change the window/output buffer until
 
225
   inflateBack() returns.
 
226
 
 
227
   in() and out() are called with a descriptor parameter provided in the
 
228
   inflateBack() call.  This parameter can be a structure that provides the
 
229
   information required to do the read or write, as well as accumulated
 
230
   information on the input and output such as totals and check values.
 
231
 
 
232
   in() should return zero on failure.  out() should return non-zero on
 
233
   failure.  If either in() or out() fails, than inflateBack() returns a
 
234
   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
 
235
   was in() or out() that caused in the error.  Otherwise,  inflateBack()
 
236
   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
 
237
   error, or Z_MEM_ERROR if it could not allocate memory for the state.
 
238
   inflateBack() can also return Z_STREAM_ERROR if the input parameters
 
239
   are not correct, i.e. strm is Z_NULL or the state was not initialized.
 
240
 */
 
241
int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
 
242
z_streamp strm;
 
243
in_func in;
 
244
void FAR *in_desc;
 
245
out_func out;
 
246
void FAR *out_desc;
 
247
{
 
248
    struct inflate_state FAR *state;
 
249
    unsigned char FAR *next;    /* next input */
 
250
    unsigned char FAR *put;     /* next output */
 
251
    unsigned have, left;        /* available input and output */
 
252
    unsigned long hold;         /* bit buffer */
 
253
    unsigned bits;              /* bits in bit buffer */
 
254
    unsigned copy;              /* number of stored or match bytes to copy */
 
255
    unsigned char FAR *from;    /* where to copy match bytes from */
 
256
    code this;                  /* current decoding table entry */
 
257
    code last;                  /* parent table entry */
 
258
    unsigned len;               /* length to copy for repeats, bits to drop */
 
259
    int ret;                    /* return code */
 
260
    static const unsigned short order[19] = /* permutation of code lengths */
 
261
        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 
262
 
 
263
    /* Check that the strm exists and that the state was initialized */
 
264
    if (strm == Z_NULL || strm->state == Z_NULL)
 
265
        return Z_STREAM_ERROR;
 
266
    state = (struct inflate_state FAR *)strm->state;
 
267
 
 
268
    /* Reset the state */
 
269
    strm->msg = Z_NULL;
 
270
    state->mode = TYPE;
 
271
    state->last = 0;
 
272
    state->whave = 0;
 
273
    next = strm->next_in;
 
274
    have = next != Z_NULL ? strm->avail_in : 0;
 
275
    hold = 0;
 
276
    bits = 0;
 
277
    put = state->window;
 
278
    left = state->wsize;
 
279
 
 
280
    /* Inflate until end of block marked as last */
 
281
    for (;;)
 
282
        switch (state->mode) {
 
283
        case TYPE:
 
284
            /* determine and dispatch block type */
 
285
            if (state->last) {
 
286
                BYTEBITS();
 
287
                state->mode = DONE;
 
288
                break;
 
289
            }
 
290
            NEEDBITS(3);
 
291
            state->last = BITS(1);
 
292
            DROPBITS(1);
 
293
            switch (BITS(2)) {
 
294
            case 0:                             /* stored block */
 
295
                Tracev((stderr, "inflate:     stored block%s\n",
 
296
                        state->last ? " (last)" : ""));
 
297
                state->mode = STORED;
 
298
                break;
 
299
            case 1:                             /* fixed block */
 
300
                fixedtables(state);
 
301
                Tracev((stderr, "inflate:     fixed codes block%s\n",
 
302
                        state->last ? " (last)" : ""));
 
303
                state->mode = LEN;              /* decode codes */
 
304
                break;
 
305
            case 2:                             /* dynamic block */
 
306
                Tracev((stderr, "inflate:     dynamic codes block%s\n",
 
307
                        state->last ? " (last)" : ""));
 
308
                state->mode = TABLE;
 
309
                break;
 
310
            case 3:
 
311
                strm->msg = (char *)"invalid block type";
 
312
                state->mode = BAD;
 
313
            }
 
314
            DROPBITS(2);
 
315
            break;
 
316
 
 
317
        case STORED:
 
318
            /* get and verify stored block length */
 
319
            BYTEBITS();                         /* go to byte boundary */
 
320
            NEEDBITS(32);
 
321
            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
 
322
                strm->msg = (char *)"invalid stored block lengths";
 
323
                state->mode = BAD;
 
324
                break;
 
325
            }
 
326
            state->length = (unsigned)hold & 0xffff;
 
327
            Tracev((stderr, "inflate:       stored length %u\n",
 
328
                    state->length));
 
329
            INITBITS();
 
330
 
 
331
            /* copy stored block from input to output */
 
332
            while (state->length != 0) {
 
333
                copy = state->length;
 
334
                PULL();
 
335
                ROOM();
 
336
                if (copy > have) copy = have;
 
337
                if (copy > left) copy = left;
 
338
                zmemcpy(put, next, copy);
 
339
                have -= copy;
 
340
                next += copy;
 
341
                left -= copy;
 
342
                put += copy;
 
343
                state->length -= copy;
 
344
            }
 
345
            Tracev((stderr, "inflate:       stored end\n"));
 
346
            state->mode = TYPE;
 
347
            break;
 
348
 
 
349
        case TABLE:
 
350
            /* get dynamic table entries descriptor */
 
351
            NEEDBITS(14);
 
352
            state->nlen = BITS(5) + 257;
 
353
            DROPBITS(5);
 
354
            state->ndist = BITS(5) + 1;
 
355
            DROPBITS(5);
 
356
            state->ncode = BITS(4) + 4;
 
357
            DROPBITS(4);
 
358
#ifndef PKZIP_BUG_WORKAROUND
 
359
            if (state->nlen > 286 || state->ndist > 30) {
 
360
                strm->msg = (char *)"too many length or distance symbols";
 
361
                state->mode = BAD;
 
362
                break;
 
363
            }
 
364
#endif
 
365
            Tracev((stderr, "inflate:       table sizes ok\n"));
 
366
 
 
367
            /* get code length code lengths (not a typo) */
 
368
            state->have = 0;
 
369
            while (state->have < state->ncode) {
 
370
                NEEDBITS(3);
 
371
                state->lens[order[state->have++]] = (unsigned short)BITS(3);
 
372
                DROPBITS(3);
 
373
            }
 
374
            while (state->have < 19)
 
375
                state->lens[order[state->have++]] = 0;
 
376
            state->next = state->codes;
 
377
            state->lencode = (code const FAR *)(state->next);
 
378
            state->lenbits = 7;
 
379
            ret = inflate_table(CODES, state->lens, 19, &(state->next),
 
380
                                &(state->lenbits), state->work);
 
381
            if (ret) {
 
382
                strm->msg = (char *)"invalid code lengths set";
 
383
                state->mode = BAD;
 
384
                break;
 
385
            }
 
386
            Tracev((stderr, "inflate:       code lengths ok\n"));
 
387
 
 
388
            /* get length and distance code code lengths */
 
389
            state->have = 0;
 
390
            while (state->have < state->nlen + state->ndist) {
 
391
                for (;;) {
 
392
                    this = state->lencode[BITS(state->lenbits)];
 
393
                    if ((unsigned)(this.bits) <= bits) break;
 
394
                    PULLBYTE();
 
395
                }
 
396
                if (this.val < 16) {
 
397
                    NEEDBITS(this.bits);
 
398
                    DROPBITS(this.bits);
 
399
                    state->lens[state->have++] = this.val;
 
400
                }
 
401
                else {
 
402
                    if (this.val == 16) {
 
403
                        NEEDBITS(this.bits + 2);
 
404
                        DROPBITS(this.bits);
 
405
                        if (state->have == 0) {
 
406
                            strm->msg = (char *)"invalid bit length repeat";
 
407
                            state->mode = BAD;
 
408
                            break;
 
409
                        }
 
410
                        len = (unsigned)(state->lens[state->have - 1]);
 
411
                        copy = 3 + BITS(2);
 
412
                        DROPBITS(2);
 
413
                    }
 
414
                    else if (this.val == 17) {
 
415
                        NEEDBITS(this.bits + 3);
 
416
                        DROPBITS(this.bits);
 
417
                        len = 0;
 
418
                        copy = 3 + BITS(3);
 
419
                        DROPBITS(3);
 
420
                    }
 
421
                    else {
 
422
                        NEEDBITS(this.bits + 7);
 
423
                        DROPBITS(this.bits);
 
424
                        len = 0;
 
425
                        copy = 11 + BITS(7);
 
426
                        DROPBITS(7);
 
427
                    }
 
428
                    if (state->have + copy > state->nlen + state->ndist) {
 
429
                        strm->msg = (char *)"invalid bit length repeat";
 
430
                        state->mode = BAD;
 
431
                        break;
 
432
                    }
 
433
                    while (copy--)
 
434
                        state->lens[state->have++] = (unsigned short)len;
 
435
                }
 
436
            }
 
437
 
 
438
            /* handle error breaks in while */
 
439
            if (state->mode == BAD) break;
 
440
 
 
441
            /* build code tables */
 
442
            state->next = state->codes;
 
443
            state->lencode = (code const FAR *)(state->next);
 
444
            state->lenbits = 9;
 
445
            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
 
446
                                &(state->lenbits), state->work);
 
447
            if (ret) {
 
448
                strm->msg = (char *)"invalid literal/lengths set";
 
449
                state->mode = BAD;
 
450
                break;
 
451
            }
 
452
            state->distcode = (code const FAR *)(state->next);
 
453
            state->distbits = 6;
 
454
            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
 
455
                            &(state->next), &(state->distbits), state->work);
 
456
            if (ret) {
 
457
                strm->msg = (char *)"invalid distances set";
 
458
                state->mode = BAD;
 
459
                break;
 
460
            }
 
461
            Tracev((stderr, "inflate:       codes ok\n"));
 
462
            state->mode = LEN;
 
463
 
 
464
        case LEN:
 
465
            /* use inflate_fast() if we have enough input and output */
 
466
            if (have >= 6 && left >= 258) {
 
467
                RESTORE();
 
468
                if (state->whave < state->wsize)
 
469
                    state->whave = state->wsize - left;
 
470
                inflate_fast(strm, state->wsize);
 
471
                LOAD();
 
472
                break;
 
473
            }
 
474
 
 
475
            /* get a literal, length, or end-of-block code */
 
476
            for (;;) {
 
477
                this = state->lencode[BITS(state->lenbits)];
 
478
                if ((unsigned)(this.bits) <= bits) break;
 
479
                PULLBYTE();
 
480
            }
 
481
            if (this.op && (this.op & 0xf0) == 0) {
 
482
                last = this;
 
483
                for (;;) {
 
484
                    this = state->lencode[last.val +
 
485
                            (BITS(last.bits + last.op) >> last.bits)];
 
486
                    if ((unsigned)(last.bits + this.bits) <= bits) break;
 
487
                    PULLBYTE();
 
488
                }
 
489
                DROPBITS(last.bits);
 
490
            }
 
491
            DROPBITS(this.bits);
 
492
            state->length = (unsigned)this.val;
 
493
 
 
494
            /* process literal */
 
495
            if (this.op == 0) {
 
496
                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
 
497
                        "inflate:         literal '%c'\n" :
 
498
                        "inflate:         literal 0x%02x\n", this.val));
 
499
                ROOM();
 
500
                *put++ = (unsigned char)(state->length);
 
501
                left--;
 
502
                state->mode = LEN;
 
503
                break;
 
504
            }
 
505
 
 
506
            /* process end of block */
 
507
            if (this.op & 32) {
 
508
                Tracevv((stderr, "inflate:         end of block\n"));
 
509
                state->mode = TYPE;
 
510
                break;
 
511
            }
 
512
 
 
513
            /* invalid code */
 
514
            if (this.op & 64) {
 
515
                strm->msg = (char *)"invalid literal/length code";
 
516
                state->mode = BAD;
 
517
                break;
 
518
            }
 
519
 
 
520
            /* length code -- get extra bits, if any */
 
521
            state->extra = (unsigned)(this.op) & 15;
 
522
            if (state->extra != 0) {
 
523
                NEEDBITS(state->extra);
 
524
                state->length += BITS(state->extra);
 
525
                DROPBITS(state->extra);
 
526
            }
 
527
            Tracevv((stderr, "inflate:         length %u\n", state->length));
 
528
 
 
529
            /* get distance code */
 
530
            for (;;) {
 
531
                this = state->distcode[BITS(state->distbits)];
 
532
                if ((unsigned)(this.bits) <= bits) break;
 
533
                PULLBYTE();
 
534
            }
 
535
            if ((this.op & 0xf0) == 0) {
 
536
                last = this;
 
537
                for (;;) {
 
538
                    this = state->distcode[last.val +
 
539
                            (BITS(last.bits + last.op) >> last.bits)];
 
540
                    if ((unsigned)(last.bits + this.bits) <= bits) break;
 
541
                    PULLBYTE();
 
542
                }
 
543
                DROPBITS(last.bits);
 
544
            }
 
545
            DROPBITS(this.bits);
 
546
            if (this.op & 64) {
 
547
                strm->msg = (char *)"invalid distance code";
 
548
                state->mode = BAD;
 
549
                break;
 
550
            }
 
551
            state->offset = (unsigned)this.val;
 
552
 
 
553
            /* get distance extra bits, if any */
 
554
            state->extra = (unsigned)(this.op) & 15;
 
555
            if (state->extra != 0) {
 
556
                NEEDBITS(state->extra);
 
557
                state->offset += BITS(state->extra);
 
558
                DROPBITS(state->extra);
 
559
            }
 
560
            if (state->offset > state->wsize - (state->whave < state->wsize ?
 
561
                                                left : 0)) {
 
562
                strm->msg = (char *)"invalid distance too far back";
 
563
                state->mode = BAD;
 
564
                break;
 
565
            }
 
566
            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
 
567
 
 
568
            /* copy match from window to output */
 
569
            do {
 
570
                ROOM();
 
571
                copy = state->wsize - state->offset;
 
572
                if (copy < left) {
 
573
                    from = put + copy;
 
574
                    copy = left - copy;
 
575
                }
 
576
                else {
 
577
                    from = put - state->offset;
 
578
                    copy = left;
 
579
                }
 
580
                if (copy > state->length) copy = state->length;
 
581
                state->length -= copy;
 
582
                left -= copy;
 
583
                do {
 
584
                    *put++ = *from++;
 
585
                } while (--copy);
 
586
            } while (state->length != 0);
 
587
            break;
 
588
 
 
589
        case DONE:
 
590
            /* inflate stream terminated properly -- write leftover output */
 
591
            ret = Z_STREAM_END;
 
592
            if (left < state->wsize) {
 
593
                if (out(out_desc, state->window, state->wsize - left))
 
594
                    ret = Z_BUF_ERROR;
 
595
            }
 
596
            goto inf_leave;
 
597
 
 
598
        case BAD:
 
599
            ret = Z_DATA_ERROR;
 
600
            goto inf_leave;
 
601
 
 
602
        default:                /* can't happen, but makes compilers happy */
 
603
            ret = Z_STREAM_ERROR;
 
604
            goto inf_leave;
 
605
        }
 
606
 
 
607
    /* Return unused input */
 
608
  inf_leave:
 
609
    strm->next_in = next;
 
610
    strm->avail_in = have;
 
611
    return ret;
 
612
}
 
613
 
 
614
int ZEXPORT inflateBackEnd(strm)
 
615
z_streamp strm;
 
616
{
 
617
    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
 
618
        return Z_STREAM_ERROR;
 
619
    ZFREE(strm, strm->state);
 
620
    strm->state = Z_NULL;
 
621
    Tracev((stderr, "inflate: end\n"));
 
622
    return Z_OK;
 
623
}