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