gzread.c

   1 /* gzread.c -- zlib functions for reading gzip files
   2  * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
   3  * For conditions of distribution and use, see copyright notice in zlib.h
   4  */
   5
   6 #include "gzguts.h"
   7
   8 /* Local functions */
   9 local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
  10 local int gz_avail OF((gz_statep));
  11 local int gz_look OF((gz_statep));
  12 local int gz_decomp OF((gz_statep));
  13 local int gz_fetch OF((gz_statep));
  14 local int gz_skip OF((gz_statep, z_off64_t));
  15 local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
  16
  17 /* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
  18    state->fd, and update state->eof, state->err, and state->msg as appropriate.
  19    This function needs to loop on read(), since read() is not guaranteed to
  20    read the number of bytes requested, depending on the type of descriptor. */
  21 local int gz_load(state, buf, len, have)
  22     gz_statep state;
  23     unsigned char *buf;
  24     unsigned len;
  25     unsigned *have;
  26 {
  27     z_ssize_t ret;
  28
  29     *have = 0;
  30     do {
  31         ret = read(state->fd, buf + *have, len - *have);
  32         if (ret <= 0)
  33             break;
  34         *have += (unsigned)ret;
  35     } while (*have < len);
  36     if (ret < 0) {
  37         gz_error(state, Z_ERRNO, zstrerror());
  38         return -1;
  39     }
  40     if (ret == 0)
  41         state->eof = 1;
  42     return 0;
  43 }
  44
  45 /* Load up input buffer and set eof flag if last data loaded -- return -1 on
  46    error, 0 otherwise.  Note that the eof flag is set when the end of the input
  47    file is reached, even though there may be unused data in the buffer.  Once
  48    that data has been used, no more attempts will be made to read the file.
  49    If strm->avail_in != 0, then the current data is moved to the beginning of
  50    the input buffer, and then the remainder of the buffer is loaded with the
  51    available data from the input file. */
  52 local int gz_avail(state)
  53     gz_statep state;
  54 {
  55     unsigned got;
  56     z_streamp strm = &(state->strm);
  57
  58     if (state->err != Z_OK && state->err != Z_BUF_ERROR)
  59         return -1;
  60     if (state->eof == 0) {
  61         if (strm->avail_in) {       /* copy what's there to the start */
  62             unsigned char *p = state->in;
  63             unsigned const char *q = strm->next_in;
  64             unsigned n = strm->avail_in;
  65             do {
  66                 *p++ = *q++;
  67             } while (--n);
  68         }
  69         if (gz_load(state, state->in + strm->avail_in,
  70                     state->size - strm->avail_in, &got) == -1)
  71             return -1;
  72         strm->avail_in += got;
  73         strm->next_in = state->in;
  74     }
  75     return 0;
  76 }
  77
  78 /* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
  79    If this is the first time in, allocate required memory.  state->how will be
  80    left unchanged if there is no more input data available, will be set to COPY
  81    if there is no gzip header and direct copying will be performed, or it will
  82    be set to GZIP for decompression.  If direct copying, then leftover input
  83    data from the input buffer will be copied to the output buffer.  In that
  84    case, all further file reads will be directly to either the output buffer or
  85    a user buffer.  If decompressing, the inflate state will be initialized.
  86    gz_look() will return 0 on success or -1 on failure. */
  87 local int gz_look(state)
  88     gz_statep state;
  89 {
  90     z_streamp strm = &(state->strm);
  91
  92     /* allocate read buffers and inflate memory */
  93     if (state->size == 0) {
  94         /* allocate buffers */
  95         state->in = (unsigned char *)malloc(state->want);
  96         state->out = (unsigned char *)malloc(state->want << 1);
  97         if (state->in == NULL || state->out == NULL) {
  98             if (state->out != NULL)
  99                 free(state->out);
 100             if (state->in != NULL)
 101                 free(state->in);
 102             gz_error(state, Z_MEM_ERROR, "out of memory");
 103             return -1;
 104         }
 105         state->size = state->want;
 106
 107         /* allocate inflate memory */
 108         state->strm.zalloc = Z_NULL;
 109         state->strm.zfree = Z_NULL;
 110         state->strm.opaque = Z_NULL;
 111         state->strm.avail_in = 0;
 112         state->strm.next_in = Z_NULL;
 113         if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
 114             free(state->out);
 115             free(state->in);
 116             state->size = 0;
 117             gz_error(state, Z_MEM_ERROR, "out of memory");
 118             return -1;
 119         }
 120     }
 121
 122     /* get at least the magic bytes in the input buffer */
 123     if (strm->avail_in < 2) {
 124         if (gz_avail(state) == -1)
 125             return -1;
 126         if (strm->avail_in == 0)
 127             return 0;
 128     }
 129
 130     /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
 131        a logical dilemma here when considering the case of a partially written
 132        gzip file, to wit, if a single 31 byte is written, then we cannot tell
 133        whether this is a single-byte file, or just a partially written gzip
 134        file -- for here we assume that if a gzip file is being written, then
 135        the header will be written in a single operation, so that reading a
 136        single byte is sufficient indication that it is not a gzip file) */
 137     if (strm->avail_in > 1 &&
 138             strm->next_in[0] == 31 && strm->next_in[1] == 139) {
 139         inflateReset(strm);
 140         state->how = GZIP;
 141         state->direct = 0;
 142         return 0;
 143     }
 144
 145     /* no gzip header -- if we were decoding gzip before, then this is trailing
 146        garbage.  Ignore the trailing garbage and finish. */
 147     if (state->direct == 0) {
 148         strm->avail_in = 0;
 149         state->eof = 1;
 150         state->x.have = 0;
 151         return 0;
 152     }
 153
 154     /* doing raw i/o, copy any leftover input to output -- this assumes that
 155        the output buffer is larger than the input buffer, which also assures
 156        space for gzungetc() */
 157     state->x.next = state->out;
 158     if (strm->avail_in) {
 159         memcpy(state->x.next, strm->next_in, strm->avail_in);
 160         state->x.have = strm->avail_in;
 161         strm->avail_in = 0;
 162     }
 163     state->how = COPY;
 164     state->direct = 1;
 165     return 0;
 166 }
 167
 168 /* Decompress from input to the provided next_out and avail_out in the state.
 169    On return, state->x.have and state->x.next point to the just decompressed
 170    data.  If the gzip stream completes, state->how is reset to LOOK to look for
 171    the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
 172    on success, -1 on failure. */
 173 local int gz_decomp(state)
 174     gz_statep state;
 175 {
 176     int ret = Z_OK;
 177     unsigned had;
 178     z_streamp strm = &(state->strm);
 179
 180     /* fill output buffer up to end of deflate stream */
 181     had = strm->avail_out;
 182     do {
 183         /* get more input for inflate() */
 184         if (strm->avail_in == 0 && gz_avail(state) == -1)
 185             return -1;
 186         if (strm->avail_in == 0) {
 187             gz_error(state, Z_BUF_ERROR, "unexpected end of file");
 188             break;
 189         }
 190
 191         /* decompress and handle errors */
 192         ret = inflate(strm, Z_NO_FLUSH);
 193         if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
 194             gz_error(state, Z_STREAM_ERROR,
 195                      "internal error: inflate stream corrupt");
 196             return -1;
 197         }
 198         if (ret == Z_MEM_ERROR) {
 199             gz_error(state, Z_MEM_ERROR, "out of memory");
 200             return -1;
 201         }
 202         if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
 203             gz_error(state, Z_DATA_ERROR,
 204                      strm->msg == NULL ? "compressed data error" : strm->msg);
 205             return -1;
 206         }
 207     } while (strm->avail_out && ret != Z_STREAM_END);
 208
 209     /* update available output */
 210     state->x.have = had - strm->avail_out;
 211     state->x.next = strm->next_out - state->x.have;
 212
 213     /* if the gzip stream completed successfully, look for another */
 214     if (ret == Z_STREAM_END)
 215         state->how = LOOK;
 216
 217     /* good decompression */
 218     return 0;
 219 }
 220
 221 /* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
 222    Data is either copied from the input file or decompressed from the input
 223    file depending on state->how.  If state->how is LOOK, then a gzip header is
 224    looked for to determine whether to copy or decompress.  Returns -1 on error,
 225    otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
 226    end of the input file has been reached and all data has been processed.  */
 227 local int gz_fetch(state)
 228     gz_statep state;
 229 {
 230     z_streamp strm = &(state->strm);
 231
 232     do {
 233         switch(state->how) {
 234         case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
 235             if (gz_look(state) == -1)
 236                 return -1;
 237             if (state->how == LOOK)
 238                 return 0;
 239             break;
 240         case COPY:      /* -> COPY */
 241             if (gz_load(state, state->out, state->size << 1, &(state->x.have))
 242                     == -1)
 243                 return -1;
 244             state->x.next = state->out;
 245             return 0;
 246         case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
 247             strm->avail_out = state->size << 1;
 248             strm->next_out = state->out;
 249             if (gz_decomp(state) == -1)
 250                 return -1;
 251         }
 252     } while (state->x.have == 0 && (!state->eof || strm->avail_in));
 253     return 0;
 254 }
 255
 256 /* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
 257 local int gz_skip(state, len)
 258     gz_statep state;
 259     z_off64_t len;
 260 {
 261     unsigned n;
 262
 263     /* skip over len bytes or reach end-of-file, whichever comes first */
 264     while (len)
 265         /* skip over whatever is in output buffer */
 266         if (state->x.have) {
 267             n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
 268                 (unsigned)len : state->x.have;
 269             state->x.have -= n;
 270             state->x.next += n;
 271             state->x.pos += n;
 272             len -= n;
 273         }
 274
 275         /* output buffer empty -- return if we're at the end of the input */
 276         else if (state->eof && state->strm.avail_in == 0)
 277             break;
 278
 279         /* need more data to skip -- load up output buffer */
 280         else {
 281             /* get more output, looking for header if required */
 282             if (gz_fetch(state) == -1)
 283                 return -1;
 284         }
 285     return 0;
 286 }
 287
 288 /* Read len bytes into buf from file, or less than len up to the end of the
 289    input.  Return the number of bytes read.  If zero is returned, either the
 290    end of file was reached, or there was an error.  state->err must be
 291    consulted in that case to determine which. */
 292 local z_size_t gz_read(state, buf, len)
 293     gz_statep state;
 294     voidp buf;
 295     z_size_t len;
 296 {
 297     z_size_t got;
 298     unsigned n;
 299
 300     /* if len is zero, avoid unnecessary operations */
 301     if (len == 0)
 302         return 0;
 303
 304     /* process a skip request */
 305     if (state->seek) {
 306         state->seek = 0;
 307         if (gz_skip(state, state->skip) == -1)
 308             return 0;
 309     }
 310
 311     /* get len bytes to buf, or less than len if at the end */
 312     got = 0;
 313     do {
 314         /* set n to the maximum amount of len that fits in an unsigned int */
 315         n = -1;
 316         if (n > len)
 317             n = len;
 318
 319         /* first just try copying data from the output buffer */
 320         if (state->x.have) {
 321             if (state->x.have < n)
 322                 n = state->x.have;
 323             memcpy(buf, state->x.next, n);
 324             state->x.next += n;
 325             state->x.have -= n;
 326         }
 327
 328         /* output buffer empty -- return if we're at the end of the input */
 329         else if (state->eof && state->strm.avail_in == 0) {
 330             state->past = 1;        /* tried to read past end */
 331             break;
 332         }
 333
 334         /* need output data -- for small len or new stream load up our output
 335            buffer */
 336         else if (state->how == LOOK || n < (state->size << 1)) {
 337             /* get more output, looking for header if required */
 338             if (gz_fetch(state) == -1)
 339                 return 0;
 340             continue;       /* no progress yet -- go back to copy above */
 341             /* the copy above assures that we will leave with space in the
 342                output buffer, allowing at least one gzungetc() to succeed */
 343         }
 344
 345         /* large len -- read directly into user buffer */
 346         else if (state->how == COPY) {      /* read directly */
 347             if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
 348                 return 0;
 349         }
 350
 351         /* large len -- decompress directly into user buffer */
 352         else {  /* state->how == GZIP */
 353             state->strm.avail_out = n;
 354             state->strm.next_out = (unsigned char *)buf;
 355             if (gz_decomp(state) == -1)
 356                 return 0;
 357             n = state->x.have;
 358             state->x.have = 0;
 359         }
 360
 361         /* update progress */
 362         len -= n;
 363         buf = (char *)buf + n;
 364         got += n;
 365         state->x.pos += n;
 366     } while (len);
 367
 368     /* return number of bytes read into user buffer */
 369     return got;
 370 }
 371
 372 /* -- see zlib.h -- */
 373 int ZEXPORT gzread(file, buf, len)
 374     gzFile file;
 375     voidp buf;
 376     unsigned len;
 377 {
 378     gz_statep state;
 379
 380     /* get internal structure */
 381     if (file == NULL)
 382         return -1;
 383     state = (gz_statep)file;
 384
 385     /* check that we're reading and that there's no (serious) error */
 386     if (state->mode != GZ_READ ||
 387             (state->err != Z_OK && state->err != Z_BUF_ERROR))
 388         return -1;
 389
 390     /* since an int is returned, make sure len fits in one, otherwise return
 391        with an error (this avoids a flaw in the interface) */
 392     if ((int)len < 0) {
 393         gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
 394         return -1;
 395     }
 396
 397     /* read len or fewer bytes to buf */
 398     len = gz_read(state, buf, len);
 399
 400     /* check for an error */
 401     if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
 402         return -1;
 403
 404     /* return the number of bytes read (this is assured to fit in an int) */
 405     return (int)len;
 406 }
 407
 408 /* -- see zlib.h -- */
 409 z_size_t ZEXPORT gzfread(buf, size, nitems, file)
 410     voidp buf;
 411     z_size_t size;
 412     z_size_t nitems;
 413     gzFile file;
 414 {
 415     z_size_t len;
 416     gz_statep state;
 417
 418     /* get internal structure */
 419     if (file == NULL)
 420         return 0;
 421     state = (gz_statep)file;
 422
 423     /* check that we're reading and that there's no (serious) error */
 424     if (state->mode != GZ_READ ||
 425             (state->err != Z_OK && state->err != Z_BUF_ERROR))
 426         return 0;
 427
 428     /* compute bytes to read -- error on overflow */
 429     len = nitems * size;
 430     if (size && len / size != nitems) {
 431         gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
 432         return 0;
 433     }
 434
 435     /* read len or fewer bytes to buf, return the number of full items read */
 436     return len ? gz_read(state, buf, len) / size : 0;
 437 }
 438
 439 /* -- see zlib.h -- */
 440 #ifdef Z_PREFIX_SET
 441 #  undef z_gzgetc
 442 #else
 443 #  undef gzgetc
 444 #endif
 445 int ZEXPORT gzgetc(file)
 446     gzFile file;
 447 {
 448     int ret;
 449     unsigned char buf[1];
 450     gz_statep state;
 451
 452     /* get internal structure */
 453     if (file == NULL)
 454         return -1;
 455     state = (gz_statep)file;
 456
 457     /* check that we're reading and that there's no (serious) error */
 458     if (state->mode != GZ_READ ||
 459         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 460         return -1;
 461
 462     /* try output buffer (no need to check for skip request) */
 463     if (state->x.have) {
 464         state->x.have--;
 465         state->x.pos++;
 466         return *(state->x.next)++;
 467     }
 468
 469     /* nothing there -- try gz_read() */
 470     ret = gz_read(state, buf, 1);
 471     return ret < 1 ? -1 : buf[0];
 472 }
 473
 474 int ZEXPORT gzgetc_(file)
 475 gzFile file;
 476 {
 477     return gzgetc(file);
 478 }
 479
 480 /* -- see zlib.h -- */
 481 int ZEXPORT gzungetc(c, file)
 482     int c;
 483     gzFile file;
 484 {
 485     gz_statep state;
 486
 487     /* get internal structure */
 488     if (file == NULL)
 489         return -1;
 490     state = (gz_statep)file;
 491
 492     /* check that we're reading and that there's no (serious) error */
 493     if (state->mode != GZ_READ ||
 494         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 495         return -1;
 496
 497     /* process a skip request */
 498     if (state->seek) {
 499         state->seek = 0;
 500         if (gz_skip(state, state->skip) == -1)
 501             return -1;
 502     }
 503
 504     /* can't push EOF */
 505     if (c < 0)
 506         return -1;
 507
 508     /* if output buffer empty, put byte at end (allows more pushing) */
 509     if (state->x.have == 0) {
 510         state->x.have = 1;
 511         state->x.next = state->out + (state->size << 1) - 1;
 512         state->x.next[0] = (unsigned char)c;
 513         state->x.pos--;
 514         state->past = 0;
 515         return c;
 516     }
 517
 518     /* if no room, give up (must have already done a gzungetc()) */
 519     if (state->x.have == (state->size << 1)) {
 520         gz_error(state, Z_DATA_ERROR, "out of room to push characters");
 521         return -1;
 522     }
 523
 524     /* slide output data if needed and insert byte before existing data */
 525     if (state->x.next == state->out) {
 526         unsigned char *src = state->out + state->x.have;
 527         unsigned char *dest = state->out + (state->size << 1);
 528         while (src > state->out)
 529             *--dest = *--src;
 530         state->x.next = dest;
 531     }
 532     state->x.have++;
 533     state->x.next--;
 534     state->x.next[0] = (unsigned char)c;
 535     state->x.pos--;
 536     state->past = 0;
 537     return c;
 538 }
 539
 540 /* -- see zlib.h -- */
 541 char * ZEXPORT gzgets(file, buf, len)
 542     gzFile file;
 543     char *buf;
 544     int len;
 545 {
 546     unsigned left, n;
 547     char *str;
 548     unsigned char *eol;
 549     gz_statep state;
 550
 551     /* check parameters and get internal structure */
 552     if (file == NULL || buf == NULL || len < 1)
 553         return NULL;
 554     state = (gz_statep)file;
 555
 556     /* check that we're reading and that there's no (serious) error */
 557     if (state->mode != GZ_READ ||
 558         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 559         return NULL;
 560
 561     /* process a skip request */
 562     if (state->seek) {
 563         state->seek = 0;
 564         if (gz_skip(state, state->skip) == -1)
 565             return NULL;
 566     }
 567
 568     /* copy output bytes up to new line or len - 1, whichever comes first --
 569        append a terminating zero to the string (we don't check for a zero in
 570        the contents, let the user worry about that) */
 571     str = buf;
 572     left = (unsigned)len - 1;
 573     if (left) do {
 574         /* assure that something is in the output buffer */
 575         if (state->x.have == 0 && gz_fetch(state) == -1)
 576             return NULL;                /* error */
 577         if (state->x.have == 0) {       /* end of file */
 578             state->past = 1;            /* read past end */
 579             break;                      /* return what we have */
 580         }
 581
 582         /* look for end-of-line in current output buffer */
 583         n = state->x.have > left ? left : state->x.have;
 584         eol = (unsigned char *)memchr(state->x.next, '\n', n);
 585         if (eol != NULL)
 586             n = (unsigned)(eol - state->x.next) + 1;
 587
 588         /* copy through end-of-line, or remainder if not found */
 589         memcpy(buf, state->x.next, n);
 590         state->x.have -= n;
 591         state->x.next += n;
 592         state->x.pos += n;
 593         left -= n;
 594         buf += n;
 595     } while (left && eol == NULL);
 596
 597     /* return terminated string, or if nothing, end of file */
 598     if (buf == str)
 599         return NULL;
 600     buf[0] = 0;
 601     return str;
 602 }
 603
 604 /* -- see zlib.h -- */
 605 int ZEXPORT gzdirect(file)
 606     gzFile file;
 607 {
 608     gz_statep state;
 609
 610     /* get internal structure */
 611     if (file == NULL)
 612         return 0;
 613     state = (gz_statep)file;
 614
 615     /* if the state is not known, but we can find out, then do so (this is
 616        mainly for right after a gzopen() or gzdopen()) */
 617     if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
 618         (void)gz_look(state);
 619
 620     /* return 1 if transparent, 0 if processing a gzip stream */
 621     return state->direct;
 622 }
 623
 624 /* -- see zlib.h -- */
 625 int ZEXPORT gzclose_r(file)
 626     gzFile file;
 627 {
 628     int ret, err;
 629     gz_statep state;
 630
 631     /* get internal structure */
 632     if (file == NULL)
 633         return Z_STREAM_ERROR;
 634     state = (gz_statep)file;
 635
 636     /* check that we're reading */
 637     if (state->mode != GZ_READ)
 638         return Z_STREAM_ERROR;
 639
 640     /* free memory and close file */
 641     if (state->size) {
 642         inflateEnd(&(state->strm));
 643         free(state->out);
 644         free(state->in);
 645     }
 646     err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
 647     gz_error(state, Z_OK, NULL);
 648     free(state->path);
 649     ret = close(state->fd);
 650     free(state);
 651     return ret ? Z_ERRNO : err;
 652 }