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