gzio.c File Reference

#include <stdio.h>
#include "zutil.h"

Include dependency graph for gzio.c:

Go to the source code of this file.

Classes
struct	internal_state
struct	gz_stream

Macros
#define	_POSIX_C_SOURCE   1 /* for fdopen() */
#define	_BSD_SOURCE   /* for vsnprintf */
#define	Z_BUFSIZE   16384
#define	Z_PRINTF_BUFSIZE   4096
#define	ALLOC(size)   malloc(size)
#define	TRYFREE(p)   {if (p) free(p);}
#define	ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
#define	HEAD_CRC   0x02 /* bit 1 set: header CRC present */
#define	EXTRA_FIELD   0x04 /* bit 2 set: extra field present */
#define	ORIG_NAME   0x08 /* bit 3 set: original file name present */
#define	COMMENT   0x10 /* bit 4 set: file comment present */
#define	RESERVED   0xE0 /* bits 5..7: reserved */
#define	zstrerror(errnum)   ""

Typedefs
typedef struct gz_stream	gz_stream

Functions
voidp malloc	OF ((uInt size))
void free	OF ((voidpf ptr))
gzFile gz_open	OF ((const char *path, const char *mode, int fd))
int do_flush	OF ((gzFile file, int flush))
int get_byte	OF ((gz_stream *s))
void putLong	OF ((FILE *file, uLong x))
gzFile	gz_open (char *path, const char *mode, int fd) const
gzFile ZEXPORT	c4_gzopen (char *path, const char *mode) const
gzFile ZEXPORT	c4_gzdopen (int fd, const char *mode)
int ZEXPORT	c4_gzsetparams (gzFile file, int level, int strategy)
int	get_byte (gz_stream *s)
void	check_header (gz_stream *s)
int	destroy (gz_stream *s)
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 a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
int ZEXPORT	c4_gzputc (gzFile file, int c)
int ZEXPORT	c4_gzputs (gzFile file, const char *s)
int	do_flush (gzFile file, int flush)
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)
void	putLong (FILE *file, uLong x)
uLong	getLong (gz_stream *s)
int ZEXPORT	c4_gzclose (gzFile file)
void ZEXPORT	c4_gzclearerr (gzFile file)

---

Class Documentation

internal_state

struct internal_state

Definition at line 26 of file gzio.c.

Class Members
int	dummy

gz_stream

struct gz_stream

Definition at line 65 of file gzio.c.

Class Members
int	back
uLong	crc
FILE *	file
z_off_t	in
Byte *	inbuf
int	last
char	mode
char *	msg
z_off_t	out
Byte *	outbuf
char *	path
z_off_t	start
z_stream	stream
int	transparent
int	z_eof
int	z_err

Macro Definition Documentation

_BSD_SOURCE

#define _BSD_SOURCE   /* for vsnprintf */

Definition at line 15 of file gzio.c.

_POSIX_C_SOURCE

#define _POSIX_C_SOURCE   1 /* for fdopen() */

Definition at line 14 of file gzio.c.

ALLOC

#define ALLOC

(

size

)

malloc(size)

Definition at line 50 of file gzio.c.

ASCII_FLAG

#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */

Definition at line 58 of file gzio.c.

COMMENT

#define COMMENT   0x10 /* bit 4 set: file comment present */

Definition at line 62 of file gzio.c.

EXTRA_FIELD

#define EXTRA_FIELD   0x04 /* bit 2 set: extra field present */

Definition at line 60 of file gzio.c.

HEAD_CRC

#define HEAD_CRC   0x02 /* bit 1 set: header CRC present */

Definition at line 59 of file gzio.c.

ORIG_NAME

#define ORIG_NAME   0x08 /* bit 3 set: original file name present */

Definition at line 61 of file gzio.c.

RESERVED

#define RESERVED   0xE0 /* bits 5..7: reserved */

Definition at line 63 of file gzio.c.

TRYFREE

#define TRYFREE

(

p

)

