import zlib-1.2.11-31.el9

.gitignore

+SOURCES/zlib-1.2.11.tar.xz

.zlib.metadata

+e1cb0d5c92da8e9a8c2635dfa249c341dfd00322 SOURCES/zlib-1.2.11.tar.xz

SOURCES/zlib-1.2.11-IBM-DFLTCC-compression-level-switching-issues.patch

+Subject: [PATCH] Fixed DFLTCC compression level switching issues
+
+---
+ configure                     |  4 +--
+ contrib/s390/dfltcc.c         | 52 ++++++++++++++++++++++++++++++-----
+ contrib/s390/dfltcc_deflate.h |  2 ++
+ deflate.c                     | 12 ++++----
+ test/infcover.c               |  2 +-
+ 5 files changed, 57 insertions(+), 15 deletions(-)
+
+diff --git a/configure b/configure
+index bfe4386..70ed86b 100755
+--- a/configure
++++ b/configure
+@@ -139,7 +139,7 @@ case "$1" in
+     -w* | --warn) warn=1; shift ;;
+     -d* | --debug) debug=1; shift ;;
+     --dfltcc)
+-	    CFLAGS="$CFLAGS -DDFLTCC"
++	    CFLAGS="$CFLAGS -DDFLTCC -DDFLTCC_LEVEL_MASK=0x7e"
+       OBJC="$OBJC dfltcc.o"
+ 	    PIC_OBJC="$PIC_OBJC dfltcc.lo"
+       shift
+@@ -838,7 +838,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"
+diff --git a/contrib/s390/dfltcc.c b/contrib/s390/dfltcc.c
+index d88a0d6..94a196f 100644
+--- a/contrib/s390/dfltcc.c
++++ b/contrib/s390/dfltcc.c
+@@ -350,8 +350,12 @@ int ZLIB_INTERNAL dfltcc_deflate(strm, flush, result)
+     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.
+@@ -737,10 +747,15 @@ __attribute__((constructor)) local void init_globals(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" (cpu_facilities)
+                      , [r0] "+r" (r0)
+                      :
+@@ -872,6 +887,28 @@ int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy, flush)
+     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.
+ */
+@@ -925,6 +962,7 @@ int ZLIB_INTERNAL dfltcc_deflate_set_dictionary(strm, dictionary, dict_length)
+ 
+     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;
+ }
+ 
+diff --git a/contrib/s390/dfltcc_deflate.h b/contrib/s390/dfltcc_deflate.h
+index de36784..914daa4 100644
+--- a/contrib/s390/dfltcc_deflate.h
++++ b/contrib/s390/dfltcc_deflate.h
+@@ -11,6 +11,7 @@ int ZLIB_INTERNAL dfltcc_deflate_params OF((z_streamp strm,
+                                             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_dictionary OF((z_streamp strm,
+         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))) \
+diff --git a/deflate.c b/deflate.c
+index d907a1b..085abbe 100644
+--- a/deflate.c
++++ b/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
+@@ -605,14 +606,15 @@ int ZEXPORT deflateParams(strm, level, strategy)
+     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) {
+diff --git a/test/infcover.c b/test/infcover.c
+index a34cd17..a208219 100644
+--- a/test/infcover.c
++++ b/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");
+ 
+-- 
+2.26.0
+

SOURCES/zlib-1.2.11-IBM-Z-hw-accelrated-deflate-fix.patch

+From 608b71008c16ce6fbf2305145c5ffb69cd88ef59 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Fri, 7 Aug 2020 07:12:50 +0200
+Subject: [PATCH] Fix for Z hardware-accelerated deflate for s390x
+
+---
+ configure                     |   7 +
+ contrib/s390/dfltcc.c         | 244 +++++++++++++++++++++-------------
+ contrib/s390/dfltcc_deflate.h |  10 +-
+ deflate.c                     |  21 +--
+ 4 files changed, 177 insertions(+), 105 deletions(-)
+
+diff --git a/configure b/configure
+index 66caece..bfe4386 100755
+--- a/configure
++++ b/configure
+@@ -114,6 +114,7 @@ case "$1" in
+       echo '  configure [--const] [--zprefix] [--prefix=PREFIX]  [--eprefix=EXPREFIX]' | 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 '    [--dfltcc]' | tee -a configure.log
+         exit 0 ;;
+     -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
+     -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
+@@ -137,6 +138,12 @@ case "$1" in
+     -c* | --const) zconst=1; shift ;;
+     -w* | --warn) warn=1; shift ;;
+     -d* | --debug) debug=1; shift ;;
++    --dfltcc)
++	    CFLAGS="$CFLAGS -DDFLTCC"
++      OBJC="$OBJC dfltcc.o"
++	    PIC_OBJC="$PIC_OBJC dfltcc.lo"
++      shift
++      ;; 
+     *)
+       echo "unknown option: $1" | tee -a configure.log
+       echo "$0 --help for help" | tee -a configure.log
+diff --git a/contrib/s390/dfltcc.c b/contrib/s390/dfltcc.c
+index d187796..d88a0d6 100644
+--- a/contrib/s390/dfltcc.c
++++ b/contrib/s390/dfltcc.c
+@@ -2,12 +2,13 @@
+ 
+ /*
+    Use the following commands to build zlib with DFLTCC support:
+-        $ CFLAGS=-DDFLTCC ./configure
+-        $ make OBJA=dfltcc.o PIC_OBJA=dfltcc.lo
++        $ ./configure --dfltcc
++        $ make 
+ */
+ 
+ #define _GNU_SOURCE
+ #include <ctype.h>
++#include <errno.h>
+ #include <inttypes.h>
+ #include <stddef.h>
+ #include <stdio.h>
+@@ -230,31 +231,28 @@ struct dfltcc_state {
+ /*
+    Compress.
+  */
+-local inline int dfltcc_are_params_ok(int level,
+-                                      uInt window_bits,
+-                                      int strategy,
+-                                      uLong level_mask);
+-local inline int dfltcc_are_params_ok(level, window_bits, strategy, level_mask)
++local inline int dfltcc_can_deflate_with_params(z_streamp strm,
++                                                 int level,
++                                                 uInt window_bits,
++                                                 int strategy);
++local inline int dfltcc_can_deflate_with_params(strm,
++                                                 level,
++                                                 window_bits,
++                                                 strategy)
++    z_streamp strm; 
+     int level;
+     uInt window_bits;
+     int strategy;
+-    uLong level_mask;
+-{
+-    return (level_mask & (1 << level)) != 0 &&
+-        (window_bits == HB_BITS) &&
+-        (strategy == Z_FIXED || strategy == Z_DEFAULT_STRATEGY);
+-}
+-
+-
+-int ZLIB_INTERNAL dfltcc_can_deflate(strm)
+-    z_streamp strm;
+ {
+     deflate_state FAR *state = (deflate_state FAR *)strm->state;
+     struct dfltcc_state FAR *dfltcc_state = GET_DFLTCC_STATE(state);
+ 
+     /* Unsupported compression settings */
+-    if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy,
+-                              dfltcc_state->level_mask))
++    if ((dfltcc_state->level_mask & (1 << level)) == 0)
++        return 0;
++    if (window_bits != HB_BITS)
++        return 0;
++    if (strategy != Z_FIXED && strategy != Z_DEFAULT_STRATEGY) 
+         return 0;
+ 
+     /* Unsupported hardware */
+@@ -266,6 +264,17 @@ int ZLIB_INTERNAL dfltcc_can_deflate(strm)
+     return 1;
+ }
+ 
++int ZLIB_INTERNAL dfltcc_can_deflate(strm)
++    z_streamp strm;
++{
++    deflate_state FAR *state = (deflate_state FAR *)strm->state;
++
++    return dfltcc_can_deflate_with_params(strm,
++                                          state->level,
++                                          state->w_bits,
++                                          state->strategy);
++} 
++
+ local void dfltcc_gdht OF((z_streamp strm));
+ local void dfltcc_gdht(strm)
+     z_streamp strm;
+@@ -349,22 +358,24 @@ again:
+     soft_bcc = 0;
+     no_flush = flush == Z_NO_FLUSH;
+ 
+-    /* Trailing empty block. Switch to software, except when Continuation Flag
+-     * is set, which means that DFLTCC has buffered some output in the
+-     * parameter block and needs to be called again in order to flush it.
++    /* No input data. Return, except when Continuation Flag is set, which means
++     * that DFLTCC has buffered some output in the parameter block and needs to
++     * be called again in order to flush it. 
+      */
+-    if (flush == Z_FINISH && strm->avail_in == 0 && !param->cf) {
+-        if (param->bcf) {
+-            /* A block is still open, and the hardware does not support closing
+-             * blocks without adding data. Thus, close it manually.
+-             */
++    if (strm->avail_in == 0 && !param->cf) {
++        /* A block is still open, and the hardware does not support closing
++         * blocks without adding data. Thus, close it manually.
++         */
++        if (!no_flush && param->bcf) { 
+             send_eobs(strm, param);
+             param->bcf = 0;
+         }
+-        return 0;
+-    }
+-
+-    if (strm->avail_in == 0 && !param->cf) {
++        /* Let one of deflate_* functions write a trailing empty block. */
++        if (flush == Z_FINISH)
++            return 0;
++        /* Clear history. */
++        if (flush == Z_FULL_FLUSH)
++            param->hl = 0; 
+         *result = need_more;
+         return 1;
+     }
+@@ -418,7 +429,7 @@ again:
+     param->cvt = state->wrap == 2 ? CVT_CRC32 : CVT_ADLER32;
+     if (!no_flush)
+         /* We need to close a block. Always do this in software - when there is
+-         * no input data, the hardware will not nohor BCC. */
++         * no input data, the hardware will not honor BCC. */
+         soft_bcc = 1;
+     if (flush == Z_FINISH && !param->bcf)
+         /* We are about to open a BFINAL block, set Block Header Final bit
+@@ -433,8 +444,8 @@ again:
+     param->sbb = (unsigned int)state->bi_valid;
+     if (param->sbb > 0)
+         *strm->next_out = (Bytef)state->bi_buf;
+-    if (param->hl)
+-        param->nt = 0; /* Honor history */
++    /* Honor history and check value */
++    param->nt = 0; 
+     param->cv = state->wrap == 2 ? ZSWAP32(strm->adler) : strm->adler;
+ 
+     /* When opening a block, choose a Huffman-Table Type */
+@@ -642,27 +653,86 @@ int ZLIB_INTERNAL dfltcc_inflate_disable(strm)
+     return 0;
+ }
+ 
+-/*
+-   Memory management.
+-   DFLTCC requires parameter blocks and window to be aligned. zlib allows
+-   users to specify their own allocation functions, so using e.g.
+-   `posix_memalign' is not an option. Thus, we overallocate and take the
+-   aligned portion of the buffer.
+-*/
++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 *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;
++    
++
++    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);
+ 
+-    memset(facilities, 0, sizeof(facilities));
+-    r0 = sizeof(facilities) / sizeof(facilities[0]) - 1;
++#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.
+@@ -671,31 +741,35 @@ local inline int is_dfltcc_enabled(void)
+                      ".machinemode zarch\n"
+                      "stfle %[facilities]\n"
+                      ".machinemode pop\n"
+-                     : [facilities] "=Q" (facilities)
++                     : [facilities] "=Q" (cpu_facilities)
+                      , [r0] "+r" (r0)
+                      :
+                      : "cc");
+-    return is_bit_set((const char *)facilities, DFLTCC_FACILITY);
++    /* 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.
++
++   DFLTCC requires parameter blocks and window to be aligned. zlib allows
++   users to specify their own allocation functions, so using e.g.
++   `posix_memalign' is not an option. Thus, we overallocate and take the
++   aligned portion of the buffer.
++*/ 
+ void ZLIB_INTERNAL dfltcc_reset(strm, size)
+     z_streamp strm;
+     uInt size;
+ {
+     struct dfltcc_state *dfltcc_state =
+         (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 */
+-    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));
++    memcpy(&dfltcc_state->af, &cpu_af, 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
+          * depends on buffers' page offsets.
+          */
+@@ -706,36 +780,11 @@ void ZLIB_INTERNAL dfltcc_reset(strm, size)
+     dfltcc_state->param.nt = 1;
+ 
+     /* Initialize tuning parameters */
+-#ifndef DFLTCC_LEVEL_MASK
+-#define DFLTCC_LEVEL_MASK 0x2
+-#endif
+-    s = secure_getenv("DFLTCC_LEVEL_MASK");
+-    dfltcc_state->level_mask = (s && *s) ? strtoul(s, NULL, 0) :
+-                                           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;
++    dfltcc_state->level_mask = env_level_mask;
++    dfltcc_state->block_size = env_block_size;
++    dfltcc_state->block_threshold = env_block_threshold;
++    dfltcc_state->dht_threshold = env_dht_threshold;
++    dfltcc_state->param.ribm = env_ribm;
+ }
+ 
+ voidpf ZLIB_INTERNAL dfltcc_alloc_state(strm, items, size)
+@@ -787,22 +836,26 @@ void ZLIB_INTERNAL dfltcc_free_window(strm, w)
+ 
+ /*
+    Switching between hardware and software compression.
++
+    DFLTCC does not support all zlib settings, e.g. generation of non-compressed
+    blocks or alternative window sizes. When such settings are applied on the
+    fly with deflateParams, we need to convert between hardware and software
+    window formats.
+ */
+-int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy)
++int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy, flush)
+     z_streamp strm;
+     int level;
+     int strategy;
++    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;
+     int could_deflate = dfltcc_can_deflate(strm);
+-    int can_deflate = dfltcc_are_params_ok(level, state->w_bits, strategy,
+-                                           dfltcc_state->level_mask);
++    int can_deflate = dfltcc_can_deflate_with_params(strm,
++                                                     level,
++                                                     state->w_bits,
++                                                     strategy); 
+ 
+     if (can_deflate == could_deflate)
+         /* We continue to work in the same mode - no changes needed */
+@@ -812,8 +865,11 @@ int ZLIB_INTERNAL dfltcc_deflate_params(strm, level, strategy)
+         /* DFLTCC was not used yet - no changes needed */
+         return Z_OK;
+ 
+-    /* Switching between hardware and software is not implemented */
+-    return Z_STREAM_ERROR;
++    /* For now, do not convert between window formats - simply get rid of the
++     * old data instead.
++     */
++    *flush = Z_FULL_FLUSH;
++    return Z_OK; 
+ }
+ 
+ /*
+diff --git a/contrib/s390/dfltcc_deflate.h b/contrib/s390/dfltcc_deflate.h
+index a129a91..de36784 100644
+--- a/contrib/s390/dfltcc_deflate.h
++++ b/contrib/s390/dfltcc_deflate.h
+@@ -9,7 +9,8 @@ int ZLIB_INTERNAL dfltcc_deflate OF((z_streamp strm,
+                                      block_state *result));
+ int ZLIB_INTERNAL dfltcc_deflate_params OF((z_streamp strm,
+                                             int level,
+-                                            int strategy));
++                                            int strategy,
++                                            int *flush)); 
+ int ZLIB_INTERNAL dfltcc_deflate_set_dictionary OF((z_streamp strm,
+                                                     const Bytef *dictionary,
+                                                     uInt dict_length));
+@@ -29,11 +30,14 @@ int ZLIB_INTERNAL dfltcc_deflate_get_dictionary OF((z_streamp strm,
+     } while (0)
+ #define DEFLATE_RESET_KEEP_HOOK(strm) \
+     dfltcc_reset((strm), sizeof(deflate_state))
+-#define DEFLATE_PARAMS_HOOK(strm, level, strategy) \
++#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) \
+     do { \
+         int err; \
+ \
+-        err = dfltcc_deflate_params((strm), (level), (strategy)); \
++        err = dfltcc_deflate_params((strm), \
++                                    (level), \
++                                    (strategy), \
++                                    (hook_flush)); \
+         if (err == Z_STREAM_ERROR) \
+             return err; \
+     } while (0)
+diff --git a/deflate.c b/deflate.c
+index b17a7dd..a80bd3e 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -74,7 +74,7 @@ const char deflate_copyright[] =
+ #define DEFLATE_SET_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_PARAMS_HOOK(strm, level, strategy) do {} while (0)
++#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) do {} while (0)
+ #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
+@@ -589,6 +589,7 @@ int ZEXPORT deflateParams(strm, level, strategy)
+ {
+     deflate_state *s;
+     compress_func func;
++    int hook_flush = Z_NO_FLUSH;
+ 
+     if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+     s = strm->state;
+@@ -601,13 +602,14 @@ int ZEXPORT deflateParams(strm, level, strategy)
+     if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
+         return Z_STREAM_ERROR;
+     }
+-    DEFLATE_PARAMS_HOOK(strm, level, strategy);
++    DEFLATE_PARAMS_HOOK(strm, level, strategy, &hook_flush);
+     func = configuration_table[s->level].func;
+ 
+-    if ((strategy != s->strategy || func != configuration_table[level].func) &&
+-        s->high_water) {
++    if ((strategy != s->strategy || func != configuration_table[level].func ||
++        hook_flush != Z_NO_FLUSH) && s->high_water) {
+         /* Flush the last buffer: */
+-        int err = deflate(strm, Z_BLOCK);
++        int err = deflate(strm, RANK(hook_flush) > RANK(Z_BLOCK) ?
++                          hook_flush : Z_BLOCK); 
+         if (err == Z_STREAM_ERROR)
+             return err;
+         if (strm->avail_out == 0)
+@@ -1065,7 +1067,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
+@@ -1081,7 +1082,7 @@ int ZEXPORT deflate (strm, flush)
+     }
+     else
+ #endif
+-    {
++    if (s->wrap == 1) {
+         putShortMSB(s, (uInt)(strm->adler >> 16));
+         putShortMSB(s, (uInt)(strm->adler & 0xffff));
+     }
+@@ -1090,7 +1091,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; 
+ }
+ 
+ /* ========================================================================= */
+-- 
+2.26.0
+

