gzread.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "misc/util/abc_global.h"
#include "gzguts.h"

Include dependency graph for gzread.c:

Go to the source code of this file.

Macros
#define	NEXT()

Functions
ABC_NAMESPACE_IMPL_START local int gz_load	OF ((gz_statep, unsigned char *, unsigned, unsigned *))
local int gz_avail	OF ((gz_statep))
local int gz_next4	OF ((gz_statep, unsigned long *))
local int gz_skip	OF ((gz_statep, z_off64_t))
local int	gz_load (gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
local int	gz_avail (gz_statep state)
local int	gz_next4 (gz_statep state, unsigned long *ret)
local int	gz_head (gz_statep state)
local int	gz_decomp (gz_statep state)
local int	gz_make (gz_statep state)
local int	gz_skip (gz_statep state, z_off64_t len)
int ZEXPORT	gzread (gzFile file, voidp buf, unsigned len)
int ZEXPORT	gzgetc (gzFile file)
int ZEXPORT	gzungetc (int c, gzFile file)
char *ZEXPORT	gzgets (gzFile file, char *buf, int len)
int ZEXPORT	gzdirect (gzFile file)
int ZEXPORT	gzclose_r (gzFile file)

Macro Definition Documentation

NEXT

#define NEXT

(

)

Value:

                ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \
                (strm->avail_in == 0 ? -1 : \
                 (strm->avail_in--, *(strm->next_in)++)))

Definition at line 69 of file gzread.c.

#define NEXT() ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \
                (strm->avail_in == 0 ? -1 : \
                 (strm->avail_in--, *(strm->next_in)++)))

Function Documentation

gz_avail()

local int gz_avail

(

gz_statep

state

)

Definition at line 53 of file gzread.c.