{if (p) free(p);}

Definition at line 51 of file gzio.c.

Z_BUFSIZE

#define Z_BUFSIZE   16384

Definition at line 33 of file gzio.c.

Z_PRINTF_BUFSIZE

#define Z_PRINTF_BUFSIZE   4096

Definition at line 37 of file gzio.c.

zstrerror

#define zstrerror

(

errnum

)

""

Definition at line 988 of file gzio.c.

Typedef Documentation

gz_stream

typedef struct gz_stream gz_stream

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	(	char *	path,
		const char *	mode
	)		const

Definition at line 217 of file gzio.c.

{
    return gz_open (path, mode, -1);
}

References gz_open().

Here is the call graph for this function:

c4_gzprintf()

int ZEXPORTVA c4_gzprintf	(	gzFile	file,
		const char *	format,
		int	a1,
		int	a2,
		int	a3,
		int	a4,
		int	a5,
		int	a6,
		int	a7,
		int	a8,
		int	a9,
		int	a10,
		int	a11,
		int	a12,
		int	a13,
		int	a14,
		int	a15,
		int	a16,
		int	a17,
		int	a18,
		int	a19,
		int	a20
	)

Definition at line 648 of file gzio.c.

{
    char buf[Z_PRINTF_BUFSIZE];
    int len;
 
    buf[sizeof(buf) - 1] = 0;
#ifdef NO_snprintf
#  ifdef HAS_sprintf_void
    sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
    for (len = 0; len < sizeof(buf); len++)
        if (buf[len] == 0) break;
#  else
    len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
                a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
#  endif
#else
#  ifdef HAS_snprintf_void
    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
    len = strlen(buf);
#  else
    len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
                 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
#  endif
#endif
    if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
        return 0;
    return gzwrite(file, buf, len);
}

References sprintf, and Z_PRINTF_BUFSIZE.

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:

check_header()

void check_header

(

gz_stream *

s

)

Definition at line 297 of file gzio.c.

{
    int method; /* method byte */
    int flags;  /* flags byte */
    uInt len;
    int c;
 
    /* Assure two bytes in the buffer so we can peek ahead -- handle case
       where first byte of header is at the end of the buffer after the last
       gzip segment */
    len = s->stream.avail_in;
    if (len < 2) {
        if (len) s->inbuf[0] = s->stream.next_in[0];
        errno = 0;
        len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
        s->stream.avail_in += len;
        s->stream.next_in = s->inbuf;
        if (s->stream.avail_in < 2) {
            s->transparent = s->stream.avail_in;
            return;
        }
    }
 
    /* Peek ahead to check the gzip magic header */
    if ((s->stream.next_in[0] != gz_magic_old[0] ||
         s->stream.next_in[1] != gz_magic_old[1]) &&
        (s->stream.next_in[0] != gz_magic_new[0] ||
         s->stream.next_in[1] != gz_magic_new[1])) {
        s->transparent = 1;
        return;
    }
    s->stream.avail_in -= 2;
    s->stream.next_in += 2;
 
    /* Check the rest of the gzip header */
    method = get_byte(s);
    flags = get_byte(s);
    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
        s->z_err = Z_DATA_ERROR;
        return;
    }
 
    /* Discard time, xflags and OS code: */
    for (len = 0; len < 6; len++) (void)get_byte(s);
 
    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
        len  =  (uInt)get_byte(s);
        len += ((uInt)get_byte(s))<<8;
        /* len is garbage if EOF but the loop below will quit anyway */
        while (len-- != 0 && get_byte(s) != EOF) ;
    }
    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
        while ((c = get_byte(s)) != 0 && c != EOF) ;
    }
    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
        while ((c = get_byte(s)) != 0 && c != EOF) ;
    }
    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
        for (len = 0; len < 2; len++) (void)get_byte(s);
    }
    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
}

References s, and Z_BUFSIZE.

Referenced by c4_gzread().

Here is the caller graph for this function:

destroy()

int destroy

