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