Back to index

plt-scheme  4.2.1
Classes | Defines | Typedefs | Functions | Variables
gzio.c File Reference
#include <stdio.h>
#include "zutil.h"

Go to the source code of this file.

Classes

struct  internal_state
struct  gz_stream

Defines

#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 */

Typedefs

typedef struct gz_stream gz_stream

Functions

local gzFile gz_open OF ((const char *path, const char *mode, intfd))
local int do_flush OF ((gzFile file, int flush))
local int get_byte OF ((gz_stream *s))
local void putLong OF ((FILE *file, uLong x))
local gzFile gz_open (char *path, const char *mode, int fd) const
gzFile ZEXPORT gzopen (char *path, const char *mode) const
gzFile ZEXPORT gzdopen (int fd, const char *mode)
int ZEXPORT gzsetparams (gzFile file, int level, int strategy)
local int get_byte (gz_stream *s)
local void check_header (gz_stream *s)
local int destroy (gz_stream *s)
int ZEXPORT gzread (gzFile file, voidp buf, unsigned len)
int ZEXPORT gzgetc (gzFile file)
char *ZEXPORT gzgets (gzFile file, char *buf, int len)
int ZEXPORT gzwrite (gzFile file, const voidp buf, unsigned len)
int ZEXPORTVA 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 gzputc (gzFile file, int c)
int ZEXPORT gzputs (gzFile file, const char *s)
local int do_flush (gzFile file, int flush)
int ZEXPORT gzflush (gzFile file, int flush)
z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence)
int ZEXPORT gzrewind (gzFile file)
z_off_t ZEXPORT gztell (gzFile file)
int ZEXPORT gzeof (gzFile file)
local void putLong (FILE *file, uLong x)
local uLong getLong (gz_stream *s)
int ZEXPORT gzclose (gzFile file)
const char *ZEXPORT gzerror (gzFile file, int *errnum)

Variables

static int gz_magic [2] = {0x1f, 0x8b}

Class Documentation

struct internal_state

Definition at line 82 of file deflate.h.

Collaboration diagram for internal_state:
Class Members
ush bi_buf
int bi_valid
ush bl_count
long block_start
inflate_blocks_statef * blocks
ushf * d_buf
Byte data_type
uch depth
int dummy
uInt good_match
uInt hash_bits
uInt hash_mask
uInt hash_shift
uInt hash_size
Posf * head
int heap
int heap_len
int heap_max
uInt ins_h
uchf * l_buf
int last_eob_len
int last_flush
uInt last_lit
int level
uInt lit_bufsize
uInt lookahead
int match_available
uInt match_length
uInt match_start
uInt matches
uInt max_chain_length
uInt max_lazy_match
Byte method
inflate_mode mode
int nice_match
int noheader
int nowrap
ulg opt_len
int pending
Bytef * pending_buf
ulg pending_buf_size
Bytef * pending_out
Posf * prev
uInt prev_length
IPos prev_match
ulg static_len
int status
int strategy
z_streamp strm
uInt strstart
union internal_state sub
union internal_state sub
uInt w_bits
uInt w_mask
uInt w_size
uInt wbits
Bytef * window
ulg window_size
struct gz_stream

Definition at line 40 of file gzio.c.

Collaboration diagram for gz_stream:
Class Members
uLong crc
FILE * file
Byte * inbuf
char mode
char * msg
Byte * outbuf
char * path
long startpos
z_stream stream
int transparent
int z_eof
int z_err

Define Documentation

#define ALLOC (   size)    malloc(size)

Definition at line 27 of file gzio.c.

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

Definition at line 33 of file gzio.c.

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

Definition at line 37 of file gzio.c.

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

Definition at line 35 of file gzio.c.

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

Definition at line 34 of file gzio.c.

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

Definition at line 36 of file gzio.c.

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

Definition at line 38 of file gzio.c.

#define TRYFREE (   p)    {if (p) free(p);}

