contrib/libarchive/libarchive/archive_write_add_filter_gzip.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "archive_platform.h"
  27
  28 __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_compression_gzip.c 201081 2009-12-28 02:04:42Z kientzle $");
  29
  30 #ifdef HAVE_ERRNO_H
  31 #include <errno.h>
  32 #endif
  33 #ifdef HAVE_STDLIB_H
  34 #include <stdlib.h>
  35 #endif
  36 #ifdef HAVE_STRING_H
  37 #include <string.h>
  38 #endif
  39 #include <time.h>
  40 #ifdef HAVE_ZLIB_H
  41 #include <zlib.h>
  42 #endif
  43
  44 #include "archive.h"
  45 #include "archive_private.h"
  46 #include "archive_string.h"
  47 #include "archive_write_private.h"
  48
  49 #if ARCHIVE_VERSION_NUMBER < 4000000
  50 int
  51 archive_write_set_compression_gzip(struct archive *a)
  52 {
  53         __archive_write_filters_free(a);
  54         return (archive_write_add_filter_gzip(a));
  55 }
  56 #endif
  57
  58 /* Don't compile this if we don't have zlib. */
  59
  60 struct private_data {
  61         int              compression_level;
  62         int              timestamp;
  63 #ifdef HAVE_ZLIB_H
  64         z_stream         stream;
  65         int64_t          total_in;
  66         unsigned char   *compressed;
  67         size_t           compressed_buffer_size;
  68         unsigned long    crc;
  69 #else
  70         struct archive_write_program_data *pdata;
  71 #endif
  72 };
  73
  74 /*
  75  * Yuck.  zlib.h is not const-correct, so I need this one bit
  76  * of ugly hackery to convert a const * pointer to a non-const pointer.
  77  */
  78 #define SET_NEXT_IN(st,src)                                     \
  79         (st)->stream.next_in = (Bytef *)(uintptr_t)(const void *)(src)
  80
  81 static int archive_compressor_gzip_options(struct archive_write_filter *,
  82                     const char *, const char *);
  83 static int archive_compressor_gzip_open(struct archive_write_filter *);
  84 static int archive_compressor_gzip_write(struct archive_write_filter *,
  85                     const void *, size_t);
  86 static int archive_compressor_gzip_close(struct archive_write_filter *);
  87 static int archive_compressor_gzip_free(struct archive_write_filter *);
  88 #ifdef HAVE_ZLIB_H
  89 static int drive_compressor(struct archive_write_filter *,
  90                     struct private_data *, int finishing);
  91 #endif
  92
  93
  94 /*
  95  * Add a gzip compression filter to this write handle.
  96  */
  97 int
  98 archive_write_add_filter_gzip(struct archive *_a)
  99 {
 100         struct archive_write *a = (struct archive_write *)_a;
 101         struct archive_write_filter *f = __archive_write_allocate_filter(_a);
 102         struct private_data *data;
 103         archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
 104             ARCHIVE_STATE_NEW, "archive_write_add_filter_gzip");
 105
 106         data = calloc(1, sizeof(*data));
 107         if (data == NULL) {
 108                 archive_set_error(&a->archive, ENOMEM, "Out of memory");
 109                 return (ARCHIVE_FATAL);
 110         }
 111         f->data = data;
 112         f->open = &archive_compressor_gzip_open;
 113         f->options = &archive_compressor_gzip_options;
 114         f->close = &archive_compressor_gzip_close;
 115         f->free = &archive_compressor_gzip_free;
 116         f->code = ARCHIVE_FILTER_GZIP;
 117         f->name = "gzip";
 118 #ifdef HAVE_ZLIB_H
 119         data->compression_level = Z_DEFAULT_COMPRESSION;
 120         return (ARCHIVE_OK);
 121 #else
 122         data->pdata = __archive_write_program_allocate();
 123         if (data->pdata == NULL) {
 124                 free(data);
 125                 archive_set_error(&a->archive, ENOMEM, "Out of memory");
 126                 return (ARCHIVE_FATAL);
 127         }
 128         data->compression_level = 0;
 129         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 130             "Using external gzip program");
 131         return (ARCHIVE_WARN);
 132 #endif
 133 }
 134
 135 static int
 136 archive_compressor_gzip_free(struct archive_write_filter *f)
 137 {
 138         struct private_data *data = (struct private_data *)f->data;
 139
 140 #ifdef HAVE_ZLIB_H
 141         free(data->compressed);
 142 #else
 143         __archive_write_program_free(data->pdata);
 144 #endif
 145         free(data);
 146         f->data = NULL;
 147         return (ARCHIVE_OK);
 148 }
 149
 150 /*
 151  * Set write options.
 152  */
 153 static int
 154 archive_compressor_gzip_options(struct archive_write_filter *f, const char *key,
 155     const char *value)
 156 {
 157         struct private_data *data = (struct private_data *)f->data;
 158
 159         if (strcmp(key, "compression-level") == 0) {
 160                 if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
 161                     value[1] != '\0')
 162                         return (ARCHIVE_WARN);
 163                 data->compression_level = value[0] - '0';
 164                 return (ARCHIVE_OK);
 165         }
 166         if (strcmp(key, "timestamp") == 0) {
 167                 data->timestamp = (value == NULL)?-1:1;
 168                 return (ARCHIVE_OK);
 169         }
 170
 171         /* Note: The "warn" return is just to inform the options
 172          * supervisor that we didn't handle it.  It will generate
 173          * a suitable error if no one used this option. */
 174         return (ARCHIVE_WARN);
 175 }
 176
 177 #ifdef HAVE_ZLIB_H
 178 /*
 179  * Setup callback.
 180  */
 181 static int
 182 archive_compressor_gzip_open(struct archive_write_filter *f)
 183 {
 184         struct private_data *data = (struct private_data *)f->data;
 185         int ret;
 186
 187         ret = __archive_write_open_filter(f->next_filter);
 188         if (ret != ARCHIVE_OK)
 189                 return (ret);
 190
 191         if (data->compressed == NULL) {
 192                 size_t bs = 65536, bpb;
 193                 if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
 194                         /* Buffer size should be a multiple number of
 195                          * the of bytes per block for performance. */
 196                         bpb = archive_write_get_bytes_per_block(f->archive);
 197                         if (bpb > bs)
 198                                 bs = bpb;
 199                         else if (bpb != 0)
 200                                 bs -= bs % bpb;
 201                 }
 202                 data->compressed_buffer_size = bs;
 203                 data->compressed
 204                     = (unsigned char *)malloc(data->compressed_buffer_size);
 205                 if (data->compressed == NULL) {
 206                         archive_set_error(f->archive, ENOMEM,
 207                             "Can't allocate data for compression buffer");
 208                         return (ARCHIVE_FATAL);
 209                 }
 210         }
 211
 212         data->crc = crc32(0L, NULL, 0);
 213         data->stream.next_out = data->compressed;
 214         data->stream.avail_out = (uInt)data->compressed_buffer_size;
 215
 216         /* Prime output buffer with a gzip header. */
 217         data->compressed[0] = 0x1f; /* GZip signature bytes */
 218         data->compressed[1] = 0x8b;
 219         data->compressed[2] = 0x08; /* "Deflate" compression */
 220         data->compressed[3] = 0; /* No options */
 221         if (data->timestamp >= 0) {
 222                 time_t t = time(NULL);
 223                 data->compressed[4] = (uint8_t)(t)&0xff;  /* Timestamp */
 224                 data->compressed[5] = (uint8_t)(t>>8)&0xff;
 225                 data->compressed[6] = (uint8_t)(t>>16)&0xff;
 226                 data->compressed[7] = (uint8_t)(t>>24)&0xff;
 227         } else
 228                 memset(&data->compressed[4], 0, 4);
 229         data->compressed[8] = 0; /* No deflate options */
 230         data->compressed[9] = 3; /* OS=Unix */
 231         data->stream.next_out += 10;
 232         data->stream.avail_out -= 10;
 233
 234         f->write = archive_compressor_gzip_write;
 235
 236         /* Initialize compression library. */
 237         ret = deflateInit2(&(data->stream),
 238             data->compression_level,
 239             Z_DEFLATED,
 240             -15 /* < 0 to suppress zlib header */,
 241             8,
 242             Z_DEFAULT_STRATEGY);
 243
 244         if (ret == Z_OK) {
 245                 f->data = data;
 246                 return (ARCHIVE_OK);
 247         }
 248
 249         /* Library setup failed: clean up. */
 250         archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, "Internal error "
 251             "initializing compression library");
 252
 253         /* Override the error message if we know what really went wrong. */
 254         switch (ret) {
 255         case Z_STREAM_ERROR:
 256                 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
 257                     "Internal error initializing "
 258                     "compression library: invalid setup parameter");
 259                 break;
 260         case Z_MEM_ERROR:
 261                 archive_set_error(f->archive, ENOMEM,
 262                     "Internal error initializing compression library");
 263                 break;
 264         case Z_VERSION_ERROR:
 265                 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
 266                     "Internal error initializing "
 267                     "compression library: invalid library version");
 268                 break;
 269         }
 270
 271         return (ARCHIVE_FATAL);
 272 }
 273
 274 /*
 275  * Write data to the compressed stream.
 276  */
 277 static int
 278 archive_compressor_gzip_write(struct archive_write_filter *f, const void *buff,
 279     size_t length)
 280 {
 281         struct private_data *data = (struct private_data *)f->data;
 282         int ret;
 283
 284         /* Update statistics */
 285         data->crc = crc32(data->crc, (const Bytef *)buff, (uInt)length);
 286         data->total_in += length;
 287
 288         /* Compress input data to output buffer */
 289         SET_NEXT_IN(data, buff);
 290         data->stream.avail_in = (uInt)length;
 291         if ((ret = drive_compressor(f, data, 0)) != ARCHIVE_OK)
 292                 return (ret);
 293
 294         return (ARCHIVE_OK);
 295 }
 296
 297 /*
 298  * Finish the compression...
 299  */
 300 static int
 301 archive_compressor_gzip_close(struct archive_write_filter *f)
 302 {
 303         unsigned char trailer[8];
 304         struct private_data *data = (struct private_data *)f->data;
 305         int ret, r1;
 306
 307         /* Finish compression cycle */
 308         ret = drive_compressor(f, data, 1);
 309         if (ret == ARCHIVE_OK) {
 310                 /* Write the last compressed data. */
 311                 ret = __archive_write_filter(f->next_filter,
 312                     data->compressed,
 313                     data->compressed_buffer_size - data->stream.avail_out);
 314         }
 315         if (ret == ARCHIVE_OK) {
 316                 /* Build and write out 8-byte trailer. */
 317                 trailer[0] = (uint8_t)(data->crc)&0xff;
 318                 trailer[1] = (uint8_t)(data->crc >> 8)&0xff;
 319                 trailer[2] = (uint8_t)(data->crc >> 16)&0xff;
 320                 trailer[3] = (uint8_t)(data->crc >> 24)&0xff;
 321                 trailer[4] = (uint8_t)(data->total_in)&0xff;
 322                 trailer[5] = (uint8_t)(data->total_in >> 8)&0xff;
 323                 trailer[6] = (uint8_t)(data->total_in >> 16)&0xff;
 324                 trailer[7] = (uint8_t)(data->total_in >> 24)&0xff;
 325                 ret = __archive_write_filter(f->next_filter, trailer, 8);
 326         }
 327
 328         switch (deflateEnd(&(data->stream))) {
 329         case Z_OK:
 330                 break;
 331         default:
 332                 archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
 333                     "Failed to clean up compressor");
 334                 ret = ARCHIVE_FATAL;
 335         }
 336         r1 = __archive_write_close_filter(f->next_filter);
 337         return (r1 < ret ? r1 : ret);
 338 }
 339
 340 /*
 341  * Utility function to push input data through compressor,
 342  * writing full output blocks as necessary.
 343  *
 344  * Note that this handles both the regular write case (finishing ==
 345  * false) and the end-of-archive case (finishing == true).
 346  */
 347 static int
 348 drive_compressor(struct archive_write_filter *f,
 349     struct private_data *data, int finishing)
 350 {
 351         int ret;
 352
 353         for (;;) {
 354                 if (data->stream.avail_out == 0) {
 355                         ret = __archive_write_filter(f->next_filter,
 356                             data->compressed,
 357                             data->compressed_buffer_size);
 358                         if (ret != ARCHIVE_OK)
 359                                 return (ARCHIVE_FATAL);
 360                         data->stream.next_out = data->compressed;
 361                         data->stream.avail_out =
 362                             (uInt)data->compressed_buffer_size;
 363                 }
 364
 365                 /* If there's nothing to do, we're done. */
 366                 if (!finishing && data->stream.avail_in == 0)
 367                         return (ARCHIVE_OK);
 368
 369                 ret = deflate(&(data->stream),
 370                     finishing ? Z_FINISH : Z_NO_FLUSH );
 371
 372                 switch (ret) {
 373                 case Z_OK:
 374                         /* In non-finishing case, check if compressor
 375                          * consumed everything */
 376                         if (!finishing && data->stream.avail_in == 0)
 377                                 return (ARCHIVE_OK);
 378                         /* In finishing case, this return always means
 379                          * there's more work */
 380                         break;
 381                 case Z_STREAM_END:
 382                         /* This return can only occur in finishing case. */
 383                         return (ARCHIVE_OK);
 384                 default:
 385                         /* Any other return value indicates an error. */
 386                         archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
 387                             "GZip compression failed:"
 388                             " deflate() call returned status %d",
 389                             ret);
 390                         return (ARCHIVE_FATAL);
 391                 }
 392         }
 393 }
 394
 395 #else /* HAVE_ZLIB_H */
 396
 397 static int
 398 archive_compressor_gzip_open(struct archive_write_filter *f)
 399 {
 400         struct private_data *data = (struct private_data *)f->data;
 401         struct archive_string as;
 402         int r;
 403
 404         archive_string_init(&as);
 405         archive_strcpy(&as, "gzip");
 406
 407         /* Specify compression level. */
 408         if (data->compression_level > 0) {
 409                 archive_strcat(&as, " -");
 410                 archive_strappend_char(&as, '0' + data->compression_level);
 411         }
 412         if (data->timestamp < 0)
 413                 /* Do not save timestamp. */
 414                 archive_strcat(&as, " -n");
 415         else if (data->timestamp > 0)
 416                 /* Save timestamp. */
 417                 archive_strcat(&as, " -N");
 418
 419         f->write = archive_compressor_gzip_write;
 420         r = __archive_write_program_open(f, data->pdata, as.s);
 421         archive_string_free(&as);
 422         return (r);
 423 }
 424
 425 static int
 426 archive_compressor_gzip_write(struct archive_write_filter *f, const void *buff,
 427     size_t length)
 428 {
 429         struct private_data *data = (struct private_data *)f->data;
 430
 431         return __archive_write_program_write(f, data->pdata, buff, length);
 432 }
 433
 434 static int
 435 archive_compressor_gzip_close(struct archive_write_filter *f)
 436 {
 437         struct private_data *data = (struct private_data *)f->data;
 438
 439         return __archive_write_program_close(f, data->pdata);
 440 }
 441
 442 #endif /* HAVE_ZLIB_H */