compress_gz.cc

   1 /*
   2  * Copyright (c) 2001, Robert Collins.
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     A copy of the GNU General Public License can be found at
  10  *     http://www.gnu.org/
  11  *
  12  * Written by Robert Collins  <rbtcollins@hotmail.com>
  13  *
  14  */
  15
  16 /*
  17  * Portions copyright under the zlib licence - this class was derived from
  18  * gzio.c in that library.
  19  */
  20
  21 #include "compress_gz.h"
  22
  23 #include <stdexcept>
  24 using namespace std;
  25 #include <errno.h>
  26 #include <memory.h>
  27 #include <malloc.h>
  28
  29 #define HEAD_CRC     0x02       /* bit 1 set: header CRC present */
  30 #define EXTRA_FIELD  0x04       /* bit 2 set: extra field present */
  31 #define ORIG_NAME    0x08       /* bit 3 set: original file name present */
  32 #define COMMENT      0x10       /* bit 4 set: file comment present */
  33 #define RESERVED     0xE0       /* bits 5..7: reserved */
  34
  35
  36 /* TODO make this a static member and federate the magic logic */
  37 static int gz_magic[2] = { 0x1f, 0x8b };        /* gzip magic header */
  38
  39 /*
  40  * Predicate: the stream is open for read. For writing the class constructor variant with
  41  * mode must be called directly
  42  */
  43 compress_gz::compress_gz (io_stream * parent)
  44 {
  45   construct (parent, "r");
  46 }
  47
  48 compress_gz::compress_gz (io_stream * parent, const char *openmode)
  49 {
  50   construct (parent, openmode);
  51 }
  52
  53 void
  54 compress_gz::construct (io_stream * parent, const char *openmode)
  55 {
  56   original = parent;
  57   owns_original = true;
  58   peeklen = 0;
  59   int err;
  60   int level = Z_DEFAULT_COMPRESSION;    /* compression level */
  61   int strategy = Z_DEFAULT_STRATEGY;    /* compression strategy */
  62   char *p = (char *) openmode;
  63   char fmode[80];               /* copy of openmode, without the compression level */
  64   char *m = fmode;
  65
  66   stream.zalloc = (alloc_func) NULL;
  67   stream.zfree = (free_func) NULL;
  68   stream.opaque = (voidpf) NULL;
  69   stream.next_in = inbuf = NULL;
  70   stream.next_out = outbuf = NULL;
  71   stream.avail_in = stream.avail_out = 0;
  72   z_err = Z_OK;
  73   z_eof = 0;
  74   crc = crc32 (0L, Z_NULL, 0);
  75   msg = NULL;
  76   transparent = 0;
  77
  78   mode = '\0';
  79
  80   if (!parent)
  81     {
  82       z_err = Z_STREAM_ERROR;
  83       return;
  84     }
  85
  86   do
  87     {
  88       if (*p == 'r')
  89         mode = 'r';
  90       if (*p == 'w' || *p == 'a')
  91         mode = 'w';
  92       if (*p >= '0' && *p <= '9')
  93         {
  94           level = *p - '0';
  95         }
  96       else if (*p == 'f')
  97         {
  98           strategy = Z_FILTERED;
  99         }
 100       else if (*p == 'h')
 101         {
 102           strategy = Z_HUFFMAN_ONLY;
 103         }
 104       else
 105         {
 106           *m++ = *p;            /* copy the mode */
 107         }
 108     }
 109   while (*p++ && m != fmode + sizeof (fmode));
 110   if (mode == '\0')
 111     {
 112       destroy ();
 113       z_err = Z_STREAM_ERROR;
 114       return;
 115     }
 116
 117
 118   if (mode == 'w')
 119     {
 120       err = deflateInit2 (&(stream), level,
 121                           Z_DEFLATED, -MAX_WBITS, 8, strategy);
 122       /* windowBits is passed < 0 to suppress zlib header */
 123
 124       stream.next_out = outbuf = (Byte *) malloc (16384);
 125       if (err != Z_OK || outbuf == Z_NULL)
 126         {
 127           destroy ();
 128           z_err = Z_STREAM_ERROR;
 129           return;
 130         }
 131     }
 132   else
 133     {
 134
 135       stream.next_in = inbuf = (unsigned char *) malloc (16384);
 136       err = inflateInit2 (&stream, -MAX_WBITS);
 137       /* windowBits is passed < 0 to tell that there is no zlib header.
 138        * Note that in this case inflate *requires* an extra "dummy" byte
 139        * after the compressed stream in order to complete decompression and
 140        * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
 141        * present after the compressed stream.
 142        */
 143       if (err != Z_OK || inbuf == Z_NULL)
 144         {
 145           destroy ();
 146           z_err = Z_STREAM_ERROR;
 147           return;
 148         }
 149     }
 150   stream.avail_out = 16384;
 151
 152   errno = 0;
 153   if (mode == 'w')
 154     {
 155       /* Write a very simple .gz header:
 156        */
 157       char temp[20];
 158       sprintf (temp, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
 159                Z_DEFLATED, 0 /*flags */ , 0, 0, 0, 0 /*time */ ,
 160                0 /*xflags */ , 0x0b);
 161       original->write (temp, 10);
 162       startpos = 10L;
 163       /* We use 10L instead of ftell(s->file) to because ftell causes an
 164        * fflush on some systems. This version of the library doesn't use
 165        * startpos anyway in write mode, so this initialization is not
 166        * necessary.
 167        */
 168     }
 169   else
 170     {
 171
 172       check_header ();          /* skip the .gz header */
 173       startpos = (original->tell () - stream.avail_in);
 174     }
 175
 176   return;
 177 }
 178
 179 /* ===========================================================================
 180    Outputs a long in LSB order to the given file
 181 */
 182 void
 183 compress_gz::putLong (unsigned long x)
 184 {
 185   int n;
 186   for (n = 0; n < 4; n++)
 187     {
 188       unsigned char c = (unsigned char) (x & 0xff);
 189       original->write (&c, 1);
 190       x = x >> 8;
 191     }
 192 }
 193
 194
 195 uLong
 196 compress_gz::getLong ()
 197 {
 198   uLong x = (uLong) get_byte ();
 199   int c;
 200
 201   x += ((uLong) get_byte ()) << 8;
 202   x += ((uLong) get_byte ()) << 16;
 203   c = get_byte ();
 204   if (c == EOF)
 205     z_err = Z_DATA_ERROR;
 206   x += ((uLong) c) << 24;
 207   return x;
 208 }
 209
 210
 211 ssize_t
 212 compress_gz::read (void *buffer, size_t len)
 213 {
 214   if (!len)
 215     return 0;
 216
 217   if (peeklen)
 218     {
 219       ssize_t tmplen = std::min (peeklen, len);
 220       peeklen -= tmplen;
 221       memcpy (buffer, peekbuf, tmplen);
 222       memmove (peekbuf, peekbuf + tmplen, tmplen);
 223       ssize_t tmpread = read (&((char *) buffer)[tmplen], len - tmplen);
 224       if (tmpread >= 0)
 225         return tmpread + tmplen;
 226       else
 227         return tmpread;
 228     }
 229
 230   Bytef *start = (Bytef *) buffer;      /* starting point for crc computation */
 231   Byte *next_out;               /* == stream.next_out but not forced far (for MSDOS) */
 232
 233   if (mode != 'r')
 234     {
 235       z_err =  Z_STREAM_ERROR;
 236       return -1;
 237     }
 238
 239   if (z_err == Z_DATA_ERROR || z_err == Z_ERRNO)
 240     return -1;
 241   if (z_err == Z_STREAM_END)
 242     return 0;                   /* EOF */
 243
 244   next_out = (Byte *) buffer;
 245   stream.next_out = (Bytef *) buffer;
 246   stream.avail_out = len;
 247
 248   while (stream.avail_out != 0)
 249     {
 250
 251       if (transparent)
 252         {
 253           /* Copy first the lookahead bytes: */
 254           uInt n = stream.avail_in;
 255           if (n > stream.avail_out)
 256             n = stream.avail_out;
 257           if (n > 0)
 258             {
 259               memcpy (stream.next_out, stream.next_in, n);
 260               next_out += n;
 261               stream.next_out = next_out;
 262               stream.next_in += n;
 263               stream.avail_out -= n;
 264               stream.avail_in -= n;
 265             }
 266           if (stream.avail_out > 0)
 267             {
 268               stream.avail_out -= original->read (next_out, stream.avail_out);
 269             }
 270           len -= stream.avail_out;
 271           stream.total_in += (uLong) len;
 272           stream.total_out += (uLong) len;
 273           if (len == 0)
 274             z_eof = 1;
 275           return (int) len;
 276         }
 277       if (stream.avail_in == 0 && !z_eof)
 278         {
 279
 280           errno = 0;
 281           stream.avail_in = original->read (inbuf, 16384);
 282           if (stream.avail_in == 0)
 283             {
 284               z_eof = 1;
 285               if (original->error ())
 286                 {
 287                   z_err = Z_ERRNO;
 288                   break;
 289                 }
 290             }
 291           stream.next_in = inbuf;
 292         }
 293       z_err = inflate (&(stream), Z_NO_FLUSH);
 294
 295       if (z_err == Z_STREAM_END)
 296         {
 297           /* Check CRC and original size */
 298           crc = crc32 (crc, start, (uInt) (stream.next_out - start));
 299           start = stream.next_out;
 300
 301           if (getLong () != crc)
 302             {
 303               z_err = Z_DATA_ERROR;
 304             }
 305           else
 306             {
 307               (void) getLong ();
 308               /* The uncompressed length returned by above getlong() may
 309                * be different from stream.total_out) in case of
 310                * concatenated .gz files. Check for such files:
 311                */
 312               check_header ();
 313               if (z_err == Z_OK)
 314                 {
 315                   uLong total_in = stream.total_in;
 316                   uLong total_out = stream.total_out;
 317
 318                   inflateReset (&(stream));
 319                   stream.total_in = total_in;
 320                   stream.total_out = total_out;
 321                   crc = crc32 (0L, Z_NULL, 0);
 322                 }
 323             }
 324         }
 325       if (z_err != Z_OK || z_eof)
 326         break;
 327     }
 328   crc = crc32 (crc, start, (uInt) (stream.next_out - start));
 329
 330   return (int) (len - stream.avail_out);
 331 }
 332
 333
 334 /* ===========================================================================
 335    Writes the given number of uncompressed bytes into the compressed file.
 336    gzwrite returns the number of bytes actually written (0 in case of error).
 337 */
 338 ssize_t
 339 compress_gz::write (const void *buffer, size_t len)
 340 {
 341   if (mode != 'w')
 342     {
 343       z_err = Z_STREAM_ERROR;
 344       return -1;
 345     }
 346
 347   stream.next_in = (Bytef *) buffer;
 348   stream.avail_in = len;
 349
 350   while (stream.avail_in != 0)
 351     {
 352
 353       if (stream.avail_out == 0)
 354         {
 355
 356           stream.next_out = outbuf;
 357           if (original->write (outbuf, 16384) != 16384)
 358             {
 359               z_err = Z_ERRNO;
 360               break;
 361             }
 362           stream.avail_out = 16384;
 363         }
 364       z_err = deflate (&(stream), Z_NO_FLUSH);
 365       if (z_err != Z_OK)
 366         break;
 367     }
 368   crc = crc32 (crc, (const Bytef *) buffer, len);
 369
 370   return (int) (len - stream.avail_in);
 371 }
 372
 373 ssize_t
 374 compress_gz::peek (void *buffer, size_t len)
 375 {
 376   if (mode != 'r')
 377     {
 378       z_err = Z_STREAM_ERROR;
 379       return -1;
 380     }
 381   /* can only peek 512 bytes */
 382   if (len > 512)
 383     {
 384       z_err = ENOMEM;
 385       return -1;
 386     }
 387
 388   if (len > peeklen)
 389     {
 390       size_t want = len - peeklen;
 391       ssize_t got = read (&peekbuf[peeklen], want);
 392       if (got >= 0)
 393         peeklen += got;
 394       else
 395         /* error */
 396         return got;
 397       /* we may have read less than requested. */
 398       memcpy (buffer, peekbuf, peeklen);
 399       return peeklen;
 400     }
 401   else
 402     {
 403       memcpy (buffer, peekbuf, len);
 404       return len;
 405     }
 406 }
 407
 408 long
 409 compress_gz::tell ()
 410 {
 411   throw new logic_error("compress_gz::tell is not implemented");
 412 }
 413
 414 int
 415 compress_gz::seek (long where, io_stream_seek_t whence)
 416 {
 417   throw new logic_error("compress_gz::seek is not implemented");
 418 }
 419
 420 int
 421 compress_gz::error ()
 422 {
 423   if (z_err && z_err != Z_STREAM_END)
 424     return z_err;
 425   return 0;
 426 }
 427
 428 int
 429 compress_gz::set_mtime (time_t time)
 430 {
 431   if (original)
 432     return original->set_mtime (time);
 433   return 1;
 434 }
 435
 436 time_t
 437 compress_gz::get_mtime ()
 438 {
 439   if (original)
 440       return original->get_mtime ();
 441   return 0;
 442 }
 443
 444 mode_t
 445 compress_gz::get_mode ()
 446 {
 447   if (original)
 448     return original->get_mode ();
 449   return 0;
 450 }
 451
 452 void
 453 compress_gz::release_original ()
 454 {
 455   owns_original = false;
 456 }
 457
 458 void
 459 compress_gz::destroy ()
 460 {
 461   if (msg)
 462     free (msg);
 463   if (stream.state != NULL)
 464     {
 465       if (mode == 'w')
 466         {
 467           z_err = deflateEnd (&(stream));
 468         }
 469       else if (mode == 'r')
 470         {
 471           z_err = inflateEnd (&(stream));
 472         }
 473     }
 474
 475   if (inbuf)
 476
 477     free (inbuf);
 478   if (outbuf)
 479     free (outbuf);
 480   if (original && owns_original)
 481     delete original;
 482 }
 483
 484 compress_gz::~compress_gz ()
 485 {
 486   if (mode == 'w')
 487     {
 488       z_err = do_flush (Z_FINISH);
 489       if (z_err != Z_OK)
 490         {
 491           destroy ();
 492           return;
 493         }
 494
 495       putLong (crc);
 496       putLong (stream.total_in);
 497     }
 498   destroy ();
 499 }
 500
 501 int
 502 compress_gz::do_flush (int flush)
 503 {
 504   uInt len;
 505   int done = 0;
 506   if (mode != 'w')
 507     return Z_STREAM_ERROR;
 508   stream.avail_in = 0;          /* should be zero already anyway */
 509   for (;;)
 510     {
 511       len = 16384 - stream.avail_out;
 512       if (len != 0)
 513         {
 514           if ((uInt) original->write (outbuf, len) != len)
 515             {
 516               z_err = Z_ERRNO;
 517               return Z_ERRNO;
 518             }
 519           stream.next_out = outbuf;
 520           stream.avail_out = 16384;
 521         }
 522       if (done)
 523         break;
 524       z_err = deflate (&(stream), flush);
 525       /* Ignore the second of two consecutive flushes: */
 526       if (len == 0 && z_err == Z_BUF_ERROR)
 527         z_err = Z_OK;
 528       /* deflate has finished flushing only when it hasn't used up
 529        * all the available space in the output buffer:
 530        */
 531       done = (stream.avail_out != 0 || z_err == Z_STREAM_END);
 532       if (z_err != Z_OK && z_err != Z_STREAM_END)
 533         break;
 534     }
 535   return z_err == Z_STREAM_END ? Z_OK : z_err;
 536 }
 537
 538
 539 #if 0
 540
 541 gzclose (lst);
 542 #endif
 543 /* ===========================================================================
 544  *  Read a byte from a gz_stream; update next_in and avail_in. Return EOF
 545  *  for end of file.
 546  *  IN assertion: the stream s has been sucessfully opened for reading.
 547  */
 548 int
 549 compress_gz::get_byte ()
 550 {
 551   if (z_eof)
 552     return EOF;
 553   if (stream.avail_in == 0)
 554     {
 555       errno = 0;
 556       stream.avail_in = original->read (inbuf, 16384);
 557       if (stream.avail_in == 0)
 558         {
 559           z_eof = 1;
 560           if (original->error ())
 561             z_err = Z_ERRNO;
 562           return EOF;
 563         }
 564       stream.next_in = inbuf;
 565     }
 566   stream.avail_in--;
 567   return *(stream.next_in)++;
 568 }
 569
 570
 571 /* ===========================================================================
 572       Check the gzip header of a gz_stream opened for reading. Set the stream
 573     mode to transparent if the gzip magic header is not present; set s->err
 574     to Z_DATA_ERROR if the magic header is present but the rest of the header
 575     is incorrect.
 576     IN assertion: the stream s has already been created sucessfully;
 577        s->stream.avail_in is zero for the first time, but may be non-zero
 578        for concatenated .gz files.
 579 */
 580 void
 581 compress_gz::check_header ()
 582 {
 583   int method;                   /* method byte */
 584   int flags;                    /* flags byte */
 585   uInt len;
 586   int c;
 587   /* Check the gzip magic header */
 588   for (len = 0; len < 2; len++)
 589     {
 590       c = get_byte ();
 591       if (c != gz_magic[len])
 592         {
 593           if (len != 0)
 594             stream.avail_in++, stream.next_in--;
 595           if (c != EOF)
 596             {
 597               stream.avail_in++, stream.next_in--;
 598               transparent = 1;
 599             }
 600           z_err = stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
 601           return;
 602         }
 603     }
 604   method = get_byte ();
 605   flags = get_byte ();
 606   if (method != Z_DEFLATED || (flags & RESERVED) != 0)
 607     {
 608       z_err = Z_DATA_ERROR;
 609       return;
 610     }
 611
 612   /* Discard time, xflags and OS code: */
 613   for (len = 0; len < 6; len++)
 614     (void) get_byte ();
 615   if ((flags & EXTRA_FIELD) != 0)
 616     {                           /* skip the extra field */
 617       len = (uInt) get_byte ();
 618       len += ((uInt) get_byte ()) << 8;
 619       /* len is garbage if EOF but the loop below will quit anyway */
 620       while (len-- != 0 && get_byte () != EOF);
 621     }
 622   if ((flags & ORIG_NAME) != 0)
 623     {                           /* skip the original file name */
 624       while ((c = get_byte ()) != 0 && c != EOF);
 625     }
 626   if ((flags & COMMENT) != 0)
 627     {                           /* skip the .gz file comment */
 628       while ((c = get_byte ()) != 0 && c != EOF);
 629     }
 630   if ((flags & HEAD_CRC) != 0)
 631     {                           /* skip the header crc */
 632       for (len = 0; len < 2; len++)
 633         (void) get_byte ();
 634     }
 635   z_err = z_eof ? Z_DATA_ERROR : Z_OK;
 636 }