gzwrite.c File Reference

#include "gzguts.h"

Go to the source code of this file.

Functions
int gz_init	OF ((gz_statep))
int gz_comp	OF ((gz_statep, int))
int gz_zero	OF ((gz_statep, z_off64_t))
z_size_t gz_write	OF ((gz_statep, voidpc, z_size_t))
int	gz_init (gz_statep state)
int	gz_comp (gz_statep state, int flush)
int	gz_zero (gz_statep state, z_off64_t len)
z_size_t	gz_write (gz_statep state, voidpc buf, z_size_t len)
int ZEXPORT	gzwrite (gzFile file, voidpc buf, unsigned len)
z_size_t ZEXPORT	gzfwrite (voidpc buf, z_size_t size, z_size_t nitems, gzFile file)
int ZEXPORT	gzputc (gzFile file, int c)
int ZEXPORT	gzputs (gzFile file, const char *s)
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	gzflush (gzFile file, int flush)
int ZEXPORT	gzsetparams (gzFile file, int level, int strategy)
int ZEXPORT	gzclose_w (gzFile file)

Function Documentation

gz_comp()

int gz_comp	(	gz_statep	state,
		int	flush
	)

Definition at line 73 of file gzwrite.c.

{
    int ret, writ;
    unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
    z_streamp strm = &(state->strm);
 
    /* allocate memory if this is the first time through */
    if (state->size == 0 && gz_init(state) == -1)
        return -1;
 
    /* write directly if requested */
    if (state->direct) {
        while (strm->avail_in) {
            put = strm->avail_in > max ? max : strm->avail_in;
            writ = write(state->fd, strm->next_in, put);
            if (writ < 0) {
                gz_error(state, Z_ERRNO, zstrerror());
                return -1;
            }
            strm->avail_in -= (unsigned)writ;
            strm->next_in += writ;
        }
        return 0;
    }
 
    /* check for a pending reset */
    if (state->reset) {
        /* don't start a new gzip member unless there is data to write */
        if (strm->avail_in == 0)
            return 0;
        deflateReset(strm);
        state->reset = 0;
    }
 
    /* run deflate() on provided input until it produces no more output */
    ret = Z_OK;
    do {
        /* write out current buffer contents if full, or if flushing, but if
           doing Z_FINISH then don't write until we get to Z_STREAM_END */
        if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
            (flush != Z_FINISH || ret == Z_STREAM_END))) {
            while (strm->next_out > state->x.next) {
                put = strm->next_out - state->x.next > (int)max ? max :
                      (unsigned)(strm->next_out - state->x.next);
                writ = write(state->fd, state->x.next, put);
                if (writ < 0) {
                    gz_error(state, Z_ERRNO, zstrerror());
                    return -1;
                }
                state->x.next += writ;
            }
            if (strm->avail_out == 0) {
                strm->avail_out = state->size;
                strm->next_out = state->out;
                state->x.next = state->out;
            }
        }
 
        /* compress */
        have = strm->avail_out;
        ret = deflate(strm, flush);
        if (ret == Z_STREAM_ERROR) {
            gz_error(state, Z_STREAM_ERROR,
                      "internal error: deflate stream corrupt");
            return -1;
        }
        have -= strm->avail_out;
    } while (have);
 
    /* if that completed a deflate stream, allow another to start */
    if (flush == Z_FINISH)
        state->reset = 1;
 
    /* all done, no errors */
    return 0;
}

Referenced by gz_write(), gz_zero(), gzclose_w(), gzflush(), gzprintf(), and gzsetparams().

gz_init()

int gz_init

(

gz_statep

state

)

Definition at line 17 of file gzwrite.c.

