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