contrib/libarchive-2.0/libarchive/archive_read_support_compression_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: src/lib/libarchive/archive_read_support_compression_gzip.c,v 1.14 2007/04/05 05:18:16 kientzle Exp $");
  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         unsigned char   *uncompressed_buffer;
  55         size_t           uncompressed_buffer_size;
  56         unsigned char   *read_next;
  57         int64_t          total_out;
  58         unsigned long    crc;
  59         char             header_done;
  60 };
  61
  62 static int      finish(struct archive_read *);
  63 static ssize_t  read_ahead(struct archive_read *, const void **, size_t);
  64 static ssize_t  read_consume(struct archive_read *, size_t);
  65 static int      drive_decompressor(struct archive_read *a, struct private_data *);
  66 #endif
  67
  68 /* These two functions are defined even if we lack zlib.  See below. */
  69 static int      bid(const void *, size_t);
  70 static int      init(struct archive_read *, const void *, size_t);
  71
  72 int
  73 archive_read_support_compression_gzip(struct archive *_a)
  74 {
  75         struct archive_read *a = (struct archive_read *)_a;
  76         return (__archive_read_register_compression(a, bid, init));
  77 }
  78
  79 /*
  80  * Test whether we can handle this data.
  81  *
  82  * This logic returns zero if any part of the signature fails.  It
  83  * also tries to Do The Right Thing if a very short buffer prevents us
  84  * from verifying as much as we would like.
  85  */
  86 static int
  87 bid(const void *buff, size_t len)
  88 {
  89         const unsigned char *buffer;
  90         int bits_checked;
  91
  92         if (len < 1)
  93                 return (0);
  94
  95         buffer = (const unsigned char *)buff;
  96         bits_checked = 0;
  97         if (buffer[0] != 037)   /* Verify first ID byte. */
  98                 return (0);
  99         bits_checked += 8;
 100         if (len < 2)
 101                 return (bits_checked);
 102
 103         if (buffer[1] != 0213)  /* Verify second ID byte. */
 104                 return (0);
 105         bits_checked += 8;
 106         if (len < 3)
 107                 return (bits_checked);
 108
 109         if (buffer[2] != 8)     /* Compression must be 'deflate'. */
 110                 return (0);
 111         bits_checked += 8;
 112         if (len < 4)
 113                 return (bits_checked);
 114
 115         if ((buffer[3] & 0xE0)!= 0)     /* No reserved flags set. */
 116                 return (0);
 117         bits_checked += 3;
 118         if (len < 5)
 119                 return (bits_checked);
 120
 121         /*
 122          * TODO: Verify more; in particular, gzip has an optional
 123          * header CRC, which would give us 16 more verified bits.  We
 124          * may also be able to verify certain constraints on other
 125          * fields.
 126          */
 127
 128         return (bits_checked);
 129 }
 130
 131
 132 #ifndef HAVE_ZLIB_H
 133
 134 /*
 135  * If we don't have zlib on this system, we can't actually do the
 136  * decompression.  We can, however, still detect gzip-compressed
 137  * archives and emit a useful message.
 138  */
 139 static int
 140 init(struct archive_read *a, const void *buff, size_t n)
 141 {
 142         (void)a;        /* UNUSED */
 143         (void)buff;     /* UNUSED */
 144         (void)n;        /* UNUSED */
 145
 146         archive_set_error(a, -1,
 147             "This version of libarchive was compiled without gzip support");
 148         return (ARCHIVE_FATAL);
 149 }
 150
 151
 152 #else
 153
 154 /*
 155  * Setup the callbacks.
 156  */
 157 static int
 158 init(struct archive_read *a, const void *buff, size_t n)
 159 {
 160         struct private_data *state;
 161         int ret;
 162
 163         a->archive.compression_code = ARCHIVE_COMPRESSION_GZIP;
 164         a->archive.compression_name = "gzip";
 165
 166         state = (struct private_data *)malloc(sizeof(*state));
 167         if (state == NULL) {
 168                 archive_set_error(&a->archive, ENOMEM,
 169                     "Can't allocate data for %s decompression",
 170                     a->archive.compression_name);
 171                 return (ARCHIVE_FATAL);
 172         }
 173         memset(state, 0, sizeof(*state));
 174
 175         state->crc = crc32(0L, NULL, 0);
 176         state->header_done = 0; /* We've not yet begun to parse header... */
 177
 178         state->uncompressed_buffer_size = 64 * 1024;
 179         state->uncompressed_buffer = (unsigned char *)malloc(state->uncompressed_buffer_size);
 180         state->stream.next_out = state->uncompressed_buffer;
 181         state->read_next = state->uncompressed_buffer;
 182         state->stream.avail_out = state->uncompressed_buffer_size;
 183
 184         if (state->uncompressed_buffer == NULL) {
 185                 archive_set_error(&a->archive, ENOMEM,
 186                     "Can't allocate %s decompression buffers",
 187                     a->archive.compression_name);
 188                 free(state);
 189                 return (ARCHIVE_FATAL);
 190         }
 191
 192         /*
 193          * A bug in zlib.h: stream.next_in should be marked 'const'
 194          * but isn't (the library never alters data through the
 195          * next_in pointer, only reads it).  The result: this ugly
 196          * cast to remove 'const'.
 197          */
 198         state->stream.next_in = (Bytef *)(uintptr_t)(const void *)buff;
 199         state->stream.avail_in = n;
 200
 201         a->compression_read_ahead = read_ahead;
 202         a->compression_read_consume = read_consume;
 203         a->compression_skip = NULL; /* not supported */
 204         a->compression_finish = finish;
 205
 206         /*
 207          * TODO: Do I need to parse the gzip header before calling
 208          * inflateInit2()?  In particular, one of the header bytes
 209          * marks "best compression" or "fastest", which may be
 210          * appropriate for setting the second parameter here.
 211          * However, I think the only penalty for not setting it
 212          * correctly is wasted memory.  If this is necessary, it
 213          * should probably go into drive_decompressor() below.
 214          */
 215
 216         /* Initialize compression library. */
 217         ret = inflateInit2(&(state->stream),
 218             -15 /* Don't check for zlib header */);
 219         if (ret == Z_OK) {
 220                 a->compression_data = state;
 221                 return (ARCHIVE_OK);
 222         }
 223
 224         /* Library setup failed: Clean up. */
 225         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 226             "Internal error initializing %s library",
 227             a->archive.compression_name);
 228         free(state->uncompressed_buffer);
 229         free(state);
 230
 231         /* Override the error message if we know what really went wrong. */
 232         switch (ret) {
 233         case Z_STREAM_ERROR:
 234                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 235                     "Internal error initializing compression library: "
 236                     "invalid setup parameter");
 237                 break;
 238         case Z_MEM_ERROR:
 239                 archive_set_error(&a->archive, ENOMEM,
 240                     "Internal error initializing compression library: "
 241                     "out of memory");
 242                 break;
 243         case Z_VERSION_ERROR:
 244                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 245                     "Internal error initializing compression library: "
 246                     "invalid library version");
 247                 break;
 248         }
 249
 250         return (ARCHIVE_FATAL);
 251 }
 252
 253 /*
 254  * Return a block of data from the decompression buffer.  Decompress more
 255  * as necessary.
 256  */
 257 static ssize_t
 258 read_ahead(struct archive_read *a, const void **p, size_t min)
 259 {
 260         struct private_data *state;
 261         size_t read_avail, was_avail;
 262         int ret;
 263
 264         state = (struct private_data *)a->compression_data;
 265         if (!a->client_reader) {
 266                 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
 267                     "No read callback is registered?  "
 268                     "This is probably an internal programming error.");
 269                 return (ARCHIVE_FATAL);
 270         }
 271
 272         read_avail = state->stream.next_out - state->read_next;
 273
 274         if (read_avail + state->stream.avail_out < min) {
 275                 memmove(state->uncompressed_buffer, state->read_next,
 276                     read_avail);
 277                 state->read_next = state->uncompressed_buffer;
 278                 state->stream.next_out = state->read_next + read_avail;
 279                 state->stream.avail_out
 280                     = state->uncompressed_buffer_size - read_avail;
 281         }
 282
 283         while (read_avail < min &&              /* Haven't satisfied min. */
 284             read_avail < state->uncompressed_buffer_size) { /* !full */
 285                 was_avail = read_avail;
 286                 if ((ret = drive_decompressor(a, state)) != ARCHIVE_OK)
 287                         return (ret);
 288                 read_avail = state->stream.next_out - state->read_next;
 289                 if (was_avail == read_avail) /* No progress? */
 290                         break;
 291         }
 292
 293         *p = state->read_next;
 294         return (read_avail);
 295 }
 296
 297 /*
 298  * Mark a previously-returned block of data as read.
 299  */
 300 static ssize_t
 301 read_consume(struct archive_read *a, size_t n)
 302 {
 303         struct private_data *state;
 304
 305         state = (struct private_data *)a->compression_data;
 306         a->archive.file_position += n;
 307         state->read_next += n;
 308         if (state->read_next > state->stream.next_out)
 309                 __archive_errx(1, "Request to consume too many "
 310                     "bytes from gzip decompressor");
 311         return (n);
 312 }
 313
 314 /*
 315  * Clean up the decompressor.
 316  */
 317 static int
 318 finish(struct archive_read *a)
 319 {
 320         struct private_data *state;
 321         int ret;
 322
 323         state = (struct private_data *)a->compression_data;
 324         ret = ARCHIVE_OK;
 325         switch (inflateEnd(&(state->stream))) {
 326         case Z_OK:
 327                 break;
 328         default:
 329                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 330                     "Failed to clean up %s compressor",
 331                     a->archive.compression_name);
 332                 ret = ARCHIVE_FATAL;
 333         }
 334
 335         free(state->uncompressed_buffer);
 336         free(state);
 337
 338         a->compression_data = NULL;
 339         if (a->client_closer != NULL)
 340                 (a->client_closer)(&a->archive, a->client_data);
 341
 342         return (ret);
 343 }
 344
 345 /*
 346  * Utility function to pull data through decompressor, reading input
 347  * blocks as necessary.
 348  */
 349 static int
 350 drive_decompressor(struct archive_read *a, struct private_data *state)
 351 {
 352         ssize_t ret;
 353         size_t decompressed, total_decompressed;
 354         int count, flags, header_state;
 355         unsigned char *output;
 356         unsigned char b;
 357         const void *read_buf;
 358
 359         flags = 0;
 360         count = 0;
 361         header_state = 0;
 362         total_decompressed = 0;
 363         for (;;) {
 364                 if (state->stream.avail_in == 0) {
 365                         read_buf = state->stream.next_in;
 366                         ret = (a->client_reader)(&a->archive, a->client_data,
 367                             &read_buf);
 368                         state->stream.next_in = (unsigned char *)(uintptr_t)read_buf;
 369                         if (ret < 0) {
 370                                 /*
 371                                  * TODO: Find a better way to handle
 372                                  * this read failure.
 373                                  */
 374                                 goto fatal;
 375                         }
 376                         if (ret == 0  &&  total_decompressed == 0) {
 377                                 archive_set_error(&a->archive, EIO,
 378                                     "Premature end of %s compressed data",
 379                                     a->archive.compression_name);
 380                                 return (ARCHIVE_FATAL);
 381                         }
 382                         a->archive.raw_position += ret;
 383                         state->stream.avail_in = ret;
 384                 }
 385
 386                 if (!state->header_done) {
 387                         /*
 388                          * If still parsing the header, interpret the
 389                          * next byte.
 390                          */
 391                         b = *(state->stream.next_in++);
 392                         state->stream.avail_in--;
 393
 394                         /*
 395                          * Yes, this is somewhat crude, but it works,
 396                          * GZip format isn't likely to change anytime
 397                          * in the near future, and header parsing is
 398                          * certainly not a performance issue, so
 399                          * there's little point in making this more
 400                          * elegant.  Of course, if you see an easy way
 401                          * to make this more elegant, please let me
 402                          * know.. ;-)
 403                          */
 404                         switch (header_state) {
 405                         case 0: /* First byte of signature. */
 406                                 if (b != 037)
 407                                         goto fatal;
 408                                 header_state = 1;
 409                                 break;
 410                         case 1: /* Second byte of signature. */
 411                                 if (b != 0213)
 412                                         goto fatal;
 413                                 header_state = 2;
 414                                 break;
 415                         case 2: /* Compression type must be 8. */
 416                                 if (b != 8)
 417                                         goto fatal;
 418                                 header_state = 3;
 419                                 break;
 420                         case 3: /* GZip flags. */
 421                                 flags = b;
 422                                 header_state = 4;
 423                                 break;
 424                         case 4: case 5: case 6: case 7: /* Mod time. */
 425                                 header_state++;
 426                                 break;
 427                         case 8: /* Deflate flags. */
 428                                 header_state = 9;
 429                                 break;
 430                         case 9: /* OS. */
 431                                 header_state = 10;
 432                                 break;
 433                         case 10: /* Optional Extra: First byte of Length. */
 434                                 if ((flags & 4)) {
 435                                         count = 255 & (int)b;
 436                                         header_state = 11;
 437                                         break;
 438                                 }
 439                                 /*
 440                                  * Fall through if there is no
 441                                  * Optional Extra field.
 442                                  */
 443                         case 11: /* Optional Extra: Second byte of Length. */
 444                                 if ((flags & 4)) {
 445                                         count = (0xff00 & ((int)b << 8)) | count;
 446                                         header_state = 12;
 447                                         break;
 448                                 }
 449                                 /*
 450                                  * Fall through if there is no
 451                                  * Optional Extra field.
 452                                  */
 453                         case 12: /* Optional Extra Field: counted length. */
 454                                 if ((flags & 4)) {
 455                                         --count;
 456                                         if (count == 0) header_state = 13;
 457                                         else header_state = 12;
 458                                         break;
 459                                 }
 460                                 /*
 461                                  * Fall through if there is no
 462                                  * Optional Extra field.
 463                                  */
 464                         case 13: /* Optional Original Filename. */
 465                                 if ((flags & 8)) {
 466                                         if (b == 0) header_state = 14;
 467                                         else header_state = 13;
 468                                         break;
 469                                 }
 470                                 /*
 471                                  * Fall through if no Optional
 472                                  * Original Filename.
 473                                  */
 474                         case 14: /* Optional Comment. */
 475                                 if ((flags & 16)) {
 476                                         if (b == 0) header_state = 15;
 477                                         else header_state = 14;
 478                                         break;
 479                                 }
 480                                 /* Fall through if no Optional Comment. */
 481                         case 15: /* Optional Header CRC: First byte. */
 482                                 if ((flags & 2)) {
 483                                         header_state = 16;
 484                                         break;
 485                                 }
 486                                 /* Fall through if no Optional Header CRC. */
 487                         case 16: /* Optional Header CRC: Second byte. */
 488                                 if ((flags & 2)) {
 489                                         header_state = 17;
 490                                         break;
 491                                 }
 492                                 /* Fall through if no Optional Header CRC. */
 493                         case 17: /* First byte of compressed data. */
 494                                 state->header_done = 1; /* done with header */
 495                                 state->stream.avail_in++;
 496                                 state->stream.next_in--;
 497                         }
 498
 499                         /*
 500                          * TODO: Consider moving the inflateInit2 call
 501                          * here so it can include the compression type
 502                          * from the header?
 503                          */
 504                 } else {
 505                         output = state->stream.next_out;
 506
 507                         /* Decompress some data. */
 508                         ret = inflate(&(state->stream), 0);
 509                         decompressed = state->stream.next_out - output;
 510
 511                         /* Accumulate the CRC of the uncompressed data. */
 512                         state->crc = crc32(state->crc, output, decompressed);
 513
 514                         /* Accumulate the total bytes of output. */
 515                         state->total_out += decompressed;
 516                         total_decompressed += decompressed;
 517
 518                         switch (ret) {
 519                         case Z_OK: /* Decompressor made some progress. */
 520                                 if (decompressed > 0)
 521                                         return (ARCHIVE_OK);
 522                                 break;
 523                         case Z_STREAM_END: /* Found end of stream. */
 524                                 /*
 525                                  * TODO: Verify gzip trailer
 526                                  * (uncompressed length and CRC).
 527                                  */
 528                                 return (ARCHIVE_OK);
 529                         default:
 530                                 /* Any other return value is an error. */
 531                                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 532                                     "gzip decompression failed (%s)",
 533                                     state->stream.msg);
 534                                 goto fatal;
 535                         }
 536                 }
 537         }
 538         return (ARCHIVE_OK);
 539
 540         /* Return a fatal error. */
 541 fatal:
 542         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 543             "%s decompression failed", a->archive.compression_name);
 544         return (ARCHIVE_FATAL);
 545 }
 546
 547 #endif /* HAVE_ZLIB_H */