diff --git a/pkgs/by-name/zs/zsync/c23.patch b/pkgs/by-name/zs/zsync/c23.patch
new file mode 100644
index 000000000000..717a7f475c75
--- /dev/null
+++ b/pkgs/by-name/zs/zsync/c23.patch
@@ -0,0 +1,855 @@
+diff --git a/libzsync/zsync.c b/libzsync/zsync.c
+index bf3a77c..0697857 100644
+--- a/libzsync/zsync.c
++++ b/libzsync/zsync.c
+@@ -41,6 +41,8 @@
+ #include <unistd.h>
+ #include <string.h>
+ #include <ctype.h>
++
++#define _DARWIN_C_SOURCE
+ #include <time.h>
+ 
+ #include <arpa/inet.h>
+diff --git a/zlib/adler32.c b/zlib/adler32.c
+index 624a169..19a7012 100644
+--- a/zlib/adler32.c
++++ b/zlib/adler32.c
+@@ -44,10 +44,7 @@
+ #endif
+ 
+ /* ========================================================================= */
+-uLong ZEXPORT adler32(adler, buf, len)
+-    uLong adler;
+-    const Bytef *buf;
+-    uInt len;
++uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len)
+ {
+     unsigned long s1 = adler & 0xffff;
+     unsigned long s2 = (adler >> 16) & 0xffff;
+diff --git a/zlib/compress.c b/zlib/compress.c
+index 24ef029..232691b 100644
+--- a/zlib/compress.c
++++ b/zlib/compress.c
+@@ -19,12 +19,7 @@
+    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+    Z_STREAM_ERROR if the level parameter is invalid.
+ */
+-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+-    Bytef *dest;
+-    uLongf *destLen;
+-    const Bytef *source;
+-    uLong sourceLen;
+-    int level;
++int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)
+ {
+     z_stream stream;
+     int err;
+@@ -59,11 +54,7 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+ 
+ /* ===========================================================================
+  */
+-int ZEXPORT compress (dest, destLen, source, sourceLen)
+-    Bytef *dest;
+-    uLongf *destLen;
+-    const Bytef *source;
+-    uLong sourceLen;
++int ZEXPORT compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
+ {
+     return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+ }
+@@ -72,8 +63,7 @@ int ZEXPORT compress (dest, destLen, source, sourceLen)
+      If the default memLevel or windowBits for deflateInit() is changed, then
+    this function needs to be updated.
+  */
+-uLong ZEXPORT compressBound (sourceLen)
+-    uLong sourceLen;
++uLong ZEXPORT compressBound (uLong sourceLen)
+ {
+     return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
+ }
+diff --git a/zlib/crc32.c b/zlib/crc32.c
+index 689b288..b4dc0b3 100644
+--- a/zlib/crc32.c
++++ b/zlib/crc32.c
+@@ -155,9 +155,7 @@ local void make_crc_table()
+ }
+ 
+ #ifdef MAKECRCH
+-local void write_table(out, table)
+-    FILE *out;
+-    const unsigned long FAR *table;
++local void write_table(FILE *out, const unsigned long FAR *table)
+ {
+     int n;
+ 
+@@ -190,10 +188,7 @@ const unsigned long FAR * ZEXPORT get_crc_table()
+ #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+ 
+ /* ========================================================================= */
+-unsigned long ZEXPORT crc32(crc, buf, len)
+-    unsigned long crc;
+-    const unsigned char FAR *buf;
+-    unsigned len;
++unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, unsigned len)
+ {
+     if (buf == Z_NULL) return 0UL;
+ 
+@@ -233,10 +228,7 @@ unsigned long ZEXPORT crc32(crc, buf, len)
+ #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+ 
+ /* ========================================================================= */
+-local unsigned long crc32_little(crc, buf, len)
+-    unsigned long crc;
+-    const unsigned char FAR *buf;
+-    unsigned len;
++local unsigned long crc32_little(unsigned long crc, const unsigned char FAR *buf, unsigned len)
+ {
+     register u4 c;
+     register const u4 FAR *buf4;
+@@ -273,10 +265,7 @@ local unsigned long crc32_little(crc, buf, len)
+ #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+ 
+ /* ========================================================================= */
+-local unsigned long crc32_big(crc, buf, len)
+-    unsigned long crc;
+-    const unsigned char FAR *buf;
+-    unsigned len;
++local unsigned long crc32_big(unsigned long crc, const unsigned char FAR *buf, unsigned len)
+ {
+     register u4 c;
+     register const u4 FAR *buf4;
+diff --git a/zlib/deflate.c b/zlib/deflate.c
+index 19a8f27..58b2f01 100644
+--- a/zlib/deflate.c
++++ b/zlib/deflate.c
+@@ -201,11 +201,7 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
+     zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflateInit_(strm, level, version, stream_size)
+-    z_streamp strm;
+-    int level;
+-    const char *version;
+-    int stream_size;
++int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, int stream_size)
+ {
+     return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+                          Z_DEFAULT_STRATEGY, version, stream_size);
+@@ -213,16 +209,8 @@ int ZEXPORT deflateInit_(strm, level, version, stream_size)
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+-                  version, stream_size)
+-    z_streamp strm;
+-    int  level;
+-    int  method;
+-    int  windowBits;
+-    int  memLevel;
+-    int  strategy;
+-    const char *version;
+-    int stream_size;
++int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy,
++                  const char *version, int stream_size)
+ {
+     deflate_state *s;
+     int wrap = 1;
+@@ -311,10 +299,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+-    z_streamp strm;
+-    const Bytef *dictionary;
+-    uInt  dictLength;
++int ZEXPORT deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength)
+ {
+     deflate_state *s;
+     uInt length = dictLength;
+@@ -355,8 +340,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflateReset (strm)
+-    z_streamp strm;
++int ZEXPORT deflateReset (z_streamp strm)
+ {
+     deflate_state *s;
+ 
+@@ -391,10 +375,7 @@ int ZEXPORT deflateReset (strm)
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflatePrime (strm, bits, value)
+-    z_streamp strm;
+-    int bits;
+-    int value;
++int ZEXPORT deflatePrime (z_streamp strm, int bits, int value)
+ {
+     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+     strm->state->bi_valid = bits;
+@@ -403,10 +384,7 @@ int ZEXPORT deflatePrime (strm, bits, value)
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflateParams(strm, level, strategy)
+-    z_streamp strm;
+-    int level;
+-    int strategy;
++int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
+ {
+     deflate_state *s;
+     compress_func func;
+@@ -457,9 +435,7 @@ int ZEXPORT deflateParams(strm, level, strategy)
+  * But even the conservative upper bound of about 14% expansion does not
+  * seem onerous for output buffer allocation.
+  */
+-uLong ZEXPORT deflateBound(strm, sourceLen)
+-    z_streamp strm;
+-    uLong sourceLen;
++uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen)
+ {
+     deflate_state *s;
+     uLong destLen;
+@@ -486,9 +462,7 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
+  * IN assertion: the stream state is correct and there is enough room in
+  * pending_buf.
+  */
+-local void putShortMSB (s, b)
+-    deflate_state *s;
+-    uInt b;
++local void putShortMSB (deflate_state *s, uInt b)
+ {
+     put_byte(s, (Byte)(b >> 8));
+     put_byte(s, (Byte)(b & 0xff));
+@@ -500,8 +474,7 @@ local void putShortMSB (s, b)
+  * to avoid allocating a large strm->next_out buffer and copying into it.
+  * (See also read_buf()).
+  */
+-local void flush_pending(strm)
+-    z_streamp strm;
++local void flush_pending(z_streamp strm)
+ {
+     unsigned len = strm->state->pending;
+ 
+@@ -520,9 +493,7 @@ local void flush_pending(strm)
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflate (strm, flush)
+-    z_streamp strm;
+-    int flush;
++int ZEXPORT deflate (z_streamp strm, int flush)
+ {
+     int old_flush; /* value of flush param for previous deflate call */
+     deflate_state *s;
+@@ -696,8 +667,7 @@ int ZEXPORT deflate (strm, flush)
+ }
+ 
+ /* ========================================================================= */
+-int ZEXPORT deflateEnd (strm)
+-    z_streamp strm;
++int ZEXPORT deflateEnd (z_streamp strm)
+ {
+     int status;
+ 
+@@ -726,9 +696,7 @@ int ZEXPORT deflateEnd (strm)
+  * To simplify the source, this is not supported for 16-bit MSDOS (which
+  * doesn't have enough memory anyway to duplicate compression states).
+  */
+-int ZEXPORT deflateCopy (dest, source)
+-    z_streamp dest;
+-    z_streamp source;
++int ZEXPORT deflateCopy (z_streamp dest, z_streamp source)
+ {
+ #ifdef MAXSEG_64K
+     return Z_STREAM_ERROR;
+@@ -788,10 +756,7 @@ int ZEXPORT deflateCopy (dest, source)
+  * allocating a large strm->next_in buffer and copying from it.
+  * (See also flush_pending()).
+  */
+-local int read_buf(strm, buf, size)
+-    z_streamp strm;
+-    Bytef *buf;
+-    unsigned size;
++local int read_buf(z_streamp strm, Bytef *buf, unsigned size)
+ {
+     unsigned len = strm->avail_in;
+ 
+@@ -818,8 +783,7 @@ local int read_buf(strm, buf, size)
+ /* ===========================================================================
+  * Initialize the "longest match" routines for a new zlib stream
+  */
+-local void lm_init (s)
+-    deflate_state *s;
++local void lm_init (deflate_state *s)
+ {
+     s->window_size = (ulg)2L*s->w_size;
+ 
+@@ -857,9 +821,7 @@ 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)
+-    deflate_state *s;
+-    IPos cur_match;                             /* current match */
++local uInt longest_match(deflate_state *s, IPos cur_match /* current match */)
+ {
+     unsigned chain_length = s->max_chain_length;/* max hash chain length */
+     register Bytef *scan = s->window + s->strstart; /* current string */
+@@ -1000,9 +962,7 @@ local uInt longest_match(s, cur_match)
+ /* ---------------------------------------------------------------------------
+  * Optimized version for level == 1 or strategy == Z_RLE only
+  */
+-local uInt longest_match_fast(s, cur_match)
+-    deflate_state *s;
+-    IPos cur_match;                             /* current match */
++local uInt longest_match_fast(deflate_state *s, IPos cur_match /* current match */)
+ {
+     register Bytef *scan = s->window + s->strstart; /* current string */
+     register Bytef *match;                       /* matched string */
+@@ -1057,10 +1017,7 @@ local uInt longest_match_fast(s, cur_match)
+ /* ===========================================================================
+  * Check that the match at match_start is indeed a match.
+  */
+-local void check_match(s, start, match, length)
+-    deflate_state *s;
+-    IPos start, match;
+-    int length;
++local void check_match(deflate_state *s, IPos start, IPos match, int length)
+ {
+     /* check that the match is indeed a match */
+     if (zmemcmp(s->window + match,
+@@ -1091,8 +1048,7 @@ local void check_match(s, start, match, length)
+  *    performed for at least two bytes (required for the zip translate_eol
+  *    option -- not supported here).
+  */
+-local void fill_window(s)
+-    deflate_state *s;
++local void fill_window(deflate_state *s)
+ {
+     register unsigned n, m;
+     register Posf *p;
+@@ -1214,9 +1170,7 @@ local void fill_window(s)
+  * NOTE: this function should be optimized to avoid extra copying from
+  * window to pending_buf.
+  */
+-local block_state deflate_stored(s, flush)
+-    deflate_state *s;
+-    int flush;
++local block_state deflate_stored(deflate_state *s, int flush)
+ {
+     /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
+      * to pending_buf_size, and each stored block has a 5 byte header:
+@@ -1272,9 +1226,7 @@ local block_state deflate_stored(s, flush)
+  * new strings in the dictionary only for unmatched strings or for short
+  * matches. It is used only for the fast compression options.
+  */
+-local block_state deflate_fast(s, flush)
+-    deflate_state *s;
+-    int flush;
++local block_state deflate_fast(deflate_state *s, int flush)
+ {
+     IPos hash_head = NIL; /* head of the hash chain */
+     int bflush;           /* set if current block must be flushed */
+@@ -1378,9 +1330,7 @@ local block_state deflate_fast(s, flush)
+  * evaluation for matches: a match is finally adopted only if there is
+  * no better match at the next window position.
+  */
+-local block_state deflate_slow(s, flush)
+-    deflate_state *s;
+-    int flush;
++local block_state deflate_slow(deflate_state *s, int flush)
+ {
+     IPos hash_head = NIL;    /* head of hash chain */
+     int bflush;              /* set if current block must be flushed */
+diff --git a/zlib/inflate.c b/zlib/inflate.c
+index fdc3f05..03ceaa3 100644
+--- a/zlib/inflate.c
++++ b/zlib/inflate.c
+@@ -104,8 +104,7 @@ local void fixedtables OF((struct inflate_state FAR *state));
+ local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
+                               unsigned len));
+ 
+-int ZEXPORT inflateReset(strm)
+-z_streamp strm;
++int ZEXPORT inflateReset(z_streamp strm)
+ {
+     struct inflate_state FAR *state;
+ 
+@@ -125,11 +124,7 @@ z_streamp strm;
+     return Z_OK;
+ }
+ 
+-int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+-z_streamp strm;
+-int windowBits;
+-const char *version;
+-int stream_size;
++int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char *version, int stream_size)
+ {
+     struct inflate_state FAR *state;
+ 
+@@ -168,10 +163,7 @@ int stream_size;
+     return inflateReset(strm);
+ }
+ 
+-int ZEXPORT inflateInit_(strm, version, stream_size)
+-z_streamp strm;
+-const char *version;
+-int stream_size;
++int ZEXPORT inflateInit_(z_streamp strm, const char *version, int stream_size)
+ {
+     return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+ }
+@@ -186,8 +178,7 @@ int stream_size;
+    used for threaded applications, since the rewriting of the tables and virgin
+    may not be thread-safe.
+  */
+-local void fixedtables(state)
+-struct inflate_state FAR *state;
++local void fixedtables(struct inflate_state FAR *state)
+ {
+ #ifdef BUILDFIXED
+     static int virgin = 1;
+@@ -304,9 +295,7 @@ void makefixed()
+    output will fall in the output data, making match copies simpler and faster.
+    The advantage may be dependent on the size of the processor's data caches.
+  */
+-int updatewindow(strm, out)
+-z_streamp strm;
+-unsigned out;
++int updatewindow(z_streamp strm, unsigned out)
+ {
+     struct inflate_state FAR *state;
+     unsigned copy, dist;
+@@ -535,9 +524,7 @@ unsigned out;
+    will return Z_BUF_ERROR if it has not reached the end of the stream.
+  */
+ 
+-int ZEXPORT inflate(strm, flush)
+-z_streamp strm;
+-int flush;
++int ZEXPORT inflate(z_streamp strm, int flush)
+ {
+     struct inflate_state FAR *state;
+     unsigned char FAR *next;    /* next input */
+@@ -1086,8 +1073,7 @@ int flush;
+     return ret;
+ }
+ 
+-int ZEXPORT inflateEnd(strm)
+-z_streamp strm;
++int ZEXPORT inflateEnd(z_streamp strm)
+ {
+     struct inflate_state FAR *state;
+     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+@@ -1100,10 +1086,7 @@ z_streamp strm;
+     return Z_OK;
+ }
+ 
+-int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+-z_streamp strm;
+-const Bytef *dictionary;
+-uInt dictLength;
++int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
+ {
+     struct inflate_state FAR *state;
+     unsigned long id;
+@@ -1149,10 +1132,7 @@ uInt dictLength;
+    called again with more data and the *have state.  *have is initialized to
+    zero for the first call.
+  */
+-local unsigned syncsearch(have, buf, len)
+-unsigned FAR *have;
+-unsigned char FAR *buf;
+-unsigned len;
++local unsigned syncsearch(unsigned FAR *have, unsigned char FAR *buf, unsigned len)
+ {
+     unsigned got;
+     unsigned next;
+@@ -1172,8 +1152,7 @@ unsigned len;
+     return next;
+ }
+ 
+-int ZEXPORT inflateSync(strm)
+-z_streamp strm;
++int ZEXPORT inflateSync(z_streamp strm)
+ {
+     unsigned len;               /* number of bytes to look at or looked at */
+     unsigned long in, out;      /* temporary to save total_in and total_out */
+@@ -1223,8 +1202,7 @@ z_streamp strm;
+    block. When decompressing, PPP checks that at the end of input packet,
+    inflate is waiting for these length bytes.
+  */
+-int ZEXPORT inflateSyncPoint(strm)
+-z_streamp strm;
++int ZEXPORT inflateSyncPoint(z_streamp strm)
+ {
+     struct inflate_state FAR *state;
+ 
+@@ -1233,9 +1211,7 @@ z_streamp strm;
+     return state->mode == STORED && state->bits == 0;
+ }
+ 
+-int ZEXPORT inflateCopy(dest, source)
+-z_streamp dest;
+-z_streamp source;
++int ZEXPORT inflateCopy(z_streamp dest, z_streamp source)
+ {
+     struct inflate_state FAR *state;
+     struct inflate_state FAR *copy;
+@@ -1278,11 +1254,7 @@ z_streamp source;
+  * Extra stuff I need to move around in gzip files
+  */
+ 
+-void inflate_advance(strm,zoffset,b,s)
+-     z_streamp strm;
+-     int zoffset;
+-     int b;
+-     int s;
++void inflate_advance(z_streamp strm, int zoffset, int b, int s)
+ {
+   struct inflate_state FAR* state = (struct inflate_state FAR *)strm->state;
+ 
+@@ -1308,8 +1280,7 @@ void inflate_advance(strm,zoffset,b,s)
+   }
+ }
+ 
+-int ZEXPORT inflateSafePoint(strm)
+-z_streamp strm;
++int ZEXPORT inflateSafePoint(z_streamp strm)
+ {
+     struct inflate_state FAR *state;
+ 
+diff --git a/zlib/inftrees.c b/zlib/inftrees.c
+index c767d75..9176d16 100644
+--- a/zlib/inftrees.c
++++ b/zlib/inftrees.c
+@@ -29,13 +29,7 @@ const char inflate_copyright[] =
+    table index bits.  It will differ if the request is greater than the
+    longest code or if it is less than the shortest code.
+  */
+-int inflate_table(type, lens, codes, table, bits, work)
+-codetype type;
+-unsigned short FAR *lens;
+-unsigned codes;
+-code FAR * FAR *table;
+-unsigned FAR *bits;
+-unsigned short FAR *work;
++int inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR * FAR *table, unsigned FAR *bits, unsigned short FAR *work)
+ {
+     unsigned len;               /* a code's length in bits */
+     unsigned sym;               /* index of code symbols */
+diff --git a/zlib/trees.c b/zlib/trees.c
+index bb09554..8f837c9 100644
+--- a/zlib/trees.c
++++ b/zlib/trees.c
+@@ -379,8 +379,7 @@ void gen_trees_header()
+ /* ===========================================================================
+  * Initialize the tree data structures for a new zlib stream.
+  */
+-void _tr_init(s)
+-    deflate_state *s;
++void _tr_init(deflate_state *s)
+ {
+     tr_static_init();
+ 
+@@ -408,8 +407,7 @@ void _tr_init(s)
+ /* ===========================================================================
+  * Initialize a new block.
+  */
+-local void init_block(s)
+-    deflate_state *s;
++local void init_block(deflate_state *s)
+ {
+     int n; /* iterates over tree elements */
+ 
+@@ -452,10 +450,7 @@ local void init_block(s)
+  * when the heap property is re-established (each father smaller than its
+  * two sons).
+  */
+-local void pqdownheap(s, tree, k)
+-    deflate_state *s;
+-    ct_data *tree;  /* the tree to restore */
+-    int k;               /* node to move down */
++local void pqdownheap(deflate_state *s, ct_data *tree /* the tree to restore */, int k /* node to move down */)
+ {
+     int v = s->heap[k];
+     int j = k << 1;  /* left son of k */
+@@ -487,9 +482,7 @@ local void pqdownheap(s, tree, k)
+  *     The length opt_len is updated; static_len is also updated if stree is
+  *     not null.
+  */
+-local void gen_bitlen(s, desc)
+-    deflate_state *s;
+-    tree_desc *desc;    /* the tree descriptor */
++local void gen_bitlen(deflate_state *s, tree_desc *desc /* the tree descriptor */)
+ {
+     ct_data *tree        = desc->dyn_tree;
+     int max_code         = desc->max_code;
+@@ -574,10 +567,7 @@ local void gen_bitlen(s, desc)
+  * OUT assertion: the field code is set for all tree elements of non
+  *     zero code length.
+  */
+-local void gen_codes (tree, max_code, bl_count)
+-    ct_data *tree;             /* the tree to decorate */
+-    int max_code;              /* largest code with non zero frequency */
+-    ushf *bl_count;            /* number of codes at each bit length */
++local void gen_codes (ct_data *tree /* the tree to decorate */, int max_code/* largest code with non zero frequency */, ushf *bl_count /* number of codes at each bit length */)
+ {
+     ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+     ush code = 0;              /* running code value */
+@@ -616,9 +606,7 @@ local void gen_codes (tree, max_code, bl_count)
+  *     and corresponding code. The length opt_len is updated; static_len is
+  *     also updated if stree is not null. The field max_code is set.
+  */
+-local void build_tree(s, desc)
+-    deflate_state *s;
+-    tree_desc *desc; /* the tree descriptor */
++local void build_tree(deflate_state *s, tree_desc *desc)
+ {
+     ct_data *tree         = desc->dyn_tree;
+     const ct_data *stree  = desc->stat_desc->static_tree;
+@@ -704,10 +692,7 @@ local void build_tree(s, desc)
+  * Scan a literal or distance tree to determine the frequencies of the codes
+  * in the bit length tree.
+  */
+-local void scan_tree (s, tree, max_code)
+-    deflate_state *s;
+-    ct_data *tree;   /* the tree to be scanned */
+-    int max_code;    /* and its largest code of non zero frequency */
++local void scan_tree (deflate_state *s, ct_data *tree /* the tree to be scanned */, int max_code /* and its largest code of non zero frequency */)
+ {
+     int n;                     /* iterates over all tree elements */
+     int prevlen = -1;          /* last emitted length */
+@@ -749,10 +734,7 @@ local void scan_tree (s, tree, max_code)
+  * Send a literal or distance tree in compressed form, using the codes in
+  * bl_tree.
+  */
+-local void send_tree (s, tree, max_code)
+-    deflate_state *s;
+-    ct_data *tree; /* the tree to be scanned */
+-    int max_code;       /* and its largest code of non zero frequency */
++local void send_tree (deflate_state *s, ct_data *tree /* the tree to be scanned */, int max_code /* and its largest code of non zero frequency */)
+ {
+     int n;                     /* iterates over all tree elements */
+     int prevlen = -1;          /* last emitted length */
+@@ -800,8 +782,7 @@ local void send_tree (s, tree, max_code)
+  * Construct the Huffman tree for the bit lengths and return the index in
+  * bl_order of the last bit length code to send.
+  */
+-local int build_bl_tree(s)
+-    deflate_state *s;
++local int build_bl_tree(deflate_state *s)
+ {
+     int max_blindex;  /* index of last bit length code of non zero freq */
+ 
+@@ -835,9 +816,8 @@ local int build_bl_tree(s)
+  * lengths of the bit length codes, the literal tree and the distance tree.
+  * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+  */
+-local void send_all_trees(s, lcodes, dcodes, blcodes)
+-    deflate_state *s;
+-    int lcodes, dcodes, blcodes; /* number of codes for each tree */
++local void send_all_trees(deflate_state *s,
++        int lcodes, int dcodes, int blcodes /* number of codes for each tree */)
+ {
+     int rank;                    /* index in bl_order */
+ 
+@@ -864,11 +844,7 @@ local void send_all_trees(s, lcodes, dcodes, blcodes)
+ /* ===========================================================================
+  * Send a stored block
+  */
+-void _tr_stored_block(s, buf, stored_len, eof)
+-    deflate_state *s;
+-    charf *buf;       /* input block */
+-    ulg stored_len;   /* length of input block */
+-    int eof;          /* true if this is the last block for a file */
++void _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int eof)
+ {
+     send_bits(s, (STORED_BLOCK<<1)+eof, 3);  /* send block type */
+ #ifdef DEBUG
+@@ -889,8 +865,7 @@ void _tr_stored_block(s, buf, stored_len, eof)
+  * To simplify the code, we assume the worst case of last real code encoded
+  * on one bit only.
+  */
+-void _tr_align(s)
+-    deflate_state *s;
++void _tr_align(deflate_state *s)
+ {
+     send_bits(s, STATIC_TREES<<1, 3);
+     send_code(s, END_BLOCK, static_ltree);
+@@ -918,11 +893,7 @@ void _tr_align(s)
+  * Determine the best encoding for the current block: dynamic trees, static
+  * trees or store, and output the encoded block to the zip file.
+  */
+-void _tr_flush_block(s, buf, stored_len, eof)
+-    deflate_state *s;
+-    charf *buf;       /* input block, or NULL if too old */
+-    ulg stored_len;   /* length of input block */
+-    int eof;          /* true if this is the last block for a file */
++void _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int eof)
+ {
+     ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+     int max_blindex = 0;  /* index of last bit length code of non zero freq */
+@@ -1018,10 +989,7 @@ void _tr_flush_block(s, buf, stored_len, eof)
+  * Save the match info and tally the frequency counts. Return true if
+  * the current block must be flushed.
+  */
+-int _tr_tally (s, dist, lc)
+-    deflate_state *s;
+-    unsigned dist;  /* distance of matched string */
+-    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
++int _tr_tally (deflate_state *s, unsigned dist /* distance of matched string */, unsigned lc /* match length-MIN_MATCH or unmatched char (if dist==0) */)
+ {
+     s->d_buf[s->last_lit] = (ush)dist;
+     s->l_buf[s->last_lit++] = (uch)lc;
+@@ -1068,10 +1036,7 @@ int _tr_tally (s, dist, lc)
+ /* ===========================================================================
+  * Send the block data compressed using the given Huffman trees
+  */
+-local void compress_block(s, ltree, dtree)
+-    deflate_state *s;
+-    ct_data *ltree; /* literal tree */
+-    ct_data *dtree; /* distance tree */
++local void compress_block(deflate_state *s, ct_data *ltree /* literal tree */, ct_data *dtree /* distance tree */)
+ {
+     unsigned dist;      /* distance of matched string */
+     int lc;             /* match length or unmatched char (if dist == 0) */
+@@ -1122,8 +1087,7 @@ local void compress_block(s, ltree, dtree)
+  * IN assertion: the fields freq of dyn_ltree are set and the total of all
+  * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
+  */
+-local void set_data_type(s)
+-    deflate_state *s;
++local void set_data_type(deflate_state *s)
+ {
+     int n = 0;
+     unsigned ascii_freq = 0;
+@@ -1139,9 +1103,7 @@ local void set_data_type(s)
+  * method would use a table)
+  * IN assertion: 1 <= len <= 15
+  */
+-local unsigned bi_reverse(code, len)
+-    unsigned code; /* the value to invert */
+-    int len;       /* its bit length */
++local unsigned bi_reverse(unsigned code /* the value to invert */, int len /* its bit length */)
+ {
+     register unsigned res = 0;
+     do {
+@@ -1154,8 +1116,7 @@ local unsigned bi_reverse(code, len)
+ /* ===========================================================================
+  * Flush the bit buffer, keeping at most 7 bits in it.
+  */
+-local void bi_flush(s)
+-    deflate_state *s;
++local void bi_flush(deflate_state *s)
+ {
+     if (s->bi_valid == 16) {
+         put_short(s, s->bi_buf);
+@@ -1171,8 +1132,7 @@ local void bi_flush(s)
+ /* ===========================================================================
+  * Flush the bit buffer and align the output on a byte boundary
+  */
+-local void bi_windup(s)
+-    deflate_state *s;
++local void bi_windup(deflate_state *s)
+ {
+     if (s->bi_valid > 8) {
+         put_short(s, s->bi_buf);
+@@ -1190,11 +1150,7 @@ local void bi_windup(s)
+  * Copy a stored block, storing first the length and its
+  * one's complement if requested.
+  */
+-local void copy_block(s, buf, len, header)
+-    deflate_state *s;
+-    charf    *buf;    /* the input data */
+-    unsigned len;     /* its length */
+-    int      header;  /* true if block header must be written */
++local void copy_block(deflate_state *s, charf *buf, unsigned len, int header)
+ {
+     bi_windup(s);        /* align on byte boundary */
+     s->last_eob_len = 8; /* enough lookahead for inflate */
+diff --git a/zlib/zutil.c b/zlib/zutil.c
+index 0ef4f99..45334cb 100644
+--- a/zlib/zutil.c
++++ b/zlib/zutil.c
+@@ -123,8 +123,7 @@ uLong ZEXPORT zlibCompileFlags()
+ #  endif
+ int z_verbose = verbose;
+ 
+-void z_error (m)
+-    char *m;
++void z_error (char *m)
+ {
+     fprintf(stderr, "%s\n", m);
+     exit(1);
+@@ -134,8 +133,7 @@ void z_error (m)
+ /* exported to allow conversion of error code to string for compress() and
+  * uncompress()
+  */
+-const char * ZEXPORT zError(err)
+-    int err;
++const char * ZEXPORT zError(int err)
+ {
+     return ERR_MSG(err);
+ }
+@@ -147,10 +145,7 @@ const char * ZEXPORT zError(err)
+ 
+ #ifndef HAVE_MEMCPY
+ 
+-void zmemcpy(dest, source, len)
+-    Bytef* dest;
+-    const Bytef* source;
+-    uInt  len;
++void zmemcpy(Bytef* dest, const Bytef* source, uInt len)
+ {
+     if (len == 0) return;
+     do {
+@@ -158,10 +153,7 @@ void zmemcpy(dest, source, len)
+     } while (--len != 0);
+ }
+ 
+-int zmemcmp(s1, s2, len)
+-    const Bytef* s1;
+-    const Bytef* s2;
+-    uInt  len;
++int zmemcmp(const Bytef* s1, const Bytef* s2, uInt len)
+ {
+     uInt j;
+ 
+@@ -171,9 +163,7 @@ int zmemcmp(s1, s2, len)
+     return 0;
+ }
+ 
+-void zmemzero(dest, len)
+-    Bytef* dest;
+-    uInt  len;
++void zmemzero(Bytef* dest, uInt len)
+ {
+     if (len == 0) return;
+     do {
+@@ -298,19 +288,14 @@ extern voidp  calloc OF((uInt items, uInt size));
+ extern void   free   OF((voidpf ptr));
+ #endif
+ 
+-voidpf zcalloc (opaque, items, size)
+-    voidpf opaque;
+-    unsigned items;
+-    unsigned size;
++voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+ {
+     if (opaque) items += size - size; /* make compiler happy */
+     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+                               (voidpf)calloc(items, size);
+ }
+ 
+-void  zcfree (opaque, ptr)
+-    voidpf opaque;
+-    voidpf ptr;
++void  zcfree (voidpf opaque, voidpf ptr)
+ {
+     free(ptr);
+     if (opaque) return; /* make compiler happy */
diff --git a/pkgs/by-name/zs/zsync/package.nix b/pkgs/by-name/zs/zsync/package.nix
index 934b54c8e36a..d7f0fa2a63f8 100644
--- a/pkgs/by-name/zs/zsync/package.nix
+++ b/pkgs/by-name/zs/zsync/package.nix
@@ -18,7 +18,10 @@ stdenv.mkDerivation (finalAttrs: {
 
   sourceRoot = "${finalAttrs.src.name}/c";
 
-  patches = [ ./remove-inexisting-rsumtest.patch ];
+  patches = [
+    ./remove-inexisting-rsumtest.patch
+    ./c23.patch
+  ];
 
   makeFlags = [ "AR=${stdenv.cc.bintools.targetPrefix}ar" ];