{
    int ret;
    z_streamp strm = &(state->strm);
 
    /* allocate input buffer (double size for gzprintf) */
    state->in = (unsigned char *)malloc(state->want << 1);
    if (state->in == NULL) {
        gz_error(state, Z_MEM_ERROR, "out of memory");
        return -1;
    }
 
    /* only need output buffer and deflate state if compressing */
    if (!state->direct) {
        /* allocate output buffer */
        state->out = (unsigned char *)malloc(state->want);
        if (state->out == NULL) {
            free(state->in);
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
 
        /* allocate deflate memory, set up for gzip compression */
        strm->zalloc = Z_NULL;
        strm->zfree = Z_NULL;
        strm->opaque = Z_NULL;
        ret = deflateInit2(strm, state->level, Z_DEFLATED,
                           MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
        if (ret != Z_OK) {
            free(state->out);
            free(state->in);
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
        strm->next_in = NULL;
    }
 
    /* mark state as initialized */
    state->size = state->want;
 
    /* initialize write buffer if compressing */
    if (!state->direct) {
        strm->avail_out = state->size;
        strm->next_out = state->out;
        state->x.next = strm->next_out;
    }
    return 0;
}

Referenced by gz_comp(), gz_write(), and gzprintf().

gz_write()

z_size_t gz_write	(	gz_statep	state,
		voidpc	buf,
		z_size_t	len
	)

Definition at line 187 of file gzwrite.c.

{
    z_size_t put = len;
 
    /* if len is zero, avoid unnecessary operations */
    if (len == 0)
        return 0;
 
    /* allocate memory if this is the first time through */
    if (state->size == 0 && gz_init(state) == -1)
        return 0;
 
    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return 0;
    }
 
    /* for small len, copy to input buffer, otherwise compress directly */
    if (len < state->size) {
        /* copy to input buffer, compress when full */
        do {
            unsigned have, copy;
 
            if (state->strm.avail_in == 0)
                state->strm.next_in = state->in;
            have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
                              state->in);
            copy = state->size - have;
            if (copy > len)
                copy = (unsigned)len;
            memcpy(state->in + have, buf, copy);
            state->strm.avail_in += copy;
            state->x.pos += copy;
            buf = (const char *)buf + copy;
            len -= copy;
            if (len && gz_comp(state, Z_NO_FLUSH) == -1)
                return 0;
        } while (len);
    }
    else {
        /* consume whatever's left in the input buffer */
        if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
            return 0;
 
        /* directly compress user buffer to file */
        state->strm.next_in = (z_const Bytef *)buf;
        do {
            unsigned n = (unsigned)-1;
            if (n > len)
                n = (unsigned)len;
            state->strm.avail_in = n;
            state->x.pos += n;
            if (gz_comp(state, Z_NO_FLUSH) == -1)
                return 0;
            len -= n;
        } while (len);
    }
 
    /* input was all buffered or compressed */
    return put;
}

Referenced by gzfwrite(), gzputc(), gzputs(), and gzwrite().

gz_zero()

int gz_zero	(	gz_statep	state,
		z_off64_t	len
	)

Definition at line 154 of file gzwrite.c.

{
    int first;
    unsigned n;
    z_streamp strm = &(state->strm);
 
    /* consume whatever's left in the input buffer */
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
        return -1;
 
    /* compress len zeros (len guaranteed > 0) */
    first = 1;
    while (len) {
        n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
            (unsigned)len : state->size;
        if (first) {
            memset(state->in, 0, n);
            first = 0;
        }
        strm->avail_in = n;
        strm->next_in = state->in;
        state->x.pos += n;
        if (gz_comp(state, Z_NO_FLUSH) == -1)
            return -1;
        len -= n;
    }
    return 0;
}

Referenced by gz_write(), gzclose_w(), gzflush(), gzprintf(), gzputc(), and gzsetparams().

gzclose_w()

int ZEXPORT gzclose_w

(

gzFile

file

)

Definition at line 639 of file gzwrite.c.

{
    int ret = Z_OK;
    gz_statep state;
 
    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;
 
    /* check that we're writing */
    if (state->mode != GZ_WRITE)
        return Z_STREAM_ERROR;
 
    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            ret = state->err;
    }
 
    /* flush, free memory, and close file */
    if (gz_comp(state, Z_FINISH) == -1)
        ret = state->err;
    if (state->size) {
        if (!state->direct) {
            (void)deflateEnd(&(state->strm));
            free(state->out);
        }
        free(state->in);
    }
    gz_error(state, Z_OK, NULL);
    free(state->path);
    if (close(state->fd) == -1)
        ret = Z_ERRNO;
    free(state);
    return ret;
}

Referenced by gzclose().

gzflush()

int ZEXPORT gzflush	(	gzFile	file,
		int	flush
	)

Definition at line 565 of file gzwrite.c.

{
    gz_statep state;
 
    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;
 
    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return Z_STREAM_ERROR;
 
    /* check flush parameter */
    if (flush < 0 || flush > Z_FINISH)
        return Z_STREAM_ERROR;
 
    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return state->err;
    }
 
    /* compress remaining data with requested flush */
    (void)gz_comp(state, flush);
    return state->err;
}

gzfwrite()

z_size_t ZEXPORT gzfwrite	(	voidpc	buf,
		z_size_t	size,
		z_size_t	nitems,
		gzFile	file
	)

Definition at line 283 of file gzwrite.c.

