1 /*- 2 * Copyright (c) 2003-2010 Tim Kientzle 3 * Copyright (c) 2009-2012 Michihiro NAKAJIMA 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: head/lib/libarchive/archive_write_set_compression_xz.c 201108 2009-12-28 03:28:21Z kientzle $"); 30 31 #ifdef HAVE_ERRNO_H 32 #include <errno.h> 33 #endif 34 #ifdef HAVE_STDLIB_H 35 #include <stdlib.h> 36 #endif 37 #ifdef HAVE_STRING_H 38 #include <string.h> 39 #endif 40 #include <time.h> 41 #ifdef HAVE_LZMA_H 42 #include <lzma.h> 43 #endif 44 45 #include "archive.h" 46 #include "archive_endian.h" 47 #include "archive_private.h" 48 #include "archive_write_private.h" 49 50 #if ARCHIVE_VERSION_NUMBER < 4000000 51 int 52 archive_write_set_compression_lzip(struct archive *a) 53 { 54 __archive_write_filters_free(a); 55 return (archive_write_add_filter_lzip(a)); 56 } 57 58 int 59 archive_write_set_compression_lzma(struct archive *a) 60 { 61 __archive_write_filters_free(a); 62 return (archive_write_add_filter_lzma(a)); 63 } 64 65 int 66 archive_write_set_compression_xz(struct archive *a) 67 { 68 __archive_write_filters_free(a); 69 return (archive_write_add_filter_xz(a)); 70 } 71 72 #endif 73 74 #ifndef HAVE_LZMA_H 75 int 76 archive_write_add_filter_xz(struct archive *a) 77 { 78 archive_set_error(a, ARCHIVE_ERRNO_MISC, 79 "xz compression not supported on this platform"); 80 return (ARCHIVE_FATAL); 81 } 82 83 int 84 archive_write_add_filter_lzma(struct archive *a) 85 { 86 archive_set_error(a, ARCHIVE_ERRNO_MISC, 87 "lzma compression not supported on this platform"); 88 return (ARCHIVE_FATAL); 89 } 90 91 int 92 archive_write_add_filter_lzip(struct archive *a) 93 { 94 archive_set_error(a, ARCHIVE_ERRNO_MISC, 95 "lzma compression not supported on this platform"); 96 return (ARCHIVE_FATAL); 97 } 98 #else 99 /* Don't compile this if we don't have liblzma. */ 100 101 struct private_data { 102 int compression_level; 103 uint32_t threads; 104 lzma_stream stream; 105 lzma_filter lzmafilters[2]; 106 lzma_options_lzma lzma_opt; 107 int64_t total_in; 108 unsigned char *compressed; 109 size_t compressed_buffer_size; 110 int64_t total_out; 111 /* the CRC32 value of uncompressed data for lzip */ 112 uint32_t crc32; 113 }; 114 115 static int archive_compressor_xz_options(struct archive_write_filter *, 116 const char *, const char *); 117 static int archive_compressor_xz_open(struct archive_write_filter *); 118 static int archive_compressor_xz_write(struct archive_write_filter *, 119 const void *, size_t); 120 static int archive_compressor_xz_close(struct archive_write_filter *); 121 static int archive_compressor_xz_free(struct archive_write_filter *); 122 static int drive_compressor(struct archive_write_filter *, 123 struct private_data *, int finishing); 124 125 struct option_value { 126 uint32_t dict_size; 127 uint32_t nice_len; 128 lzma_match_finder mf; 129 }; 130 static const struct option_value option_values[] = { 131 { 1 << 16, 32, LZMA_MF_HC3}, 132 { 1 << 20, 32, LZMA_MF_HC3}, 133 { 3 << 19, 32, LZMA_MF_HC4}, 134 { 1 << 21, 32, LZMA_MF_BT4}, 135 { 3 << 20, 32, LZMA_MF_BT4}, 136 { 1 << 22, 32, LZMA_MF_BT4}, 137 { 1 << 23, 64, LZMA_MF_BT4}, 138 { 1 << 24, 64, LZMA_MF_BT4}, 139 { 3 << 23, 64, LZMA_MF_BT4}, 140 { 1 << 25, 64, LZMA_MF_BT4} 141 }; 142 143 static int 144 common_setup(struct archive_write_filter *f) 145 { 146 struct private_data *data; 147 struct archive_write *a = (struct archive_write *)f->archive; 148 data = calloc(1, sizeof(*data)); 149 if (data == NULL) { 150 archive_set_error(&a->archive, ENOMEM, "Out of memory"); 151 return (ARCHIVE_FATAL); 152 } 153 f->data = data; 154 data->compression_level = LZMA_PRESET_DEFAULT; 155 data->threads = 1; 156 f->open = &archive_compressor_xz_open; 157 f->close = archive_compressor_xz_close; 158 f->free = archive_compressor_xz_free; 159 f->options = &archive_compressor_xz_options; 160 return (ARCHIVE_OK); 161 } 162 163 /* 164 * Add an xz compression filter to this write handle. 165 */ 166 int 167 archive_write_add_filter_xz(struct archive *_a) 168 { 169 struct archive_write_filter *f; 170 int r; 171 172 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, 173 ARCHIVE_STATE_NEW, "archive_write_add_filter_xz"); 174 f = __archive_write_allocate_filter(_a); 175 r = common_setup(f); 176 if (r == ARCHIVE_OK) { 177 f->code = ARCHIVE_FILTER_XZ; 178 f->name = "xz"; 179 } 180 return (r); 181 } 182 183 /* LZMA is handled identically, we just need a different compression 184 * code set. (The liblzma setup looks at the code to determine 185 * the one place that XZ and LZMA require different handling.) */ 186 int 187 archive_write_add_filter_lzma(struct archive *_a) 188 { 189 struct archive_write_filter *f; 190 int r; 191 192 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, 193 ARCHIVE_STATE_NEW, "archive_write_add_filter_lzma"); 194 f = __archive_write_allocate_filter(_a); 195 r = common_setup(f); 196 if (r == ARCHIVE_OK) { 197 f->code = ARCHIVE_FILTER_LZMA; 198 f->name = "lzma"; 199 } 200 return (r); 201 } 202 203 int 204 archive_write_add_filter_lzip(struct archive *_a) 205 { 206 struct archive_write_filter *f; 207 int r; 208 209 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, 210 ARCHIVE_STATE_NEW, "archive_write_add_filter_lzip"); 211 f = __archive_write_allocate_filter(_a); 212 r = common_setup(f); 213 if (r == ARCHIVE_OK) { 214 f->code = ARCHIVE_FILTER_LZIP; 215 f->name = "lzip"; 216 } 217 return (r); 218 } 219 220 static int 221 archive_compressor_xz_init_stream(struct archive_write_filter *f, 222 struct private_data *data) 223 { 224 static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT; 225 int ret; 226 #ifdef HAVE_LZMA_STREAM_ENCODER_MT 227 lzma_mt mt_options; 228 #endif 229 230 data->stream = lzma_stream_init_data; 231 data->stream.next_out = data->compressed; 232 data->stream.avail_out = data->compressed_buffer_size; 233 if (f->code == ARCHIVE_FILTER_XZ) { 234 #ifdef HAVE_LZMA_STREAM_ENCODER_MT 235 if (data->threads != 1) { 236 bzero(&mt_options, sizeof(mt_options)); 237 mt_options.threads = data->threads; 238 mt_options.timeout = 300; 239 mt_options.filters = data->lzmafilters; 240 mt_options.check = LZMA_CHECK_CRC64; 241 ret = lzma_stream_encoder_mt(&(data->stream), 242 &mt_options); 243 } else 244 #endif 245 ret = lzma_stream_encoder(&(data->stream), 246 data->lzmafilters, LZMA_CHECK_CRC64); 247 } else if (f->code == ARCHIVE_FILTER_LZMA) { 248 ret = lzma_alone_encoder(&(data->stream), &data->lzma_opt); 249 } else { /* ARCHIVE_FILTER_LZIP */ 250 int dict_size = data->lzma_opt.dict_size; 251 int ds, log2dic, wedges; 252 253 /* Calculate a coded dictionary size */ 254 if (dict_size < (1 << 12) || dict_size > (1 << 27)) { 255 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 256 "Unacceptable dictionary size for lzip: %d", 257 dict_size); 258 return (ARCHIVE_FATAL); 259 } 260 for (log2dic = 27; log2dic >= 12; log2dic--) { 261 if (dict_size & (1 << log2dic)) 262 break; 263 } 264 if (dict_size > (1 << log2dic)) { 265 log2dic++; 266 wedges = 267 ((1 << log2dic) - dict_size) / (1 << (log2dic - 4)); 268 } else 269 wedges = 0; 270 ds = ((wedges << 5) & 0xe0) | (log2dic & 0x1f); 271 272 data->crc32 = 0; 273 /* Make a header */ 274 data->compressed[0] = 0x4C; 275 data->compressed[1] = 0x5A; 276 data->compressed[2] = 0x49; 277 data->compressed[3] = 0x50; 278 data->compressed[4] = 1;/* Version */ 279 data->compressed[5] = (unsigned char)ds; 280 data->stream.next_out += 6; 281 data->stream.avail_out -= 6; 282 283 ret = lzma_raw_encoder(&(data->stream), data->lzmafilters); 284 } 285 if (ret == LZMA_OK) 286 return (ARCHIVE_OK); 287 288 switch (ret) { 289 case LZMA_MEM_ERROR: 290 archive_set_error(f->archive, ENOMEM, 291 "Internal error initializing compression library: " 292 "Cannot allocate memory"); 293 break; 294 default: 295 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 296 "Internal error initializing compression library: " 297 "It's a bug in liblzma"); 298 break; 299 } 300 return (ARCHIVE_FATAL); 301 } 302 303 /* 304 * Setup callback. 305 */ 306 static int 307 archive_compressor_xz_open(struct archive_write_filter *f) 308 { 309 struct private_data *data = f->data; 310 int ret; 311 312 ret = __archive_write_open_filter(f->next_filter); 313 if (ret != ARCHIVE_OK) 314 return (ret); 315 316 if (data->compressed == NULL) { 317 size_t bs = 65536, bpb; 318 if (f->archive->magic == ARCHIVE_WRITE_MAGIC) { 319 /* Buffer size should be a multiple number of the of bytes 320 * per block for performance. */ 321 bpb = archive_write_get_bytes_per_block(f->archive); 322 if (bpb > bs) 323 bs = bpb; 324 else if (bpb != 0) 325 bs -= bs % bpb; 326 } 327 data->compressed_buffer_size = bs; 328 data->compressed 329 = (unsigned char *)malloc(data->compressed_buffer_size); 330 if (data->compressed == NULL) { 331 archive_set_error(f->archive, ENOMEM, 332 "Can't allocate data for compression buffer"); 333 return (ARCHIVE_FATAL); 334 } 335 } 336 337 f->write = archive_compressor_xz_write; 338 339 /* Initialize compression library. */ 340 if (f->code == ARCHIVE_FILTER_LZIP) { 341 const struct option_value *val = 342 &option_values[data->compression_level]; 343 344 data->lzma_opt.dict_size = val->dict_size; 345 data->lzma_opt.preset_dict = NULL; 346 data->lzma_opt.preset_dict_size = 0; 347 data->lzma_opt.lc = LZMA_LC_DEFAULT; 348 data->lzma_opt.lp = LZMA_LP_DEFAULT; 349 data->lzma_opt.pb = LZMA_PB_DEFAULT; 350 data->lzma_opt.mode = 351 data->compression_level<= 2? LZMA_MODE_FAST:LZMA_MODE_NORMAL; 352 data->lzma_opt.nice_len = val->nice_len; 353 data->lzma_opt.mf = val->mf; 354 data->lzma_opt.depth = 0; 355 data->lzmafilters[0].id = LZMA_FILTER_LZMA1; 356 data->lzmafilters[0].options = &data->lzma_opt; 357 data->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */ 358 } else { 359 if (lzma_lzma_preset(&data->lzma_opt, data->compression_level)) { 360 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 361 "Internal error initializing compression library"); 362 } 363 data->lzmafilters[0].id = LZMA_FILTER_LZMA2; 364 data->lzmafilters[0].options = &data->lzma_opt; 365 data->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */ 366 } 367 ret = archive_compressor_xz_init_stream(f, data); 368 if (ret == LZMA_OK) { 369 f->data = data; 370 return (0); 371 } 372 return (ARCHIVE_FATAL); 373 } 374 375 /* 376 * Set write options. 377 */ 378 static int 379 archive_compressor_xz_options(struct archive_write_filter *f, 380 const char *key, const char *value) 381 { 382 struct private_data *data = (struct private_data *)f->data; 383 384 if (strcmp(key, "compression-level") == 0) { 385 if (value == NULL || !(value[0] >= '0' && value[0] <= '9') || 386 value[1] != '\0') 387 return (ARCHIVE_WARN); 388 data->compression_level = value[0] - '0'; 389 if (data->compression_level > 6) 390 data->compression_level = 6; 391 return (ARCHIVE_OK); 392 } else if (strcmp(key, "threads") == 0) { 393 if (value == NULL) 394 return (ARCHIVE_WARN); 395 data->threads = (int)strtoul(value, NULL, 10); 396 if (data->threads == 0 && errno != 0) { 397 data->threads = 1; 398 return (ARCHIVE_WARN); 399 } 400 if (data->threads == 0) { 401 #ifdef HAVE_LZMA_STREAM_ENCODER_MT 402 data->threads = lzma_cputhreads(); 403 #else 404 data->threads = 1; 405 #endif 406 } 407 return (ARCHIVE_OK); 408 } 409 410 /* Note: The "warn" return is just to inform the options 411 * supervisor that we didn't handle it. It will generate 412 * a suitable error if no one used this option. */ 413 return (ARCHIVE_WARN); 414 } 415 416 /* 417 * Write data to the compressed stream. 418 */ 419 static int 420 archive_compressor_xz_write(struct archive_write_filter *f, 421 const void *buff, size_t length) 422 { 423 struct private_data *data = (struct private_data *)f->data; 424 int ret; 425 426 /* Update statistics */ 427 data->total_in += length; 428 if (f->code == ARCHIVE_FILTER_LZIP) 429 data->crc32 = lzma_crc32(buff, length, data->crc32); 430 431 /* Compress input data to output buffer */ 432 data->stream.next_in = buff; 433 data->stream.avail_in = length; 434 if ((ret = drive_compressor(f, data, 0)) != ARCHIVE_OK) 435 return (ret); 436 437 return (ARCHIVE_OK); 438 } 439 440 441 /* 442 * Finish the compression... 443 */ 444 static int 445 archive_compressor_xz_close(struct archive_write_filter *f) 446 { 447 struct private_data *data = (struct private_data *)f->data; 448 int ret, r1; 449 450 ret = drive_compressor(f, data, 1); 451 if (ret == ARCHIVE_OK) { 452 data->total_out += 453 data->compressed_buffer_size - data->stream.avail_out; 454 ret = __archive_write_filter(f->next_filter, 455 data->compressed, 456 data->compressed_buffer_size - data->stream.avail_out); 457 if (f->code == ARCHIVE_FILTER_LZIP && ret == ARCHIVE_OK) { 458 archive_le32enc(data->compressed, data->crc32); 459 archive_le64enc(data->compressed+4, data->total_in); 460 archive_le64enc(data->compressed+12, data->total_out + 20); 461 ret = __archive_write_filter(f->next_filter, 462 data->compressed, 20); 463 } 464 } 465 lzma_end(&(data->stream)); 466 r1 = __archive_write_close_filter(f->next_filter); 467 return (r1 < ret ? r1 : ret); 468 } 469 470 static int 471 archive_compressor_xz_free(struct archive_write_filter *f) 472 { 473 struct private_data *data = (struct private_data *)f->data; 474 free(data->compressed); 475 free(data); 476 f->data = NULL; 477 return (ARCHIVE_OK); 478 } 479 480 /* 481 * Utility function to push input data through compressor, 482 * writing full output blocks as necessary. 483 * 484 * Note that this handles both the regular write case (finishing == 485 * false) and the end-of-archive case (finishing == true). 486 */ 487 static int 488 drive_compressor(struct archive_write_filter *f, 489 struct private_data *data, int finishing) 490 { 491 int ret; 492 493 for (;;) { 494 if (data->stream.avail_out == 0) { 495 data->total_out += data->compressed_buffer_size; 496 ret = __archive_write_filter(f->next_filter, 497 data->compressed, 498 data->compressed_buffer_size); 499 if (ret != ARCHIVE_OK) 500 return (ARCHIVE_FATAL); 501 data->stream.next_out = data->compressed; 502 data->stream.avail_out = data->compressed_buffer_size; 503 } 504 505 /* If there's nothing to do, we're done. */ 506 if (!finishing && data->stream.avail_in == 0) 507 return (ARCHIVE_OK); 508 509 ret = lzma_code(&(data->stream), 510 finishing ? LZMA_FINISH : LZMA_RUN ); 511 512 switch (ret) { 513 case LZMA_OK: 514 /* In non-finishing case, check if compressor 515 * consumed everything */ 516 if (!finishing && data->stream.avail_in == 0) 517 return (ARCHIVE_OK); 518 /* In finishing case, this return always means 519 * there's more work */ 520 break; 521 case LZMA_STREAM_END: 522 /* This return can only occur in finishing case. */ 523 if (finishing) 524 return (ARCHIVE_OK); 525 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 526 "lzma compression data error"); 527 return (ARCHIVE_FATAL); 528 case LZMA_MEMLIMIT_ERROR: 529 archive_set_error(f->archive, ENOMEM, 530 "lzma compression error: " 531 "%ju MiB would have been needed", 532 (uintmax_t)((lzma_memusage(&(data->stream)) 533 + 1024 * 1024 -1) 534 / (1024 * 1024))); 535 return (ARCHIVE_FATAL); 536 default: 537 /* Any other return value indicates an error. */ 538 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 539 "lzma compression failed:" 540 " lzma_code() call returned status %d", 541 ret); 542 return (ARCHIVE_FATAL); 543 } 544 } 545 } 546 547 #endif /* HAVE_LZMA_H */ 548