diff --git a/backport-zlib-update.patch b/backport-zlib-update.patch new file mode 100644 index 0000000000000000000000000000000000000000..1f4cd6e1bc6d46bf7617077dadcae0ed4d8443b7 --- /dev/null +++ b/backport-zlib-update.patch @@ -0,0 +1,6482 @@ +From 31f1d646da884efd8f540e963631e3cd34eb12d3 Mon Sep 17 00:00:00 2001 +From: "H. Peter Anvin" +Date: Mon, 28 Jan 2019 14:45:42 -0800 +Subject: [PATCH] zlib: update to version 1.2.11 + +Update zlib to version 1.2.11 due to errata in previous versions. + +Signed-off-by: H. Peter Anvin +--- + com32/include/gzguts.h | 218 ++++++++++ + com32/include/zconf.h | 234 +++++++--- + com32/include/zlib.h | 753 +++++++++++++++++++++++---------- + com32/lib/zlib/FAQ | 12 +- + com32/lib/zlib/README | 24 +- + com32/lib/zlib/adler32.c | 85 ++-- + com32/lib/zlib/compress.c | 42 +- + com32/lib/zlib/crc32.c | 120 +++--- + com32/lib/zlib/crc32.h | 2 +- + com32/lib/zlib/deflate.c | 1033 ++++++++++++++++++++++++++++++--------------- + com32/lib/zlib/deflate.h | 45 +- + com32/lib/zlib/infback.c | 18 +- + com32/lib/zlib/inffast.c | 89 ++-- + com32/lib/zlib/inffixed.h | 6 +- + com32/lib/zlib/inflate.c | 253 +++++++---- + com32/lib/zlib/inflate.h | 11 +- + com32/lib/zlib/inftrees.c | 74 ++-- + com32/lib/zlib/trees.c | 151 +++---- + com32/lib/zlib/uncompr.c | 152 ++++--- + com32/lib/zlib/zlib.3 | 82 ++-- + com32/lib/zlib/zutil.c | 71 ++-- + com32/lib/zlib/zutil.h | 167 ++++---- + 22 files changed, 2335 insertions(+), 1307 deletions(-) + create mode 100644 com32/include/gzguts.h + rewrite com32/lib/zlib/uncompr.c (62%) + +diff --git a/com32/include/gzguts.h b/com32/include/gzguts.h +new file mode 100644 +index 00000000..990a4d25 +--- /dev/null ++++ b/com32/include/gzguts.h +@@ -0,0 +1,218 @@ ++/* gzguts.h -- zlib internal header definitions for gz* operations ++ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler ++ * For conditions of distribution and use, see copyright notice in zlib.h ++ */ ++ ++#ifdef _LARGEFILE64_SOURCE ++# ifndef _LARGEFILE_SOURCE ++# define _LARGEFILE_SOURCE 1 ++# endif ++# ifdef _FILE_OFFSET_BITS ++# undef _FILE_OFFSET_BITS ++# endif ++#endif ++ ++#ifdef HAVE_HIDDEN ++# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) ++#else ++# define ZLIB_INTERNAL ++#endif ++ ++#include ++#include "zlib.h" ++#ifdef STDC ++# include ++# include ++# include ++#endif ++ ++#ifndef _POSIX_SOURCE ++# define _POSIX_SOURCE ++#endif ++#include ++ ++#ifdef _WIN32 ++# include ++#endif ++ ++#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32) ++# include ++#endif ++ ++#if defined(_WIN32) || defined(__CYGWIN__) ++# define WIDECHAR ++#endif ++ ++#ifdef WINAPI_FAMILY ++# define open _open ++# define read _read ++# define write _write ++# define close _close ++#endif ++ ++#ifdef NO_DEFLATE /* for compatibility with old definition */ ++# define NO_GZCOMPRESS ++#endif ++ ++#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) ++# ifndef HAVE_VSNPRINTF ++# define HAVE_VSNPRINTF ++# endif ++#endif ++ ++#if defined(__CYGWIN__) ++# ifndef HAVE_VSNPRINTF ++# define HAVE_VSNPRINTF ++# endif ++#endif ++ ++#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410) ++# ifndef HAVE_VSNPRINTF ++# define HAVE_VSNPRINTF ++# endif ++#endif ++ ++#ifndef HAVE_VSNPRINTF ++# ifdef MSDOS ++/* vsnprintf may exist on some MS-DOS compilers (DJGPP?), ++ but for now we just assume it doesn't. */ ++# define NO_vsnprintf ++# endif ++# ifdef __TURBOC__ ++# define NO_vsnprintf ++# endif ++# ifdef WIN32 ++/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ ++# if !defined(vsnprintf) && !defined(NO_vsnprintf) ++# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) ++# define vsnprintf _vsnprintf ++# endif ++# endif ++# endif ++# ifdef __SASC ++# define NO_vsnprintf ++# endif ++# ifdef VMS ++# define NO_vsnprintf ++# endif ++# ifdef __OS400__ ++# define NO_vsnprintf ++# endif ++# ifdef __MVS__ ++# define NO_vsnprintf ++# endif ++#endif ++ ++/* unlike snprintf (which is required in C99), _snprintf does not guarantee ++ null termination of the result -- however this is only used in gzlib.c where ++ the result is assured to fit in the space provided */ ++#if defined(_MSC_VER) && _MSC_VER < 1900 ++# define snprintf _snprintf ++#endif ++ ++#ifndef local ++# define local static ++#endif ++/* since "static" is used to mean two completely different things in C, we ++ define "local" for the non-static meaning of "static", for readability ++ (compile with -Dlocal if your debugger can't find static symbols) */ ++ ++/* gz* functions always use library allocation functions */ ++#ifndef STDC ++ extern voidp malloc OF((uInt size)); ++ extern void free OF((voidpf ptr)); ++#endif ++ ++/* get errno and strerror definition */ ++#if defined UNDER_CE ++# include ++# define zstrerror() gz_strwinerror((DWORD)GetLastError()) ++#else ++# ifndef NO_STRERROR ++# include ++# define zstrerror() strerror(errno) ++# else ++# define zstrerror() "stdio error (consult errno)" ++# endif ++#endif ++ ++/* provide prototypes for these when building zlib without LFS */ ++#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 ++ ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); ++ ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); ++ ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); ++ ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); ++#endif ++ ++/* default memLevel */ ++#if MAX_MEM_LEVEL >= 8 ++# define DEF_MEM_LEVEL 8 ++#else ++# define DEF_MEM_LEVEL MAX_MEM_LEVEL ++#endif ++ ++/* default i/o buffer size -- double this for output when reading (this and ++ twice this must be able to fit in an unsigned type) */ ++#define GZBUFSIZE 8192 ++ ++/* gzip modes, also provide a little integrity check on the passed structure */ ++#define GZ_NONE 0 ++#define GZ_READ 7247 ++#define GZ_WRITE 31153 ++#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ ++ ++/* values for gz_state how */ ++#define LOOK 0 /* look for a gzip header */ ++#define COPY 1 /* copy input directly */ ++#define GZIP 2 /* decompress a gzip stream */ ++ ++/* internal gzip file state data structure */ ++typedef struct { ++ /* exposed contents for gzgetc() macro */ ++ struct gzFile_s x; /* "x" for exposed */ ++ /* x.have: number of bytes available at x.next */ ++ /* x.next: next output data to deliver or write */ ++ /* x.pos: current position in uncompressed data */ ++ /* used for both reading and writing */ ++ int mode; /* see gzip modes above */ ++ int fd; /* file descriptor */ ++ char *path; /* path or fd for error messages */ ++ unsigned size; /* buffer size, zero if not allocated yet */ ++ unsigned want; /* requested buffer size, default is GZBUFSIZE */ ++ unsigned char *in; /* input buffer (double-sized when writing) */ ++ unsigned char *out; /* output buffer (double-sized when reading) */ ++ int direct; /* 0 if processing gzip, 1 if transparent */ ++ /* just for reading */ ++ int how; /* 0: get header, 1: copy, 2: decompress */ ++ z_off64_t start; /* where the gzip data started, for rewinding */ ++ int eof; /* true if end of input file reached */ ++ int past; /* true if read requested past end */ ++ /* just for writing */ ++ int level; /* compression level */ ++ int strategy; /* compression strategy */ ++ /* seek request */ ++ z_off64_t skip; /* amount to skip (already rewound if backwards) */ ++ int seek; /* true if seek request pending */ ++ /* error information */ ++ int err; /* error code */ ++ char *msg; /* error message */ ++ /* zlib inflate or deflate stream */ ++ z_stream strm; /* stream structure in-place (not a pointer) */ ++} gz_state; ++typedef gz_state FAR *gz_statep; ++ ++/* shared functions */ ++void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); ++#if defined UNDER_CE ++char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); ++#endif ++ ++/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t ++ value -- needed when comparing unsigned to z_off64_t, which is signed ++ (possible z_off64_t types off_t, off64_t, and long are all signed) */ ++#ifdef INT_MAX ++# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) ++#else ++unsigned ZLIB_INTERNAL gz_intmax OF((void)); ++# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) ++#endif +diff --git a/com32/include/zconf.h b/com32/include/zconf.h +index 02ce56c4..5e1d68a0 100644 +--- a/com32/include/zconf.h ++++ b/com32/include/zconf.h +@@ -1,5 +1,5 @@ + /* zconf.h -- configuration of the zlib compression library +- * Copyright (C) 1995-2010 Jean-loup Gailly. ++ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -15,11 +15,13 @@ + * this permanently in zconf.h using "./configure --zprefix". + */ + #ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ ++# define Z_PREFIX_SET + +-/* all linked symbols */ ++/* all linked symbols and init macros */ + # define _dist_code z__dist_code + # define _length_code z__length_code + # define _tr_align z__tr_align ++# define _tr_flush_bits z__tr_flush_bits + # define _tr_flush_block z__tr_flush_block + # define _tr_init z__tr_init + # define _tr_stored_block z__tr_stored_block +@@ -27,81 +29,111 @@ + # define adler32 z_adler32 + # define adler32_combine z_adler32_combine + # define adler32_combine64 z_adler32_combine64 +-# define compress z_compress +-# define compress2 z_compress2 +-# define compressBound z_compressBound ++# define adler32_z z_adler32_z ++# ifndef Z_SOLO ++# define compress z_compress ++# define compress2 z_compress2 ++# define compressBound z_compressBound ++# endif + # define crc32 z_crc32 + # define crc32_combine z_crc32_combine + # define crc32_combine64 z_crc32_combine64 ++# define crc32_z z_crc32_z + # define deflate z_deflate + # define deflateBound z_deflateBound + # define deflateCopy z_deflateCopy + # define deflateEnd z_deflateEnd ++# define deflateGetDictionary z_deflateGetDictionary ++# define deflateInit z_deflateInit ++# define deflateInit2 z_deflateInit2 + # define deflateInit2_ z_deflateInit2_ + # define deflateInit_ z_deflateInit_ + # define deflateParams z_deflateParams ++# define deflatePending z_deflatePending + # define deflatePrime z_deflatePrime + # define deflateReset z_deflateReset ++# define deflateResetKeep z_deflateResetKeep + # define deflateSetDictionary z_deflateSetDictionary + # define deflateSetHeader z_deflateSetHeader + # define deflateTune z_deflateTune + # define deflate_copyright z_deflate_copyright + # define get_crc_table z_get_crc_table +-# define gz_error z_gz_error +-# define gz_intmax z_gz_intmax +-# define gz_strwinerror z_gz_strwinerror +-# define gzbuffer z_gzbuffer +-# define gzclearerr z_gzclearerr +-# define gzclose z_gzclose +-# define gzclose_r z_gzclose_r +-# define gzclose_w z_gzclose_w +-# define gzdirect z_gzdirect +-# define gzdopen z_gzdopen +-# define gzeof z_gzeof +-# define gzerror z_gzerror +-# define gzflush z_gzflush +-# define gzgetc z_gzgetc +-# define gzgets z_gzgets +-# define gzoffset z_gzoffset +-# define gzoffset64 z_gzoffset64 +-# define gzopen z_gzopen +-# define gzopen64 z_gzopen64 +-# define gzprintf z_gzprintf +-# define gzputc z_gzputc +-# define gzputs z_gzputs +-# define gzread z_gzread +-# define gzrewind z_gzrewind +-# define gzseek z_gzseek +-# define gzseek64 z_gzseek64 +-# define gzsetparams z_gzsetparams +-# define gztell z_gztell +-# define gztell64 z_gztell64 +-# define gzungetc z_gzungetc +-# define gzwrite z_gzwrite ++# ifndef Z_SOLO ++# define gz_error z_gz_error ++# define gz_intmax z_gz_intmax ++# define gz_strwinerror z_gz_strwinerror ++# define gzbuffer z_gzbuffer ++# define gzclearerr z_gzclearerr ++# define gzclose z_gzclose ++# define gzclose_r z_gzclose_r ++# define gzclose_w z_gzclose_w ++# define gzdirect z_gzdirect ++# define gzdopen z_gzdopen ++# define gzeof z_gzeof ++# define gzerror z_gzerror ++# define gzflush z_gzflush ++# define gzfread z_gzfread ++# define gzfwrite z_gzfwrite ++# define gzgetc z_gzgetc ++# define gzgetc_ z_gzgetc_ ++# define gzgets z_gzgets ++# define gzoffset z_gzoffset ++# define gzoffset64 z_gzoffset64 ++# define gzopen z_gzopen ++# define gzopen64 z_gzopen64 ++# ifdef _WIN32 ++# define gzopen_w z_gzopen_w ++# endif ++# define gzprintf z_gzprintf ++# define gzputc z_gzputc ++# define gzputs z_gzputs ++# define gzread z_gzread ++# define gzrewind z_gzrewind ++# define gzseek z_gzseek ++# define gzseek64 z_gzseek64 ++# define gzsetparams z_gzsetparams ++# define gztell z_gztell ++# define gztell64 z_gztell64 ++# define gzungetc z_gzungetc ++# define gzvprintf z_gzvprintf ++# define gzwrite z_gzwrite ++# endif + # define inflate z_inflate + # define inflateBack z_inflateBack + # define inflateBackEnd z_inflateBackEnd ++# define inflateBackInit z_inflateBackInit + # define inflateBackInit_ z_inflateBackInit_ ++# define inflateCodesUsed z_inflateCodesUsed + # define inflateCopy z_inflateCopy + # define inflateEnd z_inflateEnd ++# define inflateGetDictionary z_inflateGetDictionary + # define inflateGetHeader z_inflateGetHeader ++# define inflateInit z_inflateInit ++# define inflateInit2 z_inflateInit2 + # define inflateInit2_ z_inflateInit2_ + # define inflateInit_ z_inflateInit_ + # define inflateMark z_inflateMark + # define inflatePrime z_inflatePrime + # define inflateReset z_inflateReset + # define inflateReset2 z_inflateReset2 ++# define inflateResetKeep z_inflateResetKeep + # define inflateSetDictionary z_inflateSetDictionary + # define inflateSync z_inflateSync + # define inflateSyncPoint z_inflateSyncPoint + # define inflateUndermine z_inflateUndermine ++# define inflateValidate z_inflateValidate + # define inflate_copyright z_inflate_copyright + # define inflate_fast z_inflate_fast + # define inflate_table z_inflate_table +-# define uncompress z_uncompress ++# ifndef Z_SOLO ++# define uncompress z_uncompress ++# define uncompress2 z_uncompress2 ++# endif + # define zError z_zError +-# define zcalloc z_zcalloc +-# define zcfree z_zcfree ++# ifndef Z_SOLO ++# define zcalloc z_zcalloc ++# define zcfree z_zcfree ++# endif + # define zlibCompileFlags z_zlibCompileFlags + # define zlibVersion z_zlibVersion + +@@ -111,7 +143,9 @@ + # define alloc_func z_alloc_func + # define charf z_charf + # define free_func z_free_func +-# define gzFile z_gzFile ++# ifndef Z_SOLO ++# define gzFile z_gzFile ++# endif + # define gz_header z_gz_header + # define gz_headerp z_gz_headerp + # define in_func z_in_func +@@ -197,9 +231,25 @@ + # endif + #endif + +-/* Some Mac compilers merge all .h files incorrectly: */ +-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +-# define NO_DUMMY_DECL ++#if defined(ZLIB_CONST) && !defined(z_const) ++# define z_const const ++#else ++# define z_const ++#endif ++ ++#ifdef Z_SOLO ++ typedef unsigned long z_size_t; ++#else ++# define z_longlong long long ++# if defined(NO_SIZE_T) ++ typedef unsigned NO_SIZE_T z_size_t; ++# elif defined(STDC) ++# include ++ typedef size_t z_size_t; ++# else ++ typedef unsigned long z_size_t; ++# endif ++# undef z_longlong + #endif + + /* Maximum value for memLevel in deflateInit2 */ +@@ -229,7 +279,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 ++ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes + for small objects. + */ + +@@ -243,6 +293,14 @@ + # endif + #endif + ++#ifndef Z_ARG /* function prototypes for stdarg */ ++# if defined(STDC) || defined(Z_HAVE_STDARG_H) ++# define Z_ARG(args) args ++# else ++# define Z_ARG(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 +@@ -356,12 +414,47 @@ typedef uLong FAR uLongf; + typedef Byte *voidp; + #endif + ++#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) ++# include ++# if (UINT_MAX == 0xffffffffUL) ++# define Z_U4 unsigned ++# elif (ULONG_MAX == 0xffffffffUL) ++# define Z_U4 unsigned long ++# elif (USHRT_MAX == 0xffffffffUL) ++# define Z_U4 unsigned short ++# endif ++#endif ++ ++#ifdef Z_U4 ++ typedef Z_U4 z_crc_t; ++#else ++ typedef unsigned long z_crc_t; ++#endif ++ + #ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ + # define Z_HAVE_UNISTD_H + #endif + ++#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ ++# define Z_HAVE_STDARG_H ++#endif ++ + #ifdef STDC +-# include /* for off_t */ ++# ifndef Z_SOLO ++# include /* for off_t */ ++# endif ++#endif ++ ++#if defined(STDC) || defined(Z_HAVE_STDARG_H) ++# ifndef Z_SOLO ++# include /* for va_list */ ++# endif ++#endif ++ ++#ifdef _WIN32 ++# ifndef Z_SOLO ++# include /* for wchar_t */ ++# endif + #endif + + /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and +@@ -370,21 +463,38 @@ typedef uLong FAR uLongf; + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +-#if -_LARGEFILE64_SOURCE - -1 == 1 ++#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 + # undef _LARGEFILE64_SOURCE + #endif + +-#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +-# include /* for SEEK_* and off_t */ +-# ifdef VMS +-# include /* for off_t */ +-# endif +-# ifndef z_off_t +-# define z_off_t off_t ++#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) ++# define Z_HAVE_UNISTD_H ++#endif ++#ifndef Z_SOLO ++# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) ++# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ ++# ifdef VMS ++# include /* for off_t */ ++# endif ++# ifndef z_off_t ++# define z_off_t off_t ++# endif + # endif + #endif + +-#ifndef SEEK_SET ++#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 ++# define Z_LFS64 ++#endif ++ ++#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) ++# define Z_LARGE64 ++#endif ++ ++#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) ++# define Z_WANT64 ++#endif ++ ++#if !defined(SEEK_SET) && !defined(Z_SOLO) + # 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" */ +@@ -394,18 +504,14 @@ typedef uLong FAR uLongf; + # define z_off_t long + #endif + +-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 ++#if !defined(_WIN32) && defined(Z_LARGE64) + # define z_off64_t off64_t + #else +-# define z_off64_t z_off_t +-#endif +- +-#if defined(__OS400__) +-# define NO_vsnprintf +-#endif +- +-#if defined(__MVS__) +-# define NO_vsnprintf ++# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) ++# define z_off64_t __int64 ++# else ++# define z_off64_t z_off_t ++# endif + #endif + + /* MVS linker does not support external names larger than 8 bytes */ +diff --git a/com32/include/zlib.h b/com32/include/zlib.h +index bfbba83e..f09cdaf1 100644 +--- a/com32/include/zlib.h ++++ b/com32/include/zlib.h +@@ -1,7 +1,7 @@ + /* zlib.h -- interface of the 'zlib' general purpose compression library +- version 1.2.5, April 19th, 2010 ++ version 1.2.11, January 15th, 2017 + +- Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler ++ Copyright (C) 1995-2017 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 +@@ -24,8 +24,8 @@ + + + The data format used by the zlib library is described by RFCs (Request for +- Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt +- (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). ++ Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 ++ (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). + */ + + #ifndef ZLIB_H +@@ -37,11 +37,11 @@ + extern "C" { + #endif + +-#define ZLIB_VERSION "1.2.5" +-#define ZLIB_VERNUM 0x1250 ++#define ZLIB_VERSION "1.2.11" ++#define ZLIB_VERNUM 0x12b0 + #define ZLIB_VER_MAJOR 1 + #define ZLIB_VER_MINOR 2 +-#define ZLIB_VER_REVISION 5 ++#define ZLIB_VER_REVISION 11 + #define ZLIB_VER_SUBREVISION 0 + + /* +@@ -65,7 +65,8 @@ extern "C" { + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + +- This library can optionally read and write gzip streams in memory as well. ++ This library can optionally read and write gzip and raw deflate streams in ++ memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- +@@ -74,7 +75,7 @@ extern "C" { + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never crash +- even in case of corrupted input. ++ even in the case of corrupted input. + */ + + typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +@@ -83,23 +84,24 @@ typedef void (*free_func) OF((voidpf opaque, voidpf address)); + struct internal_state; + + typedef struct z_stream_s { +- Bytef *next_in; /* next input byte */ ++ z_const 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 */ ++ uLong total_in; /* total number of input bytes read so far */ + +- Bytef *next_out; /* next output byte should be put there */ ++ Bytef *next_out; /* next output byte will go here */ + uInt avail_out; /* remaining free space at next_out */ +- uLong total_out; /* total nb of bytes output so far */ ++ uLong total_out; /* total number of bytes output so far */ + +- char *msg; /* last error message, NULL if no error */ ++ z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + +- int data_type; /* best guess about the data type: binary or text */ +- uLong adler; /* adler32 value of the uncompressed data */ ++ int data_type; /* best guess about the data type: binary or text ++ for deflate, or the decoding state for inflate */ ++ uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ + } z_stream; + +@@ -142,7 +144,9 @@ typedef gz_header FAR *gz_headerp; + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be +- thread safe. ++ thread safe. In that case, zlib is thread-safe. When zalloc and zfree are ++ Z_NULL on entry to the initialization function, they are set to internal ++ routines that use the standard library functions malloc() and free(). + + 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 +@@ -155,7 +159,7 @@ typedef gz_header FAR *gz_headerp; + + 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 ++ uncompressed data and may be saved for use by the decompressor (particularly + if the decompressor wants to decompress everything in a single step). + */ + +@@ -200,7 +204,7 @@ typedef gz_header FAR *gz_headerp; + #define Z_TEXT 1 + #define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ + #define Z_UNKNOWN 2 +-/* Possible values of the data_type field (though see inflate()) */ ++/* Possible values of the data_type field for deflate() */ + + #define Z_DEFLATED 8 + /* The deflate compression method (the only one supported in this version) */ +@@ -258,11 +262,11 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); + 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 ++ - Generate 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. ++ should be set only when necessary. Some output may be provided even if ++ flush is zero. + + 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 +@@ -271,7 +275,9 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); + 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. ++ buffer because there might be more output pending. See deflatePending(), ++ which can be used if desired to determine whether or not there is more ouput ++ in that case. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to +@@ -292,8 +298,8 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output +- in order for the decompressor to finish the block before the empty fixed code +- block. ++ in order for the decompressor to finish the block before the empty fixed ++ codes block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to +@@ -319,33 +325,38 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); + + 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 the +- value returned by deflateBound (see below). If deflate does not return +- Z_STREAM_END, then it must be called again as described above. +- +- deflate() sets strm->adler to the adler32 checksum of all input read +- so far (that is, total_in bytes). ++ enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, 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 in the first deflate call after deflateInit if all the ++ compression is to be done in a single step. In order to complete in one ++ call, avail_out must be at least the value returned by deflateBound (see ++ below). Then deflate is guaranteed to return Z_STREAM_END. If not enough ++ output space is provided, deflate will not return Z_STREAM_END, and it must ++ be called again as described above. ++ ++ deflate() sets strm->adler to the Adler-32 checksum of all input read ++ so far (that is, total_in bytes). If a gzip stream is being generated, then ++ strm->adler will be the CRC-32 checksum of the input read so far. (See ++ deflateInit2 below.) + + deflate() may update strm->data_type if it can make a good guess about +- the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered +- binary. This field is only for information purposes and does not affect the +- compression algorithm in any manner. ++ the input data type (Z_BINARY or Z_TEXT). If 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 Z_NULL), Z_BUF_ERROR if no progress is possible +- (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not +- fatal, and deflate() can be called again with more input and more output +- space to continue compressing. ++ if next_in or next_out was Z_NULL or the state was inadvertently written over ++ by the application), or Z_BUF_ERROR if no progress is possible (for example ++ avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and ++ deflate() can be called again with more input and more output space to ++ continue compressing. + */ + + +@@ -368,23 +379,21 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by +- the caller. If next_in is not Z_NULL and avail_in is large enough (the +- exact value depends on the compression method), inflateInit determines the +- compression method from the zlib header and allocates all data structures +- accordingly; otherwise the allocation will be deferred to the first call of +- inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to +- use default allocation functions. ++ the caller. In the current version of inflate, the provided input is not ++ read or consumed. The allocation of a sliding window will be deferred to ++ the first call of inflate (if the decompression does not complete on the ++ first call). 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, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if +- there is no error message. inflateInit does not perform any decompression +- apart from possibly reading the zlib header if present: actual decompression +- will be done by inflate(). (So next_in and avail_in may be modified, but +- next_out and avail_out are unused and unchanged.) The current implementation +- of inflateInit() does not process any header information -- that is deferred +- until inflate() is called. ++ there is no error message. inflateInit does not perform any decompression. ++ Actual decompression will be done by inflate(). So next_in, and avail_in, ++ next_out, and avail_out are unused and unchanged. The current ++ implementation of inflateInit() does not process any header information -- ++ that is deferred until inflate() is called. + */ + + +@@ -400,17 +409,20 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); + + - 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(). ++ enough room in the output buffer), then next_in and avail_in are updated ++ accordingly, 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 ++ - Generate 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 ++ output, and updating the next_* and avail_* values accordingly. If the ++ caller of inflate() does not provide both available input and available ++ output space, it is possible that there will be no progress made. 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 +@@ -427,7 +439,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); + gets to the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. +- Also to assist in this, on return inflate() will set strm->data_type to the ++ To assist in this, on return inflate() always sets strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 if + inflate() is currently decoding the last block in the deflate stream, plus + 128 if inflate() returned immediately after decoding an end-of-block code or +@@ -451,48 +463,57 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); + 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 approach may be used for the single +- inflate() call. ++ avail_out must be large enough to hold all of the uncompressed data for the ++ operation to complete. (The size of the uncompressed data may have been ++ saved by the compressor for this purpose.) The use of Z_FINISH is not ++ required to perform an inflation in one step. However it may be used to ++ inform inflate that a faster approach can be used for the single inflate() ++ call. Z_FINISH also informs inflate to not maintain a sliding window if the ++ stream completes, which reduces inflate's memory footprint. If the stream ++ does not complete, either because not all of the stream is provided or not ++ enough output space is provided, then a sliding window will be allocated and ++ inflate() can be called again to continue the operation as if Z_NO_FLUSH had ++ been used. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the +- first call. So the only effect of the flush parameter in this implementation +- is on the return value of inflate(), as noted below, or when it returns early +- because Z_BLOCK or Z_TREES is used. ++ first call. So the effects of the flush parameter in this implementation are ++ on the return value of inflate() as noted below, when inflate() returns early ++ when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of ++ memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary +- below), inflate sets strm->adler to the adler32 checksum of the dictionary ++ below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets +- strm->adler to the adler32 checksum of all output produced so far (that is, ++ strm->adler to the Adler-32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described +- below. At the end of the stream, inflate() checks that its computed adler32 ++ below. At the end of the stream, inflate() checks that its computed Adler-32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). Any information contained in the gzip +- header is not retained, so applications that need that information should +- instead use raw inflate, see inflateInit2() below, or inflateBack() and +- perform their own processing of the gzip header and trailer. ++ header is not retained unless inflateGetHeader() is used. When processing ++ gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output ++ produced so far. The CRC-32 is checked against the gzip trailer, as is the ++ uncompressed length, modulo 2^32. + + 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, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check +- value), Z_STREAM_ERROR if the stream structure was inconsistent (for example +- next_in or next_out was Z_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. Note that Z_BUF_ERROR is not fatal, and ++ value, in which case strm->msg points to a string with a more specific ++ error), Z_STREAM_ERROR if the stream structure was inconsistent (for example ++ next_in or next_out was Z_NULL, or the state was inadvertently written over ++ by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR ++ if no progress was possible or if there was not enough room in the output ++ buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may + then call inflateSync() to look for a good compression block if a partial +- recovery of the data is desired. ++ recovery of the data is to be attempted. + */ + + +@@ -502,9 +523,8 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); + 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). ++ inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state ++ was inconsistent. + */ + + +@@ -535,16 +555,29 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + ++ For the current implementation of deflate(), a windowBits value of 8 (a ++ window size of 256 bytes) is not supported. As a result, a request for 8 ++ will result in 9 (a 512-byte window). In that case, providing 8 to ++ inflateInit2() will result in an error when the zlib header with 9 is ++ checked against the initialization of inflate(). The remedy is to not use 8 ++ with deflateInit2() with this initialization, or at least in that case use 9 ++ with inflateInit2(). ++ + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data +- with no zlib header or trailer, and will not compute an adler32 check value. ++ with no zlib header or trailer, and will not compute a check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), no +- header crc, and the operating system will be set to 255 (unknown). If a +- gzip stream is being written, strm->adler is a crc32 instead of an adler32. ++ header crc, and the operating system will be set to the appropriate value, ++ if the operating system was determined at compile time. If a gzip stream is ++ being written, strm->adler is a CRC-32 instead of an Adler-32. ++ ++ For raw deflate or gzip encoding, a request for a 256-byte window is ++ rejected as invalid, since only the zlib header provides a means of ++ transmitting the window size to the decompressor. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but is +@@ -580,10 +613,15 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + uInt dictLength)); + /* + Initializes the compression dictionary from the given byte sequence +- without producing any compressed output. This function must be called +- immediately after deflateInit, deflateInit2 or deflateReset, before any call +- of deflate. The compressor and decompressor must use exactly the same +- dictionary (see inflateSetDictionary). ++ without producing any compressed output. When using the zlib format, this ++ function must be called immediately after deflateInit, deflateInit2 or ++ deflateReset, and before any call of deflate. When doing raw deflate, this ++ function must be called either before any call of deflate, or immediately ++ after the completion of a deflate block, i.e. after all input has been ++ consumed and all output has been delivered when using any of the flush ++ options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. 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 +@@ -600,18 +638,40 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + +- Upon return of this function, strm->adler is set to the adler32 value ++ Upon return of this function, strm->adler is set to the Adler-32 value + of the dictionary; the decompressor may later use this value to determine +- which dictionary has been used by the compressor. (The adler32 value ++ which dictionary has been used by the compressor. (The Adler-32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the +- adler32 value is not computed and strm->adler is not set. ++ Adler-32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream +- or if the compression method is bsort). deflateSetDictionary does not +- perform any compression: this will be done by deflate(). ++ or if not at a block boundary for raw deflate). deflateSetDictionary does ++ not perform any compression: this will be done by deflate(). ++*/ ++ ++ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, ++ Bytef *dictionary, ++ uInt *dictLength)); ++/* ++ Returns the sliding dictionary being maintained by deflate. dictLength is ++ set to the number of bytes in the dictionary, and that many bytes are copied ++ to dictionary. dictionary must have enough space, where 32768 bytes is ++ always enough. If deflateGetDictionary() is called with dictionary equal to ++ Z_NULL, then only the dictionary length is returned, and nothing is copied. ++ Similary, if dictLength is Z_NULL, then it is not set. ++ ++ deflateGetDictionary() may return a length less than the window size, even ++ when more than the window size in input has been provided. It may return up ++ to 258 bytes less in that case, due to how zlib's implementation of deflate ++ manages the sliding window and lookahead for matches, where matches can be ++ up to 258 bytes long. If the application needs the last window-size bytes of ++ input, then that would need to be saved by the application outside of zlib. ++ ++ deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the ++ stream state is inconsistent. + */ + + ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, +@@ -634,10 +694,10 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + + 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. ++ This function is equivalent to deflateEnd followed by deflateInit, but ++ does not free and reallocate the internal compression state. The stream ++ will leave the compression level and any other attributes that may have been ++ set unchanged. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +@@ -648,20 +708,36 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int strategy)); + /* + Dynamically update the compression level and compression strategy. The +- interpretation of level and strategy is as in deflateInit2. This can be ++ interpretation of level and strategy is as in deflateInit2(). 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. ++ If the compression approach (which is a function of the level) or the ++ strategy is changed, and if any input has been consumed in a previous ++ deflate() call, then the input available so far is compressed with the old ++ level and strategy using deflate(strm, Z_BLOCK). There are three approaches ++ for the compression levels 0, 1..3, and 4..9 respectively. The new level ++ and strategy will take effect at the next call of deflate(). ++ ++ If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does ++ not have enough output space to complete, then the parameter change will not ++ take effect. In this case, deflateParams() can be called again with the ++ same parameters and more output space to try again. ++ ++ In order to assure a change in the parameters on the first try, the ++ deflate stream should be flushed using deflate() with Z_BLOCK or other flush ++ request until strm.avail_out is not zero, before calling deflateParams(). ++ Then no more input data should be provided before the deflateParams() call. ++ If this is done, the old level and strategy will be applied to the data ++ compressed before deflateParams(), and the new level and strategy will be ++ applied to the the data compressed after deflateParams(). ++ ++ deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream ++ state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if ++ there was not enough output space to complete the compression of the ++ available input data before a change in the strategy or approach. Note that ++ in the case of a Z_BUF_ERROR, the parameters are not changed. A return ++ value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be ++ retried with more output space. + */ + + ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, +@@ -688,8 +764,28 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be +- called before deflate(). +-*/ ++ called before deflate(). If that first deflate() call is provided the ++ sourceLen input bytes, an output buffer allocated to the size returned by ++ deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed ++ to return Z_STREAM_END. Note that it is possible for the compressed size to ++ be larger than the value returned by deflateBound() if flush options other ++ than Z_FINISH or Z_NO_FLUSH are used. ++*/ ++ ++ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, ++ unsigned *pending, ++ int *bits)); ++/* ++ deflatePending() returns the number of bytes and bits of output that have ++ been generated, but not yet provided in the available output. The bytes not ++ provided would be due to the available output space having being consumed. ++ The number of bits of output not provided are between 0 and 7, where they ++ await more bits to join them in order to fill out a full byte. If pending ++ or bits are Z_NULL, then those values are not set. ++ ++ deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source ++ stream state was inconsistent. ++ */ + + ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, +@@ -703,8 +799,9 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + than or equal to 16, and that many of the least significant bits of value + will be inserted in the output. + +- deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent. ++ deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough ++ room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the ++ source stream state was inconsistent. + */ + + ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, +@@ -758,7 +855,7 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is +- recommended that a check value such as an adler32 or a crc32 be applied to ++ recommended that a check value such as an Adler-32 or a CRC-32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. +@@ -767,7 +864,10 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a +- crc32 instead of an adler32. ++ CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see ++ below), inflate() will not automatically decode concatenated gzip streams. ++ inflate() will return Z_STREAM_END at the end of the gzip stream. The state ++ would need to be reset to continue decoding a subsequent gzip stream. + + inflateInit2 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 +@@ -788,34 +888,54 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor +- can be determined from the adler32 value returned by that call of inflate. ++ can be determined from the Adler-32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see +- deflateSetDictionary). For raw inflate, this function can be called +- immediately after inflateInit2() or inflateReset() and before any call of +- inflate() to set the dictionary. The application must insure that the +- dictionary that was used for compression is provided. ++ deflateSetDictionary). For raw inflate, this function can be called at any ++ time to set the dictionary. If the provided dictionary is smaller than the ++ window and there is already data in the window, then the provided dictionary ++ will amend what's there. The application must insure that the dictionary ++ that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) 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 ++ expected one (incorrect Adler-32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). + */ + ++ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, ++ Bytef *dictionary, ++ uInt *dictLength)); ++/* ++ Returns the sliding dictionary being maintained by inflate. dictLength is ++ set to the number of bytes in the dictionary, and that many bytes are copied ++ to dictionary. dictionary must have enough space, where 32768 bytes is ++ always enough. If inflateGetDictionary() is called with dictionary equal to ++ Z_NULL, then only the dictionary length is returned, and nothing is copied. ++ Similary, if dictLength is Z_NULL, then it is not set. ++ ++ inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the ++ stream state is inconsistent. ++*/ ++ + ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); + /* +- Skips invalid compressed data until a full flush point (see above the +- description of deflate with Z_FULL_FLUSH) can be found, or until all ++ Skips invalid compressed data until a possible full flush point (see above ++ for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + +- inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR +- if no more input was provided, Z_DATA_ERROR if no flush point 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. ++ inflateSync searches for a 00 00 FF FF pattern in the compressed data. ++ All full flush points have this pattern, but not all occurrences of this ++ pattern are full flush points. ++ ++ inflateSync returns Z_OK if a possible full flush point has been found, ++ Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point ++ 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 inflateCopy OF((z_streamp dest, +@@ -837,7 +957,7 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + 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 ++ but does not free and reallocate 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 +@@ -849,7 +969,9 @@ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + /* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted +- the same as it is for inflateInit2. ++ the same as it is for inflateInit2. If the window size is changed, then the ++ memory allocated for the window is freed, and the window will be reallocated ++ by inflate() if needed. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if +@@ -901,7 +1023,7 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + +- inflateMark returns the value noted above or -1 << 16 if the provided ++ inflateMark returns the value noted above, or -65536 if the provided + source stream state was inconsistent. + */ + +@@ -962,12 +1084,13 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of +- the paramaters are invalid, Z_MEM_ERROR if the internal state could not be ++ the parameters are invalid, Z_MEM_ERROR if the internal state could not be + allocated, or Z_VERSION_ERROR if the version of the library does not match + the version of the header file. + */ + +-typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); ++typedef unsigned (*in_func) OF((void FAR *, ++ z_const unsigned char FAR * FAR *)); + typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + + ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, +@@ -975,11 +1098,12 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + out_func out, void FAR *out_desc)); + /* + inflateBack() does a raw inflate with a single call using a call-back +- interface for input and output. This is more efficient than inflate() for +- file i/o applications in that it avoids copying between the output and the +- sliding window by simply making the window itself the output buffer. This +- function trusts the application to not change the output buffer passed by +- the output function, at least until inflateBack() returns. ++ interface for input and output. This is potentially more efficient than ++ inflate() for file i/o applications, in that it avoids copying between the ++ output and the sliding window by simply making the window itself the output ++ buffer. inflate() can be faster on modern CPUs when used with large ++ buffers. inflateBack() trusts the application to not change the output ++ buffer passed by the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. +@@ -991,9 +1115,9 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects only +- the raw deflate stream to decompress. This is different from the normal +- behavior of inflate(), which expects either a zlib or gzip header and +- trailer around the deflate stream. ++ the raw deflate stream to decompress. This is different from the default ++ behavior of inflate(), which expects a zlib header and trailer around the ++ deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those +@@ -1002,12 +1126,12 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If +- there is no input available, in() must return zero--buf is ignored in that +- case--and inflateBack() will return a buffer error. inflateBack() will call +- out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() +- should return zero on success, or non-zero on failure. If out() returns +- non-zero, inflateBack() will return with an error. Neither in() nor out() +- are permitted to change the contents of the window provided to ++ there is no input available, in() must return zero -- buf is ignored in that ++ case -- and inflateBack() will return a buffer error. inflateBack() will ++ call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. ++ out() should return zero on success, or non-zero on failure. If out() ++ returns non-zero, inflateBack() will return with an error. Neither in() nor ++ out() are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). +@@ -1035,7 +1159,7 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + using strm->next_in which will be Z_NULL only if in() returned an error. If + strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning + non-zero. (in() will always be called before out(), so strm->next_in is +- assured to be defined if out() returns non-zero.) Note that inflateBack() ++ assured to be defined if out() returns non-zero.) Note that inflateBack() + cannot return Z_OK. + */ + +@@ -1057,7 +1181,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); + 7.6: size of z_off_t + + Compiler, assembler, and debug options: +- 8: DEBUG ++ 8: ZLIB_DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) +@@ -1088,6 +1212,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); + 27-31: 0 (reserved) + */ + ++#ifndef Z_SOLO + + /* utility functions */ + +@@ -1106,7 +1231,8 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the +- compressed buffer. ++ compressed data. compress() is equivalent to compress2() with a level ++ parameter of Z_DEFAULT_COMPRESSION. + + 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 +@@ -1122,7 +1248,7 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the +- compressed buffer. ++ compressed data. + + compress2 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, +@@ -1145,13 +1271,22 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + 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 uncompressed buffer. ++ is the actual size of the uncompressed data. + + 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 or incomplete. ++ buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In ++ the case where there is not enough room, uncompress() will fill the output ++ buffer with the uncompressed data up to that point. + */ + ++ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, ++ const Bytef *source, uLong *sourceLen)); ++/* ++ Same as uncompress, except that sourceLen is a pointer, where the ++ length of the source is *sourceLen. On return, *sourceLen is the number of ++ source bytes consumed. ++*/ + + /* gzip file access functions */ + +@@ -1162,7 +1297,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + wrapper, documented in RFC 1952, wrapped around a deflate stream. + */ + +-typedef voidp gzFile; /* opaque gzip file descriptor */ ++typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + + /* + ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +@@ -1172,13 +1307,28 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); + a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only + compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of +- deflateInit2 for more information about the strategy parameter.) Also "a" +- can be used instead of "w" to request that the gzip stream that will be +- written be appended to the file. "+" will result in an error, since reading +- and writing to the same gzip file is not supported. ++ deflateInit2 for more information about the strategy parameter.) 'T' will ++ request transparent writing or appending with no compression and not using ++ the gzip format. ++ ++ "a" can be used instead of "w" to request that the gzip stream that will ++ be written be appended to the file. "+" will result in an error, since ++ reading and writing to the same gzip file is not supported. The addition of ++ "x" when writing will create the file exclusively, which fails if the file ++ already exists. On systems that support it, the addition of "e" when ++ reading or writing will set the flag to close the file on an execve() call. ++ ++ These functions, as well as gzip, will read and decode a sequence of gzip ++ streams in a file. The append function of gzopen() can be used to create ++ such a file. (Also see gzflush() for another way to do this.) When ++ appending, gzopen does not test whether the file begins with a gzip stream, ++ nor does it look for the end of the gzip streams to begin appending. gzopen ++ will simply append a gzip stream to the existing file. + + 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. ++ case gzread will directly read from the file without decompression. When ++ reading, this will be detected automatically by looking for the magic two- ++ byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was +@@ -1197,7 +1347,11 @@ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); + descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor + fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since +- gzdopen does not close fd if it fails. ++ gzdopen does not close fd if it fails. If you are using fileno() to get the ++ file descriptor from a FILE *, then you will have to use dup() to avoid ++ double-close()ing the file descriptor. Both gzclose() and fclose() will ++ close the associated file descriptor, so they need to have different file ++ descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not +@@ -1212,10 +1366,9 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or +- write. Two buffers are allocated, either both of the specified size when +- writing, or one of the specified size and the other twice that size when +- reading. A larger buffer size of, for example, 64K or 128K bytes will +- noticeably increase the speed of decompression (reading). ++ write. Three times that size in buffer space is allocated. A larger buffer ++ size of, for example, 64K or 128K bytes will noticeably increase the speed ++ of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + +@@ -1226,26 +1379,68 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); + ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); + /* + Dynamically update the compression level or strategy. See the description +- of deflateInit2 for the meaning of these parameters. ++ of deflateInit2 for the meaning of these parameters. Previously provided ++ data is flushed before the parameter change. + +- gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not +- opened for writing. ++ gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not ++ opened for writing, Z_ERRNO if there is an error writing the flushed data, ++ or Z_MEM_ERROR if there is a memory allocation error. + */ + + 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. ++ the input file is not in gzip format, gzread copies the given number of ++ bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue +- to read, looking for another gzip stream, or failing that, reading the rest +- of the input file directly without decompression. The entire input file +- will be read if gzread is called until it returns less than the requested +- len. ++ to read, looking for another gzip stream. Any number of gzip streams may be ++ concatenated in the input file, and will all be decompressed by gzread(). ++ If something other than a gzip stream is encountered after a gzip stream, ++ that remaining trailing garbage is ignored (and no error is returned). ++ ++ gzread can be used to read a gzip file that is being concurrently written. ++ Upon reaching the end of the input, gzread will return with the available ++ data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then ++ gzclearerr can be used to clear the end of file indicator in order to permit ++ gzread to be tried again. Z_OK indicates that a gzip stream was completed ++ on the last gzread. Z_BUF_ERROR indicates that the input file ended in the ++ middle of a gzip stream. Note that gzread does not return -1 in the event ++ of an incomplete gzip stream. This error is deferred until gzclose(), which ++ will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip ++ stream. Alternatively, gzerror can be used before gzclose to detect this ++ case. + + gzread returns the number of uncompressed bytes actually read, less than +- len for end of file, or -1 for error. ++ len for end of file, or -1 for error. If len is too large to fit in an int, ++ then nothing is read, -1 is returned, and the error state is set to ++ Z_STREAM_ERROR. ++*/ ++ ++ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, ++ gzFile file)); ++/* ++ Read up to nitems items of size size from file to buf, otherwise operating ++ as gzread() does. This duplicates the interface of stdio's fread(), with ++ size_t request and return types. If the library defines size_t, then ++ z_size_t is identical to size_t. If not, then z_size_t is an unsigned ++ integer type that can contain a pointer. ++ ++ gzfread() returns the number of full items read of size size, or zero if ++ the end of the file was reached and a full item could not be read, or if ++ there was an error. gzerror() must be consulted if zero is returned in ++ order to determine if there was an error. If the multiplication of size and ++ nitems overflows, i.e. the product does not fit in a z_size_t, then nothing ++ is read, zero is returned, and the error state is set to Z_STREAM_ERROR. ++ ++ In the event that the end of file is reached and only a partial item is ++ available at the end, i.e. the remaining uncompressed data length is not a ++ multiple of size, then the final partial item is nevetheless read into buf ++ and the end-of-file flag is set. The length of the partial item read is not ++ provided, but could be inferred from the result of gztell(). This behavior ++ is the same as the behavior of fread() implementations in common libraries, ++ but it prevents the direct use of gzfread() to read a concurrently written ++ file, reseting and retrying on end-of-file, when size is not 1. + */ + + ZEXTERN int ZEXPORT gzwrite OF((gzFile file, +@@ -1256,19 +1451,33 @@ ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + error. + */ + +-ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); ++ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, ++ z_size_t nitems, gzFile file)); ++/* ++ gzfwrite() writes nitems items of size size from buf to file, duplicating ++ the interface of stdio's fwrite(), with size_t request and return types. If ++ the library defines size_t, then z_size_t is identical to size_t. If not, ++ then z_size_t is an unsigned integer type that can contain a pointer. ++ ++ gzfwrite() returns the number of full items written of size size, or zero ++ if there was an error. If the multiplication of size and nitems overflows, ++ i.e. the product does not fit in a z_size_t, then nothing is written, zero ++ is returned, and the error state is set to Z_STREAM_ERROR. ++*/ ++ ++ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); + /* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of +- uncompressed bytes actually written, or 0 in case of error. The number of +- uncompressed bytes written is limited to 8191, or one less than the buffer +- size given to gzbuffer(). The caller should assure that this limit is not +- exceeded. If it is exceeded, then gzprintf() will return an error (0) with +- nothing written. In this case, there may also be a buffer overflow with +- unpredictable consequences, which is possible only if zlib was compiled with +- the insecure functions sprintf() or vsprintf() because the secure snprintf() +- or vsnprintf() functions were not available. This can be determined using +- zlibCompileFlags(). ++ uncompressed bytes actually written, or a negative zlib error code in case ++ of error. The number of uncompressed bytes written is limited to 8191, or ++ one less than the buffer size given to gzbuffer(). The caller should assure ++ that this limit is not exceeded. If it is exceeded, then gzprintf() will ++ return an error (0) with nothing written. In this case, there may also be a ++ buffer overflow with unpredictable consequences, which is possible only if ++ zlib was compiled with the insecure functions sprintf() or vsprintf() ++ because the secure snprintf() or vsnprintf() functions were not available. ++ This can be determined using zlibCompileFlags(). + */ + + ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +@@ -1301,7 +1510,10 @@ ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); + ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); + /* + Reads one byte from the compressed file. gzgetc returns this byte or -1 +- in case of end of file or error. ++ in case of end of file or error. This is implemented as a macro for speed. ++ As such, it does not do all of the checking the other functions do. I.e. ++ it does not check to see if file is NULL, nor whether the structure file ++ points to has been clobbered or not. + */ + + ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +@@ -1325,7 +1537,7 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such +- concatented gzip streams. ++ concatenated gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +@@ -1397,9 +1609,7 @@ ZEXTERN int ZEXPORT gzeof OF((gzFile file)); + ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); + /* + Returns true (1) if file is being copied directly while reading, or false +- (0) if file is a gzip stream being decompressed. This state can change from +- false to true while reading the input file if the end of a gzip stream is +- reached, but is followed by data that is not another gzip stream. ++ (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. +@@ -1408,6 +1618,13 @@ ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). ++ ++ When writing, gzdirect() returns true (1) if transparent writing was ++ requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: ++ gzdirect() is not needed when writing. Transparent writing must be ++ explicitly requested, so the application already knows the answer. When ++ linking statically, using gzdirect() will include all of the zlib code for ++ gzip file reading and decompression, which may not be desired.) + */ + + ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +@@ -1419,7 +1636,8 @@ ZEXTERN int ZEXPORT gzclose OF((gzFile file)); + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a +- file operation error, or Z_OK on success. ++ file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the ++ last read ended in the middle of a gzip stream, or Z_OK on success. + */ + + ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +@@ -1457,6 +1675,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); + file that is being written concurrently. + */ + ++#endif /* !Z_SOLO */ + + /* checksum functions */ + +@@ -1472,7 +1691,7 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + return the updated checksum. If buf is Z_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 ++ An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed + much faster. + + Usage example: +@@ -1485,6 +1704,12 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + if (adler != original_adler) error(); + */ + ++ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, ++ z_size_t len)); ++/* ++ Same as adler32(), but with a size_t length. ++*/ ++ + /* + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); +@@ -1492,16 +1717,17 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of +- seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. ++ seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note ++ that the z_off_t type (like off_t) is a signed integer. If len2 is ++ negative, the result has no meaning or utility. + */ + + ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); + /* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_NULL, this function returns the required +- initial value for the for the crc. Pre- and post-conditioning (one's +- complement) is performed within this function so it shouldn't be done by the +- application. ++ 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: + +@@ -1513,6 +1739,12 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); + if (crc != original_crc) error(); + */ + ++ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf, ++ z_size_t len)); ++/* ++ Same as crc32(), but with a size_t length. ++*/ ++ + /* + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + +@@ -1543,18 +1775,59 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + 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)) +-#define inflateBackInit(strm, windowBits, window) \ +- inflateBackInit_((strm), (windowBits), (window), \ +- ZLIB_VERSION, sizeof(z_stream)) ++#ifdef Z_PREFIX_SET ++# define z_deflateInit(strm, level) \ ++ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) ++# define z_inflateInit(strm) \ ++ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) ++# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ ++ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ ++ (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) ++# define z_inflateInit2(strm, windowBits) \ ++ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ ++ (int)sizeof(z_stream)) ++# define z_inflateBackInit(strm, windowBits, window) \ ++ inflateBackInit_((strm), (windowBits), (window), \ ++ ZLIB_VERSION, (int)sizeof(z_stream)) ++#else ++# define deflateInit(strm, level) \ ++ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) ++# define inflateInit(strm) \ ++ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) ++# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ ++ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ ++ (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) ++# define inflateInit2(strm, windowBits) \ ++ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ ++ (int)sizeof(z_stream)) ++# define inflateBackInit(strm, windowBits, window) \ ++ inflateBackInit_((strm), (windowBits), (window), \ ++ ZLIB_VERSION, (int)sizeof(z_stream)) ++#endif ++ ++#ifndef Z_SOLO ++ ++/* gzgetc() macro and its supporting function and exposed data structure. Note ++ * that the real internal state is much larger than the exposed structure. ++ * This abbreviated structure exposes just enough for the gzgetc() macro. The ++ * user should not mess with these exposed elements, since their names or ++ * behavior could change in the future, perhaps even capriciously. They can ++ * only be used by the gzgetc() macro. You have been warned. ++ */ ++struct gzFile_s { ++ unsigned have; ++ unsigned char *next; ++ z_off64_t pos; ++}; ++ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ ++#ifdef Z_PREFIX_SET ++# undef z_gzgetc ++# define z_gzgetc(g) \ ++ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) ++#else ++# define gzgetc(g) \ ++ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) ++#endif + + /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or + * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if +@@ -1562,7 +1835,7 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + * functions are changed to 64 bits) -- in case these are set on systems + * without large file support, _LFS64_LARGEFILE must also be true + */ +-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 ++#ifdef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); +@@ -1571,14 +1844,23 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); + #endif + +-#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0 +-# define gzopen gzopen64 +-# define gzseek gzseek64 +-# define gztell gztell64 +-# define gzoffset gzoffset64 +-# define adler32_combine adler32_combine64 +-# define crc32_combine crc32_combine64 +-# ifdef _LARGEFILE64_SOURCE ++#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) ++# ifdef Z_PREFIX_SET ++# define z_gzopen z_gzopen64 ++# define z_gzseek z_gzseek64 ++# define z_gztell z_gztell64 ++# define z_gzoffset z_gzoffset64 ++# define z_adler32_combine z_adler32_combine64 ++# define z_crc32_combine z_crc32_combine64 ++# else ++# define gzopen gzopen64 ++# define gzseek gzseek64 ++# define gztell gztell64 ++# define gzoffset gzoffset64 ++# define adler32_combine adler32_combine64 ++# define crc32_combine crc32_combine64 ++# endif ++# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); +@@ -1595,16 +1877,33 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); + #endif + +-/* hack for buggy compilers */ +-#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) +- struct internal_state {int dummy;}; +-#endif ++#else /* Z_SOLO */ ++ ++ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); ++ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); ++ ++#endif /* !Z_SOLO */ + + /* undocumented functions */ + ZEXTERN const char * ZEXPORT zError OF((int)); + ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +-ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); ++ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); + ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); ++ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int)); ++ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp)); ++ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); ++ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); ++#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO) ++ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, ++ const char *mode)); ++#endif ++#if defined(STDC) || defined(Z_HAVE_STDARG_H) ++# ifndef Z_SOLO ++ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, ++ const char *format, ++ va_list va)); ++# endif ++#endif + + #ifdef __cplusplus + } +diff --git a/com32/lib/zlib/FAQ b/com32/lib/zlib/FAQ +index 1a22750a..99b7cf92 100644 +--- a/com32/lib/zlib/FAQ ++++ b/com32/lib/zlib/FAQ +@@ -44,8 +44,8 @@ The lastest zlib FAQ is at http://zlib.net/zlib_faq.html + + 6. Where's the zlib documentation (man pages, etc.)? + +- It's in zlib.h . Examples of zlib usage are in the files example.c and +- minigzip.c, with more in examples/ . ++ It's in zlib.h . Examples of zlib usage are in the files test/example.c ++ and test/minigzip.c, with more in examples/ . + + 7. Why don't you use GNU autoconf or libtool or ...? + +@@ -84,8 +84,10 @@ The lastest zlib FAQ is at http://zlib.net/zlib_faq.html + + 13. How can I make a Unix shared library? + +- make clean +- ./configure -s ++ By default a shared (and a static) library is built for Unix. So: ++ ++ make distclean ++ ./configure + make + + 14. How do I install a shared zlib library on Unix? +@@ -325,7 +327,7 @@ The lastest zlib FAQ is at http://zlib.net/zlib_faq.html + correctly points to the zlib specification in RFC 1950 for the "deflate" + transfer encoding, there have been reports of servers and browsers that + incorrectly produce or expect raw deflate data per the deflate +- specficiation in RFC 1951, most notably Microsoft. So even though the ++ specification in RFC 1951, most notably Microsoft. So even though the + "deflate" transfer encoding using the zlib format would be the more + efficient approach (and in fact exactly what the zlib format was designed + for), using the "gzip" transfer encoding is probably more reliable due to +diff --git a/com32/lib/zlib/README b/com32/lib/zlib/README +index d4219bf8..51106de4 100644 +--- a/com32/lib/zlib/README ++++ b/com32/lib/zlib/README +@@ -1,22 +1,22 @@ + ZLIB DATA COMPRESSION LIBRARY + +-zlib 1.2.5 is a general purpose data compression library. All the code is ++zlib 1.2.11 is a general purpose data compression library. All the code is + thread safe. The data format used by the zlib library is described by RFCs + (Request for Comments) 1950 to 1952 in the files +-http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format) +-and rfc1952.txt (gzip format). ++http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and ++rfc1952 (gzip format). + + All functions of the compression library are documented in the file zlib.h + (volunteer to write man pages welcome, contact zlib@gzip.org). A usage example +-of the library is given in the file example.c which also tests that the library +-is working correctly. Another example is given in the file minigzip.c. The +-compression library itself is composed of all source files except example.c and +-minigzip.c. ++of the library is given in the file test/example.c which also tests that ++the library is working correctly. Another example is given in the file ++test/minigzip.c. The compression library itself is composed of all source ++files in the root directory. + + To compile all files and run the test program, follow the instructions given at + the top of Makefile.in. In short "./configure; make test", and if that goes +-well, "make install" should work for most flavors of Unix. For Windows, use one +-of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use ++well, "make install" should work for most flavors of Unix. For Windows, use ++one of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use + make_vms.com. + + Questions about zlib should be sent to , or to Gilles Vollant +@@ -31,7 +31,7 @@ Mark Nelson wrote an article about zlib for the Jan. 1997 + issue of Dr. Dobb's Journal; a copy of the article is available at + http://marknelson.us/1997/01/01/zlib-engine/ . + +-The changes made in version 1.2.5 are documented in the file ChangeLog. ++The changes made in version 1.2.11 are documented in the file ChangeLog. + + Unsupported third party contributions are provided in directory contrib/ . + +@@ -44,7 +44,7 @@ http://search.cpan.org/~pmqs/IO-Compress-Zlib/ . + + A Python interface to zlib written by A.M. Kuchling is + available in Python 1.5 and later versions, see +-http://www.python.org/doc/lib/module-zlib.html . ++http://docs.python.org/library/zlib.html . + + zlib is built into tcl: http://wiki.tcl.tk/4610 . + +@@ -84,7 +84,7 @@ Acknowledgments: + + Copyright notice: + +- (C) 1995-2010 Jean-loup Gailly and Mark Adler ++ (C) 1995-2017 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 +diff --git a/com32/lib/zlib/adler32.c b/com32/lib/zlib/adler32.c +index 65ad6a5a..d0be4380 100644 +--- a/com32/lib/zlib/adler32.c ++++ b/com32/lib/zlib/adler32.c +@@ -1,5 +1,5 @@ + /* adler32.c -- compute the Adler-32 checksum of a data stream +- * Copyright (C) 1995-2007 Mark Adler ++ * Copyright (C) 1995-2011, 2016 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -7,11 +7,9 @@ + + #include "zutil.h" + +-#define local static ++local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); + +-local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); +- +-#define BASE 65521UL /* largest prime smaller than 65536 */ ++#define BASE 65521U /* largest prime smaller than 65536 */ + #define NMAX 5552 + /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ + +@@ -21,46 +19,51 @@ local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); + #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); + #define DO16(buf) DO8(buf,0); DO8(buf,8); + +-/* use NO_DIVIDE if your processor does not do division in hardware */ ++/* use NO_DIVIDE if your processor does not do division in hardware -- ++ try it both ways to see which is faster */ + #ifdef NO_DIVIDE +-# define MOD(a) \ ++/* note that this assumes BASE is 65521, where 65536 % 65521 == 15 ++ (thank you to John Reiser for pointing this out) */ ++# define CHOP(a) \ + do { \ +- if (a >= (BASE << 16)) a -= (BASE << 16); \ +- if (a >= (BASE << 15)) a -= (BASE << 15); \ +- if (a >= (BASE << 14)) a -= (BASE << 14); \ +- if (a >= (BASE << 13)) a -= (BASE << 13); \ +- if (a >= (BASE << 12)) a -= (BASE << 12); \ +- if (a >= (BASE << 11)) a -= (BASE << 11); \ +- if (a >= (BASE << 10)) a -= (BASE << 10); \ +- if (a >= (BASE << 9)) a -= (BASE << 9); \ +- if (a >= (BASE << 8)) a -= (BASE << 8); \ +- if (a >= (BASE << 7)) a -= (BASE << 7); \ +- if (a >= (BASE << 6)) a -= (BASE << 6); \ +- if (a >= (BASE << 5)) a -= (BASE << 5); \ +- if (a >= (BASE << 4)) a -= (BASE << 4); \ +- if (a >= (BASE << 3)) a -= (BASE << 3); \ +- if (a >= (BASE << 2)) a -= (BASE << 2); \ +- if (a >= (BASE << 1)) a -= (BASE << 1); \ ++ unsigned long tmp = a >> 16; \ ++ a &= 0xffffUL; \ ++ a += (tmp << 4) - tmp; \ ++ } while (0) ++# define MOD28(a) \ ++ do { \ ++ CHOP(a); \ + if (a >= BASE) a -= BASE; \ + } while (0) +-# define MOD4(a) \ ++# define MOD(a) \ + do { \ +- if (a >= (BASE << 4)) a -= (BASE << 4); \ +- if (a >= (BASE << 3)) a -= (BASE << 3); \ +- if (a >= (BASE << 2)) a -= (BASE << 2); \ +- if (a >= (BASE << 1)) a -= (BASE << 1); \ ++ CHOP(a); \ ++ MOD28(a); \ ++ } while (0) ++# define MOD63(a) \ ++ do { /* this assumes a is not negative */ \ ++ z_off64_t tmp = a >> 32; \ ++ a &= 0xffffffffL; \ ++ a += (tmp << 8) - (tmp << 5) + tmp; \ ++ tmp = a >> 16; \ ++ a &= 0xffffL; \ ++ a += (tmp << 4) - tmp; \ ++ tmp = a >> 16; \ ++ a &= 0xffffL; \ ++ a += (tmp << 4) - tmp; \ + if (a >= BASE) a -= BASE; \ + } while (0) + #else + # define MOD(a) a %= BASE +-# define MOD4(a) a %= BASE ++# define MOD28(a) a %= BASE ++# define MOD63(a) a %= BASE + #endif + + /* ========================================================================= */ +-uLong ZEXPORT adler32(adler, buf, len) ++uLong ZEXPORT adler32_z(adler, buf, len) + uLong adler; + const Bytef *buf; +- uInt len; ++ z_size_t len; + { + unsigned long sum2; + unsigned n; +@@ -92,7 +95,7 @@ uLong ZEXPORT adler32(adler, buf, len) + } + if (adler >= BASE) + adler -= BASE; +- MOD4(sum2); /* only added so many BASE's */ ++ MOD28(sum2); /* only added so many BASE's */ + return adler | (sum2 << 16); + } + +@@ -128,6 +131,15 @@ uLong ZEXPORT adler32(adler, buf, len) + } + + /* ========================================================================= */ ++uLong ZEXPORT adler32(adler, buf, len) ++ uLong adler; ++ const Bytef *buf; ++ uInt len; ++{ ++ return adler32_z(adler, buf, len); ++} ++ ++/* ========================================================================= */ + local uLong adler32_combine_(adler1, adler2, len2) + uLong adler1; + uLong adler2; +@@ -137,8 +149,13 @@ local uLong adler32_combine_(adler1, adler2, len2) + unsigned long sum2; + unsigned rem; + ++ /* for negative len, return invalid adler32 as a clue for debugging */ ++ if (len2 < 0) ++ return 0xffffffffUL; ++ + /* the derivation of this formula is left as an exercise for the reader */ +- rem = (unsigned)(len2 % BASE); ++ MOD63(len2); /* assumes len2 >= 0 */ ++ rem = (unsigned)len2; + sum1 = adler1 & 0xffff; + sum2 = rem * sum1; + MOD(sum2); +@@ -146,7 +163,7 @@ local uLong adler32_combine_(adler1, adler2, len2) + sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; + if (sum1 >= BASE) sum1 -= BASE; + if (sum1 >= BASE) sum1 -= BASE; +- if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); ++ if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1); + if (sum2 >= BASE) sum2 -= BASE; + return sum1 | (sum2 << 16); + } +diff --git a/com32/lib/zlib/compress.c b/com32/lib/zlib/compress.c +index ea4dfbe9..e2db404a 100644 +--- a/com32/lib/zlib/compress.c ++++ b/com32/lib/zlib/compress.c +@@ -1,5 +1,5 @@ + /* compress.c -- compress a memory buffer +- * Copyright (C) 1995-2005 Jean-loup Gailly. ++ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -28,16 +28,11 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) + { + z_stream stream; + int err; ++ const uInt max = (uInt)-1; ++ uLong left; + +- stream.next_in = (Bytef*)source; +- stream.avail_in = (uInt)sourceLen; +-#ifdef MAXSEG_64K +- /* Check for source > 64K on 16-bit machine: */ +- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; +-#endif +- stream.next_out = dest; +- stream.avail_out = (uInt)*destLen; +- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; ++ left = *destLen; ++ *destLen = 0; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; +@@ -46,15 +41,26 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) + err = deflateInit(&stream, level); + if (err != Z_OK) return err; + +- err = deflate(&stream, Z_FINISH); +- if (err != Z_STREAM_END) { +- deflateEnd(&stream); +- return err == Z_OK ? Z_BUF_ERROR : err; +- } +- *destLen = stream.total_out; ++ stream.next_out = dest; ++ stream.avail_out = 0; ++ stream.next_in = (z_const Bytef *)source; ++ stream.avail_in = 0; + +- err = deflateEnd(&stream); +- return err; ++ do { ++ if (stream.avail_out == 0) { ++ stream.avail_out = left > (uLong)max ? max : (uInt)left; ++ left -= stream.avail_out; ++ } ++ if (stream.avail_in == 0) { ++ stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen; ++ sourceLen -= stream.avail_in; ++ } ++ err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH); ++ } while (err == Z_OK); ++ ++ *destLen = stream.total_out; ++ deflateEnd(&stream); ++ return err == Z_STREAM_END ? Z_OK : err; + } + + /* =========================================================================== +diff --git a/com32/lib/zlib/crc32.c b/com32/lib/zlib/crc32.c +index 07265c6f..9580440c 100644 +--- a/com32/lib/zlib/crc32.c ++++ b/com32/lib/zlib/crc32.c +@@ -1,5 +1,5 @@ + /* crc32.c -- compute the CRC-32 of a data stream +- * Copyright (C) 1995-2006, 2010 Mark Adler ++ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + * + * Thanks to Rodney Brown for his contribution of faster +@@ -17,6 +17,8 @@ + of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should + first call get_crc_table() to initialize the tables before allowing more than + one thread to use crc32(). ++ ++ DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. + */ + + #ifdef MAKECRCH +@@ -28,37 +30,15 @@ + + #include "zutil.h" /* for STDC and FAR definitions */ + +-#define local static +- +-/* Find a four-byte integer type for crc32_little() and crc32_big(). */ +-#ifndef NOBYFOUR +-# ifdef STDC /* need ANSI C limits.h to determine sizes */ +-# include +-# define BYFOUR +-# if (UINT_MAX == 0xffffffffUL) +- typedef unsigned int u4; +-# else +-# if (ULONG_MAX == 0xffffffffUL) +- typedef unsigned long u4; +-# else +-# if (USHRT_MAX == 0xffffffffUL) +- typedef unsigned short u4; +-# else +-# undef BYFOUR /* can't find a four-byte integer type! */ +-# endif +-# endif +-# endif +-# endif /* STDC */ +-#endif /* !NOBYFOUR */ +- + /* Definitions for doing the crc four data bytes at a time. */ ++#if !defined(NOBYFOUR) && defined(Z_U4) ++# define BYFOUR ++#endif + #ifdef BYFOUR +-# define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ +- (((w)&0xff00)<<8)+(((w)&0xff)<<24)) + local unsigned long crc32_little OF((unsigned long, +- const unsigned char FAR *, unsigned)); ++ const unsigned char FAR *, z_size_t)); + local unsigned long crc32_big OF((unsigned long, +- const unsigned char FAR *, unsigned)); ++ const unsigned char FAR *, z_size_t)); + # define TBLS 8 + #else + # define TBLS 1 +@@ -68,16 +48,16 @@ + local unsigned long gf2_matrix_times OF((unsigned long *mat, + unsigned long vec)); + local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); +-local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2); ++local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); + + + #ifdef DYNAMIC_CRC_TABLE + + local volatile int crc_table_empty = 1; +-local unsigned long FAR crc_table[TBLS][256]; ++local z_crc_t FAR crc_table[TBLS][256]; + local void make_crc_table OF((void)); + #ifdef MAKECRCH +- local void write_table OF((FILE *, const unsigned long FAR *)); ++ local void write_table OF((FILE *, const z_crc_t FAR *)); + #endif /* MAKECRCH */ + /* + Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: +@@ -107,9 +87,9 @@ local void make_crc_table OF((void)); + */ + local void make_crc_table() + { +- unsigned long c; ++ z_crc_t c; + int n, k; +- unsigned long poly; /* polynomial exclusive-or pattern */ ++ z_crc_t poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static volatile int first = 1; /* flag to limit concurrent making */ + static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; +@@ -121,13 +101,13 @@ local void make_crc_table() + first = 0; + + /* make exclusive-or pattern from polynomial (0xedb88320UL) */ +- poly = 0UL; ++ poly = 0; + for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) +- poly |= 1UL << (31 - p[n]); ++ poly |= (z_crc_t)1 << (31 - p[n]); + + /* generate a crc for every 8-bit value */ + for (n = 0; n < 256; n++) { +- c = (unsigned long)n; ++ c = (z_crc_t)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[0][n] = c; +@@ -138,11 +118,11 @@ local void make_crc_table() + and then the byte reversal of those as well as the first table */ + for (n = 0; n < 256; n++) { + c = crc_table[0][n]; +- crc_table[4][n] = REV(c); ++ crc_table[4][n] = ZSWAP32(c); + for (k = 1; k < 4; k++) { + c = crc_table[0][c & 0xff] ^ (c >> 8); + crc_table[k][n] = c; +- crc_table[k + 4][n] = REV(c); ++ crc_table[k + 4][n] = ZSWAP32(c); + } + } + #endif /* BYFOUR */ +@@ -164,7 +144,7 @@ local void make_crc_table() + if (out == NULL) return; + fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); + fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); +- fprintf(out, "local const unsigned long FAR "); ++ fprintf(out, "local const z_crc_t FAR "); + fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); + write_table(out, crc_table[0]); + # ifdef BYFOUR +@@ -184,12 +164,13 @@ local void make_crc_table() + #ifdef MAKECRCH + local void write_table(out, table) + FILE *out; +- const unsigned long FAR *table; ++ const z_crc_t FAR *table; + { + int n; + + for (n = 0; n < 256; n++) +- fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], ++ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", ++ (unsigned long)(table[n]), + n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); + } + #endif /* MAKECRCH */ +@@ -204,13 +185,13 @@ local void write_table(out, table) + /* ========================================================================= + * This function can be used by asm versions of crc32() + */ +-const unsigned long FAR * ZEXPORT get_crc_table() ++const z_crc_t FAR * ZEXPORT get_crc_table() + { + #ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); + #endif /* DYNAMIC_CRC_TABLE */ +- return (const unsigned long FAR *)crc_table; ++ return (const z_crc_t FAR *)crc_table; + } + + /* ========================================================================= */ +@@ -218,10 +199,10 @@ const unsigned long FAR * ZEXPORT get_crc_table() + #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 + + /* ========================================================================= */ +-unsigned long ZEXPORT crc32(crc, buf, len) ++unsigned long ZEXPORT crc32_z(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; +- uInt len; ++ z_size_t len; + { + if (buf == Z_NULL) return 0UL; + +@@ -232,7 +213,7 @@ unsigned long ZEXPORT crc32(crc, buf, len) + + #ifdef BYFOUR + if (sizeof(void *) == sizeof(ptrdiff_t)) { +- u4 endian; ++ z_crc_t endian; + + endian = 1; + if (*((unsigned char *)(&endian))) +@@ -252,8 +233,29 @@ unsigned long ZEXPORT crc32(crc, buf, len) + return crc ^ 0xffffffffUL; + } + ++/* ========================================================================= */ ++unsigned long ZEXPORT crc32(crc, buf, len) ++ unsigned long crc; ++ const unsigned char FAR *buf; ++ uInt len; ++{ ++ return crc32_z(crc, buf, len); ++} ++ + #ifdef BYFOUR + ++/* ++ This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit ++ integer pointer type. This violates the strict aliasing rule, where a ++ compiler can assume, for optimization purposes, that two pointers to ++ fundamentally different types won't ever point to the same memory. This can ++ manifest as a problem only if one of the pointers is written to. This code ++ only reads from those pointers. So long as this code remains isolated in ++ this compilation unit, there won't be a problem. For this reason, this code ++ should not be copied and pasted into a compilation unit in which other code ++ writes to the buffer that is passed to these routines. ++ */ ++ + /* ========================================================================= */ + #define DOLIT4 c ^= *buf4++; \ + c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ +@@ -264,19 +266,19 @@ unsigned long ZEXPORT crc32(crc, buf, len) + local unsigned long crc32_little(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; +- unsigned len; ++ z_size_t len; + { +- register u4 c; +- register const u4 FAR *buf4; ++ register z_crc_t c; ++ register const z_crc_t FAR *buf4; + +- c = (u4)crc; ++ c = (z_crc_t)crc; + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + len--; + } + +- buf4 = (const u4 FAR *)(const void FAR *)buf; ++ buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + while (len >= 32) { + DOLIT32; + len -= 32; +@@ -295,7 +297,7 @@ local unsigned long crc32_little(crc, buf, len) + } + + /* ========================================================================= */ +-#define DOBIG4 c ^= *++buf4; \ ++#define DOBIG4 c ^= *buf4++; \ + c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ + crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] + #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 +@@ -304,20 +306,19 @@ local unsigned long crc32_little(crc, buf, len) + local unsigned long crc32_big(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; +- unsigned len; ++ z_size_t len; + { +- register u4 c; +- register const u4 FAR *buf4; ++ register z_crc_t c; ++ register const z_crc_t FAR *buf4; + +- c = REV((u4)crc); ++ c = ZSWAP32((z_crc_t)crc); + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + len--; + } + +- buf4 = (const u4 FAR *)(const void FAR *)buf; +- buf4--; ++ buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + while (len >= 32) { + DOBIG32; + len -= 32; +@@ -326,14 +327,13 @@ local unsigned long crc32_big(crc, buf, len) + DOBIG4; + len -= 4; + } +- buf4++; + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + } while (--len); + c = ~c; +- return (unsigned long)(REV(c)); ++ return (unsigned long)(ZSWAP32(c)); + } + + #endif /* BYFOUR */ +diff --git a/com32/lib/zlib/crc32.h b/com32/lib/zlib/crc32.h +index 8053b611..9e0c7781 100644 +--- a/com32/lib/zlib/crc32.h ++++ b/com32/lib/zlib/crc32.h +@@ -2,7 +2,7 @@ + * Generated automatically by crc32.c + */ + +-local const unsigned long FAR crc_table[TBLS][256] = ++local const z_crc_t FAR crc_table[TBLS][256] = + { + { + 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, +diff --git a/com32/lib/zlib/deflate.c b/com32/lib/zlib/deflate.c +index 1a375634..1ec76144 100644 +--- a/com32/lib/zlib/deflate.c ++++ b/com32/lib/zlib/deflate.c +@@ -1,5 +1,5 @@ + /* deflate.c -- compress data using the deflation algorithm +- * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler ++ * Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -37,7 +37,7 @@ + * REFERENCES + * + * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". +- * Available in http://www.ietf.org/rfc/rfc1951.txt ++ * Available in http://tools.ietf.org/html/rfc1951 + * + * A description of the Rabin and Karp algorithm is given in the book + * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. +@@ -52,7 +52,7 @@ + #include "deflate.h" + + const char deflate_copyright[] = +- " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; ++ " deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler "; + /* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot +@@ -73,6 +73,8 @@ typedef enum { + typedef block_state (*compress_func) OF((deflate_state *s, int flush)); + /* Compression function. Returns the block state after the call. */ + ++local int deflateStateCheck OF((z_streamp strm)); ++local void slide_hash OF((deflate_state *s)); + local void fill_window OF((deflate_state *s)); + local block_state deflate_stored OF((deflate_state *s, int flush)); + local block_state deflate_fast OF((deflate_state *s, int flush)); +@@ -84,15 +86,16 @@ local block_state deflate_huff OF((deflate_state *s, int flush)); + local void lm_init OF((deflate_state *s)); + local void putShortMSB OF((deflate_state *s, uInt b)); + local void flush_pending OF((z_streamp strm)); +-local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); ++local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); + #ifdef ASMV ++# pragma message("Assembler code may have bugs -- use at your own risk") + void match_init OF((void)); /* asm code initialization */ + uInt longest_match OF((deflate_state *s, IPos cur_match)); + #else + local uInt longest_match OF((deflate_state *s, IPos cur_match)); + #endif + +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + local void check_match OF((deflate_state *s, IPos start, IPos match, + int length)); + #endif +@@ -148,18 +151,14 @@ local const config configuration_table[10] = { + * meaning. + */ + +-#define EQUAL 0 +-/* result of memcmp for equal strings */ +- +-#ifndef NO_DUMMY_DECL +-struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ +-#endif ++/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */ ++#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0)) + + /* =========================================================================== + * Update a hash value with the given input byte +- * IN assertion: all calls to to UPDATE_HASH are made with consecutive +- * input characters, so that a running hash key can be computed from the +- * previous key instead of complete recalculation each time. ++ * IN assertion: all calls to UPDATE_HASH are made with consecutive input ++ * characters, so that a running hash key can be computed from the previous ++ * key instead of complete recalculation each time. + */ + #define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) + +@@ -170,9 +169,9 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ + * the previous length of the hash chain. + * If this file is compiled with -DFASTEST, the compression level is forced + * to 1, and no hash chains are maintained. +- * IN assertion: all calls to to INSERT_STRING are made with consecutive +- * input characters and the first MIN_MATCH bytes of str are valid +- * (except for the last MIN_MATCH-1 bytes of the input file). ++ * IN assertion: all calls to INSERT_STRING are made with consecutive input ++ * characters and the first MIN_MATCH bytes of str are valid (except for ++ * the last MIN_MATCH-1 bytes of the input file). + */ + #ifdef FASTEST + #define INSERT_STRING(s, str, match_head) \ +@@ -194,6 +193,37 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ + s->head[s->hash_size-1] = NIL; \ + zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); + ++/* =========================================================================== ++ * Slide the hash table when sliding the window down (could be avoided with 32 ++ * bit values at the expense of memory usage). We slide even when level == 0 to ++ * keep the hash table consistent if we switch back to level > 0 later. ++ */ ++local void slide_hash(s) ++ deflate_state *s; ++{ ++ unsigned n, m; ++ Posf *p; ++ uInt wsize = s->w_size; ++ ++ n = s->hash_size; ++ p = &s->head[n]; ++ do { ++ m = *--p; ++ *p = (Pos)(m >= wsize ? m - wsize : NIL); ++ } while (--n); ++ n = wsize; ++#ifndef FASTEST ++ p = &s->prev[n]; ++ do { ++ m = *--p; ++ *p = (Pos)(m >= wsize ? m - wsize : NIL); ++ /* If n is not on any hash chain, prev[n] is garbage but ++ * its value will never be used. ++ */ ++ } while (--n); ++#endif ++} ++ + /* ========================================================================= */ + int ZEXPORT deflateInit_(strm, level, version, stream_size) + z_streamp strm; +@@ -235,10 +265,19 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + + strm->msg = Z_NULL; + if (strm->zalloc == (alloc_func)0) { ++#ifdef Z_SOLO ++ return Z_STREAM_ERROR; ++#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; ++#endif + } +- if (strm->zfree == (free_func)0) strm->zfree = zcfree; ++ if (strm->zfree == (free_func)0) ++#ifdef Z_SOLO ++ return Z_STREAM_ERROR; ++#else ++ strm->zfree = zcfree; ++#endif + + #ifdef FASTEST + if (level != 0) level = 1; +@@ -258,7 +297,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + #endif + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || +- strategy < 0 || strategy > Z_FIXED) { ++ strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) { + return Z_STREAM_ERROR; + } + if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ +@@ -266,14 +305,15 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + if (s == Z_NULL) return Z_MEM_ERROR; + strm->state = (struct internal_state FAR *)s; + s->strm = strm; ++ s->status = INIT_STATE; /* to pass state test in deflateReset() */ + + s->wrap = wrap; + s->gzhead = Z_NULL; +- s->w_bits = windowBits; ++ s->w_bits = (uInt)windowBits; + s->w_size = 1 << s->w_bits; + s->w_mask = s->w_size - 1; + +- s->hash_bits = memLevel + 7; ++ s->hash_bits = (uInt)memLevel + 7; + s->hash_size = 1 << s->hash_bits; + s->hash_mask = s->hash_size - 1; + s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); +@@ -293,7 +333,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || + s->pending_buf == Z_NULL) { + s->status = FINISH_STATE; +- strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); ++ strm->msg = ERR_MSG(Z_MEM_ERROR); + deflateEnd (strm); + return Z_MEM_ERROR; + } +@@ -307,6 +347,31 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + return deflateReset(strm); + } + ++/* ========================================================================= ++ * Check for a valid deflate stream state. Return 0 if ok, 1 if not. ++ */ ++local int deflateStateCheck (strm) ++ z_streamp strm; ++{ ++ deflate_state *s; ++ if (strm == Z_NULL || ++ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) ++ return 1; ++ s = strm->state; ++ if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE && ++#ifdef GZIP ++ s->status != GZIP_STATE && ++#endif ++ s->status != EXTRA_STATE && ++ s->status != NAME_STATE && ++ s->status != COMMENT_STATE && ++ s->status != HCRC_STATE && ++ s->status != BUSY_STATE && ++ s->status != FINISH_STATE)) ++ return 1; ++ return 0; ++} ++ + /* ========================================================================= */ + int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) + z_streamp strm; +@@ -314,49 +379,97 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) + uInt dictLength; + { + deflate_state *s; +- uInt length = dictLength; +- uInt n; +- IPos hash_head = 0; ++ uInt str, n; ++ int wrap; ++ unsigned avail; ++ z_const unsigned char *next; + +- if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || +- strm->state->wrap == 2 || +- (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) ++ if (deflateStateCheck(strm) || dictionary == Z_NULL) + return Z_STREAM_ERROR; +- + s = strm->state; +- if (s->wrap) +- strm->adler = adler32(strm->adler, dictionary, dictLength); ++ wrap = s->wrap; ++ if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) ++ return Z_STREAM_ERROR; + +- if (length < MIN_MATCH) return Z_OK; +- if (length > s->w_size) { +- length = s->w_size; +- dictionary += dictLength - length; /* use the tail of the dictionary */ ++ /* when using zlib wrappers, compute Adler-32 for provided dictionary */ ++ if (wrap == 1) ++ strm->adler = adler32(strm->adler, dictionary, dictLength); ++ s->wrap = 0; /* avoid computing Adler-32 in read_buf */ ++ ++ /* if dictionary would fill window, just replace the history */ ++ if (dictLength >= s->w_size) { ++ if (wrap == 0) { /* already empty otherwise */ ++ CLEAR_HASH(s); ++ s->strstart = 0; ++ s->block_start = 0L; ++ s->insert = 0; ++ } ++ dictionary += dictLength - s->w_size; /* use the tail */ ++ dictLength = s->w_size; + } +- zmemcpy(s->window, dictionary, length); +- s->strstart = length; +- s->block_start = (long)length; + +- /* Insert all strings in the hash table (except for the last two bytes). +- * s->lookahead stays null, so s->ins_h will be recomputed at the next +- * call of fill_window. +- */ +- s->ins_h = s->window[0]; +- UPDATE_HASH(s, s->ins_h, s->window[1]); +- for (n = 0; n <= length - MIN_MATCH; n++) { +- INSERT_STRING(s, n, hash_head); ++ /* insert dictionary into window and hash */ ++ avail = strm->avail_in; ++ next = strm->next_in; ++ strm->avail_in = dictLength; ++ strm->next_in = (z_const Bytef *)dictionary; ++ fill_window(s); ++ while (s->lookahead >= MIN_MATCH) { ++ str = s->strstart; ++ n = s->lookahead - (MIN_MATCH-1); ++ do { ++ UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); ++#ifndef FASTEST ++ s->prev[str & s->w_mask] = s->head[s->ins_h]; ++#endif ++ s->head[s->ins_h] = (Pos)str; ++ str++; ++ } while (--n); ++ s->strstart = str; ++ s->lookahead = MIN_MATCH-1; ++ fill_window(s); + } +- if (hash_head) hash_head = 0; /* to make compiler happy */ ++ s->strstart += s->lookahead; ++ s->block_start = (long)s->strstart; ++ s->insert = s->lookahead; ++ s->lookahead = 0; ++ s->match_length = s->prev_length = MIN_MATCH-1; ++ s->match_available = 0; ++ strm->next_in = next; ++ strm->avail_in = avail; ++ s->wrap = wrap; + return Z_OK; + } + + /* ========================================================================= */ +-int ZEXPORT deflateReset (strm) ++int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength) ++ z_streamp strm; ++ Bytef *dictionary; ++ uInt *dictLength; ++{ ++ deflate_state *s; ++ uInt len; ++ ++ if (deflateStateCheck(strm)) ++ return Z_STREAM_ERROR; ++ s = strm->state; ++ len = s->strstart + s->lookahead; ++ if (len > s->w_size) ++ len = s->w_size; ++ if (dictionary != Z_NULL && len) ++ zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len); ++ if (dictLength != Z_NULL) ++ *dictLength = len; ++ return Z_OK; ++} ++ ++/* ========================================================================= */ ++int ZEXPORT deflateResetKeep (strm) + z_streamp strm; + { + deflate_state *s; + +- if (strm == Z_NULL || strm->state == Z_NULL || +- strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { ++ if (deflateStateCheck(strm)) { + return Z_STREAM_ERROR; + } + +@@ -371,7 +484,11 @@ int ZEXPORT deflateReset (strm) + if (s->wrap < 0) { + s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ + } +- s->status = s->wrap ? INIT_STATE : BUSY_STATE; ++ s->status = ++#ifdef GZIP ++ s->wrap == 2 ? GZIP_STATE : ++#endif ++ s->wrap ? INIT_STATE : BUSY_STATE; + strm->adler = + #ifdef GZIP + s->wrap == 2 ? crc32(0L, Z_NULL, 0) : +@@ -380,31 +497,70 @@ int ZEXPORT deflateReset (strm) + s->last_flush = Z_NO_FLUSH; + + _tr_init(s); +- lm_init(s); + + return Z_OK; + } + + /* ========================================================================= */ ++int ZEXPORT deflateReset (strm) ++ z_streamp strm; ++{ ++ int ret; ++ ++ ret = deflateResetKeep(strm); ++ if (ret == Z_OK) ++ lm_init(strm->state); ++ return ret; ++} ++ ++/* ========================================================================= */ + int ZEXPORT deflateSetHeader (strm, head) + z_streamp strm; + gz_headerp head; + { +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- if (strm->state->wrap != 2) return Z_STREAM_ERROR; ++ if (deflateStateCheck(strm) || strm->state->wrap != 2) ++ return Z_STREAM_ERROR; + strm->state->gzhead = head; + return Z_OK; + } + + /* ========================================================================= */ ++int ZEXPORT deflatePending (strm, pending, bits) ++ unsigned *pending; ++ int *bits; ++ z_streamp strm; ++{ ++ if (deflateStateCheck(strm)) return Z_STREAM_ERROR; ++ if (pending != Z_NULL) ++ *pending = strm->state->pending; ++ if (bits != Z_NULL) ++ *bits = strm->state->bi_valid; ++ return Z_OK; ++} ++ ++/* ========================================================================= */ + int ZEXPORT deflatePrime (strm, bits, value) + z_streamp strm; + int bits; + int value; + { +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- strm->state->bi_valid = bits; +- strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); ++ deflate_state *s; ++ int put; ++ ++ if (deflateStateCheck(strm)) return Z_STREAM_ERROR; ++ s = strm->state; ++ if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) ++ return Z_BUF_ERROR; ++ do { ++ put = Buf_size - s->bi_valid; ++ if (put > bits) ++ put = bits; ++ s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); ++ s->bi_valid += put; ++ _tr_flush_bits(s); ++ value >>= put; ++ bits -= put; ++ } while (bits); + return Z_OK; + } + +@@ -416,9 +572,8 @@ int ZEXPORT deflateParams(strm, level, strategy) + { + deflate_state *s; + compress_func func; +- int err = Z_OK; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (deflateStateCheck(strm)) return Z_STREAM_ERROR; + s = strm->state; + + #ifdef FASTEST +@@ -432,11 +587,22 @@ int ZEXPORT deflateParams(strm, level, strategy) + func = configuration_table[s->level].func; + + if ((strategy != s->strategy || func != configuration_table[level].func) && +- strm->total_in != 0) { ++ s->high_water) { + /* Flush the last buffer: */ +- err = deflate(strm, Z_BLOCK); ++ int err = deflate(strm, Z_BLOCK); ++ if (err == Z_STREAM_ERROR) ++ return err; ++ if (strm->avail_out == 0) ++ return Z_BUF_ERROR; + } + if (s->level != level) { ++ if (s->level == 0 && s->matches != 0) { ++ if (s->matches == 1) ++ slide_hash(s); ++ else ++ CLEAR_HASH(s); ++ s->matches = 0; ++ } + s->level = level; + s->max_lazy_match = configuration_table[level].max_lazy; + s->good_match = configuration_table[level].good_length; +@@ -444,7 +610,7 @@ int ZEXPORT deflateParams(strm, level, strategy) + s->max_chain_length = configuration_table[level].max_chain; + } + s->strategy = strategy; +- return err; ++ return Z_OK; + } + + /* ========================================================================= */ +@@ -457,12 +623,12 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) + { + deflate_state *s; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (deflateStateCheck(strm)) return Z_STREAM_ERROR; + s = strm->state; +- s->good_match = good_length; +- s->max_lazy_match = max_lazy; ++ s->good_match = (uInt)good_length; ++ s->max_lazy_match = (uInt)max_lazy; + s->nice_match = nice_length; +- s->max_chain_length = max_chain; ++ s->max_chain_length = (uInt)max_chain; + return Z_OK; + } + +@@ -489,14 +655,13 @@ uLong ZEXPORT deflateBound(strm, sourceLen) + { + deflate_state *s; + uLong complen, wraplen; +- Bytef *str; + + /* conservative upper bound for compressed data */ + complen = sourceLen + + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; + + /* if can't get parameters, return conservative bound plus zlib wrapper */ +- if (strm == Z_NULL || strm->state == Z_NULL) ++ if (deflateStateCheck(strm)) + return complen + 6; + + /* compute wrapper length */ +@@ -508,9 +673,11 @@ uLong ZEXPORT deflateBound(strm, sourceLen) + case 1: /* zlib wrapper */ + wraplen = 6 + (s->strstart ? 4 : 0); + break; ++#ifdef GZIP + case 2: /* gzip wrapper */ + wraplen = 18; + if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ ++ Bytef *str; + if (s->gzhead->extra != Z_NULL) + wraplen += 2 + s->gzhead->extra_len; + str = s->gzhead->name; +@@ -527,6 +694,7 @@ uLong ZEXPORT deflateBound(strm, sourceLen) + wraplen += 2; + } + break; ++#endif + default: /* for compiler happiness */ + wraplen = 6; + } +@@ -554,30 +722,43 @@ local void putShortMSB (s, b) + } + + /* ========================================================================= +- * Flush as much pending output as possible. All deflate() output goes +- * through this function so some applications may wish to modify it +- * to avoid allocating a large strm->next_out buffer and copying into it. +- * (See also read_buf()). ++ * Flush as much pending output as possible. All deflate() output, except for ++ * some deflate_stored() output, goes through this function so some ++ * applications may wish to modify it to avoid allocating a large ++ * strm->next_out buffer and copying into it. (See also read_buf()). + */ + local void flush_pending(strm) + z_streamp strm; + { +- unsigned len = strm->state->pending; ++ unsigned len; ++ deflate_state *s = strm->state; + ++ _tr_flush_bits(s); ++ len = s->pending; + if (len > strm->avail_out) len = strm->avail_out; + if (len == 0) return; + +- zmemcpy(strm->next_out, strm->state->pending_out, len); ++ zmemcpy(strm->next_out, s->pending_out, len); + strm->next_out += len; +- strm->state->pending_out += len; ++ s->pending_out += len; + strm->total_out += len; +- strm->avail_out -= len; +- strm->state->pending -= len; +- if (strm->state->pending == 0) { +- strm->state->pending_out = strm->state->pending_buf; ++ strm->avail_out -= len; ++ s->pending -= len; ++ if (s->pending == 0) { ++ s->pending_out = s->pending_buf; + } + } + ++/* =========================================================================== ++ * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1]. ++ */ ++#define HCRC_UPDATE(beg) \ ++ do { \ ++ if (s->gzhead->hcrc && s->pending > (beg)) \ ++ strm->adler = crc32(strm->adler, s->pending_buf + (beg), \ ++ s->pending - (beg)); \ ++ } while (0) ++ + /* ========================================================================= */ + int ZEXPORT deflate (strm, flush) + z_streamp strm; +@@ -586,230 +767,229 @@ int ZEXPORT deflate (strm, flush) + int old_flush; /* value of flush param for previous deflate call */ + deflate_state *s; + +- if (strm == Z_NULL || strm->state == Z_NULL || +- flush > Z_BLOCK || flush < 0) { ++ if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) { + return Z_STREAM_ERROR; + } + s = strm->state; + + if (strm->next_out == Z_NULL || +- (strm->next_in == Z_NULL && strm->avail_in != 0) || ++ (strm->avail_in != 0 && strm->next_in == Z_NULL) || + (s->status == FINISH_STATE && flush != Z_FINISH)) { + ERR_RETURN(strm, Z_STREAM_ERROR); + } + if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); + +- s->strm = strm; /* just in case */ + old_flush = s->last_flush; + s->last_flush = flush; + ++ /* Flush as much pending output as possible */ ++ if (s->pending != 0) { ++ flush_pending(strm); ++ if (strm->avail_out == 0) { ++ /* Since avail_out is 0, deflate will be called again with ++ * more output space, but possibly with both pending and ++ * avail_in equal to zero. There won't be anything to do, ++ * but this is not an error situation so make sure we ++ * return OK instead of BUF_ERROR at next call of deflate: ++ */ ++ s->last_flush = -1; ++ return Z_OK; ++ } ++ ++ /* Make sure there is something to do and avoid duplicate consecutive ++ * flushes. For repeated and useless calls with Z_FINISH, we keep ++ * returning Z_STREAM_END instead of Z_BUF_ERROR. ++ */ ++ } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && ++ flush != Z_FINISH) { ++ ERR_RETURN(strm, Z_BUF_ERROR); ++ } ++ ++ /* User must not provide more input after the first FINISH: */ ++ if (s->status == FINISH_STATE && strm->avail_in != 0) { ++ ERR_RETURN(strm, Z_BUF_ERROR); ++ } ++ + /* Write the header */ + if (s->status == INIT_STATE) { +-#ifdef GZIP +- if (s->wrap == 2) { +- strm->adler = crc32(0L, Z_NULL, 0); +- put_byte(s, 31); +- put_byte(s, 139); +- put_byte(s, 8); +- if (s->gzhead == Z_NULL) { +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, s->level == 9 ? 2 : +- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? +- 4 : 0)); +- put_byte(s, OS_CODE); +- s->status = BUSY_STATE; +- } +- else { +- put_byte(s, (s->gzhead->text ? 1 : 0) + +- (s->gzhead->hcrc ? 2 : 0) + +- (s->gzhead->extra == Z_NULL ? 0 : 4) + +- (s->gzhead->name == Z_NULL ? 0 : 8) + +- (s->gzhead->comment == Z_NULL ? 0 : 16) +- ); +- put_byte(s, (Byte)(s->gzhead->time & 0xff)); +- put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); +- put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); +- put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); +- put_byte(s, s->level == 9 ? 2 : +- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? +- 4 : 0)); +- put_byte(s, s->gzhead->os & 0xff); +- if (s->gzhead->extra != Z_NULL) { +- put_byte(s, s->gzhead->extra_len & 0xff); +- put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); +- } +- if (s->gzhead->hcrc) +- strm->adler = crc32(strm->adler, s->pending_buf, +- s->pending); +- s->gzindex = 0; +- s->status = EXTRA_STATE; +- } +- } ++ /* zlib header */ ++ uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; ++ uInt level_flags; ++ ++ if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) ++ level_flags = 0; ++ else if (s->level < 6) ++ level_flags = 1; ++ else if (s->level == 6) ++ level_flags = 2; + else +-#endif +- { +- uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; +- uInt level_flags; +- +- if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) +- level_flags = 0; +- else if (s->level < 6) +- level_flags = 1; +- else if (s->level == 6) +- level_flags = 2; +- else +- level_flags = 3; +- header |= (level_flags << 6); +- if (s->strstart != 0) header |= PRESET_DICT; +- header += 31 - (header % 31); ++ level_flags = 3; ++ header |= (level_flags << 6); ++ if (s->strstart != 0) header |= PRESET_DICT; ++ header += 31 - (header % 31); + ++ putShortMSB(s, header); ++ ++ /* Save the adler32 of the preset dictionary: */ ++ if (s->strstart != 0) { ++ putShortMSB(s, (uInt)(strm->adler >> 16)); ++ putShortMSB(s, (uInt)(strm->adler & 0xffff)); ++ } ++ strm->adler = adler32(0L, Z_NULL, 0); ++ s->status = BUSY_STATE; ++ ++ /* Compression must start with an empty pending buffer */ ++ flush_pending(strm); ++ if (s->pending != 0) { ++ s->last_flush = -1; ++ return Z_OK; ++ } ++ } ++#ifdef GZIP ++ if (s->status == GZIP_STATE) { ++ /* gzip header */ ++ strm->adler = crc32(0L, Z_NULL, 0); ++ put_byte(s, 31); ++ put_byte(s, 139); ++ put_byte(s, 8); ++ if (s->gzhead == Z_NULL) { ++ put_byte(s, 0); ++ put_byte(s, 0); ++ put_byte(s, 0); ++ put_byte(s, 0); ++ put_byte(s, 0); ++ put_byte(s, s->level == 9 ? 2 : ++ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? ++ 4 : 0)); ++ put_byte(s, OS_CODE); + s->status = BUSY_STATE; +- putShortMSB(s, header); + +- /* Save the adler32 of the preset dictionary: */ +- if (s->strstart != 0) { +- putShortMSB(s, (uInt)(strm->adler >> 16)); +- putShortMSB(s, (uInt)(strm->adler & 0xffff)); ++ /* Compression must start with an empty pending buffer */ ++ flush_pending(strm); ++ if (s->pending != 0) { ++ s->last_flush = -1; ++ return Z_OK; ++ } ++ } ++ else { ++ put_byte(s, (s->gzhead->text ? 1 : 0) + ++ (s->gzhead->hcrc ? 2 : 0) + ++ (s->gzhead->extra == Z_NULL ? 0 : 4) + ++ (s->gzhead->name == Z_NULL ? 0 : 8) + ++ (s->gzhead->comment == Z_NULL ? 0 : 16) ++ ); ++ put_byte(s, (Byte)(s->gzhead->time & 0xff)); ++ put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); ++ put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); ++ put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); ++ put_byte(s, s->level == 9 ? 2 : ++ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? ++ 4 : 0)); ++ put_byte(s, s->gzhead->os & 0xff); ++ if (s->gzhead->extra != Z_NULL) { ++ put_byte(s, s->gzhead->extra_len & 0xff); ++ put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); + } +- strm->adler = adler32(0L, Z_NULL, 0); ++ if (s->gzhead->hcrc) ++ strm->adler = crc32(strm->adler, s->pending_buf, ++ s->pending); ++ s->gzindex = 0; ++ s->status = EXTRA_STATE; + } + } +-#ifdef GZIP + if (s->status == EXTRA_STATE) { + if (s->gzhead->extra != Z_NULL) { +- uInt beg = s->pending; /* start of bytes to update crc */ +- +- while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { +- if (s->pending == s->pending_buf_size) { +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- flush_pending(strm); +- beg = s->pending; +- if (s->pending == s->pending_buf_size) +- break; ++ ulg beg = s->pending; /* start of bytes to update crc */ ++ uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex; ++ while (s->pending + left > s->pending_buf_size) { ++ uInt copy = s->pending_buf_size - s->pending; ++ zmemcpy(s->pending_buf + s->pending, ++ s->gzhead->extra + s->gzindex, copy); ++ s->pending = s->pending_buf_size; ++ HCRC_UPDATE(beg); ++ s->gzindex += copy; ++ flush_pending(strm); ++ if (s->pending != 0) { ++ s->last_flush = -1; ++ return Z_OK; + } +- put_byte(s, s->gzhead->extra[s->gzindex]); +- s->gzindex++; +- } +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- if (s->gzindex == s->gzhead->extra_len) { +- s->gzindex = 0; +- s->status = NAME_STATE; ++ beg = 0; ++ left -= copy; + } ++ zmemcpy(s->pending_buf + s->pending, ++ s->gzhead->extra + s->gzindex, left); ++ s->pending += left; ++ HCRC_UPDATE(beg); ++ s->gzindex = 0; + } +- else +- s->status = NAME_STATE; ++ s->status = NAME_STATE; + } + if (s->status == NAME_STATE) { + if (s->gzhead->name != Z_NULL) { +- uInt beg = s->pending; /* start of bytes to update crc */ ++ ulg beg = s->pending; /* start of bytes to update crc */ + int val; +- + do { + if (s->pending == s->pending_buf_size) { +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); ++ HCRC_UPDATE(beg); + flush_pending(strm); +- beg = s->pending; +- if (s->pending == s->pending_buf_size) { +- val = 1; +- break; ++ if (s->pending != 0) { ++ s->last_flush = -1; ++ return Z_OK; + } ++ beg = 0; + } + val = s->gzhead->name[s->gzindex++]; + put_byte(s, val); + } while (val != 0); +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- if (val == 0) { +- s->gzindex = 0; +- s->status = COMMENT_STATE; +- } ++ HCRC_UPDATE(beg); ++ s->gzindex = 0; + } +- else +- s->status = COMMENT_STATE; ++ s->status = COMMENT_STATE; + } + if (s->status == COMMENT_STATE) { + if (s->gzhead->comment != Z_NULL) { +- uInt beg = s->pending; /* start of bytes to update crc */ ++ ulg beg = s->pending; /* start of bytes to update crc */ + int val; +- + do { + if (s->pending == s->pending_buf_size) { +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); ++ HCRC_UPDATE(beg); + flush_pending(strm); +- beg = s->pending; +- if (s->pending == s->pending_buf_size) { +- val = 1; +- break; ++ if (s->pending != 0) { ++ s->last_flush = -1; ++ return Z_OK; + } ++ beg = 0; + } + val = s->gzhead->comment[s->gzindex++]; + put_byte(s, val); + } while (val != 0); +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- if (val == 0) +- s->status = HCRC_STATE; ++ HCRC_UPDATE(beg); + } +- else +- s->status = HCRC_STATE; ++ s->status = HCRC_STATE; + } + if (s->status == HCRC_STATE) { + if (s->gzhead->hcrc) { +- if (s->pending + 2 > s->pending_buf_size) ++ if (s->pending + 2 > s->pending_buf_size) { + flush_pending(strm); +- if (s->pending + 2 <= s->pending_buf_size) { +- put_byte(s, (Byte)(strm->adler & 0xff)); +- put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); +- strm->adler = crc32(0L, Z_NULL, 0); +- s->status = BUSY_STATE; ++ if (s->pending != 0) { ++ s->last_flush = -1; ++ return Z_OK; ++ } + } ++ put_byte(s, (Byte)(strm->adler & 0xff)); ++ put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); ++ strm->adler = crc32(0L, Z_NULL, 0); + } +- else +- s->status = BUSY_STATE; +- } +-#endif ++ s->status = BUSY_STATE; + +- /* Flush as much pending output as possible */ +- if (s->pending != 0) { ++ /* Compression must start with an empty pending buffer */ + flush_pending(strm); +- if (strm->avail_out == 0) { +- /* Since avail_out is 0, deflate will be called again with +- * more output space, but possibly with both pending and +- * avail_in equal to zero. There won't be anything to do, +- * but this is not an error situation so make sure we +- * return OK instead of BUF_ERROR at next call of deflate: +- */ ++ if (s->pending != 0) { + s->last_flush = -1; + return Z_OK; + } +- +- /* Make sure there is something to do and avoid duplicate consecutive +- * flushes. For repeated and useless calls with Z_FINISH, we keep +- * returning Z_STREAM_END instead of Z_BUF_ERROR. +- */ +- } else if (strm->avail_in == 0 && flush <= old_flush && +- flush != Z_FINISH) { +- ERR_RETURN(strm, Z_BUF_ERROR); +- } +- +- /* User must not provide more input after the first FINISH: */ +- if (s->status == FINISH_STATE && strm->avail_in != 0) { +- ERR_RETURN(strm, Z_BUF_ERROR); + } ++#endif + + /* Start a new block or continue the current one. + */ +@@ -817,9 +997,10 @@ int ZEXPORT deflate (strm, flush) + (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { + block_state bstate; + +- bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : +- (s->strategy == Z_RLE ? deflate_rle(s, flush) : +- (*(configuration_table[s->level].func))(s, flush)); ++ bstate = s->level == 0 ? deflate_stored(s, flush) : ++ s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : ++ s->strategy == Z_RLE ? deflate_rle(s, flush) : ++ (*(configuration_table[s->level].func))(s, flush); + + if (bstate == finish_started || bstate == finish_done) { + s->status = FINISH_STATE; +@@ -850,6 +1031,7 @@ int ZEXPORT deflate (strm, flush) + if (s->lookahead == 0) { + s->strstart = 0; + s->block_start = 0L; ++ s->insert = 0; + } + } + } +@@ -860,7 +1042,6 @@ int ZEXPORT deflate (strm, flush) + } + } + } +- Assert(strm->avail_out > 0, "bug2"); + + if (flush != Z_FINISH) return Z_OK; + if (s->wrap <= 0) return Z_STREAM_END; +@@ -897,18 +1078,9 @@ int ZEXPORT deflateEnd (strm) + { + int status; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (deflateStateCheck(strm)) return Z_STREAM_ERROR; + + status = strm->state->status; +- if (status != INIT_STATE && +- status != EXTRA_STATE && +- status != NAME_STATE && +- status != COMMENT_STATE && +- status != HCRC_STATE && +- status != BUSY_STATE && +- status != FINISH_STATE) { +- return Z_STREAM_ERROR; +- } + + /* Deallocate in reverse order of allocations: */ + TRY_FREE(strm, strm->state->pending_buf); +@@ -939,18 +1111,18 @@ int ZEXPORT deflateCopy (dest, source) + ushf *overlay; + + +- if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { ++ if (deflateStateCheck(source) || dest == Z_NULL) { + return Z_STREAM_ERROR; + } + + ss = source->state; + +- zmemcpy(dest, source, sizeof(z_stream)); ++ zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + + ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); + if (ds == Z_NULL) return Z_MEM_ERROR; + dest->state = (struct internal_state FAR *) ds; +- zmemcpy(ds, ss, sizeof(deflate_state)); ++ zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state)); + ds->strm = dest; + + ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); +@@ -966,8 +1138,8 @@ int ZEXPORT deflateCopy (dest, source) + } + /* following zmemcpy do not work for 16-bit MSDOS */ + zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); +- zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); +- zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); ++ zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); ++ zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos)); + zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); + + ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); +@@ -989,7 +1161,7 @@ int ZEXPORT deflateCopy (dest, source) + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +-local int read_buf(strm, buf, size) ++local unsigned read_buf(strm, buf, size) + z_streamp strm; + Bytef *buf; + unsigned size; +@@ -1001,19 +1173,19 @@ local int read_buf(strm, buf, size) + + strm->avail_in -= len; + ++ zmemcpy(buf, strm->next_in, len); + if (strm->state->wrap == 1) { +- strm->adler = adler32(strm->adler, strm->next_in, len); ++ strm->adler = adler32(strm->adler, buf, len); + } + #ifdef GZIP + else if (strm->state->wrap == 2) { +- strm->adler = crc32(strm->adler, strm->next_in, len); ++ strm->adler = crc32(strm->adler, buf, len); + } + #endif +- zmemcpy(buf, strm->next_in, len); + strm->next_in += len; + strm->total_in += len; + +- return (int)len; ++ return len; + } + + /* =========================================================================== +@@ -1036,6 +1208,7 @@ local void lm_init (s) + s->strstart = 0; + s->block_start = 0L; + s->lookahead = 0; ++ s->insert = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + s->ins_h = 0; +@@ -1066,9 +1239,9 @@ local uInt longest_match(s, cur_match) + { + unsigned chain_length = s->max_chain_length;/* max hash chain length */ + register Bytef *scan = s->window + s->strstart; /* current string */ +- register Bytef *match; /* matched string */ ++ register Bytef *match; /* matched string */ + register int len; /* length of current match */ +- int best_len = s->prev_length; /* best match length so far */ ++ int best_len = (int)s->prev_length; /* best match length so far */ + int nice_match = s->nice_match; /* stop if match long enough */ + IPos limit = s->strstart > (IPos)MAX_DIST(s) ? + s->strstart - (IPos)MAX_DIST(s) : NIL; +@@ -1103,7 +1276,7 @@ local uInt longest_match(s, cur_match) + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ +- if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; ++ if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead; + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + +@@ -1264,7 +1437,11 @@ local uInt longest_match(s, cur_match) + + #endif /* FASTEST */ + +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG ++ ++#define EQUAL 0 ++/* result of memcmp for equal strings */ ++ + /* =========================================================================== + * Check that the match at match_start is indeed a match. + */ +@@ -1290,7 +1467,7 @@ local void check_match(s, start, match, length) + } + #else + # define check_match(s, start, match, length) +-#endif /* DEBUG_ZLIB */ ++#endif /* ZLIB_DEBUG */ + + /* =========================================================================== + * Fill the window when the lookahead becomes insufficient. +@@ -1305,11 +1482,12 @@ local void check_match(s, start, match, length) + local void fill_window(s) + deflate_state *s; + { +- register unsigned n, m; +- register Posf *p; ++ unsigned n; + unsigned more; /* Amount of free space at the end of the window. */ + uInt wsize = s->w_size; + ++ Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); ++ + do { + more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + +@@ -1331,38 +1509,14 @@ local void fill_window(s) + */ + if (s->strstart >= wsize+MAX_DIST(s)) { + +- zmemcpy(s->window, s->window+wsize, (unsigned)wsize); ++ zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more); + s->match_start -= wsize; + s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ + s->block_start -= (long) wsize; +- +- /* Slide the hash table (could be avoided with 32 bit values +- at the expense of memory usage). We slide even when level == 0 +- to keep the hash table consistent if we switch back to level > 0 +- later. (Using level 0 permanently is not an optimal usage of +- zlib, so we don't care about this pathological case.) +- */ +- n = s->hash_size; +- p = &s->head[n]; +- do { +- m = *--p; +- *p = (Pos)(m >= wsize ? m-wsize : NIL); +- } while (--n); +- +- n = wsize; +-#ifndef FASTEST +- p = &s->prev[n]; +- do { +- m = *--p; +- *p = (Pos)(m >= wsize ? m-wsize : NIL); +- /* If n is not on any hash chain, prev[n] is garbage but +- * its value will never be used. +- */ +- } while (--n); +-#endif ++ slide_hash(s); + more += wsize; + } +- if (s->strm->avail_in == 0) return; ++ if (s->strm->avail_in == 0) break; + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && +@@ -1381,12 +1535,24 @@ local void fill_window(s) + s->lookahead += n; + + /* Initialize the hash value now that we have some input: */ +- if (s->lookahead >= MIN_MATCH) { +- s->ins_h = s->window[s->strstart]; +- UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); ++ if (s->lookahead + s->insert >= MIN_MATCH) { ++ uInt str = s->strstart - s->insert; ++ s->ins_h = s->window[str]; ++ UPDATE_HASH(s, s->ins_h, s->window[str + 1]); + #if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times + #endif ++ while (s->insert) { ++ UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); ++#ifndef FASTEST ++ s->prev[str & s->w_mask] = s->head[s->ins_h]; ++#endif ++ s->head[s->ins_h] = (Pos)str; ++ str++; ++ s->insert--; ++ if (s->lookahead + s->insert < MIN_MATCH) ++ break; ++ } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. +@@ -1427,6 +1593,9 @@ local void fill_window(s) + s->high_water += init; + } + } ++ ++ Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, ++ "not enough room for search"); + } + + /* =========================================================================== +@@ -1450,64 +1619,199 @@ local void fill_window(s) + if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ + } + ++/* Maximum stored block length in deflate format (not including header). */ ++#define MAX_STORED 65535 ++ ++/* Minimum of a and b. */ ++#define MIN(a, b) ((a) > (b) ? (b) : (a)) ++ + /* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. +- * This function does not insert new strings in the dictionary since +- * uncompressible data is probably not useful. This function is used +- * only for the level=0 compression option. +- * NOTE: this function should be optimized to avoid extra copying from +- * window to pending_buf. ++ * ++ * In case deflateParams() is used to later switch to a non-zero compression ++ * level, s->matches (otherwise unused when storing) keeps track of the number ++ * of hash table slides to perform. If s->matches is 1, then one hash table ++ * slide will be done when switching. If s->matches is 2, the maximum value ++ * allowed here, then the hash table will be cleared, since two or more slides ++ * is the same as a clear. ++ * ++ * deflate_stored() is written to minimize the number of times an input byte is ++ * copied. It is most efficient with large input and output buffers, which ++ * maximizes the opportunites to have a single copy from next_in to next_out. + */ + local block_state deflate_stored(s, flush) + deflate_state *s; + int flush; + { +- /* Stored blocks are limited to 0xffff bytes, pending_buf is limited +- * to pending_buf_size, and each stored block has a 5 byte header: ++ /* Smallest worthy block size when not flushing or finishing. By default ++ * this is 32K. This can be as small as 507 bytes for memLevel == 1. For ++ * large input and output buffers, the stored block size will be larger. + */ +- ulg max_block_size = 0xffff; +- ulg max_start; ++ unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size); + +- if (max_block_size > s->pending_buf_size - 5) { +- max_block_size = s->pending_buf_size - 5; +- } +- +- /* Copy as much as possible from input to output: */ +- for (;;) { +- /* Fill the window as much as possible: */ +- if (s->lookahead <= 1) { +- +- Assert(s->strstart < s->w_size+MAX_DIST(s) || +- s->block_start >= (long)s->w_size, "slide too late"); ++ /* Copy as many min_block or larger stored blocks directly to next_out as ++ * possible. If flushing, copy the remaining available input to next_out as ++ * stored blocks, if there is enough space. ++ */ ++ unsigned len, left, have, last = 0; ++ unsigned used = s->strm->avail_in; ++ do { ++ /* Set len to the maximum size block that we can copy directly with the ++ * available input data and output space. Set left to how much of that ++ * would be copied from what's left in the window. ++ */ ++ len = MAX_STORED; /* maximum deflate stored block length */ ++ have = (s->bi_valid + 42) >> 3; /* number of header bytes */ ++ if (s->strm->avail_out < have) /* need room for header */ ++ break; ++ /* maximum stored block length that will fit in avail_out: */ ++ have = s->strm->avail_out - have; ++ left = s->strstart - s->block_start; /* bytes left in window */ ++ if (len > (ulg)left + s->strm->avail_in) ++ len = left + s->strm->avail_in; /* limit len to the input */ ++ if (len > have) ++ len = have; /* limit len to the output */ ++ ++ /* If the stored block would be less than min_block in length, or if ++ * unable to copy all of the available input when flushing, then try ++ * copying to the window and the pending buffer instead. Also don't ++ * write an empty block when flushing -- deflate() does that. ++ */ ++ if (len < min_block && ((len == 0 && flush != Z_FINISH) || ++ flush == Z_NO_FLUSH || ++ len != left + s->strm->avail_in)) ++ break; + +- fill_window(s); +- if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; ++ /* Make a dummy stored block in pending to get the header bytes, ++ * including any pending bits. This also updates the debugging counts. ++ */ ++ last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0; ++ _tr_stored_block(s, (char *)0, 0L, last); ++ ++ /* Replace the lengths in the dummy stored block with len. */ ++ s->pending_buf[s->pending - 4] = len; ++ s->pending_buf[s->pending - 3] = len >> 8; ++ s->pending_buf[s->pending - 2] = ~len; ++ s->pending_buf[s->pending - 1] = ~len >> 8; ++ ++ /* Write the stored block header bytes. */ ++ flush_pending(s->strm); ++ ++#ifdef ZLIB_DEBUG ++ /* Update debugging counts for the data about to be copied. */ ++ s->compressed_len += len << 3; ++ s->bits_sent += len << 3; ++#endif + +- if (s->lookahead == 0) break; /* flush the current block */ ++ /* Copy uncompressed bytes from the window to next_out. */ ++ if (left) { ++ if (left > len) ++ left = len; ++ zmemcpy(s->strm->next_out, s->window + s->block_start, left); ++ s->strm->next_out += left; ++ s->strm->avail_out -= left; ++ s->strm->total_out += left; ++ s->block_start += left; ++ len -= left; + } +- Assert(s->block_start >= 0L, "block gone"); +- +- s->strstart += s->lookahead; +- s->lookahead = 0; +- +- /* Emit a stored block if pending_buf will be full: */ +- max_start = s->block_start + max_block_size; +- if (s->strstart == 0 || (ulg)s->strstart >= max_start) { +- /* strstart == 0 is possible when wraparound on 16-bit machine */ +- s->lookahead = (uInt)(s->strstart - max_start); +- s->strstart = (uInt)max_start; +- FLUSH_BLOCK(s, 0); ++ ++ /* Copy uncompressed bytes directly from next_in to next_out, updating ++ * the check value. ++ */ ++ if (len) { ++ read_buf(s->strm, s->strm->next_out, len); ++ s->strm->next_out += len; ++ s->strm->avail_out -= len; ++ s->strm->total_out += len; + } +- /* Flush if we may have to slide, otherwise block_start may become +- * negative and the data will be gone: ++ } while (last == 0); ++ ++ /* Update the sliding window with the last s->w_size bytes of the copied ++ * data, or append all of the copied data to the existing window if less ++ * than s->w_size bytes were copied. Also update the number of bytes to ++ * insert in the hash tables, in the event that deflateParams() switches to ++ * a non-zero compression level. ++ */ ++ used -= s->strm->avail_in; /* number of input bytes directly copied */ ++ if (used) { ++ /* If any input was used, then no unused input remains in the window, ++ * therefore s->block_start == s->strstart. + */ +- if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { +- FLUSH_BLOCK(s, 0); ++ if (used >= s->w_size) { /* supplant the previous history */ ++ s->matches = 2; /* clear hash */ ++ zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size); ++ s->strstart = s->w_size; ++ } ++ else { ++ if (s->window_size - s->strstart <= used) { ++ /* Slide the window down. */ ++ s->strstart -= s->w_size; ++ zmemcpy(s->window, s->window + s->w_size, s->strstart); ++ if (s->matches < 2) ++ s->matches++; /* add a pending slide_hash() */ ++ } ++ zmemcpy(s->window + s->strstart, s->strm->next_in - used, used); ++ s->strstart += used; + } ++ s->block_start = s->strstart; ++ s->insert += MIN(used, s->w_size - s->insert); ++ } ++ if (s->high_water < s->strstart) ++ s->high_water = s->strstart; ++ ++ /* If the last block was written to next_out, then done. */ ++ if (last) ++ return finish_done; ++ ++ /* If flushing and all input has been consumed, then done. */ ++ if (flush != Z_NO_FLUSH && flush != Z_FINISH && ++ s->strm->avail_in == 0 && (long)s->strstart == s->block_start) ++ return block_done; ++ ++ /* Fill the window with any remaining input. */ ++ have = s->window_size - s->strstart - 1; ++ if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) { ++ /* Slide the window down. */ ++ s->block_start -= s->w_size; ++ s->strstart -= s->w_size; ++ zmemcpy(s->window, s->window + s->w_size, s->strstart); ++ if (s->matches < 2) ++ s->matches++; /* add a pending slide_hash() */ ++ have += s->w_size; /* more space now */ ++ } ++ if (have > s->strm->avail_in) ++ have = s->strm->avail_in; ++ if (have) { ++ read_buf(s->strm, s->window + s->strstart, have); ++ s->strstart += have; ++ } ++ if (s->high_water < s->strstart) ++ s->high_water = s->strstart; ++ ++ /* There was not enough avail_out to write a complete worthy or flushed ++ * stored block to next_out. Write a stored block to pending instead, if we ++ * have enough input for a worthy block, or if flushing and there is enough ++ * room for the remaining input as a stored block in the pending buffer. ++ */ ++ have = (s->bi_valid + 42) >> 3; /* number of header bytes */ ++ /* maximum stored block length that will fit in pending: */ ++ have = MIN(s->pending_buf_size - have, MAX_STORED); ++ min_block = MIN(have, s->w_size); ++ left = s->strstart - s->block_start; ++ if (left >= min_block || ++ ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH && ++ s->strm->avail_in == 0 && left <= have)) { ++ len = MIN(left, have); ++ last = flush == Z_FINISH && s->strm->avail_in == 0 && ++ len == left ? 1 : 0; ++ _tr_stored_block(s, (charf *)s->window + s->block_start, len, last); ++ s->block_start += len; ++ flush_pending(s->strm); + } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; ++ ++ /* We've done all we can with the available input and output. */ ++ return last ? finish_started : need_more; + } + + /* =========================================================================== +@@ -1603,8 +1907,14 @@ local block_state deflate_fast(s, flush) + } + if (bflush) FLUSH_BLOCK(s, 0); + } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; ++ s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; ++ if (flush == Z_FINISH) { ++ FLUSH_BLOCK(s, 1); ++ return finish_done; ++ } ++ if (s->last_lit) ++ FLUSH_BLOCK(s, 0); ++ return block_done; + } + + #ifndef FASTEST +@@ -1728,8 +2038,14 @@ local block_state deflate_slow(s, flush) + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + s->match_available = 0; + } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; ++ s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; ++ if (flush == Z_FINISH) { ++ FLUSH_BLOCK(s, 1); ++ return finish_done; ++ } ++ if (s->last_lit) ++ FLUSH_BLOCK(s, 0); ++ return block_done; + } + #endif /* FASTEST */ + +@@ -1749,11 +2065,11 @@ local block_state deflate_rle(s, flush) + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes +- * for the longest encodable run. ++ * for the longest run, plus one for the unrolled loop. + */ +- if (s->lookahead < MAX_MATCH) { ++ if (s->lookahead <= MAX_MATCH) { + fill_window(s); +- if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { ++ if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ +@@ -1772,10 +2088,11 @@ local block_state deflate_rle(s, flush) + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + scan < strend); +- s->match_length = MAX_MATCH - (int)(strend - scan); ++ s->match_length = MAX_MATCH - (uInt)(strend - scan); + if (s->match_length > s->lookahead) + s->match_length = s->lookahead; + } ++ Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ +@@ -1796,8 +2113,14 @@ local block_state deflate_rle(s, flush) + } + if (bflush) FLUSH_BLOCK(s, 0); + } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; ++ s->insert = 0; ++ if (flush == Z_FINISH) { ++ FLUSH_BLOCK(s, 1); ++ return finish_done; ++ } ++ if (s->last_lit) ++ FLUSH_BLOCK(s, 0); ++ return block_done; + } + + /* =========================================================================== +@@ -1829,6 +2152,12 @@ local block_state deflate_huff(s, flush) + s->strstart++; + if (bflush) FLUSH_BLOCK(s, 0); + } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; ++ s->insert = 0; ++ if (flush == Z_FINISH) { ++ FLUSH_BLOCK(s, 1); ++ return finish_done; ++ } ++ if (s->last_lit) ++ FLUSH_BLOCK(s, 0); ++ return block_done; + } +diff --git a/com32/lib/zlib/deflate.h b/com32/lib/zlib/deflate.h +index 09cf4c49..23ecdd31 100644 +--- a/com32/lib/zlib/deflate.h ++++ b/com32/lib/zlib/deflate.h +@@ -1,5 +1,5 @@ + /* deflate.h -- internal compression state +- * Copyright (C) 1995-2010 Jean-loup Gailly ++ * Copyright (C) 1995-2016 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -48,13 +48,19 @@ + #define MAX_BITS 15 + /* All codes must not exceed MAX_BITS bits */ + +-#define INIT_STATE 42 +-#define EXTRA_STATE 69 +-#define NAME_STATE 73 +-#define COMMENT_STATE 91 +-#define HCRC_STATE 103 +-#define BUSY_STATE 113 +-#define FINISH_STATE 666 ++#define Buf_size 16 ++/* size of bit buffer in bi_buf */ ++ ++#define INIT_STATE 42 /* zlib header -> BUSY_STATE */ ++#ifdef GZIP ++# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */ ++#endif ++#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */ ++#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */ ++#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */ ++#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */ ++#define BUSY_STATE 113 /* deflate -> FINISH_STATE */ ++#define FINISH_STATE 666 /* stream complete */ + /* Stream status */ + + +@@ -80,7 +86,7 @@ typedef 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 */ ++ const static_tree_desc *stat_desc; /* the corresponding static tree */ + } FAR tree_desc; + + typedef ush Pos; +@@ -97,11 +103,11 @@ typedef struct internal_state { + 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 */ +- uInt pending; /* nb of bytes in the pending buffer */ ++ ulg pending; /* nb of bytes in the pending buffer */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + gz_headerp gzhead; /* gzip header information to write */ +- uInt gzindex; /* where in extra, name, or comment */ +- Byte method; /* STORED (for zip only) or DEFLATED */ ++ ulg gzindex; /* where in extra, name, or comment */ ++ Byte method; /* can only be DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ +@@ -188,7 +194,7 @@ typedef struct internal_state { + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ +- /* Didn't use ct_data typedef below to supress compiler warning */ ++ /* Didn't use ct_data typedef below to suppress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ +@@ -244,9 +250,9 @@ typedef struct internal_state { + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ +- int last_eob_len; /* bit length of EOB code for last block */ ++ uInt insert; /* bytes at end of window left to insert */ + +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ + #endif +@@ -272,7 +278,7 @@ typedef struct internal_state { + /* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} ++#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);} + + + #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +@@ -294,6 +300,7 @@ void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); + int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); + void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); ++void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); + void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); + void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); +@@ -305,7 +312,7 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, + * used. + */ + +-#ifndef DEBUG_ZLIB ++#ifndef ZLIB_DEBUG + /* Inline versions of _tr_tally for speed: */ + + #if defined(GEN_TREES_H) || !defined(STDC) +@@ -324,8 +331,8 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, + flush = (s->last_lit == s->lit_bufsize-1); \ + } + # define _tr_tally_dist(s, distance, length, flush) \ +- { uch len = (length); \ +- ush dist = (distance); \ ++ { uch len = (uch)(length); \ ++ ush dist = (ush)(distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ +diff --git a/com32/lib/zlib/infback.c b/com32/lib/zlib/infback.c +index af3a8c96..59679ecb 100644 +--- a/com32/lib/zlib/infback.c ++++ b/com32/lib/zlib/infback.c +@@ -1,5 +1,5 @@ + /* infback.c -- inflate using a call-back interface +- * Copyright (C) 1995-2009 Mark Adler ++ * Copyright (C) 1995-2016 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -42,17 +42,26 @@ int stream_size; + return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { ++#ifdef Z_SOLO ++ return Z_STREAM_ERROR; ++#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; ++#endif + } +- if (strm->zfree == (free_func)0) strm->zfree = zcfree; ++ if (strm->zfree == (free_func)0) ++#ifdef Z_SOLO ++ return Z_STREAM_ERROR; ++#else ++ strm->zfree = zcfree; ++#endif + state = (struct inflate_state FAR *)ZALLOC(strm, 1, + sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; + state->dmax = 32768U; +- state->wbits = windowBits; ++ state->wbits = (uInt)windowBits; + state->wsize = 1U << windowBits; + state->window = window; + state->wnext = 0; +@@ -246,7 +255,7 @@ out_func out; + void FAR *out_desc; + { + struct inflate_state FAR *state; +- unsigned char FAR *next; /* next input */ ++ z_const unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned long hold; /* bit buffer */ +@@ -394,7 +403,6 @@ void FAR *out_desc; + PULLBYTE(); + } + if (here.val < 16) { +- NEEDBITS(here.bits); + DROPBITS(here.bits); + state->lens[state->have++] = here.val; + } +diff --git a/com32/lib/zlib/inffast.c b/com32/lib/zlib/inffast.c +index 2f1d60b4..0dbd1dbc 100644 +--- a/com32/lib/zlib/inffast.c ++++ b/com32/lib/zlib/inffast.c +@@ -1,5 +1,5 @@ + /* inffast.c -- fast decoding +- * Copyright (C) 1995-2008, 2010 Mark Adler ++ * Copyright (C) 1995-2017 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -8,26 +8,9 @@ + #include "inflate.h" + #include "inffast.h" + +-#ifndef ASMINF +- +-/* Allow machine dependent optimization for post-increment or pre-increment. +- Based on testing to date, +- Pre-increment preferred for: +- - PowerPC G3 (Adler) +- - MIPS R5000 (Randers-Pehrson) +- Post-increment preferred for: +- - none +- No measurable difference: +- - Pentium III (Anderson) +- - M68060 (Nikl) +- */ +-#ifdef POSTINC +-# define OFF 0 +-# define PUP(a) *(a)++ ++#ifdef ASMINF ++# pragma message("Assembler code may have bugs -- use at your own risk") + #else +-# define OFF 1 +-# define PUP(a) *++(a) +-#endif + + /* + Decode literal, length, and distance codes and write out the resulting +@@ -69,8 +52,8 @@ z_streamp strm; + unsigned start; /* inflate()'s starting value for strm->avail_out */ + { + struct inflate_state FAR *state; +- unsigned char FAR *in; /* local strm->next_in */ +- unsigned char FAR *last; /* while in < last, enough input available */ ++ z_const unsigned char FAR *in; /* local strm->next_in */ ++ z_const unsigned char FAR *last; /* have enough input while in < last */ + unsigned char FAR *out; /* local strm->next_out */ + unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ + unsigned char FAR *end; /* while out < end, enough space available */ +@@ -96,9 +79,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + + /* copy state to local variables */ + state = (struct inflate_state FAR *)strm->state; +- in = strm->next_in - OFF; ++ in = strm->next_in; + last = in + (strm->avail_in - 5); +- out = strm->next_out - OFF; ++ out = strm->next_out; + beg = out - (start - strm->avail_out); + end = out + (strm->avail_out - 257); + #ifdef INFLATE_STRICT +@@ -119,9 +102,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + input data or output space */ + do { + if (bits < 15) { +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; + } + here = lcode[hold & lmask]; +@@ -134,14 +117,14 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); +- PUP(out) = (unsigned char)(here.val); ++ *out++ = (unsigned char)(here.val); + } + else if (op & 16) { /* length base */ + len = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; + } + len += (unsigned)hold & ((1U << op) - 1); +@@ -150,9 +133,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + } + Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; + } + here = dcode[hold & dmask]; +@@ -165,10 +148,10 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + dist = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (bits < op) { +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; + if (bits < op) { +- hold += (unsigned long)(PUP(in)) << bits; ++ hold += (unsigned long)(*in++) << bits; + bits += 8; + } + } +@@ -196,30 +179,30 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + if (len <= op - whave) { + do { +- PUP(out) = 0; ++ *out++ = 0; + } while (--len); + continue; + } + len -= op - whave; + do { +- PUP(out) = 0; ++ *out++ = 0; + } while (--op > whave); + if (op == 0) { + from = out - dist; + do { +- PUP(out) = PUP(from); ++ *out++ = *from++; + } while (--len); + continue; + } + #endif + } +- from = window - OFF; ++ from = window; + if (wnext == 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { +- PUP(out) = PUP(from); ++ *out++ = *from++; + } while (--op); + from = out - dist; /* rest from output */ + } +@@ -230,14 +213,14 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + if (op < len) { /* some from end of window */ + len -= op; + do { +- PUP(out) = PUP(from); ++ *out++ = *from++; + } while (--op); +- from = window - OFF; ++ from = window; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { +- PUP(out) = PUP(from); ++ *out++ = *from++; + } while (--op); + from = out - dist; /* rest from output */ + } +@@ -248,35 +231,35 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + if (op < len) { /* some from window */ + len -= op; + do { +- PUP(out) = PUP(from); ++ *out++ = *from++; + } while (--op); + from = out - dist; /* rest from output */ + } + } + while (len > 2) { +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); ++ *out++ = *from++; ++ *out++ = *from++; ++ *out++ = *from++; + len -= 3; + } + if (len) { +- PUP(out) = PUP(from); ++ *out++ = *from++; + if (len > 1) +- PUP(out) = PUP(from); ++ *out++ = *from++; + } + } + else { + from = out - dist; /* copy direct from output */ + do { /* minimum length is three */ +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); ++ *out++ = *from++; ++ *out++ = *from++; ++ *out++ = *from++; + len -= 3; + } while (len > 2); + if (len) { +- PUP(out) = PUP(from); ++ *out++ = *from++; + if (len > 1) +- PUP(out) = PUP(from); ++ *out++ = *from++; + } + } + } +@@ -313,8 +296,8 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ + hold &= (1U << bits) - 1; + + /* update state and return */ +- strm->next_in = in + OFF; +- strm->next_out = out + OFF; ++ strm->next_in = in; ++ strm->next_out = out; + strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); + strm->avail_out = (unsigned)(out < end ? + 257 + (end - out) : 257 - (out - end)); +diff --git a/com32/lib/zlib/inffixed.h b/com32/lib/zlib/inffixed.h +index 75ed4b59..d6283277 100644 +--- a/com32/lib/zlib/inffixed.h ++++ b/com32/lib/zlib/inffixed.h +@@ -2,9 +2,9 @@ + * Generated automatically by makefixed(). + */ + +- /* 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. ++ /* WARNING: this file should *not* be used by applications. ++ It is part of the implementation of this library and is ++ subject to change. Applications should only use zlib.h. + */ + + static const code lenfix[512] = { +diff --git a/com32/lib/zlib/inflate.c b/com32/lib/zlib/inflate.c +index a8431abe..ac333e8c 100644 +--- a/com32/lib/zlib/inflate.c ++++ b/com32/lib/zlib/inflate.c +@@ -1,5 +1,5 @@ + /* inflate.c -- zlib decompression +- * Copyright (C) 1995-2010 Mark Adler ++ * Copyright (C) 1995-2016 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -92,32 +92,46 @@ + #endif + + /* function prototypes */ ++local int inflateStateCheck OF((z_streamp strm)); + local void fixedtables OF((struct inflate_state FAR *state)); +-local int updatewindow OF((z_streamp strm, unsigned out)); ++local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, ++ unsigned copy)); + #ifdef BUILDFIXED + void makefixed OF((void)); + #endif +-local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, ++local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, + unsigned len)); + +-int ZEXPORT inflateReset(strm) ++local int inflateStateCheck(strm) ++z_streamp strm; ++{ ++ struct inflate_state FAR *state; ++ if (strm == Z_NULL || ++ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) ++ return 1; ++ state = (struct inflate_state FAR *)strm->state; ++ if (state == Z_NULL || state->strm != strm || ++ state->mode < HEAD || state->mode > SYNC) ++ return 1; ++ return 0; ++} ++ ++int ZEXPORT inflateResetKeep(strm) + z_streamp strm; + { + struct inflate_state FAR *state; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + strm->total_in = strm->total_out = state->total = 0; + strm->msg = Z_NULL; +- strm->adler = 1; /* to support ill-conceived Java test suite */ ++ if (state->wrap) /* to support ill-conceived Java test suite */ ++ strm->adler = state->wrap & 1; + state->mode = HEAD; + state->last = 0; + state->havedict = 0; + state->dmax = 32768U; + state->head = Z_NULL; +- state->wsize = 0; +- state->whave = 0; +- state->wnext = 0; + state->hold = 0; + state->bits = 0; + state->lencode = state->distcode = state->next = state->codes; +@@ -127,6 +141,19 @@ z_streamp strm; + return Z_OK; + } + ++int ZEXPORT inflateReset(strm) ++z_streamp strm; ++{ ++ struct inflate_state FAR *state; ++ ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; ++ state = (struct inflate_state FAR *)strm->state; ++ state->wsize = 0; ++ state->whave = 0; ++ state->wnext = 0; ++ return inflateResetKeep(strm); ++} ++ + int ZEXPORT inflateReset2(strm, windowBits) + z_streamp strm; + int windowBits; +@@ -135,7 +162,7 @@ int windowBits; + struct inflate_state FAR *state; + + /* get the state */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + + /* extract wrap request from windowBits parameter */ +@@ -144,7 +171,7 @@ int windowBits; + windowBits = -windowBits; + } + else { +- wrap = (windowBits >> 4) + 1; ++ wrap = (windowBits >> 4) + 5; + #ifdef GUNZIP + if (windowBits < 48) + windowBits &= 15; +@@ -180,16 +207,27 @@ int stream_size; + if (strm == Z_NULL) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { ++#ifdef Z_SOLO ++ return Z_STREAM_ERROR; ++#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; ++#endif + } +- if (strm->zfree == (free_func)0) strm->zfree = zcfree; ++ if (strm->zfree == (free_func)0) ++#ifdef Z_SOLO ++ return Z_STREAM_ERROR; ++#else ++ strm->zfree = zcfree; ++#endif + state = (struct inflate_state FAR *) + ZALLOC(strm, 1, sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; ++ state->strm = strm; + state->window = Z_NULL; ++ state->mode = HEAD; /* to pass state test in inflateReset2() */ + ret = inflateReset2(strm, windowBits); + if (ret != Z_OK) { + ZFREE(strm, state); +@@ -213,17 +251,17 @@ int value; + { + struct inflate_state FAR *state; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (bits < 0) { + state->hold = 0; + state->bits = 0; + return Z_OK; + } +- if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; ++ if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR; + value &= (1L << bits) - 1; +- state->hold += value << state->bits; +- state->bits += bits; ++ state->hold += (unsigned)value << state->bits; ++ state->bits += (uInt)bits; + return Z_OK; + } + +@@ -321,8 +359,8 @@ void makefixed() + low = 0; + for (;;) { + if ((low % 7) == 0) printf("\n "); +- printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, +- state.lencode[low].val); ++ printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, ++ state.lencode[low].bits, state.lencode[low].val); + if (++low == size) break; + putchar(','); + } +@@ -355,12 +393,13 @@ void makefixed() + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +-local int updatewindow(strm, out) ++local int updatewindow(strm, end, copy) + z_streamp strm; +-unsigned out; ++const Bytef *end; ++unsigned copy; + { + struct inflate_state FAR *state; +- unsigned copy, dist; ++ unsigned dist; + + state = (struct inflate_state FAR *)strm->state; + +@@ -380,19 +419,18 @@ unsigned out; + } + + /* copy state->wsize or less output bytes into the circular window */ +- copy = out - strm->avail_out; + if (copy >= state->wsize) { +- zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); ++ zmemcpy(state->window, end - state->wsize, state->wsize); + state->wnext = 0; + state->whave = state->wsize; + } + else { + dist = state->wsize - state->wnext; + if (dist > copy) dist = copy; +- zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); ++ zmemcpy(state->window + state->wnext, end - copy, dist); + copy -= dist; + if (copy) { +- zmemcpy(state->window, strm->next_out - copy, copy); ++ zmemcpy(state->window, end - copy, copy); + state->wnext = copy; + state->whave = state->wsize; + } +@@ -499,11 +537,6 @@ unsigned out; + bits -= bits & 7; \ + } while (0) + +-/* Reverse the bytes in a 32-bit value */ +-#define REVERSE(q) \ +- ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ +- (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) +- + /* + inflate() uses a state machine to process as much input data and generate as + much output data as possible before returning. The state machine is +@@ -591,7 +624,7 @@ z_streamp strm; + int flush; + { + struct inflate_state FAR *state; +- unsigned char FAR *next; /* next input */ ++ z_const unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned long hold; /* bit buffer */ +@@ -609,7 +642,7 @@ int flush; + static const unsigned short order[19] = /* permutation of code lengths */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + +- if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || ++ if (inflateStateCheck(strm) || strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0)) + return Z_STREAM_ERROR; + +@@ -629,6 +662,8 @@ int flush; + NEEDBITS(16); + #ifdef GUNZIP + if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ ++ if (state->wbits == 0) ++ state->wbits = 15; + state->check = crc32(0L, Z_NULL, 0); + CRC2(state->check, hold); + INITBITS(); +@@ -656,7 +691,7 @@ int flush; + len = BITS(4) + 8; + if (state->wbits == 0) + state->wbits = len; +- else if (len > state->wbits) { ++ if (len > 15 || len > state->wbits) { + strm->msg = (char *)"invalid window size"; + state->mode = BAD; + break; +@@ -683,14 +718,16 @@ int flush; + } + if (state->head != Z_NULL) + state->head->text = (int)((hold >> 8) & 1); +- if (state->flags & 0x0200) CRC2(state->check, hold); ++ if ((state->flags & 0x0200) && (state->wrap & 4)) ++ CRC2(state->check, hold); + INITBITS(); + state->mode = TIME; + case TIME: + NEEDBITS(32); + if (state->head != Z_NULL) + state->head->time = hold; +- if (state->flags & 0x0200) CRC4(state->check, hold); ++ if ((state->flags & 0x0200) && (state->wrap & 4)) ++ CRC4(state->check, hold); + INITBITS(); + state->mode = OS; + case OS: +@@ -699,7 +736,8 @@ int flush; + state->head->xflags = (int)(hold & 0xff); + state->head->os = (int)(hold >> 8); + } +- if (state->flags & 0x0200) CRC2(state->check, hold); ++ if ((state->flags & 0x0200) && (state->wrap & 4)) ++ CRC2(state->check, hold); + INITBITS(); + state->mode = EXLEN; + case EXLEN: +@@ -708,7 +746,8 @@ int flush; + state->length = (unsigned)(hold); + if (state->head != Z_NULL) + state->head->extra_len = (unsigned)hold; +- if (state->flags & 0x0200) CRC2(state->check, hold); ++ if ((state->flags & 0x0200) && (state->wrap & 4)) ++ CRC2(state->check, hold); + INITBITS(); + } + else if (state->head != Z_NULL) +@@ -726,7 +765,7 @@ int flush; + len + copy > state->head->extra_max ? + state->head->extra_max - len : copy); + } +- if (state->flags & 0x0200) ++ if ((state->flags & 0x0200) && (state->wrap & 4)) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; +@@ -745,9 +784,9 @@ int flush; + if (state->head != Z_NULL && + state->head->name != Z_NULL && + state->length < state->head->name_max) +- state->head->name[state->length++] = len; ++ state->head->name[state->length++] = (Bytef)len; + } while (len && copy < have); +- if (state->flags & 0x0200) ++ if ((state->flags & 0x0200) && (state->wrap & 4)) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; +@@ -766,9 +805,9 @@ int flush; + if (state->head != Z_NULL && + state->head->comment != Z_NULL && + state->length < state->head->comm_max) +- state->head->comment[state->length++] = len; ++ state->head->comment[state->length++] = (Bytef)len; + } while (len && copy < have); +- if (state->flags & 0x0200) ++ if ((state->flags & 0x0200) && (state->wrap & 4)) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; +@@ -780,7 +819,7 @@ int flush; + case HCRC: + if (state->flags & 0x0200) { + NEEDBITS(16); +- if (hold != (state->check & 0xffff)) { ++ if ((state->wrap & 4) && hold != (state->check & 0xffff)) { + strm->msg = (char *)"header crc mismatch"; + state->mode = BAD; + break; +@@ -797,7 +836,7 @@ int flush; + #endif + case DICTID: + NEEDBITS(32); +- strm->adler = state->check = REVERSE(hold); ++ strm->adler = state->check = ZSWAP32(hold); + INITBITS(); + state->mode = DICT; + case DICT: +@@ -905,7 +944,7 @@ int flush; + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; +- state->lencode = (code const FAR *)(state->next); ++ state->lencode = (const code FAR *)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); +@@ -925,7 +964,6 @@ int flush; + PULLBYTE(); + } + if (here.val < 16) { +- NEEDBITS(here.bits); + DROPBITS(here.bits); + state->lens[state->have++] = here.val; + } +@@ -980,7 +1018,7 @@ int flush; + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; +- state->lencode = (code const FAR *)(state->next); ++ state->lencode = (const code FAR *)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); +@@ -989,7 +1027,7 @@ int flush; + state->mode = BAD; + break; + } +- state->distcode = (code const FAR *)(state->next); ++ state->distcode = (const code FAR *)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); +@@ -1162,15 +1200,15 @@ int flush; + out -= left; + strm->total_out += out; + state->total += out; +- if (out) ++ if ((state->wrap & 4) && out) + strm->adler = state->check = + UPDATE(state->check, put - out, out); + out = left; +- if (( ++ if ((state->wrap & 4) && ( + #ifdef GUNZIP + state->flags ? hold : + #endif +- REVERSE(hold)) != state->check) { ++ ZSWAP32(hold)) != state->check) { + strm->msg = (char *)"incorrect data check"; + state->mode = BAD; + break; +@@ -1214,8 +1252,9 @@ int flush; + */ + inf_leave: + RESTORE(); +- if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) +- if (updatewindow(strm, out)) { ++ if (state->wsize || (out != strm->avail_out && state->mode < BAD && ++ (state->mode < CHECK || flush != Z_FINISH))) ++ if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { + state->mode = MEM; + return Z_MEM_ERROR; + } +@@ -1224,10 +1263,10 @@ int flush; + strm->total_in += in; + strm->total_out += out; + state->total += out; +- if (state->wrap && out) ++ if ((state->wrap & 4) && out) + strm->adler = state->check = + UPDATE(state->check, strm->next_out - out, out); +- strm->data_type = state->bits + (state->last ? 64 : 0) + ++ strm->data_type = (int)state->bits + (state->last ? 64 : 0) + + (state->mode == TYPE ? 128 : 0) + + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); + if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) +@@ -1239,7 +1278,7 @@ int ZEXPORT inflateEnd(strm) + z_streamp strm; + { + struct inflate_state FAR *state; +- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) ++ if (inflateStateCheck(strm)) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->window != Z_NULL) ZFREE(strm, state->window); +@@ -1249,43 +1288,59 @@ z_streamp strm; + return Z_OK; + } + ++int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) ++z_streamp strm; ++Bytef *dictionary; ++uInt *dictLength; ++{ ++ struct inflate_state FAR *state; ++ ++ /* check state */ ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; ++ state = (struct inflate_state FAR *)strm->state; ++ ++ /* copy dictionary */ ++ if (state->whave && dictionary != Z_NULL) { ++ zmemcpy(dictionary, state->window + state->wnext, ++ state->whave - state->wnext); ++ zmemcpy(dictionary + state->whave - state->wnext, ++ state->window, state->wnext); ++ } ++ if (dictLength != Z_NULL) ++ *dictLength = state->whave; ++ return Z_OK; ++} ++ + int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) + z_streamp strm; + const Bytef *dictionary; + uInt dictLength; + { + struct inflate_state FAR *state; +- unsigned long id; ++ unsigned long dictid; ++ int ret; + + /* check state */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->wrap != 0 && state->mode != DICT) + return Z_STREAM_ERROR; + +- /* check for correct dictionary id */ ++ /* check for correct dictionary identifier */ + if (state->mode == DICT) { +- id = adler32(0L, Z_NULL, 0); +- id = adler32(id, dictionary, dictLength); +- if (id != state->check) ++ dictid = adler32(0L, Z_NULL, 0); ++ dictid = adler32(dictid, dictionary, dictLength); ++ if (dictid != state->check) + return Z_DATA_ERROR; + } + +- /* copy dictionary to window */ +- if (updatewindow(strm, strm->avail_out)) { ++ /* copy dictionary to window using updatewindow(), which will amend the ++ existing dictionary if appropriate */ ++ ret = updatewindow(strm, dictionary + dictLength, dictLength); ++ if (ret) { + state->mode = MEM; + return Z_MEM_ERROR; + } +- if (dictLength > state->wsize) { +- zmemcpy(state->window, dictionary + dictLength - state->wsize, +- state->wsize); +- state->whave = state->wsize; +- } +- else { +- zmemcpy(state->window + state->wsize - dictLength, dictionary, +- dictLength); +- state->whave = dictLength; +- } + state->havedict = 1; + Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +@@ -1298,7 +1353,7 @@ gz_headerp head; + struct inflate_state FAR *state; + + /* check state */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; + +@@ -1321,7 +1376,7 @@ gz_headerp head; + */ + local unsigned syncsearch(have, buf, len) + unsigned FAR *have; +-unsigned char FAR *buf; ++const unsigned char FAR *buf; + unsigned len; + { + unsigned got; +@@ -1351,7 +1406,7 @@ z_streamp strm; + struct inflate_state FAR *state; + + /* check parameters */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; + +@@ -1398,7 +1453,7 @@ z_streamp strm; + { + struct inflate_state FAR *state; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + return state->mode == STORED && state->bits == 0; + } +@@ -1413,8 +1468,7 @@ z_streamp source; + unsigned wsize; + + /* check input */ +- if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || +- source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) ++ if (inflateStateCheck(source) || dest == Z_NULL) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)source->state; + +@@ -1433,8 +1487,9 @@ z_streamp source; + } + + /* copy state */ +- zmemcpy(dest, source, sizeof(z_stream)); +- zmemcpy(copy, state, sizeof(struct inflate_state)); ++ zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); ++ zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); ++ copy->strm = dest; + if (state->lencode >= state->codes && + state->lencode <= state->codes + ENOUGH - 1) { + copy->lencode = copy->codes + (state->lencode - state->codes); +@@ -1456,25 +1511,51 @@ int subvert; + { + struct inflate_state FAR *state; + +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; +- state->sane = !subvert; + #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR ++ state->sane = !subvert; + return Z_OK; + #else ++ (void)subvert; + state->sane = 1; + return Z_DATA_ERROR; + #endif + } + ++int ZEXPORT inflateValidate(strm, check) ++z_streamp strm; ++int check; ++{ ++ struct inflate_state FAR *state; ++ ++ if (inflateStateCheck(strm)) return Z_STREAM_ERROR; ++ state = (struct inflate_state FAR *)strm->state; ++ if (check) ++ state->wrap |= 4; ++ else ++ state->wrap &= ~4; ++ return Z_OK; ++} ++ + long ZEXPORT inflateMark(strm) + z_streamp strm; + { + struct inflate_state FAR *state; + +- if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; ++ if (inflateStateCheck(strm)) ++ return -(1L << 16); + state = (struct inflate_state FAR *)strm->state; +- return ((long)(state->back) << 16) + ++ return (long)(((unsigned long)((long)state->back)) << 16) + + (state->mode == COPY ? state->length : + (state->mode == MATCH ? state->was - state->length : 0)); + } ++ ++unsigned long ZEXPORT inflateCodesUsed(strm) ++z_streamp strm; ++{ ++ struct inflate_state FAR *state; ++ if (inflateStateCheck(strm)) return (unsigned long)-1; ++ state = (struct inflate_state FAR *)strm->state; ++ return (unsigned long)(state->next - state->codes); ++} +diff --git a/com32/lib/zlib/inflate.h b/com32/lib/zlib/inflate.h +index 95f4986d..a46cce6b 100644 +--- a/com32/lib/zlib/inflate.h ++++ b/com32/lib/zlib/inflate.h +@@ -1,5 +1,5 @@ + /* inflate.h -- internal inflate state definition +- * Copyright (C) 1995-2009 Mark Adler ++ * Copyright (C) 1995-2016 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -18,7 +18,7 @@ + + /* Possible inflate modes between inflate() calls */ + typedef enum { +- HEAD, /* i: waiting for magic header */ ++ HEAD = 16180, /* i: waiting for magic header */ + FLAGS, /* i: waiting for method and flags (gzip) */ + TIME, /* i: waiting for modification time (gzip) */ + OS, /* i: waiting for extra flags and operating system (gzip) */ +@@ -77,11 +77,14 @@ typedef enum { + CHECK -> LENGTH -> DONE + */ + +-/* state maintained between inflate() calls. Approximately 10K bytes. */ ++/* State maintained between inflate() calls -- approximately 7K bytes, not ++ including the allocated sliding window, which is up to 32K bytes. */ + struct inflate_state { ++ z_streamp strm; /* pointer back to this zlib stream */ + inflate_mode mode; /* current inflate mode */ + int last; /* true if processing last block */ +- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ ++ int wrap; /* bit 0 true for zlib, bit 1 true for gzip, ++ bit 2 true to validate check value */ + int havedict; /* true if dictionary provided */ + int flags; /* gzip header method and flags (0 if zlib) */ + unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ +diff --git a/com32/lib/zlib/inftrees.c b/com32/lib/zlib/inftrees.c +index 11e9c52a..2ea08fc1 100644 +--- a/com32/lib/zlib/inftrees.c ++++ b/com32/lib/zlib/inftrees.c +@@ -1,5 +1,5 @@ + /* inftrees.c -- generate Huffman trees for efficient decoding +- * Copyright (C) 1995-2010 Mark Adler ++ * Copyright (C) 1995-2017 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -9,7 +9,7 @@ + #define MAXBITS 15 + + const char inflate_copyright[] = +- " inflate 1.2.5 Copyright 1995-2010 Mark Adler "; ++ " inflate 1.2.11 Copyright 1995-2017 Mark Adler "; + /* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot +@@ -54,7 +54,7 @@ unsigned short FAR *work; + code FAR *next; /* next available space in table */ + const unsigned short FAR *base; /* base value table to use */ + const unsigned short FAR *extra; /* extra bits table to use */ +- int end; /* use base and extra for symbol > end */ ++ unsigned match; /* use base and extra for symbol >= match */ + unsigned short count[MAXBITS+1]; /* number of codes of each length */ + unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ + static const unsigned short lbase[31] = { /* Length codes 257..285 base */ +@@ -62,7 +62,7 @@ unsigned short FAR *work; + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + static const unsigned short lext[31] = { /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, +- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 73, 195}; ++ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202}; + static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, +@@ -181,19 +181,17 @@ unsigned short FAR *work; + switch (type) { + case CODES: + base = extra = work; /* dummy value--not used */ +- end = 19; ++ match = 20; + break; + case LENS: + base = lbase; +- base -= 257; + extra = lext; +- extra -= 257; +- end = 256; ++ match = 257; + break; +- default: /* DISTS */ ++ default: /* DISTS */ + base = dbase; + extra = dext; +- end = -1; ++ match = 0; + } + + /* initialize state for loop */ +@@ -208,21 +206,21 @@ unsigned short FAR *work; + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ +- if ((type == LENS && used >= ENOUGH_LENS) || +- (type == DISTS && used >= ENOUGH_DISTS)) ++ if ((type == LENS && used > ENOUGH_LENS) || ++ (type == DISTS && used > ENOUGH_DISTS)) + return 1; + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + here.bits = (unsigned char)(len - drop); +- if ((int)(work[sym]) < end) { ++ if (work[sym] + 1U < match) { + here.op = (unsigned char)0; + here.val = work[sym]; + } +- else if ((int)(work[sym]) > end) { +- here.op = (unsigned char)(extra[work[sym]]); +- here.val = base[work[sym]]; ++ else if (work[sym] >= match) { ++ here.op = (unsigned char)(extra[work[sym] - match]); ++ here.val = base[work[sym] - match]; + } + else { + here.op = (unsigned char)(32 + 64); /* end of block */ +@@ -277,8 +275,8 @@ unsigned short FAR *work; + + /* check for enough space */ + used += 1U << curr; +- if ((type == LENS && used >= ENOUGH_LENS) || +- (type == DISTS && used >= ENOUGH_DISTS)) ++ if ((type == LENS && used > ENOUGH_LENS) || ++ (type == DISTS && used > ENOUGH_DISTS)) + return 1; + + /* point entry in root table to sub-table */ +@@ -289,38 +287,14 @@ unsigned short FAR *work; + } + } + +- /* +- Fill in rest of table for incomplete codes. This loop is similar to the +- loop above in incrementing huff for table indices. It is assumed that +- len is equal to curr + drop, so there is no loop needed to increment +- through high index bits. When the current sub-table is filled, the loop +- drops back to the root table to fill in any remaining entries there. +- */ +- here.op = (unsigned char)64; /* invalid code marker */ +- here.bits = (unsigned char)(len - drop); +- here.val = (unsigned short)0; +- while (huff != 0) { +- /* when done with sub-table, drop back to root table */ +- if (drop != 0 && (huff & mask) != low) { +- drop = 0; +- len = root; +- next = *table; +- here.bits = (unsigned char)len; +- } +- +- /* put invalid code marker in table */ +- next[huff >> drop] = here; +- +- /* backwards increment the len-bit code huff */ +- incr = 1U << (len - 1); +- while (huff & incr) +- incr >>= 1; +- if (incr != 0) { +- huff &= incr - 1; +- huff += incr; +- } +- else +- huff = 0; ++ /* fill in remaining table entry if code is incomplete (guaranteed to have ++ at most one remaining entry, since if the code is incomplete, the ++ maximum code length that was allowed to get this far is one bit) */ ++ if (huff != 0) { ++ here.op = (unsigned char)64; /* invalid code marker */ ++ here.bits = (unsigned char)(len - drop); ++ here.val = (unsigned short)0; ++ next[huff] = here; + } + + /* set return parameters */ +diff --git a/com32/lib/zlib/trees.c b/com32/lib/zlib/trees.c +index d1de3cd0..50cf4b45 100644 +--- a/com32/lib/zlib/trees.c ++++ b/com32/lib/zlib/trees.c +@@ -1,5 +1,5 @@ + /* trees.c -- output deflated data using Huffman coding +- * Copyright (C) 1995-2010 Jean-loup Gailly ++ * Copyright (C) 1995-2017 Jean-loup Gailly + * detect_data_type() function provided freely by Cosmin Truta, 2006 + * For conditions of distribution and use, see copyright notice in zlib.h + */ +@@ -36,7 +36,7 @@ + + #include "deflate.h" + +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + # include + #endif + +@@ -74,11 +74,6 @@ local const uch bl_order[BL_CODES] + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +-#define Buf_size (8 * 2*sizeof(char)) +-/* Number of bits used within bi_buf. (bi_buf might be implemented on +- * more than 16 bits on some systems.) +- */ +- + /* =========================================================================== + * Local data. These are initialized only once. + */ +@@ -127,13 +122,13 @@ struct static_tree_desc_s { + int max_length; /* max bit length for the codes */ + }; + +-local static_tree_desc static_l_desc = ++local const static_tree_desc static_l_desc = + {static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; + +-local static_tree_desc static_d_desc = ++local const static_tree_desc static_d_desc = + {static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; + +-local static_tree_desc static_bl_desc = ++local const static_tree_desc static_bl_desc = + {(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; + + /* =========================================================================== +@@ -151,24 +146,22 @@ local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); + local int build_bl_tree OF((deflate_state *s)); + local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, + int blcodes)); +-local void compress_block OF((deflate_state *s, ct_data *ltree, +- ct_data *dtree)); ++local void compress_block OF((deflate_state *s, const ct_data *ltree, ++ const ct_data *dtree)); + local int detect_data_type OF((deflate_state *s)); + local unsigned bi_reverse OF((unsigned value, int length)); + local void bi_windup OF((deflate_state *s)); + local void bi_flush OF((deflate_state *s)); +-local void copy_block OF((deflate_state *s, charf *buf, unsigned len, +- int header)); + + #ifdef GEN_TREES_H + local void gen_trees_header OF((void)); + #endif + +-#ifndef DEBUG_ZLIB ++#ifndef ZLIB_DEBUG + # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) + /* Send a code of the given tree. c and tree must not have side effects */ + +-#else /* DEBUG_ZLIB */ ++#else /* !ZLIB_DEBUG */ + # define send_code(s, c, tree) \ + { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ + send_bits(s, tree[c].Code, tree[c].Len); } +@@ -187,7 +180,7 @@ local void gen_trees_header OF((void)); + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + local void send_bits OF((deflate_state *s, int value, int length)); + + local void send_bits(s, value, length) +@@ -213,12 +206,12 @@ local void send_bits(s, value, length) + s->bi_valid += length; + } + } +-#else /* !DEBUG_ZLIB */ ++#else /* !ZLIB_DEBUG */ + + #define send_bits(s, value, length) \ + { int len = length;\ + if (s->bi_valid > (int)Buf_size - len) {\ +- int val = value;\ ++ int val = (int)value;\ + s->bi_buf |= (ush)val << s->bi_valid;\ + put_short(s, s->bi_buf);\ + s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ +@@ -228,7 +221,7 @@ local void send_bits(s, value, length) + s->bi_valid += len;\ + }\ + } +-#endif /* DEBUG_ZLIB */ ++#endif /* ZLIB_DEBUG */ + + + /* the arguments must not have side effects */ +@@ -322,7 +315,7 @@ local void tr_static_init() + * Genererate the file trees.h describing the static trees. + */ + #ifdef GEN_TREES_H +-# ifndef DEBUG_ZLIB ++# ifndef ZLIB_DEBUG + # include + # endif + +@@ -399,8 +392,7 @@ void ZLIB_INTERNAL _tr_init(s) + + s->bi_buf = 0; + s->bi_valid = 0; +- s->last_eob_len = 8; /* enough lookahead for inflate */ +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + s->compressed_len = 0L; + s->bits_sent = 0L; + #endif +@@ -528,12 +520,12 @@ local void gen_bitlen(s, desc) + xbits = 0; + if (n >= base) xbits = extra[n-base]; + f = tree[n].Freq; +- s->opt_len += (ulg)f * (bits + xbits); +- if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); ++ s->opt_len += (ulg)f * (unsigned)(bits + xbits); ++ if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits); + } + if (overflow == 0) return; + +- Trace((stderr,"\nbit length overflow\n")); ++ Tracev((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ +@@ -560,9 +552,8 @@ local void gen_bitlen(s, desc) + m = s->heap[--h]; + if (m > max_code) continue; + if ((unsigned) tree[m].Len != (unsigned) bits) { +- Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); +- s->opt_len += ((long)bits - (long)tree[m].Len) +- *(long)tree[m].Freq; ++ Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); ++ s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq; + tree[m].Len = (ush)bits; + } + n--; +@@ -584,7 +575,7 @@ local void gen_codes (tree, max_code, bl_count) + ushf *bl_count; /* number of codes at each bit length */ + { + ush next_code[MAX_BITS+1]; /* next code value for each bit length */ +- ush code = 0; /* running code value */ ++ unsigned code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + +@@ -592,7 +583,8 @@ local void gen_codes (tree, max_code, bl_count) + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { +- next_code[bits] = code = (code + bl_count[bits-1]) << 1; ++ code = (code + bl_count[bits-1]) << 1; ++ next_code[bits] = (ush)code; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. +@@ -605,7 +597,7 @@ local void gen_codes (tree, max_code, bl_count) + int len = tree[n].Len; + if (len == 0) continue; + /* Now reverse the bits */ +- tree[n].Code = bi_reverse(next_code[len]++, len); ++ tree[n].Code = (ush)bi_reverse(next_code[len]++, len); + + Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", + n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1)); +@@ -827,7 +819,7 @@ local int build_bl_tree(s) + if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; + } + /* Update opt_len to include the bit length tree and counts */ +- s->opt_len += 3*(max_blindex+1) + 5+5+4; ++ s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4; + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + s->opt_len, s->static_len)); + +@@ -875,52 +867,46 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) + int last; /* one if this is the last block for a file */ + { + send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ +-#ifdef DEBUG_ZLIB ++ bi_windup(s); /* align on byte boundary */ ++ put_short(s, (ush)stored_len); ++ put_short(s, (ush)~stored_len); ++ zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len); ++ s->pending += stored_len; ++#ifdef ZLIB_DEBUG + s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; + s->compressed_len += (stored_len + 4) << 3; ++ s->bits_sent += 2*16; ++ s->bits_sent += stored_len<<3; + #endif +- copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ ++} ++ ++/* =========================================================================== ++ * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) ++ */ ++void ZLIB_INTERNAL _tr_flush_bits(s) ++ deflate_state *s; ++{ ++ bi_flush(s); + } + + /* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. +- * The current inflate code requires 9 bits of lookahead. If the +- * last two codes for the previous block (real code plus EOB) were coded +- * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode +- * the last real code. In this case we send two empty static blocks instead +- * of one. (There are no problems if the previous block is stored or fixed.) +- * To simplify the code, we assume the worst case of last real code encoded +- * on one bit only. + */ + void ZLIB_INTERNAL _tr_align(s) + deflate_state *s; + { + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ + #endif + bi_flush(s); +- /* Of the 10 bits for the empty block, we have already sent +- * (10 - bi_valid) bits. The lookahead for the last real code (before +- * the EOB of the previous block) was thus at least one plus the length +- * of the EOB plus what we have just sent of the empty static block. +- */ +- if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { +- send_bits(s, STATIC_TREES<<1, 3); +- send_code(s, END_BLOCK, static_ltree); +-#ifdef DEBUG_ZLIB +- s->compressed_len += 10L; +-#endif +- bi_flush(s); +- } +- s->last_eob_len = 7; + } + + /* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static +- * trees or store, and output the encoded block to the zip file. ++ * trees or store, and write out the encoded block. + */ + void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + deflate_state *s; +@@ -990,16 +976,18 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { + #endif + send_bits(s, (STATIC_TREES<<1)+last, 3); +- compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); +-#ifdef DEBUG_ZLIB ++ compress_block(s, (const ct_data *)static_ltree, ++ (const ct_data *)static_dtree); ++#ifdef ZLIB_DEBUG + s->compressed_len += 3 + s->static_len; + #endif + } else { + send_bits(s, (DYN_TREES<<1)+last, 3); + send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, + max_blindex+1); +- compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); +-#ifdef DEBUG_ZLIB ++ compress_block(s, (const ct_data *)s->dyn_ltree, ++ (const ct_data *)s->dyn_dtree); ++#ifdef ZLIB_DEBUG + s->compressed_len += 3 + s->opt_len; + #endif + } +@@ -1011,7 +999,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + + if (last) { + bi_windup(s); +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + s->compressed_len += 7; /* align on byte boundary */ + #endif + } +@@ -1075,8 +1063,8 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc) + */ + local void compress_block(s, ltree, dtree) + deflate_state *s; +- ct_data *ltree; /* literal tree */ +- ct_data *dtree; /* distance tree */ ++ const ct_data *ltree; /* literal tree */ ++ const ct_data *dtree; /* distance tree */ + { + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ +@@ -1106,7 +1094,7 @@ local void compress_block(s, ltree, dtree) + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra != 0) { +- dist -= base_dist[code]; ++ dist -= (unsigned)base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ +@@ -1118,7 +1106,6 @@ local void compress_block(s, ltree, dtree) + } while (lx < s->last_lit); + + send_code(s, END_BLOCK, ltree); +- s->last_eob_len = ltree[END_BLOCK].Len; + } + + /* =========================================================================== +@@ -1210,35 +1197,7 @@ local void bi_windup(s) + } + s->bi_buf = 0; + s->bi_valid = 0; +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + s->bits_sent = (s->bits_sent+7) & ~7; + #endif + } +- +-/* =========================================================================== +- * Copy a stored block, storing first the length and its +- * one's complement if requested. +- */ +-local void copy_block(s, buf, len, header) +- deflate_state *s; +- charf *buf; /* the input data */ +- unsigned len; /* its length */ +- int header; /* true if block header must be written */ +-{ +- bi_windup(s); /* align on byte boundary */ +- s->last_eob_len = 8; /* enough lookahead for inflate */ +- +- if (header) { +- put_short(s, (ush)len); +- put_short(s, (ush)~len); +-#ifdef DEBUG_ZLIB +- s->bits_sent += 2*16; +-#endif +- } +-#ifdef DEBUG_ZLIB +- s->bits_sent += (ulg)len<<3; +-#endif +- while (len--) { +- put_byte(s, *buf++); +- } +-} +diff --git a/com32/lib/zlib/uncompr.c b/com32/lib/zlib/uncompr.c +dissimilarity index 62% +index ad98be3a..f03a1a86 100644 +--- a/com32/lib/zlib/uncompr.c ++++ b/com32/lib/zlib/uncompr.c +@@ -1,59 +1,93 @@ +-/* uncompr.c -- decompress a memory buffer +- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#define ZLIB_INTERNAL +-#include "zlib.h" +- +-/* =========================================================================== +- 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. +- +- 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. +-*/ +-int ZEXPORT uncompress (dest, destLen, source, sourceLen) +- Bytef *dest; +- uLongf *destLen; +- const Bytef *source; +- uLong sourceLen; +-{ +- z_stream stream; +- int err; +- +- stream.next_in = (Bytef*)source; +- stream.avail_in = (uInt)sourceLen; +- /* Check for source > 64K on 16-bit machine: */ +- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; +- +- stream.next_out = dest; +- stream.avail_out = (uInt)*destLen; +- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; +- +- stream.zalloc = (alloc_func)0; +- stream.zfree = (free_func)0; +- +- err = inflateInit(&stream); +- if (err != Z_OK) return err; +- +- err = inflate(&stream, Z_FINISH); +- if (err != Z_STREAM_END) { +- inflateEnd(&stream); +- if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) +- return Z_DATA_ERROR; +- return err; +- } +- *destLen = stream.total_out; +- +- err = inflateEnd(&stream); +- return err; +-} ++/* uncompr.c -- decompress a memory buffer ++ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler ++ * For conditions of distribution and use, see copyright notice in zlib.h ++ */ ++ ++/* @(#) $Id$ */ ++ ++#define ZLIB_INTERNAL ++#include "zlib.h" ++ ++/* =========================================================================== ++ 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 size of the decompressed data and *sourceLen is the number ++ of source bytes consumed. Upon return, source + *sourceLen points to the ++ first unused input byte. ++ ++ 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, including if the input data is ++ an incomplete zlib stream. ++*/ ++int ZEXPORT uncompress2 (dest, destLen, source, sourceLen) ++ Bytef *dest; ++ uLongf *destLen; ++ const Bytef *source; ++ uLong *sourceLen; ++{ ++ z_stream stream; ++ int err; ++ const uInt max = (uInt)-1; ++ uLong len, left; ++ Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */ ++ ++ len = *sourceLen; ++ if (*destLen) { ++ left = *destLen; ++ *destLen = 0; ++ } ++ else { ++ left = 1; ++ dest = buf; ++ } ++ ++ stream.next_in = (z_const Bytef *)source; ++ stream.avail_in = 0; ++ stream.zalloc = (alloc_func)0; ++ stream.zfree = (free_func)0; ++ stream.opaque = (voidpf)0; ++ ++ err = inflateInit(&stream); ++ if (err != Z_OK) return err; ++ ++ stream.next_out = dest; ++ stream.avail_out = 0; ++ ++ do { ++ if (stream.avail_out == 0) { ++ stream.avail_out = left > (uLong)max ? max : (uInt)left; ++ left -= stream.avail_out; ++ } ++ if (stream.avail_in == 0) { ++ stream.avail_in = len > (uLong)max ? max : (uInt)len; ++ len -= stream.avail_in; ++ } ++ err = inflate(&stream, Z_NO_FLUSH); ++ } while (err == Z_OK); ++ ++ *sourceLen -= len + stream.avail_in; ++ if (dest != buf) ++ *destLen = stream.total_out; ++ else if (stream.total_out && err == Z_BUF_ERROR) ++ left = 1; ++ ++ inflateEnd(&stream); ++ return err == Z_STREAM_END ? Z_OK : ++ err == Z_NEED_DICT ? Z_DATA_ERROR : ++ err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR : ++ err; ++} ++ ++int ZEXPORT uncompress (dest, destLen, source, sourceLen) ++ Bytef *dest; ++ uLongf *destLen; ++ const Bytef *source; ++ uLong sourceLen; ++{ ++ return uncompress2(dest, destLen, source, &sourceLen); ++} +diff --git a/com32/lib/zlib/zlib.3 b/com32/lib/zlib/zlib.3 +index 27adc4cd..bda4eb07 100644 +--- a/com32/lib/zlib/zlib.3 ++++ b/com32/lib/zlib/zlib.3 +@@ -1,4 +1,4 @@ +-.TH ZLIB 3 "19 Apr 2010" ++.TH ZLIB 3 "15 Jan 2017" + .SH NAME + zlib \- compression/decompression library + .SH SYNOPSIS +@@ -36,9 +36,9 @@ All functions of the compression library are documented in the file + .IR zlib.h . + The distribution source includes examples of use of the library + in the files +-.I example.c ++.I test/example.c + and +-.IR minigzip.c, ++.IR test/minigzip.c, + as well as other examples in the + .IR examples/ + directory. +@@ -48,32 +48,10 @@ Changes to this version are documented in the file + that accompanies the source. + .LP + .I zlib +-is available in Java using the java.util.zip package: +-.IP +-http://java.sun.com/developer/technicalArticles/Programming/compression/ +-.LP +-A Perl interface to +-.IR zlib , +-written by Paul Marquess (pmqs@cpan.org), +-is available at CPAN (Comprehensive Perl Archive Network) sites, +-including: +-.IP +-http://search.cpan.org/~pmqs/IO-Compress-Zlib/ +-.LP +-A Python interface to +-.IR zlib , +-written by A.M. Kuchling (amk@magnet.com), +-is available in Python 1.5 and later versions: +-.IP +-http://www.python.org/doc/lib/module-zlib.html +-.LP +-.I zlib +-is built into +-.IR tcl: +-.IP +-http://wiki.tcl.tk/4610 ++is built in to many languages and operating systems, including but not limited to ++Java, Python, .NET, PHP, Perl, Ruby, Swift, and Go. + .LP +-An experimental package to read and write files in .zip format, ++An experimental package to read and write files in the .zip format, + written on top of + .I zlib + by Gilles Vollant (info@winimage.com), +@@ -92,14 +70,16 @@ web site can be found at: + .IP + http://zlib.net/ + .LP +-The data format used by the zlib library is described by RFC ++The data format used by the ++.I zlib ++library is described by RFC + (Request for Comments) 1950 to 1952 in the files: + .IP +-http://www.ietf.org/rfc/rfc1950.txt (for the zlib header and trailer format) ++http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format) + .br +-http://www.ietf.org/rfc/rfc1951.txt (for the deflate compressed data format) ++http://tools.ietf.org/html/rfc1951 (for the deflate compressed data format) + .br +-http://www.ietf.org/rfc/rfc1952.txt (for the gzip header and trailer format) ++http://tools.ietf.org/html/rfc1952 (for the gzip header and trailer format) + .LP + Mark Nelson wrote an article about + .I zlib +@@ -124,17 +104,35 @@ http://zlib.net/zlib_faq.html + before asking for help. + Send questions and/or comments to zlib@gzip.org, + or (for the Windows DLL version) to Gilles Vollant (info@winimage.com). +-.SH AUTHORS +-Version 1.2.5 +-Copyright (C) 1995-2010 Jean-loup Gailly (jloup@gzip.org) +-and Mark Adler (madler@alumni.caltech.edu). +-.LP +-This software is provided "as-is," +-without any express or implied warranty. +-In no event will the authors be held liable for any damages ++.SH AUTHORS AND LICENSE ++Version 1.2.11 ++.LP ++Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler ++.LP ++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. +-See the distribution directory with respect to requirements +-governing redistribution. ++.LP ++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: ++.LP ++.nr step 1 1 ++.IP \n[step]. 3 ++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. ++.IP \n+[step]. ++Altered source versions must be plainly marked as such, and must not be ++misrepresented as being the original software. ++.IP \n+[step]. ++This notice may not be removed or altered from any source distribution. ++.LP ++Jean-loup Gailly Mark Adler ++.br ++jloup@gzip.org madler@alumni.caltech.edu ++.LP + The deflate format used by + .I zlib + was defined by Phil Katz. +diff --git a/com32/lib/zlib/zutil.c b/com32/lib/zlib/zutil.c +index 3ce89769..a76c6b0c 100644 +--- a/com32/lib/zlib/zutil.c ++++ b/com32/lib/zlib/zutil.c +@@ -1,27 +1,27 @@ + /* zutil.c -- target dependent utility functions for the compression library +- * Copyright (C) 1995-2005, 2010 Jean-loup Gailly. ++ * Copyright (C) 1995-2017 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + /* @(#) $Id$ */ + + #include "zutil.h" +- +-#ifndef NO_DUMMY_DECL +-struct internal_state {int dummy;}; /* for buggy compilers */ ++#ifndef Z_SOLO ++# include "gzguts.h" + #endif + +-const char * const z_errmsg[10] = { +-"need dictionary", /* Z_NEED_DICT 2 */ +-"stream end", /* Z_STREAM_END 1 */ +-"", /* Z_OK 0 */ +-"file error", /* Z_ERRNO (-1) */ +-"stream error", /* Z_STREAM_ERROR (-2) */ +-"data error", /* Z_DATA_ERROR (-3) */ +-"insufficient memory", /* Z_MEM_ERROR (-4) */ +-"buffer error", /* Z_BUF_ERROR (-5) */ +-"incompatible version",/* Z_VERSION_ERROR (-6) */ +-""}; ++z_const char * const z_errmsg[10] = { ++ (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */ ++ (z_const char *)"stream end", /* Z_STREAM_END 1 */ ++ (z_const char *)"", /* Z_OK 0 */ ++ (z_const char *)"file error", /* Z_ERRNO (-1) */ ++ (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */ ++ (z_const char *)"data error", /* Z_DATA_ERROR (-3) */ ++ (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */ ++ (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */ ++ (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */ ++ (z_const char *)"" ++}; + + + const char * ZEXPORT zlibVersion() +@@ -58,7 +58,7 @@ uLong ZEXPORT zlibCompileFlags() + case 8: flags += 2 << 6; break; + default: flags += 3 << 6; + } +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + flags += 1 << 8; + #endif + #if defined(ASMV) || defined(ASMINF) +@@ -85,35 +85,35 @@ uLong ZEXPORT zlibCompileFlags() + #ifdef FASTEST + flags += 1L << 21; + #endif +-#ifdef STDC ++#if defined(STDC) || defined(Z_HAVE_STDARG_H) + # ifdef NO_vsnprintf +- flags += 1L << 25; ++ flags += 1L << 25; + # ifdef HAS_vsprintf_void +- flags += 1L << 26; ++ flags += 1L << 26; + # endif + # else + # ifdef HAS_vsnprintf_void +- flags += 1L << 26; ++ flags += 1L << 26; + # endif + # endif + #else +- flags += 1L << 24; ++ flags += 1L << 24; + # ifdef NO_snprintf +- flags += 1L << 25; ++ flags += 1L << 25; + # ifdef HAS_sprintf_void +- flags += 1L << 26; ++ flags += 1L << 26; + # endif + # else + # ifdef HAS_snprintf_void +- flags += 1L << 26; ++ flags += 1L << 26; + # endif + # endif + #endif + return flags; + } + +-#ifdef DEBUG_ZLIB +- ++#ifdef ZLIB_DEBUG ++#include + # ifndef verbose + # define verbose 0 + # endif +@@ -181,6 +181,7 @@ void ZLIB_INTERNAL zmemzero(dest, len) + } + #endif + ++#ifndef Z_SOLO + + #ifdef SYS16BIT + +@@ -215,9 +216,11 @@ local ptr_table table[MAX_PTR]; + + voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) + { +- voidpf buf = opaque; /* just to make some compilers happy */ ++ voidpf buf; + ulg bsize = (ulg)items*size; + ++ (void)opaque; ++ + /* If we allocate less than 65520 bytes, we assume that farmalloc + * will return a usable pointer which doesn't have to be normalized. + */ +@@ -240,6 +243,9 @@ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) + void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) + { + int n; ++ ++ (void)opaque; ++ + if (*(ush*)&ptr != 0) { /* object < 64K */ + farfree(ptr); + return; +@@ -255,7 +261,6 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) + next_ptr--; + return; + } +- ptr = opaque; /* just to make some compilers happy */ + Assert(0, "zcfree: ptr not found"); + } + +@@ -274,13 +279,13 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) + + voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) + { +- if (opaque) opaque = 0; /* to make compiler happy */ ++ (void)opaque; + return _halloc((long)items, size); + } + + void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) + { +- if (opaque) opaque = 0; /* to make compiler happy */ ++ (void)opaque; + _hfree(ptr); + } + +@@ -302,7 +307,7 @@ voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) + unsigned items; + unsigned size; + { +- if (opaque) items += size - size; /* make compiler happy */ ++ (void)opaque; + return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : + (voidpf)calloc(items, size); + } +@@ -311,8 +316,10 @@ void ZLIB_INTERNAL zcfree (opaque, ptr) + voidpf opaque; + voidpf ptr; + { ++ (void)opaque; + free(ptr); +- if (opaque) return; /* make compiler happy */ + } + + #endif /* MY_ZCALLOC */ ++ ++#endif /* !Z_SOLO */ +diff --git a/com32/lib/zlib/zutil.h b/com32/lib/zlib/zutil.h +index ed6bd830..b079ea6a 100644 +--- a/com32/lib/zlib/zutil.h ++++ b/com32/lib/zlib/zutil.h +@@ -1,5 +1,5 @@ + /* zutil.h -- internal interface and configuration of the compression library +- * Copyright (C) 1995-2010 Jean-loup Gailly. ++ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +@@ -13,7 +13,7 @@ + #ifndef ZUTIL_H + #define ZUTIL_H + +-#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) ++#ifdef HAVE_HIDDEN + # define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) + #else + # define ZLIB_INTERNAL +@@ -21,7 +21,7 @@ + + #include "zlib.h" + +-#ifdef STDC ++#if defined(STDC) && !defined(Z_SOLO) + # if !(defined(_WIN32_WCE) && defined(_MSC_VER)) + # include + # endif +@@ -29,10 +29,16 @@ + # include + #endif + ++#ifdef Z_SOLO ++ typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */ ++#endif ++ + #ifndef local + # define local static + #endif +-/* compile with -Dlocal if your debugger can't find static symbols */ ++/* since "static" is used to mean two completely different things in C, we ++ define "local" for the non-static meaning of "static", for readability ++ (compile with -Dlocal if your debugger can't find static symbols) */ + + typedef unsigned char uch; + typedef uch FAR uchf; +@@ -40,13 +46,13 @@ typedef unsigned short ush; + typedef ush FAR ushf; + typedef unsigned long ulg; + +-extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ ++extern z_const char * const 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)) ++ return (strm->msg = ERR_MSG(err), (err)) + /* To be used only when the state is known to be valid */ + + /* common constants */ +@@ -78,63 +84,83 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ + + #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) + # define OS_CODE 0x00 +-# if defined(__TURBOC__) || defined(__BORLANDC__) +-# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) +- /* Allow compilation with ANSI keywords only enabled */ +- void _Cdecl farfree( void *block ); +- void *_Cdecl farmalloc( unsigned long nbytes ); +-# else +-# include ++# ifndef Z_SOLO ++# if defined(__TURBOC__) || defined(__BORLANDC__) ++# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) ++ /* Allow compilation with ANSI keywords only enabled */ ++ void _Cdecl farfree( void *block ); ++ void *_Cdecl farmalloc( unsigned long nbytes ); ++# else ++# include ++# endif ++# else /* MSC or DJGPP */ ++# include + # endif +-# else /* MSC or DJGPP */ +-# include + # endif + #endif + + #ifdef AMIGA +-# define OS_CODE 0x01 ++# define OS_CODE 1 + #endif + + #if defined(VAXC) || defined(VMS) +-# define OS_CODE 0x02 ++# define OS_CODE 2 + # define F_OPEN(name, mode) \ + fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") + #endif + ++#ifdef __370__ ++# if __TARGET_LIB__ < 0x20000000 ++# define OS_CODE 4 ++# elif __TARGET_LIB__ < 0x40000000 ++# define OS_CODE 11 ++# else ++# define OS_CODE 8 ++# endif ++#endif ++ + #if defined(ATARI) || defined(atarist) +-# define OS_CODE 0x05 ++# define OS_CODE 5 + #endif + + #ifdef OS2 +-# define OS_CODE 0x06 +-# ifdef M_I86 ++# define OS_CODE 6 ++# if defined(M_I86) && !defined(Z_SOLO) + # include + # endif + #endif + + #if defined(MACOS) || defined(TARGET_OS_MAC) +-# define OS_CODE 0x07 +-# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os +-# include /* for fdopen */ +-# else +-# ifndef fdopen +-# define fdopen(fd,mode) NULL /* No fdopen() */ ++# define OS_CODE 7 ++# ifndef Z_SOLO ++# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os ++# include /* for fdopen */ ++# else ++# ifndef fdopen ++# define fdopen(fd,mode) NULL /* No fdopen() */ ++# endif + # endif + # endif + #endif + +-#ifdef TOPS20 +-# define OS_CODE 0x0a ++#ifdef __acorn ++# define OS_CODE 13 + #endif + +-#ifdef WIN32 +-# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ +-# define OS_CODE 0x0b +-# endif ++#if defined(WIN32) && !defined(__CYGWIN__) ++# define OS_CODE 10 ++#endif ++ ++#ifdef _BEOS_ ++# define OS_CODE 16 ++#endif ++ ++#ifdef __TOS_OS400__ ++# define OS_CODE 18 + #endif + +-#ifdef __50SERIES /* Prime/PRIMOS */ +-# define OS_CODE 0x0f ++#ifdef __APPLE__ ++# define OS_CODE 19 + #endif + + #if defined(_BEOS_) || defined(RISCOS) +@@ -153,14 +179,15 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ + # endif + #endif + +-#if defined(__BORLANDC__) ++#if defined(__BORLANDC__) && !defined(MSDOS) + #pragma warn -8004 + #pragma warn -8008 + #pragma warn -8066 + #endif + + /* provide prototypes for these when building zlib without LFS */ +-#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 ++#if !defined(_WIN32) && \ ++ (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); + #endif +@@ -168,7 +195,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ + /* common defaults */ + + #ifndef OS_CODE +-# define OS_CODE 0x03 /* assume Unix */ ++# define OS_CODE 3 /* assume Unix */ + #endif + + #ifndef F_OPEN +@@ -177,42 +204,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ + + /* functions */ + +-#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) +-# ifndef HAVE_VSNPRINTF +-# define HAVE_VSNPRINTF +-# endif +-#endif +-#if defined(__CYGWIN__) +-# ifndef HAVE_VSNPRINTF +-# define HAVE_VSNPRINTF +-# endif +-#endif +-#ifndef HAVE_VSNPRINTF +-# ifdef MSDOS +- /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), +- but for now we just assume it doesn't. */ +-# define NO_vsnprintf +-# endif +-# ifdef __TURBOC__ +-# define NO_vsnprintf +-# endif +-# ifdef WIN32 +- /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ +-# if !defined(vsnprintf) && !defined(NO_vsnprintf) +-# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) +-# define vsnprintf _vsnprintf +-# endif +-# endif +-# endif +-# ifdef __SASC +-# define NO_vsnprintf +-# endif +-#endif +-#ifdef VMS +-# define NO_vsnprintf +-#endif +- +-#if defined(pyr) ++#if defined(pyr) || defined(Z_SOLO) + # define NO_MEMCPY + #endif + #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) +@@ -242,10 +234,10 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ + #endif + + /* Diagnostic functions */ +-#ifdef DEBUG_ZLIB ++#ifdef ZLIB_DEBUG + # include + extern int ZLIB_INTERNAL z_verbose; +- extern void ZLIB_INTERNAL z_error OF((const char *m)); ++ extern void ZLIB_INTERNAL z_error OF((char *m)); + # define Assert(cond,msg) {if(!(cond)) z_error(msg);} + # define Trace(x) {if (z_verbose>=0) fprintf x ;} + # define Tracev(x) {if (z_verbose>0) fprintf x ;} +@@ -253,22 +245,27 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ + # define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} + # define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} + #else +-# define Assert(cond,msg) ((void)0) +-# define Trace(x) ((void)0) +-# define Tracev(x) ((void)0) +-# define Tracevv(x) ((void)0) +-# define Tracec(c,x) ((void)0) +-# define Tracecv(c,x) ((void)0) ++# define Assert(cond,msg) ++# define Trace(x) ++# define Tracev(x) ++# define Tracevv(x) ++# define Tracec(c,x) ++# define Tracecv(c,x) + #endif + +- +-voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, +- unsigned size)); +-void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); ++#ifndef Z_SOLO ++ voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, ++ unsigned size)); ++ void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); ++#endif + + #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);} + ++/* Reverse the bytes in a 32-bit value */ ++#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ ++ (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) ++ + #endif /* ZUTIL_H */ +-- +2.11.4.GIT + diff --git a/syslinux.spec b/syslinux.spec index 4ac822493bc992bc9133a4012b07fc0bc9e9d09b..940d70c337f48d8a0751bfde6e4c1718fdc972a7 100644 --- a/syslinux.spec +++ b/syslinux.spec @@ -2,7 +2,7 @@ Name: syslinux Version: 6.04 -Release: 11 +Release: 12 License: GPLv2+ Summary: The Syslinux boot loader collection URL: http://syslinux.zytor.com/wiki/index.php/The_Syslinux_Project @@ -26,6 +26,7 @@ Patch0003: 0003-include-sysmacros-h.patch Patch0004: backport-replace-builtin-strlen-that-appears-to-get-optimized.patch Patch0005: backport-add-RPMOPTFLAGS-to-CFLAGS-for-some-stuff.patch Patch0006: backport-tweak-for-gcc-10.patch +Patch0007: backport-zlib-update.patch %description The Syslinux Project covers lightweight bootloaders for MS-DOS FAT filesystems (SYSLINUX), @@ -160,6 +161,9 @@ fi %{_datadir}/syslinux/efi64 %changelog +* Tue Jul 11 2023 zhangpan - 6.04-12 +- fix CVE-2016-9840 CVE-2016-9841 CVE-2016-9842 CVE-2016-9843 + * Sat May 07 2022 wangkerong - 6.04-11 - slove duplicate package files