contrib/libarchive/libarchive/archive_read_support_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$");
  29
  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 #ifdef HAVE_UNISTD_H
  41 #include <unistd.h>
  42 #endif
  43 #ifdef HAVE_ZLIB_H
  44 #include <zlib.h>
  45 #endif
  46
  47 #include "archive.h"
  48 #include "archive_private.h"
  49 #include "archive_read_private.h"
  50
  51 #ifdef HAVE_ZLIB_H
  52 struct private_data {
  53         z_stream         stream;
  54         char             in_stream;
  55         unsigned char   *out_block;
  56         size_t           out_block_size;
  57         int64_t          total_out;
  58         unsigned long    crc;
  59         char             eof; /* True = found end of compressed data. */
  60 };
  61
  62 /* Gzip Filter. */
  63 static ssize_t  gzip_filter_read(struct archive_read_filter *, const void **);
  64 static int      gzip_filter_close(struct archive_read_filter *);
  65 #endif
  66
  67 /*
  68  * Note that we can detect gzip archives even if we can't decompress
  69  * them.  (In fact, we like detecting them because we can give better
  70  * error messages.)  So the bid framework here gets compiled even
  71  * if zlib is unavailable.
  72  *
  73  * TODO: If zlib is unavailable, gzip_bidder_init() should
  74  * use the compress_program framework to try to fire up an external
  75  * gzip program.
  76  */
  77 static int      gzip_bidder_bid(struct archive_read_filter_bidder *,
  78                     struct archive_read_filter *);
  79 static int      gzip_bidder_init(struct archive_read_filter *);
  80
  81 #if ARCHIVE_VERSION_NUMBER < 4000000
  82 /* Deprecated; remove in libarchive 4.0 */
  83 int
  84 archive_read_support_compression_gzip(struct archive *a)
  85 {
  86         return archive_read_support_filter_gzip(a);
  87 }
  88 #endif
  89
  90 int
  91 archive_read_support_filter_gzip(struct archive *_a)
  92 {
  93         struct archive_read *a = (struct archive_read *)_a;
  94         struct archive_read_filter_bidder *bidder;
  95
  96         archive_check_magic(_a, ARCHIVE_READ_MAGIC,
  97             ARCHIVE_STATE_NEW, "archive_read_support_filter_gzip");
  98
  99         if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK)
 100                 return (ARCHIVE_FATAL);
 101
 102         bidder->data = NULL;
 103         bidder->name = "gzip";
 104         bidder->bid = gzip_bidder_bid;
 105         bidder->init = gzip_bidder_init;
 106         bidder->options = NULL;
 107         bidder->free = NULL; /* No data, so no cleanup necessary. */
 108         /* Signal the extent of gzip support with the return value here. */
 109 #if HAVE_ZLIB_H
 110         return (ARCHIVE_OK);
 111 #else
 112         archive_set_error(_a, ARCHIVE_ERRNO_MISC,
 113             "Using external gzip program");
 114         return (ARCHIVE_WARN);
 115 #endif
 116 }
 117
 118 /*
 119  * Read and verify the header.
 120  *
 121  * Returns zero if the header couldn't be validated, else returns
 122  * number of bytes in header.  If pbits is non-NULL, it receives a
 123  * count of bits verified, suitable for use by bidder.
 124  */
 125 static ssize_t
 126 peek_at_header(struct archive_read_filter *filter, int *pbits)
 127 {
 128         const unsigned char *p;
 129         ssize_t avail, len;
 130         int bits = 0;
 131         int header_flags;
 132
 133         /* Start by looking at the first ten bytes of the header, which
 134          * is all fixed layout. */
 135         len = 10;
 136         p = __archive_read_filter_ahead(filter, len, &avail);
 137         if (p == NULL || avail == 0)
 138                 return (0);
 139         /* We only support deflation- third byte must be 0x08. */
 140         if (memcmp(p, "\x1F\x8B\x08", 3) != 0)
 141                 return (0);
 142         bits += 24;
 143         if ((p[3] & 0xE0)!= 0)  /* No reserved flags set. */
 144                 return (0);
 145         bits += 3;
 146         header_flags = p[3];
 147         /* Bytes 4-7 are mod time. */
 148         /* Byte 8 is deflate flags. */
 149         /* XXXX TODO: return deflate flags back to consume_header for use
 150            in initializing the decompressor. */
 151         /* Byte 9 is OS. */
 152
 153         /* Optional extra data:  2 byte length plus variable body. */
 154         if (header_flags & 4) {
 155                 p = __archive_read_filter_ahead(filter, len + 2, &avail);
 156                 if (p == NULL)
 157                         return (0);
 158                 len += ((int)p[len + 1] << 8) | (int)p[len];
 159                 len += 2;
 160         }
 161
 162         /* Null-terminated optional filename. */
 163         if (header_flags & 8) {
 164                 do {
 165                         ++len;
 166                         if (avail < len)
 167                                 p = __archive_read_filter_ahead(filter,
 168                                     len, &avail);
 169                         if (p == NULL)
 170                                 return (0);
 171                 } while (p[len - 1] != 0);
 172         }
 173
 174         /* Null-terminated optional comment. */
 175         if (header_flags & 16) {
 176                 do {
 177                         ++len;
 178                         if (avail < len)
 179                                 p = __archive_read_filter_ahead(filter,
 180                                     len, &avail);
 181                         if (p == NULL)
 182                                 return (0);
 183                 } while (p[len - 1] != 0);
 184         }
 185
 186         /* Optional header CRC */
 187         if ((header_flags & 2)) {
 188                 p = __archive_read_filter_ahead(filter, len + 2, &avail);
 189                 if (p == NULL)
 190                         return (0);
 191 #if 0
 192         int hcrc = ((int)p[len + 1] << 8) | (int)p[len];
 193         int crc = /* XXX TODO: Compute header CRC. */;
 194         if (crc != hcrc)
 195                 return (0);
 196         bits += 16;
 197 #endif
 198                 len += 2;
 199         }
 200
 201         if (pbits != NULL)
 202                 *pbits = bits;
 203         return (len);
 204 }
 205
 206 /*
 207  * Bidder just verifies the header and returns the number of verified bits.
 208  */
 209 static int
 210 gzip_bidder_bid(struct archive_read_filter_bidder *self,
 211     struct archive_read_filter *filter)
 212 {
 213         int bits_checked;
 214
 215         (void)self; /* UNUSED */
 216
 217         if (peek_at_header(filter, &bits_checked))
 218                 return (bits_checked);
 219         return (0);
 220 }
 221
 222
 223 #ifndef HAVE_ZLIB_H
 224
 225 /*
 226  * If we don't have the library on this system, we can't do the
 227  * decompression directly.  We can, however, try to run "gzip -d"
 228  * in case that's available.
 229  */
 230 static int
 231 gzip_bidder_init(struct archive_read_filter *self)
 232 {
 233         int r;
 234
 235         r = __archive_read_program(self, "gzip -d");
 236         /* Note: We set the format here even if __archive_read_program()
 237          * above fails.  We do, after all, know what the format is
 238          * even if we weren't able to read it. */
 239         self->code = ARCHIVE_FILTER_GZIP;
 240         self->name = "gzip";
 241         return (r);
 242 }
 243
 244 #else
 245
 246 /*
 247  * Initialize the filter object.
 248  */
 249 static int
 250 gzip_bidder_init(struct archive_read_filter *self)
 251 {
 252         struct private_data *state;
 253         static const size_t out_block_size = 64 * 1024;
 254         void *out_block;
 255
 256         self->code = ARCHIVE_FILTER_GZIP;
 257         self->name = "gzip";
 258
 259         state = (struct private_data *)calloc(sizeof(*state), 1);
 260         out_block = (unsigned char *)malloc(out_block_size);
 261         if (state == NULL || out_block == NULL) {
 262                 free(out_block);
 263                 free(state);
 264                 archive_set_error(&self->archive->archive, ENOMEM,
 265                     "Can't allocate data for gzip decompression");
 266                 return (ARCHIVE_FATAL);
 267         }
 268
 269         self->data = state;
 270         state->out_block_size = out_block_size;
 271         state->out_block = out_block;
 272         self->read = gzip_filter_read;
 273         self->skip = NULL; /* not supported */
 274         self->close = gzip_filter_close;
 275
 276         state->in_stream = 0; /* We're not actually within a stream yet. */
 277
 278         return (ARCHIVE_OK);
 279 }
 280
 281 static int
 282 consume_header(struct archive_read_filter *self)
 283 {
 284         struct private_data *state;
 285         ssize_t avail;
 286         size_t len;
 287         int ret;
 288
 289         state = (struct private_data *)self->data;
 290
 291         /* If this is a real header, consume it. */
 292         len = peek_at_header(self->upstream, NULL);
 293         if (len == 0)
 294                 return (ARCHIVE_EOF);
 295         __archive_read_filter_consume(self->upstream, len);
 296
 297         /* Initialize CRC accumulator. */
 298         state->crc = crc32(0L, NULL, 0);
 299
 300         /* Initialize compression library. */
 301         state->stream.next_in = (unsigned char *)(uintptr_t)
 302             __archive_read_filter_ahead(self->upstream, 1, &avail);
 303         state->stream.avail_in = (uInt)avail;
 304         ret = inflateInit2(&(state->stream),
 305             -15 /* Don't check for zlib header */);
 306
 307         /* Decipher the error code. */
 308         switch (ret) {
 309         case Z_OK:
 310                 state->in_stream = 1;
 311                 return (ARCHIVE_OK);
 312         case Z_STREAM_ERROR:
 313                 archive_set_error(&self->archive->archive,
 314                     ARCHIVE_ERRNO_MISC,
 315                     "Internal error initializing compression library: "
 316                     "invalid setup parameter");
 317                 break;
 318         case Z_MEM_ERROR:
 319                 archive_set_error(&self->archive->archive, ENOMEM,
 320                     "Internal error initializing compression library: "
 321                     "out of memory");
 322                 break;
 323         case Z_VERSION_ERROR:
 324                 archive_set_error(&self->archive->archive,
 325                     ARCHIVE_ERRNO_MISC,
 326                     "Internal error initializing compression library: "
 327                     "invalid library version");
 328                 break;
 329         default:
 330                 archive_set_error(&self->archive->archive,
 331                     ARCHIVE_ERRNO_MISC,
 332                     "Internal error initializing compression library: "
 333                     " Zlib error %d", ret);
 334                 break;
 335         }
 336         return (ARCHIVE_FATAL);
 337 }
 338
 339 static int
 340 consume_trailer(struct archive_read_filter *self)
 341 {
 342         struct private_data *state;
 343         const unsigned char *p;
 344         ssize_t avail;
 345
 346         state = (struct private_data *)self->data;
 347
 348         state->in_stream = 0;
 349         switch (inflateEnd(&(state->stream))) {
 350         case Z_OK:
 351                 break;
 352         default:
 353                 archive_set_error(&self->archive->archive,
 354                     ARCHIVE_ERRNO_MISC,
 355                     "Failed to clean up gzip decompressor");
 356                 return (ARCHIVE_FATAL);
 357         }
 358
 359         /* GZip trailer is a fixed 8 byte structure. */
 360         p = __archive_read_filter_ahead(self->upstream, 8, &avail);
 361         if (p == NULL || avail == 0)
 362                 return (ARCHIVE_FATAL);
 363
 364         /* XXX TODO: Verify the length and CRC. */
 365
 366         /* We've verified the trailer, so consume it now. */
 367         __archive_read_filter_consume(self->upstream, 8);
 368
 369         return (ARCHIVE_OK);
 370 }
 371
 372 static ssize_t
 373 gzip_filter_read(struct archive_read_filter *self, const void **p)
 374 {
 375         struct private_data *state;
 376         size_t decompressed;
 377         ssize_t avail_in;
 378         int ret;
 379
 380         state = (struct private_data *)self->data;
 381
 382         /* Empty our output buffer. */
 383         state->stream.next_out = state->out_block;
 384         state->stream.avail_out = (uInt)state->out_block_size;
 385
 386         /* Try to fill the output buffer. */
 387         while (state->stream.avail_out > 0 && !state->eof) {
 388                 /* If we're not in a stream, read a header
 389                  * and initialize the decompression library. */
 390                 if (!state->in_stream) {
 391                         ret = consume_header(self);
 392                         if (ret == ARCHIVE_EOF) {
 393                                 state->eof = 1;
 394                                 break;
 395                         }
 396                         if (ret < ARCHIVE_OK)
 397                                 return (ret);
 398                 }
 399
 400                 /* Peek at the next available data. */
 401                 /* ZLib treats stream.next_in as const but doesn't declare
 402                  * it so, hence this ugly cast. */
 403                 state->stream.next_in = (unsigned char *)(uintptr_t)
 404                     __archive_read_filter_ahead(self->upstream, 1, &avail_in);
 405                 if (state->stream.next_in == NULL) {
 406                         archive_set_error(&self->archive->archive,
 407                             ARCHIVE_ERRNO_MISC,
 408                             "truncated gzip input");
 409                         return (ARCHIVE_FATAL);
 410                 }
 411                 state->stream.avail_in = (uInt)avail_in;
 412
 413                 /* Decompress and consume some of that data. */
 414                 ret = inflate(&(state->stream), 0);
 415                 switch (ret) {
 416                 case Z_OK: /* Decompressor made some progress. */
 417                         __archive_read_filter_consume(self->upstream,
 418                             avail_in - state->stream.avail_in);
 419                         break;
 420                 case Z_STREAM_END: /* Found end of stream. */
 421                         __archive_read_filter_consume(self->upstream,
 422                             avail_in - state->stream.avail_in);
 423                         /* Consume the stream trailer; release the
 424                          * decompression library. */
 425                         ret = consume_trailer(self);
 426                         if (ret < ARCHIVE_OK)
 427                                 return (ret);
 428                         break;
 429                 default:
 430                         /* Return an error. */
 431                         archive_set_error(&self->archive->archive,
 432                             ARCHIVE_ERRNO_MISC,
 433                             "gzip decompression failed");
 434                         return (ARCHIVE_FATAL);
 435                 }
 436         }
 437
 438         /* We've read as much as we can. */
 439         decompressed = state->stream.next_out - state->out_block;
 440         state->total_out += decompressed;
 441         if (decompressed == 0)
 442                 *p = NULL;
 443         else
 444                 *p = state->out_block;
 445         return (decompressed);
 446 }
 447
 448 /*
 449  * Clean up the decompressor.
 450  */
 451 static int
 452 gzip_filter_close(struct archive_read_filter *self)
 453 {
 454         struct private_data *state;
 455         int ret;
 456
 457         state = (struct private_data *)self->data;
 458         ret = ARCHIVE_OK;
 459
 460         if (state->in_stream) {
 461                 switch (inflateEnd(&(state->stream))) {
 462                 case Z_OK:
 463                         break;
 464                 default:
 465                         archive_set_error(&(self->archive->archive),
 466                             ARCHIVE_ERRNO_MISC,
 467                             "Failed to clean up gzip compressor");
 468                         ret = ARCHIVE_FATAL;
 469                 }
 470         }
 471
 472         free(state->out_block);
 473         free(state);
 474         return (ret);
 475 }
 476
 477 #endif /* HAVE_ZLIB_H */