{
    z_streamp strm = &(state->strm);
 
    if (state->err != Z_OK)
        return -1;
    if (state->eof == 0) {
        if (gz_load(state, state->in, state->size,
                (unsigned *)&(strm->avail_in)) == -1)
            return -1;
        strm->next_in = state->in;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gz_decomp()

local int gz_decomp

(

gz_statep

state

)

Definition at line 232 of file gzread.c.

{
    int ret;
    unsigned had;
    unsigned long crc, len;
    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_DATA_ERROR, "unexpected end of file");
            return -1;
        }
 
        /* 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 and crc check value */
    state->have = had - strm->avail_out;
    state->next = strm->next_out - state->have;
    strm->adler = crc32(strm->adler, state->next, state->have);
 
    /* check gzip trailer if at end of deflate stream */
    if (ret == Z_STREAM_END) {
        if (gz_next4(state, &crc) == -1 || gz_next4(state, &len) == -1) {
            gz_error(state, Z_DATA_ERROR, "unexpected end of file");
            return -1;
        }
        if (crc != strm->adler) {
            gz_error(state, Z_DATA_ERROR, "incorrect data check");
            return -1;
        }
        if (len != (strm->total_out & 0xffffffffL)) {
            gz_error(state, Z_DATA_ERROR, "incorrect length check");
            return -1;
        }
        state->how = LOOK;      /* ready for next stream, once have is 0 (leave
                                   state->direct unchanged to remember how) */
    }
 
    /* good decompression */
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gz_head()

local int gz_head

(

gz_statep

state

)

Definition at line 104 of file gzread.c.

{
    z_streamp strm = &(state->strm);
    int flags;
    unsigned len;
 
    /* 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) != Z_OK) {    /* raw inflate */
            free(state->out);
            free(state->in);
            state->size = 0;
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
    }
 
    /* get some data in the input buffer */
    if (strm->avail_in == 0) {
        if (gz_avail(state) == -1)
            return -1;
        if (strm->avail_in == 0)
            return 0;
    }
 
    /* look for the gzip magic header bytes 31 and 139 */
    if (strm->next_in[0] == 31) {
        strm->avail_in--;
        strm->next_in++;
        if (strm->avail_in == 0 && gz_avail(state) == -1)
            return -1;
        if (strm->avail_in && strm->next_in[0] == 139) {
            /* we have a gzip header, woo hoo! */
            strm->avail_in--;
            strm->next_in++;
 
            /* skip rest of header */
            if (NEXT() != 8) {      /* compression method */
                gz_error(state, Z_DATA_ERROR, "unknown compression method");
                return -1;
            }
            flags = NEXT();
            if (flags & 0xe0) {     /* reserved flag bits */
                gz_error(state, Z_DATA_ERROR, "unknown header flags set");
                return -1;
            }
            NEXT();                 /* modification time */
            NEXT();
            NEXT();
            NEXT();
            NEXT();                 /* extra flags */
            NEXT();                 /* operating system */
            if (flags & 4) {        /* extra field */
                len = (unsigned)NEXT();
                len += (unsigned)NEXT() << 8;
                while (len--)
                    if (NEXT() < 0)
                        break;
            }
            if (flags & 8)          /* file name */
                while (NEXT() > 0)
                    ;
            if (flags & 16)         /* comment */
                while (NEXT() > 0)
                    ;
            if (flags & 2) {        /* header crc */
                NEXT();
                NEXT();
            }
            /* an unexpected end of file is not checked for here -- it will be
               noticed on the first request for uncompressed data */
 
            /* set up for decompression */
            inflateReset(strm);
            strm->adler = crc32(0L, Z_NULL, 0);
            state->how = GZIP;
            state->direct = 0;
            return 0;
        }
        else {
            /* not a gzip file -- save first byte (31) and fall to raw i/o */
            state->out[0] = 31;
            state->have = 1;
        }
    }
 
    /* doing raw i/o, save start of raw data for seeking, 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->raw = state->pos;
    state->next = state->out;
    if (strm->avail_in) {
        memcpy(state->next + state->have, strm->next_in, strm->avail_in);
        state->have += strm->avail_in;
        strm->avail_in = 0;
    }
    state->how = COPY;
    state->direct = 1;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gz_load()

local int gz_load	(	gz_statep	state,
		unsigned char *	buf,
		unsigned	len,
		unsigned *	have )

Definition at line 28 of file gzread.c.

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gz_make()

local int gz_make

(

gz_statep

state

)

Definition at line 302 of file gzread.c.

{
    z_streamp strm = &(state->strm);
 
    if (state->how == LOOK) {           /* look for gzip header */
        if (gz_head(state) == -1)
            return -1;
        if (state->have)                /* got some data from gz_head() */
            return 0;
    }
    if (state->how == COPY) {           /* straight copy */
        if (gz_load(state, state->out, state->size << 1, &(state->have)) == -1)
            return -1;
        state->next = state->out;
    }
    else if (state->how == GZIP) {      /* decompress */
        strm->avail_out = state->size << 1;
        strm->next_out = state->out;
        if (gz_decomp(state) == -1)
            return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gz_next4()

local int gz_next4	(	gz_statep	state,
		unsigned long *	ret )

Definition at line 75 of file gzread.c.

{
    int ch;
    unsigned long val;
    z_streamp strm = &(state->strm);
 
    val = NEXT();
    val += (unsigned)NEXT() << 8;
    val += (unsigned long)NEXT() << 16;
    ch = NEXT();
    if (ch == -1)
        return -1;
    val += (unsigned long)ch << 24;
    *ret = val;
    return 0;
}

Here is the caller graph for this function:

gz_skip()

local int gz_skip	(	gz_statep	state,
		z_off64_t	len )

Definition at line 327 of file gzread.c.

{
    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->have) {
            n = GT_OFF(state->have) || (z_off64_t)state->have > len ?
                (unsigned)len : state->have;
            state->have -= n;
            state->next += n;
            state->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_make(state) == -1)
                return -1;
        }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gzclose_r()

int ZEXPORT gzclose_r

(

gzFile

file

)

Definition at line 612 of file gzread.c.

{
    int ret;
    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);
    }
    gz_error(state, Z_OK, NULL);
    free(state->path);
    ret = close(state->fd);
    free(state);
    return ret ? Z_ERRNO : Z_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gzdirect()

int ZEXPORT gzdirect

(

gzFile

file

)

Definition at line 589 of file gzread.c.

