/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
*
* Permission to use, copy, modify, and distribute this software and
* its documentation is hereby granted, provided that the above
* copyright notice appears in all copies.
*
* SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF
* THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE
* FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING,
* MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES
*
* This file has been altered from its original by Sun Microsystems to
* fit local coding style.
*/
#ifndef _ZLIB_H
#define _ZLIB_H
#pragma ident "%Z%%M% %I% %E% SMI"
#ifdef __cplusplus
extern "C" {
#endif
/* $Id: zlib.h,v 1.7 1997/11/27 06:03:33 paulus Exp $ */
/*
* Updated to zlib-1.1.3 by James Carlson.
*
* This file is derived from zlib.h and zconf.h from the zlib-1.0.4
* distribution by Jean-loup Gailly and Mark Adler, with some additions
* by Paul Mackerras to aid in implementing Deflate compression and
* decompression for PPP packets.
*/
/*
* ==FILEVERSION 971127==
*
* This marker is used by the Linux installation script to determine
* whether an up-to-date version of this file is already installed.
*/
/* +++ zlib.h */
/*
* zlib.h -- interface of the 'zlib' general purpose compression
* library version 1.1.3, July 9th, 1998
*
* Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any
* damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any
* purpose, including commercial applications, and to alter it and
* redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must
* not claim that you wrote the original software. If you use this
* software in a product, an acknowledgment in the product
* documentation would be appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must
* not be misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*
*
* Jean-loup Gailly Mark Adler
* jloup@gzip.org madler@alumni.caltech.edu
*
* The data format used by the zlib library is described by RFCs (Request for
* Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
* (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
*/
/* +++ zconf.h */
/*
* zconf.h -- configuration of the zlib compression library
* Copyright (C) 1995-1998 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* From: zconf.h,v 1.20 1996/07/02 15:09:28 me Exp $ */
/*
* If you *really* need a unique prefix for all types and library functions,
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
*/
#ifdef Z_PREFIX
#define deflateInit_ z_deflateInit_
#define deflate z_deflate
#define deflateEnd z_deflateEnd
#define inflateInit_ z_inflateInit_
#define inflate z_inflate
#define inflateEnd z_inflateEnd
#define deflateInit2_ z_deflateInit2_
#define deflateSetDictionary z_deflateSetDictionary
#define deflateCopy z_deflateCopy
#define deflateReset z_deflateReset
#define deflateParams z_deflateParams
#define inflateInit2_ z_inflateInit2_
#define inflateSetDictionary z_inflateSetDictionary
#define inflateSync z_inflateSync
#define inflateSyncPoint z_inflateSyncPoint
#define inflateReset z_inflateReset
#define compress z_compress
#define compress2 z_compress2
#define uncompress z_uncompress
#define adler32 z_adler32
#define crc32 z_crc32
#define get_crc_table z_get_crc_table
#define Byte z_Byte
#define uInt z_uInt
#define uLong z_uLong
#define Bytef z_Bytef
#define charf z_charf
#define intf z_intf
#define uIntf z_uIntf
#define uLongf z_uLongf
#define voidpf z_voidpf
#define voidp z_voidp
#endif
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
#define WIN32
#endif
#if defined(WIN32) || defined(__386__) || defined(__i386)
#ifndef __32BIT__
#define __32BIT__
#endif
#endif
#if defined(__MSDOS__) && !defined(MSDOS)
#define MSDOS
#endif
/*
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more
* than 64k bytes at a time (needed on systems with 16-bit int).
*/
#if defined(MSDOS) && !defined(__32BIT__)
#define MAXSEG_64K
#endif
#ifdef MSDOS
#define UNALIGNED_OK
#endif
#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC)
#define STDC
#endif
#if (defined(__STDC__) || defined(__cplusplus)) || defined(__OS2__)
#ifndef STDC
#define STDC
#endif
#endif
#ifndef STDC
#ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
#define const
#endif
#endif
/* Some Mac compilers merge all .h files incorrectly: */
#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
#define NO_DUMMY_DECL
#endif
/* Old Borland C incorrectly complains about missing returns: */
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
#define NEED_DUMMY_RETURN
#endif
/* Maximum value for memLevel in deflateInit2 */
#ifndef MAX_MEM_LEVEL
#ifdef MAXSEG_64K
#define MAX_MEM_LEVEL 8
#else
#define MAX_MEM_LEVEL 9
#endif
#endif
/*
* Maximum value for windowBits in deflateInit2 and inflateInit2
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
* created by gzip. (Files created by minigzip can still be extracted by
* gzip.)
*/
#ifndef MAX_WBITS
#define MAX_WBITS 15 /* 32K LZ77 window */
#endif
/*
* The memory requirements for deflate are (in bytes):
* 1 << (windowBits+2) + 1 << (memLevel+9)
*
* that is: 128K for windowBits=15 + 128K for memLevel = 8 (default
* values) plus a few kilobytes for small objects. For example, if
* you want to reduce the default memory requirements from 256K to
* 128K, compile with
*
* make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
*
* Of course this will generally degrade compression (there's no free lunch).
*
* The memory requirements for inflate are (in bytes) 1 << windowBits
* that is, 32K for windowBits=15 (default value) plus a few kilobytes
* for small objects.
*/
/* Type declarations */
#ifndef OF /* function prototypes */
#ifdef STDC
#define OF(args) args
#else
#define OF(args) ()
#endif
#endif
/*
* The following definitions for FAR are needed only for MSDOS mixed
* model programming, small or medium model with some far allocations.
* This was tested only with MSC; for other MSDOS compilers you may have
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
* just define FAR to be empty.
*/
#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
/* MSC small or medium model */
#define SMALL_MEDIUM
#ifdef _MSC_VER
#define FAR __far
#else
#define FAR far
#endif
#endif
#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
#ifndef __32BIT__
#define SMALL_MEDIUM
#define FAR __far
#endif
#endif
/* Compile with -DZLIB_DLL for Windows DLL support */
#if defined(ZLIB_DLL)
#if defined(_WINDOWS) || defined(WINDOWS)
#ifdef FAR
#undef FAR
#endif
#include <windows.h>
#define ZEXPORT WINAPI
#ifdef WIN32
#define ZEXPORTVA WINAPIV
#else
#define ZEXPORTVA FAR _cdecl _export
#endif
#endif
#if defined(__BORLANDC__)
#if (__BORLANDC__ >= 0x0500) && defined(WIN32)
#include <windows.h>
#define ZEXPORT __declspec(dllexport) WINAPI
#define ZEXPORTRVA __declspec(dllexport) WINAPIV
#else
#if defined(_Windows) && defined(__DLL__)
#define ZEXPORT _export
#define ZEXPORTVA _export
#endif
#endif
#endif
#endif
#if defined(__BEOS__)
#if defined(ZLIB_DLL)
#define ZEXTERN extern __declspec(dllexport)
#else
#define ZEXTERN extern __declspec(dllimport)
#endif
#endif
#ifndef ZEXPORT
#define ZEXPORT
#endif
#ifndef ZEXPORTVA
#define ZEXPORTVA
#endif
#ifndef ZEXTERN
#define ZEXTERN extern
#endif
#ifndef FAR
#define FAR
#endif
#if !defined(MACOS) && !defined(TARGET_OS_MAC)
typedef unsigned char Byte; /* 8 bits */
#endif
typedef unsigned int uInt; /* 16 bits or more */
typedef unsigned long uLong; /* 32 bits or more */
#ifdef SMALL_MEDIUM
/* Borland C/C++ ignores FAR inside typedef */
#define Bytef Byte FAR
#else
typedef Byte FAR Bytef;
#endif
typedef char FAR charf;
typedef int FAR intf;
typedef uInt FAR uIntf;
typedef uLong FAR uLongf;
#ifdef STDC
typedef void FAR *voidpf;
typedef void *voidp;
#else
typedef Byte FAR *voidpf;
typedef Byte *voidp;
#endif
#ifdef HAVE_UNISTD_H
#include <sys/types.h> /* for off_t */
#include <unistd.h> /* for SEEK_* and off_t */
#define z_off_t off_t
#endif
#ifndef SEEK_SET
#define SEEK_SET 0 /* Seek from beginning of file. */
#define SEEK_CUR 1 /* Seek from current position. */
#define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
#endif
#ifndef z_off_t
#define z_off_t long
#endif
/* MVS linker does not support external names larger than 8 bytes */
#if defined(__MVS__)
#pragma map(deflateInit_, "DEIN")
#pragma map(deflateInit2_, "DEIN2")
#pragma map(deflateEnd, "DEEND")
#pragma map(inflateInit_, "ININ")
#pragma map(inflateInit2_, "ININ2")
#pragma map(inflateEnd, "INEND")
#pragma map(inflateSync, "INSY")
#pragma map(inflateSetDictionary, "INSEDI")
#pragma map(inflate_blocks, "INBL")
#pragma map(inflate_blocks_new, "INBLNE")
#pragma map(inflate_blocks_free, "INBLFR")
#pragma map(inflate_blocks_reset, "INBLRE")
#pragma map(inflate_codes_free, "INCOFR")
#pragma map(inflate_codes, "INCO")
#pragma map(inflate_fast, "INFA")
#pragma map(inflate_flush, "INFLU")
#pragma map(inflate_mask, "INMA")
#pragma map(inflate_set_dictionary, "INSEDI2")
#pragma map(inflate_copyright, "INCOPY")
#pragma map(inflate_trees_bits, "INTRBI")
#pragma map(inflate_trees_dynamic, "INTRDY")
#pragma map(inflate_trees_fixed, "INTRFI")
#pragma map(inflate_trees_free, "INTRFR")
#endif
/* --- zconf.h */
/* +++ zlib.h */
#define ZLIB_VERSION "1.1.3P"
/*
* The 'zlib' compression library provides in-memory compression
* and decompression functions, including integrity checks of the
* uncompressed data. This version of the library supports only one
* compression method (deflation) but other algorithms may be added
* later and will have the same stream interface.
*
* For compression the application must provide the output buffer
* and may optionally provide the input buffer for optimization. For
* decompression, the application must provide the input buffer and
* may optionally provide the output buffer for optimization.
*
* Compression can be done in a single step if the buffers are
* large enough (for example if an input file is mmap'ed), or can be
* done by repeated calls of the compression function. In the latter
* case, the application must provide more input and/or consume the
* output (providing more output space) before each call.
*
* The library does not install any signal handler. It is
* recommended to add at least a handler for SIGSEGV when
* decompressing; the library checks the consistency of the input
* data whenever possible but may go nuts for some forms of corrupted
* input.
*/
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
typedef void (*free_func) OF((voidpf opaque, voidpf address));
struct internal_state;
typedef struct z_stream_s {
Bytef *next_in; /* next input byte */
uInt avail_in; /* number of bytes available at next_in */
uLong total_in; /* total nb of input bytes read so far */
Bytef *next_out; /* next output byte should be put there */
uInt avail_out; /* remaining free space at next_out */
uLong total_out; /* total nb of bytes output so far */
const char *msg; /* last error message, NULL if no error */
struct internal_state FAR *state; /* not visible to applications */
alloc_func zalloc; /* used to allocate the internal state */
free_func zfree; /* used to free the internal state */
/* private data object passed to zalloc and zfree */
voidpf opaque;
/* best guess about the data type: ascii or binary */
int data_type;
uLong adler; /* adler32 value of the uncompressed data */
uLong reserved; /* reserved for future use */
} z_stream;
typedef z_stream FAR *z_streamp;
/*
* The application must update next_in and avail_in when avail_in has
* dropped to zero. It must update next_out and avail_out when
* avail_out has dropped to zero. The application must initialize
* zalloc, zfree and opaque before calling the init function. All
* other fields are set by the compression library and must not be
* updated by the application.
*
* The opaque value provided by the application will be passed as the
* first parameter for calls of zalloc and zfree. This can be useful
* for custom memory management. The compression library attaches no
* meaning to the opaque value.
*
* zalloc must return Z_NULL if there is not enough memory for the
* object. On 16-bit systems, the functions zalloc and zfree must be
* able to allocate exactly 65536 bytes, but will not be required to
* allocate more than this if the symbol MAXSEG_64K is defined (see
* zconf.h). WARNING: On MSDOS, pointers returned by zalloc for
* objects of exactly 65536 bytes *must* have their offset normalized
* to zero. The default allocation function provided by this library
* ensures this (see zutil.c). To reduce memory requirements and avoid
* any allocation of 64K objects, at the expense of compression ratio,
* compile the library with -DMAX_WBITS=14 (see zconf.h).
*
* The fields total_in and total_out can be used for statistics or
* progress reports. After compression, total_in holds the total size
* of the uncompressed data and may be saved for use in the
* decompressor (particularly if the decompressor wants to decompress
* everything in a single step).
*/
/* constants */
#define Z_NO_FLUSH 0
#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
#define Z_PACKET_FLUSH 2
#define Z_SYNC_FLUSH 3
#define Z_FULL_FLUSH 4
#define Z_FINISH 5
/* Allowed flush values; see deflate() below for details */
#define Z_OK 0
#define Z_STREAM_END 1
#define Z_NEED_DICT 2
#define Z_ERRNO (-1)
#define Z_STREAM_ERROR (-2)
#define Z_DATA_ERROR (-3)
#define Z_MEM_ERROR (-4)
#define Z_BUF_ERROR (-5)
#define Z_VERSION_ERROR (-6)
/*
* Return codes for the compression/decompression functions. Negative
* values are errors, positive values are used for special but normal
* events.
*/
#define Z_NO_COMPRESSION 0
#define Z_BEST_SPEED 1
#define Z_BEST_COMPRESSION 9
#define Z_DEFAULT_COMPRESSION (-1)
/* compression levels */
#define Z_FILTERED 1
#define Z_HUFFMAN_ONLY 2
#define Z_DEFAULT_STRATEGY 0
/* compression strategy; see deflateInit2() below for details */
#define Z_BINARY 0
#define Z_ASCII 1
#define Z_UNKNOWN 2
/* Possible values of the data_type field */
#define Z_DEFLATED 8
/* The deflate compression method (the only one supported in this version) */
#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
#define zlib_version zlibVersion()
/* for compatibility with versions < 1.0.2 */
/* basic functions */
ZEXTERN const char *ZEXPORT zlibVersion OF((void));
/*
* The application can compare zlibVersion and ZLIB_VERSION for
* consistency. If the first character differs, the library code
* actually used is not compatible with the zlib.h header file used by
* the application. This check is automatically made by deflateInit
* and inflateInit.
*/
/*
* ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
*
* Initializes the internal stream state for compression. The
* fields zalloc, zfree and opaque must be initialized before by
* the caller. If zalloc and zfree are set to Z_NULL, deflateInit
* updates them to use default allocation functions.
*
* The compression level must be Z_DEFAULT_COMPRESSION, or between
* 0 and 9: 1 gives best speed, 9 gives best compression, 0 gives
* no compression at all (the input data is simply copied a block
* at a time). Z_DEFAULT_COMPRESSION requests a default
* compromise between speed and compression (currently equivalent
* to level 6).
*
* deflateInit returns Z_OK if success, Z_MEM_ERROR if there was
* not enough memory, Z_STREAM_ERROR if level is not a valid
* compression level, Z_VERSION_ERROR if the zlib library version
* (zlib_version) is incompatible with the version assumed by the
* caller (ZLIB_VERSION). msg is set to null if there is no error
* message. deflateInit does not perform any compression: this
* will be done by deflate().
*/
ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
/*
* Performs one or both of the following actions:
*
* - Compress more input starting at next_in and update next_in and
* avail_in accordingly. If not all input can be processed (because
* there is not enough room in the output buffer), next_in and
* avail_in are updated and processing will resume at this point for
* the next call of deflate().
*
* - Provide more output starting at next_out and update next_out and
* avail_out accordingly. This action is forced if the parameter flush
* is non zero. Forcing flush frequently degrades the compression
* ratio, so this parameter should be set only when necessary (in
* interactive applications). Some output may be provided even if
* flush is not set.
*
* Before the call of deflate(), the application should ensure that at
* least one of the actions is possible, by providing more input
* and/or consuming more output, and updating avail_in or avail_out
* accordingly; avail_out should never be zero before the call. The
* application can consume the compressed output when it wants, for
* example when the output buffer is full (avail_out == 0), or after
* each call of deflate(). If deflate returns Z_OK and with zero
* avail_out, it must be called again after making room in the output
* buffer because there might be more output pending.
*
* If the parameter flush is set to Z_PARTIAL_FLUSH, the current
* compression block is terminated and flushed to the output buffer so
* that the decompressor can get all input data available so far. For
* method 9, a future variant on method 8, the current block will be
* flushed but not terminated. Z_SYNC_FLUSH has the same effect as
* partial flush except that the compressed output is byte aligned
* (the compressor can clear its internal bit buffer) and the current
* block is always terminated; this can be useful if the compressor
* has to be restarted from scratch after an interruption (in which
* case the internal state of the compressor may be lost). If flush
* is set to Z_FULL_FLUSH, the compression block is terminated, a
* special marker is output and the compression dictionary is
* discarded; this is useful to allow the decompressor to synchronize
* if one compressed block has been damaged (see inflateSync below).
* Flushing degrades compression and so should be used only when
* necessary. Using Z_FULL_FLUSH too often can seriously degrade the
* compression. If deflate returns with avail_out == 0, this function
* must be called again with the same value of the flush parameter and
* more output space (updated avail_out), until the flush is complete
* (deflate returns with non-zero avail_out).
*
* If the parameter flush is set to Z_PACKET_FLUSH, the compression
* block is terminated, and a zero-length stored block is output,
* omitting the length bytes (the effect of this is that the 3-bit
* type code 000 for a stored block is output, and the output is then
* byte-aligned). This is designed for use at the end of a PPP
* packet.
*
* If the parameter flush is set to Z_FINISH, pending input is
* processed, pending output is flushed and deflate returns with
* Z_STREAM_END if there was enough output space; if deflate returns
* with Z_OK, this function must be called again with Z_FINISH and
* more output space (updated avail_out) but no more input data, until
* it returns with Z_STREAM_END or an error. After deflate has
* returned Z_STREAM_END, the only possible operations on the stream
* are deflateReset or deflateEnd.
*
* Z_FINISH can be used immediately after deflateInit if all the
* compression is to be done in a single step. In this case, avail_out
* must be at least 0.1% larger than avail_in plus 12 bytes. If
* deflate does not return Z_STREAM_END, then it must be called again
* as described above.
*
* deflate() may update data_type if it can make a good guess about
* the input data type (Z_ASCII or Z_BINARY). In doubt, the data is
* considered binary. This field is only for information purposes and
* does not affect the compression algorithm in any manner.
*
* deflate() returns Z_OK if some progress has been made (more input
* processed or more output produced), Z_STREAM_END if all input has
* been consumed and all output has been produced (only when flush is
* set to Z_FINISH), Z_STREAM_ERROR if the stream state was
* inconsistent (for example if next_in or next_out was NULL),
* Z_BUF_ERROR if no progress is possible.
*/
ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
/*
* All dynamically allocated data structures for this stream are
* freed. This function discards any unprocessed input and does not
* flush any pending output.
*
* deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream
* state was inconsistent, Z_DATA_ERROR if the stream was freed
* prematurely (some input or output was discarded). In the error
* case, msg may be set but then points to a static string (which must
* not be deallocated).
*/
/*
* ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
*
* Initializes the internal stream state for decompression. The fields
* zalloc, zfree and opaque must be initialized before by the caller.
* If zalloc and zfree are set to Z_NULL, inflateInit updates them to
* use default allocation functions.
*
* inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
* enough memory, Z_VERSION_ERROR if the zlib library version is
* incompatible with the version assumed by the caller. msg is set to
* null if there is no error message. inflateInit does not perform any
* decompression: this will be done by inflate().
*/
ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
/*
* Performs one or both of the following actions:
*
* - Decompress more input starting at next_in and update next_in and
* avail_in accordingly. If not all input can be processed (because
* there is not enough room in the output buffer), next_in is
* updated and processing will resume at this point for the next
* call of inflate().
*
* - Provide more output starting at next_out and update next_out and
* avail_out accordingly. inflate() provides as much output as
* possible, until there is no more input data or no more space in
* the output buffer (see below about the flush parameter).
*
* Before the call of inflate(), the application should ensure that at
* least one of the actions is possible, by providing more input
* and/or consuming more output, and updating the next_* and avail_*
* values accordingly. The application can consume the uncompressed
* output when it wants, for example when the output buffer is full
* (avail_out == 0), or after each call of inflate(). If inflate
* returns Z_OK and with zero avail_out, it must be called again after
* making room in the output buffer because there might be more output
* pending.
*
* If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
* inflate flushes as much output as possible to the output
* buffer. The flushing behavior of inflate is not specified for
* values of the flush parameter other than Z_PARTIAL_FLUSH,
* Z_PACKET_FLUSH or Z_FINISH, but the current implementation actually
* flushes as much output as possible anyway. For Z_PACKET_FLUSH,
* inflate checks that once all the input data has been consumed, it
* is expecting to see the length field of a stored block; if not, it
* returns Z_DATA_ERROR.
*
* inflate() should normally be called until it returns Z_STREAM_END
* or an error. However if all decompression is to be performed in a
* single step (a single call of inflate), the parameter flush should
* be set to Z_FINISH. In this case all pending input is processed and
* all pending output is flushed; avail_out must be large enough to
* hold all the uncompressed data. (The size of the uncompressed data
* may have been saved by the compressor for this purpose.) The next
* operation on this stream must be inflateEnd to deallocate the
* decompression state. The use of Z_FINISH is never required, but can
* be used to inform inflate that a faster routine may be used for the
* single inflate() call.
*
* inflate() returns Z_OK if some progress has been made (more input
* processed or more output produced), Z_STREAM_END if the end of the
* compressed data has been reached and all uncompressed output has
* been produced, Z_NEED_DICT if a preset dictionary is needed at this
* point (see inflateSetDictionary below), Z_DATA_ERROR if the input
* data was corrupted, Z_STREAM_ERROR if the stream structure was
* inconsistent (for example if next_in or next_out was NULL),
* Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
* progress is possible or if there was not enough room in the output
* buffer when Z_FINISH is used. In the Z_DATA_ERROR case, the
* application may then call inflateSync to look for a good
* compression block. In the Z_NEED_DICT case, strm->adler is set to
* the Adler32 value of the dictionary chosen by the compressor.
*/
ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
/*
* All dynamically allocated data structures for this stream are
* freed. This function discards any unprocessed input and does not
* flush any pending output.
*
* inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream
* state was inconsistent. In the error case, msg may be set but then
* points to a static string (which must not be deallocated).
*/
/* Advanced functions */
/* The following functions are needed only in some special applications. */
/*
* ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
* int level,
* int method,
* int windowBits,
* int memLevel,
* int strategy));
*
* This is another version of deflateInit with more compression
* options. The fields next_in, zalloc, zfree and opaque must be
* initialized before by the caller.
*
* The method parameter is the compression method. It must be
* Z_DEFLATED in this version of the library. (Method 9 will allow a
* 64K history buffer and partial block flushes.)
*
* The windowBits parameter is the base two logarithm of the window
* size (the size of the history buffer). It should be in the range
* 8..15 for this version of the library (the value 16 will be allowed
* for method 9). Larger values of this parameter result in better
* compression at the expense of memory usage. The default value is 15
* if deflateInit is used instead.
*
* The memLevel parameter specifies how much memory should be
* allocated for the internal compression state. memLevel=1 uses
* minimum memory but is slow and reduces compression ratio;
* memLevel=9 uses maximum memory for optimal speed. The default value
* is 8. See zconf.h for total memory usage as a function of
* windowBits and memLevel.
*
* The strategy parameter is used to tune the compression
* algorithm. Use the value Z_DEFAULT_STRATEGY for normal data,
* Z_FILTERED for data produced by a filter (or predictor), or
* Z_HUFFMAN_ONLY to force Huffman encoding only (no string match).
* Filtered data consists mostly of small values with a somewhat
* random distribution. In this case, the compression algorithm is
* tuned to compress them better. The effect of Z_FILTERED is to force
* more Huffman coding and less string matching; it is somewhat
* intermediate between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy
* parameter only affects the compression ratio but not the
* correctness of the compressed output even if it is not set
* appropriately.
*
* If next_in is not null, the library will use this buffer to hold
* also some history information; the buffer must either hold the
* entire input data, or have at least 1<<(windowBits+1) bytes and be
* writable. If next_in is null, the library will allocate its own
* history buffer (and leave next_in null). next_out need not be
* provided here but must be provided by the application for the next
* call of deflate().
*
* If the history buffer is provided by the application, next_in must
* must never be changed by the application since the compressor
* maintains information inside this buffer from call to call; the
* application must provide more input only by increasing
* avail_in. next_in is always reset by the library in this case.
*
* deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not
* enough memory, Z_STREAM_ERROR if a parameter is invalid (such as an
* invalid method). msg is set to null if there is no error message.
* deflateInit2 does not perform any compression: this will be done by
* deflate().
*/
ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
const Bytef *dictionary, uInt dictLength));
/*
* Initializes the compression dictionary (history buffer) from the
* given byte sequence without producing any compressed output. This
* function must be called immediately after deflateInit or
* deflateInit2, before any call of deflate. The compressor and
* decompressor must use exactly the same dictionary (see
* inflateSetDictionary).
*
* The dictionary should consist of strings (byte sequences) that are
* likely to be encountered later in the data to be compressed, with
* the most commonly used strings preferably put towards the end of
* the dictionary. Using a dictionary is most useful when the data to
* be compressed is short and can be predicted with good accuracy; the
* data can then be compressed better than with the default empty
* dictionary. In this version of the library, only the last 32K bytes
* of the dictionary are used.
*
* Upon return of this function, strm->adler is set to the Adler32
* value of the dictionary; the decompressor may later use this value
* to determine which dictionary has been used by the compressor. (The
* Adler32 value applies to the whole dictionary even if only a subset
* of the dictionary is actually used by the compressor.)
*
* deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if
* a parameter is invalid (such as NULL dictionary) or the stream
* state is inconsistent (for example if deflate has already been
* called for this stream). deflateSetDictionary does not perform any
* compression: this will be done by deflate().
*/
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, z_streamp source));
/*
* Sets the destination stream as a complete copy of the source
* stream. If the source stream is using an application-supplied
* history buffer, a new buffer is allocated for the destination
* stream. The compressed output buffer is always
* application-supplied. It's the responsibility of the application to
* provide the correct values of next_out and avail_out for the next
* call of deflate.
*
* This function can be useful when several compression strategies
* will be tried, for example when there are several ways of
* pre-processing the input data with a filter. The streams that will
* be discarded should then be freed by calling deflateEnd. Note that
* deflateCopy duplicates the internal compression state which can be
* quite large, so this strategy is slow and can consume lots of
* memory.
*
* deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
* enough memory, Z_STREAM_ERROR if the source stream state was
* inconsistent (such as zalloc being NULL). msg is left unchanged in
* both source and destination.
*/
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
/*
* This function is equivalent to deflateEnd followed by deflateInit,
* but does not free and reallocate all the internal compression
* state. The stream will keep the same compression level and any
* other attributes that may have been set by deflateInit2.
*
* deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the
* source stream state was inconsistent (such as zalloc or state being
* NULL).
*/
ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy));
/*
* Dynamically update the compression level and compression strategy.
* This can be used to switch between compression and straight copy of
* the input data, or to switch to a different kind of input data
* requiring a different strategy. If the compression level is
* changed, the input available so far is compressed with the old
* level (and may be flushed); the new level will take effect only at
* the next call of deflate().
*
* Before the call of deflateParams, the stream state must be set as
* for a call of deflate(), since the currently available input may
* have to be compressed and flushed. In particular, strm->avail_out
* must be non-zero.
*
* deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
* stream state was inconsistent or if a parameter was invalid,
* Z_BUF_ERROR if strm->avail_out was zero.
*/
ZEXTERN int ZEXPORT deflateOutputPending OF((z_streamp strm));
/*
* Returns the number of bytes of output which are immediately
* available from the compressor (i.e. without any further input or
* flush).
*/
/*
* ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
* int windowBits));
*
* This is another version of inflateInit with more compression
* options. The fields next_out, zalloc, zfree and opaque must be
* initialized before by the caller.
*
* The windowBits parameter is the base two logarithm of the maximum
* window size (the size of the history buffer). It should be in the
* range 8..15 for this version of the library (the value 16 will be
* allowed soon). The default value is 15 if inflateInit is used
* instead. If a compressed stream with a larger window size is given
* as input, inflate() will return with the error code Z_DATA_ERROR
* instead of trying to allocate a larger window.
*
* If next_out is not null, the library will use this buffer for the
* history buffer; the buffer must either be large enough to hold the
* entire output data, or have at least 1<<windowBits bytes. If
* next_out is null, the library will allocate its own buffer (and
* leave next_out null). next_in need not be provided here but must be
* provided by the application for the next call of inflate().
*
* If the history buffer is provided by the application, next_out must
* never be changed by the application since the decompressor
* maintains history information inside this buffer from call to call;
* the application can only reset next_out to the beginning of the
* history buffer when avail_out is zero and all output has been
* consumed.
*
* inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not
* enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
* windowBits < 8). msg is set to null if there is no error message.
* inflateInit2 does not perform any decompression: this will be done
* by inflate().
*/
ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
const Bytef *dictionary, uInt dictLength));
/*
* Initializes the decompression dictionary (history buffer) from the
* given uncompressed byte sequence. This function must be called
* immediately after a call of inflate if this call returned
* Z_NEED_DICT. The dictionary chosen by the compressor can be
* determined from the Adler32 value returned by this call of
* inflate. The compressor and decompressor must use exactly the same
* dictionary (see deflateSetDictionary).
*
* inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
* parameter is invalid (such as NULL dictionary) or the stream state
* is inconsistent, Z_DATA_ERROR if the given dictionary doesn't match
* the expected one (incorrect Adler32 value). inflateSetDictionary
* does not perform any decompression: this will be done by subsequent
* calls of inflate().
*/
ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
/*
* Skips invalid compressed data until the special marker (see
* deflate() above) can be found, or until all available input is
* skipped. No output is provided.
*
* inflateSync returns Z_OK if the special marker has been found,
* Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no
* marker has been found, or Z_STREAM_ERROR if the stream structure
* was inconsistent. In the success case, the application may save the
* current current value of total_in which indicates where valid
* compressed data was found. In the error case, the application may
* repeatedly call inflateSync, providing more input each time, until
* success or end of the input data.
*/
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
/*
* This function is equivalent to inflateEnd followed by inflateInit,
* but does not free and reallocate all the internal decompression
* state. The stream will keep attributes that may have been set by
* inflateInit2.
*
* inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the
* source stream state was inconsistent (such as zalloc or state being
* NULL).
*/
ZEXTERN int inflateIncomp OF((z_stream *strm));
/*
* This function adds the data at next_in (avail_in bytes) to the
* output history without performing any output. There must be no
* pending output, and the decompressor must be expecting to see the
* start of a block. Calling this function is equivalent to
* decompressing a stored block containing the data at next_in (except
* that the data is not output).
*/
/* utility functions */
/*
* The following utility functions are implemented on top of the basic
* stream-oriented functions. To simplify the interface, some default
* options are assumed (compression level, window size, standard
* memory allocation functions). The source code of these utility
* functions can easily be modified if you need special options.
*/
/*
* ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
* const Bytef *source, uLong sourceLen));
*/
/*
* Compresses the source buffer into the destination buffer.
* sourceLen is the byte length of the source buffer. Upon entry,
* destLen is the total size of the destination buffer, which must be
* at least 0.1% larger than sourceLen plus 12 bytes. Upon exit,
* destLen is the actual size of the compressed buffer.
*
* This function can be used to compress a whole file at once if the
* input file is mmap'ed.
*
* compress returns Z_OK if success, Z_MEM_ERROR if there was not
* enough memory, Z_BUF_ERROR if there was not enough room in the
* output buffer.
*/
/*
* ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
* const Bytef *source, uLong sourceLen));
*/
/*
* Decompresses the source buffer into the destination buffer.
* sourceLen is the byte length of the source buffer. Upon entry,
* destLen is the total size of the destination buffer, which must be
* large enough to hold the entire uncompressed data. (The size of the
* uncompressed data must have been saved previously by the compressor
* and transmitted to the decompressor by some mechanism outside the
* scope of this compression library.) Upon exit, destLen is the
* actual size of the compressed buffer.
*
* This function can be used to decompress a whole file at once if the
* input file is mmap'ed.
*
* uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
* enough memory, Z_BUF_ERROR if there was not enough room in the
* output buffer, or Z_DATA_ERROR if the input data was corrupted.
*/
typedef voidp gzFile;
/* ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); */
/*
* Opens a gzip (.gz) file for reading or writing. The mode parameter
* is as in fopen ("rb" or "wb") but can also include a compression
* level ("wb9"). gzopen can be used to read a file which is not in
* gzip format; in this case gzread will directly read from the file
* without decompression.
*
* gzopen 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).
*/
/* ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); */
/*
* gzdopen() associates a gzFile with the file descriptor fd. File
* descriptors are obtained from calls like open, dup, creat, pipe or
* fileno (in the file has been previously opened with fopen). The
* mode parameter is as in gzopen.
*
* The next call of gzclose on the returned gzFile will also close the
* file descriptor fd, just like fclose(fdopen(fd), mode) closes the
* file descriptor fd. If you want to keep fd open, use
* gzdopen(dup(fd), mode).
*
* gzdopen returns NULL if there was insufficient memory to allocate
* the (de)compression state.
*/
/* ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); */
/*
* Reads the given number of uncompressed bytes from the compressed
* file. If the input file was not in gzip format, gzread copies the
* given number of bytes into the buffer.
*
* gzread returns the number of uncompressed bytes actually read (0
* for end of file, -1 for error).
*/
/*
* ZEXTERN int ZEXPORT gzwrite OF((gzFile file, const voidp buf,
* unsigned len));
*/
/*
* Writes the given number of uncompressed bytes into the compressed
* file. gzwrite returns the number of uncompressed bytes actually
* written (0 in case of error).
*/
/* ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); */
/*
* Flushes all pending output into the compressed file. The parameter
* flush is as in the deflate() function. The return value is the zlib
* error number (see function gzerror below). gzflush returns Z_OK if
* the flush parameter is Z_FINISH and all output could be flushed.
*
* gzflush should be called only when strictly necessary because it
* can degrade compression.
*/
/* ZEXTERN int ZEXPORT gzclose OF((gzFile file)); */
/*
* Flushes all pending output if necessary, closes the compressed file
* and deallocates all the (de)compression state. The return value is
* the zlib error number (see function gzerror below).
*/
/* ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); */
/*
* Returns the error message for the last error which occurred on the
* given compressed file. errnum is set to zlib error number. If an
* error occurred in the file system and not in the compression
* library, errnum is set to Z_ERRNO and the application may consult
* errno to get the exact error code.
*/
/* checksum functions */
/*
* These functions are not related to compression but are exported
* anyway because they might be useful in applications using the
* compression library.
*/
ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
/*
* Update a running Adler-32 checksum with the bytes buf[0..len-1] and
* return the updated checksum. If buf is NULL, this function returns
* the required initial value for the checksum. An Adler-32 checksum
* is almost as reliable as a CRC32 but can be computed much
* faster. Usage example:
*
* uLong adler = adler32(0L, Z_NULL, 0);
*
* while (read_buffer(buffer, length) != EOF) {
* adler = adler32(adler, buffer, length);
* }
* if (adler != original_adler) error();
*/
/* ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); */
/*
* Update a running crc with the bytes buf[0..len-1] and return the
* updated crc. If buf is NULL, this function returns the required
* initial value for the crc. Pre- and post-conditioning (one's
* complement) is performed within this function so it shouldn't be
* done by the application. Usage example:
*
* uLong crc = crc32(0L, Z_NULL, 0);
*
* while (read_buffer(buffer, length) != EOF) {
* crc = crc32(crc, buffer, length);
* }
* if (crc != original_crc) error();
*/
/* various hacks, don't look :) */
/*
* deflateInit and inflateInit are macros to allow checking the zlib version
* and the compiler's view of z_stream:
*/
ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
const char *version, int stream_size));
ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
const char *version, int stream_size));
ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
int windowBits, int memLevel, int strategy,
const char *version, int stream_size));
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
const char *version, int stream_size));
#define deflateInit(strm, level) \
deflateInit_((strm), (level), ZLIB_VERSION, sizeof (z_stream))
#define inflateInit(strm) \
inflateInit_((strm), ZLIB_VERSION, sizeof (z_stream))
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
deflateInit2_((strm), (level), (method), (windowBits), (memLevel), \
(strategy), ZLIB_VERSION, sizeof (z_stream))
#define inflateInit2(strm, windowBits) \
inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof (z_stream))
#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
struct internal_state {int dummy; }; /* hack for buggy compilers */
#endif
/*
* uLongf *get_crc_table OF((void)); * can be used by asm versions of
* crc32()
*/
#ifdef __cplusplus
}
#endif
#endif /* _ZLIB_H */