path: root/usr/src/uts/common/io/ppp/spppcomp/zlib.h

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