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