1228753Smm/*- 2228753Smm * Copyright (c) 2003-2007 Tim Kientzle 3228753Smm * All rights reserved. 4228753Smm * 5228753Smm * Redistribution and use in source and binary forms, with or without 6228753Smm * modification, are permitted provided that the following conditions 7228753Smm * are met: 8228753Smm * 1. Redistributions of source code must retain the above copyright 9228753Smm * notice, this list of conditions and the following disclaimer. 10228753Smm * 2. Redistributions in binary form must reproduce the above copyright 11228753Smm * notice, this list of conditions and the following disclaimer in the 12228753Smm * documentation and/or other materials provided with the distribution. 13228753Smm * 14228753Smm * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15228753Smm * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16228753Smm * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17228753Smm * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18228753Smm * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19228753Smm * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20228753Smm * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21228753Smm * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22228753Smm * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23228753Smm * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24228753Smm */ 25228753Smm 26228753Smm#include "archive_platform.h" 27228753Smm 28228753Smm__FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_compression_gzip.c 201081 2009-12-28 02:04:42Z kientzle $"); 29228753Smm 30228753Smm#ifdef HAVE_ERRNO_H 31228753Smm#include <errno.h> 32228753Smm#endif 33228753Smm#ifdef HAVE_STDLIB_H 34228753Smm#include <stdlib.h> 35228753Smm#endif 36228753Smm#ifdef HAVE_STRING_H 37228753Smm#include <string.h> 38228753Smm#endif 39228753Smm#include <time.h> 40228753Smm#ifdef HAVE_ZLIB_H 41228753Smm#include <zlib.h> 42228753Smm#endif 43228753Smm 44228753Smm#include "archive.h" 45228753Smm#include "archive_private.h" 46248616Smm#include "archive_string.h" 47228753Smm#include "archive_write_private.h" 48228753Smm 49231200Smm#if ARCHIVE_VERSION_NUMBER < 4000000 50228753Smmint 51228753Smmarchive_write_set_compression_gzip(struct archive *a) 52228753Smm{ 53231200Smm __archive_write_filters_free(a); 54231200Smm return (archive_write_add_filter_gzip(a)); 55231200Smm} 56231200Smm#endif 57231200Smm 58228753Smm/* Don't compile this if we don't have zlib. */ 59228753Smm 60228753Smmstruct private_data { 61231200Smm int compression_level; 62248616Smm int timestamp; 63248616Smm#ifdef HAVE_ZLIB_H 64228753Smm z_stream stream; 65228753Smm int64_t total_in; 66228753Smm unsigned char *compressed; 67228753Smm size_t compressed_buffer_size; 68228753Smm unsigned long crc; 69248616Smm#else 70248616Smm struct archive_write_program_data *pdata; 71248616Smm#endif 72228753Smm}; 73228753Smm 74228753Smm/* 75228753Smm * Yuck. zlib.h is not const-correct, so I need this one bit 76228753Smm * of ugly hackery to convert a const * pointer to a non-const pointer. 77228753Smm */ 78228753Smm#define SET_NEXT_IN(st,src) \ 79228753Smm (st)->stream.next_in = (Bytef *)(uintptr_t)(const void *)(src) 80228753Smm 81231200Smmstatic int archive_compressor_gzip_options(struct archive_write_filter *, 82228753Smm const char *, const char *); 83231200Smmstatic int archive_compressor_gzip_open(struct archive_write_filter *); 84231200Smmstatic int archive_compressor_gzip_write(struct archive_write_filter *, 85228753Smm const void *, size_t); 86231200Smmstatic int archive_compressor_gzip_close(struct archive_write_filter *); 87231200Smmstatic int archive_compressor_gzip_free(struct archive_write_filter *); 88248616Smm#ifdef HAVE_ZLIB_H 89231200Smmstatic int drive_compressor(struct archive_write_filter *, 90231200Smm struct private_data *, int finishing); 91248616Smm#endif 92228753Smm 93228753Smm 94228753Smm/* 95231200Smm * Add a gzip compression filter to this write handle. 96228753Smm */ 97228753Smmint 98231200Smmarchive_write_add_filter_gzip(struct archive *_a) 99228753Smm{ 100228753Smm struct archive_write *a = (struct archive_write *)_a; 101231200Smm struct archive_write_filter *f = __archive_write_allocate_filter(_a); 102231200Smm struct private_data *data; 103231200Smm archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 104231200Smm ARCHIVE_STATE_NEW, "archive_write_add_filter_gzip"); 105231200Smm 106231200Smm data = calloc(1, sizeof(*data)); 107231200Smm if (data == NULL) { 108228753Smm archive_set_error(&a->archive, ENOMEM, "Out of memory"); 109228753Smm return (ARCHIVE_FATAL); 110228753Smm } 111231200Smm f->data = data; 112231200Smm f->open = &archive_compressor_gzip_open; 113231200Smm f->options = &archive_compressor_gzip_options; 114231200Smm f->close = &archive_compressor_gzip_close; 115231200Smm f->free = &archive_compressor_gzip_free; 116248616Smm f->code = ARCHIVE_FILTER_GZIP; 117231200Smm f->name = "gzip"; 118248616Smm#ifdef HAVE_ZLIB_H 119248616Smm data->compression_level = Z_DEFAULT_COMPRESSION; 120228753Smm return (ARCHIVE_OK); 121248616Smm#else 122248616Smm data->pdata = __archive_write_program_allocate(); 123248616Smm if (data->pdata == NULL) { 124248616Smm free(data); 125248616Smm archive_set_error(&a->archive, ENOMEM, "Out of memory"); 126248616Smm return (ARCHIVE_FATAL); 127248616Smm } 128248616Smm data->compression_level = 0; 129248616Smm archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 130248616Smm "Using external gzip program"); 131248616Smm return (ARCHIVE_WARN); 132248616Smm#endif 133228753Smm} 134228753Smm 135248616Smmstatic int 136248616Smmarchive_compressor_gzip_free(struct archive_write_filter *f) 137248616Smm{ 138248616Smm struct private_data *data = (struct private_data *)f->data; 139248616Smm 140248616Smm#ifdef HAVE_ZLIB_H 141248616Smm free(data->compressed); 142248616Smm#else 143248616Smm __archive_write_program_free(data->pdata); 144248616Smm#endif 145248616Smm free(data); 146248616Smm f->data = NULL; 147248616Smm return (ARCHIVE_OK); 148248616Smm} 149248616Smm 150228753Smm/* 151248616Smm * Set write options. 152248616Smm */ 153248616Smmstatic int 154248616Smmarchive_compressor_gzip_options(struct archive_write_filter *f, const char *key, 155248616Smm const char *value) 156248616Smm{ 157248616Smm struct private_data *data = (struct private_data *)f->data; 158248616Smm 159248616Smm if (strcmp(key, "compression-level") == 0) { 160248616Smm if (value == NULL || !(value[0] >= '0' && value[0] <= '9') || 161248616Smm value[1] != '\0') 162248616Smm return (ARCHIVE_WARN); 163248616Smm data->compression_level = value[0] - '0'; 164248616Smm return (ARCHIVE_OK); 165248616Smm } 166248616Smm if (strcmp(key, "timestamp") == 0) { 167248616Smm data->timestamp = (value == NULL)?-1:1; 168248616Smm return (ARCHIVE_OK); 169248616Smm } 170248616Smm 171248616Smm /* Note: The "warn" return is just to inform the options 172248616Smm * supervisor that we didn't handle it. It will generate 173248616Smm * a suitable error if no one used this option. */ 174248616Smm return (ARCHIVE_WARN); 175248616Smm} 176248616Smm 177248616Smm#ifdef HAVE_ZLIB_H 178248616Smm/* 179228753Smm * Setup callback. 180228753Smm */ 181228753Smmstatic int 182231200Smmarchive_compressor_gzip_open(struct archive_write_filter *f) 183228753Smm{ 184231200Smm struct private_data *data = (struct private_data *)f->data; 185228753Smm int ret; 186228753Smm 187231200Smm ret = __archive_write_open_filter(f->next_filter); 188231200Smm if (ret != ARCHIVE_OK) 189231200Smm return (ret); 190228753Smm 191231200Smm if (data->compressed == NULL) { 192238856Smm size_t bs = 65536, bpb; 193238856Smm if (f->archive->magic == ARCHIVE_WRITE_MAGIC) { 194248616Smm /* Buffer size should be a multiple number of 195248616Smm * the of bytes per block for performance. */ 196238856Smm bpb = archive_write_get_bytes_per_block(f->archive); 197238856Smm if (bpb > bs) 198238856Smm bs = bpb; 199238856Smm else if (bpb != 0) 200238856Smm bs -= bs % bpb; 201238856Smm } 202238856Smm data->compressed_buffer_size = bs; 203231200Smm data->compressed 204231200Smm = (unsigned char *)malloc(data->compressed_buffer_size); 205231200Smm if (data->compressed == NULL) { 206231200Smm archive_set_error(f->archive, ENOMEM, 207231200Smm "Can't allocate data for compression buffer"); 208231200Smm return (ARCHIVE_FATAL); 209231200Smm } 210228753Smm } 211228753Smm 212231200Smm data->crc = crc32(0L, NULL, 0); 213231200Smm data->stream.next_out = data->compressed; 214248616Smm data->stream.avail_out = (uInt)data->compressed_buffer_size; 215228753Smm 216228753Smm /* Prime output buffer with a gzip header. */ 217231200Smm data->compressed[0] = 0x1f; /* GZip signature bytes */ 218231200Smm data->compressed[1] = 0x8b; 219231200Smm data->compressed[2] = 0x08; /* "Deflate" compression */ 220231200Smm data->compressed[3] = 0; /* No options */ 221248616Smm if (data->timestamp >= 0) { 222248616Smm time_t t = time(NULL); 223248616Smm data->compressed[4] = (uint8_t)(t)&0xff; /* Timestamp */ 224248616Smm data->compressed[5] = (uint8_t)(t>>8)&0xff; 225248616Smm data->compressed[6] = (uint8_t)(t>>16)&0xff; 226248616Smm data->compressed[7] = (uint8_t)(t>>24)&0xff; 227248616Smm } else 228248616Smm memset(&data->compressed[4], 0, 4); 229231200Smm data->compressed[8] = 0; /* No deflate options */ 230231200Smm data->compressed[9] = 3; /* OS=Unix */ 231231200Smm data->stream.next_out += 10; 232231200Smm data->stream.avail_out -= 10; 233228753Smm 234231200Smm f->write = archive_compressor_gzip_write; 235228753Smm 236228753Smm /* Initialize compression library. */ 237231200Smm ret = deflateInit2(&(data->stream), 238231200Smm data->compression_level, 239228753Smm Z_DEFLATED, 240228753Smm -15 /* < 0 to suppress zlib header */, 241228753Smm 8, 242228753Smm Z_DEFAULT_STRATEGY); 243228753Smm 244228753Smm if (ret == Z_OK) { 245231200Smm f->data = data; 246231200Smm return (ARCHIVE_OK); 247228753Smm } 248228753Smm 249228753Smm /* Library setup failed: clean up. */ 250231200Smm archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, "Internal error " 251228753Smm "initializing compression library"); 252228753Smm 253228753Smm /* Override the error message if we know what really went wrong. */ 254228753Smm switch (ret) { 255228753Smm case Z_STREAM_ERROR: 256231200Smm archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 257228753Smm "Internal error initializing " 258228753Smm "compression library: invalid setup parameter"); 259228753Smm break; 260228753Smm case Z_MEM_ERROR: 261248616Smm archive_set_error(f->archive, ENOMEM, 262248616Smm "Internal error initializing compression library"); 263228753Smm break; 264228753Smm case Z_VERSION_ERROR: 265231200Smm archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 266228753Smm "Internal error initializing " 267228753Smm "compression library: invalid library version"); 268228753Smm break; 269228753Smm } 270228753Smm 271228753Smm return (ARCHIVE_FATAL); 272228753Smm} 273228753Smm 274228753Smm/* 275228753Smm * Write data to the compressed stream. 276228753Smm */ 277228753Smmstatic int 278231200Smmarchive_compressor_gzip_write(struct archive_write_filter *f, const void *buff, 279228753Smm size_t length) 280228753Smm{ 281231200Smm struct private_data *data = (struct private_data *)f->data; 282228753Smm int ret; 283228753Smm 284228753Smm /* Update statistics */ 285248616Smm data->crc = crc32(data->crc, (const Bytef *)buff, (uInt)length); 286231200Smm data->total_in += length; 287228753Smm 288228753Smm /* Compress input data to output buffer */ 289231200Smm SET_NEXT_IN(data, buff); 290248616Smm data->stream.avail_in = (uInt)length; 291231200Smm if ((ret = drive_compressor(f, data, 0)) != ARCHIVE_OK) 292228753Smm return (ret); 293228753Smm 294228753Smm return (ARCHIVE_OK); 295228753Smm} 296228753Smm 297228753Smm/* 298228753Smm * Finish the compression... 299228753Smm */ 300228753Smmstatic int 301231200Smmarchive_compressor_gzip_close(struct archive_write_filter *f) 302228753Smm{ 303228753Smm unsigned char trailer[8]; 304231200Smm struct private_data *data = (struct private_data *)f->data; 305231200Smm int ret, r1; 306228753Smm 307231200Smm /* Finish compression cycle */ 308231200Smm ret = drive_compressor(f, data, 1); 309231200Smm if (ret == ARCHIVE_OK) { 310231200Smm /* Write the last compressed data. */ 311231200Smm ret = __archive_write_filter(f->next_filter, 312231200Smm data->compressed, 313231200Smm data->compressed_buffer_size - data->stream.avail_out); 314231200Smm } 315231200Smm if (ret == ARCHIVE_OK) { 316231200Smm /* Build and write out 8-byte trailer. */ 317238856Smm trailer[0] = (uint8_t)(data->crc)&0xff; 318238856Smm trailer[1] = (uint8_t)(data->crc >> 8)&0xff; 319238856Smm trailer[2] = (uint8_t)(data->crc >> 16)&0xff; 320238856Smm trailer[3] = (uint8_t)(data->crc >> 24)&0xff; 321238856Smm trailer[4] = (uint8_t)(data->total_in)&0xff; 322238856Smm trailer[5] = (uint8_t)(data->total_in >> 8)&0xff; 323238856Smm trailer[6] = (uint8_t)(data->total_in >> 16)&0xff; 324238856Smm trailer[7] = (uint8_t)(data->total_in >> 24)&0xff; 325231200Smm ret = __archive_write_filter(f->next_filter, trailer, 8); 326231200Smm } 327228753Smm 328231200Smm switch (deflateEnd(&(data->stream))) { 329231200Smm case Z_OK: 330231200Smm break; 331231200Smm default: 332231200Smm archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 333231200Smm "Failed to clean up compressor"); 334231200Smm ret = ARCHIVE_FATAL; 335228753Smm } 336231200Smm r1 = __archive_write_close_filter(f->next_filter); 337231200Smm return (r1 < ret ? r1 : ret); 338228753Smm} 339228753Smm 340228753Smm/* 341228753Smm * Utility function to push input data through compressor, 342228753Smm * writing full output blocks as necessary. 343228753Smm * 344228753Smm * Note that this handles both the regular write case (finishing == 345228753Smm * false) and the end-of-archive case (finishing == true). 346228753Smm */ 347228753Smmstatic int 348231200Smmdrive_compressor(struct archive_write_filter *f, 349231200Smm struct private_data *data, int finishing) 350228753Smm{ 351228753Smm int ret; 352228753Smm 353228753Smm for (;;) { 354231200Smm if (data->stream.avail_out == 0) { 355231200Smm ret = __archive_write_filter(f->next_filter, 356231200Smm data->compressed, 357231200Smm data->compressed_buffer_size); 358231200Smm if (ret != ARCHIVE_OK) 359228753Smm return (ARCHIVE_FATAL); 360231200Smm data->stream.next_out = data->compressed; 361248616Smm data->stream.avail_out = 362248616Smm (uInt)data->compressed_buffer_size; 363228753Smm } 364228753Smm 365228753Smm /* If there's nothing to do, we're done. */ 366231200Smm if (!finishing && data->stream.avail_in == 0) 367228753Smm return (ARCHIVE_OK); 368228753Smm 369231200Smm ret = deflate(&(data->stream), 370228753Smm finishing ? Z_FINISH : Z_NO_FLUSH ); 371228753Smm 372228753Smm switch (ret) { 373228753Smm case Z_OK: 374228753Smm /* In non-finishing case, check if compressor 375228753Smm * consumed everything */ 376231200Smm if (!finishing && data->stream.avail_in == 0) 377228753Smm return (ARCHIVE_OK); 378228753Smm /* In finishing case, this return always means 379228753Smm * there's more work */ 380228753Smm break; 381228753Smm case Z_STREAM_END: 382228753Smm /* This return can only occur in finishing case. */ 383228753Smm return (ARCHIVE_OK); 384228753Smm default: 385228753Smm /* Any other return value indicates an error. */ 386231200Smm archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, 387228753Smm "GZip compression failed:" 388228753Smm " deflate() call returned status %d", 389228753Smm ret); 390228753Smm return (ARCHIVE_FATAL); 391228753Smm } 392228753Smm } 393228753Smm} 394228753Smm 395248616Smm#else /* HAVE_ZLIB_H */ 396248616Smm 397248616Smmstatic int 398248616Smmarchive_compressor_gzip_open(struct archive_write_filter *f) 399248616Smm{ 400248616Smm struct private_data *data = (struct private_data *)f->data; 401248616Smm struct archive_string as; 402248616Smm int r; 403248616Smm 404248616Smm archive_string_init(&as); 405248616Smm archive_strcpy(&as, "gzip"); 406248616Smm 407248616Smm /* Specify compression level. */ 408248616Smm if (data->compression_level > 0) { 409248616Smm archive_strcat(&as, " -"); 410248616Smm archive_strappend_char(&as, '0' + data->compression_level); 411248616Smm } 412248616Smm if (data->timestamp < 0) 413248616Smm /* Do not save timestamp. */ 414248616Smm archive_strcat(&as, " -n"); 415248616Smm else if (data->timestamp > 0) 416248616Smm /* Save timestamp. */ 417248616Smm archive_strcat(&as, " -N"); 418248616Smm 419248616Smm f->write = archive_compressor_gzip_write; 420248616Smm r = __archive_write_program_open(f, data->pdata, as.s); 421248616Smm archive_string_free(&as); 422248616Smm return (r); 423248616Smm} 424248616Smm 425248616Smmstatic int 426248616Smmarchive_compressor_gzip_write(struct archive_write_filter *f, const void *buff, 427248616Smm size_t length) 428248616Smm{ 429248616Smm struct private_data *data = (struct private_data *)f->data; 430248616Smm 431248616Smm return __archive_write_program_write(f, data->pdata, buff, length); 432248616Smm} 433248616Smm 434248616Smmstatic int 435248616Smmarchive_compressor_gzip_close(struct archive_write_filter *f) 436248616Smm{ 437248616Smm struct private_data *data = (struct private_data *)f->data; 438248616Smm 439248616Smm return __archive_write_program_close(f, data->pdata); 440248616Smm} 441248616Smm 442228753Smm#endif /* HAVE_ZLIB_H */ 443