/* Portions Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 */

/* gzio.c -- IO on .gz files

 * Copyright (C) 1995-2005 Jean-loup Gailly.

 * For conditions of distribution and use, see copyright notice in zlib.h

 *

 * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.

 */

/* @(#) $Id$ */

#include <stdio.h>

#include "libzgzio.h"	/* libzgzio.h must be included BEFORE zutil.h, as its header guard is used in zutil.h */

#include "zutil.h"

#ifdef NO_DEFLATE       /* for compatibility with old definition */

#  define NO_GZCOMPRESS

#endif

#ifndef NO_DUMMY_DECL

struct internal_state {int dummy;}; /* for buggy compilers */

#endif

#ifndef Z_BUFSIZE

#  ifdef MAXSEG_64K

#    define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */

#  else

#    define Z_BUFSIZE 16384

#  endif

#endif

#ifndef Z_PRINTF_BUFSIZE

#  define Z_PRINTF_BUFSIZE 4096

#endif

#ifdef __MVS__

#  pragma map (fdopen , "\174\174FDOPEN")

   FILE *fdopen(int, const char *);

#endif

#ifndef STDC

extern voidp  malloc OF((uInt size));

extern void   free   OF((voidpf ptr));

#endif

#define ALLOC(size) malloc(size)

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

static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */

/* gzip flag byte */

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

typedef struct gz_stream {

    z_stream stream;

    int      z_err;   /* error code for last stream operation */

    int      z_eof;   /* set if end of input file */

    FILE     *file;   /* .gz file */

    Byte     *inbuf;  /* input buffer */

    Byte     *outbuf; /* output buffer */

    uLong    crc;     /* crc32 of uncompressed data */

    char     *msg;    /* error message */

    char     *path;   /* path name for debugging only */

    int      transparent; /* 1 if input file is not a .gz file */

    char     mode;    /* 'w' or 'r' */

    z_off_t  start;   /* start of compressed data in file (header skipped) */

    z_off_t  in;      /* bytes into deflate or inflate */

    z_off_t  out;     /* bytes out of deflate or inflate */

    int      back;    /* one character push-back */

    int      last;    /* true if push-back is last character */

} gz_stream;

#ifdef SYMBIAN_EZLIB_DEVICE

/* This array is a copy of the one originally defined in zutil.cpp.  It is

   required here as zutil.cpp is now compiled seperately in libzcore.dll */

const char * const z_errmsg[10] = {

		"need dictionary",     /* Z_NEED_DICT       2  */

		"stream end",          /* Z_STREAM_END      1  */

		"",                    /* Z_OK              0  */

		"file error",          /* Z_ERRNO         (-1) */

		"stream error",        /* Z_STREAM_ERROR  (-2) */

		"data error",          /* Z_DATA_ERROR    (-3) */

		"insufficient memory", /* Z_MEM_ERROR     (-4) */

		"buffer error",        /* Z_BUF_ERROR     (-5) */

		"incompatible version",/* Z_VERSION_ERROR (-6) */

""};

#endif /* SYMBIAN_EZLIB_DEVICE */

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

local int do_flush        OF((gzFile file, int flush));

local int    get_byte     OF((gz_stream *s));

local void   check_header OF((gz_stream *s));

local int    destroy      OF((gz_stream *s));

local void   putLong      OF((FILE *file, uLong x));

local uLong  getLong      OF((gz_stream *s));

/* ===========================================================================

   Opens a gzip (.gz) file for reading or writing. The mode parameter

   is as in fopen ("rb" or "wb"). The file is given either by file descriptor

   or path name (if fd == -1).

   gz_open returns NULL if the file could not be opened or if there was

   insufficient memory to allocate the (de)compression state; errno

   can be checked to distinguish the two cases (if errno is zero, the

   zlib error is Z_MEM_ERROR).

*/

#ifdef __SYMBIAN32__

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

#else

local gzFile gz_open (path, mode, fd)

    const char *path;

    const char *mode;

    int  fd;

#endif /* __SYMBIAN32__ */