Definition at line 28 of file gzio.c.

#define Z_BUFSIZE   16384

Definition at line 20 of file gzio.c.

#define Z_PRINTF_BUFSIZE   4096

Definition at line 24 of file gzio.c.


Typedef Documentation


Function Documentation

Definition at line 263 of file gzio.c.

{
    int method; /* method byte */
    int flags;  /* flags byte */
    uInt len;
    int c;

    /* Check the gzip magic header */
    for (len = 0; len < 2; len++) {
       c = get_byte(s);
       if (c != gz_magic[len]) {
           if (len != 0) s->stream.avail_in++, s->stream.next_in--;
           if (c != EOF) {
              s->stream.avail_in++, s->stream.next_in--;
              s->transparent = 1;
           }
           s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
           return;
       }
    }
    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;
}

Here is the call graph for this function:

Definition at line 316 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_DEFLATE
           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;
}

Here is the call graph for this function:

local int do_flush ( gzFile  file,
int  flush 
)

Definition at line 600 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->z_err = deflate(&(s->stream), flush);

       /* 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;
}

Here is the call graph for this function:

Definition at line 236 of file gzio.c.

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

Definition at line 804 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;
}

Here is the call graph for this function:

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

Definition at line 73 of file gzio.c.

{
    int err;
    int level = Z_DEFAULT_COMPRESSION; /* compression level */
    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
    char *p = (char*)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->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 {
           *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_DEFLATE
        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[0], gz_magic[1],
             Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
       s->startpos = 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
         * startpos anyway in write mode, so this initialization is not
         * necessary.
         */
    } else {
       check_header(s); /* skip the .gz header */
       s->startpos = (ftell(s->file) - s->stream.avail_in);
    }
    
    return (gzFile)s;
}

Here is the call graph for this function:

Definition at line 822 of file gzio.c.

{
    int err;
    gz_stream *s = (gz_stream*)file;

    if (s == NULL) return Z_STREAM_ERROR;

    if (s->mode == 'w') {
#ifdef NO_DEFLATE
       return Z_STREAM_ERROR;
#else
        err = do_flush (file, Z_FINISH);
        if (err != Z_OK) return destroy((gz_stream*)file);

        putLong (s->file, s->crc);
        putLong (s->file, s->stream.total_in);
#endif
    }
    return destroy((gz_stream*)file);
}

Here is the call graph for this function:

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

Definition at line 194 of file gzio.c.

{
    char name[20];

    if (fd < 0) return (gzFile)Z_NULL;
    sprintf(name, "<fd:%d>", fd); /* for debugging */

    return gz_open (name, mode, fd);
}

Here is the call graph for this function:

int ZEXPORT gzeof ( gzFile  file)

Definition at line 778 of file gzio.c.

{
    gz_stream *s = (gz_stream*)file;
    
    return (s == NULL || s->mode != 'r') ? 0 : s->z_eof;
}
const char* ZEXPORT gzerror ( gzFile  file,
int errnum 
)

Definition at line 851 of file gzio.c.

{
    char *m;
    gz_stream *s = (gz_stream*)file;

    if (s == NULL) {
        *errnum = Z_STREAM_ERROR;
        return (const char*)ERR_MSG(Z_STREAM_ERROR);
    }
    *errnum = s->z_err;
    if (*errnum == Z_OK) return (const char*)"";

    m =  (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);

    if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);

    TRYFREE(s->msg);
    s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
    strcpy(s->msg, s->path);
    strcat(s->msg, ": ");
    strcat(s->msg, m);
    return (const char*)s->msg;
}
int ZEXPORT gzflush ( gzFile  file,
int  flush 
)

Definition at line 639 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;
}

Here is the call graph for this function:

int ZEXPORT gzgetc ( gzFile  file)

Definition at line 449 of file gzio.c.

{
    unsigned char c;

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

Here is the call graph for this function:

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

Definition at line 467 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;
}

