deps/libchdr/deps/zlib-1.3.1/gzread.c

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