gzread.c

   1 /* gzread.c -- zlib functions for reading gzip files
   2  * Copyright (C) 2004, 2005, 2010 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->have must be zero.
  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->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->next = state->out;
 151     if (strm->avail_in) {
 152         memcpy(state->next, strm->next_in, strm->avail_in);
 153         state->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    state->have and state->next are set to point to the just decompressed data,
 163    If the gzip stream completes, state->how is reset to LOOK to look for the
 164    next gzip stream or raw data, once state->have is depleted.  Returns 0 on
 165    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->have = had - strm->avail_out;
 204     state->next = strm->next_out - state->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 that state->have == 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->have))
 235                     == -1)
 236                 return -1;
 237             state->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->have == 0);
 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->have) {
 260             n = GT_OFF(state->have) || (z_off64_t)state->have > len ?
 261                 (unsigned)len : state->have;
 262             state->have -= n;
 263             state->next += n;
 264             state->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_BUF_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->have) {
 325             n = state->have > len ? len : state->have;
 326             memcpy(buf, state->next, n);
 327             state->next += n;
 328             state->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             break;
 334
 335         /* need output data -- for small len or new stream load up our output
 336            buffer */
 337         else if (state->how == LOOK || len < (state->size << 1)) {
 338             /* get more output, looking for header if required */
 339             if (gz_fetch(state) == -1)
 340                 return -1;
 341             continue;       /* no progress yet -- go back to memcpy() above */
 342             /* the copy above assures that we will leave with space in the
 343                output buffer, allowing at least one gzungetc() to succeed */
 344         }
 345
 346         /* large len -- read directly into user buffer */
 347         else if (state->how == COPY) {      /* read directly */
 348             if (gz_load(state, buf, len, &n) == -1)
 349                 return -1;
 350         }
 351
 352         /* large len -- decompress directly into user buffer */
 353         else {  /* state->how == GZIP */
 354             strm->avail_out = len;
 355             strm->next_out = buf;
 356             if (gz_decomp(state) == -1)
 357                 return -1;
 358             n = state->have;
 359             state->have = 0;
 360         }
 361
 362         /* update progress */
 363         len -= n;
 364         buf = (char *)buf + n;
 365         got += n;
 366         state->pos += n;
 367     } while (len);
 368
 369     /* return number of bytes read into user buffer (will fit in int) */
 370     return (int)got;
 371 }
 372
 373 /* -- see zlib.h -- */
 374 int ZEXPORT gzgetc(file)
 375     gzFile file;
 376 {
 377     int ret;
 378     unsigned char buf[1];
 379     gz_statep state;
 380
 381     /* get internal structure */
 382     if (file == NULL)
 383         return -1;
 384     state = (gz_statep)file;
 385
 386     /* check that we're reading and that there's no (serious) error */
 387     if (state->mode != GZ_READ ||
 388         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 389         return -1;
 390
 391     /* try output buffer (no need to check for skip request) */
 392     if (state->have) {
 393         state->have--;
 394         state->pos++;
 395         return *(state->next)++;
 396     }
 397
 398     /* nothing there -- try gzread() */
 399     ret = gzread(file, buf, 1);
 400     return ret < 1 ? -1 : buf[0];
 401 }
 402
 403 /* -- see zlib.h -- */
 404 int ZEXPORT gzungetc(c, file)
 405     int c;
 406     gzFile file;
 407 {
 408     gz_statep state;
 409
 410     /* get internal structure */
 411     if (file == NULL)
 412         return -1;
 413     state = (gz_statep)file;
 414
 415     /* check that we're reading and that there's no (serious) error */
 416     if (state->mode != GZ_READ ||
 417         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 418         return -1;
 419
 420     /* process a skip request */
 421     if (state->seek) {
 422         state->seek = 0;
 423         if (gz_skip(state, state->skip) == -1)
 424             return -1;
 425     }
 426
 427     /* can't push EOF */
 428     if (c < 0)
 429         return -1;
 430
 431     /* if output buffer empty, put byte at end (allows more pushing) */
 432     if (state->have == 0) {
 433         state->have = 1;
 434         state->next = state->out + (state->size << 1) - 1;
 435         state->next[0] = c;
 436         state->pos--;
 437         return c;
 438     }
 439
 440     /* if no room, give up (must have already done a gzungetc()) */
 441     if (state->have == (state->size << 1)) {
 442         gz_error(state, Z_BUF_ERROR, "out of room to push characters");
 443         return -1;
 444     }
 445
 446     /* slide output data if needed and insert byte before existing data */
 447     if (state->next == state->out) {
 448         unsigned char *src = state->out + state->have;
 449         unsigned char *dest = state->out + (state->size << 1);
 450         while (src > state->out)
 451             *--dest = *--src;
 452         state->next = dest;
 453     }
 454     state->have++;
 455     state->next--;
 456     state->next[0] = c;
 457     state->pos--;
 458     return c;
 459 }
 460
 461 /* -- see zlib.h -- */
 462 char * ZEXPORT gzgets(file, buf, len)
 463     gzFile file;
 464     char *buf;
 465     int len;
 466 {
 467     unsigned left, n;
 468     char *str;
 469     unsigned char *eol;
 470     gz_statep state;
 471
 472     /* check parameters and get internal structure */
 473     if (file == NULL || buf == NULL || len < 1)
 474         return NULL;
 475     state = (gz_statep)file;
 476
 477     /* check that we're reading and that there's no (serious) error */
 478     if (state->mode != GZ_READ ||
 479         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 480         return NULL;
 481
 482     /* process a skip request */
 483     if (state->seek) {
 484         state->seek = 0;
 485         if (gz_skip(state, state->skip) == -1)
 486             return NULL;
 487     }
 488
 489     /* copy output bytes up to new line or len - 1, whichever comes first --
 490        append a terminating zero to the string (we don't check for a zero in
 491        the contents, let the user worry about that) */
 492     str = buf;
 493     left = (unsigned)len - 1;
 494     if (left) do {
 495         /* assure that something is in the output buffer */
 496         if (state->have == 0 && gz_fetch(state) == -1)
 497             return NULL;                /* error */
 498         if (state->have == 0) {         /* end of file */
 499             if (buf == str)             /* got bupkus */
 500                 return NULL;
 501             break;                      /* got something -- return it */
 502         }
 503
 504         /* look for end-of-line in current output buffer */
 505         n = state->have > left ? left : state->have;
 506         eol = memchr(state->next, '\n', n);
 507         if (eol != NULL)
 508             n = (unsigned)(eol - state->next) + 1;
 509
 510         /* copy through end-of-line, or remainder if not found */
 511         memcpy(buf, state->next, n);
 512         state->have -= n;
 513         state->next += n;
 514         state->pos += n;
 515         left -= n;
 516         buf += n;
 517     } while (left && eol == NULL);
 518
 519     /* found end-of-line or out of space -- terminate string and return it */
 520     buf[0] = 0;
 521     return str;
 522 }
 523
 524 /* -- see zlib.h -- */
 525 int ZEXPORT gzdirect(file)
 526     gzFile file;
 527 {
 528     gz_statep state;
 529
 530     /* get internal structure */
 531     if (file == NULL)
 532         return 0;
 533     state = (gz_statep)file;
 534
 535     /* check that we're reading */
 536     if (state->mode != GZ_READ)
 537         return 0;
 538
 539     /* if the state is not known, but we can find out, then do so (this is
 540        mainly for right after a gzopen() or gzdopen()) */
 541     if (state->how == LOOK && state->have == 0)
 542         (void)gz_look(state);
 543
 544     /* return 1 if reading direct, 0 if decompressing a gzip stream */
 545     return state->direct;
 546 }
 547
 548 /* -- see zlib.h -- */
 549 int ZEXPORT gzclose_r(file)
 550     gzFile file;
 551 {
 552     int ret;
 553     gz_statep state;
 554
 555     /* get internal structure */
 556     if (file == NULL)
 557         return Z_STREAM_ERROR;
 558     state = (gz_statep)file;
 559
 560     /* check that we're reading */
 561     if (state->mode != GZ_READ)
 562         return Z_STREAM_ERROR;
 563
 564     /* free memory and close file */
 565     if (state->size) {
 566         inflateEnd(&(state->strm));
 567         free(state->out);
 568         free(state->in);
 569     }
 570     gz_error(state, Z_OK, NULL);
 571     free(state->path);
 572     ret = close(state->fd);
 573     free(state);
 574     return ret ? Z_ERRNO : Z_OK;
 575 }