1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/compressionlibs/ziplib/src/zlib/gzio.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1198 @@
1.4 +/* Portions Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 + * All rights reserved.
1.6 + */
1.7 +
1.8 +/* gzio.c -- IO on .gz files
1.9 + * Copyright (C) 1995-2005 Jean-loup Gailly.
1.10 + * For conditions of distribution and use, see copyright notice in zlib.h
1.11 + *
1.12 + * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
1.13 + */
1.14 +
1.15 +/* @(#) $Id$ */
1.16 +
1.17 +#include <stdio.h>
1.18 +#include "libzgzio.h" /* libzgzio.h must be included BEFORE zutil.h, as its header guard is used in zutil.h */
1.19 +#include "zutil.h"
1.20 +
1.21 +#ifdef NO_DEFLATE /* for compatibility with old definition */
1.22 +# define NO_GZCOMPRESS
1.23 +#endif
1.24 +
1.25 +#ifndef NO_DUMMY_DECL
1.26 +struct internal_state {int dummy;}; /* for buggy compilers */
1.27 +#endif
1.28 +
1.29 +#ifndef Z_BUFSIZE
1.30 +# ifdef MAXSEG_64K
1.31 +# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
1.32 +# else
1.33 +# define Z_BUFSIZE 16384
1.34 +# endif
1.35 +#endif
1.36 +#ifndef Z_PRINTF_BUFSIZE
1.37 +# define Z_PRINTF_BUFSIZE 4096
1.38 +#endif
1.39 +
1.40 +#ifdef __MVS__
1.41 +# pragma map (fdopen , "\174\174FDOPEN")
1.42 + FILE *fdopen(int, const char *);
1.43 +#endif
1.44 +
1.45 +#ifndef STDC
1.46 +extern voidp malloc OF((uInt size));
1.47 +extern void free OF((voidpf ptr));
1.48 +#endif
1.49 +
1.50 +#define ALLOC(size) malloc(size)
1.51 +#define TRYFREE(p) {if (p) free(p);}
1.52 +
1.53 +static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
1.54 +
1.55 +/* gzip flag byte */
1.56 +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
1.57 +#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
1.58 +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
1.59 +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
1.60 +#define COMMENT 0x10 /* bit 4 set: file comment present */
1.61 +#define RESERVED 0xE0 /* bits 5..7: reserved */
1.62 +
1.63 +typedef struct gz_stream {
1.64 + z_stream stream;
1.65 + int z_err; /* error code for last stream operation */
1.66 + int z_eof; /* set if end of input file */
1.67 + FILE *file; /* .gz file */
1.68 + Byte *inbuf; /* input buffer */
1.69 + Byte *outbuf; /* output buffer */
1.70 + uLong crc; /* crc32 of uncompressed data */
1.71 + char *msg; /* error message */
1.72 + char *path; /* path name for debugging only */
1.73 + int transparent; /* 1 if input file is not a .gz file */
1.74 + char mode; /* 'w' or 'r' */
1.75 + z_off_t start; /* start of compressed data in file (header skipped) */
1.76 + z_off_t in; /* bytes into deflate or inflate */
1.77 + z_off_t out; /* bytes out of deflate or inflate */
1.78 + int back; /* one character push-back */
1.79 + int last; /* true if push-back is last character */
1.80 +} gz_stream;
1.81 +
1.82 +#ifdef SYMBIAN_EZLIB_DEVICE
1.83 +/* This array is a copy of the one originally defined in zutil.cpp. It is
1.84 + required here as zutil.cpp is now compiled seperately in libzcore.dll */
1.85 +const char * const z_errmsg[10] = {
1.86 + "need dictionary", /* Z_NEED_DICT 2 */
1.87 + "stream end", /* Z_STREAM_END 1 */
1.88 + "", /* Z_OK 0 */
1.89 + "file error", /* Z_ERRNO (-1) */
1.90 + "stream error", /* Z_STREAM_ERROR (-2) */
1.91 + "data error", /* Z_DATA_ERROR (-3) */
1.92 + "insufficient memory", /* Z_MEM_ERROR (-4) */
1.93 + "buffer error", /* Z_BUF_ERROR (-5) */
1.94 + "incompatible version",/* Z_VERSION_ERROR (-6) */
1.95 +""};
1.96 +#endif /* SYMBIAN_EZLIB_DEVICE */
1.97 +
1.98 +local gzFile gz_open OF((const char *path, const char *mode, int fd));
1.99 +local int do_flush OF((gzFile file, int flush));
1.100 +local int get_byte OF((gz_stream *s));
1.101 +local void check_header OF((gz_stream *s));
1.102 +local int destroy OF((gz_stream *s));
1.103 +local void putLong OF((FILE *file, uLong x));
1.104 +local uLong getLong OF((gz_stream *s));
1.105 +
1.106 +/* ===========================================================================
1.107 + Opens a gzip (.gz) file for reading or writing. The mode parameter
1.108 + is as in fopen ("rb" or "wb"). The file is given either by file descriptor
1.109 + or path name (if fd == -1).
1.110 + gz_open returns NULL if the file could not be opened or if there was
1.111 + insufficient memory to allocate the (de)compression state; errno
1.112 + can be checked to distinguish the two cases (if errno is zero, the
1.113 + zlib error is Z_MEM_ERROR).
1.114 +*/
1.115 +#ifdef __SYMBIAN32__
1.116 +local gzFile gz_open (const char * path,const char * mode, int fd)
1.117 +#else
1.118 +local gzFile gz_open (path, mode, fd)
1.119 + const char *path;
1.120 + const char *mode;
1.121 + int fd;
1.122 +#endif /* __SYMBIAN32__ */
1.123 +
1.124 +{
1.125 + int err;
1.126 + int level = Z_DEFAULT_COMPRESSION; /* compression level */
1.127 + int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
1.128 + char *p = (char*)mode;
1.129 + gz_stream *s;
1.130 + char fmode[80]; /* copy of mode, without the compression level */
1.131 + char *m = fmode;
1.132 +
1.133 + if (!path || !mode) return Z_NULL;
1.134 +
1.135 + s = (gz_stream *)ALLOC(sizeof(gz_stream));
1.136 + if (!s) return Z_NULL;
1.137 +
1.138 + s->stream.zalloc = (alloc_func)0;
1.139 + s->stream.zfree = (free_func)0;
1.140 + s->stream.opaque = (voidpf)0;
1.141 + s->stream.next_in = s->inbuf = Z_NULL;
1.142 + s->stream.next_out = s->outbuf = Z_NULL;
1.143 + s->stream.avail_in = s->stream.avail_out = 0;
1.144 + s->file = NULL;
1.145 + s->z_err = Z_OK;
1.146 + s->z_eof = 0;
1.147 + s->in = 0;
1.148 + s->out = 0;
1.149 + s->back = EOF;
1.150 + s->crc = crc32_r(0L, Z_NULL, 0);
1.151 + s->msg = NULL;
1.152 + s->transparent = 0;
1.153 +
1.154 + s->path = (char*)ALLOC(strlen(path)+1);
1.155 + if (s->path == NULL) {
1.156 + return destroy(s), (gzFile)Z_NULL;
1.157 + }
1.158 + strcpy(s->path, path); /* do this early for debugging */
1.159 +
1.160 + s->mode = '\0';
1.161 + do {
1.162 + if (*p == 'r') s->mode = 'r';
1.163 + if (*p == 'w' || *p == 'a') s->mode = 'w';
1.164 + if (*p >= '0' && *p <= '9') {
1.165 + level = *p - '0';
1.166 + } else if (*p == 'f') {
1.167 + strategy = Z_FILTERED;
1.168 + } else if (*p == 'h') {
1.169 + strategy = Z_HUFFMAN_ONLY;
1.170 + } else if (*p == 'R') {
1.171 + strategy = Z_RLE;
1.172 + } else {
1.173 + *m++ = *p; /* copy the mode */
1.174 + }
1.175 + } while (*p++ && m != fmode + sizeof(fmode));
1.176 + if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
1.177 +
1.178 + if (s->mode == 'w') {
1.179 +#ifdef NO_GZCOMPRESS
1.180 + err = Z_STREAM_ERROR;
1.181 +#else
1.182 + err = deflateInit2_r(&(s->stream), level,
1.183 + Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
1.184 + /* windowBits is passed < 0 to suppress zlib header */
1.185 +
1.186 + s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
1.187 +#endif
1.188 + if (err != Z_OK || s->outbuf == Z_NULL) {
1.189 + return destroy(s), (gzFile)Z_NULL;
1.190 + }
1.191 + } else {
1.192 + s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
1.193 +
1.194 + err = inflateInit2_r(&(s->stream), -MAX_WBITS);
1.195 + /* windowBits is passed < 0 to tell that there is no zlib header.
1.196 + * Note that in this case inflate *requires* an extra "dummy" byte
1.197 + * after the compressed stream in order to complete decompression and
1.198 + * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
1.199 + * present after the compressed stream.
1.200 + */
1.201 + if (err != Z_OK || s->inbuf == Z_NULL) {
1.202 + return destroy(s), (gzFile)Z_NULL;
1.203 + }
1.204 + }
1.205 + s->stream.avail_out = Z_BUFSIZE;
1.206 + //coverity[cleanup_stack]
1.207 + //This code is derived from open source and hence does not use cleanup stack
1.208 + errno = 0;
1.209 + s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
1.210 +
1.211 + if (s->file == NULL) {
1.212 + return destroy(s), (gzFile)Z_NULL;
1.213 + }
1.214 + if (s->mode == 'w') {
1.215 + /* Write a very simple .gz header:
1.216 + */
1.217 + fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
1.218 + Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
1.219 + s->start = 10L;
1.220 + /* We use 10L instead of ftell(s->file) to because ftell causes an
1.221 + * fflush on some systems. This version of the library doesn't use
1.222 + * start anyway in write mode, so this initialization is not
1.223 + * necessary.
1.224 + */
1.225 + } else {
1.226 + //coverity[cleanup_stack]
1.227 + //This code is derived from open source and hence does not use cleanup stack
1.228 + check_header(s); /* skip the .gz header */
1.229 + s->start = ftell(s->file) - s->stream.avail_in;
1.230 + }
1.231 +
1.232 + return (gzFile)s;
1.233 +}
1.234 +
1.235 +/* ===========================================================================
1.236 + Opens a gzip (.gz) file for reading or writing.
1.237 +*/
1.238 +#ifdef __SYMBIAN32__
1.239 +gzFile gzopen_r (const char * path, const char * mode)
1.240 +#else
1.241 +gzFile ZEXPORT gzopen (path, mode)
1.242 + const char *path;
1.243 + const char *mode;
1.244 +#endif /* __SYMBIAN32__ */
1.245 +
1.246 +{
1.247 + return gz_open (path, mode, -1);
1.248 +}
1.249 +
1.250 +/* ===========================================================================
1.251 + Associate a gzFile with the file descriptor fd. fd is not dup'ed here
1.252 + to mimic the behavio(u)r of fdopen.
1.253 +*/
1.254 +#ifdef __SYMBIAN32__
1.255 +gzFile gzdopen_r (int fd, const char * mode)
1.256 +#else
1.257 +gzFile ZEXPORT gzdopen (fd, mode)
1.258 + int fd;
1.259 + const char *mode;
1.260 +#endif /* __SYMBIAN32__ */
1.261 +{
1.262 + char name[46]; /* allow for up to 128-bit integers */
1.263 +
1.264 + if (fd < 0) return (gzFile)Z_NULL;
1.265 + sprintf(name, "<fd:%d>", fd); /* for debugging */
1.266 +
1.267 + return gz_open (name, mode, fd);
1.268 +}
1.269 +
1.270 +/* ===========================================================================
1.271 + * Update the compression level and strategy
1.272 + */
1.273 +#ifdef __SYMBIAN32__
1.274 +int gzsetparams_r (gzFile file,int level,int strategy)
1.275 +#else
1.276 +int ZEXPORT gzsetparams (file, level, strategy)
1.277 + gzFile file;
1.278 + int level;
1.279 + int strategy;
1.280 +#endif /* __SYMBIAN32__ */
1.281 +
1.282 +{
1.283 + gz_stream *s = (gz_stream*)file;
1.284 +
1.285 + if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
1.286 +
1.287 + /* Make room to allow flushing */
1.288 + if (s->stream.avail_out == 0) {
1.289 +
1.290 + s->stream.next_out = s->outbuf;
1.291 + if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
1.292 + s->z_err = Z_ERRNO;
1.293 + }
1.294 + s->stream.avail_out = Z_BUFSIZE;
1.295 + }
1.296 +
1.297 + return deflateParams_r (&(s->stream), level, strategy);
1.298 +}
1.299 +
1.300 +/* ===========================================================================
1.301 + Read a byte from a gz_stream; update next_in and avail_in. Return EOF
1.302 + for end of file.
1.303 + IN assertion: the stream s has been sucessfully opened for reading.
1.304 +*/
1.305 +#ifdef __SYMBIAN32__
1.306 +local int get_byte (gz_stream *s)
1.307 +#else
1.308 +local int get_byte(s)
1.309 + gz_stream *s;
1.310 +#endif /* __SYMBIAN32__ */
1.311 +{
1.312 + if (s->z_eof) return EOF;
1.313 + if (s->stream.avail_in == 0) {
1.314 + errno = 0;
1.315 + s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
1.316 + if (s->stream.avail_in == 0) {
1.317 + s->z_eof = 1;
1.318 + if (ferror(s->file)) s->z_err = Z_ERRNO;
1.319 + return EOF;
1.320 + }
1.321 + s->stream.next_in = s->inbuf;
1.322 + }
1.323 + s->stream.avail_in--;
1.324 + return *(s->stream.next_in)++;
1.325 +}
1.326 +
1.327 +/* ===========================================================================
1.328 + Check the gzip header of a gz_stream opened for reading. Set the stream
1.329 + mode to transparent if the gzip magic header is not present; set s->err
1.330 + to Z_DATA_ERROR if the magic header is present but the rest of the header
1.331 + is incorrect.
1.332 + IN assertion: the stream s has already been created sucessfully;
1.333 + s->stream.avail_in is zero for the first time, but may be non-zero
1.334 + for concatenated .gz files.
1.335 +*/
1.336 +#ifdef __SYMBIAN32__
1.337 +local void check_header (gz_stream * s)
1.338 +#else
1.339 +local void check_header(s)
1.340 + gz_stream *s;
1.341 +#endif /* __SYMBIAN32__ */
1.342 +{
1.343 + int method; /* method byte */
1.344 + int flags; /* flags byte */
1.345 + uInt len;
1.346 + int c;
1.347 +
1.348 + /* Assure two bytes in the buffer so we can peek ahead -- handle case
1.349 + where first byte of header is at the end of the buffer after the last
1.350 + gzip segment */
1.351 + len = s->stream.avail_in;
1.352 + if (len < 2) {
1.353 + if (len) s->inbuf[0] = s->stream.next_in[0];
1.354 + errno = 0;
1.355 + len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
1.356 + if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
1.357 + s->stream.avail_in += len;
1.358 + s->stream.next_in = s->inbuf;
1.359 + if (s->stream.avail_in < 2) {
1.360 + s->transparent = s->stream.avail_in;
1.361 + return;
1.362 + }
1.363 + }
1.364 +
1.365 + /* Peek ahead to check the gzip magic header */
1.366 + if (s->stream.next_in[0] != gz_magic[0] ||
1.367 + s->stream.next_in[1] != gz_magic[1]) {
1.368 + s->transparent = 1;
1.369 + return;
1.370 + }
1.371 + s->stream.avail_in -= 2;
1.372 + s->stream.next_in += 2;
1.373 +
1.374 + /* Check the rest of the gzip header */
1.375 + method = get_byte(s);
1.376 + flags = get_byte(s);
1.377 + if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
1.378 + s->z_err = Z_DATA_ERROR;
1.379 + return;
1.380 + }
1.381 +
1.382 + /* Discard time, xflags and OS code: */
1.383 + for (len = 0; len < 6; len++) (void)get_byte(s);
1.384 +
1.385 + if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
1.386 + len = (uInt)get_byte(s);
1.387 + len += ((uInt)get_byte(s))<<8;
1.388 + /* len is garbage if EOF but the loop below will quit anyway */
1.389 + while (len-- != 0 && get_byte(s) != EOF) ;
1.390 + }
1.391 + if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
1.392 + while ((c = get_byte(s)) != 0 && c != EOF) ;
1.393 + }
1.394 + if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
1.395 + while ((c = get_byte(s)) != 0 && c != EOF) ;
1.396 + }
1.397 + if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
1.398 + for (len = 0; len < 2; len++) (void)get_byte(s);
1.399 + }
1.400 + s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
1.401 +}
1.402 +
1.403 + /* ===========================================================================
1.404 + Cleanup then free the given gz_stream. Return a zlib error code.
1.405 + Try freeing in the reverse order of allocations.
1.406 + */
1.407 +#ifdef __SYMBIAN32__
1.408 +local int destroy (gz_stream * s)
1.409 +#else
1.410 +local int destroy (s)
1.411 + gz_stream *s;
1.412 +#endif /* __SYMBIAN32__ */
1.413 +{
1.414 + int err = Z_OK;
1.415 +
1.416 + if (!s) return Z_STREAM_ERROR;
1.417 +
1.418 + TRYFREE(s->msg);
1.419 +
1.420 + if (s->stream.state != NULL) {
1.421 + if (s->mode == 'w') {
1.422 +#ifdef NO_GZCOMPRESS
1.423 + err = Z_STREAM_ERROR;
1.424 +#else
1.425 + err = deflateEnd_r(&(s->stream));
1.426 +#endif
1.427 + } else if (s->mode == 'r') {
1.428 + err = inflateEnd_r(&(s->stream));
1.429 + }
1.430 + }
1.431 + if (s->file != NULL && fclose(s->file)) {
1.432 +#ifdef ESPIPE
1.433 + if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
1.434 +#endif
1.435 + err = Z_ERRNO;
1.436 + }
1.437 + if (s->z_err < 0) err = s->z_err;
1.438 +
1.439 + TRYFREE(s->inbuf);
1.440 + TRYFREE(s->outbuf);
1.441 + TRYFREE(s->path);
1.442 + TRYFREE(s);
1.443 + return err;
1.444 +}
1.445 +
1.446 +/* ===========================================================================
1.447 + Reads the given number of uncompressed bytes from the compressed file.
1.448 + gzread returns the number of bytes actually read (0 for end of file).
1.449 +*/
1.450 +#ifdef __SYMBIAN32__
1.451 +int gzread_r (gzFile file,voidp buf,unsigned len)
1.452 +#else
1.453 +int ZEXPORT gzread (file, buf, len)
1.454 + gzFile file;
1.455 + voidp buf;
1.456 + unsigned len;
1.457 +#endif /* __SYMBIAN32__ */
1.458 +{
1.459 + gz_stream *s = (gz_stream*)file;
1.460 + Bytef *start = (Bytef*)buf; /* starting point for crc computation */
1.461 + Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
1.462 +
1.463 + if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
1.464 +
1.465 + if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
1.466 + if (s->z_err == Z_STREAM_END) return 0; /* EOF */
1.467 +
1.468 + next_out = (Byte*)buf;
1.469 + s->stream.next_out = (Bytef*)buf;
1.470 + s->stream.avail_out = len;
1.471 +
1.472 + if (s->stream.avail_out && s->back != EOF) {
1.473 + *next_out++ = s->back;
1.474 + s->stream.next_out++;
1.475 + s->stream.avail_out--;
1.476 + s->back = EOF;
1.477 + s->out++;
1.478 + start++;
1.479 + if (s->last) {
1.480 + s->z_err = Z_STREAM_END;
1.481 + return 1;
1.482 + }
1.483 + }
1.484 +
1.485 + while (s->stream.avail_out != 0) {
1.486 +
1.487 + if (s->transparent) {
1.488 + /* Copy first the lookahead bytes: */
1.489 + uInt n = s->stream.avail_in;
1.490 + if (n > s->stream.avail_out) n = s->stream.avail_out;
1.491 + if (n > 0) {
1.492 + zmemcpy(s->stream.next_out, s->stream.next_in, n);
1.493 + next_out += n;
1.494 + s->stream.next_out = next_out;
1.495 + s->stream.next_in += n;
1.496 + s->stream.avail_out -= n;
1.497 + s->stream.avail_in -= n;
1.498 + }
1.499 + if (s->stream.avail_out > 0) {
1.500 + s->stream.avail_out -=
1.501 + (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
1.502 + }
1.503 + len -= s->stream.avail_out;
1.504 + s->in += len;
1.505 + s->out += len;
1.506 + if (len == 0) s->z_eof = 1;
1.507 + return (int)len;
1.508 + }
1.509 + if (s->stream.avail_in == 0 && !s->z_eof) {
1.510 +
1.511 + errno = 0;
1.512 + s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
1.513 + if (s->stream.avail_in == 0) {
1.514 + s->z_eof = 1;
1.515 + if (ferror(s->file)) {
1.516 + s->z_err = Z_ERRNO;
1.517 + break;
1.518 + }
1.519 + }
1.520 + s->stream.next_in = s->inbuf;
1.521 + }
1.522 + s->in += s->stream.avail_in;
1.523 + s->out += s->stream.avail_out;
1.524 + s->z_err = inflate_r(&(s->stream), Z_NO_FLUSH);
1.525 + s->in -= s->stream.avail_in;
1.526 + s->out -= s->stream.avail_out;
1.527 +
1.528 + if (s->z_err == Z_STREAM_END) {
1.529 + /* Check CRC and original size */
1.530 + s->crc = crc32_r(s->crc, start, (uInt)(s->stream.next_out - start));
1.531 + start = s->stream.next_out;
1.532 +
1.533 + if (getLong(s) != s->crc) {
1.534 + s->z_err = Z_DATA_ERROR;
1.535 + } else {
1.536 + (void)getLong(s);
1.537 + /* The uncompressed length returned by above getlong() may be
1.538 + * different from s->out in case of concatenated .gz files.
1.539 + * Check for such files:
1.540 + */
1.541 + check_header(s);
1.542 + if (s->z_err == Z_OK) {
1.543 + inflateReset_r(&(s->stream));
1.544 + s->crc = crc32_r(0L, Z_NULL, 0);
1.545 + }
1.546 + }
1.547 + }
1.548 + if (s->z_err != Z_OK || s->z_eof) break;
1.549 + }
1.550 + s->crc = crc32_r(s->crc, start, (uInt)(s->stream.next_out - start));
1.551 +
1.552 + if (len == s->stream.avail_out &&
1.553 + (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
1.554 + return -1;
1.555 + return (int)(len - s->stream.avail_out);
1.556 +}
1.557 +
1.558 +
1.559 +/* ===========================================================================
1.560 + Reads one byte from the compressed file. gzgetc returns this byte
1.561 + or -1 in case of end of file or error.
1.562 +*/
1.563 +#ifdef __SYMBIAN32__
1.564 +int gzgetc_r (gzFile file)
1.565 +#else
1.566 +int ZEXPORT gzgetc(file)
1.567 + gzFile file;
1.568 +#endif /* __SYMBIAN32__ */
1.569 +
1.570 +{
1.571 + unsigned char c;
1.572 +
1.573 + return gzread_r(file, &c, 1) == 1 ? c : -1;
1.574 +}
1.575 +
1.576 +
1.577 +/* ===========================================================================
1.578 + Push one byte back onto the stream.
1.579 +*/
1.580 +#ifdef __SYMBIAN32__
1.581 +int gzungetc_r (int c,gzFile file)
1.582 +#else
1.583 +int ZEXPORT gzungetc(c, file)
1.584 + int c;
1.585 + gzFile file;
1.586 +#endif /* __SYMBIAN32__ */
1.587 +{
1.588 + gz_stream *s = (gz_stream*)file;
1.589 +
1.590 + if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
1.591 + s->back = c;
1.592 + s->out--;
1.593 + s->last = (s->z_err == Z_STREAM_END);
1.594 + if (s->last) s->z_err = Z_OK;
1.595 + s->z_eof = 0;
1.596 + return c;
1.597 +}
1.598 +
1.599 +
1.600 +/* ===========================================================================
1.601 + Reads bytes from the compressed file until len-1 characters are
1.602 + read, or a newline character is read and transferred to buf, or an
1.603 + end-of-file condition is encountered. The string is then terminated
1.604 + with a null character.
1.605 + gzgets returns buf, or Z_NULL in case of error.
1.606 +
1.607 + The current implementation is not optimized at all.
1.608 +*/
1.609 +#ifdef __SYMBIAN32__
1.610 +char * gzgets_r (gzFile file, char * buf, int len)
1.611 +#else
1.612 +char * ZEXPORT gzgets(file, buf, len)
1.613 + gzFile file;
1.614 + char *buf;
1.615 + int len;
1.616 +#endif /* __SYMBIAN32__ */
1.617 +{
1.618 + char *b = buf;
1.619 + if (buf == Z_NULL || len <= 0) return Z_NULL;
1.620 +
1.621 + while (--len > 0 && gzread_r(file, buf, 1) == 1 && *buf++ != '\n') ;
1.622 + *buf = '\0';
1.623 + return b == buf && len > 0 ? Z_NULL : b;
1.624 +}
1.625 +
1.626 +
1.627 +#ifndef NO_GZCOMPRESS
1.628 +/* ===========================================================================
1.629 + Writes the given number of uncompressed bytes into the compressed file.
1.630 + gzwrite returns the number of bytes actually written (0 in case of error).
1.631 +*/
1.632 +#ifdef __SYMBIAN32__
1.633 +int gzwrite_r (gzFile file,voidpc buf,unsigned len)
1.634 +#else
1.635 +int ZEXPORT gzwrite (file, buf, len)
1.636 + gzFile file;
1.637 + voidpc buf;
1.638 + unsigned len;
1.639 +#endif /* __SYMBIAN32__ */
1.640 +{
1.641 + gz_stream *s = (gz_stream*)file;
1.642 +
1.643 + if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
1.644 +
1.645 + s->stream.next_in = (Bytef*)buf;
1.646 + s->stream.avail_in = len;
1.647 +
1.648 + while (s->stream.avail_in != 0) {
1.649 +
1.650 + if (s->stream.avail_out == 0) {
1.651 +
1.652 + s->stream.next_out = s->outbuf;
1.653 + if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
1.654 + s->z_err = Z_ERRNO;
1.655 + break;
1.656 + }
1.657 + s->stream.avail_out = Z_BUFSIZE;
1.658 + }
1.659 + s->in += s->stream.avail_in;
1.660 + s->out += s->stream.avail_out;
1.661 + s->z_err = deflate_r(&(s->stream), Z_NO_FLUSH);
1.662 + s->in -= s->stream.avail_in;
1.663 + s->out -= s->stream.avail_out;
1.664 + if (s->z_err != Z_OK) break;
1.665 + }
1.666 + s->crc = crc32_r(s->crc, (const Bytef *)buf, len);
1.667 +
1.668 + return (int)(len - s->stream.avail_in);
1.669 +}
1.670 +
1.671 +
1.672 +/* ===========================================================================
1.673 + Converts, formats, and writes the args to the compressed file under
1.674 + control of the format string, as in fprintf. gzprintf returns the number of
1.675 + uncompressed bytes actually written (0 in case of error).
1.676 +*/
1.677 +#ifdef STDC
1.678 +#include <stdarg.h>
1.679 +
1.680 +#ifdef __SYMBIAN32__
1.681 +int gzprintf_r (gzFile file, const char *format, va_list va)
1.682 +#else
1.683 +int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
1.684 +#endif /* __SYMBIAN32__ */
1.685 +{
1.686 + int len;
1.687 + int ret;
1.688 +
1.689 +#ifndef SYMBIAN_EZLIB_DEVICE
1.690 + char buf[Z_PRINTF_BUFSIZE];
1.691 + buf[sizeof(buf) - 1] = 0;
1.692 +#else
1.693 + char *buf = (char*)0;
1.694 + buf = (char*) ALLOC(Z_PRINTF_BUFSIZE * sizeof(char));
1.695 + if(!buf)
1.696 + return 0;
1.697 + buf[Z_PRINTF_BUFSIZE - 1] = 0;
1.698 +#endif /* SYMBIAN_EZLIB_DEVICE */
1.699 +
1.700 +#ifdef NO_vsnprintf
1.701 +# ifdef HAS_vsprintf_void
1.702 + (void)vsprintf(buf, format, va);
1.703 + va_end(va);
1.704 +# ifndef SYMBIAN_EZLIB_DEVICE
1.705 + for (len = 0; len < sizeof(buf); len++)
1.706 +# else
1.707 + for (len = 0; len < Z_PRINTF_BUFSIZE; len++)
1.708 +# endif /* SYMBIAN_EZLIB_DEVICE */
1.709 + if (buf[len] == 0) break;
1.710 +# else
1.711 + len = vsprintf(buf, format, va);
1.712 + va_end(va);
1.713 +# endif
1.714 +#else
1.715 +# ifdef HAS_vsnprintf_void
1.716 +# ifndef SYMBIAN_EZLIB_DEVICE
1.717 + (void)vsnprintf(buf, sizeof(buf), format, va);
1.718 +# else
1.719 + (void)vsnprintf(buf, Z_PRINTF_BUFSIZE, format, va);
1.720 +# endif /* SYMBIAN_EZLIB_DEVICE */
1.721 + va_end(va);
1.722 + len = strlen(buf);
1.723 +# else
1.724 +# ifndef SYMBIAN_EZLIB_DEVICE
1.725 + len = vsnprintf(buf, sizeof(buf), format, va);
1.726 +# else
1.727 + len = vsnprintf(buf, Z_PRINTF_BUFSIZE, format, va);
1.728 +# endif /* SYMBIAN_EZLIB_DEVICE */
1.729 + va_end(va);
1.730 +# endif
1.731 +#endif
1.732 +
1.733 +#ifndef SYMBIAN_EZLIB_DEVICE
1.734 + if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
1.735 + {
1.736 +#else
1.737 + if (len <= 0 || len >= Z_PRINTF_BUFSIZE || buf[Z_PRINTF_BUFSIZE - 1] != 0)
1.738 + {
1.739 + free(buf);
1.740 +#endif /* SYMBIAN_EZLIB_DEVICE */
1.741 + return 0;
1.742 + }
1.743 + ret = gzwrite_r(file, buf, (unsigned)len);
1.744 +
1.745 +#ifdef SYMBIAN_EZLIB_DEVICE
1.746 + free(buf);
1.747 +#endif /* SYMBIAN_EZLIB_DEVICE */
1.748 + return ret;
1.749 +}
1.750 +
1.751 +#else /* not ANSI C */
1.752 +
1.753 +int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
1.754 + a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
1.755 + gzFile file;
1.756 + const char *format;
1.757 + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
1.758 + a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
1.759 +{
1.760 + char buf[Z_PRINTF_BUFSIZE];
1.761 + int len;
1.762 +
1.763 + buf[sizeof(buf) - 1] = 0;
1.764 +#ifdef NO_snprintf
1.765 +# ifdef HAS_sprintf_void
1.766 + sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
1.767 + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
1.768 + for (len = 0; len < sizeof(buf); len++)
1.769 + if (buf[len] == 0) break;
1.770 +# else
1.771 + len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
1.772 + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
1.773 +# endif
1.774 +#else
1.775 +# ifdef HAS_snprintf_void
1.776 + snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
1.777 + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
1.778 + len = strlen(buf);
1.779 +# else
1.780 + len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
1.781 + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
1.782 +# endif
1.783 +#endif
1.784 + if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
1.785 + return 0;
1.786 + return gzwrite(file, buf, len);
1.787 +}
1.788 +#endif
1.789 +
1.790 +/* ===========================================================================
1.791 + Writes c, converted to an unsigned char, into the compressed file.
1.792 + gzputc returns the value that was written, or -1 in case of error.
1.793 +*/
1.794 +#ifdef __SYMBIAN32__
1.795 +int gzputc_r (gzFile file,int c)
1.796 +#else
1.797 +int ZEXPORT gzputc(file, c)
1.798 + gzFile file;
1.799 + int c;
1.800 +#endif /* __SYMBIAN32__ */
1.801 +{
1.802 + unsigned char cc = (unsigned char) c; /* required for big endian systems */
1.803 +
1.804 + return gzwrite_r(file, &cc, 1) == 1 ? (int)cc : -1;
1.805 +}
1.806 +
1.807 +
1.808 +/* ===========================================================================
1.809 + Writes the given null-terminated string to the compressed file, excluding
1.810 + the terminating null character.
1.811 + gzputs returns the number of characters written, or -1 in case of error.
1.812 +*/
1.813 +#ifdef __SYMBIAN32__
1.814 +int gzputs_r (gzFile file, const char * s)
1.815 +#else
1.816 +int ZEXPORT gzputs(file, s)
1.817 + gzFile file;
1.818 + const char *s;
1.819 +#endif /* __SYMBIAN32__ */
1.820 +{
1.821 + return gzwrite_r(file, (char*)s, (unsigned)strlen(s));
1.822 +}
1.823 +
1.824 +
1.825 +/* ===========================================================================
1.826 + Flushes all pending output into the compressed file. The parameter
1.827 + flush is as in the deflate() function.
1.828 +*/
1.829 +#ifdef __SYMBIAN32__
1.830 +local int do_flush (gzFile file,int flush)
1.831 +#else
1.832 +local int do_flush (file, flush)
1.833 + gzFile file;
1.834 + int flush;
1.835 +#endif /* __SYMBIAN32__ */
1.836 +{
1.837 + uInt len;
1.838 + int done = 0;
1.839 + gz_stream *s = (gz_stream*)file;
1.840 +
1.841 + if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
1.842 +
1.843 + s->stream.avail_in = 0; /* should be zero already anyway */
1.844 +
1.845 + for (;;) {
1.846 + len = Z_BUFSIZE - s->stream.avail_out;
1.847 +
1.848 + if (len != 0) {
1.849 + if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
1.850 + s->z_err = Z_ERRNO;
1.851 + return Z_ERRNO;
1.852 + }
1.853 + s->stream.next_out = s->outbuf;
1.854 + s->stream.avail_out = Z_BUFSIZE;
1.855 + }
1.856 + if (done) break;
1.857 + s->out += s->stream.avail_out;
1.858 + s->z_err = deflate_r(&(s->stream), flush);
1.859 + s->out -= s->stream.avail_out;
1.860 +
1.861 + /* Ignore the second of two consecutive flushes: */
1.862 + if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
1.863 +
1.864 + /* deflate has finished flushing only when it hasn't used up
1.865 + * all the available space in the output buffer:
1.866 + */
1.867 + done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
1.868 +
1.869 + if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
1.870 + }
1.871 + return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
1.872 +}
1.873 +#ifdef __SYMBIAN32__
1.874 +int gzflush_r (gzFile file,int flush)
1.875 +#else
1.876 +int ZEXPORT gzflush (file, flush)
1.877 + gzFile file;
1.878 + int flush;
1.879 +#endif /* __SYMBIAN32__ */
1.880 +{
1.881 + gz_stream *s = (gz_stream*)file;
1.882 + int err = do_flush (file, flush);
1.883 +
1.884 + if (err) return err;
1.885 + fflush(s->file);
1.886 + return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
1.887 +}
1.888 +#endif /* NO_GZCOMPRESS */
1.889 +
1.890 +/* ===========================================================================
1.891 + Sets the starting position for the next gzread or gzwrite on the given
1.892 + compressed file. The offset represents a number of bytes in the
1.893 + gzseek returns the resulting offset location as measured in bytes from
1.894 + the beginning of the uncompressed stream, or -1 in case of error.
1.895 + SEEK_END is not implemented, returns error.
1.896 + In this version of the library, gzseek can be extremely slow.
1.897 +*/
1.898 +#ifdef __SYMBIAN32__
1.899 +z_off_t gzseek_r (gzFile file,z_off_t offset,int whence)
1.900 +#else
1.901 +z_off_t ZEXPORT gzseek (file, offset, whence)
1.902 + gzFile file;
1.903 + z_off_t offset;
1.904 + int whence;
1.905 +#endif /* __SYMBIAN32__ */
1.906 +
1.907 +{
1.908 + gz_stream *s = (gz_stream*)file;
1.909 +
1.910 + if (s == NULL || whence == SEEK_END ||
1.911 + s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
1.912 + return -1L;
1.913 + }
1.914 +
1.915 + if (s->mode == 'w') {
1.916 +#ifdef NO_GZCOMPRESS
1.917 + return -1L;
1.918 +#else
1.919 + if (whence == SEEK_SET) {
1.920 + offset -= s->in;
1.921 + }
1.922 + if (offset < 0) return -1L;
1.923 +
1.924 + /* At this point, offset is the number of zero bytes to write. */
1.925 + if (s->inbuf == Z_NULL) {
1.926 + s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
1.927 + if (s->inbuf == Z_NULL) return -1L;
1.928 + zmemzero(s->inbuf, Z_BUFSIZE);
1.929 + }
1.930 + while (offset > 0) {
1.931 + uInt size = Z_BUFSIZE;
1.932 + if (offset < Z_BUFSIZE) size = (uInt)offset;
1.933 +
1.934 + size = gzwrite_r(file, s->inbuf, size);
1.935 + if (size == 0) return -1L;
1.936 +
1.937 + offset -= size;
1.938 + }
1.939 + return s->in;
1.940 +#endif
1.941 + }
1.942 + /* Rest of function is for reading only */
1.943 +
1.944 + /* compute absolute position */
1.945 + if (whence == SEEK_CUR) {
1.946 + offset += s->out;
1.947 + }
1.948 + if (offset < 0) return -1L;
1.949 +
1.950 + if (s->transparent) {
1.951 + /* map to fseek */
1.952 + s->back = EOF;
1.953 + s->stream.avail_in = 0;
1.954 + s->stream.next_in = s->inbuf;
1.955 + if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
1.956 +
1.957 + s->in = s->out = offset;
1.958 + return offset;
1.959 + }
1.960 +
1.961 + /* For a negative seek, rewind and use positive seek */
1.962 + if (offset >= s->out) {
1.963 + offset -= s->out;
1.964 + } else if (gzrewind_r(file) < 0) {
1.965 + return -1L;
1.966 + }
1.967 + /* offset is now the number of bytes to skip. */
1.968 +
1.969 + if (offset != 0 && s->outbuf == Z_NULL) {
1.970 + s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
1.971 + if (s->outbuf == Z_NULL) return -1L;
1.972 + }
1.973 + if (offset && s->back != EOF) {
1.974 + s->back = EOF;
1.975 + s->out++;
1.976 + offset--;
1.977 + if (s->last) s->z_err = Z_STREAM_END;
1.978 + }
1.979 + while (offset > 0) {
1.980 + int size = Z_BUFSIZE;
1.981 + if (offset < Z_BUFSIZE) size = (int)offset;
1.982 +
1.983 + size = gzread_r(file, s->outbuf, (uInt)size);
1.984 + if (size <= 0) return -1L;
1.985 + offset -= size;
1.986 + }
1.987 + return s->out;
1.988 +}
1.989 +
1.990 +/* ===========================================================================
1.991 + Rewinds input file.
1.992 +*/
1.993 +#ifdef __SYMBIAN32__
1.994 +int gzrewind_r (gzFile file)
1.995 +#else
1.996 +int ZEXPORT gzrewind (file)
1.997 + gzFile file;
1.998 +#endif /* __SYMBIAN32__ */
1.999 +{
1.1000 + gz_stream *s = (gz_stream*)file;
1.1001 +
1.1002 + if (s == NULL || s->mode != 'r') return -1;
1.1003 +
1.1004 + s->z_err = Z_OK;
1.1005 + s->z_eof = 0;
1.1006 + s->back = EOF;
1.1007 + s->stream.avail_in = 0;
1.1008 + s->stream.next_in = s->inbuf;
1.1009 + s->crc = crc32_r(0L, Z_NULL, 0);
1.1010 + if (!s->transparent) (void)inflateReset_r(&s->stream);
1.1011 + s->in = 0;
1.1012 + s->out = 0;
1.1013 + return fseek(s->file, s->start, SEEK_SET);
1.1014 +}
1.1015 +
1.1016 +/* ===========================================================================
1.1017 + Returns the starting position for the next gzread or gzwrite on the
1.1018 + given compressed file. This position represents a number of bytes in the
1.1019 + uncompressed data stream.
1.1020 +*/
1.1021 +#ifdef __SYMBIAN32__
1.1022 +z_off_t gztell_r (gzFile file)
1.1023 +#else
1.1024 +z_off_t ZEXPORT gztell (file)
1.1025 + gzFile file;
1.1026 +#endif /* __SYMBIAN32__ */
1.1027 +{
1.1028 + return gzseek_r(file, 0L, SEEK_CUR);
1.1029 +}
1.1030 +
1.1031 +/* ===========================================================================
1.1032 + Returns 1 when EOF has previously been detected reading the given
1.1033 + input stream, otherwise zero.
1.1034 +*/
1.1035 +#ifdef __SYMBIAN32__
1.1036 +int gzeof_r (gzFile file)
1.1037 +#else
1.1038 +int ZEXPORT gzeof (file)
1.1039 + gzFile file;
1.1040 +#endif /* __SYMBIAN32__ */
1.1041 +{
1.1042 + gz_stream *s = (gz_stream*)file;
1.1043 +
1.1044 + /* With concatenated compressed files that can have embedded
1.1045 + * crc trailers, z_eof is no longer the only/best indicator of EOF
1.1046 + * on a gz_stream. Handle end-of-stream error explicitly here.
1.1047 + */
1.1048 + if (s == NULL || s->mode != 'r') return 0;
1.1049 + if (s->z_eof) return 1;
1.1050 + return s->z_err == Z_STREAM_END;
1.1051 +}
1.1052 +
1.1053 +/* ===========================================================================
1.1054 + Returns 1 if reading and doing so transparently, otherwise zero.
1.1055 +*/
1.1056 +#ifdef __SYMBIAN32__
1.1057 +int gzdirect_r (gzFile file)
1.1058 +#else
1.1059 +int ZEXPORT gzdirect (file)
1.1060 + gzFile file;
1.1061 +#endif /* __SYMBIAN32__ */
1.1062 +{
1.1063 + gz_stream *s = (gz_stream*)file;
1.1064 +
1.1065 + if (s == NULL || s->mode != 'r') return 0;
1.1066 + return s->transparent;
1.1067 +}
1.1068 +
1.1069 +/* ===========================================================================
1.1070 + Outputs a long in LSB order to the given file
1.1071 +*/
1.1072 +#ifdef __SYMBIAN32__
1.1073 +local void putLong (FILE * file,uLong x)
1.1074 +#else
1.1075 +local void putLong (file, x)
1.1076 + FILE *file;
1.1077 + uLong x;
1.1078 +#endif /* __SYMBIAN32__ */
1.1079 +{
1.1080 + int n;
1.1081 + for (n = 0; n < 4; n++) {
1.1082 + fputc((int)(x & 0xff), file);
1.1083 + x >>= 8;
1.1084 + }
1.1085 +}
1.1086 +
1.1087 +/* ===========================================================================
1.1088 + Reads a long in LSB order from the given gz_stream. Sets z_err in case
1.1089 + of error.
1.1090 +*/
1.1091 +#ifdef __SYMBIAN32__
1.1092 +local uLong getLong (gz_stream * s)
1.1093 +#else
1.1094 +local uLong getLong (s)
1.1095 + gz_stream *s;
1.1096 +#endif /* __SYMBIAN32__ */
1.1097 +{
1.1098 + uLong x = (uLong)get_byte(s);
1.1099 + int c;
1.1100 +
1.1101 + x += ((uLong)get_byte(s))<<8;
1.1102 + x += ((uLong)get_byte(s))<<16;
1.1103 + c = get_byte(s);
1.1104 + if (c == EOF) s->z_err = Z_DATA_ERROR;
1.1105 + x += ((uLong)c)<<24;
1.1106 + return x;
1.1107 +}
1.1108 +
1.1109 +/* ===========================================================================
1.1110 + Flushes all pending output if necessary, closes the compressed file
1.1111 + and deallocates all the (de)compression state.
1.1112 +*/
1.1113 +#ifdef __SYMBIAN32__
1.1114 +int gzclose_r(gzFile file)
1.1115 +#else
1.1116 +int ZEXPORT gzclose (file)
1.1117 + gzFile file;
1.1118 +#endif /* __SYMBIAN32__ */
1.1119 +{
1.1120 + gz_stream *s = (gz_stream*)file;
1.1121 +
1.1122 + if (s == NULL) return Z_STREAM_ERROR;
1.1123 +
1.1124 + if (s->mode == 'w') {
1.1125 +#ifdef NO_GZCOMPRESS
1.1126 + return Z_STREAM_ERROR;
1.1127 +#else
1.1128 + if (do_flush (file, Z_FINISH) != Z_OK)
1.1129 + return destroy((gz_stream*)file);
1.1130 +
1.1131 + putLong (s->file, s->crc);
1.1132 + putLong (s->file, (uLong)(s->in & 0xffffffff));
1.1133 +#endif
1.1134 + }
1.1135 + return destroy((gz_stream*)file);
1.1136 +}
1.1137 +
1.1138 +#ifdef STDC
1.1139 +# define zstrerror(errnum) strerror(errnum)
1.1140 +#else
1.1141 +# define zstrerror(errnum) ""
1.1142 +#endif
1.1143 +
1.1144 +/* ===========================================================================
1.1145 + Returns the error message for the last error which occurred on the
1.1146 + given compressed file. errnum is set to zlib error number. If an
1.1147 + error occurred in the file system and not in the compression library,
1.1148 + errnum is set to Z_ERRNO and the application may consult errno
1.1149 + to get the exact error code.
1.1150 +*/
1.1151 +#ifdef __SYMBIAN32__
1.1152 +const char * gzerror_r (gzFile file, int * errnum)
1.1153 +#else
1.1154 +const char * ZEXPORT gzerror (file, errnum)
1.1155 + gzFile file;
1.1156 + int *errnum;
1.1157 +#endif /* __SYMBIAN32__ */
1.1158 +{
1.1159 + char *m;
1.1160 + gz_stream *s = (gz_stream*)file;
1.1161 +
1.1162 + if (s == NULL) {
1.1163 + *errnum = Z_STREAM_ERROR;
1.1164 + return (const char*)ERR_MSG(Z_STREAM_ERROR);
1.1165 + }
1.1166 + *errnum = s->z_err;
1.1167 + if (*errnum == Z_OK) return (const char*)"";
1.1168 +
1.1169 + m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
1.1170 +
1.1171 + if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
1.1172 +
1.1173 + TRYFREE(s->msg);
1.1174 + s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
1.1175 + if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
1.1176 + strcpy(s->msg, s->path);
1.1177 + strcat(s->msg, ": ");
1.1178 + strcat(s->msg, m);
1.1179 + return (const char*)s->msg;
1.1180 +}
1.1181 +
1.1182 +/* ===========================================================================
1.1183 + Clear the error and end-of-file flags, and do the same for the real file.
1.1184 +*/
1.1185 +#ifdef __SYMBIAN32__
1.1186 +void gzclearerr_r (gzFile file)
1.1187 +#else
1.1188 +void ZEXPORT gzclearerr (file)
1.1189 + gzFile file;
1.1190 +#endif /* __SYMBIAN32__ */
1.1191 +{
1.1192 + gz_stream *s = (gz_stream*)file;
1.1193 +
1.1194 + if (s == NULL) return;
1.1195 + if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
1.1196 + s->z_eof = 0;
1.1197 + clearerr(s->file);
1.1198 +}
1.1199 +
1.1200 +
1.1201 +