{
    z_size_t len;
    gz_statep state;
 
    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;
 
    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return 0;
 
    /* compute bytes to read -- error on overflow */
    len = nitems * size;
    if (size && len / size != nitems) {
        gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
        return 0;
    }
 
    /* write len bytes to buf, return the number of full items written */
    return len ? gz_write(state, buf, len) / size : 0;
}

gzprintf()

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 477 of file gzwrite.c.

{
    unsigned len, left;
    char *next;
    gz_statep state;
    z_streamp strm;
 
    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;
    strm = &(state->strm);
 
    /* check that can really pass pointer in ints */
    if (sizeof(int) != sizeof(void *))
        return Z_STREAM_ERROR;
 
    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return Z_STREAM_ERROR;
 
    /* make sure we have some buffer space */
    if (state->size == 0 && gz_init(state) == -1)
        return state->error;
 
    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return state->error;
    }
 
    /* do the printf() into the input buffer, put length in len -- the input
       buffer is double-sized just for this function, so there is guaranteed to
       be state->size bytes available after the current contents */
    if (strm->avail_in == 0)
        strm->next_in = state->in;
    next = (char *)(strm->next_in + strm->avail_in);
    next[state->size - 1] = 0;
#ifdef NO_snprintf
#  ifdef HAS_sprintf_void
    sprintf(next, 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 < size; len++)
        if (next[len] == 0)
            break;
#  else
    len = sprintf(next, 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(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
             a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
    len = strlen(next);
#  else
    len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
                   a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
#  endif
#endif
 
    /* check that printf() results fit in buffer */
    if (len == 0 || len >= state->size || next[state->size - 1] != 0)
        return 0;
 
    /* update buffer and position, compress first half if past that */
    strm->avail_in += len;
    state->x.pos += len;
    if (strm->avail_in >= state->size) {
        left = strm->avail_in - state->size;
        strm->avail_in = state->size;
        if (gz_comp(state, Z_NO_FLUSH) == -1)
            return state->err;
        memmove(state->in, state->in + state->size, left);
        strm->next_in = state->in;
        strm->avail_in = left;
    }
    return (int)len;
}

gzputc()

int ZEXPORT gzputc	(	gzFile	file,
		int	c
	)

Definition at line 313 of file gzwrite.c.

{
    unsigned have;
    unsigned char buf[1];
    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 writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return -1;
 
    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return -1;
    }
 
    /* try writing to input buffer for speed (state->size == 0 if buffer not
       initialized) */
    if (state->size) {
        if (strm->avail_in == 0)
            strm->next_in = state->in;
        have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
        if (have < state->size) {
            state->in[have] = (unsigned char)c;
            strm->avail_in++;
            state->x.pos++;
            return c & 0xff;
        }
    }
 
    /* no room in buffer or not initialized, use gz_write() */
    buf[0] = (unsigned char)c;
    if (gz_write(state, buf, 1) != 1)
        return -1;
    return c & 0xff;
}

gzputs()

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

Definition at line 361 of file gzwrite.c.

{
    z_size_t len, put;
    gz_statep state;
 
    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;
 
    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return -1;
 
    /* write string */
    len = strlen(s);
    if ((int)len < 0 || (unsigned)len != len) {
        gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
        return -1;
    }
    put = gz_write(state, s, len);
    return put < len ? -1 : (int)len;
}

gzsetparams()

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

Definition at line 597 of file gzwrite.c.

{
    gz_statep state;
    z_streamp strm;
 
    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;
    strm = &(state->strm);
 
    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return Z_STREAM_ERROR;
 
    /* if no change is requested, then do nothing */
    if (level == state->level && strategy == state->strategy)
        return Z_OK;
 
    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return state->err;
    }
 
    /* change compression parameters for subsequent input */
    if (state->size) {
        /* flush previous input with previous parameters before changing */
        if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
            return state->err;
        deflateParams(strm, level, strategy);
    }
    state->level = level;
    state->strategy = strategy;
    return Z_OK;
}

gzwrite()

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

Definition at line 255 of file gzwrite.c.

{
    gz_statep state;
 
    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;
 
    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return 0;
 
    /* since an int is returned, make sure len fits in one, otherwise return
       with an error (this avoids a flaw in the interface) */
    if ((int)len < 0) {
        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
        return 0;
    }
 
    /* write len bytes from buf (the return value will fit in an int) */
    return (int)gz_write(state, buf, len);
}

OF() [1/4]

int gz_init OF

(

(gz_statep)

)

OF() [2/4]

int gz_comp OF

(

(gz_statep, int)

)

OF() [3/4]

z_size_t gz_write OF

(

(gz_statep, voidpc, z_size_t)

)

OF() [4/4]

int gz_zero OF

(

(gz_statep, z_off64_t)

)