public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/syslinux] f44: update zlib version to zlib-1.2.11
@ 2026-07-13 16:30 Josue Hernandez
0 siblings, 0 replies; only message in thread
From: Josue Hernandez @ 2026-07-13 16:30 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/syslinux
Branch : f44
Commit : 452950760e6a1ba3e2e74fc20b5754d0081a2db1
Author : Josue Hernandez <josherna@redhat.com>
Date : 2026-03-31T11:02:23-06:00
Stats : +6460/-1 in 2 file(s)
URL : https://src.fedoraproject.org/rpms/syslinux/c/452950760e6a1ba3e2e74fc20b5754d0081a2db1?branch=f44
Log:
update zlib version to zlib-1.2.11
Resolves: CVE-2022-37434 CVE-2018-25032 CVE-2016-9840 CVE-2016-9843
Signed-off-by: Josue Hernandez <josherna@redhat.com>
---
diff --git a/0012-zlib-update-to-version-1.2.11.patch b/0012-zlib-update-to-version-1.2.11.patch
new file mode 100644
index 0000000..6cad670
--- /dev/null
+++ b/0012-zlib-update-to-version-1.2.11.patch
@@ -0,0 +1,6454 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "H. Peter Anvin" <hpa@zytor.com>
+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 <hpa@zytor.com>
+---
+ com32/include/gzguts.h | 218 +++++++++
+ com32/include/zconf.h | 234 +++++++---
+ com32/include/zlib.h | 743 +++++++++++++++++++++----------
+ com32/lib/zlib/FAQ | 12 +-
+ com32/lib/zlib/README | 24 +-
+ com32/lib/zlib/adler32.c | 87 ++--
+ com32/lib/zlib/compress.c | 42 +-
+ com32/lib/zlib/crc32.c | 120 ++---
+ com32/lib/zlib/crc32.h | 2 +-
+ com32/lib/zlib/deflate.c | 1079 +++++++++++++++++++++++++++++----------------
+ 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 | 98 ++--
+ com32/lib/zlib/zlib.3 | 80 ++--
+ com32/lib/zlib/zutil.c | 71 +--
+ com32/lib/zlib/zutil.h | 167 ++++---
+ 22 files changed, 2326 insertions(+), 1298 deletions(-)
+ create mode 100644 com32/include/gzguts.h
+
+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 <stdio.h>
++#include "zlib.h"
++#ifdef STDC
++# include <string.h>
++# include <stdlib.h>
++# include <limits.h>
++#endif
++
++#ifndef _POSIX_SOURCE
++# define _POSIX_SOURCE
++#endif
++#include <fcntl.h>
++
++#ifdef _WIN32
++# include <stddef.h>
++#endif
++
++#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
++# include <io.h>
++#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 <windows.h>
++# define zstrerror() gz_strwinerror((DWORD)GetLastError())
++#else
++# ifndef NO_STRERROR
++# include <errno.h>
++# 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 <stddef.h>
++ 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 <limits.h>
++# 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 <sys/types.h> /* for off_t */
++# ifndef Z_SOLO
++# include <sys/types.h> /* for off_t */
++# endif
++#endif
++
++#if defined(STDC) || defined(Z_HAVE_STDARG_H)
++# ifndef Z_SOLO
++# include <stdarg.h> /* for va_list */
++# endif
++#endif
++
++#ifdef _WIN32
++# ifndef Z_SOLO
++# include <stddef.h> /* 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 <unistd.h> /* for SEEK_* and off_t */
+-# ifdef VMS
+-# include <unixio.h> /* 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 <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
++# ifdef VMS
++# include <unixio.h> /* 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.
++ 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 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.
++ 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 adler32 checksum of all input read
+- so far (that is, total_in bytes).
++ 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().
++ 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().
+
+- 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.
++ 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.
+
+- 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.
++ 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,9 +764,29 @@ 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,
+ int value));
+@@ -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 <zlib@gzip.org>, or to Gilles Vollant
+@@ -31,7 +31,7 @@ Mark Nelson <markn@ieee.org> 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 <amk@amk.ca> 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
++/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
++ (thank you to John Reiser for pointing this out) */
++# define CHOP(a) \
++ do { \
++ 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 MOD(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); \
+- if (a >= BASE) a -= BASE; \
++ CHOP(a); \
++ MOD28(a); \
+ } while (0)
+-# define MOD4(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); \
++# 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);
+ }
+
+@@ -127,6 +130,15 @@ uLong ZEXPORT adler32(adler, buf, len)
+ return adler | (sum2 << 16);
+ }
+
++/* ========================================================================= */
++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;
+@@ -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;
+- }
++ stream.next_out = dest;
++ stream.avail_out = 0;
++ stream.next_in = (z_const Bytef *)source;
++ stream.avail_in = 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 = 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;
+-
+- err = deflateEnd(&stream);
+- return err;
++ 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 <rbrown64@csc.com.au> 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 <limits.h>
+-# 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)<<s->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)
++ wrap = s->wrap;
++ if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
++ return Z_STREAM_ERROR;
++
++ /* 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 (length < MIN_MATCH) return Z_OK;
+- if (length > s->w_size) {
+- length = s->w_size;
+- dictionary += dictLength - length; /* use the tail of the dictionary */
++ /* 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 (strm == Z_NULL || strm->state == Z_NULL ||
+- strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
++ 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 (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,203 +767,21 @@ 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;
+
+- /* 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;
+- }
+- }
+- 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);
+-
+- 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));
+- }
+- strm->adler = adler32(0L, Z_NULL, 0);
+- }
+- }
+-#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;
+- }
+- 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;
+- }
+- }
+- else
+- 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 */
+- 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);
+- flush_pending(strm);
+- beg = s->pending;
+- if (s->pending == s->pending_buf_size) {
+- val = 1;
+- break;
+- }
+- }
+- 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;
+- }
+- }
+- else
+- 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 */
+- 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);
+- flush_pending(strm);
+- beg = s->pending;
+- if (s->pending == s->pending_buf_size) {
+- val = 1;
+- break;
+- }
+- }
+- 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;
+- }
+- else
+- s->status = HCRC_STATE;
+- }
+- if (s->status == HCRC_STATE) {
+- if (s->gzhead->hcrc) {
+- 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;
+- }
+- }
+- else
+- s->status = BUSY_STATE;
+- }
+-#endif
+-
+ /* Flush as much pending output as possible */
+ if (s->pending != 0) {
+ flush_pending(strm);
+@@ -801,7 +800,7 @@ int ZEXPORT deflate (strm, flush)
+ * 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 &&
++ } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
+ flush != Z_FINISH) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+@@ -811,15 +810,197 @@ int ZEXPORT deflate (strm, flush)
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
++ /* Write the header */
++ if (s->status == INIT_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
++ 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;
++
++ /* 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);
++ }
++ if (s->gzhead->hcrc)
++ strm->adler = crc32(strm->adler, s->pending_buf,
++ s->pending);
++ s->gzindex = 0;
++ s->status = EXTRA_STATE;
++ }
++ }
++ if (s->status == EXTRA_STATE) {
++ if (s->gzhead->extra != Z_NULL) {
++ 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;
++ }
++ 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;
++ }
++ s->status = NAME_STATE;
++ }
++ if (s->status == NAME_STATE) {
++ if (s->gzhead->name != Z_NULL) {
++ ulg beg = s->pending; /* start of bytes to update crc */
++ int val;
++ do {
++ if (s->pending == s->pending_buf_size) {
++ HCRC_UPDATE(beg);
++ flush_pending(strm);
++ 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);
++ HCRC_UPDATE(beg);
++ s->gzindex = 0;
++ }
++ s->status = COMMENT_STATE;
++ }
++ if (s->status == COMMENT_STATE) {
++ if (s->gzhead->comment != Z_NULL) {
++ ulg beg = s->pending; /* start of bytes to update crc */
++ int val;
++ do {
++ if (s->pending == s->pending_buf_size) {
++ HCRC_UPDATE(beg);
++ flush_pending(strm);
++ 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);
++ HCRC_UPDATE(beg);
++ }
++ s->status = HCRC_STATE;
++ }
++ if (s->status == HCRC_STATE) {
++ if (s->gzhead->hcrc) {
++ if (s->pending + 2 > s->pending_buf_size) {
++ flush_pending(strm);
++ 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);
++ }
++ 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;
++ }
++ }
++#endif
++
+ /* Start a new block or continue the current one.
+ */
+ if (strm->avail_in != 0 || s->lookahead != 0 ||
+ (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 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 */
+
+- /* Copy as much as possible from input to output: */
+- for (;;) {
+- /* Fill the window as much as possible: */
+- if (s->lookahead <= 1) {
++ /* 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;
++
++ /* 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);
+
+- Assert(s->strstart < s->w_size+MAX_DIST(s) ||
+- s->block_start >= (long)s->w_size, "slide too late");
++ /* 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;
+
+- fill_window(s);
+- if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
++ /* Write the stored block header bytes. */
++ flush_pending(s->strm);
+
+- if (s->lookahead == 0) break; /* flush the current block */
++#ifdef ZLIB_DEBUG
++ /* Update debugging counts for the data about to be copied. */
++ s->compressed_len += len << 3;
++ s->bits_sent += len << 3;
++#endif
++
++ /* 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 */
+ }
+- FLUSH_BLOCK(s, flush == Z_FINISH);
+- return flush == Z_FINISH ? finish_done : block_done;
++ 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);
++ }
++
++ /* 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;
++}
+
+- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
++int ZEXPORT inflateResetKeep(strm)
++z_streamp strm;
++{
++ struct inflate_state FAR *state;
++
++ 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;
++#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ state->sane = !subvert;
+-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ 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 <ctype.h>
+ #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 <stdio.h>
+ # 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
+index ad98be3a..f03a1a86 100644
+--- a/com32/lib/zlib/uncompr.c
++++ b/com32/lib/zlib/uncompr.c
+@@ -1,5 +1,5 @@
+ /* uncompr.c -- decompress a memory buffer
+- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
++ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+@@ -9,51 +9,85 @@
+ #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.
++ 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.
++ 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 uncompress (dest, destLen, source, sourceLen)
++int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+- uLong sourceLen;
++ 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 */
+
+- 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;
++ 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;
+
+- 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;
++ 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/
++is built in to many languages and operating systems, including but not limited to
++Java, Python, .NET, PHP, Perl, Ruby, Swift, and Go.
+ .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
+-.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).
++.SH AUTHORS AND LICENSE
++Version 1.2.11
+ .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
++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 <stdlib.h>
+ # 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 <stddef.h>
+ # endif
+@@ -29,10 +29,16 @@
+ # include <stdlib.h>
+ #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 <alloc.h>
++# 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 <alloc.h>
++# endif
++# else /* MSC or DJGPP */
++# include <malloc.h>
+ # endif
+-# else /* MSC or DJGPP */
+-# include <malloc.h>
+ # 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 <malloc.h>
+ # 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 <unix.h> /* 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 <unix.h> /* 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 __50SERIES /* Prime/PRIMOS */
+-# define OS_CODE 0x0f
++#ifdef _BEOS_
++# define OS_CODE 16
++#endif
++
++#ifdef __TOS_OS400__
++# define OS_CODE 18
++#endif
++
++#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 <stdio.h>
+ 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 */
diff --git a/syslinux.spec b/syslinux.spec
index 6e5cc07..d9628dc 100644
--- a/syslinux.spec
+++ b/syslinux.spec
@@ -10,7 +10,7 @@ Summary: Simple kernel loader which boots from a FAT filesystem
Name: syslinux
Version: 6.04
%define tarball_version 6.04-pre1
-Release: 0.35%{?dist}
+Release: 0.36%{?dist}
License: GPL-2.0-or-later
URL: http://syslinux.zytor.com/wiki/index.php/The_Syslinux_Project
Source0: http://www.kernel.org/pub/linux/utils/boot/syslinux/%{name}-%{tarball_version}.tar.xz
@@ -25,6 +25,7 @@ Patch0008: 0008-Fix-build-with-GCC-14.patch
Patch0009: 0009-Rewrite_Digest_SHA1_to_SHA.patch
Patch0010: 0010-Fix-reported-SAST-findings.patch
Patch0011: 0011-core-Makefile-allow-relocations-on-text-sections.patch
+Patch0012: 0012-zlib-update-to-version-1.2.11.patch
# this is to keep rpmbuild from thinking the .c32 / .com / .0 / memdisk files
# in noarch packages are a reason to stop the build.
@@ -260,6 +261,10 @@ fi
%endif
%changelog
+* Wed Mar 25 2026 Josue Hernandez <josherna@redhat.com> - 6.04-0.36
+- Update zlib version to zlib-1.2.11
+- Resolves: CVE-2022-37434 CVE-2018-25032 CVE-2016-9840 CVE-2016-9843
+
* Wed Jan 28 2026 Leo Sandoval <lsandova@redhat.com> - 6.04-0.35
- Allow relocations on text sections
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-07-13 16:30 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-07-13 16:30 [rpms/syslinux] f44: update zlib version to zlib-1.2.11 Josue Hernandez
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox