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