CommonLibs/zlib-1.2.8/gzread.c

/* gzread.c -- zlib functions for reading gzip files
 * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

#include "gzguts.h"

/* Local functions */
local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
local int gz_avail OF((gz_statep));
local int gz_look OF((gz_statep));
local int gz_decomp OF((gz_statep));
local int gz_fetch OF((gz_statep));
local int gz_skip OF((gz_statep, z_off64_t));

/* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
   state->fd, and update state->eof, state->err, and state->msg as appropriate.
   This function needs to loop on read(), since read() is not guaranteed to
   read the number of bytes requested, depending on the type of descriptor. */
local int gz_load(state, buf, len, have)
    gz_statep state;
    unsigned char *buf;
    unsigned len;
    unsigned *have;
{
    int ret;

    *have = 0;
    do {
        ret = read(state->fd, buf + *have, len - *have);
        if (ret <= 0)
            break;
        *have += ret;
    } while (*have < len);
    if (ret < 0) {
        gz_error(state, Z_ERRNO, zstrerror());
        return -1;
    }
    if (ret == 0)
        state->eof = 1;
    return 0;
}

/* Load up input buffer and set eof flag if last data loaded -- return -1 on
   error, 0 otherwise.  Note that the eof flag is set when the end of the input
   file is reached, even though there may be unused data in the buffer.  Once
   that data has been used, no more attempts will be made to read the file.
   If strm->avail_in != 0, then the current data is moved to the beginning of
   the input buffer, and then the remainder of the buffer is loaded with the
   available data from the input file. */
local int gz_avail(state)
    gz_statep state;
{
    unsigned got;
    z_streamp strm = &(state->strm);

    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
        return -1;
    if (state->eof == 0) {
        if (strm->avail_in) {       /* copy what's there to the start */
            unsigned char *p = state->in;
            unsigned const char *q = strm->next_in;
            unsigned n = strm->avail_in;
            do {
                *p++ = *q++;
            } while (--n);
        }
        if (gz_load(state, state->in + strm->avail_in,
                    state->size - strm->avail_in, &got) == -1)
            return -1;
        strm->avail_in += got;
        strm->next_in = state->in;
    }
    return 0;
}

/* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
   If this is the first time in, allocate required memory.  state->how will be
   left unchanged if there is no more input data available, will be set to COPY
   if there is no gzip header and direct copying will be performed, or it will
   be set to GZIP for decompression.  If direct copying, then leftover input
   data from the input buffer will be copied to the output buffer.  In that
   case, all further file reads will be directly to either the output buffer or
   a user buffer.  If decompressing, the inflate state will be initialized.
   gz_look() will return 0 on success or -1 on failure. */
local int gz_look(state)
    gz_statep state;
{
    z_streamp strm = &(state->strm);

    /* allocate read buffers and inflate memory */
    if (state->size == 0) {
        /* allocate buffers */
        state->in = (unsigned char *)malloc(state->want);
        state->out = (unsigned char *)malloc(state->want << 1);
        if (state->in == NULL || state->out == NULL) {
            if (state->out != NULL)
                free(state->out);
            if (state->in != NULL)
                free(state->in);
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
        state->size = state->want;

        /* allocate inflate memory */
        state->strm.zalloc = Z_NULL;
        state->strm.zfree = Z_NULL;
        state->strm.opaque = Z_NULL;
        state->strm.avail_in = 0;
        state->strm.next_in = Z_NULL;
        if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
            free(state->out);
            free(state->in);
            state->size = 0;
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
    }

    /* get at least the magic bytes in the input buffer */
    if (strm->avail_in < 2) {
        if (gz_avail(state) == -1)
            return -1;
        if (strm->avail_in == 0)
            return 0;
    }

    /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
       a logical dilemma here when considering the case of a partially written
       gzip file, to wit, if a single 31 byte is written, then we cannot tell
       whether this is a single-byte file, or just a partially written gzip
       file -- for here we assume that if a gzip file is being written, then
       the header will be written in a single operation, so that reading a
       single byte is sufficient indication that it is not a gzip file) */
    if (strm->avail_in > 1 &&
            strm->next_in[0] == 31 && strm->next_in[1] == 139) {
        inflateReset(strm);
        state->how = GZIP;
        state->direct = 0;
        return 0;
    }

    /* no gzip header -- if we were decoding gzip before, then this is trailing
       garbage.  Ignore the trailing garbage and finish. */
    if (state->direct == 0) {
        strm->avail_in = 0;
        state->eof = 1;
        state->x.have = 0;
        return 0;
    }

    /* doing raw i/o, copy any leftover input to output -- this assumes that
       the output buffer is larger than the input buffer, which also assures
       space for gzungetc() */
    state->x.next = state->out;
    if (strm->avail_in) {
        memcpy(state->x.next, strm->next_in, strm->avail_in);
        state->x.have = strm->avail_in;
        strm->avail_in = 0;
    }
    state->how = COPY;
    state->direct = 1;
    return 0;
}

