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);
 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_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->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             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->x.have;
 359             state->x.have = 0;
 360         }
 361
 362         /* update progress */
 363         len -= n;
 364         buf = (char *)buf + n;
 365         got += n;
 366         state->x.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) -- while
 392        this check really isn't required since the gzgetc() macro has
 393        already determined that x.have is zero, we leave it in for
 394        completeness. */
 395     if (state->x.have) {
 396         state->x.have--;
 397         state->x.pos++;
 398         return *(state->x.next)++;
 399     }
 400
 401     /* nothing there -- try gzread() */
 402     ret = gzread(file, buf, 1);
 403     return ret < 1 ? -1 : buf[0];
 404 }
 405
 406 /* -- see zlib.h -- */
 407 int ZEXPORT gzungetc(c, file)
 408     int c;
 409     gzFile file;
 410 {
 411     gz_statep state;
 412
 413     /* get internal structure */
 414     if (file == NULL)
 415         return -1;
 416     state = (gz_statep)file;
 417
 418     /* check that we're reading and that there's no (serious) error */
 419     if (state->mode != GZ_READ ||
 420         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 421         return -1;
 422
 423     /* process a skip request */
 424     if (state->seek) {
 425         state->seek = 0;
 426         if (gz_skip(state, state->skip) == -1)
 427             return -1;
 428     }
 429
 430     /* can't push EOF */
 431     if (c < 0)
 432         return -1;
 433
 434     /* if output buffer empty, put byte at end (allows more pushing) */
 435     if (state->x.have == 0) {
 436         state->x.have = 1;
 437         state->x.next = state->out + (state->size << 1) - 1;
 438         state->x.next[0] = c;
 439         state->x.pos--;
 440         return c;
 441     }
 442
 443     /* if no room, give up (must have already done a gzungetc()) */
 444     if (state->x.have == (state->size << 1)) {
 445         gz_error(state, Z_BUF_ERROR, "out of room to push characters");
 446         return -1;
 447     }
 448
 449     /* slide output data if needed and insert byte before existing data */
 450     if (state->x.next == state->out) {
 451         unsigned char *src = state->out + state->x.have;
 452         unsigned char *dest = state->out + (state->size << 1);
 453         while (src > state->out)
 454             *--dest = *--src;
 455         state->x.next = dest;
 456     }
 457     state->x.have++;
 458     state->x.next--;
 459     state->x.next[0] = c;
 460     state->x.pos--;
 461     return c;
 462 }
 463
 464 /* -- see zlib.h -- */
 465 char * ZEXPORT gzgets(file, buf, len)
 466     gzFile file;
 467     char *buf;
 468     int len;
 469 {
 470     unsigned left, n;
 471     char *str;
 472     unsigned char *eol;
 473     gz_statep state;
 474
 475     /* check parameters and get internal structure */
 476     if (file == NULL || buf == NULL || len < 1)
 477         return NULL;
 478     state = (gz_statep)file;
 479
 480     /* check that we're reading and that there's no (serious) error */
 481     if (state->mode != GZ_READ ||
 482         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 483         return NULL;
 484
 485     /* process a skip request */
 486     if (state->seek) {
 487         state->seek = 0;
 488         if (gz_skip(state, state->skip) == -1)
 489             return NULL;
 490     }
 491
 492     /* copy output bytes up to new line or len - 1, whichever comes first --
 493        append a terminating zero to the string (we don't check for a zero in
 494        the contents, let the user worry about that) */
 495     str = buf;
 496     left = (unsigned)len - 1;
 497     if (left) do {
 498         /* assure that something is in the output buffer */
 499         if (state->x.have == 0 && gz_fetch(state) == -1)
 500             return NULL;                /* error */
 501         if (state->x.have == 0) {       /* end of file */
 502             if (buf == str)             /* got bupkus */
 503                 return NULL;
 504             break;                      /* got something -- return it */
 505         }
 506
 507         /* look for end-of-line in current output buffer */
 508         n = state->x.have > left ? left : state->x.have;
 509         eol = memchr(state->x.next, '\n', n);
 510         if (eol != NULL)
 511             n = (unsigned)(eol - state->x.next) + 1;
 512
 513         /* copy through end-of-line, or remainder if not found */
 514         memcpy(buf, state->x.next, n);
 515         state->x.have -= n;
 516         state->x.next += n;
 517         state->x.pos += n;
 518         left -= n;
 519         buf += n;
 520     } while (left && eol == NULL);
 521
 522     /* found end-of-line or out of space -- terminate string and return it */
 523     buf[0] = 0;
 524     return str;
 525 }
 526
 527 /* -- see zlib.h -- */
 528 int ZEXPORT gzdirect(file)
 529     gzFile file;
 530 {
 531     gz_statep state;
 532
 533     /* get internal structure */
 534     if (file == NULL)
 535         return 0;
 536     state = (gz_statep)file;
 537
 538     /* check that we're reading */
 539     if (state->mode != GZ_READ)
 540         return 0;
 541
 542     /* if the state is not known, but we can find out, then do so (this is
 543        mainly for right after a gzopen() or gzdopen()) */
 544     if (state->how == LOOK && state->x.have == 0)
 545         (void)gz_look(state);
 546
 547     /* return 1 if reading direct, 0 if decompressing a gzip stream */
 548     return state->direct;
 549 }
 550
 551 /* -- see zlib.h -- */
 552 int ZEXPORT gzclose_r(file)
 553     gzFile file;
 554 {
 555     int ret;
 556     gz_statep state;
 557
 558     /* get internal structure */
 559     if (file == NULL)
 560         return Z_STREAM_ERROR;
 561     state = (gz_statep)file;
 562
 563     /* check that we're reading */
 564     if (state->mode != GZ_READ)
 565         return Z_STREAM_ERROR;
 566
 567     /* free memory and close file */
 568     if (state->size) {
 569         inflateEnd(&(state->strm));
 570         free(state->out);
 571         free(state->in);
 572     }
 573     gz_error(state, Z_OK, NULL);
 574     free(state->path);
 575     ret = close(state->fd);
 576     free(state);
 577     return ret ? Z_ERRNO : Z_OK;
 578 }