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