gzio.h File Reference

#include <zlib.h>

Include dependency graph for gzio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
gzFile ZEXPORT	c4_gzopen (const char *path, const char *mode)
gzFile ZEXPORT	c4_gzdopen (int fd, const char *mode)
int ZEXPORT	c4_gzsetparams (gzFile file, int level, int strategy)
int ZEXPORT	c4_gzread (gzFile file, voidp buf, unsigned len)
int ZEXPORT	c4_gzgetc (gzFile file)
int ZEXPORT	c4_gzungetc (int c, gzFile file)
char *ZEXPORT	c4_gzgets (gzFile file, char *buf, int len)
int ZEXPORT	c4_gzwrite (gzFile file, voidpc buf, unsigned len)
int ZEXPORTVA	c4_gzprintf (gzFile file, const char *format,...)
int ZEXPORT	c4_gzputc (gzFile file, int c)
int ZEXPORT	c4_gzputs (gzFile file, const char *s)
int ZEXPORT	c4_gzflush (gzFile file, int flush)
z_off_t ZEXPORT	c4_gzseek (gzFile file, z_off_t offset, int whence)
int ZEXPORT	c4_gzrewind (gzFile file)
z_off_t ZEXPORT	c4_gztell (gzFile file)
int ZEXPORT	c4_gzeof (gzFile file)
int ZEXPORT	c4_gzdirect (gzFile file)
int ZEXPORT	c4_gzclose (gzFile file)
void ZEXPORT	c4_gzclearerr (gzFile file)

Function Documentation

c4_gzclearerr()

void ZEXPORT c4_gzclearerr

(

gzFile

file

)

Definition at line 1030 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL) return;
    if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
    s->z_eof = 0;
    clearerr(s->file);
}

References s.

c4_gzclose()

int ZEXPORT c4_gzclose

(

gzFile

file

)

Definition at line 964 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL) return Z_STREAM_ERROR;
 
    if (s->mode == 'w') {
#ifdef NO_GZCOMPRESS
        return Z_STREAM_ERROR;
#else
        if (do_flush (file, Z_FINISH) != Z_OK)
            return destroy((gz_stream*)file);
 
        putLong (s->file, s->crc);
        putLong (s->file, (uLong)(s->in & 0xffffffff));
#endif
    }
    return destroy((gz_stream*)file);
}

References destroy(), do_flush(), putLong(), and s.

Referenced by CStdFile::Close(), CStdFile::Open(), and UncompressedFileSize().

Here is the call graph for this function:

Here is the caller graph for this function:

c4_gzdirect()

int ZEXPORT c4_gzdirect

(

gzFile

file

)

Definition at line 919 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || s->mode != 'r') return 0;
    return s->transparent;
}

References s.

Referenced by CStdFile::Open().

Here is the caller graph for this function:

c4_gzdopen()

gzFile ZEXPORT c4_gzdopen	(	int	fd,
		const char *	mode
	)

Definition at line 228 of file gzio.c.

{
    char name[46];      /* allow for up to 128-bit integers */
 
    if (fd < 0) return (gzFile)Z_NULL;
    sprintf(name, "<fd:%d>", fd); /* for debugging */
 
    return gz_open (name, mode, fd);
}

References gz_open(), and sprintf.

Referenced by CStdFile::Create(), CStdFile::Open(), and UncompressedFileSize().

Here is the call graph for this function:

Here is the caller graph for this function:

c4_gzeof()

int ZEXPORT c4_gzeof

(

gzFile

file

)

Definition at line 902 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    /* With concatenated compressed files that can have embedded
     * crc trailers, z_eof is no longer the only/best indicator of EOF
     * on a gz_stream. Handle end-of-stream error explicitly here.
     */
    if (s == NULL || s->mode != 'r') return 0;
    if (s->z_eof) return 1;
    return s->z_err == Z_STREAM_END;
}

References s.

c4_gzflush()

int ZEXPORT c4_gzflush	(	gzFile	file,
		int	flush
	)

Definition at line 757 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
    int err = do_flush (file, flush);
 
    if (err) return err;
    fflush(s->file);
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
}

References do_flush(), and s.

Here is the call graph for this function:

c4_gzgetc()

int ZEXPORT c4_gzgetc

(

gzFile

file

)

Definition at line 514 of file gzio.c.

{
    unsigned char c;
 
    return gzread(file, &c, 1) == 1 ? c : -1;
}

c4_gzgets()

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

Definition at line 551 of file gzio.c.

