/* * This file is derived from various .h and .c files 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.  See zlib.h for conditions of * distribution and use. * * Changes that have been made include: * - added Z_PACKET_FLUSH (see zlib.h for details) * - added inflateIncomp and deflateOutputPending * - allow strm->next_out to be NULL, meaning discard the output * * $Id: zlib.c,v 1.3 1997/12/23 10:47:42 paulus Exp $ *//*  *  ==FILEVERSION 20020318== * * This marker is used by the Linux installation script to determine * whether an up-to-date version of this file is already installed. */#define NO_DUMMY_DECL#define NO_ZCFUNCS#define MY_ZCALLOC#if defined(__FreeBSD__) && (defined(KERNEL) || defined(_KERNEL))#define inflate	inflate_ppp	/* FreeBSD already has an inflate :-( */#endif/* +++ zutil.h *//* zutil.h -- internal interface and configuration of the compression library * Copyright (C) 1995-1996 Jean-loup Gailly. * For conditions of distribution and use, see copyright notice in zlib.h *//* WARNING: this file should *not* be used by applications. It is   part of the implementation of the compression library and is   subject to change. Applications should only use zlib.h. *//* From: zutil.h,v 1.16 1996/07/24 13:41:13 me Exp $ */#ifndef _Z_UTIL_H#define _Z_UTIL_H#include "zlib.h"#if defined(KERNEL) || defined(_KERNEL)/* Assume this is a *BSD or SVR4 kernel */#include <sys/types.h>#include <sys/time.h>#include <sys/systm.h>#  define HAVE_MEMCPY#  define memcpy(d, s, n)	bcopy((s), (d), (n))#  define memset(d, v, n)	bzero((d), (n))#  define memcmp		bcmp#else#if defined(__KERNEL__)/* Assume this is a Linux kernel */#include <linux/string.h>#define HAVE_MEMCPY#else /* not kernel */#if defined(MSDOS)||defined(VMS)||defined(CRAY)||defined(WIN32)||defined(RISCOS)#   include <stddef.h>#   include <errno.h>#else    extern int errno;#endif#ifdef STDC#  include <string.h>#  include <stdlib.h>#endif#endif /* __KERNEL__ */#endif /* _KERNEL || KERNEL */#ifndef local#  define local static#endif/* compile with -Dlocal if your debugger can't find static symbols */typedef unsigned char  uch;typedef uch FAR uchf;typedef unsigned short ush;typedef ush FAR ushf;typedef unsigned long  ulg;extern const char *z_errmsg[10]; /* indexed by 2-zlib_error *//* (size given to avoid silly warnings with Visual C++) */#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]#define ERR_RETURN(strm,err) \  return (strm->msg = (char*)ERR_MSG(err), (err))/* To be used only when the state is known to be valid */        /* common constants */#ifndef DEF_WBITS#  define DEF_WBITS MAX_WBITS#endif/* default windowBits for decompression. MAX_WBITS is for compression only */#if MAX_MEM_LEVEL >= 8#  define DEF_MEM_LEVEL 8#else#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL#endif/* default memLevel */#define STORED_BLOCK 0#define STATIC_TREES 1#define DYN_TREES    2/* The three kinds of block type */#define MIN_MATCH  3#define MAX_MATCH  258/* The minimum and maximum match lengths */#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */        /* target dependencies */#ifdef MSDOS#  define OS_CODE  0x00#  ifdef __TURBOC__#    include <alloc.h>#  else /* MSC or DJGPP */#    include <malloc.h>#  endif#endif#ifdef OS2#  define OS_CODE  0x06#endif#ifdef WIN32 /* Window 95 & Windows NT */#  define OS_CODE  0x0b#endif#if defined(VAXC) || defined(VMS)#  define OS_CODE  0x02#  define FOPEN(name, mode) \     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")#endif#ifdef AMIGA#  define OS_CODE  0x01#endif#if defined(ATARI) || defined(atarist)#  define OS_CODE  0x05#endif#ifdef MACOS#  define OS_CODE  0x07#endif#ifdef __50SERIES /* Prime/PRIMOS */#  define OS_CODE  0x0F#endif#ifdef TOPS20#  define OS_CODE  0x0a#endif#if defined(_BEOS_) || defined(RISCOS)#  define fdopen(fd,mode) NULL /* No fdopen() */#endif        /* Common defaults */#ifndef OS_CODE#  define OS_CODE  0x03  /* assume Unix */#endif#ifndef FOPEN#  define FOPEN(name, mode) fopen((name), (mode))#endif         /* functions */#ifdef HAVE_STRERROR   extern char *strerror OF((int));#  define zstrerror(errnum) strerror(errnum)#else#  define zstrerror(errnum) ""#endif#if defined(pyr)#  define NO_MEMCPY#endif#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(_MSC_VER) /* Use our own functions for small and medium model with MSC <= 5.0.  * You may have to use the same strategy for Borland C (untested).  */#  define NO_MEMCPY#endif#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)#  define HAVE_MEMCPY#endif#ifdef HAVE_MEMCPY#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */#    define zmemcpy _fmemcpy#    define zmemcmp _fmemcmp#    define zmemzero(dest, len) _fmemset(dest, 0, len)#  else#    define zmemcpy memcpy#    define zmemcmp memcmp#    define zmemzero(dest, len) memset(dest, 0, len)#  endif#else   extern void zmemcpy  OF((Bytef* dest, Bytef* source, uInt len));   extern int  zmemcmp  OF((Bytef* s1,   Bytef* s2, uInt len));   extern void zmemzero OF((Bytef* dest, uInt len));#endif/* Diagnostic functions */#ifdef DEBUG_ZLIB#  include <stdio.h>#  ifndef verbose#    define verbose 0#  endif   extern void z_error    OF((char *m));#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}#  define Trace(x) fprintf x#  define Tracev(x) {if (verbose) fprintf x ;}#  define Tracevv(x) {if (verbose>1) fprintf x ;}#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}#else#  define Assert(cond,msg)#  define Trace(x)#  define Tracev(x)#  define Tracevv(x)#  define Tracec(c,x)#  define Tracecv(c,x)#endiftypedef uLong (*check_func) OF((uLong check, const Bytef *buf, uInt len));voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));void   zcfree  OF((voidpf opaque, voidpf ptr));#define ZALLOC(strm, items, size) \           (*((strm)->zalloc))((strm)->opaque, (items), (size))#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}#endif /* _Z_UTIL_H *//* --- zutil.h *//* +++ deflate.h *//* deflate.h -- internal compression state * Copyright (C) 1995-1996 Jean-loup Gailly * For conditions of distribution and use, see copyright notice in zlib.h  *//* WARNING: this file should *not* be used by applications. It is   part of the implementation of the compression library and is   subject to change. Applications should only use zlib.h. *//* From: deflate.h,v 1.10 1996/07/02 12:41:00 me Exp $ */#ifndef _DEFLATE_H#define _DEFLATE_H/* #include "zutil.h" *//* =========================================================================== * Internal compression state. */#define LENGTH_CODES 29/* number of length codes, not counting the special END_BLOCK code */#define LITERALS  256/* number of literal bytes 0..255 */#define L_CODES (LITERALS+1+LENGTH_CODES)/* number of Literal or Length codes, including the END_BLOCK code */#define D_CODES   30/* number of distance codes */#define BL_CODES  19/* number of codes used to transfer the bit lengths */#define HEAP_SIZE (2*L_CODES+1)/* maximum heap size */#define MAX_BITS 15/* All codes must not exceed MAX_BITS bits */#define INIT_STATE    42#define BUSY_STATE   113#define FINISH_STATE 666/* Stream status *//* Data structure describing a single value and its code string. */typedef struct ct_data_s {    union {        ush  freq;       /* frequency count */        ush  code;       /* bit string */    } fc;    union {        ush  dad;        /* father node in Huffman tree */        ush  len;        /* length of bit string */    } dl;} FAR ct_data;#define Freq fc.freq#define Code fc.code#define Dad  dl.dad#define Len  dl.lentypedef struct static_tree_desc_s  static_tree_desc;typedef struct tree_desc_s {    ct_data *dyn_tree;           /* the dynamic tree */    int     max_code;            /* largest code with non zero frequency */    static_tree_desc *stat_desc; /* the corresponding static tree */} FAR tree_desc;typedef ush Pos;typedef Pos FAR Posf;typedef unsigned IPos;/* A Pos is an index in the character window. We use short instead of int to * save space in the various tables. IPos is used only for parameter passing. */typedef struct deflate_state {    z_streamp strm;      /* pointer back to this zlib stream */    int   status;        /* as the name implies */    Bytef *pending_buf;  /* output still pending */    ulg   pending_buf_size; /* size of pending_buf */    Bytef *pending_out;  /* next pending byte to output to the stream */    int   pending;       /* nb of bytes in the pending buffer */    int   noheader;      /* suppress zlib header and adler32 */    Byte  data_type;     /* UNKNOWN, BINARY or ASCII */    Byte  method;        /* STORED (for zip only) or DEFLATED */    int   last_flush;    /* value of flush param for previous deflate call */                /* used by deflate.c: */    uInt  w_size;        /* LZ77 window size (32K by default) */    uInt  w_bits;        /* log2(w_size)  (8..16) */    uInt  w_mask;        /* w_size - 1 */    Bytef *window;    /* Sliding window. Input bytes are read into the second half of the window,     * and move to the first half later to keep a dictionary of at least wSize     * bytes. With this organization, matches are limited to a distance of     * wSize-MAX_MATCH bytes, but this ensures that IO is always     * performed with a length multiple of the block size. Also, it limits     * the window size to 64K, which is quite useful on MSDOS.     * To do: use the user input buffer as sliding window.     */    ulg window_size;    /* Actual size of window: 2*wSize, except when the user input buffer     * is directly used as sliding window.     */    Posf *prev;    /* Link to older string with same hash index. To limit the size of this     * array to 64K, this link is maintained only for the last 32K strings.     * An index in this array is thus a window index modulo 32K.     */