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

Macros
#define	LSEEK lseek

Functions
local void gz_reset	OF ((gz_statep))

local gzFile gz_open	OF ((const char , int, const char ))

local void	gz_reset (gz_statep state)

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

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

gzFile ZEXPORT	gzopen64 (const char path, const char mode)

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

int ZEXPORT	gzbuffer (gzFile file, unsigned size)

int ZEXPORT	gzrewind (gzFile file)

z_off64_t ZEXPORT	gzseek64 (gzFile file, z_off64_t offset, int whence)

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

z_off64_t ZEXPORT	gztell64 (gzFile file)

z_off_t ZEXPORT	gztell (gzFile file)

z_off64_t ZEXPORT	gzoffset64 (gzFile file)

z_off_t ZEXPORT	gzoffset (gzFile file)

int ZEXPORT	gzeof (gzFile file)

const char *ZEXPORT	gzerror (gzFile file, int *errnum)

void ZEXPORT	gzclearerr (gzFile file)

void ZLIB_INTERNAL	gz_error (gz_statep state, int err, const char *msg)

unsigned ZLIB_INTERNAL	gz_intmax ()

Macro Definition Documentation

#define LSEEK lseek

Definition at line 18 of file gzlib.c.

Function Documentation

void ZLIB_INTERNAL gz_error	(	gz_statep	state,
		int	err,
		const char *	msg
	)

Definition at line 464 of file gzlib.c.

 {
     /* free previously allocated message and clear */
     if (state->msg != NULL) {
         if (state->err != Z_MEM_ERROR)
             free(state->msg);
         state->msg = NULL;
     }
 
     /* set error code, and if no message, then done */
     state->err = err;
     if (msg == NULL)
         return;
 
     /* for an out of memory error, save as static string */
     if (err == Z_MEM_ERROR) {
         state->msg = (char *)msg;
         return;
     }
 
     /* construct error message with path */
     if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {
         state->err = Z_MEM_ERROR;
         state->msg = (char *)"out of memory";
         return;
     }
     strcpy(state->msg, state->path);
     strcat(state->msg, ": ");
     strcat(state->msg, msg);
     return;
 }

unsigned ZLIB_INTERNAL gz_intmax ( )

Definition at line 501 of file gzlib.c.

 {
     unsigned p, q;
 
     p = 1;
     do {
         q = p;
         p <<= 1;
         p++;
     } while (p > q);
     return q >> 1;
 }

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

Definition at line 92 of file gzlib.c.

 {
     gz_statep state;
 
     /* allocate gzFile structure to return */
     state = (gz_statep)malloc(sizeof(gz_state));
     if (state == NULL)
         return NULL;
     state->size = 0;            /* no buffers allocated yet */
     state->want = GZBUFSIZE;    /* requested buffer size */
     state->msg = NULL;          /* no error message yet */
 
     /* interpret mode */
     state->mode = GZ_NONE;
     state->level = Z_DEFAULT_COMPRESSION;
     state->strategy = Z_DEFAULT_STRATEGY;
     while (*mode) {
         if (*mode >= '0' && *mode <= '9')
             state->level = *mode - '0';
         else
             switch (*mode) {
             case 'r':
                 state->mode = GZ_READ;
                 break;
 #ifndef NO_GZCOMPRESS
             case 'w':
                 state->mode = GZ_WRITE;
                 break;
             case 'a':
                 state->mode = GZ_APPEND;
                 break;
 #endif
             case '+':       /* can't read and write at the same time */
                 free(state);
                 return NULL;
             case 'b':       /* ignore -- will request binary anyway */
                 break;
             case 'f':
                 state->strategy = Z_FILTERED;
                 break;
             case 'h':
                 state->strategy = Z_HUFFMAN_ONLY;
                 break;
             case 'R':
                 state->strategy = Z_RLE;
                 break;
             case 'F':
                 state->strategy = Z_FIXED;
             default:        /* could consider as an error, but just ignore */
                 ;
             }
         mode++;
     }
 
     /* must provide an "r", "w", or "a" */
     if (state->mode == GZ_NONE) {
         free(state);
         return NULL;
     }
 
     /* save the path name for error messages */
     state->path = (char *)malloc(strlen(path) + 1);
     if (state->path == NULL) {
         free(state);
         return NULL;
     }
     strcpy(state->path, path);
 
     /* open the file with the appropriate mode (or just use fd) */
     state->fd = fd != -1 ? fd :
         open(path,
 #ifdef O_LARGEFILE
             O_LARGEFILE |
 #endif
 #ifdef O_BINARY
             O_BINARY |
 #endif
             (state->mode == GZ_READ ?
                 O_RDONLY :
                 (O_WRONLY | O_CREAT | (
                     state->mode == GZ_WRITE ?
                         O_TRUNC :
                         O_APPEND))),
             0666);
     if (state->fd == -1) {
         free(state->path);
         free(state);
         return NULL;
     }
     if (state->mode == GZ_APPEND)
         state->mode = GZ_WRITE;         /* simplify later checks */
 
     /* save the current position for rewinding (only if reading) */
     if (state->mode == GZ_READ) {
         state->start = LSEEK(state->fd, 0, SEEK_CUR);
         if (state->start == -1) state->start = 0;
     }
 
     /* initialize stream */
     gz_reset(state);
 
     /* return stream */
     return (gzFile)state;
 }

local void gz_reset ( gz_statep state )