(

gz_stream *

s

)

Definition at line 366 of file gzio.c.

{
    int err = Z_OK;
 
    if (!s) return Z_STREAM_ERROR;
 
    TRYFREE(s->msg);
 
    if (s->stream.state != NULL) {
        if (s->mode == 'w') {
#ifdef NO_GZCOMPRESS
            err = Z_STREAM_ERROR;
#else
            err = deflateEnd(&(s->stream));
#endif
        } else if (s->mode == 'r') {
            err = inflateEnd(&(s->stream));
        }
    }
    if (s->file != NULL && fclose(s->file)) {
#ifdef ESPIPE
        if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
#endif
            err = Z_ERRNO;
    }
    if (s->z_err < 0) err = s->z_err;
 
    TRYFREE(s->inbuf);
    TRYFREE(s->outbuf);
    TRYFREE(s->path);
    TRYFREE(s);
    return err;
}

References s, and TRYFREE.

Referenced by c4_gzclose(), and gz_open().

Here is the caller graph for this function:

do_flush()

int do_flush	(	gzFile	file,
		int	flush
	)

Definition at line 716 of file gzio.c.

{
    uInt len;
    int done = 0;
    gz_stream *s = (gz_stream*)file;
 
    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
 
    s->stream.avail_in = 0; /* should be zero already anyway */
 
    for (;;) {
        len = Z_BUFSIZE - s->stream.avail_out;
 
        if (len != 0) {
            if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
                s->z_err = Z_ERRNO;
                return Z_ERRNO;
            }
            s->stream.next_out = s->outbuf;
            s->stream.avail_out = Z_BUFSIZE;
        }
        if (done) break;
        s->out += s->stream.avail_out;
        s->z_err = deflate(&(s->stream), flush);
        s->out -= s->stream.avail_out;
 
        /* Ignore the second of two consecutive flushes: */
        if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
 
        /* deflate has finished flushing only when it hasn't used up
         * all the available space in the output buffer:
         */
        done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
 
        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
    }
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
}

References s, and Z_BUFSIZE.

Referenced by c4_gzclose(), and c4_gzflush().

Here is the caller graph for this function:

get_byte()

int get_byte

(

gz_stream *

s

)

Definition at line 270 of file gzio.c.

{
    if (s->z_eof) return EOF;
    if (s->stream.avail_in == 0) {
        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;
            return EOF;
        }
        s->stream.next_in = s->inbuf;
    }
    s->stream.avail_in--;
    return *(s->stream.next_in)++;
}

References s, and Z_BUFSIZE.

Referenced by getLong().

Here is the caller graph for this function:

getLong()

uLong getLong

(

gz_stream *

s

)

Definition at line 946 of file gzio.c.

{
    uLong x = (uLong)get_byte(s);
    int c;
 
    x += ((uLong)get_byte(s))<<8;
    x += ((uLong)get_byte(s))<<16;
    c = get_byte(s);
    if (c == EOF) s->z_err = Z_DATA_ERROR;
    x += ((uLong)c)<<24;
    return x;
}

References get_byte(), and s.

Referenced by c4_gzread().

Here is the call graph for this function:

Here is the caller graph for this function:

gz_open()

gzFile gz_open	(	char *	path,
		const char *	mode,
		int	fd
	)		const

Definition at line 102 of file gzio.c.

