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