pool/zlib
SHA256
2
0
Fork 2
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Accepting request 965637 from devel:libraries:c_c++

Browse Source 
OBS-URL: https://build.opensuse.org/request/show/965637
OBS-URL: https://build.opensuse.org/package/show/openSUSE:Factory/zlib?expand=0&rev=82
This commit is contained in:
Dominique Leuenberger 2022-04-01 19:34:49 +00:00 committed by Git OBS Bridge
commit 740b6f4b53
9 changed files with 754 additions and 427 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

481
410.patch
View File

@ -1,4 +1,4 @@
From 79ccd96ec69d2367291568c586aeaae941d2635c Mon Sep 17 00:00:00 2001 From b25781e735363e04f6c56e21431c47e4afc50b17 Mon Sep 17 00:00:00 2001
From: Ilya Leoshkevich <iii@linux.ibm.com> From: Ilya Leoshkevich <iii@linux.ibm.com>
Date: Wed, 18 Jul 2018 13:14:07 +0200 Date: Wed, 18 Jul 2018 13:14:07 +0200
Subject: [PATCH] Add support for IBM Z hardware-accelerated deflate Subject: [PATCH] Add support for IBM Z hardware-accelerated deflate
@ -17,8 +17,8 @@ following build commands should be used:
When built like this, zlib would compress in hardware on level 1, and in When built like this, zlib would compress in hardware on level 1, and in
software on all other levels. Decompression will always happen in software on all other levels. Decompression will always happen in
hardware. In order to enable DFLTCC compression for levels 1-6 (i.e. to hardware. In order to enable DFLTCC compression for levels 1-6 (i.e. to
make it used by default) one could either add -DDFLTCC_LEVEL_MASK=0x7e make it used by default) one could either configure with
to CFLAGS at compile time, or set the environment variable --dfltcc-level-mask=0x7e or set the environment variable
DFLTCC_LEVEL_MASK to 0x7e at run time. DFLTCC_LEVEL_MASK to 0x7e at run time.
Two DFLTCC compression calls produce the same results only when they Two DFLTCC compression calls produce the same results only when they
@ -34,6 +34,7 @@ DFLTCC does not support every single zlib feature, in particular:
* inflate(Z_BLOCK) and inflate(Z_TREES) * inflate(Z_BLOCK) and inflate(Z_TREES)
* inflateMark() * inflateMark()
* inflatePrime() * inflatePrime()
* inflateSyncPoint()
When used, these functions will either switch to software, or, in case When used, these functions will either switch to software, or, in case
this is not possible, gracefully fail. this is not possible, gracefully fail.
@ -63,9 +64,9 @@ the new DEFLATE_RESET_KEEP_HOOK and INFLATE_RESET_KEEP_HOOK macros.
The new DEFLATE_PARAMS_HOOK switches between hardware and software The new DEFLATE_PARAMS_HOOK switches between hardware and software
deflate implementations when deflateParams() arguments demand this. deflate implementations when deflateParams() arguments demand this.
In order to make unsupported inflatePrime() and inflateMark() calls The new INFLATE_PRIME_HOOK, INFLATE_MARK_HOOK and
fail gracefully, the new INFLATE_PRIME_HOOK and INFLATE_MARK_HOOK macros INFLATE_SYNC_POINT_HOOK macros make the respective unsupported calls
were introduced. gracefully fail.
The algorithm implemented in hardware has different compression ratio The algorithm implemented in hardware has different compression ratio
than the one implemented in software. In order for deflateBound() to than the one implemented in software. In order for deflateBound() to
@ -95,20 +96,24 @@ might be not allocated yet, inflate_ensure_window was factored out of
updatewindow and made ZLIB_INTERNAL. updatewindow and made ZLIB_INTERNAL.
--- ---
Makefile.in | 8 + Makefile.in | 8 +
configure | 20 + compress.c | 14 +-
configure | 24 +
contrib/README.contrib | 4 + contrib/README.contrib | 4 +
contrib/s390/dfltcc.c | 920 ++++++++++++++++++++++++++++++++++ contrib/s390/README.txt | 17 +
contrib/s390/dfltcc.h | 55 ++ contrib/s390/dfltcc.c | 996 ++++++++++++++++++++++++++++++++++
contrib/s390/dfltcc_deflate.h | 54 ++ contrib/s390/dfltcc.h | 81 +++
deflate.c | 68 ++- contrib/s390/dfltcc_deflate.h | 55 ++
deflate.c | 81 ++-
deflate.h | 12 + deflate.h | 12 +
gzguts.h | 4 + gzguts.h | 4 +
inflate.c | 85 +++- inflate.c | 87 ++-
inflate.h | 2 + inflate.h | 2 +
test/infcover.c | 2 +- test/infcover.c | 4 +-
test/minigzip.c | 4 + test/minigzip.c | 4 +
trees.c | 13 +- trees.c | 13 +-
14 files changed, 1197 insertions(+), 54 deletions(-) zutil.h | 2 +
17 files changed, 1348 insertions(+), 60 deletions(-)
create mode 100644 contrib/s390/README.txt
create mode 100644 contrib/s390/dfltcc.c create mode 100644 contrib/s390/dfltcc.c
create mode 100644 contrib/s390/dfltcc.h create mode 100644 contrib/s390/dfltcc.h
create mode 100644 contrib/s390/dfltcc_deflate.h create mode 100644 contrib/s390/dfltcc_deflate.h
@ -132,6 +137,40 @@ Index: zlib-1.2.11/Makefile.in
example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c
Index: zlib-1.2.11/compress.c
===================================================================
--- zlib-1.2.11.orig/compress.c
+++ zlib-1.2.11/compress.c
@@ -5,9 +5,15 @@
/* @(#) $Id$ */
-#define ZLIB_INTERNAL
+#include "zutil.h"
#include "zlib.h"
+#ifdef DFLTCC
+# include "contrib/s390/dfltcc.h"
+#else
+#define DEFLATE_BOUND_COMPLEN(source_len) 0
+#endif
+
/* ===========================================================================
Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte
@@ -81,6 +87,12 @@ int ZEXPORT compress (dest, destLen, sou
uLong ZEXPORT compressBound (sourceLen)
uLong sourceLen;
{
+ uLong complen = DEFLATE_BOUND_COMPLEN(sourceLen);
+
+ if (complen > 0)
+ /* Architecture-specific code provided an upper bound. */
+ return complen + ZLIB_WRAPLEN;
+
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
(sourceLen >> 25) + 13;
}
Index: zlib-1.2.11/configure Index: zlib-1.2.11/configure
=================================================================== ===================================================================
--- zlib-1.2.11.orig/configure --- zlib-1.2.11.orig/configure
@ -140,11 +179,11 @@ Index: zlib-1.2.11/configure
echo ' configure [--const] [--zprefix] [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log echo ' configure [--const] [--zprefix] [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log
echo ' [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log echo ' [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
echo ' [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log echo ' [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
+ echo ' [--dfltcc]' | tee -a configure.log + echo ' [--dfltcc] [--dfltcc-level-mask=MASK]' | tee -a configure.log
exit 0 ;; exit 0 ;;
-p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;; -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
-e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;; -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
@@ -137,6 +138,12 @@ case "$1" in @@ -137,6 +138,16 @@ case "$1" in
-c* | --const) zconst=1; shift ;; -c* | --const) zconst=1; shift ;;
-w* | --warn) warn=1; shift ;; -w* | --warn) warn=1; shift ;;
-d* | --debug) debug=1; shift ;; -d* | --debug) debug=1; shift ;;
@ -153,11 +192,15 @@ Index: zlib-1.2.11/configure
+ OBJC="$OBJC dfltcc.o" + OBJC="$OBJC dfltcc.o"
+ PIC_OBJC="$PIC_OBJC dfltcc.lo" + PIC_OBJC="$PIC_OBJC dfltcc.lo"
+ shift + shift
+ ;;
+ --dfltcc-level-mask=*)
+ CFLAGS="$CFLAGS -DDFLTCC_LEVEL_MASK=`echo $1 | sed 's/.*=//'`"
+ shift
+ ;; + ;;
*) *)
echo "unknown option: $1" | tee -a configure.log echo "unknown option: $1" | tee -a configure.log
echo "$0 --help for help" | tee -a configure.log echo "$0 --help for help" | tee -a configure.log
@@ -911,6 +918,19 @@ EOF @@ -911,6 +922,19 @@ EOF
fi fi
fi fi
@ -166,7 +209,7 @@ Index: zlib-1.2.11/configure
+#include <sys/sdt.h> +#include <sys/sdt.h>
+int main() { return 0; } +int main() { return 0; }
+EOF +EOF
+if try ${CC} ${CFLAGS} $test.c; then +if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for sys/sdt.h ... Yes." | tee -a configure.log + echo "Checking for sys/sdt.h ... Yes." | tee -a configure.log
+ CFLAGS="$CFLAGS -DHAVE_SYS_SDT_H" + CFLAGS="$CFLAGS -DHAVE_SYS_SDT_H"
+ SFLAGS="$SFLAGS -DHAVE_SYS_SDT_H" + SFLAGS="$SFLAGS -DHAVE_SYS_SDT_H"
@ -192,11 +235,33 @@ Index: zlib-1.2.11/contrib/README.contrib
testzlib/ by Gilles Vollant <info@winimage.com> testzlib/ by Gilles Vollant <info@winimage.com>
Example of the use of zlib Example of the use of zlib
Index: zlib-1.2.11/contrib/s390/README.txt
===================================================================
--- /dev/null
+++ zlib-1.2.11/contrib/s390/README.txt
@@ -0,0 +1,17 @@
+IBM Z mainframes starting from version z15 provide DFLTCC instruction,
+which implements deflate algorithm in hardware with estimated
+compression and decompression performance orders of magnitude faster
+than the current zlib and ratio comparable with that of level 1.
+
+This directory adds DFLTCC support. In order to enable it, the following
+build commands should be used:
+
+ $ ./configure --dfltcc
+ $ make
+
+When built like this, zlib would compress in hardware on level 1, and in
+software on all other levels. Decompression will always happen in
+hardware. In order to enable DFLTCC compression for levels 1-6 (i.e. to
+make it used by default) one could either configure with
+--dfltcc-level-mask=0x7e or set the environment variable
+DFLTCC_LEVEL_MASK to 0x7e at run time.
Index: zlib-1.2.11/contrib/s390/dfltcc.c Index: zlib-1.2.11/contrib/s390/dfltcc.c
=================================================================== ===================================================================
--- /dev/null --- /dev/null
+++ zlib-1.2.11/contrib/s390/dfltcc.c +++ zlib-1.2.11/contrib/s390/dfltcc.c
@@ -0,0 +1,920 @@ @@ -0,0 +1,996 @@
+/* dfltcc.c - SystemZ DEFLATE CONVERSION CALL support. */ +/* dfltcc.c - SystemZ DEFLATE CONVERSION CALL support. */
+ +
+/* +/*
@ -208,6 +273,7 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ +
+#define _GNU_SOURCE +#define _GNU_SOURCE
+#include <ctype.h> +#include <ctype.h>
+#include <errno.h>
+#include <inttypes.h> +#include <inttypes.h>
+#include <stddef.h> +#include <stddef.h>
+#include <stdio.h> +#include <stdio.h>
@ -549,8 +615,12 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ int soft_bcc; + int soft_bcc;
+ int no_flush; + int no_flush;
+ +
+ if (!dfltcc_can_deflate(strm)) + if (!dfltcc_can_deflate(strm)) {
+ /* Clear history. */
+ if (flush == Z_FULL_FLUSH)
+ param->hl = 0;
+ return 0; + return 0;
+ }
+ +
+again: +again:
+ masked_avail_in = 0; + masked_avail_in = 0;
@ -575,7 +645,8 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ /* Clear history. */ + /* Clear history. */
+ if (flush == Z_FULL_FLUSH) + if (flush == Z_FULL_FLUSH)
+ param->hl = 0; + param->hl = 0;
+ *result = need_more; + /* Trigger block post-processing if necessary. */
+ *result = no_flush ? need_more : block_done;
+ return 1; + return 1;
+ } + }
+ +
@ -602,12 +673,17 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ param->bcf = 0; + param->bcf = 0;
+ dfltcc_state->block_threshold = + dfltcc_state->block_threshold =
+ strm->total_in + dfltcc_state->block_size; + strm->total_in + dfltcc_state->block_size;
+ }
+ }
+
+ /* No space for compressed data. If we proceed, dfltcc_cmpr() will return
+ * DFLTCC_CC_OP1_TOO_SHORT without buffering header bits, but we will still
+ * set BCF=1, which is wrong. Avoid complications and return early.
+ */
+ if (strm->avail_out == 0) { + if (strm->avail_out == 0) {
+ *result = need_more; + *result = need_more;
+ return 1; + return 1;
+ } + }
+ }
+ }
+ +
+ /* The caller gave us too much data. Pass only one block worth of + /* The caller gave us too much data. Pass only one block worth of
+ * uncompressed data to DFLTCC and mask the rest, so that on the next + * uncompressed data to DFLTCC and mask the rest, so that on the next
@ -852,6 +928,110 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ return 0; + return 0;
+} +}
+ +
+local int env_dfltcc_disabled;
+local int env_source_date_epoch;
+local unsigned long env_level_mask;
+local unsigned long env_block_size;
+local unsigned long env_block_threshold;
+local unsigned long env_dht_threshold;
+local unsigned long env_ribm;
+local uint64_t cpu_facilities[(DFLTCC_FACILITY / 64) + 1];
+local struct dfltcc_qaf_param cpu_af __attribute__((aligned(8)));
+
+local inline int is_dfltcc_enabled OF((void));
+local inline int is_dfltcc_enabled(void)
+{
+ if (env_dfltcc_disabled)
+ /* User has explicitly disabled DFLTCC. */
+ return 0;
+
+ return is_bit_set((const char *)cpu_facilities, DFLTCC_FACILITY);
+}
+
+local unsigned long xstrtoul OF((const char *s, unsigned long _default));
+local unsigned long xstrtoul(s, _default)
+ const char *s;
+ unsigned long _default;
+{
+ char *endptr;
+ unsigned long result;
+
+ if (!(s && *s))
+ return _default;
+ errno = 0;
+ result = strtoul(s, &endptr, 0);
+ return (errno || *endptr) ? _default : result;
+}
+
+__attribute__((constructor)) local void init_globals OF((void));
+__attribute__((constructor)) local void init_globals(void)
+{
+ const char *endptr;
+ const char *env;
+ register char r0 __asm__("r0");
+
+ env = secure_getenv("DFLTCC");
+ env_dfltcc_disabled = env && !strcmp(env, "0");
+
+ env = secure_getenv("SOURCE_DATE_EPOCH");
+ env_source_date_epoch = !!env;
+
+#ifndef DFLTCC_LEVEL_MASK
+#define DFLTCC_LEVEL_MASK 0x2
+#endif
+ env_level_mask = xstrtoul(secure_getenv("DFLTCC_LEVEL_MASK"),
+ DFLTCC_LEVEL_MASK);
+
+#ifndef DFLTCC_BLOCK_SIZE
+#define DFLTCC_BLOCK_SIZE 1048576
+#endif
+ env_block_size = xstrtoul(secure_getenv("DFLTCC_BLOCK_SIZE"),
+ DFLTCC_BLOCK_SIZE);
+
+#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE
+#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096
+#endif
+ env_block_threshold = xstrtoul(secure_getenv("DFLTCC_FIRST_FHT_BLOCK_SIZE"),
+ DFLTCC_FIRST_FHT_BLOCK_SIZE);
+
+#ifndef DFLTCC_DHT_MIN_SAMPLE_SIZE
+#define DFLTCC_DHT_MIN_SAMPLE_SIZE 4096
+#endif
+ env_dht_threshold = xstrtoul(secure_getenv("DFLTCC_DHT_MIN_SAMPLE_SIZE"),
+ DFLTCC_DHT_MIN_SAMPLE_SIZE);
+
+#ifndef DFLTCC_RIBM
+#define DFLTCC_RIBM 0
+#endif
+ env_ribm = xstrtoul(secure_getenv("DFLTCC_RIBM"), DFLTCC_RIBM);
+
+ memset(cpu_facilities, 0, sizeof(cpu_facilities));
+ r0 = sizeof(cpu_facilities) / sizeof(cpu_facilities[0]) - 1;
+ /* STFLE is supported since z9-109 and only in z/Architecture mode. When
+ * compiling with -m31, gcc defaults to ESA mode, however, since the kernel
+ * is 64-bit, it's always z/Architecture mode at runtime.
+ */
+ __asm__ volatile(
+#ifndef __clang__
+ ".machinemode push\n"
+ ".machinemode zarch\n"
+#endif
+ "stfle %[facilities]\n"
+#ifndef __clang__
+ ".machinemode pop\n"
+#endif
+ : [facilities] "=Q" (cpu_facilities)
+ , [r0] "+r" (r0)
+ :
+ : "cc");
+
+ /* Initialize available functions */
+ if (is_dfltcc_enabled())
+ dfltcc(DFLTCC_QAF, &cpu_af, NULL, NULL, NULL, NULL, NULL);
+ else
+ memset(&cpu_af, 0, sizeof(cpu_af));
+}
+
+/* +/*
+ Memory management. + Memory management.
+ +
@ -860,53 +1040,16 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ `posix_memalign' is not an option. Thus, we overallocate and take the + `posix_memalign' is not an option. Thus, we overallocate and take the
+ aligned portion of the buffer. + aligned portion of the buffer.
+*/ +*/
+local inline int is_dfltcc_enabled OF((void));
+local inline int is_dfltcc_enabled(void)
+{
+ const char *env;
+ uint64_t facilities[(DFLTCC_FACILITY / 64) + 1];
+ register char r0 __asm__("r0");
+
+ env = secure_getenv("DFLTCC");
+ if (env && !strcmp(env, "0"))
+ /* User has explicitly disabled DFLTCC. */
+ return 0;
+
+ memset(facilities, 0, sizeof(facilities));
+ r0 = sizeof(facilities) / sizeof(facilities[0]) - 1;
+ /* STFLE is supported since z9-109 and only in z/Architecture mode. When
+ * compiling with -m31, gcc defaults to ESA mode, however, since the kernel
+ * is 64-bit, it's always z/Architecture mode at runtime.
+ */
+ __asm__ volatile(".machinemode push\n"
+ ".machinemode zarch\n"
+ "stfle %[facilities]\n"
+ ".machinemode pop\n"
+ : [facilities] "=Q" (facilities)
+ , [r0] "+r" (r0)
+ :
+ : "cc");
+ return is_bit_set((const char *)facilities, DFLTCC_FACILITY);
+}
+
+void ZLIB_INTERNAL dfltcc_reset(strm, size) +void ZLIB_INTERNAL dfltcc_reset(strm, size)
+ z_streamp strm; + z_streamp strm;
+ uInt size; + uInt size;
+{ +{
+ struct dfltcc_state *dfltcc_state = + struct dfltcc_state *dfltcc_state =
+ (struct dfltcc_state *)((char FAR *)strm->state + ALIGN_UP(size, 8)); + (struct dfltcc_state *)((char FAR *)strm->state + ALIGN_UP(size, 8));
+ struct dfltcc_qaf_param *param =
+ (struct dfltcc_qaf_param *)&dfltcc_state->param;
+ const char *s;
+ +
+ /* Initialize available functions */ + memcpy(&dfltcc_state->af, &cpu_af, sizeof(dfltcc_state->af));
+ if (is_dfltcc_enabled()) {
+ dfltcc(DFLTCC_QAF, param, NULL, NULL, NULL, NULL, NULL);
+ memmove(&dfltcc_state->af, param, sizeof(dfltcc_state->af));
+ } else
+ memset(&dfltcc_state->af, 0, sizeof(dfltcc_state->af));
+ +
+ if (secure_getenv("SOURCE_DATE_EPOCH")) + if (env_source_date_epoch)
+ /* User needs reproducible results, but the output of DFLTCC_CMPR + /* User needs reproducible results, but the output of DFLTCC_CMPR
+ * depends on buffers' page offsets. + * depends on buffers' page offsets.
+ */ + */
@ -917,36 +1060,11 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ dfltcc_state->param.nt = 1; + dfltcc_state->param.nt = 1;
+ +
+ /* Initialize tuning parameters */ + /* Initialize tuning parameters */
+#ifndef DFLTCC_LEVEL_MASK + dfltcc_state->level_mask = env_level_mask;
+#define DFLTCC_LEVEL_MASK 0x2 + dfltcc_state->block_size = env_block_size;
+#endif + dfltcc_state->block_threshold = env_block_threshold;
+ s = secure_getenv("DFLTCC_LEVEL_MASK"); + dfltcc_state->dht_threshold = env_dht_threshold;
+ dfltcc_state->level_mask = (s && *s) ? strtoul(s, NULL, 0) : + dfltcc_state->param.ribm = env_ribm;
+ DFLTCC_LEVEL_MASK;
+#ifndef DFLTCC_BLOCK_SIZE
+#define DFLTCC_BLOCK_SIZE 1048576
+#endif
+ s = secure_getenv("DFLTCC_BLOCK_SIZE");
+ dfltcc_state->block_size = (s && *s) ? strtoul(s, NULL, 0) :
+ DFLTCC_BLOCK_SIZE;
+#ifndef DFLTCC_FIRST_FHT_BLOCK_SIZE
+#define DFLTCC_FIRST_FHT_BLOCK_SIZE 4096
+#endif
+ s = secure_getenv("DFLTCC_FIRST_FHT_BLOCK_SIZE");
+ dfltcc_state->block_threshold = (s && *s) ? strtoul(s, NULL, 0) :
+ DFLTCC_FIRST_FHT_BLOCK_SIZE;
+#ifndef DFLTCC_DHT_MIN_SAMPLE_SIZE
+#define DFLTCC_DHT_MIN_SAMPLE_SIZE 4096
+#endif
+ s = secure_getenv("DFLTCC_DHT_MIN_SAMPLE_SIZE");
+ dfltcc_state->dht_threshold = (s && *s) ? strtoul(s, NULL, 0) :
+ DFLTCC_DHT_MIN_SAMPLE_SIZE;
+#ifndef DFLTCC_RIBM
+#define DFLTCC_RIBM 0
+#endif
+ s = secure_getenv("DFLTCC_RIBM");
+ dfltcc_state->param.ribm = (s && *s) ? strtoul(s, NULL, 0) :
+ DFLTCC_RIBM;
+} +}
+ +
+voidpf ZLIB_INTERNAL dfltcc_alloc_state(strm, items, size) +voidpf ZLIB_INTERNAL dfltcc_alloc_state(strm, items, size)
@ -1034,6 +1152,28 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ return Z_OK; + return Z_OK;
+} +}
+ +
+int ZLIB_INTERNAL dfltcc_deflate_done(strm, flush)
+ z_streamp strm;
+ int flush;
+{
+ deflate_state FAR *state = (deflate_state FAR *)strm->state;
+ struct dfltcc_state FAR *dfltcc_state = GET_DFLTCC_STATE(state);
+ struct dfltcc_param_v0 FAR *param = &dfltcc_state->param;
+
+ /* When deflate(Z_FULL_FLUSH) is called with small avail_out, it might
+ * close the block without resetting the compression state. Detect this
+ * situation and return that deflation is not done.
+ */
+ if (flush == Z_FULL_FLUSH && strm->avail_out == 0)
+ return 0;
+
+ /* Return that deflation is not done if DFLTCC is used and either it
+ * buffered some data (Continuation Flag is set), or has not written EOBS
+ * yet (Block-Continuation Flag is set).
+ */
+ return !dfltcc_can_deflate(strm) || (!param->cf && !param->bcf);
+}
+
+/* +/*
+ Preloading history. + Preloading history.
+*/ +*/
@ -1087,6 +1227,7 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.c
+ +
+ append_history(param, state->window, dictionary, dict_length); + append_history(param, state->window, dictionary, dict_length);
+ state->strstart = 1; /* Add FDICT to zlib header */ + state->strstart = 1; /* Add FDICT to zlib header */
+ state->block_start = state->strstart; /* Make deflate_stored happy */
+ return Z_OK; + return Z_OK;
+} +}
+ +
@ -1121,7 +1262,7 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.h
=================================================================== ===================================================================
--- /dev/null --- /dev/null
+++ zlib-1.2.11/contrib/s390/dfltcc.h +++ zlib-1.2.11/contrib/s390/dfltcc.h
@@ -0,0 +1,55 @@ @@ -0,0 +1,81 @@
+#ifndef DFLTCC_H +#ifndef DFLTCC_H
+#define DFLTCC_H +#define DFLTCC_H
+ +
@ -1136,6 +1277,28 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.h
+voidpf ZLIB_INTERNAL dfltcc_alloc_window OF((z_streamp strm, uInt items, +voidpf ZLIB_INTERNAL dfltcc_alloc_window OF((z_streamp strm, uInt items,
+ uInt size)); + uInt size));
+void ZLIB_INTERNAL dfltcc_free_window OF((z_streamp strm, voidpf w)); +void ZLIB_INTERNAL dfltcc_free_window OF((z_streamp strm, voidpf w));
+#define DFLTCC_BLOCK_HEADER_BITS 3
+#define DFLTCC_HLITS_COUNT_BITS 5
+#define DFLTCC_HDISTS_COUNT_BITS 5
+#define DFLTCC_HCLENS_COUNT_BITS 4
+#define DFLTCC_MAX_HCLENS 19
+#define DFLTCC_HCLEN_BITS 3
+#define DFLTCC_MAX_HLITS 286
+#define DFLTCC_MAX_HDISTS 30
+#define DFLTCC_MAX_HLIT_HDIST_BITS 7
+#define DFLTCC_MAX_SYMBOL_BITS 16
+#define DFLTCC_MAX_EOBS_BITS 15
+#define DFLTCC_MAX_PADDING_BITS 7
+#define DEFLATE_BOUND_COMPLEN(source_len) \
+ ((DFLTCC_BLOCK_HEADER_BITS + \
+ DFLTCC_HLITS_COUNT_BITS + \
+ DFLTCC_HDISTS_COUNT_BITS + \
+ DFLTCC_HCLENS_COUNT_BITS + \
+ DFLTCC_MAX_HCLENS * DFLTCC_HCLEN_BITS + \
+ (DFLTCC_MAX_HLITS + DFLTCC_MAX_HDISTS) * DFLTCC_MAX_HLIT_HDIST_BITS + \
+ (source_len) * DFLTCC_MAX_SYMBOL_BITS + \
+ DFLTCC_MAX_EOBS_BITS + \
+ DFLTCC_MAX_PADDING_BITS) >> 3)
+int ZLIB_INTERNAL dfltcc_can_inflate OF((z_streamp strm)); +int ZLIB_INTERNAL dfltcc_can_inflate OF((z_streamp strm));
+typedef enum { +typedef enum {
+ DFLTCC_INFLATE_CONTINUE, + DFLTCC_INFLATE_CONTINUE,
@ -1175,13 +1338,17 @@ Index: zlib-1.2.11/contrib/s390/dfltcc.h
+ do { \ + do { \
+ if (dfltcc_was_inflate_used((strm))) return -(1L << 16); \ + if (dfltcc_was_inflate_used((strm))) return -(1L << 16); \
+ } while (0) + } while (0)
+#define INFLATE_SYNC_POINT_HOOK(strm) \
+ do { \
+ if (dfltcc_was_inflate_used((strm))) return Z_STREAM_ERROR; \
+ } while (0)
+ +
+#endif +#endif
Index: zlib-1.2.11/contrib/s390/dfltcc_deflate.h Index: zlib-1.2.11/contrib/s390/dfltcc_deflate.h
=================================================================== ===================================================================
--- /dev/null --- /dev/null
+++ zlib-1.2.11/contrib/s390/dfltcc_deflate.h +++ zlib-1.2.11/contrib/s390/dfltcc_deflate.h
@@ -0,0 +1,54 @@ @@ -0,0 +1,55 @@
+#ifndef DFLTCC_DEFLATE_H +#ifndef DFLTCC_DEFLATE_H
+#define DFLTCC_DEFLATE_H +#define DFLTCC_DEFLATE_H
+ +
@ -1195,6 +1362,7 @@ Index: zlib-1.2.11/contrib/s390/dfltcc_deflate.h
+ int level, + int level,
+ int strategy, + int strategy,
+ int *flush)); + int *flush));
+int ZLIB_INTERNAL dfltcc_deflate_done OF((z_streamp strm, int flush));
+int ZLIB_INTERNAL dfltcc_deflate_set_dictionary OF((z_streamp strm, +int ZLIB_INTERNAL dfltcc_deflate_set_dictionary OF((z_streamp strm,
+ const Bytef *dictionary, + const Bytef *dictionary,
+ uInt dict_length)); + uInt dict_length));
@ -1225,11 +1393,11 @@ Index: zlib-1.2.11/contrib/s390/dfltcc_deflate.h
+ if (err == Z_STREAM_ERROR) \ + if (err == Z_STREAM_ERROR) \
+ return err; \ + return err; \
+ } while (0) + } while (0)
+#define DEFLATE_DONE dfltcc_deflate_done
+#define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, source_len) \ +#define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, source_len) \
+ do { \ + do { \
+ if (dfltcc_can_deflate((strm))) \ + if (dfltcc_can_deflate((strm))) \
+ (complen) = (3 + 5 + 5 + 4 + 19 * 3 + (286 + 30) * 7 + \ + (complen) = DEFLATE_BOUND_COMPLEN(source_len); \
+ (source_len) * 16 + 15 + 7) >> 3; \
+ } while (0) + } while (0)
+#define DEFLATE_NEED_CONSERVATIVE_BOUND(strm) (dfltcc_can_deflate((strm))) +#define DEFLATE_NEED_CONSERVATIVE_BOUND(strm) (dfltcc_can_deflate((strm)))
+#define DEFLATE_HOOK dfltcc_deflate +#define DEFLATE_HOOK dfltcc_deflate
@ -1240,7 +1408,7 @@ Index: zlib-1.2.11/deflate.c
=================================================================== ===================================================================
--- zlib-1.2.11.orig/deflate.c --- zlib-1.2.11.orig/deflate.c
+++ zlib-1.2.11/deflate.c +++ zlib-1.2.11/deflate.c
@@ -61,15 +61,29 @@ const char deflate_copyright[] = @@ -61,15 +61,30 @@ const char deflate_copyright[] =
*/ */
/* =========================================================================== /* ===========================================================================
@ -1265,6 +1433,7 @@ Index: zlib-1.2.11/deflate.c
+#define DEFLATE_GET_DICTIONARY_HOOK(strm, dict, dict_len) do {} while (0) +#define DEFLATE_GET_DICTIONARY_HOOK(strm, dict, dict_len) do {} while (0)
+#define DEFLATE_RESET_KEEP_HOOK(strm) do {} while (0) +#define DEFLATE_RESET_KEEP_HOOK(strm) do {} while (0)
+#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) do {} while (0) +#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) do {} while (0)
+#define DEFLATE_DONE(strm, flush) 1
+#define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, sourceLen) do {} while (0) +#define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, sourceLen) do {} while (0)
+#define DEFLATE_NEED_CONSERVATIVE_BOUND(strm) 0 +#define DEFLATE_NEED_CONSERVATIVE_BOUND(strm) 0
+#define DEFLATE_HOOK(strm, flush, bstate) 0 +#define DEFLATE_HOOK(strm, flush, bstate) 0
@ -1277,7 +1446,7 @@ Index: zlib-1.2.11/deflate.c
typedef block_state (*compress_func) OF((deflate_state *s, int flush)); typedef block_state (*compress_func) OF((deflate_state *s, int flush));
/* Compression function. Returns the block state after the call. */ /* Compression function. Returns the block state after the call. */
@@ -85,7 +99,6 @@ local block_state deflate_rle OF((def @@ -85,7 +100,6 @@ local block_state deflate_rle OF((def
local block_state deflate_huff OF((deflate_state *s, int flush)); local block_state deflate_huff OF((deflate_state *s, int flush));
local void lm_init OF((deflate_state *s)); local void lm_init OF((deflate_state *s));
local void putShortMSB OF((deflate_state *s, uInt b)); local void putShortMSB OF((deflate_state *s, uInt b));
@ -1285,7 +1454,7 @@ Index: zlib-1.2.11/deflate.c
local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
#ifdef ASMV #ifdef ASMV
# pragma message("Assembler code may have bugs -- use at your own risk") # pragma message("Assembler code may have bugs -- use at your own risk")
@@ -301,7 +314,7 @@ int ZEXPORT deflateInit2_(strm, level, m @@ -291,7 +305,7 @@ int ZEXPORT deflateInit2_(strm, level, m
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
} }
if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
@ -1294,7 +1463,7 @@ Index: zlib-1.2.11/deflate.c
if (s == Z_NULL) return Z_MEM_ERROR; if (s == Z_NULL) return Z_MEM_ERROR;
strm->state = (struct internal_state FAR *)s; strm->state = (struct internal_state FAR *)s;
s->strm = strm; s->strm = strm;
@@ -318,7 +331,7 @@ int ZEXPORT deflateInit2_(strm, level, m @@ -308,7 +322,7 @@ int ZEXPORT deflateInit2_(strm, level, m
s->hash_mask = s->hash_size - 1; s->hash_mask = s->hash_size - 1;
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
@ -1303,7 +1472,7 @@ Index: zlib-1.2.11/deflate.c
s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
@@ -394,6 +407,7 @@ int ZEXPORT deflateSetDictionary (strm, @@ -426,6 +440,7 @@ int ZEXPORT deflateSetDictionary (strm,
/* when using zlib wrappers, compute Adler-32 for provided dictionary */ /* when using zlib wrappers, compute Adler-32 for provided dictionary */
if (wrap == 1) if (wrap == 1)
strm->adler = adler32(strm->adler, dictionary, dictLength); strm->adler = adler32(strm->adler, dictionary, dictLength);
@ -1311,7 +1480,7 @@ Index: zlib-1.2.11/deflate.c
s->wrap = 0; /* avoid computing Adler-32 in read_buf */ s->wrap = 0; /* avoid computing Adler-32 in read_buf */
/* if dictionary would fill window, just replace the history */ /* if dictionary would fill window, just replace the history */
@@ -452,6 +466,7 @@ int ZEXPORT deflateGetDictionary (strm, @@ -484,6 +499,7 @@ int ZEXPORT deflateGetDictionary (strm,
if (deflateStateCheck(strm)) if (deflateStateCheck(strm))
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
@ -1319,7 +1488,7 @@ Index: zlib-1.2.11/deflate.c
s = strm->state; s = strm->state;
len = s->strstart + s->lookahead; len = s->strstart + s->lookahead;
if (len > s->w_size) if (len > s->w_size)
@@ -498,6 +513,8 @@ int ZEXPORT deflateResetKeep (strm) @@ -530,6 +546,8 @@ int ZEXPORT deflateResetKeep (strm)
_tr_init(s); _tr_init(s);
@ -1328,7 +1497,7 @@ Index: zlib-1.2.11/deflate.c
return Z_OK; return Z_OK;
} }
@@ -572,6 +589,7 @@ int ZEXPORT deflateParams(strm, level, s @@ -604,6 +622,7 @@ int ZEXPORT deflateParams(strm, level, s
{ {
deflate_state *s; deflate_state *s;
compress_func func; compress_func func;
@ -1336,7 +1505,7 @@ Index: zlib-1.2.11/deflate.c
if (deflateStateCheck(strm)) return Z_STREAM_ERROR; if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state; s = strm->state;
@@ -584,12 +602,14 @@ int ZEXPORT deflateParams(strm, level, s @@ -616,15 +635,18 @@ int ZEXPORT deflateParams(strm, level, s
if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
} }
@ -1344,17 +1513,22 @@ Index: zlib-1.2.11/deflate.c
func = configuration_table[s->level].func; func = configuration_table[s->level].func;
- if ((strategy != s->strategy || func != configuration_table[level].func) && - if ((strategy != s->strategy || func != configuration_table[level].func) &&
- s->high_water) { - s->last_flush != -2) {
+ if ((strategy != s->strategy || func != configuration_table[level].func || + if (((strategy != s->strategy || func != configuration_table[level].func) &&
+ hook_flush != Z_NO_FLUSH) && s->high_water) { + s->last_flush != -2) || hook_flush != Z_NO_FLUSH) {
/* Flush the last buffer: */ /* Flush the last buffer: */
- int err = deflate(strm, Z_BLOCK); - int err = deflate(strm, Z_BLOCK);
+ int err = deflate(strm, RANK(hook_flush) > RANK(Z_BLOCK) ? + int flush = RANK(hook_flush) > RANK(Z_BLOCK) ? hook_flush : Z_BLOCK;
+ hook_flush : Z_BLOCK); + int err = deflate(strm, flush);
if (err == Z_STREAM_ERROR) if (err == Z_STREAM_ERROR)
return err; return err;
if (strm->avail_out == 0) - if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
@@ -659,6 +679,7 @@ uLong ZEXPORT deflateBound(strm, sourceL + if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead ||
+ !DEFLATE_DONE(strm, flush))
return Z_BUF_ERROR;
}
if (s->level != level) {
@@ -691,6 +713,7 @@ uLong ZEXPORT deflateBound(strm, sourceL
/* conservative upper bound for compressed data */ /* conservative upper bound for compressed data */
complen = sourceLen + complen = sourceLen +
((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
@ -1362,7 +1536,7 @@ Index: zlib-1.2.11/deflate.c
/* if can't get parameters, return conservative bound plus zlib wrapper */ /* if can't get parameters, return conservative bound plus zlib wrapper */
if (deflateStateCheck(strm)) if (deflateStateCheck(strm))
@@ -700,7 +721,8 @@ uLong ZEXPORT deflateBound(strm, sourceL @@ -732,7 +755,8 @@ uLong ZEXPORT deflateBound(strm, sourceL
} }
/* if not default parameters, return conservative bound */ /* if not default parameters, return conservative bound */
@ -1372,7 +1546,7 @@ Index: zlib-1.2.11/deflate.c
return complen + wraplen; return complen + wraplen;
/* default settings: return tight bound for that case */ /* default settings: return tight bound for that case */
@@ -727,7 +749,7 @@ local void putShortMSB (s, b) @@ -759,7 +783,7 @@ local void putShortMSB (s, b)
* applications may wish to modify it to avoid allocating a large * applications may wish to modify it to avoid allocating a large
* strm->next_out buffer and copying into it. (See also read_buf()). * strm->next_out buffer and copying into it. (See also read_buf()).
*/ */
@ -1381,7 +1555,7 @@ Index: zlib-1.2.11/deflate.c
z_streamp strm; z_streamp strm;
{ {
unsigned len; unsigned len;
@@ -997,7 +1019,8 @@ int ZEXPORT deflate (strm, flush) @@ -1029,7 +1053,8 @@ int ZEXPORT deflate (strm, flush)
(flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
block_state bstate; block_state bstate;
@ -1391,7 +1565,7 @@ Index: zlib-1.2.11/deflate.c
s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
s->strategy == Z_RLE ? deflate_rle(s, flush) : s->strategy == Z_RLE ? deflate_rle(s, flush) :
(*(configuration_table[s->level].func))(s, flush); (*(configuration_table[s->level].func))(s, flush);
@@ -1086,9 +1109,9 @@ int ZEXPORT deflateEnd (strm) @@ -1118,9 +1143,9 @@ int ZEXPORT deflateEnd (strm)
TRY_FREE(strm, strm->state->pending_buf); TRY_FREE(strm, strm->state->pending_buf);
TRY_FREE(strm, strm->state->head); TRY_FREE(strm, strm->state->head);
TRY_FREE(strm, strm->state->prev); TRY_FREE(strm, strm->state->prev);
@ -1403,7 +1577,7 @@ Index: zlib-1.2.11/deflate.c
strm->state = Z_NULL; strm->state = Z_NULL;
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
@@ -1119,13 +1142,13 @@ int ZEXPORT deflateCopy (dest, source) @@ -1150,13 +1175,13 @@ int ZEXPORT deflateCopy (dest, source)
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
@ -1419,8 +1593,8 @@ Index: zlib-1.2.11/deflate.c
+ ds->window = (Bytef *) ZALLOC_WINDOW(dest, ds->w_size, 2*sizeof(Byte)); + ds->window = (Bytef *) ZALLOC_WINDOW(dest, ds->w_size, 2*sizeof(Byte));
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); ds->pending_buf = (uchf *) ZALLOC(dest, ds->lit_bufsize, 4);
@@ -1174,7 +1197,8 @@ local unsigned read_buf(strm, buf, size) @@ -1203,7 +1228,8 @@ local unsigned read_buf(strm, buf, size)
strm->avail_in -= len; strm->avail_in -= len;
zmemcpy(buf, strm->next_in, len); zmemcpy(buf, strm->next_in, len);
@ -1434,7 +1608,7 @@ Index: zlib-1.2.11/deflate.h
=================================================================== ===================================================================
--- zlib-1.2.11.orig/deflate.h --- zlib-1.2.11.orig/deflate.h
+++ zlib-1.2.11/deflate.h +++ zlib-1.2.11/deflate.h
@@ -304,6 +304,7 @@ void ZLIB_INTERNAL _tr_flush_bits OF((de @@ -299,6 +299,7 @@ void ZLIB_INTERNAL _tr_flush_bits OF((de
void ZLIB_INTERNAL _tr_align 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, void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
ulg stored_len, int last)); ulg stored_len, int last));
@ -1442,7 +1616,7 @@ Index: zlib-1.2.11/deflate.h
#define d_code(dist) \ #define d_code(dist) \
((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
@@ -346,4 +347,15 @@ void ZLIB_INTERNAL _tr_stored_block OF(( @@ -343,4 +344,15 @@ void ZLIB_INTERNAL _tr_stored_block OF((
flush = _tr_tally(s, distance, length) flush = _tr_tally(s, distance, length)
#endif #endif
@ -1478,7 +1652,7 @@ Index: zlib-1.2.11/inflate.c
=================================================================== ===================================================================
--- zlib-1.2.11.orig/inflate.c --- zlib-1.2.11.orig/inflate.c
+++ zlib-1.2.11/inflate.c +++ zlib-1.2.11/inflate.c
@@ -85,6 +85,23 @@ @@ -85,6 +85,24 @@
#include "inflate.h" #include "inflate.h"
#include "inffast.h" #include "inffast.h"
@ -1497,12 +1671,13 @@ Index: zlib-1.2.11/inflate.c
+#define INFLATE_NEED_CHECKSUM(strm) 1 +#define INFLATE_NEED_CHECKSUM(strm) 1
+#define INFLATE_NEED_UPDATEWINDOW(strm) 1 +#define INFLATE_NEED_UPDATEWINDOW(strm) 1
+#define INFLATE_MARK_HOOK(strm) do {} while (0) +#define INFLATE_MARK_HOOK(strm) do {} while (0)
+#define INFLATE_SYNC_POINT_HOOK(strm) do {} while (0)
+#endif +#endif
+ +
#ifdef MAKEFIXED #ifdef MAKEFIXED
# ifndef BUILDFIXED # ifndef BUILDFIXED
# define BUILDFIXED # define BUILDFIXED
@@ -137,6 +154,7 @@ z_streamp strm; @@ -137,6 +155,7 @@ z_streamp strm;
state->lencode = state->distcode = state->next = state->codes; state->lencode = state->distcode = state->next = state->codes;
state->sane = 1; state->sane = 1;
state->back = -1; state->back = -1;
@ -1510,7 +1685,7 @@ Index: zlib-1.2.11/inflate.c
Tracev((stderr, "inflate: reset\n")); Tracev((stderr, "inflate: reset\n"));
return Z_OK; return Z_OK;
} }
@@ -182,7 +200,7 @@ int windowBits; @@ -182,7 +201,7 @@ int windowBits;
if (windowBits && (windowBits < 8 || windowBits > 15)) if (windowBits && (windowBits < 8 || windowBits > 15))
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
@ -1519,7 +1694,7 @@ Index: zlib-1.2.11/inflate.c
state->window = Z_NULL; state->window = Z_NULL;
} }
@@ -221,7 +239,7 @@ int stream_size; @@ -218,7 +237,7 @@ int stream_size;
strm->zfree = zcfree; strm->zfree = zcfree;
#endif #endif
state = (struct inflate_state FAR *) state = (struct inflate_state FAR *)
@ -1528,7 +1703,7 @@ Index: zlib-1.2.11/inflate.c
if (state == Z_NULL) return Z_MEM_ERROR; if (state == Z_NULL) return Z_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n")); Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state; strm->state = (struct internal_state FAR *)state;
@@ -230,7 +248,7 @@ int stream_size; @@ -227,7 +246,7 @@ int stream_size;
state->mode = HEAD; /* to pass state test in inflateReset2() */ state->mode = HEAD; /* to pass state test in inflateReset2() */
ret = inflateReset2(strm, windowBits); ret = inflateReset2(strm, windowBits);
if (ret != Z_OK) { if (ret != Z_OK) {
@ -1537,7 +1712,7 @@ Index: zlib-1.2.11/inflate.c
strm->state = Z_NULL; strm->state = Z_NULL;
} }
return ret; return ret;
@@ -252,6 +270,7 @@ int value; @@ -249,6 +268,7 @@ int value;
struct inflate_state FAR *state; struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR; if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
@ -1545,7 +1720,7 @@ Index: zlib-1.2.11/inflate.c
state = (struct inflate_state FAR *)strm->state; state = (struct inflate_state FAR *)strm->state;
if (bits < 0) { if (bits < 0) {
state->hold = 0; state->hold = 0;
@@ -379,6 +398,27 @@ void makefixed() @@ -376,6 +396,27 @@ void makefixed()
} }
#endif /* MAKEFIXED */ #endif /* MAKEFIXED */
@ -1573,7 +1748,7 @@ Index: zlib-1.2.11/inflate.c
/* /*
Update the window with the last wsize (normally 32K) bytes written before Update the window with the last wsize (normally 32K) bytes written before
returning. If window does not exist yet, create it. This is only called returning. If window does not exist yet, create it. This is only called
@@ -403,20 +443,7 @@ unsigned copy; @@ -400,20 +441,7 @@ unsigned copy;
state = (struct inflate_state FAR *)strm->state; state = (struct inflate_state FAR *)strm->state;
@ -1595,7 +1770,7 @@ Index: zlib-1.2.11/inflate.c
/* copy state->wsize or less output bytes into the circular window */ /* copy state->wsize or less output bytes into the circular window */
if (copy >= state->wsize) { if (copy >= state->wsize) {
@@ -849,6 +876,7 @@ int flush; @@ -846,6 +874,7 @@ int flush;
case TYPE: case TYPE:
if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
case TYPEDO: case TYPEDO:
@ -1603,7 +1778,7 @@ Index: zlib-1.2.11/inflate.c
if (state->last) { if (state->last) {
BYTEBITS(); BYTEBITS();
state->mode = CHECK; state->mode = CHECK;
@@ -1200,7 +1228,7 @@ int flush; @@ -1197,7 +1226,7 @@ int flush;
out -= left; out -= left;
strm->total_out += out; strm->total_out += out;
state->total += out; state->total += out;
@ -1612,7 +1787,7 @@ Index: zlib-1.2.11/inflate.c
strm->adler = state->check = strm->adler = state->check =
UPDATE(state->check, put - out, out); UPDATE(state->check, put - out, out);
out = left; out = left;
@@ -1252,8 +1280,9 @@ int flush; @@ -1249,8 +1278,9 @@ int flush;
*/ */
inf_leave: inf_leave:
RESTORE(); RESTORE();
@ -1624,7 +1799,7 @@ Index: zlib-1.2.11/inflate.c
if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
state->mode = MEM; state->mode = MEM;
return Z_MEM_ERROR; return Z_MEM_ERROR;
@@ -1263,7 +1292,7 @@ int flush; @@ -1260,7 +1290,7 @@ int flush;
strm->total_in += in; strm->total_in += in;
strm->total_out += out; strm->total_out += out;
state->total += out; state->total += out;
@ -1633,7 +1808,7 @@ Index: zlib-1.2.11/inflate.c
strm->adler = state->check = strm->adler = state->check =
UPDATE(state->check, strm->next_out - out, out); UPDATE(state->check, strm->next_out - out, out);
strm->data_type = (int)state->bits + (state->last ? 64 : 0) + strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
@@ -1281,8 +1310,8 @@ z_streamp strm; @@ -1278,8 +1308,8 @@ z_streamp strm;
if (inflateStateCheck(strm)) if (inflateStateCheck(strm))
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state; state = (struct inflate_state FAR *)strm->state;
@ -1644,7 +1819,15 @@ Index: zlib-1.2.11/inflate.c
strm->state = Z_NULL; strm->state = Z_NULL;
Tracev((stderr, "inflate: end\n")); Tracev((stderr, "inflate: end\n"));
return Z_OK; return Z_OK;
@@ -1474,21 +1503,22 @@ z_streamp source; @@ -1451,6 +1481,7 @@ z_streamp strm;
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ INFLATE_SYNC_POINT_HOOK(strm);
state = (struct inflate_state FAR *)strm->state;
return state->mode == STORED && state->bits == 0;
}
@@ -1471,21 +1502,22 @@ z_streamp source;
/* allocate space */ /* allocate space */
copy = (struct inflate_state FAR *) copy = (struct inflate_state FAR *)
@ -1671,7 +1854,7 @@ Index: zlib-1.2.11/inflate.c
copy->strm = dest; copy->strm = dest;
if (state->lencode >= state->codes && if (state->lencode >= state->codes &&
state->lencode <= state->codes + ENOUGH - 1) { state->lencode <= state->codes + ENOUGH - 1) {
@@ -1545,6 +1575,7 @@ z_streamp strm; @@ -1542,6 +1574,7 @@ z_streamp strm;
if (inflateStateCheck(strm)) if (inflateStateCheck(strm))
return -(1L << 16); return -(1L << 16);
@ -1693,6 +1876,15 @@ Index: zlib-1.2.11/test/infcover.c
=================================================================== ===================================================================
--- zlib-1.2.11.orig/test/infcover.c --- zlib-1.2.11.orig/test/infcover.c
+++ zlib-1.2.11/test/infcover.c +++ zlib-1.2.11/test/infcover.c
@@ -373,7 +373,7 @@ local void cover_support(void)
mem_setup(&strm);
strm.avail_in = 0;
strm.next_in = Z_NULL;
- ret = inflateInit_(&strm, ZLIB_VERSION - 1, (int)sizeof(z_stream));
+ ret = inflateInit_(&strm, &ZLIB_VERSION[1], (int)sizeof(z_stream));
assert(ret == Z_VERSION_ERROR);
mem_done(&strm, "wrong version");
@@ -444,7 +444,7 @@ local void cover_wrap(void) @@ -444,7 +444,7 @@ local void cover_wrap(void)
} }
@ -1745,7 +1937,7 @@ Index: zlib-1.2.11/trees.c
/* the arguments must not have side effects */ /* the arguments must not have side effects */
@@ -1155,7 +1160,7 @@ local int detect_data_type(s) @@ -1133,7 +1138,7 @@ local int detect_data_type(s)
* method would use a table) * method would use a table)
* IN assertion: 1 <= len <= 15 * IN assertion: 1 <= len <= 15
*/ */
@ -1754,7 +1946,7 @@ Index: zlib-1.2.11/trees.c
unsigned code; /* the value to invert */ unsigned code; /* the value to invert */
int len; /* its bit length */ int len; /* its bit length */
{ {
@@ -1187,7 +1192,7 @@ local void bi_flush(s) @@ -1165,7 +1170,7 @@ local void bi_flush(s)
/* =========================================================================== /* ===========================================================================
* Flush the bit buffer and align the output on a byte boundary * Flush the bit buffer and align the output on a byte boundary
*/ */
@ -1763,3 +1955,16 @@ Index: zlib-1.2.11/trees.c
deflate_state *s; deflate_state *s;
{ {
if (s->bi_valid > 8) { if (s->bi_valid > 8) {
Index: zlib-1.2.11/zutil.h
===================================================================
--- zlib-1.2.11.orig/zutil.h
+++ zlib-1.2.11/zutil.h
@@ -80,6 +80,8 @@ extern z_const char * const z_errmsg[10]
#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+#define ZLIB_WRAPLEN 6 /* zlib format overhead */
+
/* target dependencies */
#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))

34
bsc1174551-fxi-imcomplete-raw-streams.patch
View File

@ -1,34 +0,0 @@
diff --git a/deflate.c b/deflate.c
index 3c302bc..1ab1635 100644
--- a/deflate.c
+++ b/deflate.c
@@ -1110,7 +1110,6 @@ int ZEXPORT deflate (strm, flush)
}
if (flush != Z_FINISH) return Z_OK;
- if (s->wrap <= 0) return Z_STREAM_END;
/* Write the trailer */
#ifdef GZIP
@@ -1126,7 +1125,7 @@ int ZEXPORT deflate (strm, flush)
}
else
#endif
- {
+ if (s->wrap == 1) {
putShortMSB(s, (uInt)(strm->adler >> 16));
putShortMSB(s, (uInt)(strm->adler & 0xffff));
}
@@ -1135,7 +1134,11 @@ int ZEXPORT deflate (strm, flush)
* to flush the rest.
*/
if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
- return s->pending != 0 ? Z_OK : Z_STREAM_END;
+ if (s->pending == 0) {
+ Assert(s->bi_valid == 0, "bi_buf not flushed");
+ return Z_STREAM_END;
+ }
+ return Z_OK;
}
/* ========================================================================= */

11
bsc1174736-DFLTCC_LEVEL_MASK-set-to-0x1ff.patch
View File

@ -11,15 +11,14 @@ Index: zlib-1.2.11/deflate.c
_tr_init(s); _tr_init(s);
@@ -601,13 +601,13 @@ int ZEXPORT deflateParams(strm, level, s @@ -582,12 +582,12 @@ int ZEXPORT deflateParams(strm, level, s
func = configuration_table[s->level].func; func = configuration_table[s->level].func;
if ((strategy != s->strategy || func != configuration_table[level].func || if ((strategy != s->strategy || func != configuration_table[level].func) &&
- hook_flush != Z_NO_FLUSH) && s->high_water) { - s->high_water) {
+ hook_flush != Z_NO_FLUSH) && s->last_flush != -2) { + s->last_flush != -2) {
/* Flush the last buffer: */ /* Flush the last buffer: */
int err = deflate(strm, RANK(hook_flush) > RANK(Z_BLOCK) ? int err = deflate(strm, Z_BLOCK);
hook_flush : Z_BLOCK);
if (err == Z_STREAM_ERROR) if (err == Z_STREAM_ERROR)
return err; return err;
- if (strm->avail_out == 0) - if (strm->avail_out == 0)

343
bsc1197459.patch Normal file
View File

@ -0,0 +1,343 @@
From 5c44459c3b28a9bd3283aaceab7c615f8020c531 Mon Sep 17 00:00:00 2001
From: Mark Adler <madler@alumni.caltech.edu>
Date: Tue, 17 Apr 2018 22:09:22 -0700
Subject: [PATCH] Fix a bug that can crash deflate on some input when using
Z_FIXED.
This bug was reported by Danilo Ramos of Eideticom, Inc. It has
lain in wait 13 years before being found! The bug was introduced
in zlib 1.2.2.2, with the addition of the Z_FIXED option. That
option forces the use of fixed Huffman codes. For rare inputs with
a large number of distant matches, the pending buffer into which
the compressed data is written can overwrite the distance symbol
table which it overlays. That results in corrupted output due to
invalid distances, and can result in out-of-bound accesses,
crashing the application.
The fix here combines the distance buffer and literal/length
buffers into a single symbol buffer. Now three bytes of pending
buffer space are opened up for each literal or length/distance
pair consumed, instead of the previous two bytes. This assures
that the pending buffer cannot overwrite the symbol table, since
the maximum fixed code compressed length/distance is 31 bits, and
since there are four bytes of pending space for every three bytes
of symbol space.
---
deflate.c | 74 ++++++++++++++++++++++++++++++++++++++++---------------
deflate.h | 25 +++++++++----------
trees.c | 50 +++++++++++--------------------------
3 files changed, 79 insertions(+), 70 deletions(-)
Index: zlib-1.2.11/deflate.c
===================================================================
--- zlib-1.2.11.orig/deflate.c
+++ zlib-1.2.11/deflate.c
@@ -251,11 +251,6 @@ int ZEXPORT deflateInit2_(strm, level, m
deflate_state *s;
int wrap = 1;
- ushf *overlay;
- /* We overlay pending_buf and d_buf+l_buf. This works since the average
- * output size for (length,distance) codes is <= 24 bits.
- */
-
if (strm == Z_NULL) return Z_STREAM_ERROR;
strm->msg = Z_NULL;
@@ -321,9 +316,47 @@ int ZEXPORT deflateInit2_(strm, level, m
s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
- overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
- s->pending_buf = (uchf *) overlay;
- s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+ /* We overlay pending_buf and sym_buf. This works since the average size
+ * for length/distance pairs over any compressed block is assured to be 31
+ * bits or less.
+ *
+ * Analysis: The longest fixed codes are a length code of 8 bits plus 5
+ * extra bits, for lengths 131 to 257. The longest fixed distance codes are
+ * 5 bits plus 13 extra bits, for distances 16385 to 32768. The longest
+ * possible fixed-codes length/distance pair is then 31 bits total.
+ *
+ * sym_buf starts one-fourth of the way into pending_buf. So there are
+ * three bytes in sym_buf for every four bytes in pending_buf. Each symbol
+ * in sym_buf is three bytes -- two for the distance and one for the
+ * literal/length. As each symbol is consumed, the pointer to the next
+ * sym_buf value to read moves forward three bytes. From that symbol, up to
+ * 31 bits are written to pending_buf. The closest the written pending_buf
+ * bits gets to the next sym_buf symbol to read is just before the last
+ * code is written. At that time, 31*(n-2) bits have been written, just
+ * after 24*(n-2) bits have been consumed from sym_buf. sym_buf starts at
+ * 8*n bits into pending_buf. (Note that the symbol buffer fills when n-1
+ * symbols are written.) The closest the writing gets to what is unread is
+ * then n+14 bits. Here n is lit_bufsize, which is 16384 by default, and
+ * can range from 128 to 32768.
+ *
+ * Therefore, at a minimum, there are 142 bits of space between what is
+ * written and what is read in the overlain buffers, so the symbols cannot
+ * be overwritten by the compressed data. That space is actually 139 bits,
+ * due to the three-bit fixed-code block header.
+ *
+ * That covers the case where either Z_FIXED is specified, forcing fixed
+ * codes, or when the use of fixed codes is chosen, because that choice
+ * results in a smaller compressed block than dynamic codes. That latter
+ * condition then assures that the above analysis also covers all dynamic
+ * blocks. A dynamic-code block will only be chosen to be emitted if it has
+ * fewer bits than a fixed-code block would for the same set of symbols.
+ * Therefore its average symbol length is assured to be less than 31. So
+ * the compressed data for a dynamic block also cannot overwrite the
+ * symbols from which it is being constructed.
+ */
+
+ s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 4);
+ s->pending_buf_size = (ulg)s->lit_bufsize * 4;
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
s->pending_buf == Z_NULL) {
@@ -332,8 +365,12 @@ int ZEXPORT deflateInit2_(strm, level, m
deflateEnd (strm);
return Z_MEM_ERROR;
}
- s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
- s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+ s->sym_buf = s->pending_buf + s->lit_bufsize;
+ s->sym_end = (s->lit_bufsize - 1) * 3;
+ /* We avoid equality with lit_bufsize*3 because of wraparound at 64K
+ * on 16 bit machines and because stored blocks are restricted to
+ * 64K-1 bytes.
+ */
s->level = level;
s->strategy = strategy;
@@ -544,7 +581,7 @@ int ZEXPORT deflatePrime (strm, bits, va
if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
- if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
+ if (s->sym_buf < s->pending_out + ((Buf_size + 7) >> 3))
return Z_BUF_ERROR;
do {
put = Buf_size - s->bi_valid;
@@ -1103,7 +1140,6 @@ int ZEXPORT deflateCopy (dest, source)
#else
deflate_state *ds;
deflate_state *ss;
- ushf *overlay;
if (deflateStateCheck(source) || dest == Z_NULL) {
@@ -1123,8 +1159,7 @@ int ZEXPORT deflateCopy (dest, source)
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
- overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
- ds->pending_buf = (uchf *) overlay;
+ ds->pending_buf = (uchf *) ZALLOC(dest, ds->lit_bufsize, 4);
if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
ds->pending_buf == Z_NULL) {
@@ -1138,8 +1173,7 @@ int ZEXPORT deflateCopy (dest, source)
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
- ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
- ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+ ds->sym_buf = ds->pending_buf + ds->lit_bufsize;
ds->l_desc.dyn_tree = ds->dyn_ltree;
ds->d_desc.dyn_tree = ds->dyn_dtree;
@@ -1911,7 +1945,7 @@ local block_state deflate_fast(s, flush)
FLUSH_BLOCK(s, 1);
return finish_done;
}
- if (s->last_lit)
+ if (s->sym_next)
FLUSH_BLOCK(s, 0);
return block_done;
}
@@ -2042,7 +2076,7 @@ local block_state deflate_slow(s, flush)
FLUSH_BLOCK(s, 1);
return finish_done;
}
- if (s->last_lit)
+ if (s->sym_next)
FLUSH_BLOCK(s, 0);
return block_done;
}
@@ -2117,7 +2151,7 @@ local block_state deflate_rle(s, flush)
FLUSH_BLOCK(s, 1);
return finish_done;
}
- if (s->last_lit)
+ if (s->sym_next)
FLUSH_BLOCK(s, 0);
return block_done;
}
@@ -2156,7 +2190,7 @@ local block_state deflate_huff(s, flush)
FLUSH_BLOCK(s, 1);
return finish_done;
}
- if (s->last_lit)
+ if (s->sym_next)
FLUSH_BLOCK(s, 0);
return block_done;
}
Index: zlib-1.2.11/deflate.h
===================================================================
--- zlib-1.2.11.orig/deflate.h
+++ zlib-1.2.11/deflate.h
@@ -217,7 +217,7 @@ typedef struct internal_state {
/* Depth of each subtree used as tie breaker for trees of equal frequency
*/
- uchf *l_buf; /* buffer for literals or lengths */
+ uchf *sym_buf; /* buffer for distances and literals/lengths */
uInt lit_bufsize;
/* Size of match buffer for literals/lengths. There are 4 reasons for
@@ -239,13 +239,8 @@ typedef struct internal_state {
* - I can't count above 4
*/
- uInt last_lit; /* running index in l_buf */
-
- ushf *d_buf;
- /* Buffer for distances. To simplify the code, d_buf and l_buf have
- * the same number of elements. To use different lengths, an extra flag
- * array would be necessary.
- */
+ uInt sym_next; /* running index in sym_buf */
+ uInt sym_end; /* symbol table full when sym_next reaches this */
ulg opt_len; /* bit length of current block with optimal trees */
ulg static_len; /* bit length of current block with static trees */
@@ -325,20 +320,22 @@ void ZLIB_INTERNAL _tr_stored_block OF((
# define _tr_tally_lit(s, c, flush) \
{ uch cc = (c); \
- s->d_buf[s->last_lit] = 0; \
- s->l_buf[s->last_lit++] = cc; \
+ s->sym_buf[s->sym_next++] = 0; \
+ s->sym_buf[s->sym_next++] = 0; \
+ s->sym_buf[s->sym_next++] = cc; \
s->dyn_ltree[cc].Freq++; \
- flush = (s->last_lit == s->lit_bufsize-1); \
+ flush = (s->sym_next == s->sym_end); \
}
# define _tr_tally_dist(s, distance, length, flush) \
{ uch len = (uch)(length); \
ush dist = (ush)(distance); \
- s->d_buf[s->last_lit] = dist; \
- s->l_buf[s->last_lit++] = len; \
+ s->sym_buf[s->sym_next++] = dist; \
+ s->sym_buf[s->sym_next++] = dist >> 8; \
+ s->sym_buf[s->sym_next++] = len; \
dist--; \
s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
s->dyn_dtree[d_code(dist)].Freq++; \
- flush = (s->last_lit == s->lit_bufsize-1); \
+ flush = (s->sym_next == s->sym_end); \
}
#else
# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
Index: zlib-1.2.11/trees.c
===================================================================
--- zlib-1.2.11.orig/trees.c
+++ zlib-1.2.11/trees.c
@@ -416,7 +416,7 @@ local void init_block(s)
s->dyn_ltree[END_BLOCK].Freq = 1;
s->opt_len = s->static_len = 0L;
- s->last_lit = s->matches = 0;
+ s->sym_next = s->matches = 0;
}
#define SMALLEST 1
@@ -947,7 +947,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, bu
Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
- s->last_lit));
+ s->sym_next / 3));
if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
@@ -1016,8 +1016,9 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc
unsigned dist; /* distance of matched string */
unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
{
- s->d_buf[s->last_lit] = (ush)dist;
- s->l_buf[s->last_lit++] = (uch)lc;
+ s->sym_buf[s->sym_next++] = dist;
+ s->sym_buf[s->sym_next++] = dist >> 8;
+ s->sym_buf[s->sym_next++] = lc;
if (dist == 0) {
/* lc is the unmatched char */
s->dyn_ltree[lc].Freq++;
@@ -1032,30 +1033,7 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc
s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
s->dyn_dtree[d_code(dist)].Freq++;
}
-
-#ifdef TRUNCATE_BLOCK
- /* Try to guess if it is profitable to stop the current block here */
- if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
- /* Compute an upper bound for the compressed length */
- ulg out_length = (ulg)s->last_lit*8L;
- ulg in_length = (ulg)((long)s->strstart - s->block_start);
- int dcode;
- for (dcode = 0; dcode < D_CODES; dcode++) {
- out_length += (ulg)s->dyn_dtree[dcode].Freq *
- (5L+extra_dbits[dcode]);
- }
- out_length >>= 3;
- Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
- s->last_lit, in_length, out_length,
- 100L - out_length*100L/in_length));
- if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
- }
-#endif
- return (s->last_lit == s->lit_bufsize-1);
- /* We avoid equality with lit_bufsize because of wraparound at 64K
- * on 16 bit machines and because stored blocks are restricted to
- * 64K-1 bytes.
- */
+ return (s->sym_next == s->sym_end);
}
/* ===========================================================================
@@ -1068,13 +1046,14 @@ local void compress_block(s, ltree, dtre
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
- unsigned lx = 0; /* running index in l_buf */
+ unsigned sx = 0; /* running index in sym_buf */
unsigned code; /* the code to send */
int extra; /* number of extra bits to send */
- if (s->last_lit != 0) do {
- dist = s->d_buf[lx];
- lc = s->l_buf[lx++];
+ if (s->sym_next != 0) do {
+ dist = s->sym_buf[sx++] & 0xff;
+ dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8;
+ lc = s->sym_buf[sx++];
if (dist == 0) {
send_code(s, lc, ltree); /* send a literal byte */
Tracecv(isgraph(lc), (stderr," '%c' ", lc));
@@ -1099,11 +1078,10 @@ local void compress_block(s, ltree, dtre
}
} /* literal or match pair ? */
- /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
- Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
- "pendingBuf overflow");
+ /* Check that the overlay between pending_buf and sym_buf is ok: */
+ Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow");
- } while (lx < s->last_lit);
+ } while (sx < s->sym_next);
send_code(s, END_BLOCK, ltree);
}

32
minizip-dont-install-crypt-header.patch Normal file
View File

@ -0,0 +1,32 @@
From e490ddad3091574a0c2e3b5a66a8fee9a7ab212f Mon Sep 17 00:00:00 2001
From: Pavel Raiskup <praiskup@redhat.com>
Date: Sun, 19 Feb 2017 16:42:12 +0100
Subject: [PATCH] minizip: don't install crypt.h
People did mistakenly or unintentionally include crypt.h before,
don't install this internal header from now.
---
contrib/minizip/Makefile.am | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/contrib/minizip/Makefile.am b/contrib/minizip/Makefile.am
index d343011eb..4f4661023 100644
--- a/contrib/minizip/Makefile.am
+++ b/contrib/minizip/Makefile.am
@@ -26,13 +26,15 @@ libminizip_la_LDFLAGS = $(AM_LDFLAGS) -version-info 1:0:0 -lz
minizip_includedir = $(includedir)/minizip
minizip_include_HEADERS = \
- crypt.h \
ioapi.h \
mztools.h \
unzip.h \
zip.h \
${iowin32_h}
+noinst_HEADERS = \
+ crypt.h
+
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = minizip.pc

184
zlib-compression-switching.patch
View File

@ -1,184 +0,0 @@
Index: zlib-1.2.11/configure
===================================================================
--- zlib-1.2.11.orig/configure
+++ zlib-1.2.11/configure
@@ -923,7 +923,7 @@ cat > $test.c << EOF
#include <sys/sdt.h>
int main() { return 0; }
EOF
-if try ${CC} ${CFLAGS} $test.c; then
+if try $CC -c $CFLAGS $test.c; then
echo "Checking for sys/sdt.h ... Yes." | tee -a configure.log
CFLAGS="$CFLAGS -DHAVE_SYS_SDT_H"
SFLAGS="$SFLAGS -DHAVE_SYS_SDT_H"
Index: zlib-1.2.11/contrib/s390/dfltcc.c
===================================================================
--- zlib-1.2.11.orig/contrib/s390/dfltcc.c
+++ zlib-1.2.11/contrib/s390/dfltcc.c
@@ -350,8 +350,12 @@ int ZLIB_INTERNAL dfltcc_deflate(strm, f
int soft_bcc;
int no_flush;
- if (!dfltcc_can_deflate(strm))
+ if (!dfltcc_can_deflate(strm)) {
+ /* Clear history. */
+ if (flush == Z_FULL_FLUSH)
+ param->hl = 0;
return 0;
+ }
again:
masked_avail_in = 0;
@@ -376,7 +380,8 @@ again:
/* Clear history. */
if (flush == Z_FULL_FLUSH)
param->hl = 0;
- *result = need_more;
+ /* Trigger block post-processing if necessary. */
+ *result = no_flush ? need_more : block_done;
return 1;
}
@@ -403,13 +408,18 @@ again:
param->bcf = 0;
dfltcc_state->block_threshold =
strm->total_in + dfltcc_state->block_size;
- if (strm->avail_out == 0) {
- *result = need_more;
- return 1;
- }
}
}
+ /* No space for compressed data. If we proceed, dfltcc_cmpr() will return
+ * DFLTCC_CC_OP1_TOO_SHORT without buffering header bits, but we will still
+ * set BCF=1, which is wrong. Avoid complications and return early.
+ */
+ if (strm->avail_out == 0) {
+ *result = need_more;
+ return 1;
+ }
+
/* The caller gave us too much data. Pass only one block worth of
* uncompressed data to DFLTCC and mask the rest, so that on the next
* iteration we start a new block.
@@ -679,10 +689,15 @@ local inline int is_dfltcc_enabled(void)
* compiling with -m31, gcc defaults to ESA mode, however, since the kernel
* is 64-bit, it's always z/Architecture mode at runtime.
*/
- __asm__ volatile(".machinemode push\n"
+ __asm__ volatile(
+#ifndef __clang__
+ ".machinemode push\n"
".machinemode zarch\n"
+#endif
"stfle %[facilities]\n"
+#ifndef __clang__
".machinemode pop\n"
+#endif
: [facilities] "=Q" (facilities)
, [r0] "+r" (r0)
:
@@ -835,6 +850,28 @@ int ZLIB_INTERNAL dfltcc_deflate_params(
return Z_OK;
}
+int ZLIB_INTERNAL dfltcc_deflate_done(strm, flush)
+ z_streamp strm;
+ int flush;
+{
+ deflate_state FAR *state = (deflate_state FAR *)strm->state;
+ struct dfltcc_state FAR *dfltcc_state = GET_DFLTCC_STATE(state);
+ struct dfltcc_param_v0 FAR *param = &dfltcc_state->param;
+
+ /* When deflate(Z_FULL_FLUSH) is called with small avail_out, it might
+ * close the block without resetting the compression state. Detect this
+ * situation and return that deflation is not done.
+ */
+ if (flush == Z_FULL_FLUSH && strm->avail_out == 0)
+ return 0;
+
+ /* Return that deflation is not done if DFLTCC is used and either it
+ * buffered some data (Continuation Flag is set), or has not written EOBS
+ * yet (Block-Continuation Flag is set).
+ */
+ return !dfltcc_can_deflate(strm) || (!param->cf && !param->bcf);
+}
+
/*
Preloading history.
*/
@@ -888,6 +925,7 @@ int ZLIB_INTERNAL dfltcc_deflate_set_dic
append_history(param, state->window, dictionary, dict_length);
state->strstart = 1; /* Add FDICT to zlib header */
+ state->block_start = state->strstart; /* Make deflate_stored happy */
return Z_OK;
}
Index: zlib-1.2.11/contrib/s390/dfltcc_deflate.h
===================================================================
--- zlib-1.2.11.orig/contrib/s390/dfltcc_deflate.h
+++ zlib-1.2.11/contrib/s390/dfltcc_deflate.h
@@ -11,6 +11,7 @@ int ZLIB_INTERNAL dfltcc_deflate_params
int level,
int strategy,
int *flush));
+int ZLIB_INTERNAL dfltcc_deflate_done OF((z_streamp strm, int flush));
int ZLIB_INTERNAL dfltcc_deflate_set_dictionary OF((z_streamp strm,
const Bytef *dictionary,
uInt dict_length));
@@ -41,6 +42,7 @@ int ZLIB_INTERNAL dfltcc_deflate_get_dic
if (err == Z_STREAM_ERROR) \
return err; \
} while (0)
+#define DEFLATE_DONE dfltcc_deflate_done
#define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, source_len) \
do { \
if (dfltcc_can_deflate((strm))) \
Index: zlib-1.2.11/deflate.c
===================================================================
--- zlib-1.2.11.orig/deflate.c
+++ zlib-1.2.11/deflate.c
@@ -75,6 +75,7 @@ const char deflate_copyright[] =
#define DEFLATE_GET_DICTIONARY_HOOK(strm, dict, dict_len) do {} while (0)
#define DEFLATE_RESET_KEEP_HOOK(strm) do {} while (0)
#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) do {} while (0)
+#define DEFLATE_DONE(strm, flush) 1
#define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, sourceLen) do {} while (0)
#define DEFLATE_NEED_CONSERVATIVE_BOUND(strm) 0
#define DEFLATE_HOOK(strm, flush, bstate) 0
@@ -600,14 +601,15 @@ int ZEXPORT deflateParams(strm, level, s
DEFLATE_PARAMS_HOOK(strm, level, strategy, &hook_flush);
func = configuration_table[s->level].func;
- if ((strategy != s->strategy || func != configuration_table[level].func ||
- hook_flush != Z_NO_FLUSH) && s->last_flush != -2) {
+ if (((strategy != s->strategy || func != configuration_table[level].func) &&
+ s->last_flush != -2) || hook_flush != Z_NO_FLUSH) {
/* Flush the last buffer: */
- int err = deflate(strm, RANK(hook_flush) > RANK(Z_BLOCK) ?
- hook_flush : Z_BLOCK);
+ int flush = RANK(hook_flush) > RANK(Z_BLOCK) ? hook_flush : Z_BLOCK;
+ int err = deflate(strm, flush);
if (err == Z_STREAM_ERROR)
return err;
- if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
+ if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead ||
+ !DEFLATE_DONE(strm, flush))
return Z_BUF_ERROR;
}
if (s->level != level) {
Index: zlib-1.2.11/test/infcover.c
===================================================================
--- zlib-1.2.11.orig/test/infcover.c
+++ zlib-1.2.11/test/infcover.c
@@ -373,7 +373,7 @@ local void cover_support(void)
mem_setup(&strm);
strm.avail_in = 0;
strm.next_in = Z_NULL;
- ret = inflateInit_(&strm, ZLIB_VERSION - 1, (int)sizeof(z_stream));
+ ret = inflateInit_(&strm, &ZLIB_VERSION[1], (int)sizeof(z_stream));
assert(ret == Z_VERSION_ERROR);
mem_done(&strm, "wrong version");

47
zlib-s390x-z15-fix-hw-compression.patch
View File

@ -1,47 +0,0 @@
From 4a587d07b3774c603f1a33ab1648419064951988 Mon Sep 17 00:00:00 2001
From: Ilya Leoshkevich <iii@linux.ibm.com>
Date: Mon, 28 Sep 2020 19:32:44 +0200
Subject: [PATCH] wip
---
contrib/s390/dfltcc.h | 4 ++++
inflate.c | 2 ++
2 files changed, 6 insertions(+)
diff --git a/contrib/s390/dfltcc.h b/contrib/s390/dfltcc.h
index e4447dd..bf41272 100644
--- a/contrib/s390/dfltcc.h
+++ b/contrib/s390/dfltcc.h
@@ -51,5 +51,9 @@ int ZLIB_INTERNAL dfltcc_inflate_disable OF((z_streamp strm));
do { \
if (dfltcc_was_inflate_used((strm))) return -(1L << 16); \
} while (0)
+#define INFLATE_SYNC_POINT_HOOK(strm) \
+ do { \
+ if (dfltcc_was_inflate_used((strm))) return Z_STREAM_ERROR; \
+ } while (0)
#endif
diff --git a/inflate.c b/inflate.c
index 2b7d564..6f19a87 100644
--- a/inflate.c
+++ b/inflate.c
@@ -100,6 +100,7 @@
#define INFLATE_NEED_CHECKSUM(strm) 1
#define INFLATE_NEED_UPDATEWINDOW(strm) 1
#define INFLATE_MARK_HOOK(strm) do {} while (0)
+#define INFLATE_SYNC_POINT_HOOK(strm) do {} while (0)
#endif
#ifdef MAKEFIXED
@@ -1491,6 +1492,7 @@ z_streamp strm;
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ INFLATE_SYNC_POINT_HOOK(strm);
state = (struct inflate_state FAR *)strm->state;
return state->mode == STORED && state->bits == 0;
}
--
2.25.4

18
zlib.changes
View File

@ -1,3 +1,21 @@
-------------------------------------------------------------------
Fri Mar 25 14:59:29 UTC 2022 - Danilo Spinella <danilo.spinella@suse.com>
- Fix memory corruption on deflate, bsc#1197459
* bsc1197459.patch - CVE-2018-25032
- Update 410.patch
* Remove included patches:
bsc1174551-fxi-imcomplete-raw-streams.patch
zlib-compression-switching.patch
zlib-s390x-z15-fix-hw-compression.patch
- Refresh bsc1174736-DFLTCC_LEVEL_MASK-set-to-0x1ff.patch
-------------------------------------------------------------------
Fri Mar 11 17:38:09 UTC 2022 - Arjen de Korte <suse+build@de-korte.org>
- Don't install (internal) crypt.h header in minizip
* minizip-dont-install-crypt-header.patch
------------------------------------------------------------------- -------------------------------------------------------------------
Mon Nov 9 08:00:35 UTC 2020 - Ali Abdallah <ali.abdallah@suse.com> Mon Nov 9 08:00:35 UTC 2020 - Ali Abdallah <ali.abdallah@suse.com>

27
zlib.spec
View File

@ -1,7 +1,7 @@
# #
# spec file for package zlib # spec file for package zlib
# #
# Copyright (c) 2020 SUSE LLC # Copyright (c) 2022 SUSE LLC
# #
# All modifications and additions to the file contributed by third parties # All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed # remain the property of their copyright owners, unless otherwise agreed
@ -36,16 +36,16 @@ Patch1: zlib-format.patch
Patch2: 0001-Do-not-try-to-store-negative-values-in-unsigned-int.patch Patch2: 0001-Do-not-try-to-store-negative-values-in-unsigned-int.patch
#PATCH-FIX-UPSTREAM https://github.com/madler/zlib/pull/335 #PATCH-FIX-UPSTREAM https://github.com/madler/zlib/pull/335
Patch3: zlib-power8-fate325307.patch Patch3: zlib-power8-fate325307.patch
#PATCH-FIX-UPSTREAM https://github.com/madler/zlib/pull/410
Patch4: 410.patch
#PATCH-FIX-SUSE do not check exact version match as the lib can be updated #PATCH-FIX-SUSE do not check exact version match as the lib can be updated
# we should simply rely on soname versioning to protect us # we should simply rely on soname versioning to protect us
Patch5: zlib-no-version-check.patch Patch5: zlib-no-version-check.patch
Patch6: bsc1174736-DFLTCC_LEVEL_MASK-set-to-0x1ff.patch Patch6: bsc1174736-DFLTCC_LEVEL_MASK-set-to-0x1ff.patch
Patch7: bsc1174551-fxi-imcomplete-raw-streams.patch #PATCH-FIX-UPSTREAM https://github.com/madler/zlib/pull/229
Patch8: zlib-compression-switching.patch Patch10: minizip-dont-install-crypt-header.patch
#PATCH-FIX-SUSE: bsc#1176201, sent upstream by IBM #PATCH-FIX-UPSTREAM https://github.com/madler/zlib/commit/5c44459c3b28a9bd3283aaceab7c615f8020c531
Patch9: zlib-s390x-z15-fix-hw-compression.patch Patch11: bsc1197459.patch
#PATCH-FIX-UPSTREAM https://github.com/madler/zlib/pull/410
Patch101: 410.patch
BuildRequires: autoconf BuildRequires: autoconf
BuildRequires: automake BuildRequires: automake
BuildRequires: libtool BuildRequires: libtool
@ -134,22 +134,16 @@ It should exit 0
%patch1 %patch1
%patch2 -p1 %patch2 -p1
%patch3 -p1 %patch3 -p1
%patch4 -p1
%patch5 -p1 %patch5 -p1
%patch6 -p1 %patch6 -p1
%patch7 -p1 %patch10 -p1
%patch8 -p1 %patch11 -p1
%patch9 -p1 %patch101 -p1
cp %{SOURCE4} . cp %{SOURCE4} .
%build %build
%global _lto_cflags %{_lto_cflags} -ffat-lto-objects %global _lto_cflags %{_lto_cflags} -ffat-lto-objects
export LDFLAGS="-Wl,-z,relro,-z,now" export LDFLAGS="-Wl,-z,relro,-z,now"
%ifarch s390x s390
export CFLAGS="%{optflags} -DDFLTCC_LEVEL_MASK=0x7e"
%else
export CFLAGS="%{optflags}"
%endif
# For sure not autotools build # For sure not autotools build
CC="cc" ./configure \ CC="cc" ./configure \
--shared \ --shared \
@ -157,6 +151,7 @@ CC="cc" ./configure \
--libdir=%{_libdir} \ --libdir=%{_libdir} \
%ifarch s390x s390 %ifarch s390x s390
--dfltcc \ --dfltcc \
--dfltcc-level-mask=0x7e \
%endif %endif
%{nil} %{nil}