/* Decompress from input to the provided next_out and avail_out in the state.
   On return, state->x.have and state->x.next point to the just decompressed
   data.  If the gzip stream completes, state->how is reset to LOOK to look for
   the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
   on success, -1 on failure. */
local int gz_decomp(state)
    gz_statep state;
{
    int ret = Z_OK;
    unsigned had;
    z_streamp strm = &(state->strm);

    /* fill output buffer up to end of deflate stream */
    had = strm->avail_out;
    do {
        /* get more input for inflate() */
        if (strm->avail_in == 0 && gz_avail(state) == -1)
            return -1;
        if (strm->avail_in == 0) {
            gz_error(state, Z_BUF_ERROR, "unexpected end of file");
            break;
        }

        /* decompress and handle errors */
        ret = inflate(strm, Z_NO_FLUSH);
        if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
            gz_error(state, Z_STREAM_ERROR,
                     "internal error: inflate stream corrupt");
            return -1;
        }
        if (ret == Z_MEM_ERROR) {
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
        if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
            gz_error(state, Z_DATA_ERROR,
                     strm->msg == NULL ? "compressed data error" : strm->msg);
            return -1;
        }
    } while (strm->avail_out && ret != Z_STREAM_END);

    /* update available output */
    state->x.have = had - strm->avail_out;
    state->x.next = strm->next_out - state->x.have;

    /* if the gzip stream completed successfully, look for another */
    if (ret == Z_STREAM_END)
        state->how = LOOK;

    /* good decompression */
    return 0;
}

/* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
   Data is either copied from the input file or decompressed from the input
   file depending on state->how.  If state->how is LOOK, then a gzip header is
   looked for to determine whether to copy or decompress.  Returns -1 on error,
   otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
   end of the input file has been reached and all data has been processed.  */
local int gz_fetch(state)
    gz_statep state;
{
    z_streamp strm = &(state->strm);

    do {
        switch(state->how) {
        case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
            if (gz_look(state) == -1)
                return -1;
            if (state->how == LOOK)
                return 0;
            break;
        case COPY:      /* -> COPY */
            if (gz_load(state, state->out, state->size << 1, &(state->x.have))
                    == -1)
                return -1;
            state->x.next = state->out;
            return 0;
        case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
            strm->avail_out = state->size << 1;
            strm->next_out = state->out;
            if (gz_decomp(state) == -1)
                return -1;
        }
    } while (state->x.have == 0 && (!state->eof || strm->avail_in));
    return 0;
}

/* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
local int gz_skip(state, len)
    gz_statep state;
    z_off64_t len;
{
    unsigned n;

    /* skip over len bytes or reach end-of-file, whichever comes first */
    while (len)
        /* skip over whatever is in output buffer */
        if (state->x.have) {
            n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
                (unsigned)len : state->x.have;
            state->x.have -= n;
            state->x.next += n;
            state->x.pos += n;
            len -= n;
        }

        /* output buffer empty -- return if we're at the end of the input */
        else if (state->eof && state->strm.avail_in == 0)
            break;

        /* need more data to skip -- load up output buffer */
        else {
            /* get more output, looking for header if required */
            if (gz_fetch(state) == -1)
                return -1;
        }
    return 0;
}

