3rdparty/zlib/gzwrite.c

/* gzwrite.c -- zlib functions for writing gzip files
 * Copyright (C) 2004, 2005, 2010 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

#include "gzguts.h"

/* Local functions */
local int gz_init OF((gz_statep));
local int gz_comp OF((gz_statep, int));
local int gz_zero OF((gz_statep, z_off64_t));

/* Initialize state for writing a gzip file.  Mark initialization by setting
   state->size to non-zero.  Return -1 on failure or 0 on success. */
local int gz_init(state)
    gz_statep state;
{
    int ret;
    z_streamp strm = &(state->strm);

    /* allocate input and output buffers */
    state->in = malloc(state->want);
    state->out = malloc(state->want);
    if (state->in == NULL || state->out == NULL) {
        if (state->out != NULL)
            free(state->out);
        if (state->in != 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,
                       15 + 16, 8, state->strategy);
    if (ret != Z_OK) {
        free(state->in);
        gz_error(state, Z_MEM_ERROR, "out of memory");
        return -1;
    }

    /* mark state as initialized */
    state->size = state->want;

    /* initialize write buffer */
    strm->avail_out = state->size;
    strm->next_out = state->out;
    state->next = strm->next_out;
    return 0;
}

/* Compress whatever is at avail_in and next_in and write to the output file.
   Return -1 if there is an error writing to the output file, otherwise 0.
   flush is assumed to be a valid deflate() flush value.  If flush is Z_FINISH,
   then the deflate() state is reset to start a new gzip stream. */
local int gz_comp(state, flush)
    gz_statep state;
    int flush;
{
    int ret, got;
    unsigned have;
    z_streamp strm = &(state->strm);

    /* allocate memory if this is the first time through */
    if (state->size == 0 && gz_init(state) == -1)
        return -1;

    /* 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))) {
            have = (unsigned)(strm->next_out - state->next);
            if (have && ((got = write(state->fd, state->next, have)) < 0 ||
                         (unsigned)got != have)) {
                gz_error(state, Z_ERRNO, zstrerror());
                return -1;
            }
            if (strm->avail_out == 0) {
                strm->avail_out = state->size;
                strm->next_out = state->out;
            }
            state->next = strm->next_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)
        deflateReset(strm);

    /* all done, no errors */
    return 0;
}

/* Compress len zeros to output.  Return -1 on error, 0 on success. */
local int gz_zero(state, len)
    gz_statep state;
    z_off64_t len;
{
    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->pos += n;
        if (gz_comp(state, Z_NO_FLUSH) == -1)
            return -1;
        len -= n;
    }
    return 0;
}

/* -- see zlib.h -- */
int ZEXPORT gzwrite(file, buf, len)
    gzFile file;
    voidpc buf;
    unsigned len;
{
    unsigned put = len;
    unsigned n;
    gz_statep state;
    z_streamp strm;

    /* get internal structure */
    if (file == NULL)
        return 0;
    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 0;

    /* since an int is returned, make sure len fits in one, otherwise return
       with an error (this avoids the flaw in the interface) */
    if ((int)len < 0) {
        gz_error(state, Z_BUF_ERROR, "requested length does not fit in int");
        return 0;
    }

    /* 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 {
            if (strm->avail_in == 0)
                strm->next_in = state->in;
            n = state->size - strm->avail_in;
            if (n > len)
                n = len;
            memcpy(strm->next_in + strm->avail_in, buf, n);
            strm->avail_in += n;
            state->pos += n;
            buf = (char *)buf + n;
            len -= n;
            if (len && gz_comp(state, Z_NO_FLUSH) == -1)
                return 0;
        } while (len);
    }
    else {
        /* consume whatever's left in the input buffer */
        if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
            return 0;

        /* directly compress user buffer to file */
        strm->avail_in = len;
        strm->next_in = (voidp)buf;
        state->pos += len;
        if (gz_comp(state, Z_NO_FLUSH) == -1)
            return 0;
    }

    /* input was all buffered or compressed (put will fit in int) */
    return (int)put;
}

