File Coverage

cpan/Compress-Raw-Zlib/inflate.c
Criterion Covered Total %
statement 443 626 70.8
branch n/a
condition n/a
subroutine n/a
total 443 626 70.8


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