{
    char *b = buf;
    if (buf == Z_NULL || len <= 0) return Z_NULL;
 
    while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
    *buf = '\0';
    return b == buf && len > 0 ? Z_NULL : b;
}

References b.

c4_gzopen()

gzFile ZEXPORT c4_gzopen	(	const char *	path,
		const char *	mode
	)

c4_gzprintf()

int ZEXPORTVA c4_gzprintf	(	gzFile	file,
		const char *	format,
			...
	)

c4_gzputc()

int ZEXPORT c4_gzputc	(	gzFile	file,
		int	c
	)

Definition at line 689 of file gzio.c.

{
    unsigned char cc = (unsigned char) c; /* required for big endian systems */
 
    return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
}

c4_gzputs()

int ZEXPORT c4_gzputs	(	gzFile	file,
		const char *	s
	)

Definition at line 704 of file gzio.c.

{
    return gzwrite(file, s, (unsigned)strlen(s));
}

References s.

c4_gzread()

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

Definition at line 405 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
    Bytef *start = (Bytef*)buf; /* starting point for crc computation */
    Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
 
    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
 
    if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
 
    next_out = (Byte*)buf;
    s->stream.next_out = (Bytef*)buf;
    s->stream.avail_out = len;
 
    if (s->stream.avail_out && s->back != EOF) {
        *next_out++ = s->back;
        s->stream.next_out++;
        s->stream.avail_out--;
        s->back = EOF;
        s->out++;
        start++;
        if (s->last) {
            s->z_err = Z_STREAM_END;
            return 1;
        }
    }
 
    while (s->stream.avail_out != 0) {
 
        if (s->transparent) {
            /* Copy first the lookahead bytes: */
            uInt n = s->stream.avail_in;
            if (n > s->stream.avail_out) n = s->stream.avail_out;
            if (n > 0) {
                zmemcpy(s->stream.next_out, s->stream.next_in, n);
                next_out += n;
                s->stream.next_out = next_out;
                s->stream.next_in   += n;
                s->stream.avail_out -= n;
                s->stream.avail_in  -= n;
            }
            if (s->stream.avail_out > 0) {
                s->stream.avail_out -=
                    (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
            }
            len -= s->stream.avail_out;
            s->in  += len;
            s->out += len;
            if (len == 0) s->z_eof = 1;
            return (int)len;
        }
        if (s->stream.avail_in == 0 && !s->z_eof) {
 
            errno = 0;
            s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
            if (s->stream.avail_in == 0) {
                s->z_eof = 1;
                if (ferror(s->file)) {
                    s->z_err = Z_ERRNO;
                    break;
                }
            }
            s->stream.next_in = s->inbuf;
        }
        s->in += s->stream.avail_in;
        s->out += s->stream.avail_out;
        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
        s->in -= s->stream.avail_in;
        s->out -= s->stream.avail_out;
 
        if (s->z_err == Z_STREAM_END) {
            /* Check CRC and original size */
            s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
            start = s->stream.next_out;
 
            if (getLong(s) != s->crc) {
                s->z_err = Z_DATA_ERROR;
            } else {
                (void)getLong(s);
                /* The uncompressed length returned by above getlong() may be
                 * different from s->out in case of concatenated .gz files.
                 * Check for such files:
                 */
                check_header(s);
                if (s->z_err == Z_OK) {
                    inflateReset(&(s->stream));
                    s->crc = crc32(0L, Z_NULL, 0);
                }
            }
        }
        if (s->z_err != Z_OK || s->z_eof) break;
    }
    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
 
    if (len == s->stream.avail_out &&
        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
        return -1;
    return (int)(len - s->stream.avail_out);
}

References check_header(), getLong(), s, and Z_BUFSIZE.

Referenced by CStdFile::LoadBuffer(), and UncompressedFileSize().

Here is the call graph for this function:

Here is the caller graph for this function:

c4_gzrewind()

int ZEXPORT c4_gzrewind

(

gzFile

file

)

Definition at line 868 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || s->mode != 'r') return -1;
 
    s->z_err = Z_OK;
    s->z_eof = 0;
    s->back = EOF;
    s->stream.avail_in = 0;
    s->stream.next_in = s->inbuf;
    s->crc = crc32(0L, Z_NULL, 0);
    if (!s->transparent) (void)inflateReset(&s->stream);
    s->in = 0;
    s->out = 0;
    return fseek(s->file, s->start, SEEK_SET);
}

References s.

Referenced by CStdFile::Rewind().

