Annotation of embedaddon/sudo/zlib/gzread.c, revision 1.1
1.1 ! misho 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_next4 OF((gz_statep, unsigned long *));
! 12: local int gz_head OF((gz_statep));
! 13: local int gz_decomp OF((gz_statep));
! 14: local int gz_make OF((gz_statep));
! 15: local int gz_skip OF((gz_statep, z_off64_t));
! 16:
! 17: /* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
! 18: state->fd, and update state->eof, state->err, and state->msg as appropriate.
! 19: This function needs to loop on read(), since read() is not guaranteed to
! 20: read the number of bytes requested, depending on the type of descriptor. */
! 21: local int gz_load(state, buf, len, have)
! 22: gz_statep state;
! 23: unsigned char *buf;
! 24: unsigned len;
! 25: unsigned *have;
! 26: {
! 27: int ret;
! 28:
! 29: *have = 0;
! 30: do {
! 31: ret = read(state->fd, buf + *have, len - *have);
! 32: if (ret <= 0)
! 33: break;
! 34: *have += ret;
! 35: } while (*have < len);
! 36: if (ret < 0) {
! 37: gz_error(state, Z_ERRNO, zstrerror());
! 38: return -1;
! 39: }
! 40: if (ret == 0)
! 41: state->eof = 1;
! 42: return 0;
! 43: }
! 44:
! 45: /* Load up input buffer and set eof flag if last data loaded -- return -1 on
! 46: error, 0 otherwise. Note that the eof flag is set when the end of the input
! 47: file is reached, even though there may be unused data in the buffer. Once
! 48: that data has been used, no more attempts will be made to read the file.
! 49: gz_avail() assumes that strm->avail_in == 0. */
! 50: local int gz_avail(state)
! 51: gz_statep state;
! 52: {
! 53: z_streamp strm = &(state->strm);
! 54:
! 55: if (state->err != Z_OK)
! 56: return -1;
! 57: if (state->eof == 0) {
! 58: if (gz_load(state, state->in, state->size,
! 59: (unsigned *)&(strm->avail_in)) == -1)
! 60: return -1;
! 61: strm->next_in = state->in;
! 62: }
! 63: return 0;
! 64: }
! 65:
! 66: /* Get next byte from input, or -1 if end or error. */
! 67: #define NEXT() ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \
! 68: (strm->avail_in == 0 ? -1 : \
! 69: (strm->avail_in--, *(strm->next_in)++)))
! 70:
! 71: /* Get a four-byte little-endian integer and return 0 on success and the value
! 72: in *ret. Otherwise -1 is returned and *ret is not modified. */
! 73: local int gz_next4(state, ret)
! 74: gz_statep state;
! 75: unsigned long *ret;
! 76: {
! 77: int ch;
! 78: unsigned long val;
! 79: z_streamp strm = &(state->strm);
! 80:
! 81: val = NEXT();
! 82: val += (unsigned)NEXT() << 8;
! 83: val += (unsigned long)NEXT() << 16;
! 84: ch = NEXT();
! 85: if (ch == -1)
! 86: return -1;
! 87: val += (unsigned long)ch << 24;
! 88: *ret = val;
! 89: return 0;
! 90: }
! 91:
! 92: /* Look for gzip header, set up for inflate or copy. state->have must be zero.
! 93: If this is the first time in, allocate required memory. state->how will be
! 94: left unchanged if there is no more input data available, will be set to COPY
! 95: if there is no gzip header and direct copying will be performed, or it will
! 96: be set to GZIP for decompression, and the gzip header will be skipped so
! 97: that the next available input data is the raw deflate stream. If direct
! 98: copying, then leftover input data from the input buffer will be copied to
! 99: the output buffer. In that case, all further file reads will be directly to
! 100: either the output buffer or a user buffer. If decompressing, the inflate
! 101: state and the check value will be initialized. gz_head() will return 0 on
! 102: success or -1 on failure. Failures may include read errors or gzip header
! 103: errors. */
! 104: local int gz_head(state)
! 105: gz_statep state;
! 106: {
! 107: z_streamp strm = &(state->strm);
! 108: int flags;
! 109: unsigned len;
! 110:
! 111: /* allocate read buffers and inflate memory */
! 112: if (state->size == 0) {
! 113: /* allocate buffers */
! 114: state->in = malloc(state->want);
! 115: state->out = malloc(state->want << 1);
! 116: if (state->in == NULL || state->out == NULL) {
! 117: if (state->out != NULL)
! 118: free(state->out);
! 119: if (state->in != NULL)
! 120: free(state->in);
! 121: gz_error(state, Z_MEM_ERROR, "out of memory");
! 122: return -1;
! 123: }
! 124: state->size = state->want;
! 125:
! 126: /* allocate inflate memory */
! 127: state->strm.zalloc = Z_NULL;
! 128: state->strm.zfree = Z_NULL;
! 129: state->strm.opaque = Z_NULL;
! 130: state->strm.avail_in = 0;
! 131: state->strm.next_in = Z_NULL;
! 132: if (inflateInit2(&(state->strm), -15) != Z_OK) { /* raw inflate */
! 133: free(state->out);
! 134: free(state->in);
! 135: state->size = 0;
! 136: gz_error(state, Z_MEM_ERROR, "out of memory");
! 137: return -1;
! 138: }
! 139: }
! 140:
! 141: /* get some data in the input buffer */
! 142: if (strm->avail_in == 0) {
! 143: if (gz_avail(state) == -1)
! 144: return -1;
! 145: if (strm->avail_in == 0)
! 146: return 0;
! 147: }
! 148:
! 149: /* look for the gzip magic header bytes 31 and 139 */
! 150: if (strm->next_in[0] == 31) {
! 151: strm->avail_in--;
! 152: strm->next_in++;
! 153: if (strm->avail_in == 0 && gz_avail(state) == -1)
! 154: return -1;
! 155: if (strm->avail_in && strm->next_in[0] == 139) {
! 156: /* we have a gzip header, woo hoo! */
! 157: strm->avail_in--;
! 158: strm->next_in++;
! 159:
! 160: /* skip rest of header */
! 161: if (NEXT() != 8) { /* compression method */
! 162: gz_error(state, Z_DATA_ERROR, "unknown compression method");
! 163: return -1;
! 164: }
! 165: flags = NEXT();
! 166: if (flags & 0xe0) { /* reserved flag bits */
! 167: gz_error(state, Z_DATA_ERROR, "unknown header flags set");
! 168: return -1;
! 169: }
! 170: NEXT(); /* modification time */
! 171: NEXT();
! 172: NEXT();
! 173: NEXT();
! 174: NEXT(); /* extra flags */
! 175: NEXT(); /* operating system */
! 176: if (flags & 4) { /* extra field */
! 177: len = (unsigned)NEXT();
! 178: len += (unsigned)NEXT() << 8;
! 179: while (len--)
! 180: if (NEXT() < 0)
! 181: break;
! 182: }
! 183: if (flags & 8) /* file name */
! 184: while (NEXT() > 0)
! 185: ;
! 186: if (flags & 16) /* comment */
! 187: while (NEXT() > 0)
! 188: ;
! 189: if (flags & 2) { /* header crc */
! 190: NEXT();
! 191: NEXT();
! 192: }
! 193: /* an unexpected end of file is not checked for here -- it will be
! 194: noticed on the first request for uncompressed data */
! 195:
! 196: /* set up for decompression */
! 197: inflateReset(strm);
! 198: strm->adler = crc32(0L, Z_NULL, 0);
! 199: state->how = GZIP;
! 200: state->direct = 0;
! 201: return 0;
! 202: }
! 203: else {
! 204: /* not a gzip file -- save first byte (31) and fall to raw i/o */
! 205: state->out[0] = 31;
! 206: state->have = 1;
! 207: }
! 208: }
! 209:
! 210: /* doing raw i/o, save start of raw data for seeking, copy any leftover
! 211: input to output -- this assumes that the output buffer is larger than
! 212: the input buffer, which also assures space for gzungetc() */
! 213: state->raw = state->pos;
! 214: state->next = state->out;
! 215: if (strm->avail_in) {
! 216: memcpy(state->next + state->have, strm->next_in, strm->avail_in);
! 217: state->have += strm->avail_in;
! 218: strm->avail_in = 0;
! 219: }
! 220: state->how = COPY;
! 221: state->direct = 1;
! 222: return 0;
! 223: }
! 224:
! 225: /* Decompress from input to the provided next_out and avail_out in the state.
! 226: If the end of the compressed data is reached, then verify the gzip trailer
! 227: check value and length (modulo 2^32). state->have and state->next are set
! 228: to point to the just decompressed data, and the crc is updated. If the
! 229: trailer is verified, state->how is reset to LOOK to look for the next gzip
! 230: stream or raw data, once state->have is depleted. Returns 0 on success, -1
! 231: on failure. Failures may include invalid compressed data or a failed gzip
! 232: trailer verification. */
! 233: local int gz_decomp(state)
! 234: gz_statep state;
! 235: {
! 236: int ret;
! 237: unsigned had;
! 238: unsigned long crc, len;
! 239: z_streamp strm = &(state->strm);
! 240:
! 241: /* fill output buffer up to end of deflate stream */
! 242: had = strm->avail_out;
! 243: do {
! 244: /* get more input for inflate() */
! 245: if (strm->avail_in == 0 && gz_avail(state) == -1)
! 246: return -1;
! 247: if (strm->avail_in == 0) {
! 248: gz_error(state, Z_DATA_ERROR, "unexpected end of file");
! 249: return -1;
! 250: }
! 251:
! 252: /* decompress and handle errors */
! 253: ret = inflate(strm, Z_NO_FLUSH);
! 254: if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
! 255: gz_error(state, Z_STREAM_ERROR,
! 256: "internal error: inflate stream corrupt");
! 257: return -1;
! 258: }
! 259: if (ret == Z_MEM_ERROR) {
! 260: gz_error(state, Z_MEM_ERROR, "out of memory");
! 261: return -1;
! 262: }
! 263: if (ret == Z_DATA_ERROR) { /* deflate stream invalid */
! 264: gz_error(state, Z_DATA_ERROR,
! 265: strm->msg == NULL ? "compressed data error" : strm->msg);
! 266: return -1;
! 267: }
! 268: } while (strm->avail_out && ret != Z_STREAM_END);
! 269:
! 270: /* update available output and crc check value */
! 271: state->have = had - strm->avail_out;
! 272: state->next = strm->next_out - state->have;
! 273: strm->adler = crc32(strm->adler, state->next, state->have);
! 274:
! 275: /* check gzip trailer if at end of deflate stream */
! 276: if (ret == Z_STREAM_END) {
! 277: if (gz_next4(state, &crc) == -1 || gz_next4(state, &len) == -1) {
! 278: gz_error(state, Z_DATA_ERROR, "unexpected end of file");
! 279: return -1;
! 280: }
! 281: if (crc != strm->adler) {
! 282: gz_error(state, Z_DATA_ERROR, "incorrect data check");
! 283: return -1;
! 284: }
! 285: if (len != (strm->total_out & 0xffffffffL)) {
! 286: gz_error(state, Z_DATA_ERROR, "incorrect length check");
! 287: return -1;
! 288: }
! 289: state->how = LOOK; /* ready for next stream, once have is 0 (leave
! 290: state->direct unchanged to remember how) */
! 291: }
! 292:
! 293: /* good decompression */
! 294: return 0;
! 295: }
! 296:
! 297: /* Make data and put in the output buffer. Assumes that state->have == 0.
! 298: Data is either copied from the input file or decompressed from the input
! 299: file depending on state->how. If state->how is LOOK, then a gzip header is
! 300: looked for (and skipped if found) to determine wither to copy or decompress.
! 301: Returns -1 on error, otherwise 0. gz_make() will leave state->have as COPY
! 302: or GZIP unless the end of the input file has been reached and all data has
! 303: been processed. */
! 304: local int gz_make(state)
! 305: gz_statep state;
! 306: {
! 307: z_streamp strm = &(state->strm);
! 308:
! 309: if (state->how == LOOK) { /* look for gzip header */
! 310: if (gz_head(state) == -1)
! 311: return -1;
! 312: if (state->have) /* got some data from gz_head() */
! 313: return 0;
! 314: }
! 315: if (state->how == COPY) { /* straight copy */
! 316: if (gz_load(state, state->out, state->size << 1, &(state->have)) == -1)
! 317: return -1;
! 318: state->next = state->out;
! 319: }
! 320: else if (state->how == GZIP) { /* decompress */
! 321: strm->avail_out = state->size << 1;
! 322: strm->next_out = state->out;
! 323: if (gz_decomp(state) == -1)
! 324: return -1;
! 325: }
! 326: return 0;
! 327: }
! 328:
! 329: /* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */
! 330: local int gz_skip(state, len)
! 331: gz_statep state;
! 332: z_off64_t len;
! 333: {
! 334: unsigned n;
! 335:
! 336: /* skip over len bytes or reach end-of-file, whichever comes first */
! 337: while (len)
! 338: /* skip over whatever is in output buffer */
! 339: if (state->have) {
! 340: n = GT_OFF(state->have) || (z_off64_t)state->have > len ?
! 341: (unsigned)len : state->have;
! 342: state->have -= n;
! 343: state->next += n;
! 344: state->pos += n;
! 345: len -= n;
! 346: }
! 347:
! 348: /* output buffer empty -- return if we're at the end of the input */
! 349: else if (state->eof && state->strm.avail_in == 0)
! 350: break;
! 351:
! 352: /* need more data to skip -- load up output buffer */
! 353: else {
! 354: /* get more output, looking for header if required */
! 355: if (gz_make(state) == -1)
! 356: return -1;
! 357: }
! 358: return 0;
! 359: }
! 360:
! 361: /* -- see zlib.h -- */
! 362: int ZEXPORT gzread(file, buf, len)
! 363: gzFile file;
! 364: voidp buf;
! 365: unsigned len;
! 366: {
! 367: unsigned got, n;
! 368: gz_statep state;
! 369: z_streamp strm;
! 370:
! 371: /* get internal structure */
! 372: if (file == NULL)
! 373: return -1;
! 374: state = (gz_statep)file;
! 375: strm = &(state->strm);
! 376:
! 377: /* check that we're reading and that there's no error */
! 378: if (state->mode != GZ_READ || state->err != Z_OK)
! 379: return -1;
! 380:
! 381: /* since an int is returned, make sure len fits in one, otherwise return
! 382: with an error (this avoids the flaw in the interface) */
! 383: if ((int)len < 0) {
! 384: gz_error(state, Z_BUF_ERROR, "requested length does not fit in int");
! 385: return -1;
! 386: }
! 387:
! 388: /* if len is zero, avoid unnecessary operations */
! 389: if (len == 0)
! 390: return 0;
! 391:
! 392: /* process a skip request */
! 393: if (state->seek) {
! 394: state->seek = 0;
! 395: if (gz_skip(state, state->skip) == -1)
! 396: return -1;
! 397: }
! 398:
! 399: /* get len bytes to buf, or less than len if at the end */
! 400: got = 0;
! 401: do {
! 402: /* first just try copying data from the output buffer */
! 403: if (state->have) {
! 404: n = state->have > len ? len : state->have;
! 405: memcpy(buf, state->next, n);
! 406: state->next += n;
! 407: state->have -= n;
! 408: }
! 409:
! 410: /* output buffer empty -- return if we're at the end of the input */
! 411: else if (state->eof && strm->avail_in == 0)
! 412: break;
! 413:
! 414: /* need output data -- for small len or new stream load up our output
! 415: buffer */
! 416: else if (state->how == LOOK || len < (state->size << 1)) {
! 417: /* get more output, looking for header if required */
! 418: if (gz_make(state) == -1)
! 419: return -1;
! 420: continue; /* no progress yet -- go back to memcpy() above */
! 421: /* the copy above assures that we will leave with space in the
! 422: output buffer, allowing at least one gzungetc() to succeed */
! 423: }
! 424:
! 425: /* large len -- read directly into user buffer */
! 426: else if (state->how == COPY) { /* read directly */
! 427: if (gz_load(state, buf, len, &n) == -1)
! 428: return -1;
! 429: }
! 430:
! 431: /* large len -- decompress directly into user buffer */
! 432: else { /* state->how == GZIP */
! 433: strm->avail_out = len;
! 434: strm->next_out = buf;
! 435: if (gz_decomp(state) == -1)
! 436: return -1;
! 437: n = state->have;
! 438: state->have = 0;
! 439: }
! 440:
! 441: /* update progress */
! 442: len -= n;
! 443: buf = (char *)buf + n;
! 444: got += n;
! 445: state->pos += n;
! 446: } while (len);
! 447:
! 448: /* return number of bytes read into user buffer (will fit in int) */
! 449: return (int)got;
! 450: }
! 451:
! 452: /* -- see zlib.h -- */
! 453: int ZEXPORT gzgetc(file)
! 454: gzFile file;
! 455: {
! 456: int ret;
! 457: unsigned char buf[1];
! 458: gz_statep state;
! 459:
! 460: /* get internal structure */
! 461: if (file == NULL)
! 462: return -1;
! 463: state = (gz_statep)file;
! 464:
! 465: /* check that we're reading and that there's no error */
! 466: if (state->mode != GZ_READ || state->err != Z_OK)
! 467: return -1;
! 468:
! 469: /* try output buffer (no need to check for skip request) */
! 470: if (state->have) {
! 471: state->have--;
! 472: state->pos++;
! 473: return *(state->next)++;
! 474: }
! 475:
! 476: /* nothing there -- try gzread() */
! 477: ret = gzread(file, buf, 1);
! 478: return ret < 1 ? -1 : buf[0];
! 479: }
! 480:
! 481: /* -- see zlib.h -- */
! 482: int ZEXPORT gzungetc(c, file)
! 483: int c;
! 484: gzFile file;
! 485: {
! 486: gz_statep state;
! 487:
! 488: /* get internal structure */
! 489: if (file == NULL)
! 490: return -1;
! 491: state = (gz_statep)file;
! 492:
! 493: /* check that we're reading and that there's no error */
! 494: if (state->mode != GZ_READ || state->err != Z_OK)
! 495: return -1;
! 496:
! 497: /* process a skip request */
! 498: if (state->seek) {
! 499: state->seek = 0;
! 500: if (gz_skip(state, state->skip) == -1)
! 501: return -1;
! 502: }
! 503:
! 504: /* can't push EOF */
! 505: if (c < 0)
! 506: return -1;
! 507:
! 508: /* if output buffer empty, put byte at end (allows more pushing) */
! 509: if (state->have == 0) {
! 510: state->have = 1;
! 511: state->next = state->out + (state->size << 1) - 1;
! 512: state->next[0] = c;
! 513: state->pos--;
! 514: return c;
! 515: }
! 516:
! 517: /* if no room, give up (must have already done a gzungetc()) */
! 518: if (state->have == (state->size << 1)) {
! 519: gz_error(state, Z_BUF_ERROR, "out of room to push characters");
! 520: return -1;
! 521: }
! 522:
! 523: /* slide output data if needed and insert byte before existing data */
! 524: if (state->next == state->out) {
! 525: unsigned char *src = state->out + state->have;
! 526: unsigned char *dest = state->out + (state->size << 1);
! 527: while (src > state->out)
! 528: *--dest = *--src;
! 529: state->next = dest;
! 530: }
! 531: state->have++;
! 532: state->next--;
! 533: state->next[0] = c;
! 534: state->pos--;
! 535: return c;
! 536: }
! 537:
! 538: /* -- see zlib.h -- */
! 539: char * ZEXPORT gzgets(file, buf, len)
! 540: gzFile file;
! 541: char *buf;
! 542: int len;
! 543: {
! 544: unsigned left, n;
! 545: char *str;
! 546: unsigned char *eol;
! 547: gz_statep state;
! 548:
! 549: /* check parameters and get internal structure */
! 550: if (file == NULL || buf == NULL || len < 1)
! 551: return NULL;
! 552: state = (gz_statep)file;
! 553:
! 554: /* check that we're reading and that there's no error */
! 555: if (state->mode != GZ_READ || state->err != Z_OK)
! 556: return NULL;
! 557:
! 558: /* process a skip request */
! 559: if (state->seek) {
! 560: state->seek = 0;
! 561: if (gz_skip(state, state->skip) == -1)
! 562: return NULL;
! 563: }
! 564:
! 565: /* copy output bytes up to new line or len - 1, whichever comes first --
! 566: append a terminating zero to the string (we don't check for a zero in
! 567: the contents, let the user worry about that) */
! 568: str = buf;
! 569: left = (unsigned)len - 1;
! 570: if (left) do {
! 571: /* assure that something is in the output buffer */
! 572: if (state->have == 0) {
! 573: if (gz_make(state) == -1)
! 574: return NULL; /* error */
! 575: if (state->have == 0) { /* end of file */
! 576: if (buf == str) /* got bupkus */
! 577: return NULL;
! 578: break; /* got something -- return it */
! 579: }
! 580: }
! 581:
! 582: /* look for end-of-line in current output buffer */
! 583: n = state->have > left ? left : state->have;
! 584: eol = memchr(state->next, '\n', n);
! 585: if (eol != NULL)
! 586: n = (unsigned)(eol - state->next) + 1;
! 587:
! 588: /* copy through end-of-line, or remainder if not found */
! 589: memcpy(buf, state->next, n);
! 590: state->have -= n;
! 591: state->next += n;
! 592: state->pos += n;
! 593: left -= n;
! 594: buf += n;
! 595: } while (left && eol == NULL);
! 596:
! 597: /* found end-of-line or out of space -- terminate string and return it */
! 598: buf[0] = 0;
! 599: return str;
! 600: }
! 601:
! 602: /* -- see zlib.h -- */
! 603: int ZEXPORT gzdirect(file)
! 604: gzFile file;
! 605: {
! 606: gz_statep state;
! 607:
! 608: /* get internal structure */
! 609: if (file == NULL)
! 610: return 0;
! 611: state = (gz_statep)file;
! 612:
! 613: /* check that we're reading */
! 614: if (state->mode != GZ_READ)
! 615: return 0;
! 616:
! 617: /* if the state is not known, but we can find out, then do so (this is
! 618: mainly for right after a gzopen() or gzdopen()) */
! 619: if (state->how == LOOK && state->have == 0)
! 620: (void)gz_head(state);
! 621:
! 622: /* return 1 if reading direct, 0 if decompressing a gzip stream */
! 623: return state->direct;
! 624: }
! 625:
! 626: /* -- see zlib.h -- */
! 627: int ZEXPORT gzclose_r(file)
! 628: gzFile file;
! 629: {
! 630: int ret;
! 631: gz_statep state;
! 632:
! 633: /* get internal structure */
! 634: if (file == NULL)
! 635: return Z_STREAM_ERROR;
! 636: state = (gz_statep)file;
! 637:
! 638: /* check that we're reading */
! 639: if (state->mode != GZ_READ)
! 640: return Z_STREAM_ERROR;
! 641:
! 642: /* free memory and close file */
! 643: if (state->size) {
! 644: inflateEnd(&(state->strm));
! 645: free(state->out);
! 646: free(state->in);
! 647: }
! 648: gz_error(state, Z_OK, NULL);
! 649: free(state->path);
! 650: ret = close(state->fd);
! 651: free(state);
! 652: return ret ? Z_ERRNO : Z_OK;
! 653: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gzread.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / zlib