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#elif HAVE_LZMADEC_H 47#include <lzmadec.h> 48#endif 49 50#include "archive.h" 51#include "archive_endian.h" 52#include "archive_private.h" 53#include "archive_read_private.h" 54 55#if HAVE_LZMA_H && HAVE_LIBLZMA 56 57struct private_data { 58 lzma_stream stream; 59 unsigned char *out_block; 60 size_t out_block_size; 61 int64_t total_out; 62 char eof; /* True = found end of compressed data. */ 63 char in_stream; 64 65 /* Following variables are used for lzip only. */ 66 char lzip_ver; 67 uint32_t crc32; 68 int64_t member_in; 69 int64_t member_out; 70}; 71 72#if LZMA_VERSION_MAJOR >= 5 73/* Effectively disable the limiter. */ 74#define LZMA_MEMLIMIT UINT64_MAX 75#else 76/* NOTE: This needs to check memory size which running system has. */ 77#define LZMA_MEMLIMIT (1U << 30) 78#endif 79 80/* Combined lzip/lzma/xz filter */ 81static ssize_t xz_filter_read(struct archive_read_filter *, const void **); 82static int xz_filter_close(struct archive_read_filter *); 83static int xz_lzma_bidder_init(struct archive_read_filter *); 84 85#elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC 86 87struct private_data { 88 lzmadec_stream stream; 89 unsigned char *out_block; 90 size_t out_block_size; 91 int64_t total_out; 92 char eof; /* True = found end of compressed data. */ 93}; 94 95/* Lzma-only filter */ 96static ssize_t lzma_filter_read(struct archive_read_filter *, const void **); 97static int lzma_filter_close(struct archive_read_filter *); 98#endif 99 100/* 101 * Note that we can detect xz and lzma compressed files even if we 102 * can't decompress them. (In fact, we like detecting them because we 103 * can give better error messages.) So the bid framework here gets 104 * compiled even if no lzma library is available. 105 */ 106static int xz_bidder_bid(struct archive_read_filter_bidder *, 107 struct archive_read_filter *); 108static int xz_bidder_init(struct archive_read_filter *); 109static int lzma_bidder_bid(struct archive_read_filter_bidder *, 110 struct archive_read_filter *); 111static int lzma_bidder_init(struct archive_read_filter *); 112static int lzip_has_member(struct archive_read_filter *); 113static int lzip_bidder_bid(struct archive_read_filter_bidder *, 114 struct archive_read_filter *); 115static int lzip_bidder_init(struct archive_read_filter *); 116 117#if ARCHIVE_VERSION_NUMBER < 4000000 118/* Deprecated; remove in libarchive 4.0 */ 119int 120archive_read_support_compression_xz(struct archive *a) 121{ 122 return archive_read_support_filter_xz(a); 123} 124#endif 125 126int 127archive_read_support_filter_xz(struct archive *_a) 128{ 129 struct archive_read *a = (struct archive_read *)_a; 130 struct archive_read_filter_bidder *bidder; 131 132 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 133 ARCHIVE_STATE_NEW, "archive_read_support_filter_xz"); 134 135 if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) 136 return (ARCHIVE_FATAL); 137 138 bidder->data = NULL; 139 bidder->name = "xz"; 140 bidder->bid = xz_bidder_bid; 141 bidder->init = xz_bidder_init; 142 bidder->options = NULL; 143 bidder->free = NULL; 144#if HAVE_LZMA_H && HAVE_LIBLZMA 145 return (ARCHIVE_OK); 146#else 147 archive_set_error(_a, ARCHIVE_ERRNO_MISC, 148 "Using external xz program for xz decompression"); 149 return (ARCHIVE_WARN); 150#endif 151} 152 153#if ARCHIVE_VERSION_NUMBER < 4000000 154int 155archive_read_support_compression_lzma(struct archive *a) 156{ 157 return archive_read_support_filter_lzma(a); 158} 159#endif 160 161int 162archive_read_support_filter_lzma(struct archive *_a) 163{ 164 struct archive_read *a = (struct archive_read *)_a; 165 struct archive_read_filter_bidder *bidder; 166 167 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 168 ARCHIVE_STATE_NEW, "archive_read_support_filter_lzma"); 169 170 if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) 171 return (ARCHIVE_FATAL); 172 173 bidder->data = NULL; 174 bidder->name = "lzma"; 175 bidder->bid = lzma_bidder_bid; 176 bidder->init = lzma_bidder_init; 177 bidder->options = NULL; 178 bidder->free = NULL; 179#if HAVE_LZMA_H && HAVE_LIBLZMA 180 return (ARCHIVE_OK); 181#elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC 182 return (ARCHIVE_OK); 183#else 184 archive_set_error(_a, ARCHIVE_ERRNO_MISC, 185 "Using external lzma program for lzma decompression"); 186 return (ARCHIVE_WARN); 187#endif 188} 189 190 191#if ARCHIVE_VERSION_NUMBER < 4000000 192int 193archive_read_support_compression_lzip(struct archive *a) 194{ 195 return archive_read_support_filter_lzip(a); 196} 197#endif 198 199int 200archive_read_support_filter_lzip(struct archive *_a) 201{ 202 struct archive_read *a = (struct archive_read *)_a; 203 struct archive_read_filter_bidder *bidder; 204 205 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 206 ARCHIVE_STATE_NEW, "archive_read_support_filter_lzip"); 207 208 if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) 209 return (ARCHIVE_FATAL); 210 211 bidder->data = NULL; 212 bidder->name = "lzip"; 213 bidder->bid = lzip_bidder_bid; 214 bidder->init = lzip_bidder_init; 215 bidder->options = NULL; 216 bidder->free = NULL; 217#if HAVE_LZMA_H && HAVE_LIBLZMA 218 return (ARCHIVE_OK); 219#else 220 archive_set_error(_a, ARCHIVE_ERRNO_MISC, 221 "Using external lzip program for lzip decompression"); 222 return (ARCHIVE_WARN); 223#endif 224} 225 226/* 227 * Test whether we can handle this data. 228 */ 229static int 230xz_bidder_bid(struct archive_read_filter_bidder *self, 231 struct archive_read_filter *filter) 232{ 233 const unsigned char *buffer; 234 ssize_t avail; 235 236 (void)self; /* UNUSED */ 237 238 buffer = __archive_read_filter_ahead(filter, 6, &avail); 239 if (buffer == NULL) 240 return (0); 241 242 /* 243 * Verify Header Magic Bytes : FD 37 7A 58 5A 00 244 */ 245 if (memcmp(buffer, "\xFD\x37\x7A\x58\x5A\x00", 6) != 0) 246 return (0); 247 248 return (48); 249} 250 251/* 252 * Test whether we can handle this data. 253 * 254 * <sigh> LZMA has a rather poor file signature. Zeros do not 255 * make good signature bytes as a rule, and the only non-zero byte 256 * here is an ASCII character. For example, an uncompressed tar 257 * archive whose first file is ']' would satisfy this check. It may 258 * be necessary to exclude LZMA from compression_all() because of 259 * this. Clients of libarchive would then have to explicitly enable 260 * LZMA checking instead of (or in addition to) compression_all() when 261 * they have other evidence (file name, command-line option) to go on. 262 */ 263static int 264lzma_bidder_bid(struct archive_read_filter_bidder *self, 265 struct archive_read_filter *filter) 266{ 267 const unsigned char *buffer; 268 ssize_t avail; 269 uint32_t dicsize; 270 uint64_t uncompressed_size; 271 int bits_checked; 272 273 (void)self; /* UNUSED */ 274 275 buffer = __archive_read_filter_ahead(filter, 14, &avail); 276 if (buffer == NULL) 277 return (0); 278 279 /* First byte of raw LZMA stream is commonly 0x5d. 280 * The first byte is a special number, which consists of 281 * three parameters of LZMA compression, a number of literal 282 * context bits(which is from 0 to 8, default is 3), a number 283 * of literal pos bits(which is from 0 to 4, default is 0), 284 * a number of pos bits(which is from 0 to 4, default is 2). 285 * The first byte is made by 286 * (pos bits * 5 + literal pos bit) * 9 + * literal contest bit, 287 * and so the default value in this field is 288 * (2 * 5 + 0) * 9 + 3 = 0x5d. 289 * lzma of LZMA SDK has options to change those parameters. 290 * It means a range of this field is from 0 to 224. And lzma of 291 * XZ Utils with option -e records 0x5e in this field. */ 292 /* NOTE: If this checking of the first byte increases false 293 * recognition, we should allow only 0x5d and 0x5e for the first 294 * byte of LZMA stream. */ 295 bits_checked = 0; 296 if (buffer[0] > (4 * 5 + 4) * 9 + 8) 297 return (0); 298 /* Most likely value in the first byte of LZMA stream. */ 299 if (buffer[0] == 0x5d || buffer[0] == 0x5e) 300 bits_checked += 8; 301 302 /* Sixth through fourteenth bytes are uncompressed size, 303 * stored in little-endian order. `-1' means uncompressed 304 * size is unknown and lzma of XZ Utils always records `-1' 305 * in this field. */ 306 uncompressed_size = archive_le64dec(buffer+5); 307 if (uncompressed_size == (uint64_t)ARCHIVE_LITERAL_LL(-1)) 308 bits_checked += 64; 309 310 /* Second through fifth bytes are dictionary size, stored in 311 * little-endian order. The minimum dictionary size is 312 * 1 << 12(4KiB) which the lzma of LZMA SDK uses with option 313 * -d12 and the maxinam dictionary size is 1 << 27(128MiB) 314 * which the one uses with option -d27. 315 * NOTE: A comment of LZMA SDK source code says this dictionary 316 * range is from 1 << 12 to 1 << 30. */ 317 dicsize = archive_le32dec(buffer+1); 318 switch (dicsize) { 319 case 0x00001000:/* lzma of LZMA SDK option -d12. */ 320 case 0x00002000:/* lzma of LZMA SDK option -d13. */ 321 case 0x00004000:/* lzma of LZMA SDK option -d14. */ 322 case 0x00008000:/* lzma of LZMA SDK option -d15. */ 323 case 0x00010000:/* lzma of XZ Utils option -0 and -1. 324 * lzma of LZMA SDK option -d16. */ 325 case 0x00020000:/* lzma of LZMA SDK option -d17. */ 326 case 0x00040000:/* lzma of LZMA SDK option -d18. */ 327 case 0x00080000:/* lzma of XZ Utils option -2. 328 * lzma of LZMA SDK option -d19. */ 329 case 0x00100000:/* lzma of XZ Utils option -3. 330 * lzma of LZMA SDK option -d20. */ 331 case 0x00200000:/* lzma of XZ Utils option -4. 332 * lzma of LZMA SDK option -d21. */ 333 case 0x00400000:/* lzma of XZ Utils option -5. 334 * lzma of LZMA SDK option -d22. */ 335 case 0x00800000:/* lzma of XZ Utils option -6. 336 * lzma of LZMA SDK option -d23. */ 337 case 0x01000000:/* lzma of XZ Utils option -7. 338 * lzma of LZMA SDK option -d24. */ 339 case 0x02000000:/* lzma of XZ Utils option -8. 340 * lzma of LZMA SDK option -d25. */ 341 case 0x04000000:/* lzma of XZ Utils option -9. 342 * lzma of LZMA SDK option -d26. */ 343 case 0x08000000:/* lzma of LZMA SDK option -d27. */ 344 bits_checked += 32; 345 break; 346 default: 347 /* If a memory usage for encoding was not enough on 348 * the platform where LZMA stream was made, lzma of 349 * XZ Utils automatically decreased the dictionary 350 * size to enough memory for encoding by 1Mi bytes 351 * (1 << 20).*/ 352 if (dicsize <= 0x03F00000 && dicsize >= 0x00300000 && 353 (dicsize & ((1 << 20)-1)) == 0 && 354 bits_checked == 8 + 64) { 355 bits_checked += 32; 356 break; 357 } 358 /* Otherwise dictionary size is unlikely. But it is 359 * possible that someone makes lzma stream with 360 * liblzma/LZMA SDK in one's dictionary size. */ 361 return (0); 362 } 363 364 /* TODO: The above test is still very weak. It would be 365 * good to do better. */ 366 367 return (bits_checked); 368} 369 370static int 371lzip_has_member(struct archive_read_filter *filter) 372{ 373 const unsigned char *buffer; 374 ssize_t avail; 375 int bits_checked; 376 int log2dic; 377 378 buffer = __archive_read_filter_ahead(filter, 6, &avail); 379 if (buffer == NULL) 380 return (0); 381 382 /* 383 * Verify Header Magic Bytes : 4C 5A 49 50 (`LZIP') 384 */ 385 bits_checked = 0; 386 if (memcmp(buffer, "LZIP", 4) != 0) 387 return (0); 388 bits_checked += 32; 389 390 /* A version number must be 0 or 1 */ 391 if (buffer[4] != 0 && buffer[4] != 1) 392 return (0); 393 bits_checked += 8; 394 395 /* Dictionary size. */ 396 log2dic = buffer[5] & 0x1f; 397 if (log2dic < 12 || log2dic > 27) 398 return (0); 399 bits_checked += 8; 400 401 return (bits_checked); 402} 403 404static int 405lzip_bidder_bid(struct archive_read_filter_bidder *self, 406 struct archive_read_filter *filter) 407{ 408 409 (void)self; /* UNUSED */ 410 return (lzip_has_member(filter)); 411} 412 413#if HAVE_LZMA_H && HAVE_LIBLZMA 414 415/* 416 * liblzma 4.999.7 and later support both lzma and xz streams. 417 */ 418static int 419xz_bidder_init(struct archive_read_filter *self) 420{ 421 self->code = ARCHIVE_FILTER_XZ; 422 self->name = "xz"; 423 return (xz_lzma_bidder_init(self)); 424} 425 426static int 427lzma_bidder_init(struct archive_read_filter *self) 428{ 429 self->code = ARCHIVE_FILTER_LZMA; 430 self->name = "lzma"; 431 return (xz_lzma_bidder_init(self)); 432} 433 434static int 435lzip_bidder_init(struct archive_read_filter *self) 436{ 437 self->code = ARCHIVE_FILTER_LZIP; 438 self->name = "lzip"; 439 return (xz_lzma_bidder_init(self)); 440} 441 442/* 443 * Set an error code and choose an error message 444 */ 445static void 446set_error(struct archive_read_filter *self, int ret) 447{ 448 449 switch (ret) { 450 case LZMA_STREAM_END: /* Found end of stream. */ 451 case LZMA_OK: /* Decompressor made some progress. */ 452 break; 453 case LZMA_MEM_ERROR: 454 archive_set_error(&self->archive->archive, ENOMEM, 455 "Lzma library error: Cannot allocate memory"); 456 break; 457 case LZMA_MEMLIMIT_ERROR: 458 archive_set_error(&self->archive->archive, ENOMEM, 459 "Lzma library error: Out of memory"); 460 break; 461 case LZMA_FORMAT_ERROR: 462 archive_set_error(&self->archive->archive, 463 ARCHIVE_ERRNO_MISC, 464 "Lzma library error: format not recognized"); 465 break; 466 case LZMA_OPTIONS_ERROR: 467 archive_set_error(&self->archive->archive, 468 ARCHIVE_ERRNO_MISC, 469 "Lzma library error: Invalid options"); 470 break; 471 case LZMA_DATA_ERROR: 472 archive_set_error(&self->archive->archive, 473 ARCHIVE_ERRNO_MISC, 474 "Lzma library error: Corrupted input data"); 475 break; 476 case LZMA_BUF_ERROR: 477 archive_set_error(&self->archive->archive, 478 ARCHIVE_ERRNO_MISC, 479 "Lzma library error: No progress is possible"); 480 break; 481 default: 482 /* Return an error. */ 483 archive_set_error(&self->archive->archive, 484 ARCHIVE_ERRNO_MISC, 485 "Lzma decompression failed: Unknown error"); 486 break; 487 } 488} 489 490/* 491 * Setup the callbacks. 492 */ 493static int 494xz_lzma_bidder_init(struct archive_read_filter *self) 495{ 496 static const size_t out_block_size = 64 * 1024; 497 void *out_block; 498 struct private_data *state; 499 int ret; 500 501 state = (struct private_data *)calloc(sizeof(*state), 1); 502 out_block = (unsigned char *)malloc(out_block_size); 503 if (state == NULL || out_block == NULL) { 504 archive_set_error(&self->archive->archive, ENOMEM, 505 "Can't allocate data for xz decompression"); 506 free(out_block); 507 free(state); 508 return (ARCHIVE_FATAL); 509 } 510 511 self->data = state; 512 state->out_block_size = out_block_size; 513 state->out_block = out_block; 514 self->read = xz_filter_read; 515 self->skip = NULL; /* not supported */ 516 self->close = xz_filter_close; 517 518 state->stream.avail_in = 0; 519 520 state->stream.next_out = state->out_block; 521 state->stream.avail_out = state->out_block_size; 522 523 state->crc32 = 0; 524 if (self->code == ARCHIVE_FILTER_LZIP) { 525 /* 526 * We have to read a lzip header and use it to initialize 527 * compression library, thus we cannot initialize the 528 * library for lzip here. 529 */ 530 state->in_stream = 0; 531 return (ARCHIVE_OK); 532 } else 533 state->in_stream = 1; 534 535 /* Initialize compression library. */ 536 if (self->code == ARCHIVE_FILTER_XZ) 537 ret = lzma_stream_decoder(&(state->stream), 538 LZMA_MEMLIMIT,/* memlimit */ 539 LZMA_CONCATENATED); 540 else 541 ret = lzma_alone_decoder(&(state->stream), 542 LZMA_MEMLIMIT);/* memlimit */ 543 544 if (ret == LZMA_OK) 545 return (ARCHIVE_OK); 546 547 /* Library setup failed: Choose an error message and clean up. */ 548 set_error(self, ret); 549 550 free(state->out_block); 551 free(state); 552 self->data = NULL; 553 return (ARCHIVE_FATAL); 554} 555 556static int 557lzip_init(struct archive_read_filter *self) 558{ 559 struct private_data *state; 560 const unsigned char *h; 561 lzma_filter filters[2]; 562 unsigned char props[5]; 563 ssize_t avail_in; 564 uint32_t dicsize; 565 int log2dic, ret; 566 567 state = (struct private_data *)self->data; 568 h = __archive_read_filter_ahead(self->upstream, 6, &avail_in); 569 if (h == NULL) 570 return (ARCHIVE_FATAL); 571 572 /* Get a version number. */ 573 state->lzip_ver = h[4]; 574 575 /* 576 * Setup lzma property. 577 */ 578 props[0] = 0x5d; 579 580 /* Get dictionary size. */ 581 log2dic = h[5] & 0x1f; 582 if (log2dic < 12 || log2dic > 27) 583 return (ARCHIVE_FATAL); 584 dicsize = 1U << log2dic; 585 if (log2dic > 12) 586 dicsize -= (dicsize / 16) * (h[5] >> 5); 587 archive_le32enc(props+1, dicsize); 588 589 /* Consume lzip header. */ 590 __archive_read_filter_consume(self->upstream, 6); 591 state->member_in = 6; 592 593 filters[0].id = LZMA_FILTER_LZMA1; 594 filters[0].options = NULL; 595 filters[1].id = LZMA_VLI_UNKNOWN; 596 filters[1].options = NULL; 597 598 ret = lzma_properties_decode(&filters[0], NULL, props, sizeof(props)); 599 if (ret != LZMA_OK) { 600 set_error(self, ret); 601 return (ARCHIVE_FATAL); 602 } 603 ret = lzma_raw_decoder(&(state->stream), filters); 604#if LZMA_VERSION < 50000030 605 free(filters[0].options); 606#endif 607 if (ret != LZMA_OK) { 608 set_error(self, ret); 609 return (ARCHIVE_FATAL); 610 } 611 return (ARCHIVE_OK); 612} 613 614static int 615lzip_tail(struct archive_read_filter *self) 616{ 617 struct private_data *state; 618 const unsigned char *f; 619 ssize_t avail_in; 620 int tail; 621 622 state = (struct private_data *)self->data; 623 if (state->lzip_ver == 0) 624 tail = 12; 625 else 626 tail = 20; 627 f = __archive_read_filter_ahead(self->upstream, tail, &avail_in); 628 if (f == NULL && avail_in < 0) 629 return (ARCHIVE_FATAL); 630 if (avail_in < tail) { 631 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 632 "Lzip: Remaining data is less bytes"); 633 return (ARCHIVE_FAILED); 634 } 635 636 /* Check the crc32 value of the uncompressed data of the current 637 * member */ 638 if (state->crc32 != archive_le32dec(f)) { 639 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 640 "Lzip: CRC32 error"); 641 return (ARCHIVE_FAILED); 642 } 643 644 /* Check the uncompressed size of the current member */ 645 if ((uint64_t)state->member_out != archive_le64dec(f + 4)) { 646 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 647 "Lzip: Uncompressed size error"); 648 return (ARCHIVE_FAILED); 649 } 650 651 /* Check the total size of the current member */ 652 if (state->lzip_ver == 1 && 653 (uint64_t)state->member_in + tail != archive_le64dec(f + 12)) { 654 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 655 "Lzip: Member size error"); 656 return (ARCHIVE_FAILED); 657 } 658 __archive_read_filter_consume(self->upstream, tail); 659 660 /* If current lzip data consists of multi member, try decompressing 661 * a next member. */ 662 if (lzip_has_member(self->upstream) != 0) { 663 state->in_stream = 0; 664 state->crc32 = 0; 665 state->member_out = 0; 666 state->member_in = 0; 667 state->eof = 0; 668 } 669 return (ARCHIVE_OK); 670} 671 672/* 673 * Return the next block of decompressed data. 674 */ 675static ssize_t 676xz_filter_read(struct archive_read_filter *self, const void **p) 677{ 678 struct private_data *state; 679 size_t decompressed; 680 ssize_t avail_in; 681 int ret; 682 683 state = (struct private_data *)self->data; 684 685 /* Empty our output buffer. */ 686 state->stream.next_out = state->out_block; 687 state->stream.avail_out = state->out_block_size; 688 689 /* Try to fill the output buffer. */ 690 while (state->stream.avail_out > 0 && !state->eof) { 691 if (!state->in_stream) { 692 /* 693 * Initialize liblzma for lzip 694 */ 695 ret = lzip_init(self); 696 if (ret != ARCHIVE_OK) 697 return (ret); 698 state->in_stream = 1; 699 } 700 state->stream.next_in = 701 __archive_read_filter_ahead(self->upstream, 1, &avail_in); 702 if (state->stream.next_in == NULL && avail_in < 0) { 703 archive_set_error(&self->archive->archive, 704 ARCHIVE_ERRNO_MISC, 705 "truncated input"); 706 return (ARCHIVE_FATAL); 707 } 708 state->stream.avail_in = avail_in; 709 710 /* Decompress as much as we can in one pass. */ 711 ret = lzma_code(&(state->stream), 712 (state->stream.avail_in == 0)? LZMA_FINISH: LZMA_RUN); 713 switch (ret) { 714 case LZMA_STREAM_END: /* Found end of stream. */ 715 state->eof = 1; 716 /* FALL THROUGH */ 717 case LZMA_OK: /* Decompressor made some progress. */ 718 __archive_read_filter_consume(self->upstream, 719 avail_in - state->stream.avail_in); 720 state->member_in += 721 avail_in - state->stream.avail_in; 722 break; 723 default: 724 set_error(self, ret); 725 return (ARCHIVE_FATAL); 726 } 727 } 728 729 decompressed = state->stream.next_out - state->out_block; 730 state->total_out += decompressed; 731 state->member_out += decompressed; 732 if (decompressed == 0) 733 *p = NULL; 734 else { 735 *p = state->out_block; 736 if (self->code == ARCHIVE_FILTER_LZIP) { 737 state->crc32 = lzma_crc32(state->out_block, 738 decompressed, state->crc32); 739 if (state->eof) { 740 ret = lzip_tail(self); 741 if (ret != ARCHIVE_OK) 742 return (ret); 743 } 744 } 745 } 746 return (decompressed); 747} 748 749/* 750 * Clean up the decompressor. 751 */ 752static int 753xz_filter_close(struct archive_read_filter *self) 754{ 755 struct private_data *state; 756 757 state = (struct private_data *)self->data; 758 lzma_end(&(state->stream)); 759 free(state->out_block); 760 free(state); 761 return (ARCHIVE_OK); 762} 763 764#else 765 766#if HAVE_LZMADEC_H && HAVE_LIBLZMADEC 767 768/* 769 * If we have the older liblzmadec library, then we can handle 770 * LZMA streams but not XZ streams. 771 */ 772 773/* 774 * Setup the callbacks. 775 */ 776static int 777lzma_bidder_init(struct archive_read_filter *self) 778{ 779 static const size_t out_block_size = 64 * 1024; 780 void *out_block; 781 struct private_data *state; 782 ssize_t ret, avail_in; 783 784 self->code = ARCHIVE_FILTER_LZMA; 785 self->name = "lzma"; 786 787 state = (struct private_data *)calloc(sizeof(*state), 1); 788 out_block = (unsigned char *)malloc(out_block_size); 789 if (state == NULL || out_block == NULL) { 790 archive_set_error(&self->archive->archive, ENOMEM, 791 "Can't allocate data for lzma decompression"); 792 free(out_block); 793 free(state); 794 return (ARCHIVE_FATAL); 795 } 796 797 self->data = state; 798 state->out_block_size = out_block_size; 799 state->out_block = out_block; 800 self->read = lzma_filter_read; 801 self->skip = NULL; /* not supported */ 802 self->close = lzma_filter_close; 803 804 /* Prime the lzma library with 18 bytes of input. */ 805 state->stream.next_in = (unsigned char *)(uintptr_t) 806 __archive_read_filter_ahead(self->upstream, 18, &avail_in); 807 if (state->stream.next_in == NULL) 808 return (ARCHIVE_FATAL); 809 state->stream.avail_in = avail_in; 810 state->stream.next_out = state->out_block; 811 state->stream.avail_out = state->out_block_size; 812 813 /* Initialize compression library. */ 814 ret = lzmadec_init(&(state->stream)); 815 __archive_read_filter_consume(self->upstream, 816 avail_in - state->stream.avail_in); 817 if (ret == LZMADEC_OK) 818 return (ARCHIVE_OK); 819 820 /* Library setup failed: Clean up. */ 821 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 822 "Internal error initializing lzma library"); 823 824 /* Override the error message if we know what really went wrong. */ 825 switch (ret) { 826 case LZMADEC_HEADER_ERROR: 827 archive_set_error(&self->archive->archive, 828 ARCHIVE_ERRNO_MISC, 829 "Internal error initializing compression library: " 830 "invalid header"); 831 break; 832 case LZMADEC_MEM_ERROR: 833 archive_set_error(&self->archive->archive, ENOMEM, 834 "Internal error initializing compression library: " 835 "out of memory"); 836 break; 837 } 838 839 free(state->out_block); 840 free(state); 841 self->data = NULL; 842 return (ARCHIVE_FATAL); 843} 844 845/* 846 * Return the next block of decompressed data. 847 */ 848static ssize_t 849lzma_filter_read(struct archive_read_filter *self, const void **p) 850{ 851 struct private_data *state; 852 size_t decompressed; 853 ssize_t avail_in, ret; 854 855 state = (struct private_data *)self->data; 856 857 /* Empty our output buffer. */ 858 state->stream.next_out = state->out_block; 859 state->stream.avail_out = state->out_block_size; 860 861 /* Try to fill the output buffer. */ 862 while (state->stream.avail_out > 0 && !state->eof) { 863 state->stream.next_in = (unsigned char *)(uintptr_t) 864 __archive_read_filter_ahead(self->upstream, 1, &avail_in); 865 if (state->stream.next_in == NULL && avail_in < 0) { 866 archive_set_error(&self->archive->archive, 867 ARCHIVE_ERRNO_MISC, 868 "truncated lzma input"); 869 return (ARCHIVE_FATAL); 870 } 871 state->stream.avail_in = avail_in; 872 873 /* Decompress as much as we can in one pass. */ 874 ret = lzmadec_decode(&(state->stream), avail_in == 0); 875 switch (ret) { 876 case LZMADEC_STREAM_END: /* Found end of stream. */ 877 state->eof = 1; 878 /* FALL THROUGH */ 879 case LZMADEC_OK: /* Decompressor made some progress. */ 880 __archive_read_filter_consume(self->upstream, 881 avail_in - state->stream.avail_in); 882 break; 883 case LZMADEC_BUF_ERROR: /* Insufficient input data? */ 884 archive_set_error(&self->archive->archive, 885 ARCHIVE_ERRNO_MISC, 886 "Insufficient compressed data"); 887 return (ARCHIVE_FATAL); 888 default: 889 /* Return an error. */ 890 archive_set_error(&self->archive->archive, 891 ARCHIVE_ERRNO_MISC, 892 "Lzma decompression failed"); 893 return (ARCHIVE_FATAL); 894 } 895 } 896 897 decompressed = state->stream.next_out - state->out_block; 898 state->total_out += decompressed; 899 if (decompressed == 0) 900 *p = NULL; 901 else 902 *p = state->out_block; 903 return (decompressed); 904} 905 906/* 907 * Clean up the decompressor. 908 */ 909static int 910lzma_filter_close(struct archive_read_filter *self) 911{ 912 struct private_data *state; 913 int ret; 914 915 state = (struct private_data *)self->data; 916 ret = ARCHIVE_OK; 917 switch (lzmadec_end(&(state->stream))) { 918 case LZMADEC_OK: 919 break; 920 default: 921 archive_set_error(&(self->archive->archive), 922 ARCHIVE_ERRNO_MISC, 923 "Failed to clean up %s compressor", 924 self->archive->archive.compression_name); 925 ret = ARCHIVE_FATAL; 926 } 927 928 free(state->out_block); 929 free(state); 930 return (ret); 931} 932 933#else 934 935/* 936 * 937 * If we have no suitable library on this system, we can't actually do 938 * the decompression. We can, however, still detect compressed 939 * archives and emit a useful message. 940 * 941 */ 942static int 943lzma_bidder_init(struct archive_read_filter *self) 944{ 945 int r; 946 947 r = __archive_read_program(self, "lzma -d -qq"); 948 /* Note: We set the format here even if __archive_read_program() 949 * above fails. We do, after all, know what the format is 950 * even if we weren't able to read it. */ 951 self->code = ARCHIVE_FILTER_LZMA; 952 self->name = "lzma"; 953 return (r); 954} 955 956#endif /* HAVE_LZMADEC_H */ 957 958 959static int 960xz_bidder_init(struct archive_read_filter *self) 961{ 962 int r; 963 964 r = __archive_read_program(self, "xz -d -qq"); 965 /* Note: We set the format here even if __archive_read_program() 966 * above fails. We do, after all, know what the format is 967 * even if we weren't able to read it. */ 968 self->code = ARCHIVE_FILTER_XZ; 969 self->name = "xz"; 970 return (r); 971} 972 973static int 974lzip_bidder_init(struct archive_read_filter *self) 975{ 976 int r; 977 978 r = __archive_read_program(self, "lzip -d -q"); 979 /* Note: We set the format here even if __archive_read_program() 980 * above fails. We do, after all, know what the format is 981 * even if we weren't able to read it. */ 982 self->code = ARCHIVE_FILTER_LZIP; 983 self->name = "lzip"; 984 return (r); 985} 986 987 988#endif /* HAVE_LZMA_H */ 989