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