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 */ 443