{

    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->in = 0;

    s->out = 0;

    s->back = EOF;

    s->crc = crc32_r(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 if (*p == 'R') {

          strategy = Z_RLE;

        } 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_GZCOMPRESS

        err = Z_STREAM_ERROR;

#else

        err = deflateInit2_r(&(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_r(&(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;

	//coverity[cleanup_stack]

	//This code is derived from open source and hence does not use cleanup stack 

    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->start = 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

         * start anyway in write mode, so this initialization is not

         * necessary.

         */

    } else {

		//coverity[cleanup_stack]

		//This code is derived from open source and hence does not use cleanup stack

        check_header(s); /* skip the .gz header */

        s->start = ftell(s->file) - s->stream.avail_in;

    }

    return (gzFile)s;

}

/* ===========================================================================

     Opens a gzip (.gz) file for reading or writing.

*/

#ifdef __SYMBIAN32__

gzFile gzopen_r (const char * path, const char * mode)

#else

gzFile ZEXPORT gzopen (path, mode)

    const char *path;

    const char *mode;

#endif /* __SYMBIAN32__ */

{

    return gz_open (path, mode, -1);

}

/* ===========================================================================

   Associate a gzFile with the file descriptor fd. fd is not dup'ed here

   to mimic the behavio(u)r of fdopen.

*/

#ifdef __SYMBIAN32__

gzFile gzdopen_r (int fd, const char *  mode)

#else

gzFile ZEXPORT gzdopen (fd, mode)

    int fd;

    const char *mode;

#endif /* __SYMBIAN32__ */

{

    char name[46];      /* allow for up to 128-bit integers */

    if (fd < 0) return (gzFile)Z_NULL;

    sprintf(name, "<fd:%d>", fd); /* for debugging */

    return gz_open (name, mode, fd);

}

/* ===========================================================================

 * Update the compression level and strategy

 */

#ifdef __SYMBIAN32__

int gzsetparams_r (gzFile file,int  level,int  strategy)	

#else

int ZEXPORT gzsetparams (file, level, strategy)

    gzFile file;

    int level;

    int strategy;

#endif /* __SYMBIAN32__ */

{

    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_r (&(s->stream), level, strategy);

}

/* ===========================================================================

   Read a byte from a gz_stream; update next_in and avail_in. Return EOF

   for end of file.

   IN assertion: the stream s has been sucessfully opened for reading.

*/

#ifdef __SYMBIAN32__

local int get_byte (gz_stream *s)

#else

local int get_byte(s)

    gz_stream *s;

#endif /* __SYMBIAN32__ */

{

    if (s->z_eof) return EOF;

    if (s->stream.avail_in == 0) {

        errno = 0;

        s->stream.avail_in = (uInt)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)++;

}

/* ===========================================================================

    Check the gzip header of a gz_stream opened for reading. Set the stream

    mode to transparent if the gzip magic header is not present; set s->err

    to Z_DATA_ERROR if the magic header is present but the rest of the header

    is incorrect.

    IN assertion: the stream s has already been created sucessfully;

    s->stream.avail_in is zero for the first time, but may be non-zero

    for concatenated .gz files.

*/

#ifdef __SYMBIAN32__

local void check_header (gz_stream * s)

#else

local void check_header(s)

    gz_stream *s;

#endif /* __SYMBIAN32__ */

{

    int method; /* method byte */

    int flags;  /* flags byte */

    uInt len;

    int c;

    /* Assure two bytes in the buffer so we can peek ahead -- handle case

       where first byte of header is at the end of the buffer after the last

       gzip segment */

    len = s->stream.avail_in;

    if (len < 2) {

        if (len) s->inbuf[0] = s->stream.next_in[0];

        errno = 0;

        len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);

        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;

        s->stream.avail_in += len;

        s->stream.next_in = s->inbuf;

        if (s->stream.avail_in < 2) {

            s->transparent = s->stream.avail_in;

            return;

        }

    }

    /* Peek ahead to check the gzip magic header */

    if (s->stream.next_in[0] != gz_magic[0] ||

        s->stream.next_in[1] != gz_magic[1]) {

        s->transparent = 1;

        return;

    }

    s->stream.avail_in -= 2;

    s->stream.next_in += 2;

    /* Check the rest of the gzip header */

    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;

}

 /* ===========================================================================

    Cleanup then free the given gz_stream. Return a zlib error code.

    Try freeing in the reverse order of allocations.

 */

#ifdef __SYMBIAN32__ 

local int destroy (gz_stream * s)

#else

local int destroy (s)

    gz_stream *s;

#endif /* __SYMBIAN32__ */

{

    int err = Z_OK;

    if (!s) return Z_STREAM_ERROR;

    TRYFREE(s->msg);

    if (s->stream.state != NULL) {

        if (s->mode == 'w') {

#ifdef NO_GZCOMPRESS

            err = Z_STREAM_ERROR;

#else

            err = deflateEnd_r(&(s->stream));

#endif

        } else if (s->mode == 'r') {

            err = inflateEnd_r(&(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;

}

/* ===========================================================================

   Reads the given number of uncompressed bytes from the compressed file.

   gzread returns the number of bytes actually read (0 for end of file).

*/

#ifdef __SYMBIAN32__

int gzread_r (gzFile file,voidp  buf,unsigned  len)

#else

int ZEXPORT gzread (file, buf, len)

    gzFile file;

    voidp buf;

    unsigned len;

#endif /* __SYMBIAN32__ */

{

    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;

    if (s->stream.avail_out && s->back != EOF) {

        *next_out++ = s->back;

        s->stream.next_out++;

        s->stream.avail_out--;

        s->back = EOF;

        s->out++;

        start++;

        if (s->last) {

            s->z_err = Z_STREAM_END;

            return 1;

        }

    }

    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 -=

                    (uInt)fread(next_out, 1, s->stream.avail_out, s->file);

            }

            len -= s->stream.avail_out;

            s->in  += len;

            s->out += 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 = (uInt)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->in += s->stream.avail_in;

        s->out += s->stream.avail_out;

        s->z_err = inflate_r(&(s->stream), Z_NO_FLUSH);

        s->in -= s->stream.avail_in;

        s->out -= s->stream.avail_out;

        if (s->z_err == Z_STREAM_END) {

            /* Check CRC and original size */

            s->crc = crc32_r(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->out in case of concatenated .gz files.

                 * Check for such files:

                 */

                check_header(s);

                if (s->z_err == Z_OK) {

                    inflateReset_r(&(s->stream));

                    s->crc = crc32_r(0L, Z_NULL, 0);

                }

            }

        }

        if (s->z_err != Z_OK || s->z_eof) break;

    }

    s->crc = crc32_r(s->crc, start, (uInt)(s->stream.next_out - start));

    if (len == s->stream.avail_out &&

        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))

        return -1;

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

}

/* ===========================================================================

   Reads one byte from the compressed file. gzgetc returns this byte

   or -1 in case of end of file or error.

*/

#ifdef __SYMBIAN32__

int gzgetc_r (gzFile file)

#else

int ZEXPORT gzgetc(file)

    gzFile file;

#endif /* __SYMBIAN32__ */

{

    unsigned char c;

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

}

/* ===========================================================================

   Push one byte back onto the stream.

*/

#ifdef __SYMBIAN32__

int gzungetc_r (int c,gzFile file)

#else

int ZEXPORT gzungetc(c, file)

    int c;

    gzFile file;

#endif /* __SYMBIAN32__ */

{

    gz_stream *s = (gz_stream*)file;

    if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;

    s->back = c;

    s->out--;

    s->last = (s->z_err == Z_STREAM_END);

    if (s->last) s->z_err = Z_OK;

    s->z_eof = 0;

    return c;

}

/* ===========================================================================

   Reads bytes from the compressed file until len-1 characters are

   read, or a newline character is read and transferred to buf, or an

   end-of-file condition is encountered.  The string is then terminated

   with a null character.

   gzgets returns buf, or Z_NULL in case of error.

   The current implementation is not optimized at all.

*/

#ifdef __SYMBIAN32__

char * gzgets_r (gzFile file, char * buf, int len)

#else

char * ZEXPORT gzgets(file, buf, len)

    gzFile file;

    char *buf;

    int len;

#endif /* __SYMBIAN32__ */

{

    char *b = buf;

    if (buf == Z_NULL || len <= 0) return Z_NULL;

    while (--len > 0 && gzread_r(file, buf, 1) == 1 && *buf++ != '\n') ;

    *buf = '\0';

    return b == buf && len > 0 ? Z_NULL : b;

}

#ifndef NO_GZCOMPRESS

/* ===========================================================================

   Writes the given number of uncompressed bytes into the compressed file.

   gzwrite returns the number of bytes actually written (0 in case of error).

*/

#ifdef __SYMBIAN32__

int gzwrite_r (gzFile file,voidpc  buf,unsigned len)	

#else

int ZEXPORT gzwrite (file, buf, len)

    gzFile file;

    voidpc buf;

    unsigned len;

#endif /* __SYMBIAN32__ */

{

    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->in += s->stream.avail_in;

        s->out += s->stream.avail_out;

        s->z_err = deflate_r(&(s->stream), Z_NO_FLUSH);

        s->in -= s->stream.avail_in;

        s->out -= s->stream.avail_out;

        if (s->z_err != Z_OK) break;

    }

    s->crc = crc32_r(s->crc, (const Bytef *)buf, len);

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

}

/* ===========================================================================

   Converts, formats, and writes the args to the compressed file under

   control of the format string, as in fprintf. gzprintf returns the number of

   uncompressed bytes actually written (0 in case of error).

*/

#ifdef STDC

#include <stdarg.h>

#ifdef __SYMBIAN32__

int gzprintf_r (gzFile file, const char *format, va_list va)

#else

int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)

#endif /* __SYMBIAN32__ */

{

    int len;

	int ret;

#ifndef SYMBIAN_EZLIB_DEVICE

	char buf[Z_PRINTF_BUFSIZE];

    buf[sizeof(buf) - 1] = 0;

#else

	char *buf = (char*)0;

    buf = (char*) ALLOC(Z_PRINTF_BUFSIZE * sizeof(char));

    if(!buf)

    	return 0;

    buf[Z_PRINTF_BUFSIZE - 1] = 0;

#endif /* SYMBIAN_EZLIB_DEVICE */

#ifdef NO_vsnprintf

#  ifdef HAS_vsprintf_void

    (void)vsprintf(buf, format, va);

    va_end(va);

#    ifndef SYMBIAN_EZLIB_DEVICE

       for (len = 0; len < sizeof(buf); len++)

#	 else

	   for (len = 0; len < Z_PRINTF_BUFSIZE; len++)

#	 endif /* SYMBIAN_EZLIB_DEVICE */

        if (buf[len] == 0) break;

#  else

    len = vsprintf(buf, format, va);

    va_end(va);

#  endif

#else

#  ifdef HAS_vsnprintf_void

#    ifndef SYMBIAN_EZLIB_DEVICE

       (void)vsnprintf(buf, sizeof(buf), format, va);

#    else 

	   (void)vsnprintf(buf, Z_PRINTF_BUFSIZE, format, va);

#    endif /* SYMBIAN_EZLIB_DEVICE */

    va_end(va);

    len = strlen(buf);

#  else

#    ifndef SYMBIAN_EZLIB_DEVICE 

       len = vsnprintf(buf, sizeof(buf), format, va);

#    else

	   len = vsnprintf(buf, Z_PRINTF_BUFSIZE, format, va);

#    endif /* SYMBIAN_EZLIB_DEVICE */

    va_end(va);

#  endif

#endif

#ifndef SYMBIAN_EZLIB_DEVICE

    if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)

    {

#else

	if (len <= 0 || len >= Z_PRINTF_BUFSIZE || buf[Z_PRINTF_BUFSIZE - 1] != 0)

	{

		free(buf);

#endif /* SYMBIAN_EZLIB_DEVICE */

    	return 0;

    }

    ret = gzwrite_r(file, buf, (unsigned)len);

#ifdef SYMBIAN_EZLIB_DEVICE

    free(buf);    

#endif /* SYMBIAN_EZLIB_DEVICE */

    return ret; 

}

#else /* not ANSI C */

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;

{

    char buf[Z_PRINTF_BUFSIZE];

    int len;

    buf[sizeof(buf) - 1] = 0;

#ifdef NO_snprintf

#  ifdef HAS_sprintf_void

    sprintf(buf, 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 < sizeof(buf); len++)

        if (buf[len] == 0) break;

#  else

    len = sprintf(buf, 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(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,

             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);

    len = strlen(buf);

#  else

    len = 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);

#  endif

#endif

    if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)

        return 0;

    return gzwrite(file, buf, len);

}

#endif

/* ===========================================================================

   Writes c, converted to an unsigned char, into the compressed file.

   gzputc returns the value that was written, or -1 in case of error.

*/

#ifdef __SYMBIAN32__

int  gzputc_r (gzFile file,int  c)

#else

int ZEXPORT gzputc(file, c)

    gzFile file;

    int c;

#endif /* __SYMBIAN32__ */

{

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

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

}

/* ===========================================================================

   Writes the given null-terminated string to the compressed file, excluding

   the terminating null character.

   gzputs returns the number of characters written, or -1 in case of error.

*/

#ifdef __SYMBIAN32__

int  gzputs_r (gzFile file,  const char * s)

#else

int ZEXPORT gzputs(file, s)

    gzFile file;

    const char *s;

#endif /* __SYMBIAN32__ */

{

    return gzwrite_r(file, (char*)s, (unsigned)strlen(s));

}

/* ===========================================================================

   Flushes all pending output into the compressed file. The parameter

   flush is as in the deflate() function.

*/

#ifdef __SYMBIAN32__

local int do_flush (gzFile file,int  flush)

#else

local int do_flush (file, flush)

    gzFile file;

    int flush;

#endif /* __SYMBIAN32__ */

{

    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->out += s->stream.avail_out;

        s->z_err = deflate_r(&(s->stream), flush);

        s->out -= s->stream.avail_out;

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

}

#ifdef __SYMBIAN32__

int gzflush_r (gzFile file,int  flush)

#else

int ZEXPORT gzflush (file, flush)

     gzFile file;

     int flush;

#endif /* __SYMBIAN32__ */

{

    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;

}

#endif /* NO_GZCOMPRESS */

/* ===========================================================================

   Sets the starting position for the next gzread or gzwrite on the given

   compressed file. The offset represents a number of bytes in the

   gzseek returns the resulting offset location as measured in bytes from

   the beginning of the uncompressed stream, or -1 in case of error.

   SEEK_END is not implemented, returns error.

   In this version of the library, gzseek can be extremely slow.

*/

#ifdef __SYMBIAN32__

z_off_t gzseek_r (gzFile file,z_off_t  offset,int whence)

#else

z_off_t ZEXPORT gzseek (file, offset, whence)

    gzFile file;

    z_off_t offset;

    int whence;

#endif /* __SYMBIAN32__ */

{

    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_GZCOMPRESS

        return -1L;

#else

        if (whence == SEEK_SET) {

            offset -= s->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 */

            if (s->inbuf == Z_NULL) return -1L;

            zmemzero(s->inbuf, Z_BUFSIZE);

        }

        while (offset > 0)  {

            uInt size = Z_BUFSIZE;

            if (offset < Z_BUFSIZE) size = (uInt)offset;

            size = gzwrite_r(file, s->inbuf, size);

            if (size == 0) return -1L;

            offset -= size;

        }

        return s->in;

#endif

    }

    /* Rest of function is for reading only */

    /* compute absolute position */

    if (whence == SEEK_CUR) {

        offset += s->out;

    }

    if (offset < 0) return -1L;

    if (s->transparent) {

        /* map to fseek */

        s->back = EOF;

        s->stream.avail_in = 0;

        s->stream.next_in = s->inbuf;

        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;

        s->in = s->out = offset;

        return offset;

    }

    /* For a negative seek, rewind and use positive seek */

    if (offset >= s->out) {

        offset -= s->out;

    } else if (gzrewind_r(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);

        if (s->outbuf == Z_NULL) return -1L;

    }

    if (offset && s->back != EOF) {

        s->back = EOF;

        s->out++;

        offset--;

        if (s->last) s->z_err = Z_STREAM_END;

    }

    while (offset > 0)  {

        int size = Z_BUFSIZE;

        if (offset < Z_BUFSIZE) size = (int)offset;

        size = gzread_r(file, s->outbuf, (uInt)size);

        if (size <= 0) return -1L;

        offset -= size;

    }

    return s->out;

}

/* ===========================================================================

     Rewinds input file.

*/

#ifdef __SYMBIAN32__

int  gzrewind_r (gzFile file)

#else

int ZEXPORT gzrewind (file)

    gzFile file;