1/*- 2 * Copyright (c) 2009 Michihiro NAKAJIMA 3 * Copyright (c) 2003-2007 Tim Kientzle 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_private.h" 47#include "archive_write_private.h" 48 49#ifndef HAVE_LZMA_H 50int 51archive_write_set_compression_xz(struct archive *a) 52{ 53 archive_set_error(a, ARCHIVE_ERRNO_MISC, 54 "xz compression not supported on this platform"); 55 return (ARCHIVE_FATAL); 56} 57 58int 59archive_write_set_compression_lzma(struct archive *a) 60{ 61 archive_set_error(a, ARCHIVE_ERRNO_MISC, 62 "lzma compression not supported on this platform"); 63 return (ARCHIVE_FATAL); 64} 65#else 66/* Don't compile this if we don't have liblzma. */ 67 68struct private_data { 69 lzma_stream stream; 70 lzma_filter lzmafilters[2]; 71 lzma_options_lzma lzma_opt; 72 int64_t total_in; 73 unsigned char *compressed; 74 size_t compressed_buffer_size; 75}; 76 77struct private_config { 78 int compression_level; 79}; 80 81static int archive_compressor_xz_init(struct archive_write *); 82static int archive_compressor_xz_options(struct archive_write *, 83 const char *, const char *); 84static int archive_compressor_xz_finish(struct archive_write *); 85static int archive_compressor_xz_write(struct archive_write *, 86 const void *, size_t); 87static int drive_compressor(struct archive_write *, struct private_data *, 88 int finishing); 89 90 91/* 92 * Allocate, initialize and return a archive object. 93 */ 94int 95archive_write_set_compression_xz(struct archive *_a) 96{ 97 struct private_config *config; 98 struct archive_write *a = (struct archive_write *)_a; 99 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 100 ARCHIVE_STATE_NEW, "archive_write_set_compression_xz"); 101 config = calloc(1, sizeof(*config)); 102 if (config == NULL) { 103 archive_set_error(&a->archive, ENOMEM, "Out of memory"); 104 return (ARCHIVE_FATAL); 105 } 106 a->compressor.config = config; 107 a->compressor.finish = archive_compressor_xz_finish; 108 config->compression_level = LZMA_PRESET_DEFAULT; 109 a->compressor.init = &archive_compressor_xz_init; 110 a->compressor.options = &archive_compressor_xz_options; 111 a->archive.compression_code = ARCHIVE_COMPRESSION_XZ; 112 a->archive.compression_name = "xz"; 113 return (ARCHIVE_OK); 114} 115 116/* LZMA is handled identically, we just need a different compression 117 * code set. (The liblzma setup looks at the code to determine 118 * the one place that XZ and LZMA require different handling.) */ 119int 120archive_write_set_compression_lzma(struct archive *_a) 121{ 122 struct archive_write *a = (struct archive_write *)_a; 123 int r = archive_write_set_compression_xz(_a); 124 if (r != ARCHIVE_OK) 125 return (r); 126 a->archive.compression_code = ARCHIVE_COMPRESSION_LZMA; 127 a->archive.compression_name = "lzma"; 128 return (ARCHIVE_OK); 129} 130 131static int 132archive_compressor_xz_init_stream(struct archive_write *a, 133 struct private_data *state) 134{ 135 int ret; 136 137 state->stream = (lzma_stream)LZMA_STREAM_INIT; 138 state->stream.next_out = state->compressed; 139 state->stream.avail_out = state->compressed_buffer_size; 140 if (a->archive.compression_code == ARCHIVE_COMPRESSION_XZ) 141 ret = lzma_stream_encoder(&(state->stream), 142 state->lzmafilters, LZMA_CHECK_CRC64); 143 else 144 ret = lzma_alone_encoder(&(state->stream), &state->lzma_opt); 145 if (ret == LZMA_OK) 146 return (ARCHIVE_OK); 147 148 switch (ret) { 149 case LZMA_MEM_ERROR: 150 archive_set_error(&a->archive, ENOMEM, 151 "Internal error initializing compression library: " 152 "Cannot allocate memory"); 153 break; 154 default: 155 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 156 "Internal error initializing compression library: " 157 "It's a bug in liblzma"); 158 break; 159 } 160 return (ARCHIVE_FATAL); 161} 162 163/* 164 * Setup callback. 165 */ 166static int 167archive_compressor_xz_init(struct archive_write *a) 168{ 169 int ret; 170 struct private_data *state; 171 struct private_config *config; 172 173 if (a->client_opener != NULL) { 174 ret = (a->client_opener)(&a->archive, a->client_data); 175 if (ret != ARCHIVE_OK) 176 return (ret); 177 } 178 179 state = (struct private_data *)malloc(sizeof(*state)); 180 if (state == NULL) { 181 archive_set_error(&a->archive, ENOMEM, 182 "Can't allocate data for compression"); 183 return (ARCHIVE_FATAL); 184 } 185 memset(state, 0, sizeof(*state)); 186 config = a->compressor.config; 187 188 /* 189 * See comment above. We should set compressed_buffer_size to 190 * max(bytes_per_block, 65536), but the code can't handle that yet. 191 */ 192 state->compressed_buffer_size = a->bytes_per_block; 193 state->compressed = (unsigned char *)malloc(state->compressed_buffer_size); 194 if (state->compressed == NULL) { 195 archive_set_error(&a->archive, ENOMEM, 196 "Can't allocate data for compression buffer"); 197 free(state); 198 return (ARCHIVE_FATAL); 199 } 200 a->compressor.write = archive_compressor_xz_write; 201 202 /* Initialize compression library. */ 203 if (lzma_lzma_preset(&state->lzma_opt, config->compression_level)) { 204 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 205 "Internal error initializing compression library"); 206 free(state->compressed); 207 free(state); 208 } 209 state->lzmafilters[0].id = LZMA_FILTER_LZMA2; 210 state->lzmafilters[0].options = &state->lzma_opt; 211 state->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */ 212 ret = archive_compressor_xz_init_stream(a, state); 213 if (ret == LZMA_OK) { 214 a->compressor.data = state; 215 return (0); 216 } 217 /* Library setup failed: clean up. */ 218 free(state->compressed); 219 free(state); 220 221 return (ARCHIVE_FATAL); 222} 223 224/* 225 * Set write options. 226 */ 227static int 228archive_compressor_xz_options(struct archive_write *a, const char *key, 229 const char *value) 230{ 231 struct private_config *config; 232 233 config = (struct private_config *)a->compressor.config; 234 if (strcmp(key, "compression-level") == 0) { 235 if (value == NULL || !(value[0] >= '0' && value[0] <= '9') || 236 value[1] != '\0') 237 return (ARCHIVE_WARN); 238 config->compression_level = value[0] - '0'; 239 if (config->compression_level > 6) 240 config->compression_level = 6; 241 return (ARCHIVE_OK); 242 } 243 244 return (ARCHIVE_WARN); 245} 246 247/* 248 * Write data to the compressed stream. 249 */ 250static int 251archive_compressor_xz_write(struct archive_write *a, const void *buff, 252 size_t length) 253{ 254 struct private_data *state; 255 int ret; 256 257 state = (struct private_data *)a->compressor.data; 258 if (a->client_writer == NULL) { 259 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, 260 "No write callback is registered? " 261 "This is probably an internal programming error."); 262 return (ARCHIVE_FATAL); 263 } 264 265 /* Update statistics */ 266 state->total_in += length; 267 268 /* Compress input data to output buffer */ 269 state->stream.next_in = buff; 270 state->stream.avail_in = length; 271 if ((ret = drive_compressor(a, state, 0)) != ARCHIVE_OK) 272 return (ret); 273 274 a->archive.file_position += length; 275 return (ARCHIVE_OK); 276} 277 278 279/* 280 * Finish the compression... 281 */ 282static int 283archive_compressor_xz_finish(struct archive_write *a) 284{ 285 ssize_t block_length, target_block_length, bytes_written; 286 int ret; 287 struct private_data *state; 288 unsigned tocopy; 289 290 ret = ARCHIVE_OK; 291 state = (struct private_data *)a->compressor.data; 292 if (state != NULL) { 293 if (a->client_writer == NULL) { 294 archive_set_error(&a->archive, 295 ARCHIVE_ERRNO_PROGRAMMER, 296 "No write callback is registered? " 297 "This is probably an internal programming error."); 298 ret = ARCHIVE_FATAL; 299 goto cleanup; 300 } 301 302 /* By default, always pad the uncompressed data. */ 303 if (a->pad_uncompressed) { 304 tocopy = a->bytes_per_block - 305 (state->total_in % a->bytes_per_block); 306 while (tocopy > 0 && tocopy < (unsigned)a->bytes_per_block) { 307 state->stream.next_in = a->nulls; 308 state->stream.avail_in = tocopy < a->null_length ? 309 tocopy : a->null_length; 310 state->total_in += state->stream.avail_in; 311 tocopy -= state->stream.avail_in; 312 ret = drive_compressor(a, state, 0); 313 if (ret != ARCHIVE_OK) 314 goto cleanup; 315 } 316 } 317 318 /* Finish compression cycle */ 319 if (((ret = drive_compressor(a, state, 1))) != ARCHIVE_OK) 320 goto cleanup; 321 322 /* Optionally, pad the final compressed block. */ 323 block_length = state->stream.next_out - state->compressed; 324 325 /* Tricky calculation to determine size of last block. */ 326 if (a->bytes_in_last_block <= 0) 327 /* Default or Zero: pad to full block */ 328 target_block_length = a->bytes_per_block; 329 else 330 /* Round length to next multiple of bytes_in_last_block. */ 331 target_block_length = a->bytes_in_last_block * 332 ( (block_length + a->bytes_in_last_block - 1) / 333 a->bytes_in_last_block); 334 if (target_block_length > a->bytes_per_block) 335 target_block_length = a->bytes_per_block; 336 if (block_length < target_block_length) { 337 memset(state->stream.next_out, 0, 338 target_block_length - block_length); 339 block_length = target_block_length; 340 } 341 342 /* Write the last block */ 343 bytes_written = (a->client_writer)(&a->archive, a->client_data, 344 state->compressed, block_length); 345 if (bytes_written <= 0) { 346 ret = ARCHIVE_FATAL; 347 goto cleanup; 348 } 349 a->archive.raw_position += bytes_written; 350 351 /* Cleanup: shut down compressor, release memory, etc. */ 352 cleanup: 353 lzma_end(&(state->stream)); 354 free(state->compressed); 355 free(state); 356 } 357 free(a->compressor.config); 358 a->compressor.config = NULL; 359 return (ret); 360} 361 362/* 363 * Utility function to push input data through compressor, 364 * writing full output blocks as necessary. 365 * 366 * Note that this handles both the regular write case (finishing == 367 * false) and the end-of-archive case (finishing == true). 368 */ 369static int 370drive_compressor(struct archive_write *a, struct private_data *state, int finishing) 371{ 372 ssize_t bytes_written; 373 int ret; 374 375 for (;;) { 376 if (state->stream.avail_out == 0) { 377 bytes_written = (a->client_writer)(&a->archive, 378 a->client_data, state->compressed, 379 state->compressed_buffer_size); 380 if (bytes_written <= 0) { 381 /* TODO: Handle this write failure */ 382 return (ARCHIVE_FATAL); 383 } else if ((size_t)bytes_written < state->compressed_buffer_size) { 384 /* Short write: Move remaining to 385 * front of block and keep filling */ 386 memmove(state->compressed, 387 state->compressed + bytes_written, 388 state->compressed_buffer_size - bytes_written); 389 } 390 a->archive.raw_position += bytes_written; 391 state->stream.next_out 392 = state->compressed + 393 state->compressed_buffer_size - bytes_written; 394 state->stream.avail_out = bytes_written; 395 } 396 397 /* If there's nothing to do, we're done. */ 398 if (!finishing && state->stream.avail_in == 0) 399 return (ARCHIVE_OK); 400 401 ret = lzma_code(&(state->stream), 402 finishing ? LZMA_FINISH : LZMA_RUN ); 403 404 switch (ret) { 405 case LZMA_OK: 406 /* In non-finishing case, check if compressor 407 * consumed everything */ 408 if (!finishing && state->stream.avail_in == 0) 409 return (ARCHIVE_OK); 410 /* In finishing case, this return always means 411 * there's more work */ 412 break; 413 case LZMA_STREAM_END: 414 /* This return can only occur in finishing case. */ 415 if (finishing) 416 return (ARCHIVE_OK); 417 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 418 "lzma compression data error"); 419 return (ARCHIVE_FATAL); 420 case LZMA_MEMLIMIT_ERROR: 421 archive_set_error(&a->archive, ENOMEM, 422 "lzma compression error: " 423 "%ju MiB would have been needed", 424 (lzma_memusage(&(state->stream)) + 1024 * 1024 -1) 425 / (1024 * 1024)); 426 return (ARCHIVE_FATAL); 427 default: 428 /* Any other return value indicates an error. */ 429 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 430 "lzma compression failed:" 431 " lzma_code() call returned status %d", 432 ret); 433 return (ARCHIVE_FATAL); 434 } 435 } 436} 437 438#endif /* HAVE_LZMA_H */ 439