Definition at line 77 of file gzlib.c.

 {
     if (state->mode == GZ_READ) {   /* for reading ... */
         state->have = 0;            /* no output data available */
         state->eof = 0;             /* not at end of file */
         state->how = LOOK;          /* look for gzip header */
         state->direct = 1;          /* default for empty file */
     }
     state->seek = 0;                /* no seek request pending */
     gz_error(state, Z_OK, NULL);    /* clear error */
     state->pos = 0;                 /* no uncompressed data yet */
     state->strm.avail_in = 0;       /* no input data yet */
 }

int ZEXPORT gzbuffer	(	gzFile	file,
		unsigned	size
	)

Definition at line 224 of file gzlib.c.

 {
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
     /* make sure we haven't already allocated memory */
     if (state->size != 0)
         return -1;
 
     /* check and set requested size */
     if (size == 0)
         return -1;
     state->want = size;
     return 0;
 }

void ZEXPORT gzclearerr ( gzFile file )

Definition at line 441 of file gzlib.c.

 {
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return;
 
     /* clear error and end-of-file */
     if (state->mode == GZ_READ)
         state->eof = 0;
     gz_error(state, Z_OK, NULL);
 }

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

Definition at line 210 of file gzlib.c.

 {
     char *path;         /* identifier for error messages */
     gzFile gz;
 
     if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
         return NULL;
     sprintf(path, "<fd:%d>", fd);   /* for debugging */
     gz = gz_open(path, fd, mode);
     free(path);
     return gz;
 }

int ZEXPORT gzeof ( gzFile file )

Definition at line 406 of file gzlib.c.

 {
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return 0;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return 0;
 
     /* return end-of-file state */
     return state->mode == GZ_READ ?
         (state->eof && state->strm.avail_in == 0 && state->have == 0) : 0;
 }

const char* ZEXPORT gzerror	(	gzFile	file,
		int *	errnum
	)

Definition at line 423 of file gzlib.c.

 {
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return NULL;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return NULL;
 
     /* return error information */
     if (errnum != NULL)
         *errnum = state->err;
     return state->msg == NULL ? "" : state->msg;
 }

z_off_t ZEXPORT gzoffset ( gzFile file )

Definition at line 397 of file gzlib.c.

 {
     z_off64_t ret;
 
     ret = gzoffset64(file);
     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 }

z_off64_t ZEXPORT gzoffset64 ( gzFile file )

Definition at line 375 of file gzlib.c.

 {
     z_off64_t offset;
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
     /* compute and return effective offset in file */
     offset = LSEEK(state->fd, 0, SEEK_CUR);
     if (offset == -1)
         return -1;
     if (state->mode == GZ_READ)             /* reading */
         offset -= state->strm.avail_in;     /* don't count buffered input */
     return offset;
 }

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

Definition at line 198 of file gzlib.c.

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

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

Definition at line 204 of file gzlib.c.

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

int ZEXPORT gzrewind ( gzFile file )

Definition at line 247 of file gzlib.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;
 
     /* back up and start over */
     if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
         return -1;
     gz_reset(state);
     return 0;
 }

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

Definition at line 341 of file gzlib.c.

 {
     z_off64_t ret;
 
     ret = gzseek64(file, (z_off64_t)offset, whence);
     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 }

z_off64_t ZEXPORT gzseek64	(	gzFile	file,
		z_off64_t	offset,
		int	whence
	)

Definition at line 268 of file gzlib.c.

 {
     unsigned n;
     z_off64_t ret;
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
     /* check that there's no error */
     if (state->err != Z_OK)
         return -1;
 
     /* can only seek from start or relative to current position */
     if (whence != SEEK_SET && whence != SEEK_CUR)
         return -1;
 
     /* normalize offset to a SEEK_CUR specification */
     if (whence == SEEK_SET)
         offset -= state->pos;
     else if (state->seek)
         offset += state->skip;
     state->seek = 0;
 
     /* if within raw area while reading, just go there */
     if (state->mode == GZ_READ && state->how == COPY &&
         state->pos + offset >= state->raw) {
         ret = LSEEK(state->fd, offset - state->have, SEEK_CUR);
         if (ret == -1)
             return -1;
         state->have = 0;
         state->eof = 0;
         state->seek = 0;
         gz_error(state, Z_OK, NULL);
         state->strm.avail_in = 0;
         state->pos += offset;
         return state->pos;
     }
 
     /* calculate skip amount, rewinding if needed for back seek when reading */
     if (offset < 0) {
         if (state->mode != GZ_READ)         /* writing -- can't go backwards */
             return -1;
         offset += state->pos;
         if (offset < 0)                     /* before start of file! */
             return -1;
         if (gzrewind(file) == -1)           /* rewind, then skip to offset */
             return -1;
     }
 
     /* if reading, skip what's in output buffer (one less gzgetc() check) */
     if (state->mode == GZ_READ) {
         n = GT_OFF(state->have) || (z_off64_t)state->have > offset ?
             (unsigned)offset : state->have;
         state->have -= n;
         state->next += n;
         state->pos += n;
         offset -= n;
     }
 
     /* request skip (if not zero) */
     if (offset) {
         state->seek = 1;
         state->skip = offset;
     }
     return state->pos + offset;
 }

z_off_t ZEXPORT gztell ( gzFile file )

Definition at line 366 of file gzlib.c.

 {
     z_off64_t ret;
 
     ret = gztell64(file);
     return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 }

z_off64_t ZEXPORT gztell64 ( gzFile file )

Definition at line 350 of file gzlib.c.

 {
     gz_statep state;
 
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
     state = (gz_statep)file;
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
     /* return position */
     return state->pos + (state->seek ? state->skip : 0);
 }

local void gz_reset OF ( (gz_statep) )

local gzFile gz_open OF ( (const char *, int, const char *) )

Macros

Functions

Macro Definition Documentation

Function Documentation