xz_dec_stream.c revision 229159
1/* 2 * .xz Stream decoder 3 * 4 * Author: Lasse Collin <lasse.collin@tukaani.org> 5 * 6 * This file has been put into the public domain. 7 * You can do whatever you want with this file. 8 */ 9 10#include "xz_private.h" 11#include "xz_stream.h" 12 13/* Hash used to validate the Index field */ 14struct xz_dec_hash { 15 vli_type unpadded; 16 vli_type uncompressed; 17 uint32_t crc32; 18}; 19 20struct xz_dec { 21 /* Position in dec_main() */ 22 enum { 23 SEQ_STREAM_HEADER, 24 SEQ_BLOCK_START, 25 SEQ_BLOCK_HEADER, 26 SEQ_BLOCK_UNCOMPRESS, 27 SEQ_BLOCK_PADDING, 28 SEQ_BLOCK_CHECK, 29 SEQ_INDEX, 30 SEQ_INDEX_PADDING, 31 SEQ_INDEX_CRC32, 32 SEQ_STREAM_FOOTER 33 } sequence; 34 35 /* Position in variable-length integers and Check fields */ 36 uint32_t pos; 37 38 /* Variable-length integer decoded by dec_vli() */ 39 vli_type vli; 40 41 /* Saved in_pos and out_pos */ 42 size_t in_start; 43 size_t out_start; 44 45 /* CRC32 value in Block or Index */ 46 uint32_t crc32; 47 48 /* Type of the integrity check calculated from uncompressed data */ 49 enum xz_check check_type; 50 51 /* Operation mode */ 52 enum xz_mode mode; 53 54 /* 55 * True if the next call to xz_dec_run() is allowed to return 56 * XZ_BUF_ERROR. 57 */ 58 bool allow_buf_error; 59 60 /* Information stored in Block Header */ 61 struct { 62 /* 63 * Value stored in the Compressed Size field, or 64 * VLI_UNKNOWN if Compressed Size is not present. 65 */ 66 vli_type compressed; 67 68 /* 69 * Value stored in the Uncompressed Size field, or 70 * VLI_UNKNOWN if Uncompressed Size is not present. 71 */ 72 vli_type uncompressed; 73 74 /* Size of the Block Header field */ 75 uint32_t size; 76 } block_header; 77 78 /* Information collected when decoding Blocks */ 79 struct { 80 /* Observed compressed size of the current Block */ 81 vli_type compressed; 82 83 /* Observed uncompressed size of the current Block */ 84 vli_type uncompressed; 85 86 /* Number of Blocks decoded so far */ 87 vli_type count; 88 89 /* 90 * Hash calculated from the Block sizes. This is used to 91 * validate the Index field. 92 */ 93 struct xz_dec_hash hash; 94 } block; 95 96 /* Variables needed when verifying the Index field */ 97 struct { 98 /* Position in dec_index() */ 99 enum { 100 SEQ_INDEX_COUNT, 101 SEQ_INDEX_UNPADDED, 102 SEQ_INDEX_UNCOMPRESSED 103 } sequence; 104 105 /* Size of the Index in bytes */ 106 vli_type size; 107 108 /* Number of Records (matches block.count in valid files) */ 109 vli_type count; 110 111 /* 112 * Hash calculated from the Records (matches block.hash in 113 * valid files). 114 */ 115 struct xz_dec_hash hash; 116 } index; 117 118 /* 119 * Temporary buffer needed to hold Stream Header, Block Header, 120 * and Stream Footer. The Block Header is the biggest (1 KiB) 121 * so we reserve space according to that. buf[] has to be aligned 122 * to a multiple of four bytes; the size_t variables before it 123 * should guarantee this. 124 */ 125 struct { 126 size_t pos; 127 size_t size; 128 uint8_t buf[1024]; 129 } temp; 130 131 struct xz_dec_lzma2 *lzma2; 132 133#ifdef XZ_DEC_BCJ 134 struct xz_dec_bcj *bcj; 135 bool bcj_active; 136#endif 137}; 138 139#ifdef XZ_DEC_ANY_CHECK 140/* Sizes of the Check field with different Check IDs */ 141static const uint8_t check_sizes[16] = { 142 0, 143 4, 4, 4, 144 8, 8, 8, 145 16, 16, 16, 146 32, 32, 32, 147 64, 64, 64 148}; 149#endif 150 151/* 152 * Fill s->temp by copying data starting from b->in[b->in_pos]. Caller 153 * must have set s->temp.pos to indicate how much data we are supposed 154 * to copy into s->temp.buf. Return true once s->temp.pos has reached 155 * s->temp.size. 156 */ 157static bool fill_temp(struct xz_dec *s, struct xz_buf *b) 158{ 159 size_t copy_size = min_t(size_t, 160 b->in_size - b->in_pos, s->temp.size - s->temp.pos); 161 162 memcpy(s->temp.buf + s->temp.pos, b->in + b->in_pos, copy_size); 163 b->in_pos += copy_size; 164 s->temp.pos += copy_size; 165 166 if (s->temp.pos == s->temp.size) { 167 s->temp.pos = 0; 168 return true; 169 } 170 171 return false; 172} 173 174/* Decode a variable-length integer (little-endian base-128 encoding) */ 175static enum xz_ret dec_vli(struct xz_dec *s, const uint8_t *in, 176 size_t *in_pos, size_t in_size) 177{ 178 uint8_t byte; 179 180 if (s->pos == 0) 181 s->vli = 0; 182 183 while (*in_pos < in_size) { 184 byte = in[*in_pos]; 185 ++*in_pos; 186 187 s->vli |= (vli_type)(byte & 0x7F) << s->pos; 188 189 if ((byte & 0x80) == 0) { 190 /* Don't allow non-minimal encodings. */ 191 if (byte == 0 && s->pos != 0) 192 return XZ_DATA_ERROR; 193 194 s->pos = 0; 195 return XZ_STREAM_END; 196 } 197 198 s->pos += 7; 199 if (s->pos == 7 * VLI_BYTES_MAX) 200 return XZ_DATA_ERROR; 201 } 202 203 return XZ_OK; 204} 205 206/* 207 * Decode the Compressed Data field from a Block. Update and validate 208 * the observed compressed and uncompressed sizes of the Block so that 209 * they don't exceed the values possibly stored in the Block Header 210 * (validation assumes that no integer overflow occurs, since vli_type 211 * is normally uint64_t). Update the CRC32 if presence of the CRC32 212 * field was indicated in Stream Header. 213 * 214 * Once the decoding is finished, validate that the observed sizes match 215 * the sizes possibly stored in the Block Header. Update the hash and 216 * Block count, which are later used to validate the Index field. 217 */ 218static enum xz_ret dec_block(struct xz_dec *s, struct xz_buf *b) 219{ 220 enum xz_ret ret; 221 222 s->in_start = b->in_pos; 223 s->out_start = b->out_pos; 224 225#ifdef XZ_DEC_BCJ 226 if (s->bcj_active) 227 ret = xz_dec_bcj_run(s->bcj, s->lzma2, b); 228 else 229#endif 230 ret = xz_dec_lzma2_run(s->lzma2, b); 231 232 s->block.compressed += b->in_pos - s->in_start; 233 s->block.uncompressed += b->out_pos - s->out_start; 234 235 /* 236 * There is no need to separately check for VLI_UNKNOWN, since 237 * the observed sizes are always smaller than VLI_UNKNOWN. 238 */ 239 if (s->block.compressed > s->block_header.compressed 240 || s->block.uncompressed 241 > s->block_header.uncompressed) 242 return XZ_DATA_ERROR; 243 244 if (s->check_type == XZ_CHECK_CRC32) 245 s->crc32 = xz_crc32(b->out + s->out_start, 246 b->out_pos - s->out_start, s->crc32); 247 248 if (ret == XZ_STREAM_END) { 249 if (s->block_header.compressed != VLI_UNKNOWN 250 && s->block_header.compressed 251 != s->block.compressed) 252 return XZ_DATA_ERROR; 253 254 if (s->block_header.uncompressed != VLI_UNKNOWN 255 && s->block_header.uncompressed 256 != s->block.uncompressed) 257 return XZ_DATA_ERROR; 258 259 s->block.hash.unpadded += s->block_header.size 260 + s->block.compressed; 261 262#ifdef XZ_DEC_ANY_CHECK 263 s->block.hash.unpadded += check_sizes[s->check_type]; 264#else 265 if (s->check_type == XZ_CHECK_CRC32) 266 s->block.hash.unpadded += 4; 267#endif 268 269 s->block.hash.uncompressed += s->block.uncompressed; 270 s->block.hash.crc32 = xz_crc32( 271 (const uint8_t *)&s->block.hash, 272 sizeof(s->block.hash), s->block.hash.crc32); 273 274 ++s->block.count; 275 } 276 277 return ret; 278} 279 280/* Update the Index size and the CRC32 value. */ 281static void index_update(struct xz_dec *s, const struct xz_buf *b) 282{ 283 size_t in_used = b->in_pos - s->in_start; 284 s->index.size += in_used; 285 s->crc32 = xz_crc32(b->in + s->in_start, in_used, s->crc32); 286} 287 288/* 289 * Decode the Number of Records, Unpadded Size, and Uncompressed Size 290 * fields from the Index field. That is, Index Padding and CRC32 are not 291 * decoded by this function. 292 * 293 * This can return XZ_OK (more input needed), XZ_STREAM_END (everything 294 * successfully decoded), or XZ_DATA_ERROR (input is corrupt). 295 */ 296static enum xz_ret dec_index(struct xz_dec *s, struct xz_buf *b) 297{ 298 enum xz_ret ret; 299 300 do { 301 ret = dec_vli(s, b->in, &b->in_pos, b->in_size); 302 if (ret != XZ_STREAM_END) { 303 index_update(s, b); 304 return ret; 305 } 306 307 switch (s->index.sequence) { 308 case SEQ_INDEX_COUNT: 309 s->index.count = s->vli; 310 311 /* 312 * Validate that the Number of Records field 313 * indicates the same number of Records as 314 * there were Blocks in the Stream. 315 */ 316 if (s->index.count != s->block.count) 317 return XZ_DATA_ERROR; 318 319 s->index.sequence = SEQ_INDEX_UNPADDED; 320 break; 321 322 case SEQ_INDEX_UNPADDED: 323 s->index.hash.unpadded += s->vli; 324 s->index.sequence = SEQ_INDEX_UNCOMPRESSED; 325 break; 326 327 case SEQ_INDEX_UNCOMPRESSED: 328 s->index.hash.uncompressed += s->vli; 329 s->index.hash.crc32 = xz_crc32( 330 (const uint8_t *)&s->index.hash, 331 sizeof(s->index.hash), 332 s->index.hash.crc32); 333 --s->index.count; 334 s->index.sequence = SEQ_INDEX_UNPADDED; 335 break; 336 } 337 } while (s->index.count > 0); 338 339 return XZ_STREAM_END; 340} 341 342/* 343 * Validate that the next four input bytes match the value of s->crc32. 344 * s->pos must be zero when starting to validate the first byte. 345 */ 346static enum xz_ret crc32_validate(struct xz_dec *s, struct xz_buf *b) 347{ 348 do { 349 if (b->in_pos == b->in_size) 350 return XZ_OK; 351 352 if (((s->crc32 >> s->pos) & 0xFF) != b->in[b->in_pos++]) 353 return XZ_DATA_ERROR; 354 355 s->pos += 8; 356 357 } while (s->pos < 32); 358 359 s->crc32 = 0; 360 s->pos = 0; 361 362 return XZ_STREAM_END; 363} 364 365#ifdef XZ_DEC_ANY_CHECK 366/* 367 * Skip over the Check field when the Check ID is not supported. 368 * Returns true once the whole Check field has been skipped over. 369 */ 370static bool check_skip(struct xz_dec *s, struct xz_buf *b) 371{ 372 while (s->pos < check_sizes[s->check_type]) { 373 if (b->in_pos == b->in_size) 374 return false; 375 376 ++b->in_pos; 377 ++s->pos; 378 } 379 380 s->pos = 0; 381 382 return true; 383} 384#endif 385 386/* Decode the Stream Header field (the first 12 bytes of the .xz Stream). */ 387static enum xz_ret dec_stream_header(struct xz_dec *s) 388{ 389 if (!memeq(s->temp.buf, HEADER_MAGIC, HEADER_MAGIC_SIZE)) 390 return XZ_FORMAT_ERROR; 391 392 if (xz_crc32(s->temp.buf + HEADER_MAGIC_SIZE, 2, 0) 393 != get_le32(s->temp.buf + HEADER_MAGIC_SIZE + 2)) 394 return XZ_DATA_ERROR; 395 396 if (s->temp.buf[HEADER_MAGIC_SIZE] != 0) 397 return XZ_OPTIONS_ERROR; 398 399 /* 400 * Of integrity checks, we support only none (Check ID = 0) and 401 * CRC32 (Check ID = 1). However, if XZ_DEC_ANY_CHECK is defined, 402 * we will accept other check types too, but then the check won't 403 * be verified and a warning (XZ_UNSUPPORTED_CHECK) will be given. 404 */ 405 s->check_type = s->temp.buf[HEADER_MAGIC_SIZE + 1]; 406 407#ifdef XZ_DEC_ANY_CHECK 408 if (s->check_type > XZ_CHECK_MAX) 409 return XZ_OPTIONS_ERROR; 410 411 if (s->check_type > XZ_CHECK_CRC32) 412 return XZ_UNSUPPORTED_CHECK; 413#else 414 if (s->check_type > XZ_CHECK_CRC32) 415 return XZ_OPTIONS_ERROR; 416#endif 417 418 return XZ_OK; 419} 420 421/* Decode the Stream Footer field (the last 12 bytes of the .xz Stream) */ 422static enum xz_ret dec_stream_footer(struct xz_dec *s) 423{ 424 if (!memeq(s->temp.buf + 10, FOOTER_MAGIC, FOOTER_MAGIC_SIZE)) 425 return XZ_DATA_ERROR; 426 427 if (xz_crc32(s->temp.buf + 4, 6, 0) != get_le32(s->temp.buf)) 428 return XZ_DATA_ERROR; 429 430 /* 431 * Validate Backward Size. Note that we never added the size of the 432 * Index CRC32 field to s->index.size, thus we use s->index.size / 4 433 * instead of s->index.size / 4 - 1. 434 */ 435 if ((s->index.size >> 2) != get_le32(s->temp.buf + 4)) 436 return XZ_DATA_ERROR; 437 438 if (s->temp.buf[8] != 0 || s->temp.buf[9] != s->check_type) 439 return XZ_DATA_ERROR; 440 441 /* 442 * Use XZ_STREAM_END instead of XZ_OK to be more convenient 443 * for the caller. 444 */ 445 return XZ_STREAM_END; 446} 447 448/* Decode the Block Header and initialize the filter chain. */ 449static enum xz_ret dec_block_header(struct xz_dec *s) 450{ 451 enum xz_ret ret; 452 453 /* 454 * Validate the CRC32. We know that the temp buffer is at least 455 * eight bytes so this is safe. 456 */ 457 s->temp.size -= 4; 458 if (xz_crc32(s->temp.buf, s->temp.size, 0) 459 != get_le32(s->temp.buf + s->temp.size)) 460 return XZ_DATA_ERROR; 461 462 s->temp.pos = 2; 463 464 /* 465 * Catch unsupported Block Flags. We support only one or two filters 466 * in the chain, so we catch that with the same test. 467 */ 468#ifdef XZ_DEC_BCJ 469 if (s->temp.buf[1] & 0x3E) 470#else 471 if (s->temp.buf[1] & 0x3F) 472#endif 473 return XZ_OPTIONS_ERROR; 474 475 /* Compressed Size */ 476 if (s->temp.buf[1] & 0x40) { 477 if (dec_vli(s, s->temp.buf, &s->temp.pos, s->temp.size) 478 != XZ_STREAM_END) 479 return XZ_DATA_ERROR; 480 481 s->block_header.compressed = s->vli; 482 } else { 483 s->block_header.compressed = VLI_UNKNOWN; 484 } 485 486 /* Uncompressed Size */ 487 if (s->temp.buf[1] & 0x80) { 488 if (dec_vli(s, s->temp.buf, &s->temp.pos, s->temp.size) 489 != XZ_STREAM_END) 490 return XZ_DATA_ERROR; 491 492 s->block_header.uncompressed = s->vli; 493 } else { 494 s->block_header.uncompressed = VLI_UNKNOWN; 495 } 496 497#ifdef XZ_DEC_BCJ 498 /* If there are two filters, the first one must be a BCJ filter. */ 499 s->bcj_active = s->temp.buf[1] & 0x01; 500 if (s->bcj_active) { 501 if (s->temp.size - s->temp.pos < 2) 502 return XZ_OPTIONS_ERROR; 503 504 ret = xz_dec_bcj_reset(s->bcj, s->temp.buf[s->temp.pos++]); 505 if (ret != XZ_OK) 506 return ret; 507 508 /* 509 * We don't support custom start offset, 510 * so Size of Properties must be zero. 511 */ 512 if (s->temp.buf[s->temp.pos++] != 0x00) 513 return XZ_OPTIONS_ERROR; 514 } 515#endif 516 517 /* Valid Filter Flags always take at least two bytes. */ 518 if (s->temp.size - s->temp.pos < 2) 519 return XZ_DATA_ERROR; 520 521 /* Filter ID = LZMA2 */ 522 if (s->temp.buf[s->temp.pos++] != 0x21) 523 return XZ_OPTIONS_ERROR; 524 525 /* Size of Properties = 1-byte Filter Properties */ 526 if (s->temp.buf[s->temp.pos++] != 0x01) 527 return XZ_OPTIONS_ERROR; 528 529 /* Filter Properties contains LZMA2 dictionary size. */ 530 if (s->temp.size - s->temp.pos < 1) 531 return XZ_DATA_ERROR; 532 533 ret = xz_dec_lzma2_reset(s->lzma2, s->temp.buf[s->temp.pos++]); 534 if (ret != XZ_OK) 535 return ret; 536 537 /* The rest must be Header Padding. */ 538 while (s->temp.pos < s->temp.size) 539 if (s->temp.buf[s->temp.pos++] != 0x00) 540 return XZ_OPTIONS_ERROR; 541 542 s->temp.pos = 0; 543 s->block.compressed = 0; 544 s->block.uncompressed = 0; 545 546 return XZ_OK; 547} 548 549static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b) 550{ 551 enum xz_ret ret; 552 553 /* 554 * Store the start position for the case when we are in the middle 555 * of the Index field. 556 */ 557 s->in_start = b->in_pos; 558 559 while (true) { 560 switch (s->sequence) { 561 case SEQ_STREAM_HEADER: 562 /* 563 * Stream Header is copied to s->temp, and then 564 * decoded from there. This way if the caller 565 * gives us only little input at a time, we can 566 * still keep the Stream Header decoding code 567 * simple. Similar approach is used in many places 568 * in this file. 569 */ 570 if (!fill_temp(s, b)) 571 return XZ_OK; 572 573 /* 574 * If dec_stream_header() returns 575 * XZ_UNSUPPORTED_CHECK, it is still possible 576 * to continue decoding if working in multi-call 577 * mode. Thus, update s->sequence before calling 578 * dec_stream_header(). 579 */ 580 s->sequence = SEQ_BLOCK_START; 581 582 ret = dec_stream_header(s); 583 if (ret != XZ_OK) 584 return ret; 585 586 case SEQ_BLOCK_START: 587 /* We need one byte of input to continue. */ 588 if (b->in_pos == b->in_size) 589 return XZ_OK; 590 591 /* See if this is the beginning of the Index field. */ 592 if (b->in[b->in_pos] == 0) { 593 s->in_start = b->in_pos++; 594 s->sequence = SEQ_INDEX; 595 break; 596 } 597 598 /* 599 * Calculate the size of the Block Header and 600 * prepare to decode it. 601 */ 602 s->block_header.size 603 = ((uint32_t)b->in[b->in_pos] + 1) * 4; 604 605 s->temp.size = s->block_header.size; 606 s->temp.pos = 0; 607 s->sequence = SEQ_BLOCK_HEADER; 608 609 case SEQ_BLOCK_HEADER: 610 if (!fill_temp(s, b)) 611 return XZ_OK; 612 613 ret = dec_block_header(s); 614 if (ret != XZ_OK) 615 return ret; 616 617 s->sequence = SEQ_BLOCK_UNCOMPRESS; 618 619 case SEQ_BLOCK_UNCOMPRESS: 620 ret = dec_block(s, b); 621 if (ret != XZ_STREAM_END) 622 return ret; 623 624 s->sequence = SEQ_BLOCK_PADDING; 625 626 case SEQ_BLOCK_PADDING: 627 /* 628 * Size of Compressed Data + Block Padding 629 * must be a multiple of four. We don't need 630 * s->block.compressed for anything else 631 * anymore, so we use it here to test the size 632 * of the Block Padding field. 633 */ 634 while (s->block.compressed & 3) { 635 if (b->in_pos == b->in_size) 636 return XZ_OK; 637 638 if (b->in[b->in_pos++] != 0) 639 return XZ_DATA_ERROR; 640 641 ++s->block.compressed; 642 } 643 644 s->sequence = SEQ_BLOCK_CHECK; 645 646 case SEQ_BLOCK_CHECK: 647 if (s->check_type == XZ_CHECK_CRC32) { 648 ret = crc32_validate(s, b); 649 if (ret != XZ_STREAM_END) 650 return ret; 651 } 652#ifdef XZ_DEC_ANY_CHECK 653 else if (!check_skip(s, b)) { 654 return XZ_OK; 655 } 656#endif 657 658 s->sequence = SEQ_BLOCK_START; 659 break; 660 661 case SEQ_INDEX: 662 ret = dec_index(s, b); 663 if (ret != XZ_STREAM_END) 664 return ret; 665 666 s->sequence = SEQ_INDEX_PADDING; 667 668 case SEQ_INDEX_PADDING: 669 while ((s->index.size + (b->in_pos - s->in_start)) 670 & 3) { 671 if (b->in_pos == b->in_size) { 672 index_update(s, b); 673 return XZ_OK; 674 } 675 676 if (b->in[b->in_pos++] != 0) 677 return XZ_DATA_ERROR; 678 } 679 680 /* Finish the CRC32 value and Index size. */ 681 index_update(s, b); 682 683 /* Compare the hashes to validate the Index field. */ 684 if (!memeq(&s->block.hash, &s->index.hash, 685 sizeof(s->block.hash))) 686 return XZ_DATA_ERROR; 687 688 s->sequence = SEQ_INDEX_CRC32; 689 690 case SEQ_INDEX_CRC32: 691 ret = crc32_validate(s, b); 692 if (ret != XZ_STREAM_END) 693 return ret; 694 695 s->temp.size = STREAM_HEADER_SIZE; 696 s->sequence = SEQ_STREAM_FOOTER; 697 698 case SEQ_STREAM_FOOTER: 699 if (!fill_temp(s, b)) 700 return XZ_OK; 701 702 return dec_stream_footer(s); 703 } 704 } 705 706 /* Never reached */ 707} 708 709/* 710 * xz_dec_run() is a wrapper for dec_main() to handle some special cases in 711 * multi-call and single-call decoding. 712 * 713 * In multi-call mode, we must return XZ_BUF_ERROR when it seems clear that we 714 * are not going to make any progress anymore. This is to prevent the caller 715 * from calling us infinitely when the input file is truncated or otherwise 716 * corrupt. Since zlib-style API allows that the caller fills the input buffer 717 * only when the decoder doesn't produce any new output, we have to be careful 718 * to avoid returning XZ_BUF_ERROR too easily: XZ_BUF_ERROR is returned only 719 * after the second consecutive call to xz_dec_run() that makes no progress. 720 * 721 * In single-call mode, if we couldn't decode everything and no error 722 * occurred, either the input is truncated or the output buffer is too small. 723 * Since we know that the last input byte never produces any output, we know 724 * that if all the input was consumed and decoding wasn't finished, the file 725 * must be corrupt. Otherwise the output buffer has to be too small or the 726 * file is corrupt in a way that decoding it produces too big output. 727 * 728 * If single-call decoding fails, we reset b->in_pos and b->out_pos back to 729 * their original values. This is because with some filter chains there won't 730 * be any valid uncompressed data in the output buffer unless the decoding 731 * actually succeeds (that's the price to pay of using the output buffer as 732 * the workspace). 733 */ 734XZ_EXTERN enum xz_ret xz_dec_run(struct xz_dec *s, struct xz_buf *b) 735{ 736 size_t in_start; 737 size_t out_start; 738 enum xz_ret ret; 739 740 if (DEC_IS_SINGLE(s->mode)) 741 xz_dec_reset(s); 742 743 in_start = b->in_pos; 744 out_start = b->out_pos; 745 ret = dec_main(s, b); 746 747 if (DEC_IS_SINGLE(s->mode)) { 748 if (ret == XZ_OK) 749 ret = b->in_pos == b->in_size 750 ? XZ_DATA_ERROR : XZ_BUF_ERROR; 751 752 if (ret != XZ_STREAM_END) { 753 b->in_pos = in_start; 754 b->out_pos = out_start; 755 } 756 757 } else if (ret == XZ_OK && in_start == b->in_pos 758 && out_start == b->out_pos) { 759 if (s->allow_buf_error) 760 ret = XZ_BUF_ERROR; 761 762 s->allow_buf_error = true; 763 } else { 764 s->allow_buf_error = false; 765 } 766 767 return ret; 768} 769 770XZ_EXTERN struct xz_dec *xz_dec_init(enum xz_mode mode, uint32_t dict_max) 771{ 772 struct xz_dec *s = kmalloc(sizeof(*s), GFP_KERNEL); 773 if (s == NULL) 774 return NULL; 775 776 s->mode = mode; 777 778#ifdef XZ_DEC_BCJ 779 s->bcj = xz_dec_bcj_create(DEC_IS_SINGLE(mode)); 780 if (s->bcj == NULL) 781 goto error_bcj; 782#endif 783 784 s->lzma2 = xz_dec_lzma2_create(mode, dict_max); 785 if (s->lzma2 == NULL) 786 goto error_lzma2; 787 788 xz_dec_reset(s); 789 return s; 790 791error_lzma2: 792#ifdef XZ_DEC_BCJ 793 xz_dec_bcj_end(s->bcj); 794error_bcj: 795#endif 796 kfree(s); 797 return NULL; 798} 799 800XZ_EXTERN void xz_dec_reset(struct xz_dec *s) 801{ 802 s->sequence = SEQ_STREAM_HEADER; 803 s->allow_buf_error = false; 804 s->pos = 0; 805 s->crc32 = 0; 806 memzero(&s->block, sizeof(s->block)); 807 memzero(&s->index, sizeof(s->index)); 808 s->temp.pos = 0; 809 s->temp.size = STREAM_HEADER_SIZE; 810} 811 812XZ_EXTERN void xz_dec_end(struct xz_dec *s) 813{ 814 if (s != NULL) { 815 xz_dec_lzma2_end(s->lzma2); 816#ifdef XZ_DEC_BCJ 817 xz_dec_bcj_end(s->bcj); 818#endif 819 kfree(s); 820 } 821} 822