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