{
    gz_statep state;
 
    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;
 
    /* check that we're reading */
    if (state->mode != GZ_READ)
        return 0;
 
    /* 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->how == LOOK && state->have == 0)
        (void)gz_head(state);
 
    /* return 1 if reading direct, 0 if decompressing a gzip stream */
    return state->direct;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gzgetc()

int ZEXPORT gzgetc

(

gzFile

file

)

Definition at line 445 of file gzread.c.

{
    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 error */
    if (state->mode != GZ_READ || state->err != Z_OK)
        return -1;
 
    /* try output buffer (no need to check for skip request) */
    if (state->have) {
        state->have--;
        state->pos++;
        return *(state->next)++;
    }
 
    /* nothing there -- try gzread() */
    ret = gzread(file, buf, 1);
    return ret < 1 ? -1 : buf[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

gzgets()

char *ZEXPORT gzgets	(	gzFile	file,
		char *	buf,
		int	len )

Definition at line 528 of file gzread.c.

{
    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 error */
    if (state->mode != GZ_READ || state->err != Z_OK)
        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->have == 0) {
            if (gz_make(state) == -1)
                return NULL;            /* error */
            if (state->have == 0) {     /* end of file */
                if (buf == str)         /* got bupkus */
                    return NULL;
                break;                  /* got something -- return it */
            }
        }
 
        /* look for end-of-line in current output buffer */
        n = state->have > left ? left : state->have;
        eol = (unsigned char *)memchr(state->next, '\n', n);
        if (eol != NULL)
            n = (unsigned)(eol - state->next) + 1;
 
        /* copy through end-of-line, or remainder if not found */
        memcpy(buf, state->next, n);
        state->have -= n;
        state->next += n;
        state->pos += n;
        left -= n;
        buf += n;
    } while (left && eol == NULL);
 
    /* found end-of-line or out of space -- terminate string and return it */
    buf[0] = 0;
    return str;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gzread()

int ZEXPORT gzread	(	gzFile	file,
		voidp	buf,
		unsigned	len )

Definition at line 357 of file gzread.c.

{
    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 error */
    if (state->mode != GZ_READ || state->err != Z_OK)
        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_BUF_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->have) {
            n = state->have > len ? len : state->have;
            memcpy(buf, state->next, n);
            state->next += n;
            state->have -= n;
        }
 
        /* output buffer empty -- return if we're at the end of the input */
        else if (state->eof && strm->avail_in == 0)
            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_make(state) == -1)
                return -1;
            continue;       /* no progress yet -- go back to memcpy() 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->have;
            state->have = 0;
        }
 
        /* update progress */
        len -= n;
        buf = (char *)buf + n;
        got += n;
        state->pos += n;
    } while (len);
 
    /* return number of bytes read into user buffer (will fit in int) */
    return (int)got;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gzungetc()

int ZEXPORT gzungetc	(	int	c,
		gzFile	file )

Definition at line 473 of file gzread.c.

{
    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 error */
    if (state->mode != GZ_READ || state->err != Z_OK)
        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->have == 0) {
        state->have = 1;
        state->next = state->out + (state->size << 1) - 1;
        state->next[0] = c;
        state->pos--;
        return c;
    }
 
    /* if no room, give up (must have already done a gzungetc()) */
    if (state->have == (state->size << 1)) {
        gz_error(state, Z_BUF_ERROR, "out of room to push characters");
        return -1;
    }
 
    /* slide output data if needed and insert byte before existing data */
    if (state->next == state->out) {
        unsigned char *src = state->out + state->have;
        unsigned char *dest = state->out + (state->size << 1);
        while (src > state->out)
            *--dest = *--src;
        state->next = dest;
    }
    state->have++;
    state->next--;
    state->next[0] = c;
    state->pos--;
    return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

OF() [1/4]

local int gz_avail OF

(

(gz_statep)

)

Here is the call graph for this function:

OF() [2/4]

ABC_NAMESPACE_IMPL_START local int gz_load OF

(

(gz_statep, unsigned char *, unsigned, unsigned *)

)

Here is the call graph for this function:

OF() [3/4]

local int gz_next4 OF

(

(gz_statep, unsigned long *)

)

Here is the call graph for this function:

OF() [4/4]

local int gz_skip OF

(

(gz_statep, z_off64_t)

)

Here is the call graph for this function: