From bbe323be3a592640f1e2d84abd757e64b9996ef1 Mon Sep 17 00:00:00 2001 From: Julian Sikorski Date: Apr 06 2022 20:25:35 +0000 Subject: Fix issues with bundled minizip --- diff --git a/0001-fix-solved-issue-with-minizip-ng.patch b/0001-fix-solved-issue-with-minizip-ng.patch new file mode 100644 index 0000000..0e0c286 --- /dev/null +++ b/0001-fix-solved-issue-with-minizip-ng.patch @@ -0,0 +1,438 @@ +From aa93543fbca72f4b9e3cdc3fc7de41085e4155b6 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Ren=C3=A9=20Reucher?= +Date: Wed, 6 Apr 2022 18:48:31 +0200 +Subject: [PATCH] fix: solved issue with minizip-ng + +--- + qmc2.pro | 2 + + src/minizip/README.minizip | 4 +- + src/minizip/mz_strm_zlib.c | 394 +++++++++++++++++++++++++++++++++++++ + 3 files changed, 397 insertions(+), 3 deletions(-) + create mode 100644 src/minizip/mz_strm_zlib.c + +diff --git a/qmc2.pro b/qmc2.pro +index 0b1681d83..312889d91 100644 +--- a/qmc2.pro ++++ b/qmc2.pro +@@ -320,7 +320,9 @@ greaterThan(QT_MAJOR_VERSION, 4) { + src/minizip/mz_strm.c \ + src/minizip/mz_strm_mem.c \ + src/minizip/mz_strm_os_posix.c \ ++ src/minizip/mz_strm_zlib.c \ + src/minizip/mz_zip.c ++ DEFINES += HAVE_ZLIB ZLIB_COMPAT + } else { + CONFIG += link_pkgconfig + PKGCONFIG += minizip +diff --git a/src/minizip/README.minizip b/src/minizip/README.minizip +index 70c6b6943..fc3a79351 100644 +--- a/src/minizip/README.minizip ++++ b/src/minizip/README.minizip +@@ -1,3 +1 @@ +-This code has been taken from https://github.com/zlib-ng/minizip-ng +- +-git revision: f3d400e999056ca290998b3fd89cc5a74e4b8b58 / 05-MAR-2022 ++his code has been taken from https://github.com/zlib-ng/minizip-ng/releases/tag/3.0.5 +diff --git a/src/minizip/mz_strm_zlib.c b/src/minizip/mz_strm_zlib.c +new file mode 100644 +index 000000000..f76d7ffc4 +--- /dev/null ++++ b/src/minizip/mz_strm_zlib.c +@@ -0,0 +1,394 @@ ++/* mz_strm_zlib.c -- Stream for zlib inflate/deflate ++ part of the minizip-ng project ++ ++ Copyright (C) 2010-2021 Nathan Moinvaziri ++ https://github.com/zlib-ng/minizip-ng ++ ++ This program is distributed under the terms of the same license as zlib. ++ See the accompanying LICENSE file for the full text of the license. ++*/ ++ ++ ++#include "mz.h" ++#include "mz_strm.h" ++#include "mz_strm_zlib.h" ++ ++#if !defined(ZLIB_COMPAT) ++# include "zlib-ng.h" ++#else ++# include "zlib.h" ++#endif ++ ++/***************************************************************************/ ++ ++#if !defined(ZLIB_COMPAT) ++# define ZLIB_PREFIX(x) zng_ ## x ++ typedef zng_stream zlib_stream; ++#else ++# define ZLIB_PREFIX(x) x ++ typedef z_stream zlib_stream; ++#endif ++ ++#if !defined(DEF_MEM_LEVEL) ++# if MAX_MEM_LEVEL >= 8 ++# define DEF_MEM_LEVEL 8 ++# else ++# define DEF_MEM_LEVEL MAX_MEM_LEVEL ++# endif ++#endif ++ ++/***************************************************************************/ ++ ++static mz_stream_vtbl mz_stream_zlib_vtbl = { ++ mz_stream_zlib_open, ++ mz_stream_zlib_is_open, ++ mz_stream_zlib_read, ++ mz_stream_zlib_write, ++ mz_stream_zlib_tell, ++ mz_stream_zlib_seek, ++ mz_stream_zlib_close, ++ mz_stream_zlib_error, ++ mz_stream_zlib_create, ++ mz_stream_zlib_delete, ++ mz_stream_zlib_get_prop_int64, ++ mz_stream_zlib_set_prop_int64 ++}; ++ ++/***************************************************************************/ ++ ++typedef struct mz_stream_zlib_s { ++ mz_stream stream; ++ zlib_stream zstream; ++ uint8_t buffer[INT16_MAX]; ++ int32_t buffer_len; ++ int64_t total_in; ++ int64_t total_out; ++ int64_t max_total_in; ++ int8_t initialized; ++ int16_t level; ++ int32_t window_bits; ++ int32_t mode; ++ int32_t error; ++} mz_stream_zlib; ++ ++/***************************************************************************/ ++ ++int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ ++ MZ_UNUSED(path); ++ ++ zlib->zstream.data_type = Z_BINARY; ++ zlib->zstream.zalloc = Z_NULL; ++ zlib->zstream.zfree = Z_NULL; ++ zlib->zstream.opaque = Z_NULL; ++ zlib->zstream.total_in = 0; ++ zlib->zstream.total_out = 0; ++ ++ zlib->total_in = 0; ++ zlib->total_out = 0; ++ ++ if (mode & MZ_OPEN_MODE_WRITE) { ++#ifdef MZ_ZIP_NO_COMPRESSION ++ return MZ_SUPPORT_ERROR; ++#else ++ zlib->zstream.next_out = zlib->buffer; ++ zlib->zstream.avail_out = sizeof(zlib->buffer); ++ ++ zlib->error = ZLIB_PREFIX(deflateInit2)(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED, ++ zlib->window_bits, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); ++#endif ++ } else if (mode & MZ_OPEN_MODE_READ) { ++#ifdef MZ_ZIP_NO_DECOMPRESSION ++ return MZ_SUPPORT_ERROR; ++#else ++ zlib->zstream.next_in = zlib->buffer; ++ zlib->zstream.avail_in = 0; ++ ++ zlib->error = ZLIB_PREFIX(inflateInit2)(&zlib->zstream, zlib->window_bits); ++#endif ++ } ++ ++ if (zlib->error != Z_OK) ++ return MZ_OPEN_ERROR; ++ ++ zlib->initialized = 1; ++ zlib->mode = mode; ++ return MZ_OK; ++} ++ ++int32_t mz_stream_zlib_is_open(void *stream) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ if (zlib->initialized != 1) ++ return MZ_OPEN_ERROR; ++ return MZ_OK; ++} ++ ++int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size) { ++#ifdef MZ_ZIP_NO_DECOMPRESSION ++ MZ_UNUSED(stream); ++ MZ_UNUSED(buf); ++ MZ_UNUSED(size); ++ return MZ_SUPPORT_ERROR; ++#else ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ uint64_t total_in_before = 0; ++ uint64_t total_in_after = 0; ++ uint64_t total_out_before = 0; ++ uint64_t total_out_after = 0; ++ uint32_t total_in = 0; ++ uint32_t total_out = 0; ++ uint32_t in_bytes = 0; ++ uint32_t out_bytes = 0; ++ int32_t bytes_to_read = sizeof(zlib->buffer); ++ int32_t read = 0; ++ int32_t err = Z_OK; ++ ++ ++ zlib->zstream.next_out = (Bytef*)buf; ++ zlib->zstream.avail_out = (uInt)size; ++ ++ do { ++ if (zlib->zstream.avail_in == 0) { ++ if (zlib->max_total_in > 0) { ++ if ((int64_t)bytes_to_read > (zlib->max_total_in - zlib->total_in)) ++ bytes_to_read = (int32_t)(zlib->max_total_in - zlib->total_in); ++ } ++ ++ read = mz_stream_read(zlib->stream.base, zlib->buffer, bytes_to_read); ++ ++ if (read < 0) ++ return read; ++ ++ zlib->zstream.next_in = zlib->buffer; ++ zlib->zstream.avail_in = read; ++ } ++ ++ total_in_before = zlib->zstream.avail_in; ++ total_out_before = zlib->zstream.total_out; ++ ++ err = ZLIB_PREFIX(inflate)(&zlib->zstream, Z_SYNC_FLUSH); ++ if ((err >= Z_OK) && (zlib->zstream.msg != NULL)) { ++ zlib->error = Z_DATA_ERROR; ++ break; ++ } ++ ++ total_in_after = zlib->zstream.avail_in; ++ total_out_after = zlib->zstream.total_out; ++ ++ in_bytes = (uint32_t)(total_in_before - total_in_after); ++ out_bytes = (uint32_t)(total_out_after - total_out_before); ++ ++ total_in += in_bytes; ++ total_out += out_bytes; ++ ++ zlib->total_in += in_bytes; ++ zlib->total_out += out_bytes; ++ ++ if (err == Z_STREAM_END) ++ break; ++ if (err != Z_OK) { ++ zlib->error = err; ++ break; ++ } ++ } while (zlib->zstream.avail_out > 0); ++ ++ if (zlib->error != 0) { ++ /* Zlib errors are compatible with MZ */ ++ return zlib->error; ++ } ++ ++ return total_out; ++#endif ++} ++ ++#ifndef MZ_ZIP_NO_COMPRESSION ++static int32_t mz_stream_zlib_flush(void *stream) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ if (mz_stream_write(zlib->stream.base, zlib->buffer, zlib->buffer_len) != zlib->buffer_len) ++ return MZ_WRITE_ERROR; ++ return MZ_OK; ++} ++ ++static int32_t mz_stream_zlib_deflate(void *stream, int flush) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ uint64_t total_out_before = 0; ++ uint64_t total_out_after = 0; ++ int32_t out_bytes = 0; ++ int32_t err = Z_OK; ++ ++ ++ do { ++ if (zlib->zstream.avail_out == 0) { ++ err = mz_stream_zlib_flush(zlib); ++ if (err != MZ_OK) ++ return err; ++ ++ zlib->zstream.avail_out = sizeof(zlib->buffer); ++ zlib->zstream.next_out = zlib->buffer; ++ ++ zlib->buffer_len = 0; ++ } ++ ++ total_out_before = zlib->zstream.total_out; ++ err = ZLIB_PREFIX(deflate)(&zlib->zstream, flush); ++ total_out_after = zlib->zstream.total_out; ++ ++ out_bytes = (uint32_t)(total_out_after - total_out_before); ++ ++ zlib->buffer_len += out_bytes; ++ zlib->total_out += out_bytes; ++ ++ if (err == Z_STREAM_END) ++ break; ++ if (err != Z_OK) { ++ zlib->error = err; ++ return MZ_DATA_ERROR; ++ } ++ } while ((zlib->zstream.avail_in > 0) || (flush == Z_FINISH && err == Z_OK)); ++ ++ return MZ_OK; ++} ++#endif ++ ++int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size) { ++#ifdef MZ_ZIP_NO_COMPRESSION ++ MZ_UNUSED(stream); ++ MZ_UNUSED(buf); ++ MZ_UNUSED(size); ++ return MZ_SUPPORT_ERROR; ++#else ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ int32_t err = MZ_OK; ++ ++ zlib->zstream.next_in = (Bytef*)(intptr_t)buf; ++ zlib->zstream.avail_in = (uInt)size; ++ ++ err = mz_stream_zlib_deflate(stream, Z_NO_FLUSH); ++ if (err != MZ_OK) { ++ return err; ++ } ++ ++ zlib->total_in += size; ++ return size; ++#endif ++} ++ ++int64_t mz_stream_zlib_tell(void *stream) { ++ MZ_UNUSED(stream); ++ ++ return MZ_TELL_ERROR; ++} ++ ++int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin) { ++ MZ_UNUSED(stream); ++ MZ_UNUSED(offset); ++ MZ_UNUSED(origin); ++ ++ return MZ_SEEK_ERROR; ++} ++ ++int32_t mz_stream_zlib_close(void *stream) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ ++ ++ if (zlib->mode & MZ_OPEN_MODE_WRITE) { ++#ifdef MZ_ZIP_NO_COMPRESSION ++ return MZ_SUPPORT_ERROR; ++#else ++ mz_stream_zlib_deflate(stream, Z_FINISH); ++ mz_stream_zlib_flush(stream); ++ ++ ZLIB_PREFIX(deflateEnd)(&zlib->zstream); ++#endif ++ } else if (zlib->mode & MZ_OPEN_MODE_READ) { ++#ifdef MZ_ZIP_NO_DECOMPRESSION ++ return MZ_SUPPORT_ERROR; ++#else ++ ZLIB_PREFIX(inflateEnd)(&zlib->zstream); ++#endif ++ } ++ ++ zlib->initialized = 0; ++ ++ if (zlib->error != Z_OK) ++ return MZ_CLOSE_ERROR; ++ return MZ_OK; ++} ++ ++int32_t mz_stream_zlib_error(void *stream) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ return zlib->error; ++} ++ ++int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ switch (prop) { ++ case MZ_STREAM_PROP_TOTAL_IN: ++ *value = zlib->total_in; ++ break; ++ case MZ_STREAM_PROP_TOTAL_IN_MAX: ++ *value = zlib->max_total_in; ++ break; ++ case MZ_STREAM_PROP_TOTAL_OUT: ++ *value = zlib->total_out; ++ break; ++ case MZ_STREAM_PROP_HEADER_SIZE: ++ *value = 0; ++ break; ++ case MZ_STREAM_PROP_COMPRESS_WINDOW: ++ *value = zlib->window_bits; ++ break; ++ default: ++ return MZ_EXIST_ERROR; ++ } ++ return MZ_OK; ++} ++ ++int32_t mz_stream_zlib_set_prop_int64(void *stream, int32_t prop, int64_t value) { ++ mz_stream_zlib *zlib = (mz_stream_zlib *)stream; ++ switch (prop) { ++ case MZ_STREAM_PROP_COMPRESS_LEVEL: ++ zlib->level = (int16_t)value; ++ break; ++ case MZ_STREAM_PROP_TOTAL_IN_MAX: ++ zlib->max_total_in = value; ++ break; ++ case MZ_STREAM_PROP_COMPRESS_WINDOW: ++ zlib->window_bits = (int32_t)value; ++ break; ++ default: ++ return MZ_EXIST_ERROR; ++ } ++ return MZ_OK; ++} ++ ++void *mz_stream_zlib_create(void **stream) { ++ mz_stream_zlib *zlib = NULL; ++ ++ zlib = (mz_stream_zlib *)MZ_ALLOC(sizeof(mz_stream_zlib)); ++ if (zlib != NULL) { ++ memset(zlib, 0, sizeof(mz_stream_zlib)); ++ zlib->stream.vtbl = &mz_stream_zlib_vtbl; ++ zlib->level = Z_DEFAULT_COMPRESSION; ++ zlib->window_bits = -MAX_WBITS; ++ } ++ if (stream != NULL) ++ *stream = zlib; ++ ++ return zlib; ++} ++ ++void mz_stream_zlib_delete(void **stream) { ++ mz_stream_zlib *zlib = NULL; ++ if (stream == NULL) ++ return; ++ zlib = (mz_stream_zlib *)*stream; ++ if (zlib != NULL) ++ MZ_FREE(zlib); ++ *stream = NULL; ++} ++ ++void *mz_stream_zlib_get_interface(void) { ++ return (void *)&mz_stream_zlib_vtbl; ++} +-- +2.35.1 + diff --git a/qmc2.spec b/qmc2.spec index 0722464..7f12cf7 100644 --- a/qmc2.spec +++ b/qmc2.spec @@ -15,6 +15,7 @@ Summary: M.A.M.E. Catalog / Launcher II License: GPLv2 and ASL 2.0 and MIT URL: http://qmc2.batcom-it.net Source0: %{forgesource} +Patch0: 0001-fix-solved-issue-with-minizip-ng.patch #Fedora-specific configuration Patch1: %{name}-ini.patch @@ -63,8 +64,9 @@ the games" %prep %forgeautosetup -p1 #ensure system minizip and zlib are used -rm -rf minizip -rm -rf zlib +#https://bugzilla.redhat.com/show_bug.cgi?id=1998742 +#rm -rf src/minizip +rm -rf src/zlib %build