archive_write_set_compression_xz.c revision 229592
1129198Scognet/*- 2129198Scognet * Copyright (c) 2009 Michihiro NAKAJIMA 3129198Scognet * Copyright (c) 2003-2007 Tim Kientzle 4129198Scognet * All rights reserved. 5129198Scognet * 6129198Scognet * Redistribution and use in source and binary forms, with or without 7129198Scognet * modification, are permitted provided that the following conditions 8129198Scognet * are met: 9129198Scognet * 1. Redistributions of source code must retain the above copyright 10129198Scognet * notice, this list of conditions and the following disclaimer. 11129198Scognet * 2. Redistributions in binary form must reproduce the above copyright 12129198Scognet * notice, this list of conditions and the following disclaimer in the 13263036Simp * documentation and/or other materials provided with the distribution. 14129198Scognet * 15129198Scognet * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16129198Scognet * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17129198Scognet * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18129198Scognet * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19129198Scognet * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20129198Scognet * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21129198Scognet * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22129198Scognet * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23129198Scognet * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24129198Scognet * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25129198Scognet */ 26129198Scognet 27129198Scognet#include "archive_platform.h" 28129198Scognet 29129198Scognet__FBSDID("$FreeBSD: stable/9/contrib/libarchive/libarchive/archive_write_set_compression_xz.c 229592 2012-01-05 12:06:54Z mm $"); 30129198Scognet 31129198Scognet#ifdef HAVE_ERRNO_H 32129198Scognet#include <errno.h> 33129198Scognet#endif 34129198Scognet#ifdef HAVE_STDLIB_H 35223668Sjonathan#include <stdlib.h> 36219134Srwatson#endif 37129198Scognet#ifdef HAVE_STRING_H 38129198Scognet#include <string.h> 39263233Srwatson#endif 40129198Scognet#include <time.h> 41129198Scognet#ifdef HAVE_LZMA_H 42129198Scognet#include <lzma.h> 43129198Scognet#endif 44283947Sian 45283947Sian#include "archive.h" 46129198Scognet#include "archive_private.h" 47295315Smmel#include "archive_write_private.h" 48135642Scognet 49283947Sian#ifndef HAVE_LZMA_H 50135642Scognetint 51129198Scognetarchive_write_set_compression_xz(struct archive *a) 52129198Scognet{ 53129198Scognet archive_set_error(a, ARCHIVE_ERRNO_MISC, 54129198Scognet "xz compression not supported on this platform"); 55129198Scognet return (ARCHIVE_FATAL); 56129198Scognet} 57129198Scognet 58135642Scognetint 59135642Scognetarchive_write_set_compression_lzma(struct archive *a) 60135642Scognet{ 61135642Scognet archive_set_error(a, ARCHIVE_ERRNO_MISC, 62283947Sian "lzma compression not supported on this platform"); 63135642Scognet return (ARCHIVE_FATAL); 64283947Sian} 65283947Sian#else 66283947Sian/* Don't compile this if we don't have liblzma. */ 67283947Sian 68283947Sianstruct private_data { 69283947Sian lzma_stream stream; 70283947Sian lzma_filter lzmafilters[2]; 71283947Sian lzma_options_lzma lzma_opt; 72283947Sian int64_t total_in; 73283947Sian unsigned char *compressed; 74283947Sian size_t compressed_buffer_size; 75283947Sian}; 76283947Sian 77283947Sianstruct private_config { 78283947Sian int compression_level; 79283947Sian}; 80283947Sian 81283947Sianstatic int archive_compressor_xz_init(struct archive_write *); 82283947Sianstatic int archive_compressor_xz_options(struct archive_write *, 83283947Sian const char *, const char *); 84283947Sianstatic int archive_compressor_xz_finish(struct archive_write *); 85283947Sianstatic int archive_compressor_xz_write(struct archive_write *, 86283947Sian const void *, size_t); 87283947Sianstatic int drive_compressor(struct archive_write *, struct private_data *, 88283947Sian int finishing); 89283947Sian 90283947Sian 91283947Sian/* 92283947Sian * Allocate, initialize and return a archive object. 93283947Sian */ 94283947Sianint 95283947Sianarchive_write_set_compression_xz(struct archive *_a) 96283947Sian{ 97283947Sian struct private_config *config; 98283947Sian struct archive_write *a = (struct archive_write *)_a; 99283947Sian __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 100283947Sian ARCHIVE_STATE_NEW, "archive_write_set_compression_xz"); 101135642Scognet config = calloc(1, sizeof(*config)); 102135642Scognet if (config == NULL) { 103135642Scognet archive_set_error(&a->archive, ENOMEM, "Out of memory"); 104135642Scognet return (ARCHIVE_FATAL); 105283947Sian } 106283947Sian a->compressor.config = config; 107283947Sian a->compressor.finish = archive_compressor_xz_finish; 108283947Sian config->compression_level = LZMA_PRESET_DEFAULT; 109135642Scognet a->compressor.init = &archive_compressor_xz_init; 110135642Scognet a->compressor.options = &archive_compressor_xz_options; 111135642Scognet a->archive.compression_code = ARCHIVE_COMPRESSION_XZ; 112135642Scognet a->archive.compression_name = "xz"; 113283947Sian return (ARCHIVE_OK); 114283947Sian} 115283947Sian 116283947Sian/* LZMA is handled identically, we just need a different compression 117283947Sian * code set. (The liblzma setup looks at the code to determine 118283947Sian * the one place that XZ and LZMA require different handling.) */ 119283947Sianint 120283947Sianarchive_write_set_compression_lzma(struct archive *_a) 121283947Sian{ 122283947Sian struct archive_write *a = (struct archive_write *)_a; 123283947Sian int r = archive_write_set_compression_xz(_a); 124283947Sian if (r != ARCHIVE_OK) 125283947Sian return (r); 126283947Sian a->archive.compression_code = ARCHIVE_COMPRESSION_LZMA; 127283947Sian a->archive.compression_name = "lzma"; 128283947Sian return (ARCHIVE_OK); 129283947Sian} 130283947Sian 131283947Sianstatic int 132283947Sianarchive_compressor_xz_init_stream(struct archive_write *a, 133283947Sian struct private_data *state) 134283947Sian{ 135283947Sian static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT; 136283947Sian int ret; 137283947Sian 138283947Sian state->stream = lzma_stream_init_data; 139283947Sian state->stream.next_out = state->compressed; 140283947Sian state->stream.avail_out = state->compressed_buffer_size; 141283947Sian if (a->archive.compression_code == ARCHIVE_COMPRESSION_XZ) 142283947Sian ret = lzma_stream_encoder(&(state->stream), 143135642Scognet state->lzmafilters, LZMA_CHECK_CRC64); 144283947Sian else 145135642Scognet ret = lzma_alone_encoder(&(state->stream), &state->lzma_opt); 146135642Scognet if (ret == LZMA_OK) 147166695Skevlo return (ARCHIVE_OK); 148135642Scognet 149135642Scognet switch (ret) { 150135642Scognet case LZMA_MEM_ERROR: 151135642Scognet archive_set_error(&a->archive, ENOMEM, 152135642Scognet "Internal error initializing compression library: " 153135642Scognet "Cannot allocate memory"); 154135642Scognet break; 155295319Smmel default: 156295319Smmel archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 157295319Smmel "Internal error initializing compression library: " 158295319Smmel "It's a bug in liblzma"); 159295319Smmel break; 160295319Smmel } 161135642Scognet return (ARCHIVE_FATAL); 162166695Skevlo} 163135642Scognet 164135642Scognet/* 165142519Scognet * Setup callback. 166142519Scognet */ 167142519Scognetstatic int 168142519Scognetarchive_compressor_xz_init(struct archive_write *a) 169284115Sandrew{ 170280402Sian int ret; 171239268Sgonzo struct private_data *state; 172307136Sed struct private_config *config; 173280402Sian 174239268Sgonzo if (a->client_opener != NULL) { 175142519Scognet ret = (a->client_opener)(&a->archive, a->client_data); 176142519Scognet if (ret != ARCHIVE_OK) 177142519Scognet return (ret); 178142519Scognet } 179142519Scognet 180142519Scognet state = (struct private_data *)malloc(sizeof(*state)); 181142519Scognet if (state == NULL) { 182284115Sandrew archive_set_error(&a->archive, ENOMEM, 183307136Sed "Can't allocate data for compression"); 184239268Sgonzo return (ARCHIVE_FATAL); 185280402Sian } 186239268Sgonzo memset(state, 0, sizeof(*state)); 187142519Scognet config = a->compressor.config; 188142519Scognet 189142519Scognet /* 190129198Scognet * See comment above. We should set compressed_buffer_size to 191129198Scognet * max(bytes_per_block, 65536), but the code can't handle that yet. 192129198Scognet */ 193129198Scognet state->compressed_buffer_size = a->bytes_per_block; 194129198Scognet state->compressed = (unsigned char *)malloc(state->compressed_buffer_size); 195135642Scognet if (state->compressed == NULL) { 196135642Scognet archive_set_error(&a->archive, ENOMEM, 197223668Sjonathan "Can't allocate data for compression buffer"); 198219134Srwatson free(state); 199223692Sjonathan return (ARCHIVE_FATAL); 200223692Sjonathan } 201223692Sjonathan a->compressor.write = archive_compressor_xz_write; 202219134Srwatson 203219134Srwatson /* Initialize compression library. */ 204219134Srwatson if (lzma_lzma_preset(&state->lzma_opt, config->compression_level)) { 205223692Sjonathan archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 206223692Sjonathan "Internal error initializing compression library"); 207223692Sjonathan free(state->compressed); 208223692Sjonathan free(state); 209223692Sjonathan } 210219134Srwatson state->lzmafilters[0].id = LZMA_FILTER_LZMA2; 211223692Sjonathan state->lzmafilters[0].options = &state->lzma_opt; 212226498Sdes state->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */ 213226498Sdes ret = archive_compressor_xz_init_stream(a, state); 214255677Spjd if (ret == LZMA_OK) { 215226498Sdes a->compressor.data = state; 216223692Sjonathan return (0); 217219134Srwatson } 218219134Srwatson /* Library setup failed: clean up. */ 219219134Srwatson free(state->compressed); 220219134Srwatson free(state); 221135642Scognet 222236991Simp return (ARCHIVE_FATAL); 223135642Scognet} 224135642Scognet 225236991Simp/* 226135642Scognet * Set write options. 227135642Scognet */ 228142519Scognetstatic int 229142519Scognetarchive_compressor_xz_options(struct archive_write *a, const char *key, 230142519Scognet const char *value) 231142519Scognet{ 232142519Scognet struct private_config *config; 233142519Scognet 234135642Scognet config = (struct private_config *)a->compressor.config; 235135642Scognet if (strcmp(key, "compression-level") == 0) { 236135642Scognet if (value == NULL || !(value[0] >= '0' && value[0] <= '9') || 237135642Scognet value[1] != '\0') 238135642Scognet return (ARCHIVE_WARN); 239129198Scognet config->compression_level = value[0] - '0'; 240 if (config->compression_level > 6) 241 config->compression_level = 6; 242 return (ARCHIVE_OK); 243 } 244 245 return (ARCHIVE_WARN); 246} 247 248/* 249 * Write data to the compressed stream. 250 */ 251static int 252archive_compressor_xz_write(struct archive_write *a, const void *buff, 253 size_t length) 254{ 255 struct private_data *state; 256 int ret; 257 258 state = (struct private_data *)a->compressor.data; 259 if (a->client_writer == NULL) { 260 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, 261 "No write callback is registered? " 262 "This is probably an internal programming error."); 263 return (ARCHIVE_FATAL); 264 } 265 266 /* Update statistics */ 267 state->total_in += length; 268 269 /* Compress input data to output buffer */ 270 state->stream.next_in = buff; 271 state->stream.avail_in = length; 272 if ((ret = drive_compressor(a, state, 0)) != ARCHIVE_OK) 273 return (ret); 274 275 a->archive.file_position += length; 276 return (ARCHIVE_OK); 277} 278 279 280/* 281 * Finish the compression... 282 */ 283static int 284archive_compressor_xz_finish(struct archive_write *a) 285{ 286 ssize_t block_length, target_block_length, bytes_written; 287 int ret; 288 struct private_data *state; 289 unsigned tocopy; 290 291 ret = ARCHIVE_OK; 292 state = (struct private_data *)a->compressor.data; 293 if (state != NULL) { 294 if (a->client_writer == NULL) { 295 archive_set_error(&a->archive, 296 ARCHIVE_ERRNO_PROGRAMMER, 297 "No write callback is registered? " 298 "This is probably an internal programming error."); 299 ret = ARCHIVE_FATAL; 300 goto cleanup; 301 } 302 303 /* By default, always pad the uncompressed data. */ 304 if (a->pad_uncompressed) { 305 tocopy = a->bytes_per_block - 306 (state->total_in % a->bytes_per_block); 307 while (tocopy > 0 && tocopy < (unsigned)a->bytes_per_block) { 308 state->stream.next_in = a->nulls; 309 state->stream.avail_in = tocopy < a->null_length ? 310 tocopy : a->null_length; 311 state->total_in += state->stream.avail_in; 312 tocopy -= state->stream.avail_in; 313 ret = drive_compressor(a, state, 0); 314 if (ret != ARCHIVE_OK) 315 goto cleanup; 316 } 317 } 318 319 /* Finish compression cycle */ 320 if (((ret = drive_compressor(a, state, 1))) != ARCHIVE_OK) 321 goto cleanup; 322 323 /* Optionally, pad the final compressed block. */ 324 block_length = state->stream.next_out - state->compressed; 325 326 /* Tricky calculation to determine size of last block. */ 327 if (a->bytes_in_last_block <= 0) 328 /* Default or Zero: pad to full block */ 329 target_block_length = a->bytes_per_block; 330 else 331 /* Round length to next multiple of bytes_in_last_block. */ 332 target_block_length = a->bytes_in_last_block * 333 ( (block_length + a->bytes_in_last_block - 1) / 334 a->bytes_in_last_block); 335 if (target_block_length > a->bytes_per_block) 336 target_block_length = a->bytes_per_block; 337 if (block_length < target_block_length) { 338 memset(state->stream.next_out, 0, 339 target_block_length - block_length); 340 block_length = target_block_length; 341 } 342 343 /* Write the last block */ 344 bytes_written = (a->client_writer)(&a->archive, a->client_data, 345 state->compressed, block_length); 346 if (bytes_written <= 0) { 347 ret = ARCHIVE_FATAL; 348 goto cleanup; 349 } 350 a->archive.raw_position += bytes_written; 351 352 /* Cleanup: shut down compressor, release memory, etc. */ 353 cleanup: 354 lzma_end(&(state->stream)); 355 free(state->compressed); 356 free(state); 357 } 358 free(a->compressor.config); 359 a->compressor.config = NULL; 360 return (ret); 361} 362 363/* 364 * Utility function to push input data through compressor, 365 * writing full output blocks as necessary. 366 * 367 * Note that this handles both the regular write case (finishing == 368 * false) and the end-of-archive case (finishing == true). 369 */ 370static int 371drive_compressor(struct archive_write *a, struct private_data *state, int finishing) 372{ 373 ssize_t bytes_written; 374 int ret; 375 376 for (;;) { 377 if (state->stream.avail_out == 0) { 378 bytes_written = (a->client_writer)(&a->archive, 379 a->client_data, state->compressed, 380 state->compressed_buffer_size); 381 if (bytes_written <= 0) { 382 /* TODO: Handle this write failure */ 383 return (ARCHIVE_FATAL); 384 } else if ((size_t)bytes_written < state->compressed_buffer_size) { 385 /* Short write: Move remaining to 386 * front of block and keep filling */ 387 memmove(state->compressed, 388 state->compressed + bytes_written, 389 state->compressed_buffer_size - bytes_written); 390 } 391 a->archive.raw_position += bytes_written; 392 state->stream.next_out 393 = state->compressed + 394 state->compressed_buffer_size - bytes_written; 395 state->stream.avail_out = bytes_written; 396 } 397 398 /* If there's nothing to do, we're done. */ 399 if (!finishing && state->stream.avail_in == 0) 400 return (ARCHIVE_OK); 401 402 ret = lzma_code(&(state->stream), 403 finishing ? LZMA_FINISH : LZMA_RUN ); 404 405 switch (ret) { 406 case LZMA_OK: 407 /* In non-finishing case, check if compressor 408 * consumed everything */ 409 if (!finishing && state->stream.avail_in == 0) 410 return (ARCHIVE_OK); 411 /* In finishing case, this return always means 412 * there's more work */ 413 break; 414 case LZMA_STREAM_END: 415 /* This return can only occur in finishing case. */ 416 if (finishing) 417 return (ARCHIVE_OK); 418 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 419 "lzma compression data error"); 420 return (ARCHIVE_FATAL); 421 case LZMA_MEMLIMIT_ERROR: 422 archive_set_error(&a->archive, ENOMEM, 423 "lzma compression error: " 424 "%ju MiB would have been needed", 425 (uintmax_t)((lzma_memusage(&(state->stream)) + 1024 * 1024 -1) 426 / (1024 * 1024))); 427 return (ARCHIVE_FATAL); 428 default: 429 /* Any other return value indicates an error. */ 430 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 431 "lzma compression failed:" 432 " lzma_code() call returned status %d", 433 ret); 434 return (ARCHIVE_FATAL); 435 } 436 } 437} 438 439#endif /* HAVE_LZMA_H */ 440