← Back to branch summary

~ubuntu-branches/ubuntu/raring/smplayer/raring

« back to all changes in this revision

Viewing changes to zlib/inflate.c

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2013-02-12 03:00:21 UTC
  • mfrom: (20.1.2 experimental)
  • Revision ID: package-import@ubuntu.com-20130212030021-q5mg053fru2u6zl8
Tags: 0.8.3-1
http://bugs.debian.org/698300
* Team upload.
* New upstream release. (Closes: #698300)

Show diffs side-by-side

added added

removed removed

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