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