update zlib header

Author: braindigitalis

include/ramdisk.h

@@ -75,6 +75,8 @@ const char* init_ramdisk_from_memory(uint8_t* memory, size_t blocks, size_t bloc
  */
 bool decompress_gzip(uint8_t *compressed_image, size_t compressed_size, uint8_t** out, uint32_t* out_size);
 
+bool compress_gzip(uint8_t *data, size_t data_size, uint8_t **out, uint32_t *out_size, int level);
+
 /**
  * @brief Inflate and mount the initial ramdisk supplied by the bootloader
  *

include/zlib/zlib.h

@@ -1,5 +1,5 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.3.1.1, January xxth, 2024
+  version 1.3.1, January 22nd, 2024
 
   Copyright (C) 1995-2024 Jean-loup Gailly and Mark Adler
 
@@ -31,22 +31,18 @@
 #ifndef ZLIB_H
 #define ZLIB_H
 
-#ifdef ZLIB_BUILD
-#  include <zconf.h>
-#else
-# include "zconf.h"
-#endif
+#include "zconf.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define ZLIB_VERSION "1.3.1.1-motley"
-#define ZLIB_VERNUM 0x1311
+#define ZLIB_VERSION "1.3.1"
+#define ZLIB_VERNUM 0x1310
 #define ZLIB_VER_MAJOR 1
 #define ZLIB_VER_MINOR 3
 #define ZLIB_VER_REVISION 1
-#define ZLIB_VER_SUBREVISION 1
+#define ZLIB_VER_SUBREVISION 0
 
 /*
     The 'zlib' compression library provides in-memory compression and
@@ -591,21 +587,18 @@ ZEXTERN int ZEXPORT deflateInit2(z_streamp strm,
 
      The strategy parameter is used to tune the compression algorithm.  Use the
    value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
-   filter (or predictor), Z_RLE to limit match distances to one (run-length
-   encoding), or Z_HUFFMAN_ONLY to force Huffman encoding only (no string
-   matching).  Filtered data consists mostly of small values with a somewhat
-   random distribution, as produced by the PNG filters.  In this case, the
-   compression algorithm is tuned to compress them better.  The effect of
-   Z_FILTERED is to force more Huffman coding and less string matching than the
-   default; it is intermediate between Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.
-   Z_RLE is almost as fast as Z_HUFFMAN_ONLY, but should give better
-   compression for PNG image data than Huffman only.  The degree of string
-   matching from most to none is: Z_DEFAULT_STRATEGY, Z_FILTERED, Z_RLE, then
-   Z_HUFFMAN_ONLY. The strategy parameter affects the compression ratio but
-   never the correctness of the compressed output, even if it is not set
-   optimally for the given data.  Z_FIXED uses the default string matching, but
-   prevents the use of dynamic Huffman codes, allowing for a simpler decoder
-   for special applications.
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
 
      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
    memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
@@ -795,18 +788,6 @@ ZEXTERN int ZEXPORT deflatePending(z_streamp strm,
    stream state was inconsistent.
  */
 
-ZEXTERN int ZEXPORT deflateUsed(z_streamp strm,
-                                int *bits);
-/*
-     deflateUsed() returns in *bits the most recent number of deflate bits used
-   in the last byte when flushing to a byte boundary. The result is in 1..8, or
-   0 if there has not yet been a flush. This helps determine the location of
-   the last bit of a deflate stream.
-
-     deflateUsed returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
- */
-
 ZEXTERN int ZEXPORT deflatePrime(z_streamp strm,
                                  int bits,
                                  int value);
@@ -1907,9 +1888,9 @@ ZEXTERN int ZEXPORT gzgetc_(gzFile file);       /* backward compatibility */
      ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int);
      ZEXTERN z_off_t ZEXPORT gztell64(gzFile);
      ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile);
-     ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);
-     ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);
-     ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);
+     ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t);
+     ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t);
+     ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t);
 #  endif
 #else
    ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *);

src/block/ramdisk.c

@@ -213,6 +213,60 @@ static void zlib_free(voidpf opaque, voidpf addr) {
 	}
 }
 
+bool compress_gzip(uint8_t *data, size_t data_size, uint8_t **out, uint32_t *out_size, int level) {
+	if (data == NULL || out == NULL || out_size == NULL) {
+		return false;
+	}
+
+	if (data_size == 0) {
+		return false;
+	}
+
+	if (level < Z_BEST_SPEED || level > Z_BEST_COMPRESSION) {
+		level = Z_BEST_SPEED;
+	}
+
+	z_stream zs;
+	memset(&zs, 0, sizeof(zs));
+	zs.zalloc = zlib_alloc;
+	zs.zfree = zlib_free;
+	zs.opaque = Z_NULL;
+
+	size_t bound = deflateBound(&zs, data_size);
+	if (bound > UINT32_MAX) {
+		return false;
+	}
+
+	*out = kmalloc(bound);
+	if (*out == NULL) {
+		return false;
+	}
+
+	zs.next_in = (Bytef *)data;
+	zs.avail_in = (uInt)data_size;
+	zs.next_out = (Bytef *)*out;
+	zs.avail_out = (uInt)bound;
+
+	int rc = deflateInit2(&zs, level, Z_DEFLATED, 16 + MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
+	if (rc != Z_OK) {
+		kfree(*out);
+		*out = NULL;
+		return false;
+	}
+
+	rc = deflate(&zs, Z_FINISH);
+	if (rc != Z_STREAM_END) {
+		deflateEnd(&zs);
+		kfree(*out);
+		*out = NULL;
+		return false;
+	}
+
+	*out_size = (uint32_t)zs.total_out;
+	deflateEnd(&zs);
+	return true;
+}
+
 bool decompress_gzip(uint8_t *compressed_image, size_t compressed_size, uint8_t** out, uint32_t* out_size) {
 	if (compressed_image == NULL) {
 		return false;
@@ -291,4 +345,4 @@ bool mount_initial_ramdisk(uint8_t *compressed_image, size_t compressed_size) {
 	}
 
 	return true;
-}
+}

src/zlib/compress.c

@@ -0,0 +1,75 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2(Bytef *dest, uLongf *destLen, const Bytef *source,
+                      uLong sourceLen, int level) {
+    z_stream stream;
+    int err;
+    const uInt max = (uInt)-1;
+    uLong left;
+
+    left = *destLen;
+    *destLen = 0;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = deflateInit(&stream, level);
+    if (err != Z_OK) return err;
+
+    stream.next_out = dest;
+    stream.avail_out = 0;
+    stream.next_in = (z_const Bytef *)source;
+    stream.avail_in = 0;
+
+    do {
+        if (stream.avail_out == 0) {
+            stream.avail_out = left > (uLong)max ? max : (uInt)left;
+            left -= stream.avail_out;
+        }
+        if (stream.avail_in == 0) {
+            stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+            sourceLen -= stream.avail_in;
+        }
+        err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+    } while (err == Z_OK);
+
+    *destLen = stream.total_out;
+    deflateEnd(&stream);
+    return err == Z_STREAM_END ? Z_OK : err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source,
+                     uLong sourceLen) {
+    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/* ===========================================================================
+     If the default memLevel or windowBits for deflateInit() is changed, then
+   this function needs to be updated.
+ */
+uLong ZEXPORT compressBound(uLong sourceLen) {
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+           (sourceLen >> 25) + 13;
+}