/* -- see zlib.h -- */
int ZEXPORT gzread(file, buf, len)
    gzFile file;
    voidp buf;
    unsigned len;
{
    unsigned got, n;
    gz_statep state;
    z_streamp strm;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;
    strm = &(state->strm);

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
            (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* since an int is returned, make sure len fits in one, otherwise return
       with an error (this avoids the flaw in the interface) */
    if ((int)len < 0) {
        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
        return -1;
    }

    /* if len is zero, avoid unnecessary operations */
    if (len == 0)
        return 0;

    /* process a skip request */
    if (state->seek) {
        state->seek = 0;
        if (gz_skip(state, state->skip) == -1)
            return -1;
    }

    /* get len bytes to buf, or less than len if at the end */
    got = 0;
    do {
        /* first just try copying data from the output buffer */
        if (state->x.have) {
            n = state->x.have > len ? len : state->x.have;
            memcpy(buf, state->x.next, n);
            state->x.next += n;
            state->x.have -= n;
        }

        /* output buffer empty -- return if we're at the end of the input */
        else if (state->eof && strm->avail_in == 0) {
            state->past = 1;        /* tried to read past end */
            break;
        }

        /* need output data -- for small len or new stream load up our output
           buffer */
        else if (state->how == LOOK || len < (state->size << 1)) {
            /* get more output, looking for header if required */
            if (gz_fetch(state) == -1)
                return -1;
            continue;       /* no progress yet -- go back to copy above */
            /* the copy above assures that we will leave with space in the
               output buffer, allowing at least one gzungetc() to succeed */
        }

        /* large len -- read directly into user buffer */
        else if (state->how == COPY) {      /* read directly */
            if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
                return -1;
        }

        /* large len -- decompress directly into user buffer */
        else {  /* state->how == GZIP */
            strm->avail_out = len;
            strm->next_out = (unsigned char *)buf;
            if (gz_decomp(state) == -1)
                return -1;
            n = state->x.have;
            state->x.have = 0;
        }

        /* update progress */
        len -= n;
        buf = (char *)buf + n;
        got += n;
        state->x.pos += n;
    } while (len);

    /* return number of bytes read into user buffer (will fit in int) */
    return (int)got;
}

/* -- see zlib.h -- */
#ifdef Z_PREFIX_SET
#  undef z_gzgetc
#else
#  undef gzgetc
#endif
int ZEXPORT gzgetc(file)
    gzFile file;
{
    int ret;
    unsigned char buf[1];
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
        (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* try output buffer (no need to check for skip request) */
    if (state->x.have) {
        state->x.have--;
        state->x.pos++;
        return *(state->x.next)++;
    }

    /* nothing there -- try gzread() */
    ret = gzread(file, buf, 1);
    return ret < 1 ? -1 : buf[0];
}

int ZEXPORT gzgetc_(file)
gzFile file;
{
    return gzgetc(file);
}

/* -- see zlib.h -- */
int ZEXPORT gzungetc(c, file)
    int c;
    gzFile file;
{
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
        (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* process a skip request */
    if (state->seek) {
        state->seek = 0;
        if (gz_skip(state, state->skip) == -1)
            return -1;
    }

    /* can't push EOF */
    if (c < 0)
        return -1;

    /* if output buffer empty, put byte at end (allows more pushing) */
    if (state->x.have == 0) {
        state->x.have = 1;
        state->x.next = state->out + (state->size << 1) - 1;
        state->x.next[0] = c;
        state->x.pos--;
        state->past = 0;
        return c;
    }

    /* if no room, give up (must have already done a gzungetc()) */
    if (state->x.have == (state->size << 1)) {
        gz_error(state, Z_DATA_ERROR, "out of room to push characters");
        return -1;
    }

    /* slide output data if needed and insert byte before existing data */
    if (state->x.next == state->out) {
        unsigned char *src = state->out + state->x.have;
        unsigned char *dest = state->out + (state->size << 1);
        while (src > state->out)
            *--dest = *--src;
        state->x.next = dest;
    }
    state->x.have++;
    state->x.next--;
    state->x.next[0] = c;
    state->x.pos--;
    state->past = 0;
    return c;
}

/* -- see zlib.h -- */
char * ZEXPORT gzgets(file, buf, len)
    gzFile file;
    char *buf;
    int len;
{
    unsigned left, n;
    char *str;
    unsigned char *eol;
    gz_statep state;

    /* check parameters and get internal structure */
    if (file == NULL || buf == NULL || len < 1)
        return NULL;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
        (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return NULL;

    /* process a skip request */
    if (state->seek) {
        state->seek = 0;
        if (gz_skip(state, state->skip) == -1)
            return NULL;
    }

    /* copy output bytes up to new line or len - 1, whichever comes first --
       append a terminating zero to the string (we don't check for a zero in
       the contents, let the user worry about that) */
    str = buf;
    left = (unsigned)len - 1;
    if (left) do {
        /* assure that something is in the output buffer */
        if (state->x.have == 0 && gz_fetch(state) == -1)
            return NULL;                /* error */
        if (state->x.have == 0) {       /* end of file */
            state->past = 1;            /* read past end */
            break;                      /* return what we have */
        }

        /* look for end-of-line in current output buffer */
        n = state->x.have > left ? left : state->x.have;
        eol = (unsigned char *)memchr(state->x.next, '\n', n);
        if (eol != NULL)
            n = (unsigned)(eol - state->x.next) + 1;

        /* copy through end-of-line, or remainder if not found */
        memcpy(buf, state->x.next, n);
        state->x.have -= n;
        state->x.next += n;
        state->x.pos += n;
        left -= n;
        buf += n;
    } while (left && eol == NULL);

    /* return terminated string, or if nothing, end of file */
    if (buf == str)
        return NULL;
    buf[0] = 0;
    return str;
}

/* -- see zlib.h -- */
int ZEXPORT gzdirect(file)
    gzFile file;
{
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;

    /* if the state is not known, but we can find out, then do so (this is
       mainly for right after a gzopen() or gzdopen()) */
    if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
        (void)gz_look(state);

    /* return 1 if transparent, 0 if processing a gzip stream */
    return state->direct;
}

/* -- see zlib.h -- */
int ZEXPORT gzclose_r(file)
    gzFile file;
{
    int ret, err;
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;

    /* check that we're reading */
    if (state->mode != GZ_READ)
        return Z_STREAM_ERROR;

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