SOURCES/zlib-1.2.11-covscan-issues-rhel9.patch

+From 1e56dd1e7285d3026092ba794078edb290b4c1b1 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Mon, 15 Mar 2021 13:06:35 +0100
+Subject: [PATCH] fixed isues found by covscan
+
+---
+ contrib/minizip/mztools.c | 8 ++++++++
+ contrib/minizip/zip.c     | 4 ++--
+ deflate.c                 | 5 +++--
+ 3 files changed, 13 insertions(+), 4 deletions(-)
+
+diff --git a/contrib/minizip/mztools.c b/contrib/minizip/mztools.c
+index 96891c2..1197928 100644
+--- a/contrib/minizip/mztools.c
++++ b/contrib/minizip/mztools.c
+@@ -286,6 +286,14 @@ uLong* bytesRecovered;
+     }
+   } else {
+     err = Z_STREAM_ERROR;
++    if(fpZip != NULL)
++      fclose(fpZip);
++
++    if(fpOut != NULL)
++      fclose(fpOut);
++
++    if(fpOutCD != NULL)
++      fclose(fpOutCD);
+   }
+   return err;
+ }
+diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
+index 44e88a9..a753c17 100644
+--- a/contrib/minizip/zip.c
++++ b/contrib/minizip/zip.c
+@@ -526,8 +526,8 @@ local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_f
+         break;
+       }
+ 
+-      if (uPosFound!=0)
+-        break;
++    if (uPosFound!=0)
++      break;
+   }
+   TRYFREE(buf);
+   return uPosFound;
+diff --git a/deflate.c b/deflate.c
+index 085abbe..3963e79 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -203,9 +203,10 @@ local const config configuration_table[10] = {
+  * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+  * prev[] will be initialized on the fly.
+  */
+-#define CLEAR_HASH(s) \
++#define CLEAR_HASH(s) do { \
+     s->head[s->hash_size-1] = NIL; \
+-    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
++    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); \
++} while (0)
+ 
+ /* ===========================================================================
+  * Slide the hash table when sliding the window down (could be avoided with 32
+-- 
+2.26.0
+

SOURCES/zlib-1.2.11-covscan-issues.patch

+From f776e1609cc63bf486634ee9bc6226dac2c0d2f3 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Tue, 15 Oct 2019 11:27:15 +0200
+Subject: [PATCH] fixed covscan issues
+
+---
+ crc32.c           | 2 +-
+ deflate.c         | 2 +-
+ test/crc32_test.c | 8 ++++----
+ 3 files changed, 6 insertions(+), 6 deletions(-)
+
+diff --git a/crc32.c b/crc32.c
+index 406d350..34132ea 100644
+--- a/crc32.c
++++ b/crc32.c
+@@ -302,7 +302,7 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
+ 
+     if (!crc32_func)
+         crc32_func = crc32_z_ifunc();
+-        return (*crc32_func)(crc, buf, len);
++    return (*crc32_func)(crc, buf, len);
+ }
+ 
+ #endif /* defined(Z_IFUNC_ASM) || defined(Z_IFUNC_NATIVE) */
+diff --git a/deflate.c b/deflate.c
+index 089285a..9b09718 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -1015,7 +1015,7 @@ int ZEXPORT deflate (strm, flush)
+      */
+     if (strm->avail_in != 0 || s->lookahead != 0 ||
+         (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+-        block_state bstate;
++        block_state bstate = 0;
+ 
+         bstate = DEFLATE_HOOK(strm, flush, &bstate) ? bstate :
+                  s->level == 0 ? deflate_stored(s, flush) :
+diff --git a/test/crc32_test.c b/test/crc32_test.c
+index 5d73128..2d2a6c7 100644
+--- a/test/crc32_test.c
++++ b/test/crc32_test.c
+@@ -11,25 +11,25 @@
+ #  include <stdlib.h>
+ #endif
+ 
+-void test_crc32  OF((uLong crc, Byte* buf, z_size_t len, uLong chk, int line));
++void test_crc32  OF((uLong crc, char* buf, z_size_t len, uLong chk, int line));
+ int main         OF((void));
+ 
+ typedef struct {
+     int line;
+ 	uLong crc;
+-    Byte* buf;
++    char* buf;
+ 	int len;
+     uLong expect;
+ } crc32_test;
+ 
+ void test_crc32(crc, buf, len, chk, line)
+     uLong crc;
+-    Byte *buf;
++    char *buf;
+     z_size_t len;
+     uLong chk;
+     int line;
+ {
+-    uLong res = crc32(crc, buf, len);
++    uLong res = crc32(crc, (Bytef *) buf, len);
+ 	if (res != chk) {
+         fprintf(stderr, "FAIL [%d]: crc32 returned 0x%08X expected 0x%08X\n",
+                 line, (unsigned int)res, (unsigned int)chk);
+-- 
+2.19.1
+

SOURCES/zlib-1.2.11-firefox-crash-fix.patch

+From 27a84de4a30cd35f8565937397f6d1205b912818 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Thu, 5 Sep 2019 09:16:35 +0200
+Subject: [PATCH 1/2] fix: power8 crc32 - return 0 with 0 ptr passed
+
+---
+ contrib/power8-crc/vec_crc32.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/contrib/power8-crc/vec_crc32.c b/contrib/power8-crc/vec_crc32.c
+index bb2204b..5ce9cd2 100644
+--- a/contrib/power8-crc/vec_crc32.c
++++ b/contrib/power8-crc/vec_crc32.c
+@@ -74,6 +74,7 @@ unsigned int CRC32_FUNCTION(unsigned int crc, const unsigned char *p,
+ 	unsigned int prealign;
+ 	unsigned int tail;
+ 
++	if (p == (const unsigned char *) 0x0) return 0;
+ #ifdef CRC_XOR
+ 	crc ^= 0xffffffff;
+ #endif
+-- 
+2.19.1
+
+
+From c066ac92982a2ffe5b1e9bd36000058927437bd5 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Thu, 5 Sep 2019 09:36:47 +0200
+Subject: [PATCH 2/2] Add CRC32 tests (crc32_test)
+
+This commit includes a CRC32 test (crc32_test). This tests are important
+since some architectures may want include CPU dependent optimizations for
+CRC32 algorithm like using vector instructions and we may want to
+validate those.
+---
+ Makefile.in       |  35 +++++---
+ test/crc32_test.c | 205 ++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 230 insertions(+), 10 deletions(-)
+ create mode 100644 test/crc32_test.c
+
+diff --git a/Makefile.in b/Makefile.in
+index 40b5cfb..6070dcc 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -75,11 +75,11 @@ PIC_OBJS = $(PIC_OBJC) $(PIC_OBJA)
+ 
+ all: static shared
+ 
+-static: example$(EXE) minigzip$(EXE)
++static: crc32_test$(EXE) example$(EXE) minigzip$(EXE)
+ 
+-shared: examplesh$(EXE) minigzipsh$(EXE)
++shared: crc32_testsh$(EXE) examplesh$(EXE) minigzipsh$(EXE)
+ 
+-all64: example64$(EXE) minigzip64$(EXE)
++all64: crc32_test64$(EXE) example64$(EXE) minigzip64$(EXE)
+ 
+ check: test
+ 
+@@ -87,7 +87,7 @@ test: all teststatic testshared
+ 
+ teststatic: static
+ 	@TMPST=tmpst_$$; \
+-	if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST ; then \
++	if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST && ./crc32_test; then \
+ 	  echo '		*** zlib test OK ***'; \
+ 	else \
+ 	  echo '		*** zlib test FAILED ***'; false; \
+@@ -100,7 +100,7 @@ testshared: shared
+ 	DYLD_LIBRARY_PATH=`pwd`:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \
+ 	SHLIB_PATH=`pwd`:$(SHLIB_PATH) ; export SHLIB_PATH; \
+ 	TMPSH=tmpsh_$$; \
+-	if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH; then \
++	if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH && ./crc32_testsh; then \
+ 	  echo '		*** zlib shared test OK ***'; \
+ 	else \
+ 	  echo '		*** zlib shared test FAILED ***'; false; \
+@@ -109,7 +109,7 @@ testshared: shared
+ 
+ test64: all64
+ 	@TMP64=tmp64_$$; \
+-	if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64; then \
++	if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64 && ./crc32_test64; then \
+ 	  echo '		*** zlib 64-bit test OK ***'; \
+ 	else \
+ 	  echo '		*** zlib 64-bit test FAILED ***'; false; \
+@@ -157,6 +157,12 @@ example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ minigzip.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ 	$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/minigzip.c
+ 
++crc32_test.o: $(SRCDIR)test/crc32_test.c $(SRCDIR)zlib.h zconf.h
++	$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/crc32_test.c
++
++crc32_test64.o: $(SRCDIR)test/crc32_test.c $(SRCDIR)zlib.h zconf.h
++	$(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/crc32_test.c
++
+ example64.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ 	$(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/example.c
+ 
+@@ -307,12 +313,21 @@ example$(EXE): example.o $(STATICLIB)
+ minigzip$(EXE): minigzip.o $(STATICLIB)
+ 	$(CC) $(CFLAGS) -o $@ minigzip.o $(TEST_LDFLAGS)
+ 
++crc32_test$(EXE): crc32_test.o $(STATICLIB)
++	$(CC) $(CFLAGS) -o $@ crc32_test.o $(TEST_LDFLAGS)
++
++crc32_testsh$(EXE): crc32_test.o $(SHAREDLIBV)
++	$(CC) $(CFLAGS) -o $@ crc32_test.o -L. $(SHAREDLIBV)
++
+ examplesh$(EXE): example.o $(SHAREDLIBV)
+ 	$(CC) $(CFLAGS) -o $@ example.o -L. $(SHAREDLIBV)
+ 
+ minigzipsh$(EXE): minigzip.o $(SHAREDLIBV)
+ 	$(CC) $(CFLAGS) -o $@ minigzip.o -L. $(SHAREDLIBV)
+ 
++crc32_test64$(EXE): crc32_test64.o $(STATICLIB)
++	$(CC) $(CFLAGS) -o $@ crc32_test64.o $(TEST_LDFLAGS)
++
+ example64$(EXE): example64.o $(STATICLIB)
+ 	$(CC) $(CFLAGS) -o $@ example64.o $(TEST_LDFLAGS)
+ 
+@@ -382,8 +397,8 @@ zconf: $(SRCDIR)zconf.h.in
+ mostlyclean: clean
+ clean:
+ 	rm -f *.o *.lo *~ \
+-	   example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \
+-	   example64$(EXE) minigzip64$(EXE) \
++	   crc32_test$(EXE) example$(EXE) minigzip$(EXE) crc32_testsh$(EXE) examplesh$(EXE) minigzipsh$(EXE) \
++	   crc32_test64$(EXE) example64$(EXE) minigzip64$(EXE) \
+ 	   infcover \
+ 	   libz.* foo.gz so_locations \
+ 	   _match.s maketree contrib/infback9/*.o
+@@ -407,7 +422,7 @@ tags:
+ 
+ adler32.o zutil.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+ gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+-compress.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
++compress.o crc32_test.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
+ crc32.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+ deflate.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+ infback.o inflate.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+@@ -417,7 +432,7 @@ trees.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)tr
+ 
+ adler32.lo zutil.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+ gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+-compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
++compress.lo crc32_test.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
+ crc32.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+ deflate.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+ infback.lo inflate.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+diff --git a/test/crc32_test.c b/test/crc32_test.c
+new file mode 100644
+index 0000000..5d73128
+--- /dev/null
++++ b/test/crc32_test.c
+@@ -0,0 +1,205 @@
++/* crc32_tes.c -- unit test for crc32 in the zlib compression library
++ * Copyright (C) 1995-2006, 2010, 2011, 2016, 2019 Rogerio Alves
++ * For conditions of distribution and use, see copyright notice in zlib.h
++ */
++
++#include "zlib.h"
++#include <stdio.h>
++
++#ifdef STDC
++#  include <string.h>
++#  include <stdlib.h>
++#endif
++
++void test_crc32  OF((uLong crc, Byte* buf, z_size_t len, uLong chk, int line));
++int main         OF((void));
++
++typedef struct {
++    int line;
++	uLong crc;
++    Byte* buf;
++	int len;
++    uLong expect;
++} crc32_test;
++
++void test_crc32(crc, buf, len, chk, line)
++    uLong crc;
++    Byte *buf;
++    z_size_t len;
++    uLong chk;
++    int line;
++{
++    uLong res = crc32(crc, buf, len);
++	if (res != chk) {
++        fprintf(stderr, "FAIL [%d]: crc32 returned 0x%08X expected 0x%08X\n",
++                line, (unsigned int)res, (unsigned int)chk);
++        exit(1);
++    }
++}
++
++static const crc32_test tests[] = {
++  {__LINE__, 0x0, 0x0, 0, 0x0},
++  {__LINE__, 0xffffffff, 0x0, 0, 0x0},
++  {__LINE__, 0x0, 0x0, 255, 0x0}, /*  BZ 174799.  */
++  {__LINE__, 0x0, 0x0, 256, 0x0},
++  {__LINE__, 0x0, 0x0, 257, 0x0},
++  {__LINE__, 0x0, 0x0, 32767, 0x0},
++  {__LINE__, 0x0, 0x0, 32768, 0x0},
++  {__LINE__, 0x0, 0x0, 32769, 0x0},
++  {__LINE__, 0x0, "", 0, 0x0},
++  {__LINE__, 0xffffffff, "", 0, 0xffffffff},
++  {__LINE__, 0x0, "abacus", 6, 0xc3d7115b},
++  {__LINE__, 0x0, "backlog", 7, 0x269205},
++  {__LINE__, 0x0, "campfire", 8, 0x22a515f8},
++  {__LINE__, 0x0, "delta", 5, 0x9643fed9},
++  {__LINE__, 0x0, "executable", 10, 0xd68eda01},
++  {__LINE__, 0x0, "file", 4, 0x8c9f3610},
++  {__LINE__, 0x0, "greatest", 8, 0xc1abd6cd},
++  {__LINE__, 0x0, "hello", 5, 0x3610a686},
++  {__LINE__, 0x0, "inverter", 8, 0xc9e962c9},
++  {__LINE__, 0x0, "jigsaw", 6, 0xce4e3f69},
++  {__LINE__, 0x0, "karate", 6, 0x890be0e2},
++  {__LINE__, 0x0, "landscape", 9, 0xc4e0330b},
++  {__LINE__, 0x0, "machine", 7, 0x1505df84},
++  {__LINE__, 0x0, "nanometer", 9, 0xd4e19f39},
++  {__LINE__, 0x0, "oblivion", 8, 0xdae9de77},
++  {__LINE__, 0x0, "panama", 6, 0x66b8979c},
++  {__LINE__, 0x0, "quest", 5, 0x4317f817},
++  {__LINE__, 0x0, "resource", 8, 0xbc91f416},
++  {__LINE__, 0x0, "secret", 6, 0x5ca2e8e5},
++  {__LINE__, 0x0, "test", 4, 0xd87f7e0c},
++  {__LINE__, 0x0, "ultimate", 8, 0x3fc79b0b},
++  {__LINE__, 0x0, "vector", 6, 0x1b6e485b},
++  {__LINE__, 0x0, "walrus", 6, 0xbe769b97},
++  {__LINE__, 0x0, "xeno", 4, 0xe7a06444},
++  {__LINE__, 0x0, "yelling", 7, 0xfe3944e5},
++  {__LINE__, 0x0, "zlib", 4, 0x73887d3a},
++  {__LINE__, 0x0, "4BJD7PocN1VqX0jXVpWB", 20, 0xd487a5a1},
++  {__LINE__, 0x0, "F1rPWI7XvDs6nAIRx41l", 20, 0x61a0132e},
++  {__LINE__, 0x0, "ldhKlsVkPFOveXgkGtC2", 20, 0xdf02f76},
++  {__LINE__, 0x0, "5KKnGOOrs8BvJ35iKTOS", 20, 0x579b2b0a},
++  {__LINE__, 0x0, "0l1tw7GOcem06Ddu7yn4", 20, 0xf7d16e2d},
++  {__LINE__, 0x0, "MCr47CjPIn9R1IvE1Tm5", 20, 0x731788f5},
++  {__LINE__, 0x0, "UcixbzPKTIv0SvILHVdO", 20, 0x7112bb11},
++  {__LINE__, 0x0, "dGnAyAhRQDsWw0ESou24", 20, 0xf32a0dac},
++  {__LINE__, 0x0, "di0nvmY9UYMYDh0r45XT", 20, 0x625437bb},
++  {__LINE__, 0x0, "2XKDwHfAhFsV0RhbqtvH", 20, 0x896930f9},
++  {__LINE__, 0x0, "ZhrANFIiIvRnqClIVyeD", 20, 0x8579a37},
++  {__LINE__, 0x0, "v7Q9ehzioTOVeDIZioT1", 20, 0x632aa8e0},
++  {__LINE__, 0x0, "Yod5hEeKcYqyhfXbhxj2", 20, 0xc829af29},
++  {__LINE__, 0x0, "GehSWY2ay4uUKhehXYb0", 20, 0x1b08b7e8},
++  {__LINE__, 0x0, "kwytJmq6UqpflV8Y8GoE", 20, 0x4e33b192},
++  {__LINE__, 0x0, "70684206568419061514", 20, 0x59a179f0},
++  {__LINE__, 0x0, "42015093765128581010", 20, 0xcd1013d7},
++  {__LINE__, 0x0, "88214814356148806939", 20, 0xab927546},
++  {__LINE__, 0x0, "43472694284527343838", 20, 0x11f3b20c},
++  {__LINE__, 0x0, "49769333513942933689", 20, 0xd562d4ca},
++  {__LINE__, 0x0, "54979784887993251199", 20, 0x233395f7},
++  {__LINE__, 0x0, "58360544869206793220", 20, 0x2d167fd5},
++  {__LINE__, 0x0, "27347953487840714234", 20, 0x8b5108ba},
++  {__LINE__, 0x0, "07650690295365319082", 20, 0xc46b3cd8},
++  {__LINE__, 0x0, "42655507906821911703", 20, 0xc10b2662},
++  {__LINE__, 0x0, "29977409200786225655", 20, 0xc9a0f9d2},
++  {__LINE__, 0x0, "85181542907229116674", 20, 0x9341357b},
++  {__LINE__, 0x0, "87963594337989416799", 20, 0xf0424937},
++  {__LINE__, 0x0, "21395988329504168551", 20, 0xd7c4c31f},
++  {__LINE__, 0x0, "51991013580943379423", 20, 0xf11edcc4},
++  {__LINE__, 0x0, "*]+@!);({_$;}[_},?{?;(_?,=-][@", 30, 0x40795df4},
++  {__LINE__, 0x0, "_@:_).&(#.[:[{[:)$++-($_;@[)}+", 30, 0xdd61a631},
++  {__LINE__, 0x0, "&[!,[$_==}+.]@!;*(+},[;:)$;)-@", 30, 0xca907a99},
++  {__LINE__, 0x0, "]{.[.+?+[[=;[?}_#&;[=)__$$:+=_", 30, 0xf652deac},
++  {__LINE__, 0x0, "-%.)=/[@].:.(:,()$;=%@-$?]{%+%", 30, 0xaf39a5a9},
++  {__LINE__, 0x0, "+]#$(@&.=:,*];/.!]%/{:){:@(;)$", 30, 0x6bebb4cf},
++  {__LINE__, 0x0, ")-._.:?[&:.=+}(*$/=!.${;(=$@!}", 30, 0x76430bac},
++  {__LINE__, 0x0, ":(_*&%/[[}+,?#$&*+#[([*-/#;%(]", 30, 0x6c80c388},
++  {__LINE__, 0x0, "{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:", 30, 0xd54d977d},
++  {__LINE__, 0x0, "_{$*,}(&,@.)):=!/%(&(,,-?$}}}!", 30, 0xe3966ad5},
++  {__LINE__, 0x0, "e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL", 100, 0xe7c71db9},
++  {__LINE__, 0x0, "r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)", 100, 0xeaa52777},
++  {__LINE__, 0x0, "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&", 100, 0xcd472048},
++  {__LINE__, 0x7a30360d, "abacus", 6, 0xf8655a84},
++  {__LINE__, 0x6fd767ee, "backlog", 7, 0x1ed834b1},
++  {__LINE__, 0xefeb7589, "campfire", 8, 0x686cfca},
++  {__LINE__, 0x61cf7e6b, "delta", 5, 0x1554e4b1},
++  {__LINE__, 0xdc712e2, "executable", 10, 0x761b4254},
++  {__LINE__, 0xad23c7fd, "file", 4, 0x7abdd09b},
++  {__LINE__, 0x85cb2317, "greatest", 8, 0x4ba91c6b},
++  {__LINE__, 0x9eed31b0, "inverter", 8, 0xd5e78ba5},
++  {__LINE__, 0xb94f34ca, "jigsaw", 6, 0x23649109},
++  {__LINE__, 0xab058a2, "karate", 6, 0xc5591f41},
++  {__LINE__, 0x5bff2b7a, "landscape", 9, 0xf10eb644},
++  {__LINE__, 0x605c9a5f, "machine", 7, 0xbaa0a636},
++  {__LINE__, 0x51bdeea5, "nanometer", 9, 0x6af89afb},
++  {__LINE__, 0x85c21c79, "oblivion", 8, 0xecae222b},
++  {__LINE__, 0x97216f56, "panama", 6, 0x47dffac4},
++  {__LINE__, 0x18444af2, "quest", 5, 0x70c2fe36},
++  {__LINE__, 0xbe6ce359, "resource", 8, 0x1471d925},
++  {__LINE__, 0x843071f1, "secret", 6, 0x50c9a0db},
++  {__LINE__, 0xf2480c60, "ultimate", 8, 0xf973daf8},
++  {__LINE__, 0x2d2feb3d, "vector", 6, 0x344ac03d},
++  {__LINE__, 0x7490310a, "walrus", 6, 0x6d1408ef},
++  {__LINE__, 0x97d247d4, "xeno", 4, 0xe62670b5},
++  {__LINE__, 0x93cf7599, "yelling", 7, 0x1b36da38},
++  {__LINE__, 0x73c84278, "zlib", 4, 0x6432d127},
++  {__LINE__, 0x228a87d1, "4BJD7PocN1VqX0jXVpWB", 20, 0x997107d0},
++  {__LINE__, 0xa7a048d0, "F1rPWI7XvDs6nAIRx41l", 20, 0xdc567274},
++  {__LINE__, 0x1f0ded40, "ldhKlsVkPFOveXgkGtC2", 20, 0xdcc63870},
++  {__LINE__, 0xa804a62f, "5KKnGOOrs8BvJ35iKTOS", 20, 0x6926cffd},
++  {__LINE__, 0x508fae6a, "0l1tw7GOcem06Ddu7yn4", 20, 0xb52b38bc},
++  {__LINE__, 0xe5adaf4f, "MCr47CjPIn9R1IvE1Tm5", 20, 0xf83b8178},
++  {__LINE__, 0x67136a40, "UcixbzPKTIv0SvILHVdO", 20, 0xc5213070},
++  {__LINE__, 0xb00c4a10, "dGnAyAhRQDsWw0ESou24", 20, 0xbc7648b0},
++  {__LINE__, 0x2e0c84b5, "di0nvmY9UYMYDh0r45XT", 20, 0xd8123a72},
++  {__LINE__, 0x81238d44, "2XKDwHfAhFsV0RhbqtvH", 20, 0xd5ac5620},
++  {__LINE__, 0xf853aa92, "ZhrANFIiIvRnqClIVyeD", 20, 0xceae099d},
++  {__LINE__, 0x5a692325, "v7Q9ehzioTOVeDIZioT1", 20, 0xb07d2b24},
++  {__LINE__, 0x3275b9f, "Yod5hEeKcYqyhfXbhxj2", 20, 0x24ce91df},
++  {__LINE__, 0x38371feb, "GehSWY2ay4uUKhehXYb0", 20, 0x707b3b30},
++  {__LINE__, 0xafc8bf62, "kwytJmq6UqpflV8Y8GoE", 20, 0x16abc6a9},
++  {__LINE__, 0x9b07db73, "70684206568419061514", 20, 0xae1fb7b7},
++  {__LINE__, 0xe75b214, "42015093765128581010", 20, 0xd4eecd2d},
++  {__LINE__, 0x72d0fe6f, "88214814356148806939", 20, 0x4660ec7},
++  {__LINE__, 0xf857a4b1, "43472694284527343838", 20, 0xfd8afdf7},
++  {__LINE__, 0x54b8e14, "49769333513942933689", 20, 0xc6d1b5f2},
++  {__LINE__, 0xd6aa5616, "54979784887993251199", 20, 0x32476461},
++  {__LINE__, 0x11e63098, "58360544869206793220", 20, 0xd917cf1a},
++  {__LINE__, 0xbe92385, "27347953487840714234", 20, 0x4ad14a12},
++  {__LINE__, 0x49511de0, "07650690295365319082", 20, 0xe37b5c6c},
++  {__LINE__, 0x3db13bc1, "42655507906821911703", 20, 0x7cc497f1},
++  {__LINE__, 0xbb899bea, "29977409200786225655", 20, 0x99781bb2},
++  {__LINE__, 0xf6cd9436, "85181542907229116674", 20, 0x132256a1},
++  {__LINE__, 0x9109e6c3, "87963594337989416799", 20, 0xbfdb2c83},
++  {__LINE__, 0x75770fc, "21395988329504168551", 20, 0x8d9d1e81},
++  {__LINE__, 0x69b1d19b, "51991013580943379423", 20, 0x7b6d4404},
++  {__LINE__, 0xc6132975, "*]+@!);({_$;}[_},?{?;(_?,=-][@", 30, 0x8619f010},
++  {__LINE__, 0xd58cb00c, "_@:_).&(#.[:[{[:)$++-($_;@[)}+", 30, 0x15746ac3},
++  {__LINE__, 0xb63b8caa, "&[!,[$_==}+.]@!;*(+},[;:)$;)-@", 30, 0xaccf812f},
++  {__LINE__, 0x8a45a2b8, "]{.[.+?+[[=;[?}_#&;[=)__$$:+=_", 30, 0x78af45de},
++  {__LINE__, 0xcbe95b78, "-%.)=/[@].:.(:,()$;=%@-$?]{%+%", 30, 0x25b06b59},
++  {__LINE__, 0x4ef8a54b, "+]#$(@&.=:,*];/.!]%/{:){:@(;)$", 30, 0x4ba0d08f},
++  {__LINE__, 0x76ad267a, ")-._.:?[&:.=+}(*$/=!.${;(=$@!}", 30, 0xe26b6aac},
++  {__LINE__, 0x569e613c, ":(_*&%/[[}+,?#$&*+#[([*-/#;%(]", 30, 0x7e2b0a66},
++  {__LINE__, 0x36aa61da, "{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:", 30, 0xb3430dc7},
++  {__LINE__, 0xf67222df, "_{$*,}(&,@.)):=!/%(&(,,-?$}}}!", 30, 0x626c17a},
++  {__LINE__, 0x74b34fd3, "e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL", 100, 0xccf98060},
++  {__LINE__, 0x351fd770, "r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)", 100, 0xd8b95312},
++  {__LINE__, 0xc45aef77, "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&", 100, 0xbb1c9912},
++  {__LINE__, 0xc45aef77, "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&"
++                         "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&"
++                         "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&"
++                         "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&"
++                         "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&"
++                         "h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&", 600, 0x888AFA5B}
++};
++
++static const int test_size = sizeof(tests) / sizeof(tests[0]);
++
++int main(void)
++{
++    int i;
++    for (i = 0; i < test_size; i++) {
++        test_crc32(tests[i].crc, tests[i].buf, tests[i].len,
++                   tests[i].expect, tests[i].line);
++    }
++    return 0;
++}
+\ No newline at end of file
+-- 
+2.19.1
+

SOURCES/zlib-1.2.11-inflateSyncPoint-return-value-fix.patch

+Subject: [PATCH] Fixed inflateSyncPoint() bad return value on z15
+
+---
+ 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 574e84c..7960626 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
+\ No newline at end of file
+diff --git a/inflate.c b/inflate.c
+index f77c2ae..596034c 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
+@@ -1483,6 +1484,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.26.0
+

SOURCES/zlib-1.2.11-optimized-s390.patch

+diff --git a/deflate.c b/deflate.c
+index 1ec7614..b724c8d 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -1233,15 +1233,16 @@ local void lm_init (s)
+ /* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+  * match.S. The code will be functionally equivalent.
+  */
+-local uInt longest_match(s, cur_match)
++local uInt longest_match(s, pcur_match)
+     deflate_state *s;
+-    IPos cur_match;                             /* current match */
++    IPos pcur_match;                             /* current match */
+ {
++    ptrdiff_t cur_match = pcur_match; /* extend to pointer width */
+     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 int len;                           /* length of current match */
+-    int best_len = (int)s->prev_length;         /* best match length so far */
++    ptrdiff_t best_len = 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;
+@@ -1256,12 +1257,12 @@ local uInt longest_match(s, cur_match)
+      * Try with and without -DUNALIGNED_OK to check.
+      */
+     register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+-    register ush scan_start = *(ushf*)scan;
+-    register ush scan_end   = *(ushf*)(scan+best_len-1);
++    register uInt scan_start = *(ushf*)scan;
++    register uInt scan_end   = *(ushf*)(scan+best_len-1);
+ #else
+     register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+-    register Byte scan_end1  = scan[best_len-1];
+-    register Byte scan_end   = scan[best_len];
++    register uInt scan_end1  = scan[best_len-1];
++    register uInt scan_end   = scan[best_len];
+ #endif
+ 
+     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.

SOURCES/zlib-1.2.11-permit-deflateParams-change.patch

+From d09bb1ab8ef9bb91457c0ead09589e8807489260 Mon Sep 17 00:00:00 2001
+From: Ondrej Dubaj <odubaj@redhat.com>
+Date: Thu, 6 Aug 2020 08:09:53 +0200
+Subject: [PATCH] Permit a deflateParams() parameter change.
+
+This change allows a parameter change even if the input data has
+not all been compressed and copied to the application output
+buffer, so long as all of the input data has been compressed to
+the internal pending output buffer. This also allows an immediate
+deflateParams change so long as there have been no deflate calls
+since initialization or reset.
+---
+ deflate.c |  6 +++---
+ zlib.h    | 11 ++++++-----
+ 2 files changed, 9 insertions(+), 8 deletions(-)
+
+diff --git a/deflate.c b/deflate.c
+index 9705c1c..f3c9924 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -509,7 +509,7 @@ int ZEXPORT deflateResetKeep (strm)
+         s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+ #endif
+         adler32(0L, Z_NULL, 0);
+-    s->last_flush = Z_NO_FLUSH;
++    s->last_flush = -2;
+ 
+     _tr_init(s);
+ 
+@@ -606,13 +606,13 @@ int ZEXPORT deflateParams(strm, level, strategy)
+     func = configuration_table[s->level].func;
+ 
+     if ((strategy != s->strategy || func != configuration_table[level].func ||
+-        hook_flush != Z_NO_FLUSH) && s->high_water) {
++        hook_flush != Z_NO_FLUSH) && s->last_flush != -2) {
+         /* Flush the last buffer: */
+         int err = deflate(strm, RANK(hook_flush) > RANK(Z_BLOCK) ?
+                           hook_flush : Z_BLOCK); 
+         if (err == Z_STREAM_ERROR)
+             return err;
+-        if (strm->avail_out == 0)
++        if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
+             return Z_BUF_ERROR;
+     }
+     if (s->level != level) {
+diff --git a/zlib.h b/zlib.h
+index f09cdaf..001624e 100644
+--- a/zlib.h
++++ b/zlib.h
+@@ -712,11 +712,12 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+    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 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().
++   strategy is changed, and if there have been any deflate() calls since the
++   state was initialized or reset, then the input available so far is
++   compressed with the old level and strategy using deflate(strm, Z_BLOCK).
++   There are three approaches for the compression levels 0, 1..3, and 4..9
++   respectively.  The new level and strategy will take effect at the next call
++   of deflate().
+ 
+      If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+    not have enough output space to complete, then the parameter change will not
+-- 
+2.26.0
+

SOURCES/zlib-1.2.11-s390x-vectorize-crc32.patch

+From 2dfdc5b7d6943c0ac60eef63e361e2a50f9da610 Mon Sep 17 00:00:00 2001
+From: Ilya Leoshkevich <iii@linux.ibm.com>
+Date: Thu, 19 Mar 2020 11:52:03 +0100
+Subject: [PATCH] s390x: vectorize crc32
+
+Use vector extensions when compiling for s390x and binutils knows
+about them. At runtime, check whether kernel supports vector
+extensions (it has to be not just the CPU, but also the kernel) and
+choose between the regular and the vectorized implementations.
+---
+ Makefile.in             |   9 ++
+ configure               |  28 ++++++
+ contrib/s390/crc32-vx.c | 195 ++++++++++++++++++++++++++++++++++++++++
+ crc32.c                 |  55 +++++++++++-
+ 4 files changed, 285 insertions(+), 2 deletions(-)
+ create mode 100644 contrib/s390/crc32-vx.c
+
+diff --git a/Makefile.in b/Makefile.in
+index 6070dcc..9e9743b 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -29,6 +29,7 @@ LDFLAGS=
+ TEST_LDFLAGS=-L. libz.a
+ LDSHARED=$(CC)
+ CPP=$(CC) -E
++VGFMAFLAG=
+ 
+ STATICLIB=libz.a
+ SHAREDLIB=libz.so
+@@ -179,6 +180,9 @@ crc32_power8.o: $(SRCDIR)contrib/power8-crc/vec_crc32.c
+ crc32.o: $(SRCDIR)crc32.c
+ 	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)crc32.c
+ 
++crc32-vx.o: $(SRCDIR)contrib/s390/crc32-vx.c
++	$(CC) $(CFLAGS) $(VGFMAFLAG) $(ZINC) -c -o $@ $(SRCDIR)contrib/s390/crc32-vx.c
++
+ deflate.o: $(SRCDIR)deflate.c
+ 	$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)deflate.c
+ 
+@@ -234,6 +238,11 @@ crc32.lo: $(SRCDIR)crc32.c
+ 	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/crc32.o $(SRCDIR)crc32.c
+ 	-@mv objs/crc32.o $@
+ 
++crc32-vx.lo: $(SRCDIR)contrib/s390/crc32-vx.c
++	-@mkdir objs 2>/dev/null || test -d objs
++	$(CC) $(SFLAGS) $(VGFMAFLAG) $(ZINC) -DPIC -c -o objs/crc32-vx.o $(SRCDIR)contrib/s390/crc32-vx.c
++	-@mv objs/crc32-vx.o $@
++
+ deflate.lo: $(SRCDIR)deflate.c
+ 	-@mkdir objs 2>/dev/null || test -d objs
+ 	$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/deflate.o $(SRCDIR)deflate.c
+diff --git a/configure b/configure
+index 70ed86b..7941f75 100755
+--- a/configure
++++ b/configure
+@@ -923,6 +923,32 @@ EOF
+   fi
+ fi
+ 
++# check if we are compiling for s390 and binutils support vector extensions
++VGFMAFLAG=-march=z13
++cat > $test.c <<EOF
++#ifndef __s390__
++#error
++#endif
++EOF
++if try $CC -c $CFLAGS $VGFMAFLAG $test.c; then
++  CFLAGS="$CFLAGS -DHAVE_S390X_VX"
++  SFLAGS="$SFLAGS -DHAVE_S390X_VX"
++  OBJC="$OBJC crc32-vx.o"
++  PIC_OBJC="$PIC_OBJC crc32-vx.lo"
++  echo "Checking for s390 vector extensions... Yes." | tee -a configure.log
++
++  for flag in -mzarch -fzvector; do
++    if try $CC -c $CFLAGS $VGFMAFLAG $flag $test.c; then
++      VGFMAFLAG="$VGFMAFLAG $flag"
++      echo "Checking for $flag... Yes." | tee -a configure.log
++    else
++      echo "Checking for $flag... No." | tee -a configure.log
++    fi
++  done
++else
++  echo "Checking for s390 vector extensions... No." | tee -a configure.log
++fi
++
+ # show the results in the log
+ echo >> configure.log
+ echo ALL = $ALL >> configure.log
+@@ -955,6 +981,7 @@ echo mandir = $mandir >> configure.log
+ echo prefix = $prefix >> configure.log
+ echo sharedlibdir = $sharedlibdir >> configure.log
+ echo uname = $uname >> configure.log
++echo VGFMAFLAG = $VGFMAFLAG >> configure.log
+ 
+ # udpate Makefile with the configure results
+ sed < ${SRCDIR}Makefile.in "
+@@ -964,6 +991,7 @@ sed < ${SRCDIR}Makefile.in "
+ /^LDFLAGS *=/s#=.*#=$LDFLAGS#
+ /^LDSHARED *=/s#=.*#=$LDSHARED#
+ /^CPP *=/s#=.*#=$CPP#
++/^VGFMAFLAG *=/s#=.*#=$VGFMAFLAG#
+ /^STATICLIB *=/s#=.*#=$STATICLIB#
+ /^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
+ /^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
+diff --git a/contrib/s390/crc32-vx.c b/contrib/s390/crc32-vx.c
+new file mode 100644
+index 0000000..fa5387c
+--- /dev/null
++++ b/contrib/s390/crc32-vx.c
+@@ -0,0 +1,195 @@
++/*
++ * Hardware-accelerated CRC-32 variants for Linux on z Systems
++ *
++ * Use the z/Architecture Vector Extension Facility to accelerate the
++ * computing of bitreflected CRC-32 checksums.
++ *
++ * This CRC-32 implementation algorithm is bitreflected and processes
++ * the least-significant bit first (Little-Endian).
++ *
++ * This code was originally written by Hendrik Brueckner
++ * <brueckner@linux.vnet.ibm.com> for use in the Linux kernel and has been
++ * relicensed under the zlib license.
++ */
++
++#include "../../zutil.h"
++
++#include <stdint.h>
++#include <vecintrin.h>
++
++typedef unsigned char uv16qi __attribute__((vector_size(16)));
++typedef unsigned int uv4si __attribute__((vector_size(16)));
++typedef unsigned long long uv2di __attribute__((vector_size(16)));
++
++uint32_t crc32_le_vgfm_16(uint32_t crc, const unsigned char *buf, size_t len) {
++    /*
++     * The CRC-32 constant block contains reduction constants to fold and
++     * process particular chunks of the input data stream in parallel.
++     *
++     * For the CRC-32 variants, the constants are precomputed according to
++     * these definitions:
++     *
++     *      R1 = [(x4*128+32 mod P'(x) << 32)]' << 1
++     *      R2 = [(x4*128-32 mod P'(x) << 32)]' << 1
++     *      R3 = [(x128+32 mod P'(x) << 32)]'   << 1
++     *      R4 = [(x128-32 mod P'(x) << 32)]'   << 1
++     *      R5 = [(x64 mod P'(x) << 32)]'       << 1
++     *      R6 = [(x32 mod P'(x) << 32)]'       << 1
++     *
++     *      The bitreflected Barret reduction constant, u', is defined as
++     *      the bit reversal of floor(x**64 / P(x)).
++     *
++     *      where P(x) is the polynomial in the normal domain and the P'(x) is the
++     *      polynomial in the reversed (bitreflected) domain.
++     *
++     * CRC-32 (IEEE 802.3 Ethernet, ...) polynomials:
++     *
++     *      P(x)  = 0x04C11DB7
++     *      P'(x) = 0xEDB88320
++     */
++    const uv16qi perm_le2be = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};  /* BE->LE mask */
++    const uv2di r2r1 = {0x1C6E41596, 0x154442BD4};                                     /* R2, R1 */
++    const uv2di r4r3 = {0x0CCAA009E, 0x1751997D0};                                     /* R4, R3 */
++    const uv2di r5 = {0, 0x163CD6124};                                                 /* R5 */
++    const uv2di ru_poly = {0, 0x1F7011641};                                            /* u' */
++    const uv2di crc_poly = {0, 0x1DB710641};                                           /* P'(x) << 1 */
++
++    /*
++     * Load the initial CRC value.
++     *
++     * The CRC value is loaded into the rightmost word of the
++     * vector register and is later XORed with the LSB portion
++     * of the loaded input data.
++     */
++    uv2di v0 = {0, 0};
++    v0 = (uv2di)vec_insert(crc, (uv4si)v0, 3);
++
++    /* Load a 64-byte data chunk and XOR with CRC */
++    uv2di v1 = vec_perm(((uv2di *)buf)[0], ((uv2di *)buf)[0], perm_le2be);
++    uv2di v2 = vec_perm(((uv2di *)buf)[1], ((uv2di *)buf)[1], perm_le2be);
++    uv2di v3 = vec_perm(((uv2di *)buf)[2], ((uv2di *)buf)[2], perm_le2be);
++    uv2di v4 = vec_perm(((uv2di *)buf)[3], ((uv2di *)buf)[3], perm_le2be);
++
++    v1 ^= v0;
++    buf += 64;
++    len -= 64;
++
++    while (len >= 64) {
++        /* Load the next 64-byte data chunk */
++        uv16qi part1 = vec_perm(((uv16qi *)buf)[0], ((uv16qi *)buf)[0], perm_le2be);
++        uv16qi part2 = vec_perm(((uv16qi *)buf)[1], ((uv16qi *)buf)[1], perm_le2be);
++        uv16qi part3 = vec_perm(((uv16qi *)buf)[2], ((uv16qi *)buf)[2], perm_le2be);
++        uv16qi part4 = vec_perm(((uv16qi *)buf)[3], ((uv16qi *)buf)[3], perm_le2be);
++
++        /*
++         * Perform a GF(2) multiplication of the doublewords in V1 with
++         * the R1 and R2 reduction constants in V0.  The intermediate result
++         * is then folded (accumulated) with the next data chunk in PART1 and
++         * stored in V1. Repeat this step for the register contents
++         * in V2, V3, and V4 respectively.
++         */
++        v1 = (uv2di)vec_gfmsum_accum_128(r2r1, v1, part1);
++        v2 = (uv2di)vec_gfmsum_accum_128(r2r1, v2, part2);
++        v3 = (uv2di)vec_gfmsum_accum_128(r2r1, v3, part3);
++        v4 = (uv2di)vec_gfmsum_accum_128(r2r1, v4, part4);
++
++        buf += 64;
++        len -= 64;
++    }
++
++    /*
++     * Fold V1 to V4 into a single 128-bit value in V1.  Multiply V1 with R3
++     * and R4 and accumulating the next 128-bit chunk until a single 128-bit
++     * value remains.
++     */
++    v1 = (uv2di)vec_gfmsum_accum_128(r4r3, v1, (uv16qi)v2);
++    v1 = (uv2di)vec_gfmsum_accum_128(r4r3, v1, (uv16qi)v3);
++    v1 = (uv2di)vec_gfmsum_accum_128(r4r3, v1, (uv16qi)v4);
++
++    while (len >= 16) {
++        /* Load next data chunk */
++        v2 = vec_perm(*(uv2di *)buf, *(uv2di *)buf, perm_le2be);
++
++        /* Fold next data chunk */
++        v1 = (uv2di)vec_gfmsum_accum_128(r4r3, v1, (uv16qi)v2);
++
++        buf += 16;
++        len -= 16;
++    }
++
++    /*
++     * Set up a vector register for byte shifts.  The shift value must
++     * be loaded in bits 1-4 in byte element 7 of a vector register.
++     * Shift by 8 bytes: 0x40
++     * Shift by 4 bytes: 0x20
++     */
++    uv16qi v9 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
++    v9 = vec_insert((unsigned char)0x40, v9, 7);
++
++    /*
++     * Prepare V0 for the next GF(2) multiplication: shift V0 by 8 bytes
++     * to move R4 into the rightmost doubleword and set the leftmost
++     * doubleword to 0x1.
++     */
++    v0 = vec_srb(r4r3, (uv2di)v9);
++    v0[0] = 1;
++
++    /*
++     * Compute GF(2) product of V1 and V0.  The rightmost doubleword
++     * of V1 is multiplied with R4.  The leftmost doubleword of V1 is
++     * multiplied by 0x1 and is then XORed with rightmost product.
++     * Implicitly, the intermediate leftmost product becomes padded
++     */
++    v1 = (uv2di)vec_gfmsum_128(v0, v1);
++
++    /*
++     * Now do the final 32-bit fold by multiplying the rightmost word
++     * in V1 with R5 and XOR the result with the remaining bits in V1.
++     *
++     * To achieve this by a single VGFMAG, right shift V1 by a word
++     * and store the result in V2 which is then accumulated.  Use the
++     * vector unpack instruction to load the rightmost half of the
++     * doubleword into the rightmost doubleword element of V1; the other
++     * half is loaded in the leftmost doubleword.
++     * The vector register with CONST_R5 contains the R5 constant in the
++     * rightmost doubleword and the leftmost doubleword is zero to ignore
++     * the leftmost product of V1.
++     */
++    v9 = vec_insert((unsigned char)0x20, v9, 7);
++    v2 = vec_srb(v1, (uv2di)v9);
++    v1 = vec_unpackl((uv4si)v1);  /* Split rightmost doubleword */
++    v1 = (uv2di)vec_gfmsum_accum_128(r5, v1, (uv16qi)v2);
++
++    /*
++     * Apply a Barret reduction to compute the final 32-bit CRC value.
++     *
++     * The input values to the Barret reduction are the degree-63 polynomial
++     * in V1 (R(x)), degree-32 generator polynomial, and the reduction
++     * constant u.  The Barret reduction result is the CRC value of R(x) mod
++     * P(x).
++     *
++     * The Barret reduction algorithm is defined as:
++     *
++     *    1. T1(x) = floor( R(x) / x^32 ) GF2MUL u
++     *    2. T2(x) = floor( T1(x) / x^32 ) GF2MUL P(x)
++     *    3. C(x)  = R(x) XOR T2(x) mod x^32
++     *
++     *  Note: The leftmost doubleword of vector register containing
++     *  CONST_RU_POLY is zero and, thus, the intermediate GF(2) product
++     *  is zero and does not contribute to the final result.
++     */
++
++    /* T1(x) = floor( R(x) / x^32 ) GF2MUL u */
++    v2 = vec_unpackl((uv4si)v1);
++    v2 = (uv2di)vec_gfmsum_128(ru_poly, v2);
++
++    /*
++     * Compute the GF(2) product of the CRC polynomial with T1(x) in
++     * V2 and XOR the intermediate result, T2(x), with the value in V1.
++     * The final result is stored in word element 2 of V2.
++     */
++    v2 = vec_unpackl((uv4si)v2);
++    v2 = (uv2di)vec_gfmsum_accum_128(crc_poly, v2, (uv16qi)v1);
++
++    return ((uv4si)v2)[2];
++}
+diff --git a/crc32.c b/crc32.c
+index 34132ea..dfa33ef 100644
+--- a/crc32.c
++++ b/crc32.c
+@@ -252,12 +252,54 @@ unsigned long crc32_vpmsum(unsigned long, const unsigned char FAR *, z_size_t);
+ #endif
+ #endif
+ 
++#ifdef HAVE_S390X_VX
++#include <sys/auxv.h>
++
++#define VX_MIN_LEN 64
++#define VX_ALIGNMENT 16L
++#define VX_ALIGN_MASK (VX_ALIGNMENT - 1)
++
++unsigned int crc32_le_vgfm_16(unsigned int crc, const unsigned char FAR *buf, z_size_t len);
++
++local unsigned long s390_crc32_vx(unsigned long crc, const unsigned char FAR *buf, z_size_t len)
++{
++    uint64_t prealign, aligned, remaining;
++
++    if (buf == Z_NULL) return 0UL;
++
++    if (len < VX_MIN_LEN + VX_ALIGN_MASK)
++        return crc32_big(crc, buf, len);
++
++    if ((uintptr_t)buf & VX_ALIGN_MASK) {
++        prealign = VX_ALIGNMENT - ((uintptr_t)buf & VX_ALIGN_MASK);
++        len -= prealign;
++        crc = crc32_big(crc, buf, prealign);
++        buf += prealign;
++    }
++    aligned = len & ~VX_ALIGN_MASK;
++    remaining = len & VX_ALIGN_MASK;
++
++    crc = crc32_le_vgfm_16(crc ^ 0xffffffff, buf, (size_t)aligned) ^ 0xffffffff;
++
++    if (remaining)
++        crc = crc32_big(crc, buf + aligned, remaining);
++
++    return crc;
++}
++#endif
++
+ /* due to a quirk of gnu_indirect_function - "local" (aka static) is applied to
+  * crc32_z which is not desired. crc32_z_ifunc is implictly "local" */
+ #ifndef Z_IFUNC_ASM
+ local
+ #endif
+-unsigned long (*(crc32_z_ifunc(void)))(unsigned long, const unsigned char FAR *, z_size_t)
++unsigned long (*(crc32_z_ifunc(
++#ifdef __s390__
++unsigned long hwcap
++#else
++void
++#endif
++)))(unsigned long, const unsigned char FAR *, z_size_t)
+ {
+ #if _ARCH_PWR8==1
+ #if defined(__BUILTIN_CPU_SUPPORTS__)
+@@ -269,6 +311,11 @@ unsigned long (*(crc32_z_ifunc(void)))(unsigned long, const unsigned char FAR *,
+ #endif
+ #endif /* _ARCH_PWR8 */
+ 
++#ifdef HAVE_S390X_VX
++    if (hwcap & HWCAP_S390_VX)
++        return s390_crc32_vx;
++#endif
++
+ /* return a function pointer for optimized arches here */
+ 
+ #ifdef DYNAMIC_CRC_TABLE
+@@ -301,7 +348,11 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
+     static unsigned long ZEXPORT (*crc32_func)(unsigned long, const unsigned char FAR *, z_size_t) = NULL;
+ 
+     if (!crc32_func)
+-        crc32_func = crc32_z_ifunc();
++        crc32_func = crc32_z_ifunc(
++#ifdef __s390__
++            getauxval(AT_HWCAP)
++#endif
++        );
+     return (*crc32_func)(crc, buf, len);
+ }
+ 
+-- 
+2.25.1
+

SOURCES/zlib-1.2.5-minizip-fixuncrypt.patch

+diff -up zlib-1.2.5/contrib/minizip/unzip.c.fixuncrypt zlib-1.2.5/contrib/minizip/unzip.c
+--- zlib-1.2.5/contrib/minizip/unzip.c.fixuncrypt	2011-11-11 12:13:56.335867758 -0500
++++ zlib-1.2.5/contrib/minizip/unzip.c	2011-11-11 12:14:01.747799372 -0500
+@@ -68,10 +68,6 @@
+ #include <stdlib.h>
+ #include <string.h>
+ 
+-#ifndef NOUNCRYPT
+-        #define NOUNCRYPT
+-#endif
+-
+ #include "zlib.h"
+ #include "unzip.h"
+