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, save start of raw data for seeking, copy any leftover
 148        input to output -- this assumes that the output buffer is larger than
 149        the input buffer, which also assures space for gzungetc() */
 150     state->raw = state->pos;
 151     state->next = state->out;
 152     if (strm->avail_in) {
 153         memcpy(state->next, strm->next_in, strm->avail_in);
 154         state->have = strm->avail_in;
 155         strm->avail_in = 0;
 156     }
 157     state->how = COPY;
 158     state->direct = 1;
 159     return 0;
 160 }
 161
 162 /* Decompress from input to the provided next_out and avail_out in the state.
 163    state->have and state->next are set to point to the just decompressed data,
 164    If the gzip stream completes, state->how is reset to LOOK to look for the
 165    next gzip stream or raw data, once state->have is depleted.  Returns 0 on
 166    success, -1 on failure. */
 167 local int gz_decomp(state)
 168     gz_statep state;
 169 {
 170     int ret = Z_OK;
 171     unsigned had;
 172     z_streamp strm = &(state->strm);
 173
 174     /* fill output buffer up to end of deflate stream */
 175     had = strm->avail_out;
 176     do {
 177         /* get more input for inflate() */
 178         if (strm->avail_in == 0 && gz_avail(state) == -1)
 179             return -1;
 180         if (strm->avail_in == 0) {
 181             gz_error(state, Z_BUF_ERROR, "unexpected end of file");
 182             break;
 183         }
 184
 185         /* decompress and handle errors */
 186         ret = inflate(strm, Z_NO_FLUSH);
 187         if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
 188             gz_error(state, Z_STREAM_ERROR,
 189                      "internal error: inflate stream corrupt");
 190             return -1;
 191         }
 192         if (ret == Z_MEM_ERROR) {
 193             gz_error(state, Z_MEM_ERROR, "out of memory");
 194             return -1;
 195         }
 196         if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
 197             gz_error(state, Z_DATA_ERROR,
 198                      strm->msg == NULL ? "compressed data error" : strm->msg);
 199             return -1;
 200         }
 201     } while (strm->avail_out && ret != Z_STREAM_END);
 202
 203     /* update available output */
 204     state->have = had - strm->avail_out;
 205     state->next = strm->next_out - state->have;
 206
 207     /* if the gzip stream completed successfully, look for another */
 208     if (ret == Z_STREAM_END)
 209         state->how = LOOK;
 210
 211     /* good decompression */
 212     return 0;
 213 }
 214
 215 /* Fetch data and put it in the output buffer.  Assumes that state->have == 0.
 216    Data is either copied from the input file or decompressed from the input
 217    file depending on state->how.  If state->how is LOOK, then a gzip header is
 218    looked for to determine whether to copy or decompress.  Returns -1 on error,
 219    otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
 220    end of the input file has been reached and all data has been processed.  */
 221 local int gz_fetch(state)
 222     gz_statep state;
 223 {
 224     z_streamp strm = &(state->strm);
 225
 226     do {
 227         switch(state->how) {
 228         case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
 229             if (gz_look(state) == -1)
 230                 return -1;
 231             if (state->how == LOOK)
 232                 return 0;
 233             break;
 234         case COPY:      /* -> COPY */
 235             if (gz_load(state, state->out, state->size << 1, &(state->have))
 236                     == -1)
 237                 return -1;
 238             state->next = state->out;
 239             return 0;
 240         case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
 241             strm->avail_out = state->size << 1;
 242             strm->next_out = state->out;
 243             if (gz_decomp(state) == -1)
 244                 return -1;
 245         }
 246     } while (state->have == 0);
 247     return 0;
 248 }
 249
 250 /* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
 251 local int gz_skip(state, len)
 252     gz_statep state;
 253     z_off64_t len;
 254 {
 255     unsigned n;
 256
 257     /* skip over len bytes or reach end-of-file, whichever comes first */
 258     while (len)
 259         /* skip over whatever is in output buffer */
 260         if (state->have) {
 261             n = GT_OFF(state->have) || (z_off64_t)state->have > len ?
 262                 (unsigned)len : state->have;
 263             state->have -= n;
 264             state->next += n;
 265             state->pos += n;
 266             len -= n;
 267         }
 268
 269         /* output buffer empty -- return if we're at the end of the input */
 270         else if (state->eof && state->strm.avail_in == 0)
 271             break;
 272
 273         /* need more data to skip -- load up output buffer */
 274         else {
 275             /* get more output, looking for header if required */
 276             if (gz_fetch(state) == -1)
 277                 return -1;
 278         }
 279     return 0;
 280 }
 281
 282 /* -- see zlib.h -- */
 283 int ZEXPORT gzread(file, buf, len)
 284     gzFile file;
 285     voidp buf;
 286     unsigned len;
 287 {
 288     unsigned got, n;
 289     gz_statep state;
 290     z_streamp strm;
 291
 292     /* get internal structure */
 293     if (file == NULL)
 294         return -1;
 295     state = (gz_statep)file;
 296     strm = &(state->strm);
 297
 298     /* check that we're reading and that there's no (serious) error */
 299     if (state->mode != GZ_READ ||
 300             (state->err != Z_OK && state->err != Z_BUF_ERROR))
 301         return -1;
 302
 303     /* since an int is returned, make sure len fits in one, otherwise return
 304        with an error (this avoids the flaw in the interface) */
 305     if ((int)len < 0) {
 306         gz_error(state, Z_BUF_ERROR, "requested length does not fit in int");
 307         return -1;
 308     }
 309
 310     /* if len is zero, avoid unnecessary operations */
 311     if (len == 0)
 312         return 0;
 313
 314     /* process a skip request */
 315     if (state->seek) {
 316         state->seek = 0;
 317         if (gz_skip(state, state->skip) == -1)
 318             return -1;
 319     }
 320
 321     /* get len bytes to buf, or less than len if at the end */
 322     got = 0;
 323     do {
 324         /* first just try copying data from the output buffer */
 325         if (state->have) {
 326             n = state->have > len ? len : state->have;
 327             memcpy(buf, state->next, n);
 328             state->next += n;
 329             state->have -= n;
 330         }
 331
 332         /* output buffer empty -- return if we're at the end of the input */
 333         else if (state->eof && strm->avail_in == 0)
 334             break;
 335
 336         /* need output data -- for small len or new stream load up our output
 337            buffer */
 338         else if (state->how == LOOK || len < (state->size << 1)) {
 339             /* get more output, looking for header if required */
 340             if (gz_fetch(state) == -1)
 341                 return -1;
 342             continue;       /* no progress yet -- go back to memcpy() above */
 343             /* the copy above assures that we will leave with space in the
 344                output buffer, allowing at least one gzungetc() to succeed */
 345         }
 346
 347         /* large len -- read directly into user buffer */
 348         else if (state->how == COPY) {      /* read directly */
 349             if (gz_load(state, buf, len, &n) == -1)
 350                 return -1;
 351         }
 352
 353         /* large len -- decompress directly into user buffer */
 354         else {  /* state->how == GZIP */
 355             strm->avail_out = len;
 356             strm->next_out = buf;
 357             if (gz_decomp(state) == -1)
 358                 return -1;
 359             n = state->have;
 360             state->have = 0;
 361         }
 362
 363         /* update progress */
 364         len -= n;
 365         buf = (char *)buf + n;
 366         got += n;
 367         state->pos += n;
 368     } while (len);
 369
 370     /* return number of bytes read into user buffer (will fit in int) */
 371     return (int)got;
 372 }
 373
 374 /* -- see zlib.h -- */
 375 int ZEXPORT gzgetc(file)
 376     gzFile file;
 377 {
 378     int ret;
 379     unsigned char buf[1];
 380     gz_statep state;
 381
 382     /* get internal structure */
 383     if (file == NULL)
 384         return -1;
 385     state = (gz_statep)file;
 386
 387     /* check that we're reading and that there's no (serious) error */
 388     if (state->mode != GZ_READ ||
 389         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 390         return -1;
 391
 392     /* try output buffer (no need to check for skip request) */
 393     if (state->have) {
 394         state->have--;
 395         state->pos++;
 396         return *(state->next)++;
 397     }
 398
 399     /* nothing there -- try gzread() */
 400     ret = gzread(file, buf, 1);
 401     return ret < 1 ? -1 : buf[0];
 402 }
 403
 404 /* -- see zlib.h -- */
 405 int ZEXPORT gzungetc(c, file)
 406     int c;
 407     gzFile file;
 408 {
 409     gz_statep state;
 410
 411     /* get internal structure */
 412     if (file == NULL)
 413         return -1;
 414     state = (gz_statep)file;
 415
 416     /* check that we're reading and that there's no (serious) error */
 417     if (state->mode != GZ_READ ||
 418         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 419         return -1;
 420
 421     /* process a skip request */
 422     if (state->seek) {
 423         state->seek = 0;
 424         if (gz_skip(state, state->skip) == -1)
 425             return -1;
 426     }
 427
 428     /* can't push EOF */
 429     if (c < 0)
 430         return -1;
 431
 432     /* if output buffer empty, put byte at end (allows more pushing) */
 433     if (state->have == 0) {
 434         state->have = 1;
 435         state->next = state->out + (state->size << 1) - 1;
 436         state->next[0] = c;
 437         state->pos--;
 438         return c;
 439     }
 440
 441     /* if no room, give up (must have already done a gzungetc()) */
 442     if (state->have == (state->size << 1)) {
 443         gz_error(state, Z_BUF_ERROR, "out of room to push characters");
 444         return -1;
 445     }
 446
 447     /* slide output data if needed and insert byte before existing data */
 448     if (state->next == state->out) {
 449         unsigned char *src = state->out + state->have;
 450         unsigned char *dest = state->out + (state->size << 1);
 451         while (src > state->out)
 452             *--dest = *--src;
 453         state->next = dest;
 454     }
 455     state->have++;
 456     state->next--;
 457     state->next[0] = c;
 458     state->pos--;
 459     return c;
 460 }
 461
 462 /* -- see zlib.h -- */
 463 char * ZEXPORT gzgets(file, buf, len)
 464     gzFile file;
 465     char *buf;
 466     int len;
 467 {
 468     unsigned left, n;
 469     char *str;
 470     unsigned char *eol;
 471     gz_statep state;
 472
 473     /* check parameters and get internal structure */
 474     if (file == NULL || buf == NULL || len < 1)
 475         return NULL;
 476     state = (gz_statep)file;
 477
 478     /* check that we're reading and that there's no (serious) error */
 479     if (state->mode != GZ_READ ||
 480         (state->err != Z_OK && state->err != Z_BUF_ERROR))
 481         return NULL;
 482
 483     /* process a skip request */
 484     if (state->seek) {
 485         state->seek = 0;
 486         if (gz_skip(state, state->skip) == -1)
 487             return NULL;
 488     }
 489
 490     /* copy output bytes up to new line or len - 1, whichever comes first --
 491        append a terminating zero to the string (we don't check for a zero in
 492        the contents, let the user worry about that) */
 493     str = buf;
 494     left = (unsigned)len - 1;
 495     if (left) do {
 496         /* assure that something is in the output buffer */
 497         if (state->have == 0 && gz_fetch(state) == -1)
 498             return NULL;                /* error */
 499         if (state->have == 0) {         /* end of file */
 500             if (buf == str)             /* got bupkus */
 501                 return NULL;
 502             break;                      /* got something -- return it */
 503         }
 504
 505         /* look for end-of-line in current output buffer */
 506         n = state->have > left ? left : state->have;
 507         eol = memchr(state->next, '\n', n);
 508         if (eol != NULL)
 509             n = (unsigned)(eol - state->next) + 1;
 510
 511         /* copy through end-of-line, or remainder if not found */
 512         memcpy(buf, state->next, n);
 513         state->have -= n;
 514         state->next += n;
 515         state->pos += n;
 516         left -= n;
 517         buf += n;
 518     } while (left && eol == NULL);
 519
 520     /* found end-of-line or out of space -- terminate string and return it */
 521     buf[0] = 0;
 522     return str;
 523 }
 524
 525 /* -- see zlib.h -- */
 526 int ZEXPORT gzdirect(file)
 527     gzFile file;
 528 {
 529     gz_statep state;
 530
 531     /* get internal structure */
 532     if (file == NULL)
 533         return 0;
 534     state = (gz_statep)file;
 535
 536     /* check that we're reading */
 537     if (state->mode != GZ_READ)
 538         return 0;
 539
 540     /* if the state is not known, but we can find out, then do so (this is
 541        mainly for right after a gzopen() or gzdopen()) */
 542     if (state->how == LOOK && state->have == 0)
 543         (void)gz_look(state);
 544
 545     /* return 1 if reading direct, 0 if decompressing a gzip stream */
 546     return state->direct;
 547 }
 548
 549 /* -- see zlib.h -- */
 550 int ZEXPORT gzclose_r(file)
 551     gzFile file;
 552 {
 553     int ret;
 554     gz_statep state;
 555
 556     /* get internal structure */
 557     if (file == NULL)
 558         return Z_STREAM_ERROR;
 559     state = (gz_statep)file;
 560
 561     /* check that we're reading */
 562     if (state->mode != GZ_READ)
 563         return Z_STREAM_ERROR;
 564
 565     /* free memory and close file */
 566     if (state->size) {
 567         inflateEnd(&(state->strm));
 568         free(state->out);
 569         free(state->in);
 570     }
 571     gz_error(state, Z_OK, NULL);
 572     free(state->path);
 573     ret = close(state->fd);
 574     free(state);
 575     return ret ? Z_ERRNO : Z_OK;
 576 }