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->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 154 int 155 archive_read_support_compression_lzma(struct archive *a) 156 { 157 return archive_read_support_filter_lzma(a); 158 } 159 #endif 160 161 int 162 archive_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 192 int 193 archive_read_support_compression_lzip(struct archive *a) 194 { 195 return archive_read_support_filter_lzip(a); 196 } 197 #endif 198 199 int 200 archive_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 */ 229 static int 230 xz_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 */ 263 static int 264 lzma_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 370 static int 371 lzip_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 404 static int 405 lzip_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 */ 418 static int 419 xz_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 426 static int 427 lzma_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 434 static int 435 lzip_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 */ 445 static void 446 set_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 */ 493 static int 494 xz_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 556 static int 557 lzip_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 614 static int 615 lzip_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 */ 675 static ssize_t 676 xz_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 */ 752 static int 753 xz_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 */ 776 static int 777 lzma_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 */ 848 static ssize_t 849 lzma_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 */ 909 static int 910 lzma_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 */ 942 static int 943 lzma_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 959 static int 960 xz_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 973 static int 974 lzip_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