automatic import of zlibopeneuler24.03_LTS_SP3

22 files changed, 1869 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..0c5559f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/zlib-1.2.13.tar.xz
diff --git a/backport-Add-bounds-checking-to-ERR_MSG-macro-used-by-zError.patch b/backport-Add-bounds-checking-to-ERR_MSG-macro-used-by-zError.patch
new file mode 100644
index 0000000..e4d75cf
--- /dev/null
+++ b/backport-Add-bounds-checking-to-ERR_MSG-macro-used-by-zError.patch
@@ -0,0 +1,27 @@
+From 431a9b65eacab7efabf2230ba97ff426c0e07f9d Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Thu, 7 Dec 2023 06:38:10 -0800
+Subject: [PATCH] Add bounds checking to ERR_MSG() macro, used by zError().
+
+Reference: https://github.com/madler/zlib/commit/431a9b65eacab7efabf2230ba97ff426c0e07f9d
+Conflict: no
+---
+ zutil.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/zutil.h b/zutil.h
+index 902a304..0bd2dbc 100644
+--- a/zutil.h
++++ b/zutil.h
+@@ -56,7 +56,7 @@ typedef unsigned long  ulg;
+ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+ /* (size given to avoid silly warnings with Visual C++) */
+ 
+-#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
++#define ERR_MSG(err) z_errmsg[(err) < -6 || (err) > 2 ? 9 : 2 - (err)]
+ 
+ #define ERR_RETURN(strm,err) \
+   return (strm->msg = ERR_MSG(err), (err))
+-- 
+2.33.0
+
diff --git a/backport-CVE-2023-45853.patch b/backport-CVE-2023-45853.patch
new file mode 100644
index 0000000..f750e0f
--- /dev/null
+++ b/backport-CVE-2023-45853.patch
@@ -0,0 +1,39 @@
+From 73331a6a0481067628f065ffe87bb1d8f787d10c Mon Sep 17 00:00:00 2001
+From: Hans Wennborg <hans@chromium.org>
+Date: Fri, 18 Aug 2023 11:05:33 +0200
+Subject: [PATCH] Reject overflows of zip header fields in minizip.
+
+This checks the lengths of the file name, extra field, and comment
+that would be put in the zip headers, and rejects them if they are
+too long. They are each limited to 65535 bytes in length by the zip
+format. This also avoids possible buffer overflows if the provided
+fields are too long.
+---
+ contrib/minizip/zip.c | 11 +++++++++++
+ 1 file changed, 11 insertions(+)
+
+diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
+index 3d3d4ca..0446109 100644
+--- a/contrib/minizip/zip.c
++++ b/contrib/minizip/zip.c
+@@ -1043,6 +1043,17 @@ extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, c
+       return ZIP_PARAMERROR;
+ #endif
+ 
++    // The filename and comment length must fit in 16 bits.
++    if ((filename!=NULL) && (strlen(filename)>0xffff))
++        return ZIP_PARAMERROR;
++    if ((comment!=NULL) && (strlen(comment)>0xffff))
++        return ZIP_PARAMERROR;
++    // The extra field length must fit in 16 bits. If the member also requires
++    // a Zip64 extra block, that will also need to fit within that 16-bit
++    // length, but that will be checked for later.
++    if ((size_extrafield_local>0xffff) || (size_extrafield_global>0xffff))
++        return ZIP_PARAMERROR;
++
+     zi = (zip64_internal*)file;
+ 
+     if (zi->in_opened_file_inzip == 1)
+-- 
+2.41.0.windows.3
+
diff --git a/backport-CVE-2026-27171.patch b/backport-CVE-2026-27171.patch
new file mode 100644
index 0000000..c22968c
--- /dev/null
+++ b/backport-CVE-2026-27171.patch
@@ -0,0 +1,60 @@
+From ba829a458576d1ff0f26fc7230c6de816d1f6a77 Mon Sep 17 00:00:00 2001
+From: Mark Adler <git@madler.net>
+Date: Sun, 21 Dec 2025 18:17:56 -0800
+Subject: [PATCH] Check for negative lengths in crc32_combine functions.
+
+Though zlib.h says that len2 must be non-negative, this avoids the
+possibility of an accidental infinite loop.
+
+link:https://github.com/madler/zlib/commit/ba829a458576d1ff0f26fc7230c6de816d1f6a77
+---
+ crc32.c | 4 ++++
+ zlib.h  | 4 ++--
+ 2 files changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/crc32.c b/crc32.c
+index 23f8f8b..40f0810 100644
+--- a/crc32.c
++++ b/crc32.c
+@@ -1133,6 +1133,8 @@ uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
+     uLong crc2;
+     z_off64_t len2;
+ {
++    if (len2 < 0)
++        return 0;
+ #ifdef DYNAMIC_CRC_TABLE
+     once(&made, make_crc_table);
+ #endif /* DYNAMIC_CRC_TABLE */
+@@ -1152,6 +1154,8 @@ uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+ uLong ZEXPORT crc32_combine_gen64(len2)
+     z_off64_t len2;
+ {
++    if (len2 < 0)
++        return 0;
+ #ifdef DYNAMIC_CRC_TABLE
+     once(&made, make_crc_table);
+ #endif /* DYNAMIC_CRC_TABLE */
+diff --git a/zlib.h b/zlib.h
+index 953cb50..c9cecf3 100644
+--- a/zlib.h
++++ b/zlib.h
+@@ -1755,14 +1755,14 @@ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+    seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+    calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+    check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+-   len2.
++   len2. len2 must be non-negativem, otherwise zero is returned.
+ */
+ 
+ /*
+ ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2));
+ 
+      Return the operator corresponding to length len2, to be used with
+-   crc32_combine_op().
++   crc32_combine_op(). len2 must be non-negative, otherwise zero is returned.
+ */
+ 
+ ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op));
+-- 
+2.43.0
+
diff --git a/backport-Fix-a-bug-in-ZLIB_DEBUG-compiles-in-check_match.patch b/backport-Fix-a-bug-in-ZLIB_DEBUG-compiles-in-check_match.patch
new file mode 100644
index 0000000..18bc6a8
--- /dev/null
+++ b/backport-Fix-a-bug-in-ZLIB_DEBUG-compiles-in-check_match.patch
@@ -0,0 +1,50 @@
+From 7af6320ad78b390de42f414fabdc64dc6d67a5ea Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Fri, 19 Jan 2024 12:19:53 -0800
+Subject: [PATCH] Fix a bug in ZLIB_DEBUG compiles in check_match().
+
+This avoids trying to compare a match starting one byte before the
+current window. Thanks to @zmodem (Hans) for discovering this.
+
+Reference:https://github.com/madler/zlib/commit/7af6320ad78b390de42f414fabdc64dc6d67a5ea
+Conflict: Patch context adaptation
+
+---
+ deflate.c | 20 ++++++++++++++------
+ 1 file changed, 14 insertions(+), 6 deletions(-)
+
+diff --git a/deflate.c b/deflate.c
+index 8088083..396ab12 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -1510,13 +1510,21 @@ local void check_match(s, start, match, length)
+     int length;
+ {
+     /* check that the match is indeed a match */
+-    if (zmemcmp(s->window + match,
+-                s->window + start, length) != EQUAL) {
+-        fprintf(stderr, " start %u, match %u, length %d\n",
+-                start, match, length);
++    Bytef *back = s->window + (int)match, *here = s->window + start;
++    IPos len = length;
++    if (match == (IPos)-1) {
++        /* match starts one byte before the current window -- just compare the
++           subsequent length-1 bytes */
++        back++;
++        here++;
++        len--;
++    }
++    if (zmemcmp(back, here, len) != EQUAL) {
++        fprintf(stderr, " start %u, match %d, length %d\n",
++                start, (int)match, length);
+         do {
+-            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+-        } while (--length != 0);
++            fprintf(stderr, "(%02x %02x)", *back++, *here++);
++        } while (--len != 0);
+         z_error("invalid match");
+     }
+     if (z_verbose > 1) {
+-- 
+2.33.0
+
diff --git a/backport-Fix-bug-in-inflateSync-for-data-held-in-bit-buffer.patch b/backport-Fix-bug-in-inflateSync-for-data-held-in-bit-buffer.patch
new file mode 100644
index 0000000..0bcac9f
--- /dev/null
+++ b/backport-Fix-bug-in-inflateSync-for-data-held-in-bit-buffer.patch
@@ -0,0 +1,27 @@
+From 5af7cef45eeef86ddf6ab00b4e363c1eecaf47b6 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Thu, 24 Aug 2023 02:14:23 -0400
+Subject: [PATCH] Fix bug in inflateSync() for data held in bit buffer.
+
+Reference: https://github.com/madler/zlib/commit/5af7cef45eeef86ddf6ab00b4e363c1eecaf47b6
+Conflict: no
+---
+ inflate.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/inflate.c b/inflate.c
+index b0757a9..94ecff0 100644
+--- a/inflate.c
++++ b/inflate.c
+@@ -1387,7 +1387,7 @@ int ZEXPORT inflateSync(z_streamp strm) {
+     /* if first time, start search in bit buffer */
+     if (state->mode != SYNC) {
+         state->mode = SYNC;
+-        state->hold <<= state->bits & 7;
++        state->hold >>= state->bits & 7;
+         state->bits -= state->bits & 7;
+         len = 0;
+         while (state->bits >= 8) {
+-- 
+2.33.0
+
diff --git a/backport-Fix-bug-when-gzungetc-is-used-immediately-after-gzopen.patch b/backport-Fix-bug-when-gzungetc-is-used-immediately-after-gzopen.patch
new file mode 100644
index 0000000..a6b892e
--- /dev/null
+++ b/backport-Fix-bug-when-gzungetc-is-used-immediately-after-gzopen.patch
@@ -0,0 +1,26 @@
+From 7dd6aa72455ef1f2aacdc28a00d1eaf632d59593 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Fri, 11 Aug 2023 10:59:03 -0700
+Subject: [PATCH] Fix bug when gzungetc() is used immediately after gzopen().
+
+Reference:https://github.com/madler/zlib/commit/7dd6aa72455ef1f2aacdc28a00d1eaf632d59593
+Conflict:NA
+---
+ gzread.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/gzread.c b/gzread.c
+index 6034a2823..4168cbc88 100644
+--- a/gzread.c
++++ b/gzread.c
+@@ -443,6 +443,10 @@ int ZEXPORT gzungetc(int c, gzFile file) {
+         return -1;
+     state = (gz_statep)file;
+ 
++    /* in case this was just opened, set up the input buffer */
++    if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
++        (void)gz_look(state);
++
+     /* check that we're reading and that there's no (serious) error */
+     if (state->mode != GZ_READ ||
+         (state->err != Z_OK && state->err != Z_BUF_ERROR))
diff --git a/backport-Fix-bug-when-using-gzflush-with-a-very-small-buffer.patch b/backport-Fix-bug-when-using-gzflush-with-a-very-small-buffer.patch
new file mode 100644
index 0000000..047c17d
--- /dev/null
+++ b/backport-Fix-bug-when-using-gzflush-with-a-very-small-buffer.patch
@@ -0,0 +1,26 @@
+From d98251478246c8ef2f405d76e4ef1678c14d7eda Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Mon, 14 Aug 2023 17:01:54 -0700
+Subject: [PATCH] Fix bug when using gzflush() with a very small buffer.
+
+Reference:https://github.com/madler/zlib/commit/d98251478246c8ef2f405d76e4ef1678c14d7eda
+Conflict:NA
+---
+ gzlib.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/gzlib.c b/gzlib.c
+index 2b446c448..29fc4486f 100644
+--- a/gzlib.c
++++ b/gzlib.c
+@@ -308,8 +308,8 @@ int ZEXPORT gzbuffer(gzFile file, unsigned size) {
+     /* check and set requested size */
+     if ((size << 1) < size)
+         return -1;              /* need to be able to double it */
+-    if (size < 2)
+-        size = 2;               /* need two bytes to check magic header */
++    if (size < 8)
++        size = 8;               /* needed to behave well with flushing */
+     state->want = size;
+     return 0;
+ }
diff --git a/backport-Fix-crash-when-gzsetparams-attempted-for-transparent-write.patch b/backport-Fix-crash-when-gzsetparams-attempted-for-transparent-write.patch
new file mode 100644
index 0000000..1d488ba
--- /dev/null
+++ b/backport-Fix-crash-when-gzsetparams-attempted-for-transparent-write.patch
@@ -0,0 +1,26 @@
+From 02a6049eb3884c430268bb0fe3296d597a03174c Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Mon, 26 Dec 2022 23:36:01 -0800
+Subject: [PATCH] Fix crash when gzsetparams() attempted for transparent write.
+
+gzsetparams() now returns a Z_STREAM_ERROR in this case.i
+
+Reference:https://github.com/madler/zlib/commit/02a6049eb3884c430268bb0fe3296d597a03174c
+Conflict:NA
+---
+ gzwrite.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/gzwrite.c b/gzwrite.c
+index eb8a0e589..3030d74d6 100644
+--- a/gzwrite.c
++++ b/gzwrite.c
+@@ -609,7 +609,7 @@ int ZEXPORT gzsetparams(file, level, strategy)
+     strm = &(state->strm);
+ 
+     /* check that we're writing and that there's no error */
+-    if (state->mode != GZ_WRITE || state->err != Z_OK)
++    if (state->mode != GZ_WRITE || state->err != Z_OK || state->direct)
+         return Z_STREAM_ERROR;
+ 
+     /* if no change is requested, then do nothing */
diff --git a/backport-Fix-decision-on-the-emission-of-Zip64-end-records-in.patch b/backport-Fix-decision-on-the-emission-of-Zip64-end-records-in.patch
new file mode 100644
index 0000000..a2a8435
--- /dev/null
+++ b/backport-Fix-decision-on-the-emission-of-Zip64-end-records-in.patch
@@ -0,0 +1,35 @@
+From 15c45adb76e81a7e3a8a9e17b2a56eb90f668f44 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Tue, 7 Nov 2023 15:46:41 -0800
+Subject: [PATCH] Fix decision on the emission of Zip64 end records in minizip.
+
+The appnote says that if the number of entries in the end record
+is 0xffff, then the actual number of entries will be found in the
+Zip64 end record. Therefore if the number of entries is equal to
+0xffff, it can't be in the end record by itself, since that is an
+instruction to get the number from the Zip64 end record. This code
+would just store 0xffff in the end record in that case, not making
+a Zip64 end record. This commit fixes that.
+
+Reference: https://github.com/madler/zlib/commit/15c45adb76e81a7e3a8a9e17b2a56eb90f668f44
+Conflict: no
+---
+ contrib/minizip/zip.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
+index 0446109..86be90b 100644
+--- a/contrib/minizip/zip.c
++++ b/contrib/minizip/zip.c
+@@ -1872,7 +1872,7 @@ extern int ZEXPORT zipClose(zipFile file, const char* global_comment) {
+     free_linkedlist(&(zi->central_dir));
+ 
+     pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+-    if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)
++    if(pos >= 0xffffffff || zi->number_entry >= 0xFFFF)
+     {
+       ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
+       Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+-- 
+2.33.0
+
diff --git a/backport-Fix-logic-error-in-minizip-argument-processing.patch b/backport-Fix-logic-error-in-minizip-argument-processing.patch
new file mode 100644
index 0000000..e10da93
--- /dev/null
+++ b/backport-Fix-logic-error-in-minizip-argument-processing.patch
@@ -0,0 +1,24 @@
+From 3061e5013c2569974fd7d830f2776b38da4e2691 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Sat, 29 Jul 2023 23:51:22 -0700
+Subject: [PATCH] Fix logic error in minizip argument processing.
+
+Reference:https://github.com/madler/zlib/commit/3061e5013c2569974fd7d830f2776b38da4e2691
+Conflict:NA
+---
+ contrib/minizip/minizip.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/contrib/minizip/minizip.c b/contrib/minizip/minizip.c
+index f458c85ef..61a9d4c7d 100644
+--- a/contrib/minizip/minizip.c
++++ b/contrib/minizip/minizip.c
+@@ -381,7 +381,7 @@ int main(int argc, char *argv[]) {
+                   ((argv[i][1]=='o') || (argv[i][1]=='O') ||
+                    (argv[i][1]=='a') || (argv[i][1]=='A') ||
+                    (argv[i][1]=='p') || (argv[i][1]=='P') ||
+-                   ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
++                   ((argv[i][1]>='0') && (argv[i][1]<='9'))) &&
+                   (strlen(argv[i]) == 2)))
+             {
+                 FILE * fin;
diff --git a/backport-Fix-reading-disk-number-start-on-zip64-files-in-minizip.patch b/backport-Fix-reading-disk-number-start-on-zip64-files-in-minizip.patch
new file mode 100644
index 0000000..f68c8af
--- /dev/null
+++ b/backport-Fix-reading-disk-number-start-on-zip64-files-in-minizip.patch
@@ -0,0 +1,40 @@
+From e0bd0ad6e4d8afd2bc3d55d84d459a0e2c0e2890 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Sat, 29 Jul 2023 23:34:26 -0700
+Subject: [PATCH] Fix reading disk number start on zip64 files in minizip.
+
+Reference:https://github.com/madler/zlib/commit/e0bd0ad6e4d8afd2bc3d55d84d459a0e2c0e2890
+Conflict:NA
+---
+ contrib/minizip/unzip.c | 6 ++----
+ 1 file changed, 2 insertions(+), 4 deletions(-)
+
+diff --git a/contrib/minizip/unzip.c b/contrib/minizip/unzip.c
+index 1da51a9..9329732 100644
+--- a/contrib/minizip/unzip.c
++++ b/contrib/minizip/unzip.c
+@@ -1038,8 +1038,6 @@ local int unz64local_GetCurrentFileInfoInternal (unzFile file,
+             /* ZIP64 extra fields */
+             if (headerId == 0x0001)
+             {
+-                                                        uLong uL;
+-
+                                                                 if(file_info.uncompressed_size == MAXU32)
+                                                                 {
+                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
+@@ -1059,10 +1057,10 @@ local int unz64local_GetCurrentFileInfoInternal (unzFile file,
+                                                                                 err=UNZ_ERRNO;
+                                                                 }
+ 
+-                                                                if(file_info.disk_num_start == MAXU32)
++                                                                if(file_info.disk_num_start == 0xffff)
+                                                                 {
+                                                                         /* Disk Start Number */
+-                                                                        if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++                                                                        if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
+                                                                                 err=UNZ_ERRNO;
+                                                                 }
+ 
+-- 
+2.27.0
+
diff --git a/backport-Neutralize-zip-file-traversal-attacks-in-miniunz.patch b/backport-Neutralize-zip-file-traversal-attacks-in-miniunz.patch
new file mode 100644
index 0000000..18589f5
--- /dev/null
+++ b/backport-Neutralize-zip-file-traversal-attacks-in-miniunz.patch
@@ -0,0 +1,61 @@
+From 14a5f8f266c16c87ab6c086fc52b770b27701e01 Mon Sep 17 00:00:00 2001
+From: Matt Wilson <msw@amazon.com>
+Date: Wed, 17 Jan 2024 14:46:18 -0800
+Subject: [PATCH] Neutralize zip file traversal attacks in miniunz.
+
+Archive formats such as .zip files are generally susceptible to
+so-called "traversal attacks". This allows an attacker to craft
+an archive that writes to unexpected locations of the file system
+(e.g., /etc/shadow) if an unspecting root user were to unpack a
+malicious archive.
+
+This patch neutralizes absolute paths such as /tmp/moo and deeply
+relative paths such as dummy/../../../../../../../../../../tmp/moo
+
+The Debian project requested CVE-2014-9485 be allocated for the
+first identified weakness. The fix was incomplete, resulting in a
+revised patch applied here. Since there wasn't an updated version
+released by Debian with the incomplete fix, I suggest we use this
+CVE to identify both issues.
+
+Link: https://security.snyk.io/research/zip-slip-vulnerability
+Link: https://bugs.debian.org/774321
+Link: https://bugs.debian.org/776831
+Link: https://nvd.nist.gov/vuln/detail/CVE-2014-9485
+Reported-by: Jakub Wilk <jwilk@debian.org>
+Fixed-by: Michael Gilbert <mgilbert@debian.org>
+
+Reference: https://github.com/madler/zlib/commit/14a5f8f266c16c87ab6c086fc52b770b27701e01
+Conflict: no
+---
+ contrib/minizip/miniunz.c | 14 ++++++++++++++
+ 1 file changed, 14 insertions(+)
+
+diff --git a/contrib/minizip/miniunz.c b/contrib/minizip/miniunz.c
+index 0c2fb0d..d627c42 100644
+--- a/contrib/minizip/miniunz.c
++++ b/contrib/minizip/miniunz.c
+@@ -356,6 +356,20 @@ static int do_extract_currentfile(unzFile uf, const int* popt_extract_without_pa
+         else
+             write_filename = filename_withoutpath;
+ 
++        if (write_filename[0]!='\0')
++        {
++            const char* relative_check = write_filename;
++            while (relative_check[1]!='\0')
++            {
++                if (relative_check[0]=='.' && relative_check[1]=='.')
++                    write_filename = relative_check;
++                relative_check++;
++            }
++        }
++
++        while (write_filename[0]=='/' || write_filename[0]=='.')
++            write_filename++;
++
+         err = unzOpenCurrentFilePassword(uf,password);
+         if (err!=UNZ_OK)
+         {
+-- 
+2.33.0
+
diff --git a/backport-Remove-use-of-OF-from-contrib-untgz-and-render-it-compilable.patch b/backport-Remove-use-of-OF-from-contrib-untgz-and-render-it-compilable.patch
new file mode 100644
index 0000000..eabc5eb
--- /dev/null
+++ b/backport-Remove-use-of-OF-from-contrib-untgz-and-render-it-compilable.patch
@@ -0,0 +1,109 @@
+From 66588683b36042154ad35140bf9fcbb60c5d573c Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Sat, 15 Apr 2023 11:27:12 -0700
+Subject: [PATCH] Remove use of OF() from contrib/untgz and render it
+ compilable.
+
+Reference:https://github.com/madler/zlib/commit/66588683b36042154ad35140bf9fcbb60c5d573c
+Conflict:NA
+---
+ contrib/untgz/untgz.c | 47 +++++++++++--------------------------------
+ 1 file changed, 12 insertions(+), 35 deletions(-)
+
+diff --git a/contrib/untgz/untgz.c b/contrib/untgz/untgz.c
+index 2c391e598..3e530971c 100644
+--- a/contrib/untgz/untgz.c
++++ b/contrib/untgz/untgz.c
+@@ -14,15 +14,10 @@
+ 
+ #include "zlib.h"
+ 
+-#ifdef unix
+-#  include <unistd.h>
+-#else
++#ifdef _WIN32
+ #  include <direct.h>
+ #  include <io.h>
+-#endif
+-
+-#ifdef WIN32
+-#include <windows.h>
++#  include <windows.h>
+ #  ifndef F_OK
+ #    define F_OK  0
+ #  endif
+@@ -33,6 +28,8 @@
+ #    define strdup(str)         _strdup(str)
+ #  endif
+ #else
++#  include <sys/stat.h>
++#  include <unistd.h>
+ #  include <utime.h>
+ #endif
+ 
+@@ -102,28 +99,14 @@ struct attr_item
+ 
+ enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };
+ 
+-char *TGZfname          OF((const char *));
+-void TGZnotfound        OF((const char *));
+-
+-int getoct              OF((char *, int));
+-char *strtime           OF((time_t *));
+-int setfiletime         OF((char *, time_t));
+-void push_attr          OF((struct attr_item **, char *, int, time_t));
+-void restore_attr       OF((struct attr_item **));
+-
+-int ExprMatch           OF((char *, char *));
+-
+-int makedir             OF((char *));
+-int matchname           OF((int, int, char **, char *));
+-
+-void error              OF((const char *));
+-int tar                 OF((gzFile, int, int, int, char **));
+-
+-void help               OF((int));
+-int main                OF((int, char **));
+-
+ char *prog;
+ 
++void error(const char *msg)
++{
++  fprintf(stderr, "%s: %s\n", prog, msg);
++  exit(1);
++}
++
+ const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };
+ 
+ /* return the file name of the TGZ archive */
+@@ -205,7 +188,7 @@ char *strtime (time_t *t)
+ 
+ int setfiletime (char *fname,time_t ftime)
+ {
+-#ifdef WIN32
++#ifdef _WIN32
+   static int isWinNT = -1;
+   SYSTEMTIME st;
+   FILETIME locft, modft;
+@@ -590,12 +573,6 @@ void help(int exitval)
+   exit(exitval);
+ }
+ 
+-void error(const char *msg)
+-{
+-  fprintf(stderr, "%s: %s\n", prog, msg);
+-  exit(1);
+-}
+-
+ 
+ /* ============================================================ */
+ 
+@@ -608,7 +585,7 @@ int main(int argc,char **argv)
+     int         action = TGZ_EXTRACT;
+     int         arg = 1;
+     char        *TGZfile;
+-    gzFile      *f;
++    gzFile      f;
+ 
+     prog = strrchr(argv[0],'\\');
+     if (prog == NULL)
diff --git a/backport-Suppress-MSAN-detections-in-deflate-slide_hash.patch b/backport-Suppress-MSAN-detections-in-deflate-slide_hash.patch
new file mode 100644
index 0000000..449a9e3
--- /dev/null
+++ b/backport-Suppress-MSAN-detections-in-deflate-slide_hash.patch
@@ -0,0 +1,36 @@
+From 981ee7570ad98a3cf1ae74d737e2ee619ed79171 Mon Sep 17 00:00:00 2001
+From: Andrzej Hunt <andrzej@ahunt.org>
+Date: Fri, 4 Jun 2021 18:25:19 +0200
+Subject: [PATCH] Suppress MSAN detections in deflate's slide_hash().
+
+slide_hash() knowingly reads potentially uninitialized memory, see
+comment lower down about prev[n] potentially being garbage. In
+this case, the result is never used.
+
+Reference:https://github.com/madler/zlib/commit/981ee7570ad98a3cf1ae74d737e2ee619ed79171
+Conflict:NA
+---
+ deflate.c | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/deflate.c b/deflate.c
+index 5410497..8088083 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -209,6 +209,13 @@ local const config configuration_table[10] = {
+  * bit values at the expense of memory usage). We slide even when level == 0 to
+  * keep the hash table consistent if we switch back to level > 0 later.
+  */
++
++#if defined(__has_feature)
++#  if __has_feature(memory_sanitizer)
++     __attribute__((no_sanitize("memory")))
++#  endif
++#endif
++
+ local void slide_hash(s)
+     deflate_state *s;
+ {
+-- 
+2.27.0
+
diff --git a/backport-avoid-uninitialized-and-unused-warnings-in-contrib-minizip.patch b/backport-avoid-uninitialized-and-unused-warnings-in-contrib-minizip.patch
new file mode 100644
index 0000000..c40bb55
--- /dev/null
+++ b/backport-avoid-uninitialized-and-unused-warnings-in-contrib-minizip.patch
@@ -0,0 +1,63 @@
+From 25bbd7f5a6a172b83b59fab7a80c55d1533dd100 Mon Sep 17 00:00:00 2001
+From: Mark Adler <madler@alumni.caltech.edu>
+Date: Thu, 17 Aug 2023 21:40:28 -0700
+Subject: [PATCH] Avoid uninitialized and unused warnings in contrib/minizip.
+
+Reference:https://github.com/madler/zlib/commit/25bbd7f5a6a172b83b59fab7a80c55d1533dd100
+Conflict:NA
+---
+ contrib/minizip/miniunz.c | 10 ++++++++--
+ contrib/minizip/minizip.c |  2 +-
+ 2 files changed, 9 insertions(+), 3 deletions(-)
+
+diff --git a/contrib/minizip/miniunz.c b/contrib/minizip/miniunz.c
+index 3d65401..507820d 100644
+--- a/contrib/minizip/miniunz.c
++++ b/contrib/minizip/miniunz.c
+@@ -113,7 +113,11 @@ void change_file_date(filename,dosdate,tmu_date)
+ 
+   ut.actime=ut.modtime=mktime(&newdate);
+   utime(filename,&ut);
+-#endif
++#else
++  (void)filename;
++  (void)dosdate;
++  (void)tmu_date;
++#endif  
+ #endif
+ }
+ 
+@@ -131,6 +135,8 @@ int mymkdir(dirname)
+     ret = mkdir (dirname,0775);
+ #elif __APPLE__
+     ret = mkdir (dirname,0775);
++#else
++    (void)dirname;	
+ #endif
+     return ret;
+ }
+@@ -248,7 +254,7 @@ int do_list(uf)
+         char filename_inzip[256];
+         unz_file_info64 file_info;
+         uLong ratio=0;
+-        const char *string_method;
++        const char *string_method = "";
+         char charCrypt=' ';
+         err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+         if (err!=UNZ_OK)
+diff --git a/contrib/minizip/minizip.c b/contrib/minizip/minizip.c
+index c5d9cc6..5dde38f 100644
+--- a/contrib/minizip/minizip.c
++++ b/contrib/minizip/minizip.c
+@@ -395,7 +395,7 @@ int main(argc,argv)
+                    ((argv[i][1]>='0') && (argv[i][1]<='9'))) &&
+                   (strlen(argv[i]) == 2)))
+             {
+-                FILE * fin;
++                FILE * fin = NULL;
+                 size_t size_read;
+                 const char* filenameinzip = argv[i];
+                 const char *savefilenameinzip;
+-- 
+2.27.0
+
diff --git a/backport-minizip-Fix-being-unable-to-open-empty-zip-file.patch b/backport-minizip-Fix-being-unable-to-open-empty-zip-file.patch
new file mode 100644
index 0000000..f574468
--- /dev/null
+++ b/backport-minizip-Fix-being-unable-to-open-empty-zip-file.patch
@@ -0,0 +1,160 @@
+From f209ca7be7981dc8fca79428706057e4ebc929ee Mon Sep 17 00:00:00 2001
+From: RedworkDE <10944644+RedworkDE@users.noreply.github.com>
+Date: Wed, 15 Feb 2023 12:25:33 +0100
+Subject: [PATCH] minizip: Fix being unable to open empty zip file
+
+Reference:https://github.com/madler/zlib/commit/f209ca7be7981dc8fca79428706057e4ebc929ee
+Conflict:NA
+---
+ contrib/minizip/unzip.c | 48 ++++++++++++++++++++++-------------------
+ 1 file changed, 26 insertions(+), 22 deletions(-)
+
+diff --git a/contrib/minizip/unzip.c b/contrib/minizip/unzip.c
+index ad2eb3bc9..3adc692f3 100644
+--- a/contrib/minizip/unzip.c
++++ b/contrib/minizip/unzip.c
+@@ -379,6 +379,10 @@ extern int ZEXPORT unzStringFileNameCompare (const char*  fileName1,
+ #define BUFREADCOMMENT (0x400)
+ #endif
+ 
++#ifndef CENTRALDIRINVALID
++#define CENTRALDIRINVALID ((ZPOS64_T)(-1))
++#endif
++
+ /*
+   Locate the Central directory of a zipfile (at the end, just before
+     the global comment)
+@@ -388,10 +392,10 @@ local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_f
+     ZPOS64_T uSizeFile;
+     ZPOS64_T uBackRead;
+     ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+-    ZPOS64_T uPosFound=0;
++    ZPOS64_T uPosFound=CENTRALDIRINVALID;
+ 
+     if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+ 
+     uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+@@ -401,7 +405,7 @@ local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_f
+ 
+     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+     if (buf==NULL)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     uBackRead = 4;
+     while (uBackRead<uMaxBack)
+@@ -431,7 +435,7 @@ local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_f
+                 break;
+             }
+ 
+-        if (uPosFound!=0)
++        if (uPosFound!=CENTRALDIRINVALID)
+             break;
+     }
+     TRYFREE(buf);
+@@ -449,12 +453,12 @@ local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
+     ZPOS64_T uSizeFile;
+     ZPOS64_T uBackRead;
+     ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+-    ZPOS64_T uPosFound=0;
++    ZPOS64_T uPosFound=CENTRALDIRINVALID;
+     uLong uL;
+                 ZPOS64_T relativeOffset;
+ 
+     if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+ 
+     uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+@@ -464,7 +468,7 @@ local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
+ 
+     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+     if (buf==NULL)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     uBackRead = 4;
+     while (uBackRead<uMaxBack)
+@@ -494,47 +498,47 @@ local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
+                 break;
+             }
+ 
+-        if (uPosFound!=0)
++        if (uPosFound!=CENTRALDIRINVALID)
+             break;
+     }
+     TRYFREE(buf);
+-    if (uPosFound == 0)
+-        return 0;
++    if (uPosFound == CENTRALDIRINVALID)
++        return CENTRALDIRINVALID;
+ 
+     /* Zip64 end of central directory locator */
+     if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     /* the signature, already checked */
+     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     /* number of the disk with the start of the zip64 end of  central directory */
+     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+-        return 0;
++        return CENTRALDIRINVALID;
+     if (uL != 0)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     /* relative offset of the zip64 end of central directory record */
+     if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     /* total number of disks */
+     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+-        return 0;
++        return CENTRALDIRINVALID;
+     if (uL != 1)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     /* Goto end of central directory record */
+     if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+      /* the signature */
+     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     if (uL != 0x06064b50)
+-        return 0;
++        return CENTRALDIRINVALID;
+ 
+     return relativeOffset;
+ }
+@@ -587,7 +591,7 @@ local unzFile unzOpenInternal(const void *path,
+         return NULL;
+ 
+     central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
+-    if (central_pos)
++    if (central_pos!=CENTRALDIRINVALID)
+     {
+         uLong uS;
+         ZPOS64_T uL64;
+@@ -649,7 +653,7 @@ local unzFile unzOpenInternal(const void *path,
+     else
+     {
+         central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
+-        if (central_pos==0)
++        if (central_pos==CENTRALDIRINVALID)
+             err=UNZ_ERRNO;
+ 
+         us.isZip64 = 0;
diff --git a/backport-zlib-1.2.5-minizip-fixuncrypt.patch b/backport-zlib-1.2.5-minizip-fixuncrypt.patch
new file mode 100644
index 0000000..d113879
--- /dev/null
+++ b/backport-zlib-1.2.5-minizip-fixuncrypt.patch
@@ -0,0 +1,14 @@
+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"
+ 
diff --git a/sources b/sources
new file mode 100644
index 0000000..1af4c9c
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+7d9fc1d78ae2fa3e84fe98b77d006c63  zlib-1.2.13.tar.xz
diff --git a/zlib-1.2.11-SIMD.patch b/zlib-1.2.11-SIMD.patch
new file mode 100644
index 0000000..df0bf7a
--- /dev/null
+++ b/zlib-1.2.11-SIMD.patch
@@ -0,0 +1,770 @@
+From 91c1e78feec94739cc5da8562b3e2395bfdf6193 Mon Sep 17 00:00:00 2001
+From: hedongbo <hedongbo@huawei.com>
+Date: Sun, 14 Sep 2020 15:36:12 +0800
+Subject: [PATCH] zlib-1.2.11-SIMD.patch
+
+In the sampling of the Hive test program, it is found that inflate occupies a high proportion.
+The zlib is optimized through instruction set optimization, hash replacement, and compilation option optimization. 
+The inflate and deflate processes of the Zlib library provided by the JDK are optimized to shorten the invoking time.
+---
+ CMakeLists.txt |   6 +
+ adler32.c      | 169 +++++++++++++++++++++-
+ deflate.c      |  22 ++-
+ inffast.c      |  62 ++++++++-
+ inffast.h      | 370 +++++++++++++++++++++++++++++++++++++++++++++++++
+ inflate.c      |   7 +
+ 6 files changed, 627 insertions(+), 9 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index b412dc7..40dc533 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -126,6 +126,12 @@ if(NOT MINGW)
+     )
+ endif()
+ 
++if(CMAKE_COMPILER_IS_GNUCC)
++    if(ARM_NEON)
++         add_definitions(-DHASH_ARMV8_CRC32 -march=armv8-a+crc -DUNALIGNED_OK -DADLER32_SIMD_NEON -DINFLATE_CHUNK_SIMD_NEON -O3)
++    endif()
++endif()
++
+ # parse the full version number from zlib.h and include in ZLIB_FULL_VERSION
+ file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents)
+ string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*"
+diff --git a/adler32.c b/adler32.c
+index d0be438..6ced75d 100644
+--- a/adler32.c
++++ b/adler32.c
+@@ -59,7 +59,169 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
+ #  define MOD63(a) a %= BASE
+ #endif
+ 
+-/* ========================================================================= */
++#if defined(ADLER32_SIMD_NEON)
++#include <arm_neon.h>
++/*
++ * Multiply-add bytes by [ 32, 31, 30, ... ] for s2.
++ */
++uint32x4_t ZLIB_INTERNAL mul_add_bytes(
++    uint32x4_t v_s2,
++    uint16x8_t v_column_sum_1,
++    uint16x8_t v_column_sum_2,
++    uint16x8_t v_column_sum_3,
++    uint16x8_t v_column_sum_4)
++{
++    v_s2 = vshlq_n_u32(v_s2, 5);
++
++    v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_1),
++        (uint16x4_t) { 32, 31, 30, 29 });
++    v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_1),
++        (uint16x4_t) { 28, 27, 26, 25 });
++    v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_2),
++        (uint16x4_t) { 24, 23, 22, 21 });
++    v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_2),
++        (uint16x4_t) { 20, 19, 18, 17 });
++    v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_3),
++        (uint16x4_t) { 16, 15, 14, 13 });
++    v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_3),
++        (uint16x4_t) { 12, 11, 10,  9 });
++    v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_column_sum_4),
++        (uint16x4_t) {  8,  7,  6,  5 });
++    v_s2 = vmlal_u16(v_s2, vget_high_u16(v_column_sum_4),
++        (uint16x4_t) {  4,  3,  2,  1 });
++    return v_s2;
++}
++
++/*
++ * Handle leftover data.
++ */
++uLong ZLIB_INTERNAL leftover_handler(uint32_t s1, uint32_t s2, const Bytef *buf, z_size_t len)
++{
++    if (len) {
++        if (len >= 16) {
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++            s2 += (s1 += *buf++);
++
++            len -= 16;
++        }
++
++        while (len--) {
++            s2 += (s1 += *buf++);
++        }
++
++        if (s1 >= BASE)
++            s1 -= BASE;
++        s2 %= BASE;
++    }
++
++    /*
++     * Return the recombined sums.
++     */
++    return s1 | (s2 << 16);
++}
++
++uLong ZLIB_INTERNAL adler32_simd_(uLong adler, const Bytef *buf, z_size_t len)
++{
++    /*
++     * Split Adler-32 into component sums.
++     */
++    uint32_t s1 = adler & 0xffff;
++    uint32_t s2 = adler >> 16;
++    /*
++     * Serially compute s1 & s2, until the data is 16-byte aligned.
++     */
++    if ((uintptr_t)buf & 0xf) {
++        while ((uintptr_t)buf & 0xf) {
++            s2 += (s1 += *buf++);
++            --len;
++        }
++        if (s1 >= BASE)
++            s1 -= BASE;
++        s2 %= BASE;
++    }
++    /*
++     * Process the data in blocks.
++     */
++    const unsigned BLOCK_SIZE = 1 << 5;
++    z_size_t blocks = len / BLOCK_SIZE;
++    len -= blocks * BLOCK_SIZE;
++    while (blocks) {
++        unsigned n = NMAX / BLOCK_SIZE;  /* The NMAX constraint. */
++        if (n > blocks)
++            n = (unsigned) blocks;
++        blocks -= n;
++        /*
++         * Process n blocks of data. At most NMAX data bytes can be
++         * processed before s2 must be reduced modulo BASE.
++         */
++        uint32x4_t v_s2 = (uint32x4_t) { 0, 0, 0, s1 * n };
++        uint32x4_t v_s1 = (uint32x4_t) { 0, 0, 0, 0 };
++
++        uint16x8_t v_column_sum_1 = vdupq_n_u16(0);
++        uint16x8_t v_column_sum_2 = vdupq_n_u16(0);
++        uint16x8_t v_column_sum_3 = vdupq_n_u16(0);
++        uint16x8_t v_column_sum_4 = vdupq_n_u16(0);
++        do {
++            /*
++             * Load 32 input bytes.
++             */
++            const uint8x16_t bytes1 = vld1q_u8((uint8_t*)(buf));
++            const uint8x16_t bytes2 = vld1q_u8((uint8_t*)(buf + 16));
++            /*
++             * Add previous block byte sum to v_s2.
++             */
++            v_s2 = vaddq_u32(v_s2, v_s1);
++            /*
++             * Horizontally add the bytes for s1.
++             */
++            v_s1 = vpadalq_u16(v_s1, vpadalq_u8(vpaddlq_u8(bytes1), bytes2));
++            /*
++             * Vertically add the bytes for s2.
++             */
++            v_column_sum_1 = vaddw_u8(v_column_sum_1, vget_low_u8 (bytes1));
++            v_column_sum_2 = vaddw_u8(v_column_sum_2, vget_high_u8(bytes1));
++            v_column_sum_3 = vaddw_u8(v_column_sum_3, vget_low_u8 (bytes2));
++            v_column_sum_4 = vaddw_u8(v_column_sum_4, vget_high_u8(bytes2));
++            buf += BLOCK_SIZE;
++        } while (--n);
++        v_s2 = mul_add_bytes(v_s2, v_column_sum_1, v_column_sum_2, v_column_sum_3, v_column_sum_4);
++        /*
++         * Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
++         */
++        uint32x2_t sum1 = vpadd_u32(vget_low_u32(v_s1), vget_high_u32(v_s1));
++        uint32x2_t sum2 = vpadd_u32(vget_low_u32(v_s2), vget_high_u32(v_s2));
++        uint32x2_t s1s2 = vpadd_u32(sum1, sum2);
++
++        s1 += vget_lane_u32(s1s2, 0);
++        s2 += vget_lane_u32(s1s2, 1);
++        /*
++         * Reduce.
++         */
++        s1 %= BASE;
++        s2 %= BASE;
++    }
++    return leftover_handler(s1, s2, buf, len);
++
++}
++#endif
++
+ uLong ZEXPORT adler32_z(adler, buf, len)
+     uLong adler;
+     const Bytef *buf;
+@@ -68,6 +230,11 @@ uLong ZEXPORT adler32_z(adler, buf, len)
+     unsigned long sum2;
+     unsigned n;
+ 
++#if defined(ADLER32_SIMD_NEON)
++    if (buf && len >= 64)
++        return adler32_simd_(adler, buf, len);
++#endif
++
+     /* split Adler-32 into component sums */
+     sum2 = (adler >> 16) & 0xffff;
+     adler &= 0xffff;
+diff --git a/deflate.c b/deflate.c
+index f290783..31d1cfe 100644
+--- a/deflate.c
++++ b/deflate.c
+@@ -154,7 +154,16 @@ local const config configuration_table[10] = {
+  *    characters, so that a running hash key can be computed from the previous
+  *    key instead of complete recalculation each time.
+  */
+-#define UPDATE_HASH(s,h,c) (h = (((h) << s->hash_shift) ^ (c)) & s->hash_mask)
++#if defined(HASH_ARMV8_CRC32)
++#include <arm_acle.h>
++#define UPDATE_HASH_CRC_INTERNAL(s, h, c) \
++       (h = __crc32w(0, (c) & 0xFFFFFF) & ((deflate_state *)s)->hash_mask)
++
++#define UPDATE_HASH(s, h, c) \
++    UPDATE_HASH_CRC_INTERNAL(s, h, *(unsigned *)((uintptr_t)(&c) - (MIN_MATCH-1)))
++#else
++#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
++#endif
+ 
+ 
+ /* ===========================================================================
+@@ -1226,14 +1235,15 @@ local unsigned read_buf(strm, buf, size)
+     strm->avail_in  -= len;
+ 
+     zmemcpy(buf, strm->next_in, len);
+-    if (strm->state->wrap == 1) {
+-        strm->adler = adler32(strm->adler, buf, len);
+-    }
+ #ifdef GZIP
+-    else if (strm->state->wrap == 2) {
++    if (strm->state->wrap == 2) { /* use crc32 algo */
+         strm->adler = crc32(strm->adler, buf, len);
+-    }
++    } else 
+ #endif
++    if (strm->state->wrap == 1) {
++        strm->adler = adler32(strm->adler, buf, len);
++    }
++
+     strm->next_in  += len;
+     strm->total_in += len;
+ 
+diff --git a/inffast.c b/inffast.c
+index 1fec7f3..84c5aba 100644
+--- a/inffast.c
++++ b/inffast.c
+@@ -57,6 +57,9 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
+     unsigned char FAR *out;     /* local strm->next_out */
+     unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
+     unsigned char FAR *end;     /* while out < end, enough space available */
++#if defined(INFLATE_CHUNK_SIMD_NEON)
++    unsigned char FAR *limit;   /* safety limit for chunky copies */
++#endif
+ #ifdef INFLATE_STRICT
+     unsigned dmax;              /* maximum distance from zlib header */
+ #endif
+@@ -89,7 +92,12 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
+ #endif
+     wsize = state->wsize;
+     whave = state->whave;
++#if defined(INFLATE_CHUNK_SIMD_NEON)    
++    limit = out + strm->avail_out;
++    wnext = (state->wnext == 0 && whave >= wsize) ? wsize : state->wnext;
++#else
+     wnext = state->wnext;
++#endif
+     window = state->window;
+     hold = state->hold;
+     bits = state->bits;
+@@ -197,6 +205,45 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
+ #endif
+                     }
+                     from = window;
++#if defined(INFLATE_CHUNK_SIMD_NEON)
++                    if (wnext >= op) {          /* contiguous in window */
++                        from += wnext - op;
++                    }
++                    else {                      /* wrap around window */
++                        op -= wnext;
++                        from += wsize - op;
++                        if (op < len) {         /* some from end of window */
++                            len -= op;
++                            out = chunkcopy_safe(out, from, op, limit);
++                            from = window;      /* more from start of window */
++                            op = wnext;
++                            /* This (rare) case can create a situation where
++                               the first chunkcopy below must be checked.
++                             */
++                        }
++                    }
++                    if (op < len) {             /* still need some from output */
++                        out = chunkcopy_safe(out, from, op, limit);
++                        len -= op;
++                        /* When dist is small the amount of data that can be
++                           copied from the window is also small, and progress
++                           towards the dangerous end of the output buffer is
++                           also small.  This means that for trivial memsets and
++                           for chunkunroll_relaxed() a safety check is
++                           unnecessary.  However, these conditions may not be
++                           entered at all, and in that case it's possible that
++                           the main copy is near the end.
++                          */
++                        out = chunkunroll_relaxed(out, &dist, &len);
++                        out = chunkcopy_safe(out, out - dist, len, limit);
++                    }
++                    else {
++                        /* from points to window, so there is no risk of
++                           overlapping pointers requiring memset-like behaviour
++                         */
++                        out = chunkcopy_safe(out, from, len, limit);
++                    }
++#else
+                     if (wnext == 0) {           /* very common case */
+                         from += wsize - op;
+                         if (op < len) {         /* some from window */
+@@ -247,8 +294,18 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
+                         if (len > 1)
+                             *out++ = *from++;
+                     }
++#endif
+                 }
+-                else {
++                else { 
++#if defined(INFLATE_CHUNK_SIMD_NEON)
++                    /* Whole reference is in range of current output.  No
++                       range checks are necessary because we start with room
++                       for at least 258 bytes of output, so unroll and roundoff
++                       operations can write beyond `out+len` so long as they
++                       stay within 258 bytes of `out`.
++                     */
++                    out = chunkcopy_lapped_relaxed(out, dist, len);
++#else
+                     from = out - dist;          /* copy direct from output */
+                     do {                        /* minimum length is three */
+                         *out++ = *from++;
+@@ -260,7 +317,8 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
+                         *out++ = *from++;
+                         if (len > 1)
+                             *out++ = *from++;
+-                    }
++                    }                   
++#endif
+                 }
+             }
+             else if ((op & 64) == 0) {          /* 2nd level distance code */
+diff --git a/inffast.h b/inffast.h
+index e5c1aa4..259882c 100644
+--- a/inffast.h
++++ b/inffast.h
+@@ -8,4 +8,374 @@
+    subject to change. Applications should only use zlib.h.
+  */
+ 
++/*
++ * The chunk-copy code below deals with writing the decoded DEFLATE data to
++ * the output with SIMD methods to increase decode speed. Reading the input
++ * to the DEFLATE decoder with a wide, SIMD method can also increase decode
++ * speed. This option is supported on little endian machines, and reads the
++ * input data in 64-bit (8 byte) chunks.
++ */
++
+ void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
++
++#if defined(INFLATE_CHUNK_SIMD_NEON)
++
++#include <stdint.h>
++#include "zutil.h"
++#include <arm_neon.h>
++
++typedef uint8x16_t z_vec128i_t;
++
++#define Z_STATIC_ASSERT(name, assert) typedef char name[(assert) ? 1 : -1]
++
++#if __STDC_VERSION__ >= 199901L
++#define Z_RESTRICT restrict
++#else
++#define Z_RESTRICT
++#endif
++
++#if defined(__clang__) || defined(__GNUC__) || defined(__llvm__)
++#define Z_BUILTIN_MEMCPY __builtin_memcpy
++#else
++#define Z_BUILTIN_MEMCPY zmemcpy
++#endif
++
++/*
++ * chunk copy type: the z_vec128i_t type size should be exactly 128-bits
++ * and equal to CHUNKCOPY_CHUNK_SIZE.
++ */
++#define CHUNKCOPY_CHUNK_SIZE sizeof(z_vec128i_t)
++
++Z_STATIC_ASSERT(vector_128_bits_wide,
++                CHUNKCOPY_CHUNK_SIZE == sizeof(int8_t) * 16);
++
++/*
++ * Ask the compiler to perform a wide, unaligned load with a machinevst1q_u8
++ * instruction appropriate for the z_vec128i_t type.
++ */
++static inline z_vec128i_t loadchunk(
++    const unsigned char FAR* s)
++{
++    z_vec128i_t v;
++    Z_BUILTIN_MEMCPY(&v, s, sizeof(v));
++    return v;
++}
++
++/*
++ * Ask the compiler to perform a wide, unaligned store with a machine
++ * instruction appropriate for the z_vec128i_t type.
++ */
++static inline void storechunk(
++    unsigned char FAR* d,
++    const z_vec128i_t v)
++{
++    Z_BUILTIN_MEMCPY(d, &v, sizeof(v));
++}
++
++/*
++ * Perform a memcpy-like operation, assuming that length is non-zero and that
++ * it's OK to overwrite at least CHUNKCOPY_CHUNK_SIZE bytes of output even if
++ * the length is shorter than this.
++ *
++ * It also guarantees that it will properly unroll the data if the distance
++ * between `out` and `from` is at least CHUNKCOPY_CHUNK_SIZE, which we rely on
++ * in chunkcopy_relaxed().
++ *
++ * Aside from better memory bus utilisation, this means that short copies
++ * (CHUNKCOPY_CHUNK_SIZE bytes or fewer) will fall straight through the loop
++ * without iteration, which will hopefully make the branch prediction more
++ * reliable.
++ */
++static inline unsigned char FAR* chunkcopy_core(
++    unsigned char FAR* out,
++    const unsigned char FAR* from,
++    unsigned len)
++{
++    const int bump = (--len % CHUNKCOPY_CHUNK_SIZE) + 1;
++    storechunk(out, loadchunk(from));
++    out += bump;
++    from += bump;
++    len /= CHUNKCOPY_CHUNK_SIZE;
++    while (len-- > 0) {
++        storechunk(out, loadchunk(from));
++        out += CHUNKCOPY_CHUNK_SIZE;
++        from += CHUNKCOPY_CHUNK_SIZE;
++    }
++    return out;
++}
++
++/*
++ * Like chunkcopy_core(), but avoid writing beyond of legal output.
++ *
++ * Accepts an additional pointer to the end of safe output.  A generic safe
++ * copy would use (out + len), but it's normally the case that the end of the
++ * output buffer is beyond the end of the current copy, and this can still be
++ * exploited.
++ */
++static inline unsigned char FAR* chunkcopy_core_safe(
++    unsigned char FAR* out,
++    const unsigned char FAR* from,
++    unsigned len,
++    unsigned char FAR* limit)
++{
++    Assert(out + len <= limit, "chunk copy exceeds safety limit");
++    if ((limit - out) < (ptrdiff_t) CHUNKCOPY_CHUNK_SIZE) {
++        const unsigned char FAR* Z_RESTRICT rfrom = from;
++        if (len & 8) {
++            Z_BUILTIN_MEMCPY(out, rfrom, 8);
++            out += 8;
++            rfrom += 8;
++        }
++        if (len & 4) {
++            Z_BUILTIN_MEMCPY(out, rfrom, 4);
++            out += 4;
++            rfrom += 4;
++        }
++        if (len & 2) {
++            Z_BUILTIN_MEMCPY(out, rfrom, 2);
++            out += 2;
++            rfrom += 2;
++        }
++        if (len & 1) {
++            *out++ = *rfrom++;
++        }
++        return out;
++    }
++    return chunkcopy_core(out, from, len);
++}
++
++/*
++ * Perform short copies until distance can be rewritten as being at least
++ * CHUNKCOPY_CHUNK_SIZE.
++ *
++ * Assumes it's OK to overwrite at least the first 2*CHUNKCOPY_CHUNK_SIZE
++ * bytes of output even if the copy is shorter than this.  This assumption
++ * holds within zlib inflate_fast(), which starts every iteration with at
++ * least 258 bytes of output space available (258 being the maximum length
++ * output from a single token; see inffast.c).
++ */
++static inline unsigned char FAR* chunkunroll_relaxed(
++    unsigned char FAR* out,
++    unsigned FAR* dist,
++    unsigned FAR* len)
++{
++    const unsigned char FAR* from = out - *dist;
++    while (*dist < *len && *dist < CHUNKCOPY_CHUNK_SIZE) {
++        storechunk(out, loadchunk(from));
++        out += *dist;
++        *len -= *dist;
++        *dist += *dist;
++    }
++    return out;
++}
++
++/*
++ * v_load64_dup(): load *src as an unaligned 64-bit int and duplicate it in
++ * every 64-bit component of the 128-bit result (64-bit int splat).
++ */
++static inline z_vec128i_t v_load64_dup(const void* src)
++{
++    return vcombine_u8(vld1_u8(src), vld1_u8(src));
++}
++
++/*
++ * v_load32_dup(): load *src as an unaligned 32-bit int and duplicate it in
++ * every 32-bit component of the 128-bit result (32-bit int splat).
++ */
++static inline z_vec128i_t v_load32_dup(const void* src)
++{
++    int32_t i32;
++    Z_BUILTIN_MEMCPY(&i32, src, sizeof(i32));
++    return vreinterpretq_u8_s32(vdupq_n_s32(i32));
++}
++
++/*
++ * v_load16_dup(): load *src as an unaligned 16-bit int and duplicate it in
++ * every 16-bit component of the 128-bit result (16-bit int splat).
++ */
++static inline z_vec128i_t v_load16_dup(const void* src)
++{
++    int16_t i16;
++    Z_BUILTIN_MEMCPY(&i16, src, sizeof(i16));
++    return vreinterpretq_u8_s16(vdupq_n_s16(i16));
++}
++
++/*
++ * v_load8_dup(): load the 8-bit int *src and duplicate it in every 8-bit
++ * component of the 128-bit result (8-bit int splat).
++ */
++static inline z_vec128i_t v_load8_dup(const void* src)
++{
++    return vld1q_dup_u8((const uint8_t*) src);
++}
++
++/*
++ * v_store_128(): store the 128-bit vec in a memory destination (that might
++ * not be 16-byte aligned) void* out.
++ */
++static inline void v_store_128(unsigned char* out, const z_vec128i_t vec)
++{
++    vst1q_u8(out, vec);
++}
++
++/*
++ * Perform an overlapping copy which behaves as a memset() operation, but
++ * supporting periods other than one, and assume that length is non-zero and
++ * that it's OK to overwrite at least CHUNKCOPY_CHUNK_SIZE*3 bytes of output
++ * even if the length is shorter than this.
++ */
++static inline unsigned char FAR* chunkset_store_result(
++    unsigned len,
++    unsigned char FAR* out,
++    z_vec128i_t v)
++{
++    do {
++        v_store_128(out, v);
++        out += sizeof(v);
++        len -= sizeof(v);
++    } while (len > 0);
++    return out;
++}
++
++static inline unsigned char FAR* chunkset_core(unsigned char FAR* out, unsigned period, unsigned len)
++{
++    z_vec128i_t v;
++    const int bump = ((len - 1) % sizeof(v)) + 1;
++    switch (period) {
++        case 1:
++            v = v_load8_dup(out - 1);
++            v_store_128(out, v);
++            out += bump;
++            len -= bump;
++            while (len > 0) {
++                v_store_128(out, v);
++                out += sizeof(v);
++                len -= sizeof(v);
++            }
++            return out;
++        case 2:
++            v = v_load16_dup(out - 2);
++            v_store_128(out, v);
++            out += bump;
++            len -= bump;
++            if (len > 0) {
++                v = v_load16_dup(out - 2);
++                out = chunkset_store_result(len, out, v);
++            }
++            return out;
++        case 4:
++            v = v_load32_dup(out - 4);
++            v_store_128(out, v);
++            out += bump;
++            len -= bump;
++            if (len > 0) {
++                v = v_load32_dup(out - 4);
++                out = chunkset_store_result(len, out, v);
++            }
++            return out;
++        case 8:
++            v = v_load64_dup(out - 8);
++            v_store_128(out, v);
++            out += bump;
++            len -= bump;
++            if (len > 0) {
++                v = v_load64_dup(out - 8);
++                out = chunkset_store_result(len, out, v);
++            }
++            return out;
++    }
++    out = chunkunroll_relaxed(out, &period, &len);
++    return chunkcopy_core(out, out - period, len);
++}
++
++/*
++ * Perform a memcpy-like operation, but assume that length is non-zero and that
++ * it's OK to overwrite at least CHUNKCOPY_CHUNK_SIZE bytes of output even if
++ * the length is shorter than this.
++ *
++ * Unlike chunkcopy_core() above, no guarantee is made regarding the behaviour
++ * of overlapping buffers, regardless of the distance between the pointers.
++ * This is reflected in the `restrict`-qualified pointers, allowing the
++ * compiler to re-order loads and stores.
++ */
++static inline unsigned char FAR* chunkcopy_relaxed(
++    unsigned char FAR* Z_RESTRICT out,
++    const unsigned char FAR* Z_RESTRICT from,
++    unsigned len)
++{
++    return chunkcopy_core(out, from, len);
++}
++
++/*
++ * Like chunkcopy_relaxed(), but avoid writing beyond of legal output.
++ *
++ * Unlike chunkcopy_core_safe() above, no guarantee is made regarding the
++ * behaviour of overlapping buffers, regardless of the distance between the
++ * pointers.  This is reflected in the `restrict`-qualified pointers, allowing
++ * the compiler to re-order loads and stores.
++ *
++ * Accepts an additional pointer to the end of safe output.  A generic safe
++ * copy would use (out + len), but it's normally the case that the end of the
++ * output buffer is beyond the end of the current copy, and this can still be
++ * exploited.
++ */
++static inline unsigned char FAR* chunkcopy_safe(
++    unsigned char FAR* out,
++    const unsigned char FAR* Z_RESTRICT from,
++    unsigned len,
++    unsigned char FAR* limit)
++{
++    Assert(out + len <= limit, "chunk copy exceeds safety limit");
++    return chunkcopy_core_safe(out, from, len, limit);
++}
++
++/*
++ * Perform chunky copy within the same buffer, where the source and destination
++ * may potentially overlap.
++ *
++ * Assumes that len > 0 on entry, and that it's safe to write at least
++ * CHUNKCOPY_CHUNK_SIZE*3 bytes to the output.
++ */
++static inline unsigned char FAR* chunkcopy_lapped_relaxed(
++    unsigned char FAR* out,
++    unsigned dist,
++    unsigned len)
++{
++    if (dist < len && dist < CHUNKCOPY_CHUNK_SIZE) {
++        return chunkset_core(out, dist, len);
++    }
++    return chunkcopy_core(out, out - dist, len);
++}
++
++/*
++ * Behave like chunkcopy_lapped_relaxed(), but avoid writing beyond of legal
++ * output.
++ *
++ * Accepts an additional pointer to the end of safe output.  A generic safe
++ * copy would use (out + len), but it's normally the case that the end of the
++ * output buffer is beyond the end of the current copy, and this can still be
++ * exploited.
++ */
++static inline unsigned char FAR* chunkcopy_lapped_safe(
++    unsigned char FAR* out,
++    unsigned dist,
++    unsigned len,
++    unsigned char FAR* limit)
++{
++    Assert(out + len <= limit, "chunk copy exceeds safety limit");
++    if ((limit - out) < (ptrdiff_t) (3 * CHUNKCOPY_CHUNK_SIZE)) {
++        while (len-- > 0) {
++            *out = *(out - dist);
++            out++;
++        }
++        return out;
++    }
++    return chunkcopy_lapped_relaxed(out, dist, len);
++}
++
++
++#undef Z_STATIC_ASSERT
++#undef Z_RESTRICT
++#undef Z_BUILTIN_MEMCPY
++
++#endif //defined(INFLATE_CHUNK_SIMD_NEON)
+diff --git a/inflate.c b/inflate.c
+index 8acbef4..4e695b1 100644
+--- a/inflate.c
++++ b/inflate.c
+@@ -408,9 +408,16 @@ unsigned copy;
+ 
+     /* if it hasn't been done already, allocate space for the window */
+     if (state->window == Z_NULL) {
++#if defined(INFLATE_CHUNK_SIMD_NEON)
++        unsigned wsize = 1U << state->wbits;
++        state->window = (unsigned char FAR *)
++                        ZALLOC(strm, CHUNKCOPY_CHUNK_SIZE + wsize,
++                               sizeof(unsigned char));
++#else
+         state->window = (unsigned char FAR *)
+                         ZALLOC(strm, 1U << state->wbits,
+                                sizeof(unsigned char));
++#endif
+         if (state->window == Z_NULL) return 1;
+     }
+ 
+-- 
+2.33.0
+
diff --git a/zlib-Optimize-CRC32.patch b/zlib-Optimize-CRC32.patch
new file mode 100644
index 0000000..16d66b4
--- /dev/null
+++ b/zlib-Optimize-CRC32.patch
@@ -0,0 +1,94 @@
+From 8935175266e343ac1d52106e2e790810b54f26c1 Mon Sep 17 00:00:00 2001
+From: liqiang64 <liqiang64@huawei.com>
+Date: Tue, 3 Dec 2019 03:22:00 +0000
+Subject: [PATCH] zlib: Optimize CRC32
+
+This patch uses the NEON instruction set to optimize the CRC32
+algorithm.
+
+On the ARM architecture, we can optimize the efficiency of
+crc32 through the interface provided by the neon instruction
+set.
+Modify by Li Qiang.
+---
+ crc32.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 50 insertions(+)
+
+diff --git a/crc32.c b/crc32.c
+index f8357b0..5c53068 100644
+--- a/crc32.c
++++ b/crc32.c
+@@ -28,6 +28,9 @@
+ #endif /* MAKECRCH */
+ 
+ #include "zutil.h"      /* for Z_U4, Z_U8, z_crc_t, and FAR definitions */
++#ifdef __aarch64__
++#include "arm_acle.h"
++#endif
+ 
+  /*
+   A CRC of a message is computed on N braids of words in the message, where
+@@ -600,6 +603,49 @@ const z_crc_t FAR * ZEXPORT get_crc_table()
+     return (const z_crc_t FAR *)crc_table;
+ }
+
++#ifdef __aarch64__
++ulg crc32_neon(crc, buf, len)
++    unsigned long crc;
++    const unsigned char FAR *buf;
++    z_size_t len;
++{
++    register uint32_t crc_result = 0xFFFFFFFFU;
++    register const uint8_t  *buf1;
++    register const uint16_t *buf2;
++    register const uint32_t *buf4;
++    register const uint64_t *buf8;
++    int64_t length = (int64_t)len;
++    buf8 = (const  uint64_t *)(const void *)buf;
++
++    if (buf == NULL) {
++        crc_result = 0xffffffffL;
++    } else {
++        crc_result = crc^0xffffffffUL;
++
++        while((length -= sizeof(uint64_t)) >= 0) {
++            crc_result = __crc32d((crc_result), *buf8++);
++        }
++
++        buf4 = (const uint32_t *)(const void *)buf8;
++        if (length & sizeof(uint32_t)) {
++            crc_result = __crc32w((crc_result), *buf4++);
++        }
++
++        buf2 = (const uint16_t *)(const void *)buf4;
++        if(length & sizeof(uint16_t)) {
++            crc_result = __crc32h((crc_result), *buf2++);
++        }
++
++        buf1 = (const uint8_t *)(const void *)buf2;
++        if (length & sizeof(uint8_t)) {
++            crc_result = __crc32b((crc_result), *buf1);
++        }
++    }
++
++    return (crc_result ^ 0xffffffffL);
++}
++#endif
++
+ /* =========================================================================
+  * Use ARM machine instructions if available. This will compute the CRC about
+  * ten times faster than the braided calculation. This code does not check for
+@@ -750,6 +794,10 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
+     const unsigned char FAR *buf;
+     z_size_t len;
+ {
++    #ifdef __aarch64__
++    return crc32_neon(crc, buf, len);
++    #endif
++
+     /* Return initial CRC, if requested. */
+     if (buf == Z_NULL) return 0;
+ 
+-- 
+2.27.0
+
diff --git a/zlib.spec b/zlib.spec
new file mode 100644
index 0000000..dfc333a
--- /dev/null
+++ b/zlib.spec
@@ -0,0 +1,180 @@
+Name:             zlib
+Version:          1.2.13
+Release:          5
+Summary:          A lossless data-compression library
+License:          zlib and Boost
+URL:              http://www.zlib.net
+Source0:          http://www.zlib.net/zlib-%{version}.tar.xz
+
+# Patch0 get from fedora
+Patch6000:	backport-zlib-1.2.5-minizip-fixuncrypt.patch
+Patch6001:	backport-CVE-2023-45853.patch
+Patch6002:	backport-Fix-crash-when-gzsetparams-attempted-for-transparent-write.patch
+Patch6003:	backport-Remove-use-of-OF-from-contrib-untgz-and-render-it-compilable.patch
+Patch6004:	backport-minizip-Fix-being-unable-to-open-empty-zip-file.patch
+Patch6005:	backport-Fix-reading-disk-number-start-on-zip64-files-in-minizip.patch
+Patch6006:	backport-Fix-logic-error-in-minizip-argument-processing.patch
+Patch6007:	backport-Fix-bug-when-gzungetc-is-used-immediately-after-gzopen.patch
+Patch6008:	backport-Suppress-MSAN-detections-in-deflate-slide_hash.patch
+Patch6009:	backport-Fix-bug-when-using-gzflush-with-a-very-small-buffer.patch
+Patch6010:	backport-avoid-uninitialized-and-unused-warnings-in-contrib-minizip.patch
+Patch6011:	backport-Add-bounds-checking-to-ERR_MSG-macro-used-by-zError.patch
+Patch6012:	backport-Fix-bug-in-inflateSync-for-data-held-in-bit-buffer.patch
+Patch6013:	backport-Fix-decision-on-the-emission-of-Zip64-end-records-in.patch
+Patch6014:	backport-Neutralize-zip-file-traversal-attacks-in-miniunz.patch
+Patch6015:	backport-Fix-a-bug-in-ZLIB_DEBUG-compiles-in-check_match.patch
+Patch6016:	backport-CVE-2026-27171.patch
+
+Patch9000:	zlib-Optimize-CRC32.patch
+Patch9001:	zlib-1.2.11-SIMD.patch
+
+BuildRequires:    automake, autoconf, libtool
+
+%description
+Zlib is a free, general-purpose, not covered by any patents, lossless data-compression
+library for use on virtually any computer hardware and operating system. The zlib data
+format is itself portable across platforms.
+
+%package          devel
+Summary:          Header files and libraries for Zlib development
+Requires:         %{name} = %{version}-%{release}
+
+Provides:         zlib-static
+Obsoletes:        zlib-static
+
+%description      devel
+This package contains the static library, the header files, the tests user case and other
+development content.
+
+%package          help
+Summary:          Help documentation related to zlib
+BuildArch:        noarch
+
+%description      help
+This package includes help documentation and manuals related to zlib.
+
+%package          -n minizip
+Summary:          Encapsulates the operations related to zip files
+Requires:         %{name} = %{version}-%{release}
+
+%description      -n minizip
+Minizip is the upper library of zlib, which encapsulates the operations related to zip files.
+
+%package          -n minizip-devel
+Summary:          The development-related content related to minizip
+Requires:         minizip = %{version}-%{release}
+Requires:         %{name}-devel = %{version}-%{release}
+
+%description      -n minizip-devel
+This package contains the development-related content related to minizip.
+
+%prep
+%setup -n %{name}-%{version}
+%autosetup -b 0 -n %{name}-%{version} -p1
+
+%build
+export CFLAGS="$RPM_OPT_FLAGS"
+%ifarch aarch64
+CFLAGS+=" -march=armv8-a+crc"
+%endif
+
+./configure --libdir=%{_libdir} --includedir=%{_includedir} --prefix=%{_prefix}
+%make_build LDFLAGS="$LDFLAGS -Wl,-z,relro -Wl,-z,now"
+
+cd contrib/minizip
+autoreconf --install
+%configure --enable-static=no
+%make_build
+
+%install
+%make_install
+
+%make_install -C contrib/minizip
+rm -f $RPM_BUILD_ROOT%_includedir/minizip/crypt.h
+
+find $RPM_BUILD_ROOT -name '*.la' | xargs rm -f 
+
+%check
+make test
+
+%files
+%defattr(-,root,root)
+%doc README ChangeLog FAQ
+%{_libdir}/libz.so.*
+
+%files devel
+%doc doc/algorithm.txt test/example.c
+%{_includedir}/zlib.h
+%{_includedir}/zconf.h
+
+%{_libdir}/libz.so
+%{_libdir}/pkgconfig/zlib.pc
+%{_libdir}/libz.a
+
+%files help
+%{_mandir}/man3/zlib.3*
+
+%files -n minizip
+%doc contrib/minizip/MiniZip64_info.txt contrib/minizip/MiniZip64_Changes.txt
+%{_libdir}/libminizip.so.*
+
+
+%files -n minizip-devel
+%dir %{_includedir}/minizip
+%{_includedir}/minizip/*.h
+
+%{_libdir}/libminizip.so
+%{_libdir}/pkgconfig/minizip.pc
+
+%changelog
+* Wed Feb 25 2026 liweigang <liweiganga@gmail.com> - 1.2.13-5
+- fix CVE-2026-27171
+
+* Tue Aug 13 2024 yanglongkang <yanglongkang@h-partners.com> - 1.2.13-4
+- backport patches from upstream
+
+* Tue Jun 18 2024 zhoupengcheng <zhoupengcheng11@huawei.com> - 1.2.13-3
+- delete redundant patch
+
+* Tue May 14 2024 zhoupengcheng <zhoupengcheng11@huawei.com> - 1.2.13-2
+- downgrade to zlib-1.2.13
+
+* Wed Feb 21 2024 liweigang <izmirvii@gmail.com> - 1.3.1-1
+- update to version zlib-1.3.1
+
+* Tue Oct 17 2023 liningjie <liningjie@xfusion.com> - 1.2.13-2
+- DESC:Fix CVE-2023-45853
+
+* Thu Dec 29 2022 zhoupengcheng <zhoupengcheng11@huawei.com> - 1.2.13-1
+- update to zlib-1.2.13
+- remove openEuler uncompiled  patch : 0005-Accelerate-Adler32-using-arm64-SVE-instructions.patch 
+
+* Mon Dec 26 2022 zhoupengcheng <zhoupengcheng11@huawei.com> - 1.2.11-24
+- DESC:remove unapplied patches
+
+* Tue Aug 23 2022 shixuantong <shixuantong@h-partners.com> - 1.2.11-23
+- Fix missing patches due to different arch
+
+* Fri Aug 12 2022 dongyuzhen <dongyuzhen@h-partners.com> - 1.2.11-22
+- fix CVE-2022-37434
+
+* Mon Apr 18 2022 tianwei <tianwei12@h-partners.com> - 1.2.11-21
+- modify patch info for CVE-2018-25032
+
+* Wed Apr 13 2022 tianwei <tianwei12@h-partners.com> - 1.2.11-20
+- fix CVE-2018-25032
+
+* Thu Sep 2 2021 liqiang <liqiang64@huawei.com> - 1.2.11-19
+- Optimize Adler32 by SVE instructions.
+
+* Mon Sep 14 2020 noah <hedongbo@huawei.com> - 1.2.11-18
+- add zlib-1.2.11-SIMD.patch
+
+* Sat Dec 21 2019 openEuler Buildteam <buildteam@openeuler.org> - 1.2.11-17
+- Fix undefined buffer detected by oss-fuzz
+
+* Tue Dec 3 2019 liqiang <liqiang64@huawei.com> - 1.2.11-16
+- Optimize CRC32 by NEON
+
+* Thu Sep 5 2019 dongjian <dongjian13@huawei.com> - 1.2.11-15
+- Rebuild the zlib and fix description