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