1228753Smm/*- 2228753Smm * Copyright (c) 2009 Michihiro NAKAJIMA 3228753Smm * Copyright (c) 2003-2007 Tim Kientzle 4228753Smm * All rights reserved. 5228753Smm * 6228753Smm * Redistribution and use in source and binary forms, with or without 7228753Smm * modification, are permitted provided that the following conditions 8228753Smm * are met: 9228753Smm * 1. Redistributions of source code must retain the above copyright 10228753Smm * notice, this list of conditions and the following disclaimer. 11228753Smm * 2. Redistributions in binary form must reproduce the above copyright 12228753Smm * notice, this list of conditions and the following disclaimer in the 13228753Smm * documentation and/or other materials provided with the distribution. 14228753Smm * 15228753Smm * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16228753Smm * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17228753Smm * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18228753Smm * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19228753Smm * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20228753Smm * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21228753Smm * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22228753Smm * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23228753Smm * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24228753Smm * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25228753Smm */ 26228753Smm 27228753Smm#include "archive_platform.h" 28228753Smm 29229592Smm__FBSDID("$FreeBSD$"); 30228753Smm 31228753Smm#ifdef HAVE_ERRNO_H 32228753Smm#include <errno.h> 33228753Smm#endif 34228753Smm#ifdef HAVE_STDLIB_H 35228753Smm#include <stdlib.h> 36228753Smm#endif 37228753Smm#ifdef HAVE_STRING_H 38228753Smm#include <string.h> 39228753Smm#endif 40228753Smm#include <time.h> 41228753Smm#ifdef HAVE_LZMA_H 42228753Smm#include <lzma.h> 43228753Smm#endif 44228753Smm 45228753Smm#include "archive.h" 46228753Smm#include "archive_private.h" 47228753Smm#include "archive_write_private.h" 48228753Smm 49228753Smm#ifndef HAVE_LZMA_H 50228753Smmint 51228753Smmarchive_write_set_compression_xz(struct archive *a) 52228753Smm{ 53228753Smm archive_set_error(a, ARCHIVE_ERRNO_MISC, 54228753Smm "xz compression not supported on this platform"); 55228753Smm return (ARCHIVE_FATAL); 56228753Smm} 57228753Smm 58228753Smmint 59228753Smmarchive_write_set_compression_lzma(struct archive *a) 60228753Smm{ 61228753Smm archive_set_error(a, ARCHIVE_ERRNO_MISC, 62228753Smm "lzma compression not supported on this platform"); 63228753Smm return (ARCHIVE_FATAL); 64228753Smm} 65228753Smm#else 66228753Smm/* Don't compile this if we don't have liblzma. */ 67228753Smm 68228753Smmstruct private_data { 69228753Smm lzma_stream stream; 70228753Smm lzma_filter lzmafilters[2]; 71228753Smm lzma_options_lzma lzma_opt; 72228753Smm int64_t total_in; 73228753Smm unsigned char *compressed; 74228753Smm size_t compressed_buffer_size; 75228753Smm}; 76228753Smm 77228753Smmstruct private_config { 78228753Smm int compression_level; 79228753Smm}; 80228753Smm 81228753Smmstatic int archive_compressor_xz_init(struct archive_write *); 82228753Smmstatic int archive_compressor_xz_options(struct archive_write *, 83228753Smm const char *, const char *); 84228753Smmstatic int archive_compressor_xz_finish(struct archive_write *); 85228753Smmstatic int archive_compressor_xz_write(struct archive_write *, 86228753Smm const void *, size_t); 87228753Smmstatic int drive_compressor(struct archive_write *, struct private_data *, 88228753Smm int finishing); 89228753Smm 90228753Smm 91228753Smm/* 92228753Smm * Allocate, initialize and return a archive object. 93228753Smm */ 94228753Smmint 95228753Smmarchive_write_set_compression_xz(struct archive *_a) 96228753Smm{ 97228753Smm struct private_config *config; 98228753Smm struct archive_write *a = (struct archive_write *)_a; 99228753Smm __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 100228753Smm ARCHIVE_STATE_NEW, "archive_write_set_compression_xz"); 101228753Smm config = calloc(1, sizeof(*config)); 102228753Smm if (config == NULL) { 103228753Smm archive_set_error(&a->archive, ENOMEM, "Out of memory"); 104228753Smm return (ARCHIVE_FATAL); 105228753Smm } 106228753Smm a->compressor.config = config; 107228753Smm a->compressor.finish = archive_compressor_xz_finish; 108228753Smm config->compression_level = LZMA_PRESET_DEFAULT; 109228753Smm a->compressor.init = &archive_compressor_xz_init; 110228753Smm a->compressor.options = &archive_compressor_xz_options; 111228753Smm a->archive.compression_code = ARCHIVE_COMPRESSION_XZ; 112228753Smm a->archive.compression_name = "xz"; 113228753Smm return (ARCHIVE_OK); 114228753Smm} 115228753Smm 116228753Smm/* LZMA is handled identically, we just need a different compression 117228753Smm * code set. (The liblzma setup looks at the code to determine 118228753Smm * the one place that XZ and LZMA require different handling.) */ 119228753Smmint 120228753Smmarchive_write_set_compression_lzma(struct archive *_a) 121228753Smm{ 122228753Smm struct archive_write *a = (struct archive_write *)_a; 123228753Smm int r = archive_write_set_compression_xz(_a); 124228753Smm if (r != ARCHIVE_OK) 125228753Smm return (r); 126228753Smm a->archive.compression_code = ARCHIVE_COMPRESSION_LZMA; 127228753Smm a->archive.compression_name = "lzma"; 128228753Smm return (ARCHIVE_OK); 129228753Smm} 130228753Smm 131228753Smmstatic int 132228753Smmarchive_compressor_xz_init_stream(struct archive_write *a, 133228753Smm struct private_data *state) 134228753Smm{ 135228753Smm static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT; 136228753Smm int ret; 137228753Smm 138228753Smm state->stream = lzma_stream_init_data; 139228753Smm state->stream.next_out = state->compressed; 140228753Smm state->stream.avail_out = state->compressed_buffer_size; 141228753Smm if (a->archive.compression_code == ARCHIVE_COMPRESSION_XZ) 142228753Smm ret = lzma_stream_encoder(&(state->stream), 143228753Smm state->lzmafilters, LZMA_CHECK_CRC64); 144228753Smm else 145228753Smm ret = lzma_alone_encoder(&(state->stream), &state->lzma_opt); 146228753Smm if (ret == LZMA_OK) 147228753Smm return (ARCHIVE_OK); 148228753Smm 149228753Smm switch (ret) { 150228753Smm case LZMA_MEM_ERROR: 151228753Smm archive_set_error(&a->archive, ENOMEM, 152228753Smm "Internal error initializing compression library: " 153228753Smm "Cannot allocate memory"); 154228753Smm break; 155228753Smm default: 156228753Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 157228753Smm "Internal error initializing compression library: " 158228753Smm "It's a bug in liblzma"); 159228753Smm break; 160228753Smm } 161228753Smm return (ARCHIVE_FATAL); 162228753Smm} 163228753Smm 164228753Smm/* 165228753Smm * Setup callback. 166228753Smm */ 167228753Smmstatic int 168228753Smmarchive_compressor_xz_init(struct archive_write *a) 169228753Smm{ 170228753Smm int ret; 171228753Smm struct private_data *state; 172228753Smm struct private_config *config; 173228753Smm 174228753Smm if (a->client_opener != NULL) { 175228753Smm ret = (a->client_opener)(&a->archive, a->client_data); 176228753Smm if (ret != ARCHIVE_OK) 177228753Smm return (ret); 178228753Smm } 179228753Smm 180228753Smm state = (struct private_data *)malloc(sizeof(*state)); 181228753Smm if (state == NULL) { 182228753Smm archive_set_error(&a->archive, ENOMEM, 183228753Smm "Can't allocate data for compression"); 184228753Smm return (ARCHIVE_FATAL); 185228753Smm } 186228753Smm memset(state, 0, sizeof(*state)); 187228753Smm config = a->compressor.config; 188228753Smm 189228753Smm /* 190228753Smm * See comment above. We should set compressed_buffer_size to 191228753Smm * max(bytes_per_block, 65536), but the code can't handle that yet. 192228753Smm */ 193228753Smm state->compressed_buffer_size = a->bytes_per_block; 194228753Smm state->compressed = (unsigned char *)malloc(state->compressed_buffer_size); 195228753Smm if (state->compressed == NULL) { 196228753Smm archive_set_error(&a->archive, ENOMEM, 197228753Smm "Can't allocate data for compression buffer"); 198228753Smm free(state); 199228753Smm return (ARCHIVE_FATAL); 200228753Smm } 201228753Smm a->compressor.write = archive_compressor_xz_write; 202228753Smm 203228753Smm /* Initialize compression library. */ 204228753Smm if (lzma_lzma_preset(&state->lzma_opt, config->compression_level)) { 205228753Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 206228753Smm "Internal error initializing compression library"); 207228753Smm free(state->compressed); 208228753Smm free(state); 209228753Smm } 210228753Smm state->lzmafilters[0].id = LZMA_FILTER_LZMA2; 211228753Smm state->lzmafilters[0].options = &state->lzma_opt; 212228753Smm state->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */ 213228753Smm ret = archive_compressor_xz_init_stream(a, state); 214228753Smm if (ret == LZMA_OK) { 215228753Smm a->compressor.data = state; 216228753Smm return (0); 217228753Smm } 218228753Smm /* Library setup failed: clean up. */ 219228753Smm free(state->compressed); 220228753Smm free(state); 221228753Smm 222228753Smm return (ARCHIVE_FATAL); 223228753Smm} 224228753Smm 225228753Smm/* 226228753Smm * Set write options. 227228753Smm */ 228228753Smmstatic int 229228753Smmarchive_compressor_xz_options(struct archive_write *a, const char *key, 230228753Smm const char *value) 231228753Smm{ 232228753Smm struct private_config *config; 233228753Smm 234228753Smm config = (struct private_config *)a->compressor.config; 235228753Smm if (strcmp(key, "compression-level") == 0) { 236228753Smm if (value == NULL || !(value[0] >= '0' && value[0] <= '9') || 237228753Smm value[1] != '\0') 238228753Smm return (ARCHIVE_WARN); 239228753Smm config->compression_level = value[0] - '0'; 240228753Smm if (config->compression_level > 6) 241228753Smm config->compression_level = 6; 242228753Smm return (ARCHIVE_OK); 243228753Smm } 244228753Smm 245228753Smm return (ARCHIVE_WARN); 246228753Smm} 247228753Smm 248228753Smm/* 249228753Smm * Write data to the compressed stream. 250228753Smm */ 251228753Smmstatic int 252228753Smmarchive_compressor_xz_write(struct archive_write *a, const void *buff, 253228753Smm size_t length) 254228753Smm{ 255228753Smm struct private_data *state; 256228753Smm int ret; 257228753Smm 258228753Smm state = (struct private_data *)a->compressor.data; 259228753Smm if (a->client_writer == NULL) { 260228753Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, 261228753Smm "No write callback is registered? " 262228753Smm "This is probably an internal programming error."); 263228753Smm return (ARCHIVE_FATAL); 264228753Smm } 265228753Smm 266228753Smm /* Update statistics */ 267228753Smm state->total_in += length; 268228753Smm 269228753Smm /* Compress input data to output buffer */ 270228753Smm state->stream.next_in = buff; 271228753Smm state->stream.avail_in = length; 272228753Smm if ((ret = drive_compressor(a, state, 0)) != ARCHIVE_OK) 273228753Smm return (ret); 274228753Smm 275228753Smm a->archive.file_position += length; 276228753Smm return (ARCHIVE_OK); 277228753Smm} 278228753Smm 279228753Smm 280228753Smm/* 281228753Smm * Finish the compression... 282228753Smm */ 283228753Smmstatic int 284228753Smmarchive_compressor_xz_finish(struct archive_write *a) 285228753Smm{ 286228753Smm ssize_t block_length, target_block_length, bytes_written; 287228753Smm int ret; 288228753Smm struct private_data *state; 289228753Smm unsigned tocopy; 290228753Smm 291228753Smm ret = ARCHIVE_OK; 292228753Smm state = (struct private_data *)a->compressor.data; 293228753Smm if (state != NULL) { 294228753Smm if (a->client_writer == NULL) { 295228753Smm archive_set_error(&a->archive, 296228753Smm ARCHIVE_ERRNO_PROGRAMMER, 297228753Smm "No write callback is registered? " 298228753Smm "This is probably an internal programming error."); 299228753Smm ret = ARCHIVE_FATAL; 300228753Smm goto cleanup; 301228753Smm } 302228753Smm 303228753Smm /* By default, always pad the uncompressed data. */ 304228753Smm if (a->pad_uncompressed) { 305228753Smm tocopy = a->bytes_per_block - 306228753Smm (state->total_in % a->bytes_per_block); 307228753Smm while (tocopy > 0 && tocopy < (unsigned)a->bytes_per_block) { 308228753Smm state->stream.next_in = a->nulls; 309228753Smm state->stream.avail_in = tocopy < a->null_length ? 310228753Smm tocopy : a->null_length; 311228753Smm state->total_in += state->stream.avail_in; 312228753Smm tocopy -= state->stream.avail_in; 313228753Smm ret = drive_compressor(a, state, 0); 314228753Smm if (ret != ARCHIVE_OK) 315228753Smm goto cleanup; 316228753Smm } 317228753Smm } 318228753Smm 319228753Smm /* Finish compression cycle */ 320228753Smm if (((ret = drive_compressor(a, state, 1))) != ARCHIVE_OK) 321228753Smm goto cleanup; 322228753Smm 323228753Smm /* Optionally, pad the final compressed block. */ 324228753Smm block_length = state->stream.next_out - state->compressed; 325228753Smm 326228753Smm /* Tricky calculation to determine size of last block. */ 327228753Smm if (a->bytes_in_last_block <= 0) 328228753Smm /* Default or Zero: pad to full block */ 329228753Smm target_block_length = a->bytes_per_block; 330228753Smm else 331228753Smm /* Round length to next multiple of bytes_in_last_block. */ 332228753Smm target_block_length = a->bytes_in_last_block * 333228753Smm ( (block_length + a->bytes_in_last_block - 1) / 334228753Smm a->bytes_in_last_block); 335228753Smm if (target_block_length > a->bytes_per_block) 336228753Smm target_block_length = a->bytes_per_block; 337228753Smm if (block_length < target_block_length) { 338228753Smm memset(state->stream.next_out, 0, 339228753Smm target_block_length - block_length); 340228753Smm block_length = target_block_length; 341228753Smm } 342228753Smm 343228753Smm /* Write the last block */ 344228753Smm bytes_written = (a->client_writer)(&a->archive, a->client_data, 345228753Smm state->compressed, block_length); 346228753Smm if (bytes_written <= 0) { 347228753Smm ret = ARCHIVE_FATAL; 348228753Smm goto cleanup; 349228753Smm } 350228753Smm a->archive.raw_position += bytes_written; 351228753Smm 352228753Smm /* Cleanup: shut down compressor, release memory, etc. */ 353228753Smm cleanup: 354228753Smm lzma_end(&(state->stream)); 355228753Smm free(state->compressed); 356228753Smm free(state); 357228753Smm } 358228753Smm free(a->compressor.config); 359228753Smm a->compressor.config = NULL; 360228753Smm return (ret); 361228753Smm} 362228753Smm 363228753Smm/* 364228753Smm * Utility function to push input data through compressor, 365228753Smm * writing full output blocks as necessary. 366228753Smm * 367228753Smm * Note that this handles both the regular write case (finishing == 368228753Smm * false) and the end-of-archive case (finishing == true). 369228753Smm */ 370228753Smmstatic int 371228753Smmdrive_compressor(struct archive_write *a, struct private_data *state, int finishing) 372228753Smm{ 373228753Smm ssize_t bytes_written; 374228753Smm int ret; 375228753Smm 376228753Smm for (;;) { 377228753Smm if (state->stream.avail_out == 0) { 378228753Smm bytes_written = (a->client_writer)(&a->archive, 379228753Smm a->client_data, state->compressed, 380228753Smm state->compressed_buffer_size); 381228753Smm if (bytes_written <= 0) { 382228753Smm /* TODO: Handle this write failure */ 383228753Smm return (ARCHIVE_FATAL); 384228753Smm } else if ((size_t)bytes_written < state->compressed_buffer_size) { 385228753Smm /* Short write: Move remaining to 386228753Smm * front of block and keep filling */ 387228753Smm memmove(state->compressed, 388228753Smm state->compressed + bytes_written, 389228753Smm state->compressed_buffer_size - bytes_written); 390228753Smm } 391228753Smm a->archive.raw_position += bytes_written; 392228753Smm state->stream.next_out 393228753Smm = state->compressed + 394228753Smm state->compressed_buffer_size - bytes_written; 395228753Smm state->stream.avail_out = bytes_written; 396228753Smm } 397228753Smm 398228753Smm /* If there's nothing to do, we're done. */ 399228753Smm if (!finishing && state->stream.avail_in == 0) 400228753Smm return (ARCHIVE_OK); 401228753Smm 402228753Smm ret = lzma_code(&(state->stream), 403228753Smm finishing ? LZMA_FINISH : LZMA_RUN ); 404228753Smm 405228753Smm switch (ret) { 406228753Smm case LZMA_OK: 407228753Smm /* In non-finishing case, check if compressor 408228753Smm * consumed everything */ 409228753Smm if (!finishing && state->stream.avail_in == 0) 410228753Smm return (ARCHIVE_OK); 411228753Smm /* In finishing case, this return always means 412228753Smm * there's more work */ 413228753Smm break; 414228753Smm case LZMA_STREAM_END: 415228753Smm /* This return can only occur in finishing case. */ 416228753Smm if (finishing) 417228753Smm return (ARCHIVE_OK); 418228753Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 419228753Smm "lzma compression data error"); 420228753Smm return (ARCHIVE_FATAL); 421228753Smm case LZMA_MEMLIMIT_ERROR: 422228753Smm archive_set_error(&a->archive, ENOMEM, 423228753Smm "lzma compression error: " 424228753Smm "%ju MiB would have been needed", 425228753Smm (uintmax_t)((lzma_memusage(&(state->stream)) + 1024 * 1024 -1) 426228753Smm / (1024 * 1024))); 427228753Smm return (ARCHIVE_FATAL); 428228753Smm default: 429228753Smm /* Any other return value indicates an error. */ 430228753Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 431228753Smm "lzma compression failed:" 432228753Smm " lzma_code() call returned status %d", 433228753Smm ret); 434228753Smm return (ARCHIVE_FATAL); 435228753Smm } 436228753Smm } 437228753Smm} 438228753Smm 439228753Smm#endif /* HAVE_LZMA_H */ 440