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