Here is the call graph for this function:

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

Definition at line 183 of file gzio.c.

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

Here is the call graph for this function:

int ZEXPORTVA 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 545 of file gzio.c.

{
    char buf[Z_PRINTF_BUFSIZE];
    int len;

#ifdef HAS_snprintf
    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);
#else
    sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
           a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
#endif
    len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
    if (len <= 0) return 0;

    return gzwrite(file, buf, len);
}

Here is the call graph for this function:

int ZEXPORT gzputc ( gzFile  file,
int  c 
)

Definition at line 573 of file gzio.c.

{
    unsigned char cc = (unsigned char) c; /* required for big endian systems */

    return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
}

Here is the call graph for this function:

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

Definition at line 588 of file gzio.c.

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

Here is the call graph for this function:

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

Definition at line 355 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;

    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 -= fread(next_out, 1, s->stream.avail_out,
                                        s->file);
           }
           len -= s->stream.avail_out;
           s->stream.total_in  += (uLong)len;
           s->stream.total_out += (uLong)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 = 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->z_err = inflate(&(s->stream), Z_NO_FLUSH);

       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->stream.total_out) in case of
               * concatenated .gz files. Check for such files:
               */
              check_header(s);
              if (s->z_err == Z_OK) {
                  uLong total_in = s->stream.total_in;
                  uLong total_out = s->stream.total_out;

                  inflateReset(&(s->stream));
                  s->stream.total_in = total_in;
                  s->stream.total_out = total_out;
                  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));

    return (int)(len - s->stream.avail_out);
}

Here is the call graph for this function:

Definition at line 741 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->stream.avail_in = 0;
    s->stream.next_in = s->inbuf;
    s->crc = crc32(0L, Z_NULL, 0);
       
    if (s->startpos == 0) { /* not a compressed file */
       rewind(s->file);
       return 0;
    }

    (void) inflateReset(&s->stream);
    return fseek(s->file, s->startpos, SEEK_SET);
}

Here is the call graph for this function:

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

Definition at line 660 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_DEFLATE
       return -1L;
#else
       if (whence == SEEK_SET) {
           offset -= s->stream.total_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 */
           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 (z_off_t)s->stream.total_in;
#endif
    }
    /* Rest of function is for reading only */

    /* compute absolute position */
    if (whence == SEEK_CUR) {
       offset += s->stream.total_out;
    }
    if (offset < 0) return -1L;

    if (s->transparent) {
       /* map to fseek */
       s->stream.avail_in = 0;
       s->stream.next_in = s->inbuf;
        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;

       s->stream.total_in = s->stream.total_out = (uLong)offset;
       return offset;
    }

    /* For a negative seek, rewind and use positive seek */
    if ((uLong)offset >= s->stream.total_out) {
       offset -= s->stream.total_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);
    }
    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 (z_off_t)s->stream.total_out;
}

Here is the call graph for this function:

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

Definition at line 209 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);
}

Here is the call graph for this function:

Definition at line 768 of file gzio.c.

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

Here is the call graph for this function:

int ZEXPORT gzwrite ( gzFile  file,
const voidp  buf,
unsigned  len 
)

Definition at line 486 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*)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->z_err = deflate(&(s->stream), Z_NO_FLUSH);
        if (s->z_err != Z_OK) break;
    }
    s->crc = crc32(s->crc, (const Bytef *)buf, len);

    return (int)(len - s->stream.avail_in);
}

Here is the call graph for this function:

local gzFile gz_open OF ( (const char *path, const char *mode, intfd)  )
local int do_flush OF ( (gzFile file, int flush)  )
local void putLong OF ( (FILE *file, uLong x )
local void putLong ( FILE *  file,
uLong  x 
)

Definition at line 789 of file gzio.c.

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

Variable Documentation

int gz_magic[2] = {0x1f, 0x8b} [static]

Definition at line 30 of file gzio.c.