1 /*- 2 * Copyright (c) 2009-2011 Michihiro NAKAJIMA 3 * Copyright (c) 2003-2008 Tim Kientzle and Miklos Vajna 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include "archive_platform.h" 28 29 __FBSDID("$FreeBSD$"); 30 31 #ifdef HAVE_ERRNO_H 32 #include <errno.h> 33 #endif 34 #include <stdio.h> 35 #ifdef HAVE_STDLIB_H 36 #include <stdlib.h> 37 #endif 38 #ifdef HAVE_STRING_H 39 #include <string.h> 40 #endif 41 #ifdef HAVE_UNISTD_H 42 #include <unistd.h> 43 #endif 44 #if HAVE_LZMA_H 45 #include <lzma.h> 46 #endif 47 48 #include "archive.h" 49 #include "archive_endian.h" 50 #include "archive_private.h" 51 #include "archive_read_private.h" 52 53 #if HAVE_LZMA_H && HAVE_LIBLZMA 54 55 struct private_data { 56 lzma_stream stream; 57 unsigned char *out_block; 58 size_t out_block_size; 59 int64_t total_out; 60 char eof; /* True = found end of compressed data. */ 61 char in_stream; 62 63 /* Following variables are used for lzip only. */ 64 char lzip_ver; 65 uint32_t crc32; 66 int64_t member_in; 67 int64_t member_out; 68 }; 69 70 #if LZMA_VERSION_MAJOR >= 5 71 /* Effectively disable the limiter. */ 72 #define LZMA_MEMLIMIT UINT64_MAX 73 #else 74 /* NOTE: This needs to check memory size which running system has. */ 75 #define LZMA_MEMLIMIT (1U << 30) 76 #endif 77 78 /* Combined lzip/lzma/xz filter */ 79 static ssize_t xz_filter_read(struct archive_read_filter *, const void **); 80 static int xz_filter_close(struct archive_read_filter *); 81 static int xz_lzma_bidder_init(struct archive_read_filter *); 82 83 #endif 84 85 /* 86 * Note that we can detect xz and lzma compressed files even if we 87 * can't decompress them. (In fact, we like detecting them because we 88 * can give better error messages.) So the bid framework here gets 89 * compiled even if no lzma library is available. 90 */ 91 static int xz_bidder_bid(struct archive_read_filter_bidder *, 92 struct archive_read_filter *); 93 static int xz_bidder_init(struct archive_read_filter *); 94 static int lzma_bidder_bid(struct archive_read_filter_bidder *, 95 struct archive_read_filter *); 96 static int lzma_bidder_init(struct archive_read_filter *); 97 static int lzip_has_member(struct archive_read_filter *); 98 static int lzip_bidder_bid(struct archive_read_filter_bidder *, 99 struct archive_read_filter *); 100 static int lzip_bidder_init(struct archive_read_filter *); 101 102 #if ARCHIVE_VERSION_NUMBER < 4000000 103 /* Deprecated; remove in libarchive 4.0 */ 104 int 105 archive_read_support_compression_xz(struct archive *a) 106 { 107 return archive_read_support_filter_xz(a); 108 } 109 #endif 110 111 static const struct archive_read_filter_bidder_vtable 112 xz_bidder_vtable = { 113 .bid = xz_bidder_bid, 114 .init = xz_bidder_init, 115 }; 116 117 int 118 archive_read_support_filter_xz(struct archive *_a) 119 { 120 struct archive_read *a = (struct archive_read *)_a; 121 122 if (__archive_read_register_bidder(a, NULL, "xz", 123 &xz_bidder_vtable) != ARCHIVE_OK) 124 return (ARCHIVE_FATAL); 125 126 #if HAVE_LZMA_H && HAVE_LIBLZMA 127 return (ARCHIVE_OK); 128 #else 129 archive_set_error(_a, ARCHIVE_ERRNO_MISC, 130 "Using external xz program for xz decompression"); 131 return (ARCHIVE_WARN); 132 #endif 133 } 134 135 #if ARCHIVE_VERSION_NUMBER < 4000000 136 int 137 archive_read_support_compression_lzma(struct archive *a) 138 { 139 return archive_read_support_filter_lzma(a); 140 } 141 #endif 142 143 static const struct archive_read_filter_bidder_vtable 144 lzma_bidder_vtable = { 145 .bid = lzma_bidder_bid, 146 .init = lzma_bidder_init, 147 }; 148 149 int 150 archive_read_support_filter_lzma(struct archive *_a) 151 { 152 struct archive_read *a = (struct archive_read *)_a; 153 154 if (__archive_read_register_bidder(a, NULL, "lzma", 155 &lzma_bidder_vtable) != ARCHIVE_OK) 156 return (ARCHIVE_FATAL); 157 158 #if HAVE_LZMA_H && HAVE_LIBLZMA 159 return (ARCHIVE_OK); 160 #else 161 archive_set_error(_a, ARCHIVE_ERRNO_MISC, 162 "Using external lzma program for lzma decompression"); 163 return (ARCHIVE_WARN); 164 #endif 165 } 166 167 168 #if ARCHIVE_VERSION_NUMBER < 4000000 169 int 170 archive_read_support_compression_lzip(struct archive *a) 171 { 172 return archive_read_support_filter_lzip(a); 173 } 174 #endif 175 176 static const struct archive_read_filter_bidder_vtable 177 lzip_bidder_vtable = { 178 .bid = lzip_bidder_bid, 179 .init = lzip_bidder_init, 180 }; 181 182 int 183 archive_read_support_filter_lzip(struct archive *_a) 184 { 185 struct archive_read *a = (struct archive_read *)_a; 186 187 if (__archive_read_register_bidder(a, NULL, "lzip", 188 &lzip_bidder_vtable) != ARCHIVE_OK) 189 return (ARCHIVE_FATAL); 190 191 #if HAVE_LZMA_H && HAVE_LIBLZMA 192 return (ARCHIVE_OK); 193 #else 194 archive_set_error(_a, ARCHIVE_ERRNO_MISC, 195 "Using external lzip program for lzip decompression"); 196 return (ARCHIVE_WARN); 197 #endif 198 } 199 200 /* 201 * Test whether we can handle this data. 202 */ 203 static int 204 xz_bidder_bid(struct archive_read_filter_bidder *self, 205 struct archive_read_filter *filter) 206 { 207 const unsigned char *buffer; 208 ssize_t avail; 209 210 (void)self; /* UNUSED */ 211 212 buffer = __archive_read_filter_ahead(filter, 6, &avail); 213 if (buffer == NULL) 214 return (0); 215 216 /* 217 * Verify Header Magic Bytes : FD 37 7A 58 5A 00 218 */ 219 if (memcmp(buffer, "\xFD\x37\x7A\x58\x5A\x00", 6) != 0) 220 return (0); 221 222 return (48); 223 } 224 225 /* 226 * Test whether we can handle this data. 227 * 228 * <sigh> LZMA has a rather poor file signature. Zeros do not 229 * make good signature bytes as a rule, and the only non-zero byte 230 * here is an ASCII character. For example, an uncompressed tar 231 * archive whose first file is ']' would satisfy this check. It may 232 * be necessary to exclude LZMA from compression_all() because of 233 * this. Clients of libarchive would then have to explicitly enable 234 * LZMA checking instead of (or in addition to) compression_all() when 235 * they have other evidence (file name, command-line option) to go on. 236 */ 237 static int 238 lzma_bidder_bid(struct archive_read_filter_bidder *self, 239 struct archive_read_filter *filter) 240 { 241 const unsigned char *buffer; 242 ssize_t avail; 243 uint32_t dicsize; 244 uint64_t uncompressed_size; 245 int bits_checked; 246 247 (void)self; /* UNUSED */ 248 249 buffer = __archive_read_filter_ahead(filter, 14, &avail); 250 if (buffer == NULL) 251 return (0); 252 253 /* First byte of raw LZMA stream is commonly 0x5d. 254 * The first byte is a special number, which consists of 255 * three parameters of LZMA compression, a number of literal 256 * context bits(which is from 0 to 8, default is 3), a number 257 * of literal pos bits(which is from 0 to 4, default is 0), 258 * a number of pos bits(which is from 0 to 4, default is 2). 259 * The first byte is made by 260 * (pos bits * 5 + literal pos bit) * 9 + * literal contest bit, 261 * and so the default value in this field is 262 * (2 * 5 + 0) * 9 + 3 = 0x5d. 263 * lzma of LZMA SDK has options to change those parameters. 264 * It means a range of this field is from 0 to 224. And lzma of 265 * XZ Utils with option -e records 0x5e in this field. */ 266 /* NOTE: If this checking of the first byte increases false 267 * recognition, we should allow only 0x5d and 0x5e for the first 268 * byte of LZMA stream. */ 269 bits_checked = 0; 270 if (buffer[0] > (4 * 5 + 4) * 9 + 8) 271 return (0); 272 /* Most likely value in the first byte of LZMA stream. */ 273 if (buffer[0] == 0x5d || buffer[0] == 0x5e) 274 bits_checked += 8; 275 276 /* Sixth through fourteenth bytes are uncompressed size, 277 * stored in little-endian order. `-1' means uncompressed 278 * size is unknown and lzma of XZ Utils always records `-1' 279 * in this field. */ 280 uncompressed_size = archive_le64dec(buffer+5); 281 if (uncompressed_size == (uint64_t)ARCHIVE_LITERAL_LL(-1)) 282 bits_checked += 64; 283 284 /* Second through fifth bytes are dictionary size, stored in 285 * little-endian order. The minimum dictionary size is 286 * 1 << 12(4KiB) which the lzma of LZMA SDK uses with option 287 * -d12 and the maximum dictionary size is 1 << 29(512MiB) 288 * which the one uses with option -d29. 289 * NOTE: A comment of LZMA SDK source code says this dictionary 290 * range is from 1 << 12 to 1 << 30. */ 291 dicsize = archive_le32dec(buffer+1); 292 switch (dicsize) { 293 case 0x00001000:/* lzma of LZMA SDK option -d12. */ 294 case 0x00002000:/* lzma of LZMA SDK option -d13. */ 295 case 0x00004000:/* lzma of LZMA SDK option -d14. */ 296 case 0x00008000:/* lzma of LZMA SDK option -d15. */ 297 case 0x00010000:/* lzma of XZ Utils option -0 and -1. 298 * lzma of LZMA SDK option -d16. */ 299 case 0x00020000:/* lzma of LZMA SDK option -d17. */ 300 case 0x00040000:/* lzma of LZMA SDK option -d18. */ 301 case 0x00080000:/* lzma of XZ Utils option -2. 302 * lzma of LZMA SDK option -d19. */ 303 case 0x00100000:/* lzma of XZ Utils option -3. 304 * lzma of LZMA SDK option -d20. */ 305 case 0x00200000:/* lzma of XZ Utils option -4. 306 * lzma of LZMA SDK option -d21. */ 307 case 0x00400000:/* lzma of XZ Utils option -5. 308 * lzma of LZMA SDK option -d22. */ 309 case 0x00800000:/* lzma of XZ Utils option -6. 310 * lzma of LZMA SDK option -d23. */ 311 case 0x01000000:/* lzma of XZ Utils option -7. 312 * lzma of LZMA SDK option -d24. */ 313 case 0x02000000:/* lzma of XZ Utils option -8. 314 * lzma of LZMA SDK option -d25. */ 315 case 0x04000000:/* lzma of XZ Utils option -9. 316 * lzma of LZMA SDK option -d26. */ 317 case 0x08000000:/* lzma of LZMA SDK option -d27. */ 318 bits_checked += 32; 319 break; 320 default: 321 /* If a memory usage for encoding was not enough on 322 * the platform where LZMA stream was made, lzma of 323 * XZ Utils automatically decreased the dictionary 324 * size to enough memory for encoding by 1Mi bytes 325 * (1 << 20).*/ 326 if (dicsize <= 0x03F00000 && dicsize >= 0x00300000 && 327 (dicsize & ((1 << 20)-1)) == 0 && 328 bits_checked == 8 + 64) { 329 bits_checked += 32; 330 break; 331 } 332 /* Otherwise dictionary size is unlikely. But it is 333 * possible that someone makes lzma stream with 334 * liblzma/LZMA SDK in one's dictionary size. */ 335 return (0); 336 } 337 338 /* TODO: The above test is still very weak. It would be 339 * good to do better. */ 340 341 return (bits_checked); 342 } 343 344 static int 345 lzip_has_member(struct archive_read_filter *filter) 346 { 347 const unsigned char *buffer; 348 ssize_t avail; 349 int bits_checked; 350 int log2dic; 351 352 buffer = __archive_read_filter_ahead(filter, 6, &avail); 353 if (buffer == NULL) 354 return (0); 355 356 /* 357 * Verify Header Magic Bytes : 4C 5A 49 50 (`LZIP') 358 */ 359 bits_checked = 0; 360 if (memcmp(buffer, "LZIP", 4) != 0) 361 return (0); 362 bits_checked += 32; 363 364 /* A version number must be 0 or 1 */ 365 if (buffer[4] != 0 && buffer[4] != 1) 366 return (0); 367 bits_checked += 8; 368 369 /* Dictionary size. */ 370 log2dic = buffer[5] & 0x1f; 371 if (log2dic < 12 || log2dic > 29) 372 return (0); 373 bits_checked += 8; 374 375 return (bits_checked); 376 } 377 378 static int 379 lzip_bidder_bid(struct archive_read_filter_bidder *self, 380 struct archive_read_filter *filter) 381 { 382 383 (void)self; /* UNUSED */ 384 return (lzip_has_member(filter)); 385 } 386 387 #if HAVE_LZMA_H && HAVE_LIBLZMA 388 389 /* 390 * liblzma 4.999.7 and later support both lzma and xz streams. 391 */ 392 static int 393 xz_bidder_init(struct archive_read_filter *self) 394 { 395 self->code = ARCHIVE_FILTER_XZ; 396 self->name = "xz"; 397 return (xz_lzma_bidder_init(self)); 398 } 399 400 static int 401 lzma_bidder_init(struct archive_read_filter *self) 402 { 403 self->code = ARCHIVE_FILTER_LZMA; 404 self->name = "lzma"; 405 return (xz_lzma_bidder_init(self)); 406 } 407 408 static int 409 lzip_bidder_init(struct archive_read_filter *self) 410 { 411 self->code = ARCHIVE_FILTER_LZIP; 412 self->name = "lzip"; 413 return (xz_lzma_bidder_init(self)); 414 } 415 416 /* 417 * Set an error code and choose an error message 418 */ 419 static void 420 set_error(struct archive_read_filter *self, int ret) 421 { 422 423 switch (ret) { 424 case LZMA_STREAM_END: /* Found end of stream. */ 425 case LZMA_OK: /* Decompressor made some progress. */ 426 break; 427 case LZMA_MEM_ERROR: 428 archive_set_error(&self->archive->archive, ENOMEM, 429 "Lzma library error: Cannot allocate memory"); 430 break; 431 case LZMA_MEMLIMIT_ERROR: 432 archive_set_error(&self->archive->archive, ENOMEM, 433 "Lzma library error: Out of memory"); 434 break; 435 case LZMA_FORMAT_ERROR: 436 archive_set_error(&self->archive->archive, 437 ARCHIVE_ERRNO_MISC, 438 "Lzma library error: format not recognized"); 439 break; 440 case LZMA_OPTIONS_ERROR: 441 archive_set_error(&self->archive->archive, 442 ARCHIVE_ERRNO_MISC, 443 "Lzma library error: Invalid options"); 444 break; 445 case LZMA_DATA_ERROR: 446 archive_set_error(&self->archive->archive, 447 ARCHIVE_ERRNO_MISC, 448 "Lzma library error: Corrupted input data"); 449 break; 450 case LZMA_BUF_ERROR: 451 archive_set_error(&self->archive->archive, 452 ARCHIVE_ERRNO_MISC, 453 "Lzma library error: No progress is possible"); 454 break; 455 default: 456 /* Return an error. */ 457 archive_set_error(&self->archive->archive, 458 ARCHIVE_ERRNO_MISC, 459 "Lzma decompression failed: Unknown error"); 460 break; 461 } 462 } 463 464 static const struct archive_read_filter_vtable 465 xz_lzma_reader_vtable = { 466 .read = xz_filter_read, 467 .close = xz_filter_close, 468 }; 469 470 /* 471 * Setup the callbacks. 472 */ 473 static int 474 xz_lzma_bidder_init(struct archive_read_filter *self) 475 { 476 static const size_t out_block_size = 64 * 1024; 477 void *out_block; 478 struct private_data *state; 479 int ret; 480 481 state = (struct private_data *)calloc(sizeof(*state), 1); 482 out_block = (unsigned char *)malloc(out_block_size); 483 if (state == NULL || out_block == NULL) { 484 archive_set_error(&self->archive->archive, ENOMEM, 485 "Can't allocate data for xz decompression"); 486 free(out_block); 487 free(state); 488 return (ARCHIVE_FATAL); 489 } 490 491 self->data = state; 492 state->out_block_size = out_block_size; 493 state->out_block = out_block; 494 self->vtable = &xz_lzma_reader_vtable; 495 496 state->stream.avail_in = 0; 497 498 state->stream.next_out = state->out_block; 499 state->stream.avail_out = state->out_block_size; 500 501 state->crc32 = 0; 502 if (self->code == ARCHIVE_FILTER_LZIP) { 503 /* 504 * We have to read a lzip header and use it to initialize 505 * compression library, thus we cannot initialize the 506 * library for lzip here. 507 */ 508 state->in_stream = 0; 509 return (ARCHIVE_OK); 510 } else 511 state->in_stream = 1; 512 513 /* Initialize compression library. */ 514 if (self->code == ARCHIVE_FILTER_XZ) 515 ret = lzma_stream_decoder(&(state->stream), 516 LZMA_MEMLIMIT,/* memlimit */ 517 LZMA_CONCATENATED); 518 else 519 ret = lzma_alone_decoder(&(state->stream), 520 LZMA_MEMLIMIT);/* memlimit */ 521 522 if (ret == LZMA_OK) 523 return (ARCHIVE_OK); 524 525 /* Library setup failed: Choose an error message and clean up. */ 526 set_error(self, ret); 527 528 free(state->out_block); 529 free(state); 530 self->data = NULL; 531 return (ARCHIVE_FATAL); 532 } 533 534 static int 535 lzip_init(struct archive_read_filter *self) 536 { 537 struct private_data *state; 538 const unsigned char *h; 539 lzma_filter filters[2]; 540 unsigned char props[5]; 541 ssize_t avail_in; 542 uint32_t dicsize; 543 int log2dic, ret; 544 545 state = (struct private_data *)self->data; 546 h = __archive_read_filter_ahead(self->upstream, 6, &avail_in); 547 if (h == NULL) 548 return (ARCHIVE_FATAL); 549 550 /* Get a version number. */ 551 state->lzip_ver = h[4]; 552 553 /* 554 * Setup lzma property. 555 */ 556 props[0] = 0x5d; 557 558 /* Get dictionary size. */ 559 log2dic = h[5] & 0x1f; 560 if (log2dic < 12 || log2dic > 29) 561 return (ARCHIVE_FATAL); 562 dicsize = 1U << log2dic; 563 if (log2dic > 12) 564 dicsize -= (dicsize / 16) * (h[5] >> 5); 565 archive_le32enc(props+1, dicsize); 566 567 /* Consume lzip header. */ 568 __archive_read_filter_consume(self->upstream, 6); 569 state->member_in = 6; 570 571 filters[0].id = LZMA_FILTER_LZMA1; 572 filters[0].options = NULL; 573 filters[1].id = LZMA_VLI_UNKNOWN; 574 filters[1].options = NULL; 575 576 ret = lzma_properties_decode(&filters[0], NULL, props, sizeof(props)); 577 if (ret != LZMA_OK) { 578 set_error(self, ret); 579 return (ARCHIVE_FATAL); 580 } 581 ret = lzma_raw_decoder(&(state->stream), filters); 582 free(filters[0].options); 583 if (ret != LZMA_OK) { 584 set_error(self, ret); 585 return (ARCHIVE_FATAL); 586 } 587 return (ARCHIVE_OK); 588 } 589 590 static int 591 lzip_tail(struct archive_read_filter *self) 592 { 593 struct private_data *state; 594 const unsigned char *f; 595 ssize_t avail_in; 596 int tail; 597 598 state = (struct private_data *)self->data; 599 if (state->lzip_ver == 0) 600 tail = 12; 601 else 602 tail = 20; 603 f = __archive_read_filter_ahead(self->upstream, tail, &avail_in); 604 if (f == NULL && avail_in < 0) 605 return (ARCHIVE_FATAL); 606 if (f == NULL || avail_in < tail) { 607 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 608 "Lzip: Remaining data is less bytes"); 609 return (ARCHIVE_FAILED); 610 } 611 612 /* Check the crc32 value of the uncompressed data of the current 613 * member */ 614 if (state->crc32 != archive_le32dec(f)) { 615 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 616 "Lzip: CRC32 error"); 617 return (ARCHIVE_FAILED); 618 } 619 620 /* Check the uncompressed size of the current member */ 621 if ((uint64_t)state->member_out != archive_le64dec(f + 4)) { 622 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 623 "Lzip: Uncompressed size error"); 624 return (ARCHIVE_FAILED); 625 } 626 627 /* Check the total size of the current member */ 628 if (state->lzip_ver == 1 && 629 (uint64_t)state->member_in + tail != archive_le64dec(f + 12)) { 630 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 631 "Lzip: Member size error"); 632 return (ARCHIVE_FAILED); 633 } 634 __archive_read_filter_consume(self->upstream, tail); 635 636 /* If current lzip data consists of multi member, try decompressing 637 * a next member. */ 638 if (lzip_has_member(self->upstream) != 0) { 639 state->in_stream = 0; 640 state->crc32 = 0; 641 state->member_out = 0; 642 state->member_in = 0; 643 state->eof = 0; 644 } 645 return (ARCHIVE_OK); 646 } 647 648 /* 649 * Return the next block of decompressed data. 650 */ 651 static ssize_t 652 xz_filter_read(struct archive_read_filter *self, const void **p) 653 { 654 struct private_data *state; 655 size_t decompressed; 656 ssize_t avail_in; 657 int ret; 658 659 state = (struct private_data *)self->data; 660 661 /* Empty our output buffer. */ 662 state->stream.next_out = state->out_block; 663 state->stream.avail_out = state->out_block_size; 664 665 /* Try to fill the output buffer. */ 666 while (state->stream.avail_out > 0 && !state->eof) { 667 if (!state->in_stream) { 668 /* 669 * Initialize liblzma for lzip 670 */ 671 ret = lzip_init(self); 672 if (ret != ARCHIVE_OK) 673 return (ret); 674 state->in_stream = 1; 675 } 676 state->stream.next_in = 677 __archive_read_filter_ahead(self->upstream, 1, &avail_in); 678 if (state->stream.next_in == NULL && avail_in < 0) { 679 archive_set_error(&self->archive->archive, 680 ARCHIVE_ERRNO_MISC, 681 "truncated input"); 682 return (ARCHIVE_FATAL); 683 } 684 state->stream.avail_in = avail_in; 685 686 /* Decompress as much as we can in one pass. */ 687 ret = lzma_code(&(state->stream), 688 (state->stream.avail_in == 0)? LZMA_FINISH: LZMA_RUN); 689 switch (ret) { 690 case LZMA_STREAM_END: /* Found end of stream. */ 691 state->eof = 1; 692 /* FALL THROUGH */ 693 case LZMA_OK: /* Decompressor made some progress. */ 694 __archive_read_filter_consume(self->upstream, 695 avail_in - state->stream.avail_in); 696 state->member_in += 697 avail_in - state->stream.avail_in; 698 break; 699 default: 700 set_error(self, ret); 701 return (ARCHIVE_FATAL); 702 } 703 } 704 705 decompressed = state->stream.next_out - state->out_block; 706 state->total_out += decompressed; 707 state->member_out += decompressed; 708 if (decompressed == 0) 709 *p = NULL; 710 else { 711 *p = state->out_block; 712 if (self->code == ARCHIVE_FILTER_LZIP) { 713 state->crc32 = lzma_crc32(state->out_block, 714 decompressed, state->crc32); 715 if (state->eof) { 716 ret = lzip_tail(self); 717 if (ret != ARCHIVE_OK) 718 return (ret); 719 } 720 } 721 } 722 return (decompressed); 723 } 724 725 /* 726 * Clean up the decompressor. 727 */ 728 static int 729 xz_filter_close(struct archive_read_filter *self) 730 { 731 struct private_data *state; 732 733 state = (struct private_data *)self->data; 734 lzma_end(&(state->stream)); 735 free(state->out_block); 736 free(state); 737 return (ARCHIVE_OK); 738 } 739 740 #else 741 742 /* 743 * 744 * If we have no suitable library on this system, we can't actually do 745 * the decompression. We can, however, still detect compressed 746 * archives and emit a useful message. 747 * 748 */ 749 static int 750 lzma_bidder_init(struct archive_read_filter *self) 751 { 752 int r; 753 754 r = __archive_read_program(self, "lzma -d -qq"); 755 /* Note: We set the format here even if __archive_read_program() 756 * above fails. We do, after all, know what the format is 757 * even if we weren't able to read it. */ 758 self->code = ARCHIVE_FILTER_LZMA; 759 self->name = "lzma"; 760 return (r); 761 } 762 763 static int 764 xz_bidder_init(struct archive_read_filter *self) 765 { 766 int r; 767 768 r = __archive_read_program(self, "xz -d -qq"); 769 /* Note: We set the format here even if __archive_read_program() 770 * above fails. We do, after all, know what the format is 771 * even if we weren't able to read it. */ 772 self->code = ARCHIVE_FILTER_XZ; 773 self->name = "xz"; 774 return (r); 775 } 776 777 static int 778 lzip_bidder_init(struct archive_read_filter *self) 779 { 780 int r; 781 782 r = __archive_read_program(self, "lzip -d -q"); 783 /* Note: We set the format here even if __archive_read_program() 784 * above fails. We do, after all, know what the format is 785 * even if we weren't able to read it. */ 786 self->code = ARCHIVE_FILTER_LZIP; 787 self->name = "lzip"; 788 return (r); 789 } 790 791 #endif /* HAVE_LZMA_H */ 792