File indexing completed on 2024-04-28 07:36:42
0001 /* inflate.c -- zlib decompression 0002 * Copyright (C) 1995-2012 Mark Adler 0003 * For conditions of distribution and use, see copyright notice in zlib.h 0004 */ 0005 0006 /* 0007 * Change history: 0008 * 0009 * 1.2.beta0 24 Nov 2002 0010 * - First version -- complete rewrite of inflate to simplify code, avoid 0011 * creation of window when not needed, minimize use of window when it is 0012 * needed, make inffast.c even faster, implement gzip decoding, and to 0013 * improve code readability and style over the previous zlib inflate code 0014 * 0015 * 1.2.beta1 25 Nov 2002 0016 * - Use pointers for available input and output checking in inffast.c 0017 * - Remove input and output counters in inffast.c 0018 * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 0019 * - Remove unnecessary second byte pull from length extra in inffast.c 0020 * - Unroll direct copy to three copies per loop in inffast.c 0021 * 0022 * 1.2.beta2 4 Dec 2002 0023 * - Change external routine names to reduce potential conflicts 0024 * - Correct filename to inffixed.h for fixed tables in inflate.c 0025 * - Make hbuf[] unsigned char to match parameter type in inflate.c 0026 * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) 0027 * to avoid negation problem on Alphas (64 bit) in inflate.c 0028 * 0029 * 1.2.beta3 22 Dec 2002 0030 * - Add comments on state->bits assertion in inffast.c 0031 * - Add comments on op field in inftrees.h 0032 * - Fix bug in reuse of allocated window after inflateReset() 0033 * - Remove bit fields--back to byte structure for speed 0034 * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths 0035 * - Change post-increments to pre-increments in inflate_fast(), PPC biased? 0036 * - Add compile time option, POSTINC, to use post-increments instead (Intel?) 0037 * - Make MATCH copy in inflate() much faster for when inflate_fast() not used 0038 * - Use local copies of stream next and avail values, as well as local bit 0039 * buffer and bit count in inflate()--for speed when inflate_fast() not used 0040 * 0041 * 1.2.beta4 1 Jan 2003 0042 * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings 0043 * - Move a comment on output buffer sizes from inffast.c to inflate.c 0044 * - Add comments in inffast.c to introduce the inflate_fast() routine 0045 * - Rearrange window copies in inflate_fast() for speed and simplification 0046 * - Unroll last copy for window match in inflate_fast() 0047 * - Use local copies of window variables in inflate_fast() for speed 0048 * - Pull out common wnext == 0 case for speed in inflate_fast() 0049 * - Make op and len in inflate_fast() unsigned for consistency 0050 * - Add FAR to lcode and dcode declarations in inflate_fast() 0051 * - Simplified bad distance check in inflate_fast() 0052 * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new 0053 * source file infback.c to provide a call-back interface to inflate for 0054 * programs like gzip and unzip -- uses window as output buffer to avoid 0055 * window copying 0056 * 0057 * 1.2.beta5 1 Jan 2003 0058 * - Improved inflateBack() interface to allow the caller to provide initial 0059 * input in strm. 0060 * - Fixed stored blocks bug in inflateBack() 0061 * 0062 * 1.2.beta6 4 Jan 2003 0063 * - Added comments in inffast.c on effectiveness of POSTINC 0064 * - Typecasting all around to reduce compiler warnings 0065 * - Changed loops from while (1) or do {} while (1) to for (;;), again to 0066 * make compilers happy 0067 * - Changed type of window in inflateBackInit() to unsigned char * 0068 * 0069 * 1.2.beta7 27 Jan 2003 0070 * - Changed many types to unsigned or unsigned short to avoid warnings 0071 * - Added inflateCopy() function 0072 * 0073 * 1.2.0 9 Mar 2003 0074 * - Changed inflateBack() interface to provide separate opaque descriptors 0075 * for the in() and out() functions 0076 * - Changed inflateBack() argument and in_func typedef to swap the length 0077 * and buffer address return values for the input function 0078 * - Check next_in and next_out for Z_NULL on entry to inflate() 0079 * 0080 * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. 0081 */ 0082 0083 #include "zutil.h" 0084 #include "inftrees.h" 0085 #include "inflate.h" 0086 #include "inffast.h" 0087 0088 #ifdef MAKEFIXED 0089 # ifndef BUILDFIXED 0090 # define BUILDFIXED 0091 # endif 0092 #endif 0093 0094 /* function prototypes */ 0095 local void fixedtables OF((struct inflate_state FAR *state)); 0096 local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, 0097 unsigned copy)); 0098 #ifdef BUILDFIXED 0099 void makefixed OF((void)); 0100 #endif 0101 local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, 0102 unsigned len)); 0103 0104 int ZEXPORT inflateResetKeep(strm) 0105 z_streamp strm; 0106 { 0107 struct inflate_state FAR *state; 0108 0109 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 0110 state = (struct inflate_state FAR *)strm->state; 0111 strm->total_in = strm->total_out = state->total = 0; 0112 strm->msg = Z_NULL; 0113 if (state->wrap) /* to support ill-conceived Java test suite */ 0114 strm->adler = state->wrap & 1; 0115 state->mode = HEAD; 0116 state->last = 0; 0117 state->havedict = 0; 0118 state->dmax = 32768U; 0119 state->head = Z_NULL; 0120 state->hold = 0; 0121 state->bits = 0; 0122 state->lencode = state->distcode = state->next = state->codes; 0123 state->sane = 1; 0124 state->back = -1; 0125 Tracev((stderr, "inflate: reset\n")); 0126 return Z_OK; 0127 } 0128 0129 int ZEXPORT inflateReset(strm) 0130 z_streamp strm; 0131 { 0132 struct inflate_state FAR *state; 0133 0134 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 0135 state = (struct inflate_state FAR *)strm->state; 0136 state->wsize = 0; 0137 state->whave = 0; 0138 state->wnext = 0; 0139 return inflateResetKeep(strm); 0140 } 0141 0142 int ZEXPORT inflateReset2(strm, windowBits) 0143 z_streamp strm; 0144 int windowBits; 0145 { 0146 int wrap; 0147 struct inflate_state FAR *state; 0148 0149 /* get the state */ 0150 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 0151 state = (struct inflate_state FAR *)strm->state; 0152 0153 /* extract wrap request from windowBits parameter */ 0154 if (windowBits < 0) { 0155 wrap = 0; 0156 windowBits = -windowBits; 0157 } 0158 else { 0159 wrap = (windowBits >> 4) + 1; 0160 #ifdef GUNZIP 0161 if (windowBits < 48) 0162 windowBits &= 15; 0163 #endif 0164 } 0165 0166 /* set number of window bits, free window if different */ 0167 if (windowBits && (windowBits < 8 || windowBits > 15)) 0168 return Z_STREAM_ERROR; 0169 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { 0170 ZFREE(strm, state->window); 0171 state->window = Z_NULL; 0172 } 0173 0174 /* update state and reset the rest of it */ 0175 state->wrap = wrap; 0176 state->wbits = (unsigned)windowBits; 0177 return inflateReset(strm); 0178 } 0179 0180 int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) 0181 z_streamp strm; 0182 int windowBits; 0183 const char *version; 0184 int stream_size; 0185 { 0186 int ret; 0187 struct inflate_state FAR *state; 0188 0189 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || 0190 stream_size != (int)(sizeof(z_stream))) 0191 return Z_VERSION_ERROR; 0192 if (strm == Z_NULL) return Z_STREAM_ERROR; 0193 strm->msg = Z_NULL; /* in case we return an error */ 0194 if (strm->zalloc == (alloc_func)0) { 0195 #ifdef Z_SOLO 0196 return Z_STREAM_ERROR; 0197 #else 0198 strm->zalloc = zcalloc; 0199 strm->opaque = (voidpf)0; 0200 #endif 0201 } 0202 if (strm->zfree == (free_func)0) 0203 #ifdef Z_SOLO 0204 return Z_STREAM_ERROR; 0205 #else 0206 strm->zfree = zcfree; 0207 #endif 0208 state = (struct inflate_state FAR *) 0209 ZALLOC(strm, 1, sizeof(struct inflate_state)); 0210 if (state == Z_NULL) return Z_MEM_ERROR; 0211 Tracev((stderr, "inflate: allocated\n")); 0212 strm->state = (struct internal_state FAR *)state; 0213 state->window = Z_NULL; 0214 ret = inflateReset2(strm, windowBits); 0215 if (ret != Z_OK) { 0216 ZFREE(strm, state); 0217 strm->state = Z_NULL; 0218 } 0219 return ret; 0220 } 0221 0222 int ZEXPORT inflateInit_(strm, version, stream_size) 0223 z_streamp strm; 0224 const char *version; 0225 int stream_size; 0226 { 0227 return inflateInit2_(strm, DEF_WBITS, version, stream_size); 0228 } 0229 0230 int ZEXPORT inflatePrime(strm, bits, value) 0231 z_streamp strm; 0232 int bits; 0233 int value; 0234 { 0235 struct inflate_state FAR *state; 0236 0237 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 0238 state = (struct inflate_state FAR *)strm->state; 0239 if (bits < 0) { 0240 state->hold = 0; 0241 state->bits = 0; 0242 return Z_OK; 0243 } 0244 if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; 0245 value &= (1L << bits) - 1; 0246 state->hold += value << state->bits; 0247 state->bits += bits; 0248 return Z_OK; 0249 } 0250 0251 /* 0252 Return state with length and distance decoding tables and index sizes set to 0253 fixed code decoding. Normally this returns fixed tables from inffixed.h. 0254 If BUILDFIXED is defined, then instead this routine builds the tables the 0255 first time it's called, and returns those tables the first time and 0256 thereafter. This reduces the size of the code by about 2K bytes, in 0257 exchange for a little execution time. However, BUILDFIXED should not be 0258 used for threaded applications, since the rewriting of the tables and virgin 0259 may not be thread-safe. 0260 */ 0261 local void fixedtables(state) 0262 struct inflate_state FAR *state; 0263 { 0264 #ifdef BUILDFIXED 0265 static int virgin = 1; 0266 static code *lenfix, *distfix; 0267 static code fixed[544]; 0268 0269 /* build fixed huffman tables if first call (may not be thread safe) */ 0270 if (virgin) { 0271 unsigned sym, bits; 0272 static code *next; 0273 0274 /* literal/length table */ 0275 sym = 0; 0276 while (sym < 144) state->lens[sym++] = 8; 0277 while (sym < 256) state->lens[sym++] = 9; 0278 while (sym < 280) state->lens[sym++] = 7; 0279 while (sym < 288) state->lens[sym++] = 8; 0280 next = fixed; 0281 lenfix = next; 0282 bits = 9; 0283 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); 0284 0285 /* distance table */ 0286 sym = 0; 0287 while (sym < 32) state->lens[sym++] = 5; 0288 distfix = next; 0289 bits = 5; 0290 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); 0291 0292 /* do this just once */ 0293 virgin = 0; 0294 } 0295 #else /* !BUILDFIXED */ 0296 # include "inffixed.h" 0297 #endif /* BUILDFIXED */ 0298 state->lencode = lenfix; 0299 state->lenbits = 9; 0300 state->distcode = distfix; 0301 state->distbits = 5; 0302 } 0303 0304 #ifdef MAKEFIXED 0305 #include <stdio.h> 0306 0307 /* 0308 Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also 0309 defines BUILDFIXED, so the tables are built on the fly. makefixed() writes 0310 those tables to stdout, which would be piped to inffixed.h. A small program 0311 can simply call makefixed to do this: 0312 0313 void makefixed(void); 0314 0315 int main(void) 0316 { 0317 makefixed(); 0318 return 0; 0319 } 0320 0321 Then that can be linked with zlib built with MAKEFIXED defined and run: 0322 0323 a.out > inffixed.h 0324 */ 0325 void makefixed() 0326 { 0327 unsigned low, size; 0328 struct inflate_state state; 0329 0330 fixedtables(&state); 0331 puts(" /* inffixed.h -- table for decoding fixed codes"); 0332 puts(" * Generated automatically by makefixed()."); 0333 puts(" */"); 0334 puts(""); 0335 puts(" /* WARNING: this file should *not* be used by applications."); 0336 puts(" It is part of the implementation of this library and is"); 0337 puts(" subject to change. Applications should only use zlib.h."); 0338 puts(" */"); 0339 puts(""); 0340 size = 1U << 9; 0341 printf(" static const code lenfix[%u] = {", size); 0342 low = 0; 0343 for (;;) { 0344 if ((low % 7) == 0) printf("\n "); 0345 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, 0346 state.lencode[low].bits, state.lencode[low].val); 0347 if (++low == size) break; 0348 putchar(','); 0349 } 0350 puts("\n };"); 0351 size = 1U << 5; 0352 printf("\n static const code distfix[%u] = {", size); 0353 low = 0; 0354 for (;;) { 0355 if ((low % 6) == 0) printf("\n "); 0356 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, 0357 state.distcode[low].val); 0358 if (++low == size) break; 0359 putchar(','); 0360 } 0361 puts("\n };"); 0362 } 0363 #endif /* MAKEFIXED */ 0364 0365 /* 0366 Update the window with the last wsize (normally 32K) bytes written before 0367 returning. If window does not exist yet, create it. This is only called 0368 when a window is already in use, or when output has been written during this 0369 inflate call, but the end of the deflate stream has not been reached yet. 0370 It is also called to create a window for dictionary data when a dictionary 0371 is loaded. 0372 0373 Providing output buffers larger than 32K to inflate() should provide a speed 0374 advantage, since only the last 32K of output is copied to the sliding window 0375 upon return from inflate(), and since all distances after the first 32K of 0376 output will fall in the output data, making match copies simpler and faster. 0377 The advantage may be dependent on the size of the processor's data caches. 0378 */ 0379 local int updatewindow(strm, end, copy) 0380 z_streamp strm; 0381 const Bytef *end; 0382 unsigned copy; 0383 { 0384 struct inflate_state FAR *state; 0385 unsigned dist; 0386 0387 state = (struct inflate_state FAR *)strm->state; 0388 0389 /* if it hasn't been done already, allocate space for the window */ 0390 if (state->window == Z_NULL) { 0391 state->window = (unsigned char FAR *) 0392 ZALLOC(strm, 1U << state->wbits, 0393 sizeof(unsigned char)); 0394 if (state->window == Z_NULL) return 1; 0395 } 0396 0397 /* if window not in use yet, initialize */ 0398 if (state->wsize == 0) { 0399 state->wsize = 1U << state->wbits; 0400 state->wnext = 0; 0401 state->whave = 0; 0402 } 0403 0404 /* copy state->wsize or less output bytes into the circular window */ 0405 if (copy >= state->wsize) { 0406 zmemcpy(state->window, end - state->wsize, state->wsize); 0407 state->wnext = 0; 0408 state->whave = state->wsize; 0409 } 0410 else { 0411 dist = state->wsize - state->wnext; 0412 if (dist > copy) dist = copy; 0413 zmemcpy(state->window + state->wnext, end - copy, dist); 0414 copy -= dist; 0415 if (copy) { 0416 zmemcpy(state->window, end - copy, copy); 0417 state->wnext = copy; 0418 state->whave = state->wsize; 0419 } 0420 else { 0421 state->wnext += dist; 0422 if (state->wnext == state->wsize) state->wnext = 0; 0423 if (state->whave < state->wsize) state->whave += dist; 0424 } 0425 } 0426 return 0; 0427 } 0428 0429 /* Macros for inflate(): */ 0430 0431 /* check function to use adler32() for zlib or crc32() for gzip */ 0432 #ifdef GUNZIP 0433 # define UPDATE(check, buf, len) \ 0434 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) 0435 #else 0436 # define UPDATE(check, buf, len) adler32(check, buf, len) 0437 #endif 0438 0439 /* check macros for header crc */ 0440 #ifdef GUNZIP 0441 # define CRC2(check, word) \ 0442 do { \ 0443 hbuf[0] = (unsigned char)(word); \ 0444 hbuf[1] = (unsigned char)((word) >> 8); \ 0445 check = crc32(check, hbuf, 2); \ 0446 } while (0) 0447 0448 # define CRC4(check, word) \ 0449 do { \ 0450 hbuf[0] = (unsigned char)(word); \ 0451 hbuf[1] = (unsigned char)((word) >> 8); \ 0452 hbuf[2] = (unsigned char)((word) >> 16); \ 0453 hbuf[3] = (unsigned char)((word) >> 24); \ 0454 check = crc32(check, hbuf, 4); \ 0455 } while (0) 0456 #endif 0457 0458 /* Load registers with state in inflate() for speed */ 0459 #define LOAD() \ 0460 do { \ 0461 put = strm->next_out; \ 0462 left = strm->avail_out; \ 0463 next = strm->next_in; \ 0464 have = strm->avail_in; \ 0465 hold = state->hold; \ 0466 bits = state->bits; \ 0467 } while (0) 0468 0469 /* Restore state from registers in inflate() */ 0470 #define RESTORE() \ 0471 do { \ 0472 strm->next_out = put; \ 0473 strm->avail_out = left; \ 0474 strm->next_in = next; \ 0475 strm->avail_in = have; \ 0476 state->hold = hold; \ 0477 state->bits = bits; \ 0478 } while (0) 0479 0480 /* Clear the input bit accumulator */ 0481 #define INITBITS() \ 0482 do { \ 0483 hold = 0; \ 0484 bits = 0; \ 0485 } while (0) 0486 0487 /* Get a byte of input into the bit accumulator, or return from inflate() 0488 if there is no input available. */ 0489 #define PULLBYTE() \ 0490 do { \ 0491 if (have == 0) goto inf_leave; \ 0492 have--; \ 0493 hold += (unsigned long)(*next++) << bits; \ 0494 bits += 8; \ 0495 } while (0) 0496 0497 /* Assure that there are at least n bits in the bit accumulator. If there is 0498 not enough available input to do that, then return from inflate(). */ 0499 #define NEEDBITS(n) \ 0500 do { \ 0501 while (bits < (unsigned)(n)) \ 0502 PULLBYTE(); \ 0503 } while (0) 0504 0505 /* Return the low n bits of the bit accumulator (n < 16) */ 0506 #define BITS(n) \ 0507 ((unsigned)hold & ((1U << (n)) - 1)) 0508 0509 /* Remove n bits from the bit accumulator */ 0510 #define DROPBITS(n) \ 0511 do { \ 0512 hold >>= (n); \ 0513 bits -= (unsigned)(n); \ 0514 } while (0) 0515 0516 /* Remove zero to seven bits as needed to go to a byte boundary */ 0517 #define BYTEBITS() \ 0518 do { \ 0519 hold >>= bits & 7; \ 0520 bits -= bits & 7; \ 0521 } while (0) 0522 0523 /* 0524 inflate() uses a state machine to process as much input data and generate as 0525 much output data as possible before returning. The state machine is 0526 structured roughly as follows: 0527 0528 for (;;) switch (state) { 0529 ... 0530 case STATEn: 0531 if (not enough input data or output space to make progress) 0532 return; 0533 ... make progress ... 0534 state = STATEm; 0535 break; 0536 ... 0537 } 0538 0539 so when inflate() is called again, the same case is attempted again, and 0540 if the appropriate resources are provided, the machine proceeds to the 0541 next state. The NEEDBITS() macro is usually the way the state evaluates 0542 whether it can proceed or should return. NEEDBITS() does the return if 0543 the requested bits are not available. The typical use of the BITS macros 0544 is: 0545 0546 NEEDBITS(n); 0547 ... do something with BITS(n) ... 0548 DROPBITS(n); 0549 0550 where NEEDBITS(n) either returns from inflate() if there isn't enough 0551 input left to load n bits into the accumulator, or it continues. BITS(n) 0552 gives the low n bits in the accumulator. When done, DROPBITS(n) drops 0553 the low n bits off the accumulator. INITBITS() clears the accumulator 0554 and sets the number of available bits to zero. BYTEBITS() discards just 0555 enough bits to put the accumulator on a byte boundary. After BYTEBITS() 0556 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. 0557 0558 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return 0559 if there is no input available. The decoding of variable length codes uses 0560 PULLBYTE() directly in order to pull just enough bytes to decode the next 0561 code, and no more. 0562 0563 Some states loop until they get enough input, making sure that enough 0564 state information is maintained to continue the loop where it left off 0565 if NEEDBITS() returns in the loop. For example, want, need, and keep 0566 would all have to actually be part of the saved state in case NEEDBITS() 0567 returns: 0568 0569 case STATEw: 0570 while (want < need) { 0571 NEEDBITS(n); 0572 keep[want++] = BITS(n); 0573 DROPBITS(n); 0574 } 0575 state = STATEx; 0576 case STATEx: 0577 0578 As shown above, if the next state is also the next case, then the break 0579 is omitted. 0580 0581 A state may also return if there is not enough output space available to 0582 complete that state. Those states are copying stored data, writing a 0583 literal byte, and copying a matching string. 0584 0585 When returning, a "goto inf_leave" is used to update the total counters, 0586 update the check value, and determine whether any progress has been made 0587 during that inflate() call in order to return the proper return code. 0588 Progress is defined as a change in either strm->avail_in or strm->avail_out. 0589 When there is a window, goto inf_leave will update the window with the last 0590 output written. If a goto inf_leave occurs in the middle of decompression 0591 and there is no window currently, goto inf_leave will create one and copy 0592 output to the window for the next call of inflate(). 0593 0594 In this implementation, the flush parameter of inflate() only affects the 0595 return code (per zlib.h). inflate() always writes as much as possible to 0596 strm->next_out, given the space available and the provided input--the effect 0597 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers 0598 the allocation of and copying into a sliding window until necessary, which 0599 provides the effect documented in zlib.h for Z_FINISH when the entire input 0600 stream available. So the only thing the flush parameter actually does is: 0601 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it 0602 will return Z_BUF_ERROR if it has not reached the end of the stream. 0603 */ 0604 0605 int ZEXPORT inflate(strm, flush) 0606 z_streamp strm; 0607 int flush; 0608 { 0609 struct inflate_state FAR *state; 0610 z_const unsigned char FAR *next; /* next input */ 0611 unsigned char FAR *put; /* next output */ 0612 unsigned have, left; /* available input and output */ 0613 unsigned long hold; /* bit buffer */ 0614 unsigned bits; /* bits in bit buffer */ 0615 unsigned in, out; /* save starting available input and output */ 0616 unsigned copy; /* number of stored or match bytes to copy */ 0617 unsigned char FAR *from; /* where to copy match bytes from */ 0618 code here; /* current decoding table entry */ 0619 code last; /* parent table entry */ 0620 unsigned len; /* length to copy for repeats, bits to drop */ 0621 int ret; /* return code */ 0622 #ifdef GUNZIP 0623 unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ 0624 #endif 0625 static const unsigned short order[19] = /* permutation of code lengths */ 0626 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; 0627 0628 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || 0629 (strm->next_in == Z_NULL && strm->avail_in != 0)) 0630 return Z_STREAM_ERROR; 0631 0632 state = (struct inflate_state FAR *)strm->state; 0633 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ 0634 LOAD(); 0635 in = have; 0636 out = left; 0637 ret = Z_OK; 0638 for (;;) 0639 switch (state->mode) { 0640 case HEAD: 0641 if (state->wrap == 0) { 0642 state->mode = TYPEDO; 0643 break; 0644 } 0645 NEEDBITS(16); 0646 #ifdef GUNZIP 0647 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ 0648 state->check = crc32(0L, Z_NULL, 0); 0649 CRC2(state->check, hold); 0650 INITBITS(); 0651 state->mode = FLAGS; 0652 break; 0653 } 0654 state->flags = 0; /* expect zlib header */ 0655 if (state->head != Z_NULL) 0656 state->head->done = -1; 0657 if (!(state->wrap & 1) || /* check if zlib header allowed */ 0658 #else 0659 if ( 0660 #endif 0661 ((BITS(8) << 8) + (hold >> 8)) % 31) { 0662 strm->msg = (char *)"incorrect header check"; 0663 state->mode = BAD; 0664 break; 0665 } 0666 if (BITS(4) != Z_DEFLATED) { 0667 strm->msg = (char *)"unknown compression method"; 0668 state->mode = BAD; 0669 break; 0670 } 0671 DROPBITS(4); 0672 len = BITS(4) + 8; 0673 if (state->wbits == 0) 0674 state->wbits = len; 0675 else if (len > state->wbits) { 0676 strm->msg = (char *)"invalid window size"; 0677 state->mode = BAD; 0678 break; 0679 } 0680 state->dmax = 1U << len; 0681 Tracev((stderr, "inflate: zlib header ok\n")); 0682 strm->adler = state->check = adler32(0L, Z_NULL, 0); 0683 state->mode = hold & 0x200 ? DICTID : TYPE; 0684 INITBITS(); 0685 break; 0686 #ifdef GUNZIP 0687 case FLAGS: 0688 NEEDBITS(16); 0689 state->flags = (int)(hold); 0690 if ((state->flags & 0xff) != Z_DEFLATED) { 0691 strm->msg = (char *)"unknown compression method"; 0692 state->mode = BAD; 0693 break; 0694 } 0695 if (state->flags & 0xe000) { 0696 strm->msg = (char *)"unknown header flags set"; 0697 state->mode = BAD; 0698 break; 0699 } 0700 if (state->head != Z_NULL) 0701 state->head->text = (int)((hold >> 8) & 1); 0702 if (state->flags & 0x0200) CRC2(state->check, hold); 0703 INITBITS(); 0704 state->mode = TIME; 0705 case TIME: 0706 NEEDBITS(32); 0707 if (state->head != Z_NULL) 0708 state->head->time = hold; 0709 if (state->flags & 0x0200) CRC4(state->check, hold); 0710 INITBITS(); 0711 state->mode = OS; 0712 case OS: 0713 NEEDBITS(16); 0714 if (state->head != Z_NULL) { 0715 state->head->xflags = (int)(hold & 0xff); 0716 state->head->os = (int)(hold >> 8); 0717 } 0718 if (state->flags & 0x0200) CRC2(state->check, hold); 0719 INITBITS(); 0720 state->mode = EXLEN; 0721 case EXLEN: 0722 if (state->flags & 0x0400) { 0723 NEEDBITS(16); 0724 state->length = (unsigned)(hold); 0725 if (state->head != Z_NULL) 0726 state->head->extra_len = (unsigned)hold; 0727 if (state->flags & 0x0200) CRC2(state->check, hold); 0728 INITBITS(); 0729 } 0730 else if (state->head != Z_NULL) 0731 state->head->extra = Z_NULL; 0732 state->mode = EXTRA; 0733 case EXTRA: 0734 if (state->flags & 0x0400) { 0735 copy = state->length; 0736 if (copy > have) copy = have; 0737 if (copy) { 0738 if (state->head != Z_NULL && 0739 state->head->extra != Z_NULL) { 0740 len = state->head->extra_len - state->length; 0741 zmemcpy(state->head->extra + len, next, 0742 len + copy > state->head->extra_max ? 0743 state->head->extra_max - len : copy); 0744 } 0745 if (state->flags & 0x0200) 0746 state->check = crc32(state->check, next, copy); 0747 have -= copy; 0748 next += copy; 0749 state->length -= copy; 0750 } 0751 if (state->length) goto inf_leave; 0752 } 0753 state->length = 0; 0754 state->mode = NAME; 0755 case NAME: 0756 if (state->flags & 0x0800) { 0757 if (have == 0) goto inf_leave; 0758 copy = 0; 0759 do { 0760 len = (unsigned)(next[copy++]); 0761 if (state->head != Z_NULL && 0762 state->head->name != Z_NULL && 0763 state->length < state->head->name_max) 0764 state->head->name[state->length++] = len; 0765 } while (len && copy < have); 0766 if (state->flags & 0x0200) 0767 state->check = crc32(state->check, next, copy); 0768 have -= copy; 0769 next += copy; 0770 if (len) goto inf_leave; 0771 } 0772 else if (state->head != Z_NULL) 0773 state->head->name = Z_NULL; 0774 state->length = 0; 0775 state->mode = COMMENT; 0776 case COMMENT: 0777 if (state->flags & 0x1000) { 0778 if (have == 0) goto inf_leave; 0779 copy = 0; 0780 do { 0781 len = (unsigned)(next[copy++]); 0782 if (state->head != Z_NULL && 0783 state->head->comment != Z_NULL && 0784 state->length < state->head->comm_max) 0785 state->head->comment[state->length++] = len; 0786 } while (len && copy < have); 0787 if (state->flags & 0x0200) 0788 state->check = crc32(state->check, next, copy); 0789 have -= copy; 0790 next += copy; 0791 if (len) goto inf_leave; 0792 } 0793 else if (state->head != Z_NULL) 0794 state->head->comment = Z_NULL; 0795 state->mode = HCRC; 0796 case HCRC: 0797 if (state->flags & 0x0200) { 0798 NEEDBITS(16); 0799 if (hold != (state->check & 0xffff)) { 0800 strm->msg = (char *)"header crc mismatch"; 0801 state->mode = BAD; 0802 break; 0803 } 0804 INITBITS(); 0805 } 0806 if (state->head != Z_NULL) { 0807 state->head->hcrc = (int)((state->flags >> 9) & 1); 0808 state->head->done = 1; 0809 } 0810 strm->adler = state->check = crc32(0L, Z_NULL, 0); 0811 state->mode = TYPE; 0812 break; 0813 #endif 0814 case DICTID: 0815 NEEDBITS(32); 0816 strm->adler = state->check = ZSWAP32(hold); 0817 INITBITS(); 0818 state->mode = DICT; 0819 case DICT: 0820 if (state->havedict == 0) { 0821 RESTORE(); 0822 return Z_NEED_DICT; 0823 } 0824 strm->adler = state->check = adler32(0L, Z_NULL, 0); 0825 state->mode = TYPE; 0826 case TYPE: 0827 if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; 0828 case TYPEDO: 0829 if (state->last) { 0830 BYTEBITS(); 0831 state->mode = CHECK; 0832 break; 0833 } 0834 NEEDBITS(3); 0835 state->last = BITS(1); 0836 DROPBITS(1); 0837 switch (BITS(2)) { 0838 case 0: /* stored block */ 0839 Tracev((stderr, "inflate: stored block%s\n", 0840 state->last ? " (last)" : "")); 0841 state->mode = STORED; 0842 break; 0843 case 1: /* fixed block */ 0844 fixedtables(state); 0845 Tracev((stderr, "inflate: fixed codes block%s\n", 0846 state->last ? " (last)" : "")); 0847 state->mode = LEN_; /* decode codes */ 0848 if (flush == Z_TREES) { 0849 DROPBITS(2); 0850 goto inf_leave; 0851 } 0852 break; 0853 case 2: /* dynamic block */ 0854 Tracev((stderr, "inflate: dynamic codes block%s\n", 0855 state->last ? " (last)" : "")); 0856 state->mode = TABLE; 0857 break; 0858 case 3: 0859 strm->msg = (char *)"invalid block type"; 0860 state->mode = BAD; 0861 } 0862 DROPBITS(2); 0863 break; 0864 case STORED: 0865 BYTEBITS(); /* go to byte boundary */ 0866 NEEDBITS(32); 0867 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { 0868 strm->msg = (char *)"invalid stored block lengths"; 0869 state->mode = BAD; 0870 break; 0871 } 0872 state->length = (unsigned)hold & 0xffff; 0873 Tracev((stderr, "inflate: stored length %u\n", 0874 state->length)); 0875 INITBITS(); 0876 state->mode = COPY_; 0877 if (flush == Z_TREES) goto inf_leave; 0878 case COPY_: 0879 state->mode = COPY; 0880 case COPY: 0881 copy = state->length; 0882 if (copy) { 0883 if (copy > have) copy = have; 0884 if (copy > left) copy = left; 0885 if (copy == 0) goto inf_leave; 0886 zmemcpy(put, next, copy); 0887 have -= copy; 0888 next += copy; 0889 left -= copy; 0890 put += copy; 0891 state->length -= copy; 0892 break; 0893 } 0894 Tracev((stderr, "inflate: stored end\n")); 0895 state->mode = TYPE; 0896 break; 0897 case TABLE: 0898 NEEDBITS(14); 0899 state->nlen = BITS(5) + 257; 0900 DROPBITS(5); 0901 state->ndist = BITS(5) + 1; 0902 DROPBITS(5); 0903 state->ncode = BITS(4) + 4; 0904 DROPBITS(4); 0905 #ifndef PKZIP_BUG_WORKAROUND 0906 if (state->nlen > 286 || state->ndist > 30) { 0907 strm->msg = (char *)"too many length or distance symbols"; 0908 state->mode = BAD; 0909 break; 0910 } 0911 #endif 0912 Tracev((stderr, "inflate: table sizes ok\n")); 0913 state->have = 0; 0914 state->mode = LENLENS; 0915 case LENLENS: 0916 while (state->have < state->ncode) { 0917 NEEDBITS(3); 0918 state->lens[order[state->have++]] = (unsigned short)BITS(3); 0919 DROPBITS(3); 0920 } 0921 while (state->have < 19) 0922 state->lens[order[state->have++]] = 0; 0923 state->next = state->codes; 0924 state->lencode = (const code FAR *)(state->next); 0925 state->lenbits = 7; 0926 ret = inflate_table(CODES, state->lens, 19, &(state->next), 0927 &(state->lenbits), state->work); 0928 if (ret) { 0929 strm->msg = (char *)"invalid code lengths set"; 0930 state->mode = BAD; 0931 break; 0932 } 0933 Tracev((stderr, "inflate: code lengths ok\n")); 0934 state->have = 0; 0935 state->mode = CODELENS; 0936 case CODELENS: 0937 while (state->have < state->nlen + state->ndist) { 0938 for (;;) { 0939 here = state->lencode[BITS(state->lenbits)]; 0940 if ((unsigned)(here.bits) <= bits) break; 0941 PULLBYTE(); 0942 } 0943 if (here.val < 16) { 0944 DROPBITS(here.bits); 0945 state->lens[state->have++] = here.val; 0946 } 0947 else { 0948 if (here.val == 16) { 0949 NEEDBITS(here.bits + 2); 0950 DROPBITS(here.bits); 0951 if (state->have == 0) { 0952 strm->msg = (char *)"invalid bit length repeat"; 0953 state->mode = BAD; 0954 break; 0955 } 0956 len = state->lens[state->have - 1]; 0957 copy = 3 + BITS(2); 0958 DROPBITS(2); 0959 } 0960 else if (here.val == 17) { 0961 NEEDBITS(here.bits + 3); 0962 DROPBITS(here.bits); 0963 len = 0; 0964 copy = 3 + BITS(3); 0965 DROPBITS(3); 0966 } 0967 else { 0968 NEEDBITS(here.bits + 7); 0969 DROPBITS(here.bits); 0970 len = 0; 0971 copy = 11 + BITS(7); 0972 DROPBITS(7); 0973 } 0974 if (state->have + copy > state->nlen + state->ndist) { 0975 strm->msg = (char *)"invalid bit length repeat"; 0976 state->mode = BAD; 0977 break; 0978 } 0979 while (copy--) 0980 state->lens[state->have++] = (unsigned short)len; 0981 } 0982 } 0983 0984 /* handle error breaks in while */ 0985 if (state->mode == BAD) break; 0986 0987 /* check for end-of-block code (better have one) */ 0988 if (state->lens[256] == 0) { 0989 strm->msg = (char *)"invalid code -- missing end-of-block"; 0990 state->mode = BAD; 0991 break; 0992 } 0993 0994 /* build code tables -- note: do not change the lenbits or distbits 0995 values here (9 and 6) without reading the comments in inftrees.h 0996 concerning the ENOUGH constants, which depend on those values */ 0997 state->next = state->codes; 0998 state->lencode = (const code FAR *)(state->next); 0999 state->lenbits = 9; 1000 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), 1001 &(state->lenbits), state->work); 1002 if (ret) { 1003 strm->msg = (char *)"invalid literal/lengths set"; 1004 state->mode = BAD; 1005 break; 1006 } 1007 state->distcode = (const code FAR *)(state->next); 1008 state->distbits = 6; 1009 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, 1010 &(state->next), &(state->distbits), state->work); 1011 if (ret) { 1012 strm->msg = (char *)"invalid distances set"; 1013 state->mode = BAD; 1014 break; 1015 } 1016 Tracev((stderr, "inflate: codes ok\n")); 1017 state->mode = LEN_; 1018 if (flush == Z_TREES) goto inf_leave; 1019 case LEN_: 1020 state->mode = LEN; 1021 case LEN: 1022 if (have >= 6 && left >= 258) { 1023 RESTORE(); 1024 inflate_fast(strm, out); 1025 LOAD(); 1026 if (state->mode == TYPE) 1027 state->back = -1; 1028 break; 1029 } 1030 state->back = 0; 1031 for (;;) { 1032 here = state->lencode[BITS(state->lenbits)]; 1033 if ((unsigned)(here.bits) <= bits) break; 1034 PULLBYTE(); 1035 } 1036 if (here.op && (here.op & 0xf0) == 0) { 1037 last = here; 1038 for (;;) { 1039 here = state->lencode[last.val + 1040 (BITS(last.bits + last.op) >> last.bits)]; 1041 if ((unsigned)(last.bits + here.bits) <= bits) break; 1042 PULLBYTE(); 1043 } 1044 DROPBITS(last.bits); 1045 state->back += last.bits; 1046 } 1047 DROPBITS(here.bits); 1048 state->back += here.bits; 1049 state->length = (unsigned)here.val; 1050 if ((int)(here.op) == 0) { 1051 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 1052 "inflate: literal '%c'\n" : 1053 "inflate: literal 0x%02x\n", here.val)); 1054 state->mode = LIT; 1055 break; 1056 } 1057 if (here.op & 32) { 1058 Tracevv((stderr, "inflate: end of block\n")); 1059 state->back = -1; 1060 state->mode = TYPE; 1061 break; 1062 } 1063 if (here.op & 64) { 1064 strm->msg = (char *)"invalid literal/length code"; 1065 state->mode = BAD; 1066 break; 1067 } 1068 state->extra = (unsigned)(here.op) & 15; 1069 state->mode = LENEXT; 1070 case LENEXT: 1071 if (state->extra) { 1072 NEEDBITS(state->extra); 1073 state->length += BITS(state->extra); 1074 DROPBITS(state->extra); 1075 state->back += state->extra; 1076 } 1077 Tracevv((stderr, "inflate: length %u\n", state->length)); 1078 state->was = state->length; 1079 state->mode = DIST; 1080 case DIST: 1081 for (;;) { 1082 here = state->distcode[BITS(state->distbits)]; 1083 if ((unsigned)(here.bits) <= bits) break; 1084 PULLBYTE(); 1085 } 1086 if ((here.op & 0xf0) == 0) { 1087 last = here; 1088 for (;;) { 1089 here = state->distcode[last.val + 1090 (BITS(last.bits + last.op) >> last.bits)]; 1091 if ((unsigned)(last.bits + here.bits) <= bits) break; 1092 PULLBYTE(); 1093 } 1094 DROPBITS(last.bits); 1095 state->back += last.bits; 1096 } 1097 DROPBITS(here.bits); 1098 state->back += here.bits; 1099 if (here.op & 64) { 1100 strm->msg = (char *)"invalid distance code"; 1101 state->mode = BAD; 1102 break; 1103 } 1104 state->offset = (unsigned)here.val; 1105 state->extra = (unsigned)(here.op) & 15; 1106 state->mode = DISTEXT; 1107 case DISTEXT: 1108 if (state->extra) { 1109 NEEDBITS(state->extra); 1110 state->offset += BITS(state->extra); 1111 DROPBITS(state->extra); 1112 state->back += state->extra; 1113 } 1114 #ifdef INFLATE_STRICT 1115 if (state->offset > state->dmax) { 1116 strm->msg = (char *)"invalid distance too far back"; 1117 state->mode = BAD; 1118 break; 1119 } 1120 #endif 1121 Tracevv((stderr, "inflate: distance %u\n", state->offset)); 1122 state->mode = MATCH; 1123 case MATCH: 1124 if (left == 0) goto inf_leave; 1125 copy = out - left; 1126 if (state->offset > copy) { /* copy from window */ 1127 copy = state->offset - copy; 1128 if (copy > state->whave) { 1129 if (state->sane) { 1130 strm->msg = (char *)"invalid distance too far back"; 1131 state->mode = BAD; 1132 break; 1133 } 1134 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1135 Trace((stderr, "inflate.c too far\n")); 1136 copy -= state->whave; 1137 if (copy > state->length) copy = state->length; 1138 if (copy > left) copy = left; 1139 left -= copy; 1140 state->length -= copy; 1141 do { 1142 *put++ = 0; 1143 } while (--copy); 1144 if (state->length == 0) state->mode = LEN; 1145 break; 1146 #endif 1147 } 1148 if (copy > state->wnext) { 1149 copy -= state->wnext; 1150 from = state->window + (state->wsize - copy); 1151 } 1152 else 1153 from = state->window + (state->wnext - copy); 1154 if (copy > state->length) copy = state->length; 1155 } 1156 else { /* copy from output */ 1157 from = put - state->offset; 1158 copy = state->length; 1159 } 1160 if (copy > left) copy = left; 1161 left -= copy; 1162 state->length -= copy; 1163 do { 1164 *put++ = *from++; 1165 } while (--copy); 1166 if (state->length == 0) state->mode = LEN; 1167 break; 1168 case LIT: 1169 if (left == 0) goto inf_leave; 1170 *put++ = (unsigned char)(state->length); 1171 left--; 1172 state->mode = LEN; 1173 break; 1174 case CHECK: 1175 if (state->wrap) { 1176 NEEDBITS(32); 1177 out -= left; 1178 strm->total_out += out; 1179 state->total += out; 1180 if (out) 1181 strm->adler = state->check = 1182 UPDATE(state->check, put - out, out); 1183 out = left; 1184 if (( 1185 #ifdef GUNZIP 1186 state->flags ? hold : 1187 #endif 1188 ZSWAP32(hold)) != state->check) { 1189 strm->msg = (char *)"incorrect data check"; 1190 state->mode = BAD; 1191 break; 1192 } 1193 INITBITS(); 1194 Tracev((stderr, "inflate: check matches trailer\n")); 1195 } 1196 #ifdef GUNZIP 1197 state->mode = LENGTH; 1198 case LENGTH: 1199 if (state->wrap && state->flags) { 1200 NEEDBITS(32); 1201 if (hold != (state->total & 0xffffffffUL)) { 1202 strm->msg = (char *)"incorrect length check"; 1203 state->mode = BAD; 1204 break; 1205 } 1206 INITBITS(); 1207 Tracev((stderr, "inflate: length matches trailer\n")); 1208 } 1209 #endif 1210 state->mode = DONE; 1211 case DONE: 1212 ret = Z_STREAM_END; 1213 goto inf_leave; 1214 case BAD: 1215 ret = Z_DATA_ERROR; 1216 goto inf_leave; 1217 case MEM: 1218 return Z_MEM_ERROR; 1219 case SYNC: 1220 default: 1221 return Z_STREAM_ERROR; 1222 } 1223 1224 /* 1225 Return from inflate(), updating the total counts and the check value. 1226 If there was no progress during the inflate() call, return a buffer 1227 error. Call updatewindow() to create and/or update the window state. 1228 Note: a memory error from inflate() is non-recoverable. 1229 */ 1230 inf_leave: 1231 RESTORE(); 1232 if (state->wsize || (out != strm->avail_out && state->mode < BAD && 1233 (state->mode < CHECK || flush != Z_FINISH))) 1234 if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { 1235 state->mode = MEM; 1236 return Z_MEM_ERROR; 1237 } 1238 in -= strm->avail_in; 1239 out -= strm->avail_out; 1240 strm->total_in += in; 1241 strm->total_out += out; 1242 state->total += out; 1243 if (state->wrap && out) 1244 strm->adler = state->check = 1245 UPDATE(state->check, strm->next_out - out, out); 1246 strm->data_type = state->bits + (state->last ? 64 : 0) + 1247 (state->mode == TYPE ? 128 : 0) + 1248 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); 1249 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) 1250 ret = Z_BUF_ERROR; 1251 return ret; 1252 } 1253 1254 int ZEXPORT inflateEnd(strm) 1255 z_streamp strm; 1256 { 1257 struct inflate_state FAR *state; 1258 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) 1259 return Z_STREAM_ERROR; 1260 state = (struct inflate_state FAR *)strm->state; 1261 if (state->window != Z_NULL) ZFREE(strm, state->window); 1262 ZFREE(strm, strm->state); 1263 strm->state = Z_NULL; 1264 Tracev((stderr, "inflate: end\n")); 1265 return Z_OK; 1266 } 1267 1268 int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) 1269 z_streamp strm; 1270 Bytef *dictionary; 1271 uInt *dictLength; 1272 { 1273 struct inflate_state FAR *state; 1274 1275 /* check state */ 1276 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 1277 state = (struct inflate_state FAR *)strm->state; 1278 1279 /* copy dictionary */ 1280 if (state->whave && dictionary != Z_NULL) { 1281 zmemcpy(dictionary, state->window + state->wnext, 1282 state->whave - state->wnext); 1283 zmemcpy(dictionary + state->whave - state->wnext, 1284 state->window, state->wnext); 1285 } 1286 if (dictLength != Z_NULL) 1287 *dictLength = state->whave; 1288 return Z_OK; 1289 } 1290 1291 int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) 1292 z_streamp strm; 1293 const Bytef *dictionary; 1294 uInt dictLength; 1295 { 1296 struct inflate_state FAR *state; 1297 unsigned long dictid; 1298 int ret; 1299 1300 /* check state */ 1301 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 1302 state = (struct inflate_state FAR *)strm->state; 1303 if (state->wrap != 0 && state->mode != DICT) 1304 return Z_STREAM_ERROR; 1305 1306 /* check for correct dictionary identifier */ 1307 if (state->mode == DICT) { 1308 dictid = adler32(0L, Z_NULL, 0); 1309 dictid = adler32(dictid, dictionary, dictLength); 1310 if (dictid != state->check) 1311 return Z_DATA_ERROR; 1312 } 1313 1314 /* copy dictionary to window using updatewindow(), which will amend the 1315 existing dictionary if appropriate */ 1316 ret = updatewindow(strm, dictionary + dictLength, dictLength); 1317 if (ret) { 1318 state->mode = MEM; 1319 return Z_MEM_ERROR; 1320 } 1321 state->havedict = 1; 1322 Tracev((stderr, "inflate: dictionary set\n")); 1323 return Z_OK; 1324 } 1325 1326 int ZEXPORT inflateGetHeader(strm, head) 1327 z_streamp strm; 1328 gz_headerp head; 1329 { 1330 struct inflate_state FAR *state; 1331 1332 /* check state */ 1333 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 1334 state = (struct inflate_state FAR *)strm->state; 1335 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; 1336 1337 /* save header structure */ 1338 state->head = head; 1339 head->done = 0; 1340 return Z_OK; 1341 } 1342 1343 /* 1344 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found 1345 or when out of input. When called, *have is the number of pattern bytes 1346 found in order so far, in 0..3. On return *have is updated to the new 1347 state. If on return *have equals four, then the pattern was found and the 1348 return value is how many bytes were read including the last byte of the 1349 pattern. If *have is less than four, then the pattern has not been found 1350 yet and the return value is len. In the latter case, syncsearch() can be 1351 called again with more data and the *have state. *have is initialized to 1352 zero for the first call. 1353 */ 1354 local unsigned syncsearch(have, buf, len) 1355 unsigned FAR *have; 1356 const unsigned char FAR *buf; 1357 unsigned len; 1358 { 1359 unsigned got; 1360 unsigned next; 1361 1362 got = *have; 1363 next = 0; 1364 while (next < len && got < 4) { 1365 if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) 1366 got++; 1367 else if (buf[next]) 1368 got = 0; 1369 else 1370 got = 4 - got; 1371 next++; 1372 } 1373 *have = got; 1374 return next; 1375 } 1376 1377 int ZEXPORT inflateSync(strm) 1378 z_streamp strm; 1379 { 1380 unsigned len; /* number of bytes to look at or looked at */ 1381 unsigned long in, out; /* temporary to save total_in and total_out */ 1382 unsigned char buf[4]; /* to restore bit buffer to byte string */ 1383 struct inflate_state FAR *state; 1384 1385 /* check parameters */ 1386 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 1387 state = (struct inflate_state FAR *)strm->state; 1388 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; 1389 1390 /* if first time, start search in bit buffer */ 1391 if (state->mode != SYNC) { 1392 state->mode = SYNC; 1393 state->hold <<= state->bits & 7; 1394 state->bits -= state->bits & 7; 1395 len = 0; 1396 while (state->bits >= 8) { 1397 buf[len++] = (unsigned char)(state->hold); 1398 state->hold >>= 8; 1399 state->bits -= 8; 1400 } 1401 state->have = 0; 1402 syncsearch(&(state->have), buf, len); 1403 } 1404 1405 /* search available input */ 1406 len = syncsearch(&(state->have), strm->next_in, strm->avail_in); 1407 strm->avail_in -= len; 1408 strm->next_in += len; 1409 strm->total_in += len; 1410 1411 /* return no joy or set up to restart inflate() on a new block */ 1412 if (state->have != 4) return Z_DATA_ERROR; 1413 in = strm->total_in; out = strm->total_out; 1414 inflateReset(strm); 1415 strm->total_in = in; strm->total_out = out; 1416 state->mode = TYPE; 1417 return Z_OK; 1418 } 1419 1420 /* 1421 Returns true if inflate is currently at the end of a block generated by 1422 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP 1423 implementation to provide an additional safety check. PPP uses 1424 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored 1425 block. When decompressing, PPP checks that at the end of input packet, 1426 inflate is waiting for these length bytes. 1427 */ 1428 int ZEXPORT inflateSyncPoint(strm) 1429 z_streamp strm; 1430 { 1431 struct inflate_state FAR *state; 1432 1433 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 1434 state = (struct inflate_state FAR *)strm->state; 1435 return state->mode == STORED && state->bits == 0; 1436 } 1437 1438 int ZEXPORT inflateCopy(dest, source) 1439 z_streamp dest; 1440 z_streamp source; 1441 { 1442 struct inflate_state FAR *state; 1443 struct inflate_state FAR *copy; 1444 unsigned char FAR *window; 1445 unsigned wsize; 1446 1447 /* check input */ 1448 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || 1449 source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) 1450 return Z_STREAM_ERROR; 1451 state = (struct inflate_state FAR *)source->state; 1452 1453 /* allocate space */ 1454 copy = (struct inflate_state FAR *) 1455 ZALLOC(source, 1, sizeof(struct inflate_state)); 1456 if (copy == Z_NULL) return Z_MEM_ERROR; 1457 window = Z_NULL; 1458 if (state->window != Z_NULL) { 1459 window = (unsigned char FAR *) 1460 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); 1461 if (window == Z_NULL) { 1462 ZFREE(source, copy); 1463 return Z_MEM_ERROR; 1464 } 1465 } 1466 1467 /* copy state */ 1468 zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); 1469 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); 1470 if (state->lencode >= state->codes && 1471 state->lencode <= state->codes + ENOUGH - 1) { 1472 copy->lencode = copy->codes + (state->lencode - state->codes); 1473 copy->distcode = copy->codes + (state->distcode - state->codes); 1474 } 1475 copy->next = copy->codes + (state->next - state->codes); 1476 if (window != Z_NULL) { 1477 wsize = 1U << state->wbits; 1478 zmemcpy(window, state->window, wsize); 1479 } 1480 copy->window = window; 1481 dest->state = (struct internal_state FAR *)copy; 1482 return Z_OK; 1483 } 1484 1485 int ZEXPORT inflateUndermine(strm, subvert) 1486 z_streamp strm; 1487 int subvert; 1488 { 1489 struct inflate_state FAR *state; 1490 1491 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 1492 state = (struct inflate_state FAR *)strm->state; 1493 state->sane = !subvert; 1494 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 1495 return Z_OK; 1496 #else 1497 state->sane = 1; 1498 return Z_DATA_ERROR; 1499 #endif 1500 } 1501 1502 long ZEXPORT inflateMark(strm) 1503 z_streamp strm; 1504 { 1505 struct inflate_state FAR *state; 1506 1507 if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; 1508 state = (struct inflate_state FAR *)strm->state; 1509 return ((long)(state->back) << 16) + 1510 (state->mode == COPY ? state->length : 1511 (state->mode == MATCH ? state->was - state->length : 0)); 1512 }