gzread.c

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