/* -- see zlib.h -- */
int ZEXPORT gzputc(file, c)
    gzFile file;
    int c;
{
    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 (strm->avail_in < state->size) {
        if (strm->avail_in == 0)
            strm->next_in = state->in;
        strm->next_in[strm->avail_in++] = c;
        state->pos++;
        return c;
    }

    /* no room in buffer or not initialized, use gz_write() */
    buf[0] = c;
    if (gzwrite(file, buf, 1) != 1)
        return -1;
    return c;
}

/* -- see zlib.h -- */
int ZEXPORT gzputs(file, str)
    gzFile file;
    const char *str;
{
    int ret;
    unsigned len;

    /* write string */
    len = (unsigned)strlen(str);
    ret = gzwrite(file, str, len);
    return ret == 0 && len != 0 ? -1 : ret;
}

#ifdef STDC
#include <stdarg.h>

/* -- see zlib.h -- */
int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
{
    int size, len;
    gz_statep state;
    z_streamp strm;
    va_list va;

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

    /* make sure we have some buffer space */
    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;
    }

    /* consume whatever's left in the input buffer */
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
        return 0;

    /* do the printf() into the input buffer, put length in len */
    size = (int)(state->size);
    state->in[size - 1] = 0;
    va_start(va, format);
#ifdef NO_vsnprintf
#  ifdef HAS_vsprintf_void
    (void)vsprintf(state->in, format, va);
    va_end(va);
    for (len = 0; len < size; len++)
        if (state->in[len] == 0) break;
#  else
    len = vsprintf(state->in, format, va);
    va_end(va);
#  endif
#else
#  ifdef HAS_vsnprintf_void
    (void)vsnprintf(state->in, size, format, va);
    va_end(va);
    len = strlen(state->in);
#  else
    len = vsnprintf((char *)(state->in), size, format, va);
    va_end(va);
#  endif
#endif

    /* check that printf() results fit in buffer */
    if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
        return 0;

    /* update buffer and position, defer compression until needed */
    strm->avail_in = (unsigned)len;
    strm->next_in = state->in;
    state->pos += len;
    return len;
}

#else /* !STDC */

/* -- see zlib.h -- */
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
                       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
    gzFile file;
    const char *format;
    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
{
    int size, len;
    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 0;

    /* make sure we have some buffer space */
    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;
    }

    /* consume whatever's left in the input buffer */
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
        return 0;

    /* do the printf() into the input buffer, put length in len */
    size = (int)(state->size);
    state->in[size - 1] = 0;
