/* * This file is derived from various .h and .c files from the zlib-0.95 * 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: * - changed functions not used outside this file to "local" * - added minCompression parameter to deflateInit2 * - added Z_PACKET_FLUSH (see zlib.h for details) * - added inflateIncomp *//*+++++*//* zutil.h -- internal interface and configuration of the compression library * Copyright (C) 1995 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.9 1995/05/03 17:27:12 jloup Exp */#define _Z_UTIL_H#include "armboot.h"#include "zlib.h"#ifndef local#  define local static#endif/* compile with -Dlocal if your debugger can't find static symbols */#define FARtypedef unsigned char  uch;typedef uch FAR uchf;typedef unsigned short ush;typedef ush FAR ushf;typedef unsigned long  ulg;extern char *z_errmsg[]; /* indexed by 1-zlib_error */#define ERR_RETURN(strm,err) return (strm->msg=z_errmsg[1-err], err)/* To be used only when the state is known to be valid */#ifndef NULL#define NULL	((void *) 0)#endif        /* common constants */#define DEFLATED   8#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 */         /* functions */#include <linux/string.h>#define zmemcpy memcpy#define zmemzero(dest, len)	memset(dest, 0, len)/* Diagnostic functions */#ifdef DEBUG_ZLIB#  include <stdio.h>#  ifndef verbose#    define verbose 0#  endif#  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, 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, size)	\	   (*((strm)->zfree))((strm)->opaque, (voidpf)(addr), (size))#define TRY_FREE(s, p, n) {if (p) ZFREE(s, p, n);}/* deflate.h -- internal compression state * Copyright (C) 1995 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. *//*+++++*//* infblock.h -- header to use infblock.c * Copyright (C) 1995 Mark Adler * 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. */struct inflate_blocks_state;typedef struct inflate_blocks_state FAR inflate_blocks_statef;local inflate_blocks_statef * inflate_blocks_new OF((    z_stream *z,    check_func c,               /* check function */    uInt w));                   /* window size */local int inflate_blocks OF((    inflate_blocks_statef *,    z_stream *,    int));                      /* initial return code */local void inflate_blocks_reset OF((    inflate_blocks_statef *,    z_stream *,    uLongf *));                  /* check value on output */local int inflate_blocks_free OF((    inflate_blocks_statef *,    z_stream *,    uLongf *));                  /* check value on output */local int inflate_addhistory OF((    inflate_blocks_statef *,    z_stream *));local int inflate_packet_flush OF((    inflate_blocks_statef *));/*+++++*//* inftrees.h -- header to use inftrees.c * Copyright (C) 1995 Mark Adler * 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. *//* Huffman code lookup table entry--this entry is four bytes for machines   that have 16-bit pointers (e.g. PC's in the small or medium model). */typedef struct inflate_huft_s FAR inflate_huft;struct inflate_huft_s {  union {    struct {      Byte Exop;        /* number of extra bits or operation */      Byte Bits;        /* number of bits in this code or subcode */    } what;    uInt Nalloc;	/* number of these allocated here */    Bytef *pad;         /* pad structure to a power of 2 (4 bytes for */  } word;               /*  16-bit, 8 bytes for 32-bit machines) */  union {    uInt Base;          /* literal, length base, or distance base */    inflate_huft *Next; /* pointer to next level of table */  } more;};#ifdef DEBUG_ZLIB  local uInt inflate_hufts;#endiflocal int inflate_trees_bits OF((    uIntf *,                    /* 19 code lengths */    uIntf *,                    /* bits tree desired/actual depth */    inflate_huft * FAR *,       /* bits tree result */    z_stream *));               /* for zalloc, zfree functions */local int inflate_trees_dynamic OF((    uInt,                       /* number of literal/length codes */    uInt,                       /* number of distance codes */    uIntf *,                    /* that many (total) code lengths */    uIntf *,                    /* literal desired/actual bit depth */    uIntf *,                    /* distance desired/actual bit depth */    inflate_huft * FAR *,       /* literal/length tree result */    inflate_huft * FAR *,       /* distance tree result */    z_stream *));               /* for zalloc, zfree functions */local int inflate_trees_fixed OF((    uIntf *,                    /* literal desired/actual bit depth */    uIntf *,                    /* distance desired/actual bit depth */    inflate_huft * FAR *,       /* literal/length tree result */    inflate_huft * FAR *));     /* distance tree result */local int inflate_trees_free OF((    inflate_huft *,             /* tables to free */    z_stream *));               /* for zfree function *//*+++++*//* infcodes.h -- header to use infcodes.c * Copyright (C) 1995 Mark Adler * 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. */struct inflate_codes_state;typedef struct inflate_codes_state FAR inflate_codes_statef;local inflate_codes_statef *inflate_codes_new OF((    uInt, uInt,    inflate_huft *, inflate_huft *,    z_stream *));local int inflate_codes OF((    inflate_blocks_statef *,    z_stream *,    int));local void inflate_codes_free OF((    inflate_codes_statef *,    z_stream *));/*+++++*//* inflate.c -- zlib interface to inflate modules * Copyright (C) 1995 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h *//* inflate private state */struct internal_state {  /* mode */  enum {      METHOD,   /* waiting for method byte */      FLAG,     /* waiting for flag byte */      BLOCKS,   /* decompressing blocks */      CHECK4,   /* four check bytes to go */      CHECK3,   /* three check bytes to go */      CHECK2,   /* two check bytes to go */      CHECK1,   /* one check byte to go */      DONE,     /* finished check, done */      BAD}      /* got an error--stay here */    mode;               /* current inflate mode */  /* mode dependent information */  union {    uInt method;        /* if FLAGS, method byte */    struct {      uLong was;                /* computed check value */      uLong need;               /* stream check value */    } check;            /* if CHECK, check values to compare */    uInt marker;        /* if BAD, inflateSync's marker bytes count */  } sub;        /* submode */  /* mode independent information */  int  nowrap;          /* flag for no wrapper */  uInt wbits;           /* log2(window size)  (8..15, defaults to 15) */  inflate_blocks_statef    *blocks;            /* current inflate_blocks state */};int inflateReset(z)z_stream *z;{  uLong c;  if (z == Z_NULL || z->state == Z_NULL)    return Z_STREAM_ERROR;  z->total_in = z->total_out = 0;  z->msg = Z_NULL;  z->state->mode = z->state->nowrap ? BLOCKS : METHOD;  inflate_blocks_reset(z->state->blocks, z, &c);  Trace((stderr, "inflate: reset\n"));  return Z_OK;}int inflateEnd(z)z_stream *z;{  uLong c;  if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)    return Z_STREAM_ERROR;  if (z->state->blocks != Z_NULL)    inflate_blocks_free(z->state->blocks, z, &c);  ZFREE(z, z->state, sizeof(struct internal_state));  z->state = Z_NULL;  Trace((stderr, "inflate: end\n"));  return Z_OK;}int inflateInit2(z, w)z_stream *z;int w;{  /* initialize state */  if (z == Z_NULL)    return Z_STREAM_ERROR;/*  if (z->zalloc == Z_NULL) z->zalloc = zcalloc; *//*  if (z->zfree == Z_NULL) z->zfree = zcfree; */  if ((z->state = (struct internal_state FAR *)       ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)    return Z_MEM_ERROR;  z->state->blocks = Z_NULL;  /* handle undocumented nowrap option (no zlib header or check) */  z->state->nowrap = 0;  if (w < 0)  {    w = - w;    z->state->nowrap = 1;  }  /* set window size */  if (w < 8 || w > 15)  {    inflateEnd(z);    return Z_STREAM_ERROR;  }  z->state->wbits = (uInt)w;  /* create inflate_blocks state */  if ((z->state->blocks =       inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, 1 << w))      == Z_NULL)  {    inflateEnd(z);    return Z_MEM_ERROR;  }  Trace((stderr, "inflate: allocated\n"));  /* reset state */  inflateReset(z);  return Z_OK;}int inflateInit(z)z_stream *z;{  return inflateInit2(z, DEF_WBITS);}#define NEEDBYTE {if(z->avail_in==0)goto empty;r=Z_OK;}#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)int inflate(z, f)z_stream *z;int f;{  int r;  uInt b;  if (z == Z_NULL || z->next_in == Z_NULL)    return Z_STREAM_ERROR;  r = Z_BUF_ERROR;  while (1) switch (z->state->mode)  {    case METHOD:      NEEDBYTE      if (((z->state->sub.method = NEXTBYTE) & 0xf) != DEFLATED)      {        z->state->mode = BAD;        z->msg = "unknown compression method";        z->state->sub.marker = 5;       /* can't try inflateSync */        break;      }      if ((z->state->sub.method >> 4) + 8 > z->state->wbits)      {        z->state->mode = BAD;        z->msg = "invalid window size";        z->state->sub.marker = 5;       /* can't try inflateSync */        break;      }      z->state->mode = FLAG;    case FLAG:      NEEDBYTE      if ((b = NEXTBYTE) & 0x20)      {        z->state->mode = BAD;        z->msg = "invalid reserved bit";