contrib/libarchive/libarchive/archive_write_set_compression_xz.c

   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
  50 int
  51 archive_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
  58 int
  59 archive_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
  68 struct 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
  77 struct private_config {
  78         int              compression_level;
  79 };
  80
  81 static int      archive_compressor_xz_init(struct archive_write *);
  82 static int      archive_compressor_xz_options(struct archive_write *,
  83                     const char *, const char *);
  84 static int      archive_compressor_xz_finish(struct archive_write *);
  85 static int      archive_compressor_xz_write(struct archive_write *,
  86                     const void *, size_t);
  87 static int      drive_compressor(struct archive_write *, struct private_data *,
  88                     int finishing);
  89
  90
  91 /*
  92  * Allocate, initialize and return a archive object.
  93  */
  94 int
  95 archive_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.) */
 119 int
 120 archive_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
 131 static int
 132 archive_compressor_xz_init_stream(struct archive_write *a,
 133     struct private_data *state)
 134 {
 135         static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT;
 136         int ret;
 137
 138         state->stream = lzma_stream_init_data;
 139         state->stream.next_out = state->compressed;
 140         state->stream.avail_out = state->compressed_buffer_size;
 141         if (a->archive.compression_code == ARCHIVE_COMPRESSION_XZ)
 142                 ret = lzma_stream_encoder(&(state->stream),
 143                     state->lzmafilters, LZMA_CHECK_CRC64);
 144         else
 145                 ret = lzma_alone_encoder(&(state->stream), &state->lzma_opt);
 146         if (ret == LZMA_OK)
 147                 return (ARCHIVE_OK);
 148
 149         switch (ret) {
 150         case LZMA_MEM_ERROR:
 151                 archive_set_error(&a->archive, ENOMEM,
 152                     "Internal error initializing compression library: "
 153                     "Cannot allocate memory");
 154                 break;
 155         default:
 156                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 157                     "Internal error initializing compression library: "
 158                     "It's a bug in liblzma");
 159                 break;
 160         }
 161         return (ARCHIVE_FATAL);
 162 }
 163
 164 /*
 165  * Setup callback.
 166  */
 167 static int
 168 archive_compressor_xz_init(struct archive_write *a)
 169 {
 170         int ret;
 171         struct private_data *state;
 172         struct private_config *config;
 173
 174         if (a->client_opener != NULL) {
 175                 ret = (a->client_opener)(&a->archive, a->client_data);
 176                 if (ret != ARCHIVE_OK)
 177                         return (ret);
 178         }
 179
 180         state = (struct private_data *)malloc(sizeof(*state));
 181         if (state == NULL) {
 182                 archive_set_error(&a->archive, ENOMEM,
 183                     "Can't allocate data for compression");
 184                 return (ARCHIVE_FATAL);
 185         }
 186         memset(state, 0, sizeof(*state));
 187         config = a->compressor.config;
 188
 189         /*
 190          * See comment above.  We should set compressed_buffer_size to
 191          * max(bytes_per_block, 65536), but the code can't handle that yet.
 192          */
 193         state->compressed_buffer_size = a->bytes_per_block;
 194         state->compressed = (unsigned char *)malloc(state->compressed_buffer_size);
 195         if (state->compressed == NULL) {
 196                 archive_set_error(&a->archive, ENOMEM,
 197                     "Can't allocate data for compression buffer");
 198                 free(state);
 199                 return (ARCHIVE_FATAL);
 200         }
 201         a->compressor.write = archive_compressor_xz_write;
 202
 203         /* Initialize compression library. */
 204         if (lzma_lzma_preset(&state->lzma_opt, config->compression_level)) {
 205                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 206                     "Internal error initializing compression library");
 207                 free(state->compressed);
 208                 free(state);
 209         }
 210         state->lzmafilters[0].id = LZMA_FILTER_LZMA2;
 211         state->lzmafilters[0].options = &state->lzma_opt;
 212         state->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */
 213         ret = archive_compressor_xz_init_stream(a, state);
 214         if (ret == LZMA_OK) {
 215                 a->compressor.data = state;
 216                 return (0);
 217         }
 218         /* Library setup failed: clean up. */
 219         free(state->compressed);
 220         free(state);
 221
 222         return (ARCHIVE_FATAL);
 223 }
 224
 225 /*
 226  * Set write options.
 227  */
 228 static int
 229 archive_compressor_xz_options(struct archive_write *a, const char *key,
 230     const char *value)
 231 {
 232         struct private_config *config;
 233
 234         config = (struct private_config *)a->compressor.config;
 235         if (strcmp(key, "compression-level") == 0) {
 236                 if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
 237                     value[1] != '\0')
 238                         return (ARCHIVE_WARN);
 239                 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  */
 251 static int
 252 archive_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  */
 283 static int
 284 archive_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  */
 370 static int
 371 drive_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 */