#ifdef NO_snprintf
#  ifdef HAS_sprintf_void
    sprintf(state->in, 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 (state->in[len] == 0) break;
#  else
    len = sprintf(state->in, 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(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8,
             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
    len = strlen(state->in);
#  else
    len = snprintf(state->in, 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 >= (int)size || state->in[size - 1] != 0)
        return 0;

    /* update buffer and position, defer compression until needed */
    strm->avail_in = (unsigned)len;
    strm->next_in = state->in;
    state->pos += len;
    return len;
}

#endif

/* -- see zlib.h -- */
int ZEXPORT gzflush(file, flush)
    gzFile file;
    int flush;
{
    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 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 -1;
    }

    /* compress remaining data with requested flush */
    gz_comp(state, flush);
    return state->err;
}

/* -- see zlib.h -- */
int ZEXPORT gzsetparams(file, level, strategy)
    gzFile file;
    int level;
    int strategy;
{
    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 -1;
    }

    /* 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_PARTIAL_FLUSH) == -1)
            return state->err;
        deflateParams(strm, level, strategy);
    }
    state->level = level;
    state->strategy = strategy;
    return Z_OK;
}

/* -- see zlib.h -- */
int ZEXPORT gzclose_w(file)
    gzFile file;
{
    int ret = 0;
    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;
        ret += gz_zero(state, state->skip);
    }

    /* flush, free memory, and close file */
    ret += gz_comp(state, Z_FINISH);
    (void)deflateEnd(&(state->strm));
    free(state->out);
    free(state->in);
    gz_error(state, Z_OK, NULL);
    free(state->path);
    ret += close(state->fd);
    free(state);
    return ret ? Z_ERRNO : Z_OK;
}
1	/* gzwrite.c -- zlib functions for writing gzip files
2	* Copyright (C) 2004, 2005, 2010 Mark Adler
3	* For conditions of distribution and use, see copyright notice in zlib.h
4	*/
5
6	#include "gzguts.h"
7
8	/* Local functions */
9	local int gz_init OF((gz_statep));
10	local int gz_comp OF((gz_statep, int));
11	local int gz_zero OF((gz_statep, z_off64_t));
12
13	/* Initialize state for writing a gzip file. Mark initialization by setting
14	state->size to non-zero. Return -1 on failure or 0 on success. */
15	local int gz_init(state)
16	gz_statep state;
17	{
18	int ret;
19	z_streamp strm = &(state->strm);
20
21	/* allocate input and output buffers */
22	state->in = malloc(state->want);
23	state->out = malloc(state->want);
24	if (state->in == NULL \|\| state->out == NULL) {
25	if (state->out != NULL)
26	free(state->out);
27	if (state->in != NULL)
28	free(state->in);
29	gz_error(state, Z_MEM_ERROR, "out of memory");
30	return -1;
31	}
32
33	/* allocate deflate memory, set up for gzip compression */
34	strm->zalloc = Z_NULL;
35	strm->zfree = Z_NULL;
36	strm->opaque = Z_NULL;
37	ret = deflateInit2(strm, state->level, Z_DEFLATED,
38	15 + 16, 8, state->strategy);
39	if (ret != Z_OK) {
40	free(state->in);
41	gz_error(state, Z_MEM_ERROR, "out of memory");
42	return -1;
43	}
44
45	/* mark state as initialized */
46	state->size = state->want;
47
48	/* initialize write buffer */
49	strm->avail_out = state->size;
50	strm->next_out = state->out;
51	state->next = strm->next_out;
52	return 0;
53	}
54
55	/* Compress whatever is at avail_in and next_in and write to the output file.
56	Return -1 if there is an error writing to the output file, otherwise 0.
57	flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH,
58	then the deflate() state is reset to start a new gzip stream. */
59	local int gz_comp(state, flush)
60	gz_statep state;
61	int flush;
62	{
63	int ret, got;
64	unsigned have;
65	z_streamp strm = &(state->strm);
66
67	/* allocate memory if this is the first time through */
68	if (state->size == 0 && gz_init(state) == -1)
69	return -1;
70
71	/* run deflate() on provided input until it produces no more output */
72	ret = Z_OK;
73	do {
74	/* write out current buffer contents if full, or if flushing, but if
75	doing Z_FINISH then don't write until we get to Z_STREAM_END */
76	if (strm->avail_out == 0 \|\| (flush != Z_NO_FLUSH &&
77	(flush != Z_FINISH \|\| ret == Z_STREAM_END))) {
78	have = (unsigned)(strm->next_out - state->next);
79	if (have && ((got = write(state->fd, state->next, have)) < 0 \|\|
80	(unsigned)got != have)) {
81	gz_error(state, Z_ERRNO, zstrerror());
82	return -1;
83	}
84	if (strm->avail_out == 0) {
85	strm->avail_out = state->size;
86	strm->next_out = state->out;
87	}
88	state->next = strm->next_out;
89	}
90
91	/* compress */
92	have = strm->avail_out;
93	ret = deflate(strm, flush);
94	if (ret == Z_STREAM_ERROR) {
95	gz_error(state, Z_STREAM_ERROR,
96	"internal error: deflate stream corrupt");
97	return -1;
98	}
99	have -= strm->avail_out;
100	} while (have);
101
102	/* if that completed a deflate stream, allow another to start */
103	if (flush == Z_FINISH)
104	deflateReset(strm);
105
106	/* all done, no errors */
107	return 0;
108	}
109
110	/* Compress len zeros to output. Return -1 on error, 0 on success. */
111	local int gz_zero(state, len)
112	gz_statep state;
113	z_off64_t len;
114	{
115	int first;
116	unsigned n;
117	z_streamp strm = &(state->strm);
118
119	/* consume whatever's left in the input buffer */
120	if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
121	return -1;
122
123	/* compress len zeros (len guaranteed > 0) */
124	first = 1;
125	while (len) {
126	n = GT_OFF(state->size) \|\| (z_off64_t)state->size > len ?
127	(unsigned)len : state->size;
128	if (first) {
129	memset(state->in, 0, n);
130	first = 0;
131	}
132	strm->avail_in = n;
133	strm->next_in = state->in;
134	state->pos += n;
135	if (gz_comp(state, Z_NO_FLUSH) == -1)
136	return -1;
137	len -= n;
138	}
139	return 0;
140	}
141
142	/* -- see zlib.h -- */
143	int ZEXPORT gzwrite(file, buf, len)
144	gzFile file;
145	voidpc buf;
146	unsigned len;
147	{
148	unsigned put = len;
149	unsigned n;
150	gz_statep state;
151	z_streamp strm;
152
153	/* get internal structure */
154	if (file == NULL)
155	return 0;
156	state = (gz_statep)file;
157	strm = &(state->strm);
158
159	/* check that we're writing and that there's no error */
160	if (state->mode != GZ_WRITE \|\| state->err != Z_OK)
161	return 0;
162
163	/* since an int is returned, make sure len fits in one, otherwise return
164	with an error (this avoids the flaw in the interface) */
165	if ((int)len < 0) {
166	gz_error(state, Z_BUF_ERROR, "requested length does not fit in int");
167	return 0;
168	}
169
170	/* if len is zero, avoid unnecessary operations */
171	if (len == 0)
172	return 0;
173
174	/* allocate memory if this is the first time through */
175	if (state->size == 0 && gz_init(state) == -1)
176	return 0;
177
178	/* check for seek request */
179	if (state->seek) {
180	state->seek = 0;
181	if (gz_zero(state, state->skip) == -1)
182	return 0;
183	}
184
185	/* for small len, copy to input buffer, otherwise compress directly */
186	if (len < state->size) {
187	/* copy to input buffer, compress when full */
188	do {
189	if (strm->avail_in == 0)
190	strm->next_in = state->in;
191	n = state->size - strm->avail_in;
192	if (n > len)
193	n = len;
194	memcpy(strm->next_in + strm->avail_in, buf, n);
195	strm->avail_in += n;
196	state->pos += n;
197	buf = (char *)buf + n;
198	len -= n;
199	if (len && gz_comp(state, Z_NO_FLUSH) == -1)
200	return 0;
201	} while (len);
202	}
203	else {
204	/* consume whatever's left in the input buffer */
205	if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
206	return 0;
207
208	/* directly compress user buffer to file */
209	strm->avail_in = len;
210	strm->next_in = (voidp)buf;
211	state->pos += len;
212	if (gz_comp(state, Z_NO_FLUSH) == -1)
213	return 0;
214	}
215
216	/* input was all buffered or compressed (put will fit in int) */
217	return (int)put;
218	}
219
220	/* -- see zlib.h -- */
221	int ZEXPORT gzputc(file, c)
222	gzFile file;
223	int c;
224	{
225	unsigned char buf[1];
226	gz_statep state;
227	z_streamp strm;
228
229	/* get internal structure */
230	if (file == NULL)
231	return -1;
232	state = (gz_statep)file;
233	strm = &(state->strm);
234
235	/* check that we're writing and that there's no error */
236	if (state->mode != GZ_WRITE \|\| state->err != Z_OK)
237	return -1;
238
239	/* check for seek request */
240	if (state->seek) {
241	state->seek = 0;
242	if (gz_zero(state, state->skip) == -1)
243	return -1;
244	}
245
246	/* try writing to input buffer for speed (state->size == 0 if buffer not
247	initialized) */
248	if (strm->avail_in < state->size) {
249	if (strm->avail_in == 0)
250	strm->next_in = state->in;
251	strm->next_in[strm->avail_in++] = c;
252	state->pos++;
253	return c;
254	}
255
256	/* no room in buffer or not initialized, use gz_write() */
257	buf[0] = c;
258	if (gzwrite(file, buf, 1) != 1)
259	return -1;
260	return c;
261	}
262
263	/* -- see zlib.h -- */
264	int ZEXPORT gzputs(file, str)
265	gzFile file;
266	const char *str;
267	{
268	int ret;
269	unsigned len;
270
271	/* write string */
272	len = (unsigned)strlen(str);
273	ret = gzwrite(file, str, len);
274	return ret == 0 && len != 0 ? -1 : ret;
275	}
276
277	#ifdef STDC
278	#include <stdarg.h>
279
280	/* -- see zlib.h -- */
281	int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
282	{
283	int size, len;
284	gz_statep state;
285	z_streamp strm;
286	va_list va;
287
288	/* get internal structure */
289	if (file == NULL)
290	return -1;
291	state = (gz_statep)file;
292	strm = &(state->strm);
293
294	/* check that we're writing and that there's no error */
295	if (state->mode != GZ_WRITE \|\| state->err != Z_OK)
296	return 0;
297
298	/* make sure we have some buffer space */
299	if (state->size == 0 && gz_init(state) == -1)
300	return 0;
301
302	/* check for seek request */
303	if (state->seek) {
304	state->seek = 0;
305	if (gz_zero(state, state->skip) == -1)
306	return 0;
307	}
308
309	/* consume whatever's left in the input buffer */
310	if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
311	return 0;
312
313	/* do the printf() into the input buffer, put length in len */
314	size = (int)(state->size);
315	state->in[size - 1] = 0;
316	va_start(va, format);
317	#ifdef NO_vsnprintf
318	# ifdef HAS_vsprintf_void
319	(void)vsprintf(state->in, format, va);
320	va_end(va);
321	for (len = 0; len < size; len++)
322	if (state->in[len] == 0) break;
323	# else
324	len = vsprintf(state->in, format, va);
325	va_end(va);
326	# endif
327	#else
328	# ifdef HAS_vsnprintf_void
329	(void)vsnprintf(state->in, size, format, va);
330	va_end(va);
331	len = strlen(state->in);
332	# else
333	len = vsnprintf((char *)(state->in), size, format, va);
334	va_end(va);
335	# endif
336	#endif
337
338	/* check that printf() results fit in buffer */
339	if (len <= 0 \|\| len >= (int)size \|\| state->in[size - 1] != 0)
340	return 0;
341
342	/* update buffer and position, defer compression until needed */
343	strm->avail_in = (unsigned)len;
344	strm->next_in = state->in;
345	state->pos += len;
346	return len;
347	}
348
349	#else /* !STDC */
350
351	/* -- see zlib.h -- */
352	int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
353	a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
354	gzFile file;
355	const char *format;
356	int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
357	a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
358	{
359	int size, len;
360	gz_statep state;
361	z_streamp strm;
362
363	/* get internal structure */
364	if (file == NULL)
365	return -1;
366	state = (gz_statep)file;
367	strm = &(state->strm);
368
369	/* check that we're writing and that there's no error */
370	if (state->mode != GZ_WRITE \|\| state->err != Z_OK)
371	return 0;
372
373	/* make sure we have some buffer space */
374	if (state->size == 0 && gz_init(state) == -1)
375	return 0;
376
377	/* check for seek request */
378	if (state->seek) {
379	state->seek = 0;
380	if (gz_zero(state, state->skip) == -1)
381	return 0;
382	}
383
384	/* consume whatever's left in the input buffer */
385	if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
386	return 0;
387
388	/* do the printf() into the input buffer, put length in len */
389	size = (int)(state->size);
390	state->in[size - 1] = 0;
391	#ifdef NO_snprintf
392	# ifdef HAS_sprintf_void
393	sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8,
394	a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
395	for (len = 0; len < size; len++)
396	if (state->in[len] == 0) break;
397	# else
398	len = sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8,
399	a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
400	# endif
401	#else
402	# ifdef HAS_snprintf_void
403	snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8,
404	a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
405	len = strlen(state->in);
406	# else
407	len = snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8,
408	a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
409	# endif
410	#endif
411
412	/* check that printf() results fit in buffer */
413	if (len <= 0 \|\| len >= (int)size \|\| state->in[size - 1] != 0)
414	return 0;
415
416	/* update buffer and position, defer compression until needed */
417	strm->avail_in = (unsigned)len;
418	strm->next_in = state->in;
419	state->pos += len;
420	return len;
421	}
422
423	#endif
424
425	/* -- see zlib.h -- */
426	int ZEXPORT gzflush(file, flush)
427	gzFile file;
428	int flush;
429	{
430	gz_statep state;
431
432	/* get internal structure */
433	if (file == NULL)
434	return -1;
435	state = (gz_statep)file;
436
437	/* check that we're writing and that there's no error */
438	if (state->mode != GZ_WRITE \|\| state->err != Z_OK)
439	return Z_STREAM_ERROR;
440
441	/* check flush parameter */
442	if (flush < 0 \|\| flush > Z_FINISH)
443	return Z_STREAM_ERROR;
444
445	/* check for seek request */
446	if (state->seek) {
447	state->seek = 0;
448	if (gz_zero(state, state->skip) == -1)
449	return -1;
450	}
451
452	/* compress remaining data with requested flush */
453	gz_comp(state, flush);
454	return state->err;
455	}
456
457	/* -- see zlib.h -- */
458	int ZEXPORT gzsetparams(file, level, strategy)
459	gzFile file;
460	int level;
461	int strategy;
462	{
463	gz_statep state;
464	z_streamp strm;
465
466	/* get internal structure */
467	if (file == NULL)
468	return Z_STREAM_ERROR;
469	state = (gz_statep)file;
470	strm = &(state->strm);
471
472	/* check that we're writing and that there's no error */
473	if (state->mode != GZ_WRITE \|\| state->err != Z_OK)
474	return Z_STREAM_ERROR;
475
476	/* if no change is requested, then do nothing */
477	if (level == state->level && strategy == state->strategy)
478	return Z_OK;
479
480	/* check for seek request */
481	if (state->seek) {
482	state->seek = 0;
483	if (gz_zero(state, state->skip) == -1)
484	return -1;
485	}
486
487	/* change compression parameters for subsequent input */
488	if (state->size) {
489	/* flush previous input with previous parameters before changing */
490	if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
491	return state->err;
492	deflateParams(strm, level, strategy);
493	}
494	state->level = level;
495	state->strategy = strategy;
496	return Z_OK;
497	}
498
499	/* -- see zlib.h -- */
500	int ZEXPORT gzclose_w(file)
501	gzFile file;
502	{
503	int ret = 0;
504	gz_statep state;
505
506	/* get internal structure */
507	if (file == NULL)
508	return Z_STREAM_ERROR;
509	state = (gz_statep)file;
510
511	/* check that we're writing */
512	if (state->mode != GZ_WRITE)
513	return Z_STREAM_ERROR;
514
515	/* check for seek request */
516	if (state->seek) {
517	state->seek = 0;
518	ret += gz_zero(state, state->skip);
519	}
520
521	/* flush, free memory, and close file */
522	ret += gz_comp(state, Z_FINISH);
523	(void)deflateEnd(&(state->strm));
524	free(state->out);
525	free(state->in);
526	gz_error(state, Z_OK, NULL);
527	free(state->path);
528	ret += close(state->fd);
529	free(state);
530	return ret ? Z_ERRNO : Z_OK;
531	}