1 /* infback.c -- inflate using a call-back interface 2 * Copyright (C) 1995-2022 Mark Adler 3 * For conditions of distribution and use, see copyright notice in zlib.h 4 */ 5 6 /* 7 This code is largely copied from inflate.c. Normally either infback.o or 8 inflate.o would be linked into an application--not both. The interface 9 with inffast.c is retained so that optimized assembler-coded versions of 10 inflate_fast() can be used with either inflate.c or infback.c. 11 */ 12 13 #include "zutil.h" 14 #include "inftrees.h" 15 #include "inflate.h" 16 #include "inffast.h" 17 18 /* 19 strm provides memory allocation functions in zalloc and zfree, or 20 Z_NULL to use the library memory allocation functions. 21 22 windowBits is in the range 8..15, and window is a user-supplied 23 window and output buffer that is 2**windowBits bytes. 24 */ 25 int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, 26 unsigned char FAR *window, const char *version, 27 int stream_size) { 28 struct inflate_state FAR *state; 29 30 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || 31 stream_size != (int)(sizeof(z_stream))) 32 return Z_VERSION_ERROR; 33 if (strm == Z_NULL || window == Z_NULL || 34 windowBits < 8 || windowBits > 15) 35 return Z_STREAM_ERROR; 36 strm->msg = Z_NULL; /* in case we return an error */ 37 if (strm->zalloc == (alloc_func)0) { 38 #ifdef Z_SOLO 39 return Z_STREAM_ERROR; 40 #else 41 strm->zalloc = zcalloc; 42 strm->opaque = (voidpf)0; 43 #endif 44 } 45 if (strm->zfree == (free_func)0) 46 #ifdef Z_SOLO 47 return Z_STREAM_ERROR; 48 #else 49 strm->zfree = zcfree; 50 #endif 51 state = (struct inflate_state FAR *)ZALLOC(strm, 1, 52 sizeof(struct inflate_state)); 53 if (state == Z_NULL) return Z_MEM_ERROR; 54 Tracev((stderr, "inflate: allocated\n")); 55 strm->state = (struct internal_state FAR *)state; 56 state->dmax = 32768U; 57 state->wbits = (uInt)windowBits; 58 state->wsize = 1U << windowBits; 59 state->window = window; 60 state->wnext = 0; 61 state->whave = 0; 62 state->sane = 1; 63 return Z_OK; 64 } 65 66 /* 67 Return state with length and distance decoding tables and index sizes set to 68 fixed code decoding. Normally this returns fixed tables from inffixed.h. 69 If BUILDFIXED is defined, then instead this routine builds the tables the 70 first time it's called, and returns those tables the first time and 71 thereafter. This reduces the size of the code by about 2K bytes, in 72 exchange for a little execution time. However, BUILDFIXED should not be 73 used for threaded applications, since the rewriting of the tables and virgin 74 may not be thread-safe. 75 */ 76 local void fixedtables(struct inflate_state FAR *state) { 77 #ifdef BUILDFIXED 78 static int virgin = 1; 79 static code *lenfix, *distfix; 80 static code fixed[544]; 81 82 /* build fixed huffman tables if first call (may not be thread safe) */ 83 if (virgin) { 84 unsigned sym, bits; 85 static code *next; 86 87 /* literal/length table */ 88 sym = 0; 89 while (sym < 144) state->lens[sym++] = 8; 90 while (sym < 256) state->lens[sym++] = 9; 91 while (sym < 280) state->lens[sym++] = 7; 92 while (sym < 288) state->lens[sym++] = 8; 93 next = fixed; 94 lenfix = next; 95 bits = 9; 96 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); 97 98 /* distance table */ 99 sym = 0; 100 while (sym < 32) state->lens[sym++] = 5; 101 distfix = next; 102 bits = 5; 103 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); 104 105 /* do this just once */ 106 virgin = 0; 107 } 108 #else /* !BUILDFIXED */ 109 # include "inffixed.h" 110 #endif /* BUILDFIXED */ 111 state->lencode = lenfix; 112 state->lenbits = 9; 113 state->distcode = distfix; 114 state->distbits = 5; 115 } 116 117 /* Macros for inflateBack(): */ 118 119 /* Load returned state from inflate_fast() */ 120 #define LOAD() \ 121 do { \ 122 put = strm->next_out; \ 123 left = strm->avail_out; \ 124 next = strm->next_in; \ 125 have = strm->avail_in; \ 126 hold = state->hold; \ 127 bits = state->bits; \ 128 } while (0) 129 130 /* Set state from registers for inflate_fast() */ 131 #define RESTORE() \ 132 do { \ 133 strm->next_out = put; \ 134 strm->avail_out = left; \ 135 strm->next_in = next; \ 136 strm->avail_in = have; \ 137 state->hold = hold; \ 138 state->bits = bits; \ 139 } while (0) 140 141 /* Clear the input bit accumulator */ 142 #define INITBITS() \ 143 do { \ 144 hold = 0; \ 145 bits = 0; \ 146 } while (0) 147 148 /* Assure that some input is available. If input is requested, but denied, 149 then return a Z_BUF_ERROR from inflateBack(). */ 150 #define PULL() \ 151 do { \ 152 if (have == 0) { \ 153 have = in(in_desc, &next); \ 154 if (have == 0) { \ 155 next = Z_NULL; \ 156 ret = Z_BUF_ERROR; \ 157 goto inf_leave; \ 158 } \ 159 } \ 160 } while (0) 161 162 /* Get a byte of input into the bit accumulator, or return from inflateBack() 163 with an error if there is no input available. */ 164 #define PULLBYTE() \ 165 do { \ 166 PULL(); \ 167 have--; \ 168 hold += (unsigned long)(*next++) << bits; \ 169 bits += 8; \ 170 } while (0) 171 172 /* Assure that there are at least n bits in the bit accumulator. If there is 173 not enough available input to do that, then return from inflateBack() with 174 an error. */ 175 #define NEEDBITS(n) \ 176 do { \ 177 while (bits < (unsigned)(n)) \ 178 PULLBYTE(); \ 179 } while (0) 180 181 /* Return the low n bits of the bit accumulator (n < 16) */ 182 #define BITS(n) \ 183 ((unsigned)hold & ((1U << (n)) - 1)) 184 185 /* Remove n bits from the bit accumulator */ 186 #define DROPBITS(n) \ 187 do { \ 188 hold >>= (n); \ 189 bits -= (unsigned)(n); \ 190 } while (0) 191 192 /* Remove zero to seven bits as needed to go to a byte boundary */ 193 #define BYTEBITS() \ 194 do { \ 195 hold >>= bits & 7; \ 196 bits -= bits & 7; \ 197 } while (0) 198 199 /* Assure that some output space is available, by writing out the window 200 if it's full. If the write fails, return from inflateBack() with a 201 Z_BUF_ERROR. */ 202 #define ROOM() \ 203 do { \ 204 if (left == 0) { \ 205 put = state->window; \ 206 left = state->wsize; \ 207 state->whave = left; \ 208 if (out(out_desc, put, left)) { \ 209 ret = Z_BUF_ERROR; \ 210 goto inf_leave; \ 211 } \ 212 } \ 213 } while (0) 214 215 /* 216 strm provides the memory allocation functions and window buffer on input, 217 and provides information on the unused input on return. For Z_DATA_ERROR 218 returns, strm will also provide an error message. 219 220 in() and out() are the call-back input and output functions. When 221 inflateBack() needs more input, it calls in(). When inflateBack() has 222 filled the window with output, or when it completes with data in the 223 window, it calls out() to write out the data. The application must not 224 change the provided input until in() is called again or inflateBack() 225 returns. The application must not change the window/output buffer until 226 inflateBack() returns. 227 228 in() and out() are called with a descriptor parameter provided in the 229 inflateBack() call. This parameter can be a structure that provides the 230 information required to do the read or write, as well as accumulated 231 information on the input and output such as totals and check values. 232 233 in() should return zero on failure. out() should return non-zero on 234 failure. If either in() or out() fails, than inflateBack() returns a 235 Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it 236 was in() or out() that caused in the error. Otherwise, inflateBack() 237 returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format 238 error, or Z_MEM_ERROR if it could not allocate memory for the state. 239 inflateBack() can also return Z_STREAM_ERROR if the input parameters 240 are not correct, i.e. strm is Z_NULL or the state was not initialized. 241 */ 242 int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, 243 out_func out, void FAR *out_desc) { 244 struct inflate_state FAR *state; 245 z_const unsigned char FAR *next; /* next input */ 246 unsigned char FAR *put; /* next output */ 247 unsigned have, left; /* available input and output */ 248 unsigned long hold; /* bit buffer */ 249 unsigned bits; /* bits in bit buffer */ 250 unsigned copy; /* number of stored or match bytes to copy */ 251 unsigned char FAR *from; /* where to copy match bytes from */ 252 code here; /* current decoding table entry */ 253 code last; /* parent table entry */ 254 unsigned len; /* length to copy for repeats, bits to drop */ 255 int ret; /* return code */ 256 static const unsigned short order[19] = /* permutation of code lengths */ 257 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; 258 259 /* Check that the strm exists and that the state was initialized */ 260 if (strm == Z_NULL || strm->state == Z_NULL) 261 return Z_STREAM_ERROR; 262 state = (struct inflate_state FAR *)strm->state; 263 264 /* Reset the state */ 265 strm->msg = Z_NULL; 266 state->mode = TYPE; 267 state->last = 0; 268 state->whave = 0; 269 next = strm->next_in; 270 have = next != Z_NULL ? strm->avail_in : 0; 271 hold = 0; 272 bits = 0; 273 put = state->window; 274 left = state->wsize; 275 276 /* Inflate until end of block marked as last */ 277 for (;;) 278 switch (state->mode) { 279 case TYPE: 280 /* determine and dispatch block type */ 281 if (state->last) { 282 BYTEBITS(); 283 state->mode = DONE; 284 break; 285 } 286 NEEDBITS(3); 287 state->last = BITS(1); 288 DROPBITS(1); 289 switch (BITS(2)) { 290 case 0: /* stored block */ 291 Tracev((stderr, "inflate: stored block%s\n", 292 state->last ? " (last)" : "")); 293 state->mode = STORED; 294 break; 295 case 1: /* fixed block */ 296 fixedtables(state); 297 Tracev((stderr, "inflate: fixed codes block%s\n", 298 state->last ? " (last)" : "")); 299 state->mode = LEN; /* decode codes */ 300 break; 301 case 2: /* dynamic block */ 302 Tracev((stderr, "inflate: dynamic codes block%s\n", 303 state->last ? " (last)" : "")); 304 state->mode = TABLE; 305 break; 306 case 3: 307 #ifdef SMALL 308 strm->msg = (z_const char *)"error"; 309 #else 310 strm->msg = (z_const char *)"invalid block type"; 311 #endif 312 state->mode = BAD; 313 } 314 DROPBITS(2); 315 break; 316 317 case STORED: 318 /* get and verify stored block length */ 319 BYTEBITS(); /* go to byte boundary */ 320 NEEDBITS(32); 321 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { 322 #ifdef SMALL 323 strm->msg = (z_const char *)"error"; 324 #else 325 strm->msg = (z_const char *)"invalid stored block lengths"; 326 #endif 327 state->mode = BAD; 328 break; 329 } 330 state->length = (unsigned)hold & 0xffff; 331 Tracev((stderr, "inflate: stored length %u\n", 332 state->length)); 333 INITBITS(); 334 335 /* copy stored block from input to output */ 336 while (state->length != 0) { 337 copy = state->length; 338 PULL(); 339 ROOM(); 340 if (copy > have) copy = have; 341 if (copy > left) copy = left; 342 zmemcpy(put, next, copy); 343 have -= copy; 344 next += copy; 345 left -= copy; 346 put += copy; 347 state->length -= copy; 348 } 349 Tracev((stderr, "inflate: stored end\n")); 350 state->mode = TYPE; 351 break; 352 353 case TABLE: 354 /* get dynamic table entries descriptor */ 355 NEEDBITS(14); 356 state->nlen = BITS(5) + 257; 357 DROPBITS(5); 358 state->ndist = BITS(5) + 1; 359 DROPBITS(5); 360 state->ncode = BITS(4) + 4; 361 DROPBITS(4); 362 #ifndef PKZIP_BUG_WORKAROUND 363 if (state->nlen > 286 || state->ndist > 30) { 364 #ifdef SMALL 365 strm->msg = (z_const char *)"error"; 366 #else 367 strm->msg = (z_const char *)"too many length or distance symbols"; 368 #endif 369 state->mode = BAD; 370 break; 371 } 372 #endif 373 Tracev((stderr, "inflate: table sizes ok\n")); 374 375 /* get code length code lengths (not a typo) */ 376 state->have = 0; 377 while (state->have < state->ncode) { 378 NEEDBITS(3); 379 state->lens[order[state->have++]] = (unsigned short)BITS(3); 380 DROPBITS(3); 381 } 382 while (state->have < 19) 383 state->lens[order[state->have++]] = 0; 384 state->next = state->codes; 385 state->lencode = (code const FAR *)(state->next); 386 state->lenbits = 7; 387 ret = inflate_table(CODES, state->lens, 19, &(state->next), 388 &(state->lenbits), state->work); 389 if (ret) { 390 #ifdef SMALL 391 strm->msg = (z_const char *)"error"; 392 #else 393 strm->msg = (z_const char *)"invalid code lengths set"; 394 #endif 395 state->mode = BAD; 396 break; 397 } 398 Tracev((stderr, "inflate: code lengths ok\n")); 399 400 /* get length and distance code code lengths */ 401 state->have = 0; 402 while (state->have < state->nlen + state->ndist) { 403 for (;;) { 404 here = state->lencode[BITS(state->lenbits)]; 405 if ((unsigned)(here.bits) <= bits) break; 406 PULLBYTE(); 407 } 408 if (here.val < 16) { 409 DROPBITS(here.bits); 410 state->lens[state->have++] = here.val; 411 } 412 else { 413 if (here.val == 16) { 414 NEEDBITS(here.bits + 2); 415 DROPBITS(here.bits); 416 if (state->have == 0) { 417 #ifdef SMALL 418 strm->msg = (z_const char *)"error"; 419 #else 420 strm->msg = (z_const char *)"invalid bit length repeat"; 421 #endif 422 state->mode = BAD; 423 break; 424 } 425 len = (unsigned)(state->lens[state->have - 1]); 426 copy = 3 + BITS(2); 427 DROPBITS(2); 428 } 429 else if (here.val == 17) { 430 NEEDBITS(here.bits + 3); 431 DROPBITS(here.bits); 432 len = 0; 433 copy = 3 + BITS(3); 434 DROPBITS(3); 435 } 436 else { 437 NEEDBITS(here.bits + 7); 438 DROPBITS(here.bits); 439 len = 0; 440 copy = 11 + BITS(7); 441 DROPBITS(7); 442 } 443 if (state->have + copy > state->nlen + state->ndist) { 444 #ifdef SMALL 445 strm->msg = (z_const char *)"error"; 446 #else 447 strm->msg = (z_const char *)"invalid bit length repeat"; 448 #endif 449 state->mode = BAD; 450 break; 451 } 452 while (copy--) 453 state->lens[state->have++] = (unsigned short)len; 454 } 455 } 456 457 /* handle error breaks in while */ 458 if (state->mode == BAD) break; 459 460 /* check for end-of-block code (better have one) */ 461 if (state->lens[256] == 0) { 462 #ifdef SMALL 463 strm->msg = (z_const char *)"error"; 464 #else 465 strm->msg = (z_const char *)"invalid code -- missing end-of-block"; 466 #endif 467 state->mode = BAD; 468 break; 469 } 470 471 /* build code tables -- note: do not change the lenbits or distbits 472 values here (9 and 6) without reading the comments in inftrees.h 473 concerning the ENOUGH constants, which depend on those values */ 474 state->next = state->codes; 475 state->lencode = (code const FAR *)(state->next); 476 state->lenbits = 9; 477 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), 478 &(state->lenbits), state->work); 479 if (ret) { 480 #ifdef SMALL 481 strm->msg = (z_const char *)"error"; 482 #else 483 strm->msg = (z_const char *)"invalid literal/lengths set"; 484 #endif 485 state->mode = BAD; 486 break; 487 } 488 state->distcode = (code const FAR *)(state->next); 489 state->distbits = 6; 490 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, 491 &(state->next), &(state->distbits), state->work); 492 if (ret) { 493 #ifdef SMALL 494 strm->msg = (z_const char *)"error"; 495 #else 496 strm->msg = (z_const char *)"invalid distances set"; 497 #endif 498 state->mode = BAD; 499 break; 500 } 501 Tracev((stderr, "inflate: codes ok\n")); 502 state->mode = LEN; 503 /* fallthrough */ 504 505 case LEN: 506 #ifndef SLOW 507 /* use inflate_fast() if we have enough input and output */ 508 if (have >= 6 && left >= 258) { 509 RESTORE(); 510 if (state->whave < state->wsize) 511 state->whave = state->wsize - left; 512 inflate_fast(strm, state->wsize); 513 LOAD(); 514 break; 515 } 516 #endif 517 518 /* get a literal, length, or end-of-block code */ 519 for (;;) { 520 here = state->lencode[BITS(state->lenbits)]; 521 if ((unsigned)(here.bits) <= bits) break; 522 PULLBYTE(); 523 } 524 if (here.op && (here.op & 0xf0) == 0) { 525 last = here; 526 for (;;) { 527 here = state->lencode[last.val + 528 (BITS(last.bits + last.op) >> last.bits)]; 529 if ((unsigned)(last.bits + here.bits) <= bits) break; 530 PULLBYTE(); 531 } 532 DROPBITS(last.bits); 533 } 534 DROPBITS(here.bits); 535 state->length = (unsigned)here.val; 536 537 /* process literal */ 538 if (here.op == 0) { 539 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 540 "inflate: literal '%c'\n" : 541 "inflate: literal 0x%02x\n", here.val)); 542 ROOM(); 543 *put++ = (unsigned char)(state->length); 544 left--; 545 state->mode = LEN; 546 break; 547 } 548 549 /* process end of block */ 550 if (here.op & 32) { 551 Tracevv((stderr, "inflate: end of block\n")); 552 state->mode = TYPE; 553 break; 554 } 555 556 /* invalid code */ 557 if (here.op & 64) { 558 #ifdef SMALL 559 strm->msg = (z_const char *)"error"; 560 #else 561 strm->msg = (z_const char *)"invalid literal/length code"; 562 #endif 563 state->mode = BAD; 564 break; 565 } 566 567 /* length code -- get extra bits, if any */ 568 state->extra = (unsigned)(here.op) & 15; 569 if (state->extra != 0) { 570 NEEDBITS(state->extra); 571 state->length += BITS(state->extra); 572 DROPBITS(state->extra); 573 } 574 Tracevv((stderr, "inflate: length %u\n", state->length)); 575 576 /* get distance code */ 577 for (;;) { 578 here = state->distcode[BITS(state->distbits)]; 579 if ((unsigned)(here.bits) <= bits) break; 580 PULLBYTE(); 581 } 582 if ((here.op & 0xf0) == 0) { 583 last = here; 584 for (;;) { 585 here = state->distcode[last.val + 586 (BITS(last.bits + last.op) >> last.bits)]; 587 if ((unsigned)(last.bits + here.bits) <= bits) break; 588 PULLBYTE(); 589 } 590 DROPBITS(last.bits); 591 } 592 DROPBITS(here.bits); 593 if (here.op & 64) { 594 #ifdef SMALL 595 strm->msg = (z_const char *)"error"; 596 #else 597 strm->msg = (z_const char *)"invalid distance code"; 598 #endif 599 state->mode = BAD; 600 break; 601 } 602 state->offset = (unsigned)here.val; 603 604 /* get distance extra bits, if any */ 605 state->extra = (unsigned)(here.op) & 15; 606 if (state->extra != 0) { 607 NEEDBITS(state->extra); 608 state->offset += BITS(state->extra); 609 DROPBITS(state->extra); 610 } 611 if (state->offset > state->wsize - (state->whave < state->wsize ? 612 left : 0)) { 613 #ifdef SMALL 614 strm->msg = (z_const char *)"error"; 615 #else 616 strm->msg = (z_const char *)"invalid distance too far back"; 617 #endif 618 state->mode = BAD; 619 break; 620 } 621 Tracevv((stderr, "inflate: distance %u\n", state->offset)); 622 623 /* copy match from window to output */ 624 do { 625 ROOM(); 626 copy = state->wsize - state->offset; 627 if (copy < left) { 628 from = put + copy; 629 copy = left - copy; 630 } 631 else { 632 from = put - state->offset; 633 copy = left; 634 } 635 if (copy > state->length) copy = state->length; 636 state->length -= copy; 637 left -= copy; 638 do { 639 *put++ = *from++; 640 } while (--copy); 641 } while (state->length != 0); 642 break; 643 644 case DONE: 645 /* inflate stream terminated properly */ 646 ret = Z_STREAM_END; 647 goto inf_leave; 648 649 case BAD: 650 ret = Z_DATA_ERROR; 651 goto inf_leave; 652 653 default: 654 /* can't happen, but makes compilers happy */ 655 ret = Z_STREAM_ERROR; 656 goto inf_leave; 657 } 658 659 /* Write leftover output and return unused input */ 660 inf_leave: 661 if (left < state->wsize) { 662 if (out(out_desc, state->window, state->wsize - left) && 663 ret == Z_STREAM_END) 664 ret = Z_BUF_ERROR; 665 } 666 strm->next_in = next; 667 strm->avail_in = have; 668 return ret; 669 } 670 671 int ZEXPORT inflateBackEnd(z_streamp strm) { 672 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) 673 return Z_STREAM_ERROR; 674 ZFREE(strm, strm->state); 675 strm->state = Z_NULL; 676 Tracev((stderr, "inflate: end\n")); 677 return Z_OK; 678 } 679