{
    int err;
    int level = Z_DEFAULT_COMPRESSION; /* compression level */
    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
    const char *p = mode;
    gz_stream *s;
    char fmode[80]; /* copy of mode, without the compression level */
    char *m = fmode;
 
    if (!path || !mode) return Z_NULL;
 
    s = (gz_stream *)ALLOC(sizeof(gz_stream));
    if (!s) return Z_NULL;
 
    s->stream.zalloc = (alloc_func)0;
    s->stream.zfree = (free_func)0;
    s->stream.opaque = (voidpf)0;
    s->stream.next_in = s->inbuf = Z_NULL;
    s->stream.next_out = s->outbuf = Z_NULL;
    s->stream.avail_in = s->stream.avail_out = 0;
    s->file = NULL;
    s->z_err = Z_OK;
    s->z_eof = 0;
    s->in = 0;
    s->out = 0;
    s->back = EOF;
    s->crc = crc32(0L, Z_NULL, 0);
    s->msg = NULL;
    s->transparent = 0;
 
    s->path = (char*)ALLOC(strlen(path)+1);
    if (s->path == NULL) {
        return destroy(s), (gzFile)Z_NULL;
    }
    strcpy(s->path, path); /* do this early for debugging */
 
    s->mode = '\0';
    do {
        if (*p == 'r') s->mode = 'r';
        if (*p == 'w' || *p == 'a') s->mode = 'w';
        if (*p >= '0' && *p <= '9') {
            level = *p - '0';
        } else if (*p == 'f') {
          strategy = Z_FILTERED;
        } else if (*p == 'h') {
          strategy = Z_HUFFMAN_ONLY;
        } else if (*p == 'R') {
          strategy = Z_RLE;
        } else {
            *m++ = *p; /* copy the mode */
        }
    } while (*p++ && m != fmode + sizeof(fmode));
    if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
 
    if (s->mode == 'w') {
#ifdef NO_GZCOMPRESS
        err = Z_STREAM_ERROR;
#else
        err = deflateInit2(&(s->stream), level,
                           Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
        /* windowBits is passed < 0 to suppress zlib header */
 
        s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
#endif
        if (err != Z_OK || s->outbuf == Z_NULL) {
            return destroy(s), (gzFile)Z_NULL;
        }
    } else {
        s->stream.next_in  = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
 
        err = inflateInit2(&(s->stream), -MAX_WBITS);
        /* windowBits is passed < 0 to tell that there is no zlib header.
         * Note that in this case inflate *requires* an extra "dummy" byte
         * after the compressed stream in order to complete decompression and
         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
         * present after the compressed stream.
         */
        if (err != Z_OK || s->inbuf == Z_NULL) {
            return destroy(s), (gzFile)Z_NULL;
        }
    }
    s->stream.avail_out = Z_BUFSIZE;
 
    errno = 0;
    s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
 
    if (s->file == NULL) {
        return destroy(s), (gzFile)Z_NULL;
    }
    if (s->mode == 'w') {
        /* Write a very simple .gz header:
         */
        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic_new[0], gz_magic_new[1],
             Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, 0x0b /* OSCODE */);
        s->start = 10L;
        /* We use 10L instead of ftell(s->file) to because ftell causes an
         * fflush on some systems. This version of the library doesn't use
         * start anyway in write mode, so this initialization is not
         * necessary.
         */
    } else {
        check_header(s); /* skip the .gz header */
        s->start = ftell(s->file) - s->stream.avail_in;
    }
 
    return (gzFile)s;
}

References ALLOC, DEF_MEM_LEVEL, destroy(), F_OPEN, s, and Z_BUFSIZE.

Referenced by c4_gzdopen(), and c4_gzopen().

Here is the call graph for this function:

Here is the caller graph for this function:

OF() [1/6]

gzFile gz_open OF

(

(const char *path, const char *mode, int fd)

)

OF() [2/6]

void putLong OF

(

(FILE *file, uLong x)

)

OF() [3/6]

uLong getLong OF

(

(gz_stream *s)

)

OF() [4/6]

int do_flush OF

(

(gzFile file, int flush)

)

OF() [5/6]

voidp malloc OF

(

(uInt size)

)

OF() [6/6]

void free OF

(

(voidpf ptr)

)

putLong()

void putLong	(	FILE *	file,
		uLong	x
	)

Definition at line 931 of file gzio.c.

{
    int n;
    for (n = 0; n < 4; n++) {
        fputc((int)(x & 0xff), file);
        x >>= 8;
    }
}

Referenced by c4_gzclose().

Here is the caller graph for this function: