GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libz/inflate.c Lines: 0 568 0.0 %
Date: 2017-11-13 Branches: 0 479 0.0 %

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