Here is the caller graph for this function:

c4_gzseek()

z_off_t ZEXPORT c4_gzseek	(	gzFile	file,
		z_off_t	offset,
		int	whence
	)

Definition at line 778 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || whence == SEEK_END ||
        s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
        return -1L;
    }
 
    if (s->mode == 'w') {
#ifdef NO_GZCOMPRESS
        return -1L;
#else
        if (whence == SEEK_SET) {
            offset -= s->in;
        }
        if (offset < 0) return -1L;
 
        /* At this point, offset is the number of zero bytes to write. */
        if (s->inbuf == Z_NULL) {
            s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
            if (s->inbuf == Z_NULL) return -1L;
            zmemzero(s->inbuf, Z_BUFSIZE);
        }
        while (offset > 0)  {
            uInt size = Z_BUFSIZE;
            if (offset < Z_BUFSIZE) size = (uInt)offset;
 
            size = gzwrite(file, s->inbuf, size);
            if (size == 0) return -1L;
 
            offset -= size;
        }
        return s->in;
#endif
    }
    /* Rest of function is for reading only */
 
    /* compute absolute position */
    if (whence == SEEK_CUR) {
        offset += s->out;
    }
    if (offset < 0) return -1L;
 
    if (s->transparent) {
        /* map to fseek */
        s->back = EOF;
        s->stream.avail_in = 0;
        s->stream.next_in = s->inbuf;
        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
 
        s->in = s->out = offset;
        return offset;
    }
 
    /* For a negative seek, rewind and use positive seek */
    if (offset >= s->out) {
        offset -= s->out;
    } else if (gzrewind(file) < 0) {
        return -1L;
    }
    /* offset is now the number of bytes to skip. */
 
    if (offset != 0 && s->outbuf == Z_NULL) {
        s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
        if (s->outbuf == Z_NULL) return -1L;
    }
    if (offset && s->back != EOF) {
        s->back = EOF;
        s->out++;
        offset--;
        if (s->last) s->z_err = Z_STREAM_END;
    }
    while (offset > 0)  {
        int size = Z_BUFSIZE;
        if (offset < Z_BUFSIZE) size = (int)offset;
 
        size = gzread(file, s->outbuf, (uInt)size);
        if (size <= 0) return -1L;
        offset -= size;
    }
    return s->out;
}

References ALLOC, s, and Z_BUFSIZE.

c4_gzsetparams()

int ZEXPORT c4_gzsetparams	(	gzFile	file,
		int	level,
		int	strategy
	)

Definition at line 243 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
 
    /* Make room to allow flushing */
    if (s->stream.avail_out == 0) {
 
        s->stream.next_out = s->outbuf;
        if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
            s->z_err = Z_ERRNO;
        }
        s->stream.avail_out = Z_BUFSIZE;
    }
 
    return deflateParams (&(s->stream), level, strategy);
}

References s, and Z_BUFSIZE.

c4_gztell()

z_off_t ZEXPORT c4_gztell

(

gzFile

file

)

Definition at line 892 of file gzio.c.

{
    return gzseek(file, 0L, SEEK_CUR);
}

c4_gzungetc()

int ZEXPORT c4_gzungetc	(	int	c,
		gzFile	file
	)

Definition at line 526 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
    s->back = c;
    s->out--;
    s->last = (s->z_err == Z_STREAM_END);
    if (s->last) s->z_err = Z_OK;
    s->z_eof = 0;
    return c;
}

References s.

c4_gzwrite()

int ZEXPORT c4_gzwrite	(	gzFile	file,
		voidpc	buf,
		unsigned	len
	)

Definition at line 570 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
 
    s->stream.next_in = *(Bytef**)(void*)&buf;
    s->stream.avail_in = len;
 
    while (s->stream.avail_in != 0) {
 
        if (s->stream.avail_out == 0) {
 
            s->stream.next_out = s->outbuf;
            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
                s->z_err = Z_ERRNO;
                break;
            }
            s->stream.avail_out = Z_BUFSIZE;
        }
        s->in += s->stream.avail_in;
        s->out += s->stream.avail_out;
        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
        s->in -= s->stream.avail_in;
        s->out -= s->stream.avail_out;
        if (s->z_err != Z_OK) break;
    }
    s->crc = crc32(s->crc, (const Bytef *)buf, len);
 
    return (int)(len - s->stream.avail_in);
}

References s, and Z_BUFSIZE.

Referenced by CStdFile::SaveBuffer().

Here is the caller graph for this function: