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