cannam@89: /* gzwrite.c -- zlib functions for writing gzip files
cannam@89:  * Copyright (C) 2004, 2005, 2010, 2011, 2012 Mark Adler
cannam@89:  * For conditions of distribution and use, see copyright notice in zlib.h
cannam@89:  */
cannam@89: 
cannam@89: #include "gzguts.h"
cannam@89: 
cannam@89: /* Local functions */
cannam@89: local int gz_init OF((gz_statep));
cannam@89: local int gz_comp OF((gz_statep, int));
cannam@89: local int gz_zero OF((gz_statep, z_off64_t));
cannam@89: 
cannam@89: /* Initialize state for writing a gzip file.  Mark initialization by setting
cannam@89:    state->size to non-zero.  Return -1 on failure or 0 on success. */
cannam@89: local int gz_init(state)
cannam@89:     gz_statep state;
cannam@89: {
cannam@89:     int ret;
cannam@89:     z_streamp strm = &(state->strm);
cannam@89: 
cannam@89:     /* allocate input buffer */
cannam@89:     state->in = malloc(state->want);
cannam@89:     if (state->in == NULL) {
cannam@89:         gz_error(state, Z_MEM_ERROR, "out of memory");
cannam@89:         return -1;
cannam@89:     }
cannam@89: 
cannam@89:     /* only need output buffer and deflate state if compressing */
cannam@89:     if (!state->direct) {
cannam@89:         /* allocate output buffer */
cannam@89:         state->out = malloc(state->want);
cannam@89:         if (state->out == NULL) {
cannam@89:             free(state->in);
cannam@89:             gz_error(state, Z_MEM_ERROR, "out of memory");
cannam@89:             return -1;
cannam@89:         }
cannam@89: 
cannam@89:         /* allocate deflate memory, set up for gzip compression */
cannam@89:         strm->zalloc = Z_NULL;
cannam@89:         strm->zfree = Z_NULL;
cannam@89:         strm->opaque = Z_NULL;
cannam@89:         ret = deflateInit2(strm, state->level, Z_DEFLATED,
cannam@89:                            MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
cannam@89:         if (ret != Z_OK) {
cannam@89:             free(state->out);
cannam@89:             free(state->in);
cannam@89:             gz_error(state, Z_MEM_ERROR, "out of memory");
cannam@89:             return -1;
cannam@89:         }
cannam@89:     }
cannam@89: 
cannam@89:     /* mark state as initialized */
cannam@89:     state->size = state->want;
cannam@89: 
cannam@89:     /* initialize write buffer if compressing */
cannam@89:     if (!state->direct) {
cannam@89:         strm->avail_out = state->size;
cannam@89:         strm->next_out = state->out;
cannam@89:         state->x.next = strm->next_out;
cannam@89:     }
cannam@89:     return 0;
cannam@89: }
cannam@89: 
cannam@89: /* Compress whatever is at avail_in and next_in and write to the output file.
cannam@89:    Return -1 if there is an error writing to the output file, otherwise 0.
cannam@89:    flush is assumed to be a valid deflate() flush value.  If flush is Z_FINISH,
cannam@89:    then the deflate() state is reset to start a new gzip stream.  If gz->direct
cannam@89:    is true, then simply write to the output file without compressing, and
cannam@89:    ignore flush. */
cannam@89: local int gz_comp(state, flush)
cannam@89:     gz_statep state;
cannam@89:     int flush;
cannam@89: {
cannam@89:     int ret, got;
cannam@89:     unsigned have;
cannam@89:     z_streamp strm = &(state->strm);
cannam@89: 
cannam@89:     /* allocate memory if this is the first time through */
cannam@89:     if (state->size == 0 && gz_init(state) == -1)
cannam@89:         return -1;
cannam@89: 
cannam@89:     /* write directly if requested */
cannam@89:     if (state->direct) {
cannam@89:         got = write(state->fd, strm->next_in, strm->avail_in);
cannam@89:         if (got < 0 || (unsigned)got != strm->avail_in) {
cannam@89:             gz_error(state, Z_ERRNO, zstrerror());
cannam@89:             return -1;
cannam@89:         }
cannam@89:         strm->avail_in = 0;
cannam@89:         return 0;
cannam@89:     }
cannam@89: 
cannam@89:     /* run deflate() on provided input until it produces no more output */
cannam@89:     ret = Z_OK;
cannam@89:     do {
cannam@89:         /* write out current buffer contents if full, or if flushing, but if
cannam@89:            doing Z_FINISH then don't write until we get to Z_STREAM_END */
cannam@89:         if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
cannam@89:             (flush != Z_FINISH || ret == Z_STREAM_END))) {
cannam@89:             have = (unsigned)(strm->next_out - state->x.next);
cannam@89:             if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
cannam@89:                          (unsigned)got != have)) {
cannam@89:                 gz_error(state, Z_ERRNO, zstrerror());
cannam@89:                 return -1;
cannam@89:             }
cannam@89:             if (strm->avail_out == 0) {
cannam@89:                 strm->avail_out = state->size;
cannam@89:                 strm->next_out = state->out;
cannam@89:             }
cannam@89:             state->x.next = strm->next_out;
cannam@89:         }
cannam@89: 
cannam@89:         /* compress */
cannam@89:         have = strm->avail_out;
cannam@89:         ret = deflate(strm, flush);
cannam@89:         if (ret == Z_STREAM_ERROR) {
cannam@89:             gz_error(state, Z_STREAM_ERROR,
cannam@89:                       "internal error: deflate stream corrupt");
cannam@89:             return -1;
cannam@89:         }
cannam@89:         have -= strm->avail_out;
cannam@89:     } while (have);
cannam@89: 
cannam@89:     /* if that completed a deflate stream, allow another to start */
cannam@89:     if (flush == Z_FINISH)
cannam@89:         deflateReset(strm);
cannam@89: 
cannam@89:     /* all done, no errors */
cannam@89:     return 0;
cannam@89: }
cannam@89: 
cannam@89: /* Compress len zeros to output.  Return -1 on error, 0 on success. */
cannam@89: local int gz_zero(state, len)
cannam@89:     gz_statep state;
cannam@89:     z_off64_t len;
cannam@89: {
cannam@89:     int first;
cannam@89:     unsigned n;
cannam@89:     z_streamp strm = &(state->strm);
cannam@89: 
cannam@89:     /* consume whatever's left in the input buffer */
cannam@89:     if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:         return -1;
cannam@89: 
cannam@89:     /* compress len zeros (len guaranteed > 0) */
cannam@89:     first = 1;
cannam@89:     while (len) {
cannam@89:         n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
cannam@89:             (unsigned)len : state->size;
cannam@89:         if (first) {
cannam@89:             memset(state->in, 0, n);
cannam@89:             first = 0;
cannam@89:         }
cannam@89:         strm->avail_in = n;
cannam@89:         strm->next_in = state->in;
cannam@89:         state->x.pos += n;
cannam@89:         if (gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:             return -1;
cannam@89:         len -= n;
cannam@89:     }
cannam@89:     return 0;
cannam@89: }
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORT gzwrite(file, buf, len)
cannam@89:     gzFile file;
cannam@89:     voidpc buf;
cannam@89:     unsigned len;
cannam@89: {
cannam@89:     unsigned put = len;
cannam@89:     unsigned n;
cannam@89:     gz_statep state;
cannam@89:     z_streamp strm;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return 0;
cannam@89:     state = (gz_statep)file;
cannam@89:     strm = &(state->strm);
cannam@89: 
cannam@89:     /* check that we're writing and that there's no error */
cannam@89:     if (state->mode != GZ_WRITE || state->err != Z_OK)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* since an int is returned, make sure len fits in one, otherwise return
cannam@89:        with an error (this avoids the flaw in the interface) */
cannam@89:     if ((int)len < 0) {
cannam@89:         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
cannam@89:         return 0;
cannam@89:     }
cannam@89: 
cannam@89:     /* if len is zero, avoid unnecessary operations */
cannam@89:     if (len == 0)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* allocate memory if this is the first time through */
cannam@89:     if (state->size == 0 && gz_init(state) == -1)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             return 0;
cannam@89:     }
cannam@89: 
cannam@89:     /* for small len, copy to input buffer, otherwise compress directly */
cannam@89:     if (len < state->size) {
cannam@89:         /* copy to input buffer, compress when full */
cannam@89:         do {
cannam@89:             if (strm->avail_in == 0)
cannam@89:                 strm->next_in = state->in;
cannam@89:             n = state->size - strm->avail_in;
cannam@89:             if (n > len)
cannam@89:                 n = len;
cannam@89:             memcpy(strm->next_in + strm->avail_in, buf, n);
cannam@89:             strm->avail_in += n;
cannam@89:             state->x.pos += n;
cannam@89:             buf = (char *)buf + n;
cannam@89:             len -= n;
cannam@89:             if (len && gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:                 return 0;
cannam@89:         } while (len);
cannam@89:     }
cannam@89:     else {
cannam@89:         /* consume whatever's left in the input buffer */
cannam@89:         if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:             return 0;
cannam@89: 
cannam@89:         /* directly compress user buffer to file */
cannam@89:         strm->avail_in = len;
cannam@89:         strm->next_in = (voidp)buf;
cannam@89:         state->x.pos += len;
cannam@89:         if (gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:             return 0;
cannam@89:     }
cannam@89: 
cannam@89:     /* input was all buffered or compressed (put will fit in int) */
cannam@89:     return (int)put;
cannam@89: }
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORT gzputc(file, c)
cannam@89:     gzFile file;
cannam@89:     int c;
cannam@89: {
cannam@89:     unsigned char buf[1];
cannam@89:     gz_statep state;
cannam@89:     z_streamp strm;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return -1;
cannam@89:     state = (gz_statep)file;
cannam@89:     strm = &(state->strm);
cannam@89: 
cannam@89:     /* check that we're writing and that there's no error */
cannam@89:     if (state->mode != GZ_WRITE || state->err != Z_OK)
cannam@89:         return -1;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             return -1;
cannam@89:     }
cannam@89: 
cannam@89:     /* try writing to input buffer for speed (state->size == 0 if buffer not
cannam@89:        initialized) */
cannam@89:     if (strm->avail_in < state->size) {
cannam@89:         if (strm->avail_in == 0)
cannam@89:             strm->next_in = state->in;
cannam@89:         strm->next_in[strm->avail_in++] = c;
cannam@89:         state->x.pos++;
cannam@89:         return c & 0xff;
cannam@89:     }
cannam@89: 
cannam@89:     /* no room in buffer or not initialized, use gz_write() */
cannam@89:     buf[0] = c;
cannam@89:     if (gzwrite(file, buf, 1) != 1)
cannam@89:         return -1;
cannam@89:     return c & 0xff;
cannam@89: }
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORT gzputs(file, str)
cannam@89:     gzFile file;
cannam@89:     const char *str;
cannam@89: {
cannam@89:     int ret;
cannam@89:     unsigned len;
cannam@89: 
cannam@89:     /* write string */
cannam@89:     len = (unsigned)strlen(str);
cannam@89:     ret = gzwrite(file, str, len);
cannam@89:     return ret == 0 && len != 0 ? -1 : ret;
cannam@89: }
cannam@89: 
cannam@89: #if defined(STDC) || defined(Z_HAVE_STDARG_H)
cannam@89: #include <stdarg.h>
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
cannam@89: {
cannam@89:     int size, len;
cannam@89:     gz_statep state;
cannam@89:     z_streamp strm;
cannam@89:     va_list va;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return -1;
cannam@89:     state = (gz_statep)file;
cannam@89:     strm = &(state->strm);
cannam@89: 
cannam@89:     /* check that we're writing and that there's no error */
cannam@89:     if (state->mode != GZ_WRITE || state->err != Z_OK)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* make sure we have some buffer space */
cannam@89:     if (state->size == 0 && gz_init(state) == -1)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             return 0;
cannam@89:     }
cannam@89: 
cannam@89:     /* consume whatever's left in the input buffer */
cannam@89:     if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* do the printf() into the input buffer, put length in len */
cannam@89:     size = (int)(state->size);
cannam@89:     state->in[size - 1] = 0;
cannam@89:     va_start(va, format);
cannam@89: #ifdef NO_vsnprintf
cannam@89: #  ifdef HAS_vsprintf_void
cannam@89:     (void)vsprintf((char *)(state->in), format, va);
cannam@89:     va_end(va);
cannam@89:     for (len = 0; len < size; len++)
cannam@89:         if (state->in[len] == 0) break;
cannam@89: #  else
cannam@89:     len = vsprintf((char *)(state->in), format, va);
cannam@89:     va_end(va);
cannam@89: #  endif
cannam@89: #else
cannam@89: #  ifdef HAS_vsnprintf_void
cannam@89:     (void)vsnprintf((char *)(state->in), size, format, va);
cannam@89:     va_end(va);
cannam@89:     len = strlen((char *)(state->in));
cannam@89: #  else
cannam@89:     len = vsnprintf((char *)(state->in), size, format, va);
cannam@89:     va_end(va);
cannam@89: #  endif
cannam@89: #endif
cannam@89: 
cannam@89:     /* check that printf() results fit in buffer */
cannam@89:     if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* update buffer and position, defer compression until needed */
cannam@89:     strm->avail_in = (unsigned)len;
cannam@89:     strm->next_in = state->in;
cannam@89:     state->x.pos += len;
cannam@89:     return len;
cannam@89: }
cannam@89: 
cannam@89: #else /* !STDC && !Z_HAVE_STDARG_H */
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
cannam@89:                        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
cannam@89:     gzFile file;
cannam@89:     const char *format;
cannam@89:     int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
cannam@89:         a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
cannam@89: {
cannam@89:     int size, len;
cannam@89:     gz_statep state;
cannam@89:     z_streamp strm;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return -1;
cannam@89:     state = (gz_statep)file;
cannam@89:     strm = &(state->strm);
cannam@89: 
cannam@89:     /* check that can really pass pointer in ints */
cannam@89:     if (sizeof(int) != sizeof(void *))
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* check that we're writing and that there's no error */
cannam@89:     if (state->mode != GZ_WRITE || state->err != Z_OK)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* make sure we have some buffer space */
cannam@89:     if (state->size == 0 && gz_init(state) == -1)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             return 0;
cannam@89:     }
cannam@89: 
cannam@89:     /* consume whatever's left in the input buffer */
cannam@89:     if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* do the printf() into the input buffer, put length in len */
cannam@89:     size = (int)(state->size);
cannam@89:     state->in[size - 1] = 0;
cannam@89: #ifdef NO_snprintf
cannam@89: #  ifdef HAS_sprintf_void
cannam@89:     sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
cannam@89:             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
cannam@89:     for (len = 0; len < size; len++)
cannam@89:         if (state->in[len] == 0) break;
cannam@89: #  else
cannam@89:     len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
cannam@89:                   a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
cannam@89: #  endif
cannam@89: #else
cannam@89: #  ifdef HAS_snprintf_void
cannam@89:     snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
cannam@89:              a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
cannam@89:     len = strlen((char *)(state->in));
cannam@89: #  else
cannam@89:     len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6,
cannam@89:                    a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
cannam@89:                    a19, a20);
cannam@89: #  endif
cannam@89: #endif
cannam@89: 
cannam@89:     /* check that printf() results fit in buffer */
cannam@89:     if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
cannam@89:         return 0;
cannam@89: 
cannam@89:     /* update buffer and position, defer compression until needed */
cannam@89:     strm->avail_in = (unsigned)len;
cannam@89:     strm->next_in = state->in;
cannam@89:     state->x.pos += len;
cannam@89:     return len;
cannam@89: }
cannam@89: 
cannam@89: #endif
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORT gzflush(file, flush)
cannam@89:     gzFile file;
cannam@89:     int flush;
cannam@89: {
cannam@89:     gz_statep state;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return -1;
cannam@89:     state = (gz_statep)file;
cannam@89: 
cannam@89:     /* check that we're writing and that there's no error */
cannam@89:     if (state->mode != GZ_WRITE || state->err != Z_OK)
cannam@89:         return Z_STREAM_ERROR;
cannam@89: 
cannam@89:     /* check flush parameter */
cannam@89:     if (flush < 0 || flush > Z_FINISH)
cannam@89:         return Z_STREAM_ERROR;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             return -1;
cannam@89:     }
cannam@89: 
cannam@89:     /* compress remaining data with requested flush */
cannam@89:     gz_comp(state, flush);
cannam@89:     return state->err;
cannam@89: }
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORT gzsetparams(file, level, strategy)
cannam@89:     gzFile file;
cannam@89:     int level;
cannam@89:     int strategy;
cannam@89: {
cannam@89:     gz_statep state;
cannam@89:     z_streamp strm;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return Z_STREAM_ERROR;
cannam@89:     state = (gz_statep)file;
cannam@89:     strm = &(state->strm);
cannam@89: 
cannam@89:     /* check that we're writing and that there's no error */
cannam@89:     if (state->mode != GZ_WRITE || state->err != Z_OK)
cannam@89:         return Z_STREAM_ERROR;
cannam@89: 
cannam@89:     /* if no change is requested, then do nothing */
cannam@89:     if (level == state->level && strategy == state->strategy)
cannam@89:         return Z_OK;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             return -1;
cannam@89:     }
cannam@89: 
cannam@89:     /* change compression parameters for subsequent input */
cannam@89:     if (state->size) {
cannam@89:         /* flush previous input with previous parameters before changing */
cannam@89:         if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
cannam@89:             return state->err;
cannam@89:         deflateParams(strm, level, strategy);
cannam@89:     }
cannam@89:     state->level = level;
cannam@89:     state->strategy = strategy;
cannam@89:     return Z_OK;
cannam@89: }
cannam@89: 
cannam@89: /* -- see zlib.h -- */
cannam@89: int ZEXPORT gzclose_w(file)
cannam@89:     gzFile file;
cannam@89: {
cannam@89:     int ret = Z_OK;
cannam@89:     gz_statep state;
cannam@89: 
cannam@89:     /* get internal structure */
cannam@89:     if (file == NULL)
cannam@89:         return Z_STREAM_ERROR;
cannam@89:     state = (gz_statep)file;
cannam@89: 
cannam@89:     /* check that we're writing */
cannam@89:     if (state->mode != GZ_WRITE)
cannam@89:         return Z_STREAM_ERROR;
cannam@89: 
cannam@89:     /* check for seek request */
cannam@89:     if (state->seek) {
cannam@89:         state->seek = 0;
cannam@89:         if (gz_zero(state, state->skip) == -1)
cannam@89:             ret = state->err;
cannam@89:     }
cannam@89: 
cannam@89:     /* flush, free memory, and close file */
cannam@89:     if (state->size) {
cannam@89:         if (gz_comp(state, Z_FINISH) == -1)
cannam@89:             ret = state->err;
cannam@89:         if (!state->direct) {
cannam@89:             (void)deflateEnd(&(state->strm));
cannam@89:             free(state->out);
cannam@89:         }
cannam@89:         free(state->in);
cannam@89:     }
cannam@89:     gz_error(state, Z_OK, NULL);
cannam@89:     free(state->path);
cannam@89:     if (close(state->fd) == -1)
cannam@89:         ret = Z_ERRNO;
cannam@89:     free(state);
cannam@89:     return ret;
cannam@89: }