From patchwork Thu Jan 28 20:04:33 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fabrice Fontaine X-Patchwork-Id: 1432998 Return-Path: X-Original-To: incoming-buildroot@patchwork.ozlabs.org Delivered-To: patchwork-incoming-buildroot@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=busybox.net (client-ip=140.211.166.133; helo=hemlock.osuosl.org; envelope-from=buildroot-bounces@busybox.net; receiver=) Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=jlSKvF4c; dkim-atps=neutral Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4DRWgT5gCJz9sSs for ; Fri, 29 Jan 2021 07:05:57 +1100 (AEDT) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id 79AD187057; Thu, 28 Jan 2021 20:05:53 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id BUxCZExS7M+K; Thu, 28 Jan 2021 20:05:51 +0000 (UTC) Received: from ash.osuosl.org (ash.osuosl.org [140.211.166.34]) by hemlock.osuosl.org (Postfix) with ESMTP id 1ECB78732D; Thu, 28 Jan 2021 20:05:51 +0000 (UTC) X-Original-To: buildroot@lists.busybox.net Delivered-To: buildroot@osuosl.org Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by ash.osuosl.org (Postfix) with ESMTP id 8E8E81BF3CA for ; Thu, 28 Jan 2021 20:05:48 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 775E120469 for ; Thu, 28 Jan 2021 20:05:48 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id nt6tvbotTVEG for ; Thu, 28 Jan 2021 20:05:46 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wm1-f53.google.com (mail-wm1-f53.google.com [209.85.128.53]) by silver.osuosl.org (Postfix) with ESMTPS id EBA29204AD for ; Thu, 28 Jan 2021 20:05:42 +0000 (UTC) Received: by mail-wm1-f53.google.com with SMTP id f16so5254713wmq.5 for ; Thu, 28 Jan 2021 12:05:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=tHO0YHHbArh6EDqa+Fbjt5pLxjm8d65SMB5DoaBhye8=; b=jlSKvF4czOgG3T/pzCJYQq+xZIQpX9jngWWRsofcNm0KvurOmo8HWvk+9A2Ef+iPVd oFuYNDBQFGVKtSjMvcY2htc/oljoVZfpLTF1E7zf9KPxXOc1+uclFQp5c1+ZgjVlSUVe 7fJI/dNgjUdn91l/1aaEkyXunLpyas+MysdoPKcw846nVcxoWWImXTtaE+81O5Y/jjIP jir/U49Yani5g5jb4YfNWAwLXZabVCGamCTyUaz0Famsnrq6MHl7XRmkktybp0uk5ve1 jA8/r7IUvrUTAfxY3bNgOi7wwQ/eiNLj4j2ch1tIuxpKRE9VBlidfUOh2DQKSHHTgVo8 YdJw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=tHO0YHHbArh6EDqa+Fbjt5pLxjm8d65SMB5DoaBhye8=; b=tbTQla8on0cskwr1nlQt44WjANoR+GQhPsPNhNYgAXfbwrCsnVUqCXi0NIeXrUkkVA vD5W4Xp/XTaHvmSfPqZZrgQIyhEO6PJ9ZEbdZGskveELumENsqQNQkc58n4l50jn4nMw h+wkvKAofDMdAinji7jhO0tWuQ99vt49EA+cHtrhpnL/i+ITdzhLOKnxd/qDsHSLnXZb XlxVry85rCtOfl/18QCJkAPwfq9yBh0ruvyZhM29ajvwJN3Xy6oi7kfmiu3+R7cw1bZ9 BmjyDEvgrFim3CJiQOlhRm/v9VDNYLWqvS8EeBgg2RDQUs2j8zcymdJhSJcyjSDtAXun wD+g== X-Gm-Message-State: AOAM531RGOga8bbL4j8GGTXpw8rLaUzxaMGk3ltITaGSRGMgayEXo7Ke TP884r3l95a2m+rMxWp9WNnt1fK68UyUBw== X-Google-Smtp-Source: ABdhPJzyw2mGRgILI8ES8YcdP3D7xO20p8PkSmk78hSXsJY5rRAv9o9mXsKmJySSiZK0FNNNehIlzQ== X-Received: by 2002:a7b:c1d7:: with SMTP id a23mr788154wmj.149.1611864341142; Thu, 28 Jan 2021 12:05:41 -0800 (PST) Received: from kali.home (2a01cb0881b76d00c2afd0dfa851d2b9.ipv6.abo.wanadoo.fr. [2a01:cb08:81b7:6d00:c2af:d0df:a851:d2b9]) by smtp.gmail.com with ESMTPSA id k131sm7170628wmb.37.2021.01.28.12.05.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 28 Jan 2021 12:05:40 -0800 (PST) From: Fabrice Fontaine To: buildroot@buildroot.org Date: Thu, 28 Jan 2021 21:04:33 +0100 Message-Id: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> X-Mailer: git-send-email 2.29.2 MIME-Version: 1.0 Subject: [Buildroot] [PATCH v2, 1/4] Revert "package/assimp: fix musl zlib/zip related compile failure" X-BeenThere: buildroot@busybox.net X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion and development of buildroot List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Peter Seiderer , Samuel Martin , Fabrice Fontaine Errors-To: buildroot-bounces@busybox.net Sender: "buildroot" This reverts commit b529a582ba4d7671597e95d7ab54ee652cbbc261 as it raises a build failure with hiawatha because assimp installs its own zlib library in staging directory. Fixes: - http://autobuild.buildroot.org/results/9cac31962d48245a5579da692dbc9488292a397e Signed-off-by: Fabrice Fontaine --- ...ssize_t-typedef-mismatch-for-musl-co.patch | 50 ------------------- package/assimp/Config.in | 1 + package/assimp/assimp.mk | 3 +- 3 files changed, 3 insertions(+), 51 deletions(-) delete mode 100644 package/assimp/0002-contrib-zip-fix-ssize_t-typedef-mismatch-for-musl-co.patch diff --git a/package/assimp/0002-contrib-zip-fix-ssize_t-typedef-mismatch-for-musl-co.patch b/package/assimp/0002-contrib-zip-fix-ssize_t-typedef-mismatch-for-musl-co.patch deleted file mode 100644 index a9a30c4834..0000000000 --- a/package/assimp/0002-contrib-zip-fix-ssize_t-typedef-mismatch-for-musl-co.patch +++ /dev/null @@ -1,50 +0,0 @@ -From 3fef857a570d1ef2c96401358fe8e239625b48c9 Mon Sep 17 00:00:00 2001 -From: Peter Seiderer -Date: Fri, 10 Apr 2020 18:11:50 +0200 -Subject: [PATCH] contrib/zip: fix ssize_t typedef mismatch for musl compile - -Musl uses defines __DEFINED_ssize_t to indicate ssize_t -availability. So backport this part of upstream commit [1] -to fixl musl compile. - -https://github.com/assimp/assimp/commit/f78446b14aff46db2ef27d062a275b6a01fd68b1 - -Signed-off-by: Peter Seiderer ---- - contrib/zip/src/zip.h | 13 +++++++++++-- - 1 file changed, 11 insertions(+), 2 deletions(-) - -diff --git a/contrib/zip/src/zip.h b/contrib/zip/src/zip.h -index 5f39df50..4672eb3e 100644 ---- a/contrib/zip/src/zip.h -+++ b/contrib/zip/src/zip.h -@@ -20,8 +20,9 @@ extern "C" { - #endif - - #if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) && \ -- !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(__ssize_t_defined) --#define _SSIZE_T -+ !defined(__DEFINED_ssize_t) && !defined(__ssize_t_defined) && \ -+ !defined(_SSIZE_T) && !defined(_SSIZE_T_) -+ - // 64-bit Windows is the only mainstream platform - // where sizeof(long) != sizeof(void*) - #ifdef _WIN64 -@@ -29,6 +30,14 @@ typedef long long ssize_t; /* byte count or error */ - #else - typedef long ssize_t; /* byte count or error */ - #endif -+ -+#define _SSIZE_T_DEFINED -+#define _SSIZE_T_DEFINED_ -+#define __DEFINED_ssize_t -+#define __ssize_t_defined -+#define _SSIZE_T -+#define _SSIZE_T_ -+ - #endif - - #ifndef MAX_PATH --- -2.26.0 - diff --git a/package/assimp/Config.in b/package/assimp/Config.in index 9bdc054909..42bfee945d 100644 --- a/package/assimp/Config.in +++ b/package/assimp/Config.in @@ -2,6 +2,7 @@ config BR2_PACKAGE_ASSIMP bool "assimp" depends on BR2_INSTALL_LIBSTDCPP depends on BR2_USE_WCHAR + select BR2_PACKAGE_ZLIB help Open Asset Import Library (assimp) is a portable Open Source library to import various well-known 3D model formats in a diff --git a/package/assimp/assimp.mk b/package/assimp/assimp.mk index e1b9a23499..eddfbc48b0 100644 --- a/package/assimp/assimp.mk +++ b/package/assimp/assimp.mk @@ -8,6 +8,7 @@ ASSIMP_VERSION = 5.0.1 ASSIMP_SITE = $(call github,assimp,assimp,v$(ASSIMP_VERSION)) ASSIMP_LICENSE = BSD-3-Clause ASSIMP_LICENSE_FILES = LICENSE +ASSIMP_DEPENDENCIES = zlib ASSIMP_INSTALL_STAGING = YES # relocation truncated to fit: R_68K_GOT16O. We also need to disable @@ -36,7 +37,7 @@ ifeq ($(BR2_TOOLCHAIN_HAS_GCC_BUG_85180),y) ASSIMP_CXXFLAGS += -O0 endif -ASSIMP_CONF_OPTS += -DASSIMP_BUILD_ZLIB=ON -DASSIMP_BUILD_TESTS=OFF \ +ASSIMP_CONF_OPTS += -DASSIMP_BUILD_TESTS=OFF \ -DCMAKE_CXX_FLAGS="$(TARGET_CXXFLAGS) $(ASSIMP_CXXFLAGS)" $(eval $(cmake-package)) From patchwork Thu Jan 28 20:04:34 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fabrice Fontaine X-Patchwork-Id: 1432997 Return-Path: X-Original-To: incoming-buildroot@patchwork.ozlabs.org Delivered-To: patchwork-incoming-buildroot@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=busybox.net (client-ip=140.211.166.138; helo=whitealder.osuosl.org; envelope-from=buildroot-bounces@busybox.net; receiver=) Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=utJpbypK; dkim-atps=neutral Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4DRWgP1mS2z9sSs for ; Fri, 29 Jan 2021 07:05:52 +1100 (AEDT) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 270CF86E6E; Thu, 28 Jan 2021 20:05:51 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ilrbfByFYrxt; Thu, 28 Jan 2021 20:05:48 +0000 (UTC) Received: from ash.osuosl.org (ash.osuosl.org [140.211.166.34]) by whitealder.osuosl.org (Postfix) with ESMTP id 1973086CB1; Thu, 28 Jan 2021 20:05:48 +0000 (UTC) X-Original-To: buildroot@lists.busybox.net Delivered-To: buildroot@osuosl.org Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by ash.osuosl.org (Postfix) with ESMTP id 9CAC61BF3CA for ; Thu, 28 Jan 2021 20:05:46 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 9915686CB1 for ; Thu, 28 Jan 2021 20:05:46 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id i3sRODydRF+L for ; Thu, 28 Jan 2021 20:05:46 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wm1-f47.google.com (mail-wm1-f47.google.com [209.85.128.47]) by whitealder.osuosl.org (Postfix) with ESMTPS id CC05E86B78 for ; Thu, 28 Jan 2021 20:05:45 +0000 (UTC) Received: by mail-wm1-f47.google.com with SMTP id u14so5258488wml.4 for ; Thu, 28 Jan 2021 12:05:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=iMVDnt4HlAFKcU/6XriGMFTsnx8WlWeUYyT++xEgVdQ=; b=utJpbypKaJ/8rQytmV6UXwFxMTwrQwmubIm/cr4IOSrFupbmyzwvSeoc3VEiwb9Co8 JdI5h9KIk3gNJU13wFeHLOlO/bW5kc26NHSijtaZ862rCHkB6j0TMbngFco29s5hxKpY kXhyj1MMi7ktnkFB8qaV2ef9Ce36h8yISVs9d8Zlw6yWr/Ufzdm0X/rZ4A+9hCVGAdSs Qo1y8rPYIG7txUzAmOhcXIThH2hOdfAEraHK08+akWX6tN/05eHSW4h1xUfDuDbw8c3k ZGAZ7Xy3rxr03nQCkiGz62qhji9AAQDkSZEx/DIanTX368Y2XuXsvvfZjo6p9AZVNJW+ XPOg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=iMVDnt4HlAFKcU/6XriGMFTsnx8WlWeUYyT++xEgVdQ=; b=d5ENG6lLZFA0AjkNraVIRN/cfyDCzgXMiteCIWZcXXNd/ugjbPvxM4SyrrrKgxtrbI n15MsdsSXIe2jY6zO/73mTtdc53IVBG1M8v0JY6RUxNcN0YRW5UgVE4BHVAS20O7VVLz XVMSuwRho7IhofaD0an1+ZHf4UkEHR9PnUkAgfkA1bxt9neBjl0Rjtm0rvntS4MTP4B1 /oEAvHRboteOa5Fw+9oLLriyEhFtN8IUijg6w/YLjmN1xKgPau194ab17/X2Fj4ox+K2 W0MXSGzjocqiuB56fdUB7d9pwunBAOSfojaiiE9LgGQE0v1BiM+nmVYXkp7MG6bpEyFD lygQ== X-Gm-Message-State: AOAM532VevfITSFJFi70ed7pDrxl+SJD0vVKimZ3F5cM34ymHTl8kAFb 99XqyNqyhsuAvtVo6yat8pxrG/DZbUXdWQ== X-Google-Smtp-Source: ABdhPJxpwN+w3atBMZv7LY/Y+Ag0gPp2hlHuhzOUoA84nYzOU3n6J8VotTNkgHFBafbICd3595e2eQ== X-Received: by 2002:a1c:cc14:: with SMTP id h20mr819068wmb.180.1611864344044; Thu, 28 Jan 2021 12:05:44 -0800 (PST) Received: from kali.home (2a01cb0881b76d00c2afd0dfa851d2b9.ipv6.abo.wanadoo.fr. [2a01:cb08:81b7:6d00:c2af:d0df:a851:d2b9]) by smtp.gmail.com with ESMTPSA id k131sm7170628wmb.37.2021.01.28.12.05.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 28 Jan 2021 12:05:43 -0800 (PST) From: Fabrice Fontaine To: buildroot@buildroot.org Date: Thu, 28 Jan 2021 21:04:34 +0100 Message-Id: <20210128200436.4162618-2-fontaine.fabrice@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> References: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> MIME-Version: 1.0 Subject: [Buildroot] [PATCH v2, 2/4] Revert "package/assimp: fix static only build" X-BeenThere: buildroot@busybox.net X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion and development of buildroot List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Peter Seiderer , Samuel Martin , Fabrice Fontaine Errors-To: buildroot-bounces@busybox.net Sender: "buildroot" This reverts commit b44b5cb265e3764169aa4856f40e8e2db55cba22. Signed-off-by: Fabrice Fontaine --- ...lib-disable-dynamic-library-building.patch | 31 ------------------- 1 file changed, 31 deletions(-) delete mode 100644 package/assimp/0003-contrib-zlib-disable-dynamic-library-building.patch diff --git a/package/assimp/0003-contrib-zlib-disable-dynamic-library-building.patch b/package/assimp/0003-contrib-zlib-disable-dynamic-library-building.patch deleted file mode 100644 index 8661311be5..0000000000 --- a/package/assimp/0003-contrib-zlib-disable-dynamic-library-building.patch +++ /dev/null @@ -1,31 +0,0 @@ -From 2b8684aded0c383be64bac0fa59e39870252963f Mon Sep 17 00:00:00 2001 -From: Peter Seiderer -Date: Sun, 12 Apr 2020 18:19:13 +0200 -Subject: [PATCH] contrib/zlib: disable dynamic library building - -Fixes compile failure for static only toolchains (and assimp -links against the static one). - -Signed-off-by: Peter Seiderer ---- - contrib/zlib/CMakeLists.txt | 3 --- - 1 file changed, 3 deletions(-) - -diff --git a/contrib/zlib/CMakeLists.txt b/contrib/zlib/CMakeLists.txt -index 9d1fcc94..78346233 100644 ---- a/contrib/zlib/CMakeLists.txt -+++ b/contrib/zlib/CMakeLists.txt -@@ -195,10 +195,7 @@ if(MINGW) - set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj) - endif(MINGW) - --add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) - add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) --set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL) --set_target_properties(zlib PROPERTIES SOVERSION 1) - - INSTALL( TARGETS zlibstatic - LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR} --- -2.26.0 - From patchwork Thu Jan 28 20:04:35 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fabrice Fontaine X-Patchwork-Id: 1433000 Return-Path: X-Original-To: incoming-buildroot@patchwork.ozlabs.org Delivered-To: patchwork-incoming-buildroot@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=busybox.net (client-ip=140.211.166.138; helo=whitealder.osuosl.org; envelope-from=buildroot-bounces@busybox.net; receiver=) Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=DdIljLQ+; dkim-atps=neutral Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4DRWgs63HBz9sSs for ; Fri, 29 Jan 2021 07:06:17 +1100 (AEDT) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 4B40486D92; Thu, 28 Jan 2021 20:06:16 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ZUY9Zvs82gAm; Thu, 28 Jan 2021 20:05:59 +0000 (UTC) Received: from ash.osuosl.org (ash.osuosl.org [140.211.166.34]) by whitealder.osuosl.org (Postfix) with ESMTP id 25F1C86D91; Thu, 28 Jan 2021 20:05:59 +0000 (UTC) X-Original-To: buildroot@lists.busybox.net Delivered-To: buildroot@osuosl.org Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by ash.osuosl.org (Postfix) with ESMTP id 4C8E41BF3CA for ; Thu, 28 Jan 2021 20:05:58 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 1E2BA2033B for ; Thu, 28 Jan 2021 20:05:58 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id DK6lkgHxZ97F for ; Thu, 28 Jan 2021 20:05:49 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wr1-f54.google.com (mail-wr1-f54.google.com [209.85.221.54]) by silver.osuosl.org (Postfix) with ESMTPS id B669820345 for ; Thu, 28 Jan 2021 20:05:48 +0000 (UTC) Received: by mail-wr1-f54.google.com with SMTP id m13so6661530wro.12 for ; Thu, 28 Jan 2021 12:05:48 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=aIwI/rveGAn75TyLVKkbxosCI9HCyyUshT0DFJK886w=; b=DdIljLQ+vDN1bA51Zr5QJ1Kwa8oLyNnxLkjvhnaPliGbl6fjQBzX0moicM3PZFDRvN zCGkumV06aiHWmgH5KMScdcPrGrqE1Vg4sJRrLPK0Ptc4tNskbu4yXXLbt5b3E8N7d0H tlL8Js8P/TQva4wUKRWi5JNldQr4kWKCTOcmVqWBXx0HfIU3I145nDtPKBzYwmbAzrWs scaHLg4PlcA44CvvCQ7/7JZ/qjbTY8fRVFCoFuSh0BuCMcpG+ws5U38D0/Hdh7rPeUR8 vk9125yWTN3onPHL+kphC9x36PQ7yXNMjuup9tf15VBysJQCXfAnjJiNjJNMUbug+60n h0qg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=aIwI/rveGAn75TyLVKkbxosCI9HCyyUshT0DFJK886w=; b=ZG5nmz8V9swxvugh7PDg1Z+MEIqEvg5O5LrYOdAppNkB8njCkiI37R+LDNIGg1HUYG utGpec/CtOkcoC7kkK6oRT02nvq5f1FoWT45ucJi51x+8k/gi6Re5yXzRef6v0IVbqS1 xWjRl9uWL+LP/1QgUoM5mRfwyrnR5GjmTGmSOUu/cSNsw7PE3P6dSDBRwd42rOXb8GLK idS3IMsCjezRRSOtfBbpveGST8C3yoGGEp/HJQNkGyHCMY+eWdMvrbglWIAtElSM0BER 3G2Rp7yqv5s5Uc6FqBLzgE/dzJTxARPmR1M4uFfiZp0Z8x+kvonLt06dSajm8mPLo5eB dPNQ== X-Gm-Message-State: AOAM531gSz11Rt8zavX0yMCj/CDc28jQxWav5Bot+9EijkSK/EbINYcX GARcAeU8CsBAKQEpb6rAGOAFLnGsgiUjbQ== X-Google-Smtp-Source: ABdhPJyt+Ffy0V0zsHJAEFtkgVFCmZ6JQxBdbvPvkkm1KwKOU3qwIK66BHDoA5+8OmwpBPlrrqM4fg== X-Received: by 2002:a05:6000:1542:: with SMTP id 2mr831868wry.356.1611864345964; Thu, 28 Jan 2021 12:05:45 -0800 (PST) Received: from kali.home (2a01cb0881b76d00c2afd0dfa851d2b9.ipv6.abo.wanadoo.fr. [2a01:cb08:81b7:6d00:c2af:d0df:a851:d2b9]) by smtp.gmail.com with ESMTPSA id k131sm7170628wmb.37.2021.01.28.12.05.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 28 Jan 2021 12:05:45 -0800 (PST) From: Fabrice Fontaine To: buildroot@buildroot.org Date: Thu, 28 Jan 2021 21:04:35 +0100 Message-Id: <20210128200436.4162618-3-fontaine.fabrice@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> References: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> MIME-Version: 1.0 Subject: [Buildroot] [PATCH v2,3/4] package/assimp: fix build on musl X-BeenThere: buildroot@busybox.net X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion and development of buildroot List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Peter Seiderer , Samuel Martin , Fabrice Fontaine Errors-To: buildroot-bounces@busybox.net Sender: "buildroot" Fixes: - http://autobuild.buildroot.net/results/7c2db184ee200d1719308f38f42382bb39d8d5c6 Signed-off-by: Fabrice Fontaine --- ...p-to-fix-gcc-build-for-v9-2-0-32-bit.patch | 1638 +++++++++++++++++ ...oses-2954-upgrade-to-latest-greatest.patch | 243 +++ 2 files changed, 1881 insertions(+) create mode 100644 package/assimp/0002-closes-2733-update-of-zlip-to-fix-gcc-build-for-v9-2-0-32-bit.patch create mode 100644 package/assimp/0003-closes-2954-upgrade-to-latest-greatest.patch diff --git a/package/assimp/0002-closes-2733-update-of-zlip-to-fix-gcc-build-for-v9-2-0-32-bit.patch b/package/assimp/0002-closes-2733-update-of-zlip-to-fix-gcc-build-for-v9-2-0-32-bit.patch new file mode 100644 index 0000000000..4b86cc584f --- /dev/null +++ b/package/assimp/0002-closes-2733-update-of-zlip-to-fix-gcc-build-for-v9-2-0-32-bit.patch @@ -0,0 +1,1638 @@ +From f78446b14aff46db2ef27d062a275b6a01fd68b1 Mon Sep 17 00:00:00 2001 +From: Kim Kulling +Date: Tue, 19 Nov 2019 20:30:40 +0100 +Subject: [PATCH] closes https://github.com/assimp/assimp/issues/2733: update + of zlip to fix gcc build for v9.2.0 32 bit + +[Retrieved (and updated to remove .gitignore and appveyor.yml) from: +https://github.com/assimp/assimp/commit/f78446b14aff46db2ef27d062a275b6a01fd68b1] +Signed-off-by: Fabrice Fontaine +--- + contrib/zip/.gitignore | 2 + + contrib/zip/CMakeLists.txt | 83 +++++- + contrib/zip/README.md | 12 +- + contrib/zip/appveyor.yml | 2 +- + contrib/zip/src/miniz.h | 457 ++++++++++++++++++++++++++++---- + contrib/zip/src/zip.c | 62 +++-- + contrib/zip/src/zip.h | 457 ++++++++++++++++---------------- + contrib/zip/test/CMakeLists.txt | 27 +- + contrib/zip/test/test.c | 38 ++- + contrib/zip/test/test_miniz.c | 25 +- + 10 files changed, 821 insertions(+), 344 deletions(-) + +diff --git a/contrib/zip/CMakeLists.txt b/contrib/zip/CMakeLists.txt +index b46dbb1db0..77916d2e14 100644 +--- a/contrib/zip/CMakeLists.txt ++++ b/contrib/zip/CMakeLists.txt +@@ -1,10 +1,14 @@ +-cmake_minimum_required(VERSION 2.8) +-project(zip) +-enable_language(C) ++cmake_minimum_required(VERSION 3.0) ++ ++project(zip ++ LANGUAGES C ++ VERSION "0.1.15") + set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH}) + ++option(CMAKE_DISABLE_TESTING "Disable test creation" OFF) ++ + if (MSVC) +- # Use secure functions by defaualt and suppress warnings about "deprecated" functions ++ # Use secure functions by default and suppress warnings about "deprecated" functions + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1") +@@ -12,28 +16,80 @@ elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR + "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR + "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror -pedantic") ++ if(ENABLE_COVERAGE) ++ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage") ++ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") ++ endif() + endif (MSVC) + + # zip + set(SRC src/miniz.h src/zip.h src/zip.c) + add_library(${PROJECT_NAME} ${SRC}) +-target_include_directories(${PROJECT_NAME} INTERFACE src) ++target_include_directories(${PROJECT_NAME} PUBLIC ++ $ ++ $ ++) + + # test + if (NOT CMAKE_DISABLE_TESTING) + enable_testing() + add_subdirectory(test) + find_package(Sanitizers) +- add_sanitizers(${PROJECT_NAME} test.exe) +- add_sanitizers(${PROJECT_NAME} test_miniz.exe) ++ add_sanitizers(${PROJECT_NAME} ${test_out} ${test_miniz_out}) + endif() + ++#### ++# Installation (https://github.com/forexample/package-example) { ++ ++set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}") ++set(INCLUDE_INSTALL_DIR "include") ++ ++set(GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated") ++ ++# Configuration ++set(VERSION_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake") ++set(PROJECT_CONFIG "${GENERATED_DIR}/${PROJECT_NAME}Config.cmake") ++set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets") ++set(NAMESPACE "${PROJECT_NAME}::") ++ ++# Include module with fuction 'write_basic_package_version_file' ++include(CMakePackageConfigHelpers) ++ ++# Note: PROJECT_VERSION is used as a VERSION ++write_basic_package_version_file( ++ "${VERSION_CONFIG}" COMPATIBILITY SameMajorVersion ++) ++ ++# Use variables: ++# * TARGETS_EXPORT_NAME ++# * PROJECT_NAME ++configure_package_config_file( ++ "cmake/Config.cmake.in" ++ "${PROJECT_CONFIG}" ++ INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}" ++) ++ ++install( ++ FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}" ++ DESTINATION "${CONFIG_INSTALL_DIR}" ++) ++ ++install( ++ EXPORT "${TARGETS_EXPORT_NAME}" ++ NAMESPACE "${NAMESPACE}" ++ DESTINATION "${CONFIG_INSTALL_DIR}" ++) ++ ++# } ++ + install(TARGETS ${PROJECT_NAME} ++ EXPORT ${TARGETS_EXPORT_NAME} + RUNTIME DESTINATION bin + ARCHIVE DESTINATION lib + LIBRARY DESTINATION lib +- COMPONENT library) +-install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION include) ++ INCLUDES DESTINATION ${INCLUDE_INSTALL_DIR} ++) ++install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION ${INCLUDE_INSTALL_DIR}/zip) + + # uninstall target (https://gitlab.kitware.com/cmake/community/wikis/FAQ#can-i-do-make-uninstall-with-cmake) + if(NOT TARGET uninstall) +@@ -45,3 +101,12 @@ if(NOT TARGET uninstall) + add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake) + endif() ++ ++find_package(Doxygen) ++if(DOXYGEN_FOUND) ++ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY) ++ add_custom_target(doc ++ ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ COMMENT "Generating API documentation with Doxygen" VERBATIM) ++endif() +diff --git a/contrib/zip/README.md b/contrib/zip/README.md +index d5fb8cd203..14eb9a34c8 100644 +--- a/contrib/zip/README.md ++++ b/contrib/zip/README.md +@@ -71,7 +71,7 @@ int arg = 2; + zip_extract("foo.zip", "/tmp", on_extract_entry, &arg); + ``` + +-* Extract a zip entry into memory. ++* Extract a zip entry into memory. + ```c + void *buf = NULL; + size_t bufsize; +@@ -89,7 +89,7 @@ zip_close(zip); + free(buf); + ``` + +-* Extract a zip entry into memory (no internal allocation). ++* Extract a zip entry into memory (no internal allocation). + ```c + unsigned char *buf; + size_t bufsize; +@@ -110,7 +110,7 @@ zip_close(zip); + free(buf); + ``` + +-* Extract a zip entry into memory using callback. ++* Extract a zip entry into memory using callback. + ```c + struct buffer_t { + char *data; +@@ -144,7 +144,7 @@ free(buf.data); + ``` + + +-* Extract a zip entry into a file. ++* Extract a zip entry into a file. + ```c + struct zip_t *zip = zip_open("foo.zip", 0, 'r'); + { +@@ -157,7 +157,7 @@ struct zip_t *zip = zip_open("foo.zip", 0, 'r'); + zip_close(zip); + ``` + +-* List of all zip entries ++* List of all zip entries + ```c + struct zip_t *zip = zip_open("foo.zip", 0, 'r'); + int i, n = zip_total_entries(zip); +@@ -174,7 +174,7 @@ for (i = 0; i < n; ++i) { + zip_close(zip); + ``` + +-## Bindings ++# Bindings + Compile zip library as a dynamic library. + ```shell + $ mkdir build +diff --git a/contrib/zip/src/miniz.h b/contrib/zip/src/miniz.h +index 2c27a94d8d..c4fcfb83e6 100644 +--- a/contrib/zip/src/miniz.h ++++ b/contrib/zip/src/miniz.h +@@ -221,6 +221,7 @@ + #ifndef MINIZ_HEADER_INCLUDED + #define MINIZ_HEADER_INCLUDED + ++#include + #include + + // Defines to completely disable specific portions of miniz.c: +@@ -284,7 +285,8 @@ + /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */ + #if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES) + #if MINIZ_X86_OR_X64_CPU +-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */ ++/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient ++ * integer loads and stores from unaligned addresses. */ + #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1 + #define MINIZ_UNALIGNED_USE_MEMCPY + #else +@@ -354,6 +356,44 @@ enum { + MZ_FIXED = 4 + }; + ++/* miniz error codes. Be sure to update mz_zip_get_error_string() if you add or ++ * modify this enum. */ ++typedef enum { ++ MZ_ZIP_NO_ERROR = 0, ++ MZ_ZIP_UNDEFINED_ERROR, ++ MZ_ZIP_TOO_MANY_FILES, ++ MZ_ZIP_FILE_TOO_LARGE, ++ MZ_ZIP_UNSUPPORTED_METHOD, ++ MZ_ZIP_UNSUPPORTED_ENCRYPTION, ++ MZ_ZIP_UNSUPPORTED_FEATURE, ++ MZ_ZIP_FAILED_FINDING_CENTRAL_DIR, ++ MZ_ZIP_NOT_AN_ARCHIVE, ++ MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, ++ MZ_ZIP_UNSUPPORTED_MULTIDISK, ++ MZ_ZIP_DECOMPRESSION_FAILED, ++ MZ_ZIP_COMPRESSION_FAILED, ++ MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, ++ MZ_ZIP_CRC_CHECK_FAILED, ++ MZ_ZIP_UNSUPPORTED_CDIR_SIZE, ++ MZ_ZIP_ALLOC_FAILED, ++ MZ_ZIP_FILE_OPEN_FAILED, ++ MZ_ZIP_FILE_CREATE_FAILED, ++ MZ_ZIP_FILE_WRITE_FAILED, ++ MZ_ZIP_FILE_READ_FAILED, ++ MZ_ZIP_FILE_CLOSE_FAILED, ++ MZ_ZIP_FILE_SEEK_FAILED, ++ MZ_ZIP_FILE_STAT_FAILED, ++ MZ_ZIP_INVALID_PARAMETER, ++ MZ_ZIP_INVALID_FILENAME, ++ MZ_ZIP_BUF_TOO_SMALL, ++ MZ_ZIP_INTERNAL_ERROR, ++ MZ_ZIP_FILE_NOT_FOUND, ++ MZ_ZIP_ARCHIVE_TOO_LARGE, ++ MZ_ZIP_VALIDATION_FAILED, ++ MZ_ZIP_WRITE_CALLBACK_FAILED, ++ MZ_ZIP_TOTAL_ERRORS ++} mz_zip_error; ++ + // Method + #define MZ_DEFLATED 8 + +@@ -696,6 +736,7 @@ typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, + void *pBuf, size_t n); + typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, + const void *pBuf, size_t n); ++typedef mz_bool (*mz_file_needs_keepalive)(void *pOpaque); + + struct mz_zip_internal_state_tag; + typedef struct mz_zip_internal_state_tag mz_zip_internal_state; +@@ -707,13 +748,27 @@ typedef enum { + MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3 + } mz_zip_mode; + +-typedef struct mz_zip_archive_tag { ++typedef enum { ++ MZ_ZIP_TYPE_INVALID = 0, ++ MZ_ZIP_TYPE_USER, ++ MZ_ZIP_TYPE_MEMORY, ++ MZ_ZIP_TYPE_HEAP, ++ MZ_ZIP_TYPE_FILE, ++ MZ_ZIP_TYPE_CFILE, ++ MZ_ZIP_TOTAL_TYPES ++} mz_zip_type; ++ ++typedef struct { + mz_uint64 m_archive_size; + mz_uint64 m_central_directory_file_ofs; +- mz_uint m_total_files; ++ ++ /* We only support up to UINT32_MAX files in zip64 mode. */ ++ mz_uint32 m_total_files; + mz_zip_mode m_zip_mode; ++ mz_zip_type m_zip_type; ++ mz_zip_error m_last_error; + +- mz_uint m_file_offset_alignment; ++ mz_uint64 m_file_offset_alignment; + + mz_alloc_func m_pAlloc; + mz_free_func m_pFree; +@@ -722,6 +777,7 @@ typedef struct mz_zip_archive_tag { + + mz_file_read_func m_pRead; + mz_file_write_func m_pWrite; ++ mz_file_needs_keepalive m_pNeeds_keepalive; + void *m_pIO_opaque; + + mz_zip_internal_state *m_pState; +@@ -1263,6 +1319,9 @@ mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, + int strategy); + #endif // #ifndef MINIZ_NO_ZLIB_APIS + ++#define MZ_UINT16_MAX (0xFFFFU) ++#define MZ_UINT32_MAX (0xFFFFFFFFU) ++ + #ifdef __cplusplus + } + #endif +@@ -1311,6 +1370,11 @@ typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1]; + ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) + #endif + ++#define MZ_READ_LE64(p) \ ++ (((mz_uint64)MZ_READ_LE32(p)) | \ ++ (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ ++ << 32U)) ++ + #ifdef _MSC_VER + #define MZ_FORCEINLINE __forceinline + #elif defined(__GNUC__) +@@ -4160,6 +4224,17 @@ enum { + MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22, ++ ++ /* ZIP64 archive identifier and record sizes */ ++ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50, ++ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50, ++ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56, ++ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20, ++ MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001, ++ MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50, ++ MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24, ++ MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16, ++ + // Central directory header record offsets + MZ_ZIP_CDH_SIG_OFS = 0, + MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4, +@@ -4199,6 +4274,31 @@ enum { + MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12, + MZ_ZIP_ECDH_CDIR_OFS_OFS = 16, + MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20, ++ ++ /* ZIP64 End of central directory locator offsets */ ++ MZ_ZIP64_ECDL_SIG_OFS = 0, /* 4 bytes */ ++ MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4, /* 4 bytes */ ++ MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8, /* 8 bytes */ ++ MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */ ++ ++ /* ZIP64 End of central directory header offsets */ ++ MZ_ZIP64_ECDH_SIG_OFS = 0, /* 4 bytes */ ++ MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4, /* 8 bytes */ ++ MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12, /* 2 bytes */ ++ MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14, /* 2 bytes */ ++ MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16, /* 4 bytes */ ++ MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20, /* 4 bytes */ ++ MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */ ++ MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32, /* 8 bytes */ ++ MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40, /* 8 bytes */ ++ MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48, /* 8 bytes */ ++ MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0, ++ MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10, ++ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1, ++ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32, ++ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64, ++ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192, ++ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11 + }; + + typedef struct { +@@ -4211,7 +4311,24 @@ struct mz_zip_internal_state_tag { + mz_zip_array m_central_dir; + mz_zip_array m_central_dir_offsets; + mz_zip_array m_sorted_central_dir_offsets; ++ ++ /* The flags passed in when the archive is initially opened. */ ++ uint32_t m_init_flags; ++ ++ /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. ++ */ ++ mz_bool m_zip64; ++ ++ /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64 ++ * will also be slammed to true too, even if we didn't find a zip64 end of ++ * central dir header, etc.) */ ++ mz_bool m_zip64_has_extended_info_fields; ++ ++ /* These fields are used by the file, FILE, memory, and memory/heap read/write ++ * helpers. */ + MZ_FILE *m_pFile; ++ mz_uint64 m_file_archive_start_ofs; ++ + void *m_pMem; + size_t m_mem_size; + size_t m_mem_capacity; +@@ -4363,6 +4480,13 @@ static mz_bool mz_zip_set_file_times(const char *pFilename, time_t access_time, + #endif /* #ifndef MINIZ_NO_STDIO */ + #endif /* #ifndef MINIZ_NO_TIME */ + ++static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, ++ mz_zip_error err_num) { ++ if (pZip) ++ pZip->m_last_error = err_num; ++ return MZ_FALSE; ++} ++ + static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, + mz_uint32 flags) { + (void)flags; +@@ -4480,127 +4604,346 @@ mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) { + } + } + +-static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, +- mz_uint32 flags) { +- mz_uint cdir_size, num_this_disk, cdir_disk_index; +- mz_uint64 cdir_ofs; ++static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, ++ mz_uint32 record_sig, ++ mz_uint32 record_size, ++ mz_int64 *pOfs) { + mz_int64 cur_file_ofs; +- const mz_uint8 *p; + mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; + mz_uint8 *pBuf = (mz_uint8 *)buf_u32; +- mz_bool sort_central_dir = +- ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0); +- // Basic sanity checks - reject files which are too small, and check the first +- // 4 bytes of the file to make sure a local header is there. +- if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) ++ ++ /* Basic sanity checks - reject files which are too small */ ++ if (pZip->m_archive_size < record_size) + return MZ_FALSE; +- // Find the end of central directory record by scanning the file from the end +- // towards the beginning. ++ ++ /* Find the record by scanning the file from the end towards the beginning. */ + cur_file_ofs = + MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0); + for (;;) { + int i, + n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs); ++ + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n) + return MZ_FALSE; +- for (i = n - 4; i >= 0; --i) +- if (MZ_READ_LE32(pBuf + i) == MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) +- break; ++ ++ for (i = n - 4; i >= 0; --i) { ++ mz_uint s = MZ_READ_LE32(pBuf + i); ++ if (s == record_sig) { ++ if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size) ++ break; ++ } ++ } ++ + if (i >= 0) { + cur_file_ofs += i; + break; + } ++ ++ /* Give up if we've searched the entire file, or we've gone back "too far" ++ * (~64kb) */ + if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= +- (0xFFFF + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE))) ++ (MZ_UINT16_MAX + record_size))) + return MZ_FALSE; ++ + cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0); + } +- // Read and verify the end of central directory record. ++ ++ *pOfs = cur_file_ofs; ++ return MZ_TRUE; ++} ++ ++static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, ++ mz_uint flags) { ++ mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, ++ cdir_disk_index = 0; ++ mz_uint64 cdir_ofs = 0; ++ mz_int64 cur_file_ofs = 0; ++ const mz_uint8 *p; ++ ++ mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; ++ mz_uint8 *pBuf = (mz_uint8 *)buf_u32; ++ mz_bool sort_central_dir = ++ ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0); ++ mz_uint32 zip64_end_of_central_dir_locator_u32 ++ [(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / ++ sizeof(mz_uint32)]; ++ mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32; ++ ++ mz_uint32 zip64_end_of_central_dir_header_u32 ++ [(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / ++ sizeof(mz_uint32)]; ++ mz_uint8 *pZip64_end_of_central_dir = ++ (mz_uint8 *)zip64_end_of_central_dir_header_u32; ++ ++ mz_uint64 zip64_end_of_central_dir_ofs = 0; ++ ++ /* Basic sanity checks - reject files which are too small, and check the first ++ * 4 bytes of the file to make sure a local header is there. */ ++ if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) ++ return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); ++ ++ if (!mz_zip_reader_locate_header_sig( ++ pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, ++ MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs)) ++ return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR); ++ ++ /* Read and verify the end of central directory record. */ + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) +- return MZ_FALSE; +- if ((MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != +- MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) || +- ((pZip->m_total_files = +- MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS)) != +- MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS))) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); ++ ++ if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != ++ MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) ++ return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); ++ ++ if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + ++ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) { ++ if (pZip->m_pRead(pZip->m_pIO_opaque, ++ cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, ++ pZip64_locator, ++ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == ++ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) { ++ if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == ++ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) { ++ zip64_end_of_central_dir_ofs = MZ_READ_LE64( ++ pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS); ++ if (zip64_end_of_central_dir_ofs > ++ (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) ++ return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); ++ ++ if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs, ++ pZip64_end_of_central_dir, ++ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == ++ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) { ++ if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) == ++ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) { ++ pZip->m_pState->m_zip64 = MZ_TRUE; ++ } ++ } ++ } ++ } ++ } + ++ pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS); ++ cdir_entries_on_this_disk = ++ MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); + num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS); + cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS); ++ cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS); ++ cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS); ++ ++ if (pZip->m_pState->m_zip64) { ++ mz_uint32 zip64_total_num_of_disks = ++ MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS); ++ mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64( ++ pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS); ++ mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64( ++ pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); ++ mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64( ++ pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS); ++ mz_uint64 zip64_size_of_central_directory = ++ MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS); ++ ++ if (zip64_size_of_end_of_central_dir_record < ++ (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12)) ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ ++ if (zip64_total_num_of_disks != 1U) ++ return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); ++ ++ /* Check for miniz's practical limits */ ++ if (zip64_cdir_total_entries > MZ_UINT32_MAX) ++ return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); ++ ++ pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries; ++ ++ if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX) ++ return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); ++ ++ cdir_entries_on_this_disk = ++ (mz_uint32)zip64_cdir_total_entries_on_this_disk; ++ ++ /* Check for miniz's current practical limits (sorry, this should be enough ++ * for millions of files) */ ++ if (zip64_size_of_central_directory > MZ_UINT32_MAX) ++ return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); ++ ++ cdir_size = (mz_uint32)zip64_size_of_central_directory; ++ ++ num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + ++ MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS); ++ ++ cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + ++ MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS); ++ ++ cdir_ofs = ++ MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS); ++ } ++ ++ if (pZip->m_total_files != cdir_entries_on_this_disk) ++ return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); ++ + if (((num_this_disk | cdir_disk_index) != 0) && + ((num_this_disk != 1) || (cdir_disk_index != 1))) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + +- if ((cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS)) < +- pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) +- return MZ_FALSE; ++ if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + +- cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS); + if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pZip->m_central_directory_file_ofs = cdir_ofs; + + if (pZip->m_total_files) { + mz_uint i, n; +- +- // Read the entire central directory into a heap block, and allocate another +- // heap block to hold the unsorted central dir file record offsets, and +- // another to hold the sorted indices. ++ /* Read the entire central directory into a heap block, and allocate another ++ * heap block to hold the unsorted central dir file record offsets, and ++ * possibly another to hold the sorted indices. */ + if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, + MZ_FALSE)) || + (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, + pZip->m_total_files, MZ_FALSE))) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if (sort_central_dir) { + if (!mz_zip_array_resize(pZip, + &pZip->m_pState->m_sorted_central_dir_offsets, + pZip->m_total_files, MZ_FALSE)) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, + pZip->m_pState->m_central_dir.m_p, + cdir_size) != cdir_size) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + +- // Now create an index into the central directory file records, do some +- // basic sanity checking on each record, and check for zip64 entries (which +- // are not yet supported). ++ /* Now create an index into the central directory file records, do some ++ * basic sanity checking on each record */ + p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p; + for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) { +- mz_uint total_header_size, comp_size, decomp_size, disk_index; ++ mz_uint total_header_size, disk_index, bit_flags, filename_size, ++ ext_data_size; ++ mz_uint64 comp_size, decomp_size, local_header_ofs; ++ + if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || + (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, + i) = + (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p); ++ + if (sort_central_dir) + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, + mz_uint32, i) = i; ++ + comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); + decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); +- if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && +- (decomp_size != comp_size)) || +- (decomp_size && !comp_size) || (decomp_size == 0xFFFFFFFF) || +- (comp_size == 0xFFFFFFFF)) +- return MZ_FALSE; ++ local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); ++ filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); ++ ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); ++ ++ if ((!pZip->m_pState->m_zip64_has_extended_info_fields) && ++ (ext_data_size) && ++ (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == ++ MZ_UINT32_MAX)) { ++ /* Attempt to find zip64 extended information field in the entry's extra ++ * data */ ++ mz_uint32 extra_size_remaining = ext_data_size; ++ ++ if (extra_size_remaining) { ++ const mz_uint8 *pExtra_data; ++ void *buf = NULL; ++ ++ if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > ++ n) { ++ buf = MZ_MALLOC(ext_data_size); ++ if (buf == NULL) ++ return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); ++ ++ if (pZip->m_pRead(pZip->m_pIO_opaque, ++ cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + ++ filename_size, ++ buf, ext_data_size) != ext_data_size) { ++ MZ_FREE(buf); ++ return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); ++ } ++ ++ pExtra_data = (mz_uint8 *)buf; ++ } else { ++ pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size; ++ } ++ ++ do { ++ mz_uint32 field_id; ++ mz_uint32 field_data_size; ++ ++ if (extra_size_remaining < (sizeof(mz_uint16) * 2)) { ++ MZ_FREE(buf); ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ } ++ ++ field_id = MZ_READ_LE16(pExtra_data); ++ field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); ++ ++ if ((field_data_size + sizeof(mz_uint16) * 2) > ++ extra_size_remaining) { ++ MZ_FREE(buf); ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ } ++ ++ if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { ++ /* Ok, the archive didn't have any zip64 headers but it uses a ++ * zip64 extended information field so mark it as zip64 anyway ++ * (this can occur with infozip's zip util when it reads ++ * compresses files from stdin). */ ++ pZip->m_pState->m_zip64 = MZ_TRUE; ++ pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE; ++ break; ++ } ++ ++ pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; ++ extra_size_remaining = ++ extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; ++ } while (extra_size_remaining); ++ ++ MZ_FREE(buf); ++ } ++ } ++ ++ /* I've seen archives that aren't marked as zip64 that uses zip64 ext ++ * data, argh */ ++ if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) { ++ if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && ++ (decomp_size != comp_size)) || ++ (decomp_size && !comp_size)) ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ } ++ + disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS); +- if ((disk_index != num_this_disk) && (disk_index != 1)) +- return MZ_FALSE; +- if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + +- MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size) +- return MZ_FALSE; ++ if ((disk_index == MZ_UINT16_MAX) || ++ ((disk_index != num_this_disk) && (disk_index != 1))) ++ return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); ++ ++ if (comp_size != MZ_UINT32_MAX) { ++ if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + ++ MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size) ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ } ++ ++ bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); ++ if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED) ++ return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); ++ + if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > + n) +- return MZ_FALSE; ++ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); ++ + n -= total_header_size; + p += total_header_size; + } +diff --git a/contrib/zip/src/zip.c b/contrib/zip/src/zip.c +index ff3a8fe1e6..1abcfd8fd1 100644 +--- a/contrib/zip/src/zip.c ++++ b/contrib/zip/src/zip.c +@@ -24,7 +24,6 @@ + ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) && \ + (P)[1] == ':') + #define FILESYSTEM_PREFIX_LEN(P) (HAS_DEVICE(P) ? 2 : 0) +-#define ISSLASH(C) ((C) == '/' || (C) == '\\') + + #else + +@@ -48,7 +47,7 @@ int symlink(const char *target, const char *linkpath); // needed on Linux + #endif + + #ifndef ISSLASH +-#define ISSLASH(C) ((C) == '/') ++#define ISSLASH(C) ((C) == '/' || (C) == '\\') + #endif + + #define CLEANUP(ptr) \ +@@ -78,26 +77,34 @@ static const char *base_name(const char *name) { + return base; + } + +-static int mkpath(const char *path) { +- char const *p; ++static int mkpath(char *path) { ++ char *p; + char npath[MAX_PATH + 1]; + int len = 0; + int has_device = HAS_DEVICE(path); + + memset(npath, 0, MAX_PATH + 1); +- +-#ifdef _WIN32 +- // only on windows fix the path +- npath[0] = path[0]; +- npath[1] = path[1]; +- len = 2; +-#endif // _WIN32 +- ++ if (has_device) { ++ // only on windows ++ npath[0] = path[0]; ++ npath[1] = path[1]; ++ len = 2; ++ } + for (p = path + len; *p && len < MAX_PATH; p++) { + if (ISSLASH(*p) && ((!has_device && len > 0) || (has_device && len > 2))) { +- if (MKDIR(npath) == -1) +- if (errno != EEXIST) ++#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) || \ ++ defined(__MINGW32__) ++#else ++ if ('\\' == *p) { ++ *p = '/'; ++ } ++#endif ++ ++ if (MKDIR(npath) == -1) { ++ if (errno != EEXIST) { + return -1; ++ } ++ } + } + npath[len++] = *p; + } +@@ -279,7 +286,14 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) { + zip->entry.header_offset = zip->archive.m_archive_size; + memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8)); + zip->entry.method = 0; ++ ++ // UNIX or APPLE ++#if MZ_PLATFORM == 3 || MZ_PLATFORM == 19 ++ // regular file with rw-r--r-- persmissions ++ zip->entry.external_attr = (mz_uint32)(0100644) << 16; ++#else + zip->entry.external_attr = 0; ++#endif + + num_alignment_padding_bytes = + mz_zip_writer_compute_padding_needed_for_file_alignment(pzip); +@@ -660,7 +674,7 @@ ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) { + } + + if (!mz_zip_reader_extract_to_mem_no_alloc(pzip, (mz_uint)zip->entry.index, +- buf, bufsize, 0, NULL, 0)) { ++ buf, bufsize, 0, NULL, 0)) { + return -1; + } + +@@ -670,10 +684,7 @@ ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) { + int zip_entry_fread(struct zip_t *zip, const char *filename) { + mz_zip_archive *pzip = NULL; + mz_uint idx; +-#if defined(_MSC_VER) +-#else + mz_uint32 xattr = 0; +-#endif + mz_zip_archive_file_stat info; + + if (!zip) { +@@ -875,12 +886,19 @@ int zip_extract(const char *zipname, const char *dir, + goto out; + } + +- if ((((info.m_version_made_by >> 8) == 3) || ((info.m_version_made_by >> 8) == 19)) // if zip is produced on Unix or macOS (3 and 19 from section 4.4.2.2 of zip standard) +- && info.m_external_attr & (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40 is directory) ++ if ((((info.m_version_made_by >> 8) == 3) || ++ ((info.m_version_made_by >> 8) == ++ 19)) // if zip is produced on Unix or macOS (3 and 19 from ++ // section 4.4.2.2 of zip standard) ++ && info.m_external_attr & ++ (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40 ++ // is directory) + #if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) || \ + defined(__MINGW32__) +-#else +- if (info.m_uncomp_size > MAX_PATH || !mz_zip_reader_extract_to_mem_no_alloc(&zip_archive, i, symlink_to, MAX_PATH, 0, NULL, 0)) { ++#else ++ if (info.m_uncomp_size > MAX_PATH || ++ !mz_zip_reader_extract_to_mem_no_alloc(&zip_archive, i, symlink_to, ++ MAX_PATH, 0, NULL, 0)) { + goto out; + } + symlink_to[info.m_uncomp_size] = '\0'; +diff --git a/contrib/zip/src/zip.h b/contrib/zip/src/zip.h +index 5f39df50ad..a48d64d6de 100644 +--- a/contrib/zip/src/zip.h ++++ b/contrib/zip/src/zip.h +@@ -20,241 +20,240 @@ extern "C" { + #endif + + #if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) && \ +- !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(__ssize_t_defined) +-#define _SSIZE_T ++ !defined(__DEFINED_ssize_t) && !defined(__ssize_t_defined) && \ ++ !defined(_SSIZE_T) && !defined(_SSIZE_T_) ++ + // 64-bit Windows is the only mainstream platform + // where sizeof(long) != sizeof(void*) + #ifdef _WIN64 +-typedef long long ssize_t; /* byte count or error */ ++typedef long long ssize_t; /* byte count or error */ + #else +-typedef long ssize_t; /* byte count or error */ ++typedef long ssize_t; /* byte count or error */ + #endif ++ ++#define _SSIZE_T_DEFINED ++#define _SSIZE_T_DEFINED_ ++#define __DEFINED_ssize_t ++#define __ssize_t_defined ++#define _SSIZE_T ++#define _SSIZE_T_ ++ + #endif + + #ifndef MAX_PATH + #define MAX_PATH 32767 /* # chars in a path name including NULL */ + #endif + ++/** ++ * @mainpage ++ * ++ * Documenation for @ref zip. ++ */ ++ ++/** ++ * @addtogroup zip ++ * @{ ++ */ ++ ++/** ++ * Default zip compression level. ++ */ ++ + #define ZIP_DEFAULT_COMPRESSION_LEVEL 6 + +-/* +- This data structure is used throughout the library to represent zip archive +- - forward declaration. +-*/ ++/** ++ * @struct zip_t ++ * ++ * This data structure is used throughout the library to represent zip archive - ++ * forward declaration. ++ */ + struct zip_t; + +-/* +- Opens zip archive with compression level using the given mode. +- +- Args: +- zipname: zip archive file name. +- level: compression level (0-9 are the standard zlib-style levels). +- mode: file access mode. +- 'r': opens a file for reading/extracting (the file must exists). +- 'w': creates an empty file for writing. +- 'a': appends to an existing archive. +- +- Returns: +- The zip archive handler or NULL on error +-*/ ++/** ++ * Opens zip archive with compression level using the given mode. ++ * ++ * @param zipname zip archive file name. ++ * @param level compression level (0-9 are the standard zlib-style levels). ++ * @param mode file access mode. ++ * - 'r': opens a file for reading/extracting (the file must exists). ++ * - 'w': creates an empty file for writing. ++ * - 'a': appends to an existing archive. ++ * ++ * @return the zip archive handler or NULL on error ++ */ + extern struct zip_t *zip_open(const char *zipname, int level, char mode); + +-/* +- Closes the zip archive, releases resources - always finalize. +- +- Args: +- zip: zip archive handler. +-*/ ++/** ++ * Closes the zip archive, releases resources - always finalize. ++ * ++ * @param zip zip archive handler. ++ */ + extern void zip_close(struct zip_t *zip); + +-/* +- Opens an entry by name in the zip archive. +- For zip archive opened in 'w' or 'a' mode the function will append +- a new entry. In readonly mode the function tries to locate the entry +- in global dictionary. +- +- Args: +- zip: zip archive handler. +- entryname: an entry name in local dictionary. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Opens an entry by name in the zip archive. ++ * ++ * For zip archive opened in 'w' or 'a' mode the function will append ++ * a new entry. In readonly mode the function tries to locate the entry ++ * in global dictionary. ++ * ++ * @param zip zip archive handler. ++ * @param entryname an entry name in local dictionary. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_entry_open(struct zip_t *zip, const char *entryname); + +-/* +- Opens a new entry by index in the zip archive. +- This function is only valid if zip archive was opened in 'r' (readonly) mode. +- +- Args: +- zip: zip archive handler. +- index: index in local dictionary. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Opens a new entry by index in the zip archive. ++ * ++ * This function is only valid if zip archive was opened in 'r' (readonly) mode. ++ * ++ * @param zip zip archive handler. ++ * @param index index in local dictionary. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_entry_openbyindex(struct zip_t *zip, int index); + +-/* +- Closes a zip entry, flushes buffer and releases resources. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Closes a zip entry, flushes buffer and releases resources. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_entry_close(struct zip_t *zip); + +-/* +- Returns a local name of the current zip entry. +- The main difference between user's entry name and local entry name +- is optional relative path. +- Following .ZIP File Format Specification - the path stored MUST not contain +- a drive or device letter, or a leading slash. +- All slashes MUST be forward slashes '/' as opposed to backwards slashes '\' +- for compatibility with Amiga and UNIX file systems etc. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The pointer to the current zip entry name, or NULL on error. +-*/ ++/** ++ * Returns a local name of the current zip entry. ++ * ++ * The main difference between user's entry name and local entry name ++ * is optional relative path. ++ * Following .ZIP File Format Specification - the path stored MUST not contain ++ * a drive or device letter, or a leading slash. ++ * All slashes MUST be forward slashes '/' as opposed to backwards slashes '\' ++ * for compatibility with Amiga and UNIX file systems etc. ++ * ++ * @param zip: zip archive handler. ++ * ++ * @return the pointer to the current zip entry name, or NULL on error. ++ */ + extern const char *zip_entry_name(struct zip_t *zip); + +-/* +- Returns an index of the current zip entry. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The index on success, negative number (< 0) on error. +-*/ ++/** ++ * Returns an index of the current zip entry. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the index on success, negative number (< 0) on error. ++ */ + extern int zip_entry_index(struct zip_t *zip); + +-/* +- Determines if the current zip entry is a directory entry. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The return code - 1 (true), 0 (false), negative number (< 0) on error. +-*/ ++/** ++ * Determines if the current zip entry is a directory entry. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the return code - 1 (true), 0 (false), negative number (< 0) on ++ * error. ++ */ + extern int zip_entry_isdir(struct zip_t *zip); + +-/* +- Returns an uncompressed size of the current zip entry. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The uncompressed size in bytes. +-*/ ++/** ++ * Returns an uncompressed size of the current zip entry. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the uncompressed size in bytes. ++ */ + extern unsigned long long zip_entry_size(struct zip_t *zip); + +-/* +- Returns CRC-32 checksum of the current zip entry. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The CRC-32 checksum. +-*/ ++/** ++ * Returns CRC-32 checksum of the current zip entry. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the CRC-32 checksum. ++ */ + extern unsigned int zip_entry_crc32(struct zip_t *zip); + +-/* +- Compresses an input buffer for the current zip entry. +- +- Args: +- zip: zip archive handler. +- buf: input buffer. +- bufsize: input buffer size (in bytes). +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Compresses an input buffer for the current zip entry. ++ * ++ * @param zip zip archive handler. ++ * @param buf input buffer. ++ * @param bufsize input buffer size (in bytes). ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize); + +-/* +- Compresses a file for the current zip entry. +- +- Args: +- zip: zip archive handler. +- filename: input file. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Compresses a file for the current zip entry. ++ * ++ * @param zip zip archive handler. ++ * @param filename input file. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_entry_fwrite(struct zip_t *zip, const char *filename); + +-/* +- Extracts the current zip entry into output buffer. +- The function allocates sufficient memory for a output buffer. +- +- Args: +- zip: zip archive handler. +- buf: output buffer. +- bufsize: output buffer size (in bytes). +- +- Note: +- - remember to release memory allocated for a output buffer. +- - for large entries, please take a look at zip_entry_extract function. +- +- Returns: +- The return code - the number of bytes actually read on success. +- Otherwise a -1 on error. +-*/ ++/** ++ * Extracts the current zip entry into output buffer. ++ * ++ * The function allocates sufficient memory for a output buffer. ++ * ++ * @param zip zip archive handler. ++ * @param buf output buffer. ++ * @param bufsize output buffer size (in bytes). ++ * ++ * @note remember to release memory allocated for a output buffer. ++ * for large entries, please take a look at zip_entry_extract function. ++ * ++ * @return the return code - the number of bytes actually read on success. ++ * Otherwise a -1 on error. ++ */ + extern ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize); + +-/* +- Extracts the current zip entry into a memory buffer using no memory +- allocation. +- +- Args: +- zip: zip archive handler. +- buf: preallocated output buffer. +- bufsize: output buffer size (in bytes). +- +- Note: +- - ensure supplied output buffer is large enough. +- - zip_entry_size function (returns uncompressed size for the current entry) +- can be handy to estimate how big buffer is needed. +- - for large entries, please take a look at zip_entry_extract function. +- +- Returns: +- The return code - the number of bytes actually read on success. +- Otherwise a -1 on error (e.g. bufsize is not large enough). +-*/ +-extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize); +- +-/* +- Extracts the current zip entry into output file. +- +- Args: +- zip: zip archive handler. +- filename: output file. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Extracts the current zip entry into a memory buffer using no memory ++ * allocation. ++ * ++ * @param zip zip archive handler. ++ * @param buf preallocated output buffer. ++ * @param bufsize output buffer size (in bytes). ++ * ++ * @note ensure supplied output buffer is large enough. ++ * zip_entry_size function (returns uncompressed size for the current ++ * entry) can be handy to estimate how big buffer is needed. for large ++ * entries, please take a look at zip_entry_extract function. ++ * ++ * @return the return code - the number of bytes actually read on success. ++ * Otherwise a -1 on error (e.g. bufsize is not large enough). ++ */ ++extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, ++ size_t bufsize); ++ ++/** ++ * Extracts the current zip entry into output file. ++ * ++ * @param zip zip archive handler. ++ * @param filename output file. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_entry_fread(struct zip_t *zip, const char *filename); + +-/* +- Extracts the current zip entry using a callback function (on_extract). +- +- Args: +- zip: zip archive handler. +- on_extract: callback function. +- arg: opaque pointer (optional argument, +- which you can pass to the on_extract callback) +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. ++/** ++ * Extracts the current zip entry using a callback function (on_extract). ++ * ++ * @param zip zip archive handler. ++ * @param on_extract callback function. ++ * @param arg opaque pointer (optional argument, which you can pass to the ++ * on_extract callback) ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. + */ + extern int + zip_entry_extract(struct zip_t *zip, +@@ -262,53 +261,49 @@ zip_entry_extract(struct zip_t *zip, + const void *data, size_t size), + void *arg); + +-/* +- Returns the number of all entries (files and directories) in the zip archive. +- +- Args: +- zip: zip archive handler. +- +- Returns: +- The return code - the number of entries on success, +- negative number (< 0) on error. +-*/ ++/** ++ * Returns the number of all entries (files and directories) in the zip archive. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the return code - the number of entries on success, negative number ++ * (< 0) on error. ++ */ + extern int zip_total_entries(struct zip_t *zip); + +-/* +- Creates a new archive and puts files into a single zip archive. +- +- Args: +- zipname: zip archive file. +- filenames: input files. +- len: number of input files. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Creates a new archive and puts files into a single zip archive. ++ * ++ * @param zipname zip archive file. ++ * @param filenames input files. ++ * @param len: number of input files. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_create(const char *zipname, const char *filenames[], size_t len); + +-/* +- Extracts a zip archive file into directory. +- +- If on_extract_entry is not NULL, the callback will be called after +- successfully extracted each zip entry. +- Returning a negative value from the callback will cause abort and return an +- error. The last argument (void *arg) is optional, which you can use to pass +- data to the on_extract_entry callback. +- +- Args: +- zipname: zip archive file. +- dir: output directory. +- on_extract_entry: on extract callback. +- arg: opaque pointer. +- +- Returns: +- The return code - 0 on success, negative number (< 0) on error. +-*/ ++/** ++ * Extracts a zip archive file into directory. ++ * ++ * If on_extract_entry is not NULL, the callback will be called after ++ * successfully extracted each zip entry. ++ * Returning a negative value from the callback will cause abort and return an ++ * error. The last argument (void *arg) is optional, which you can use to pass ++ * data to the on_extract_entry callback. ++ * ++ * @param zipname zip archive file. ++ * @param dir output directory. ++ * @param on_extract_entry on extract callback. ++ * @param arg opaque pointer. ++ * ++ * @return the return code - 0 on success, negative number (< 0) on error. ++ */ + extern int zip_extract(const char *zipname, const char *dir, + int (*on_extract_entry)(const char *filename, void *arg), + void *arg); + ++/** @} */ ++ + #ifdef __cplusplus + } + #endif +diff --git a/contrib/zip/test/CMakeLists.txt b/contrib/zip/test/CMakeLists.txt +index 9b2a8db106..cc060b00fe 100644 +--- a/contrib/zip/test/CMakeLists.txt ++++ b/contrib/zip/test/CMakeLists.txt +@@ -1,19 +1,16 @@ + cmake_minimum_required(VERSION 2.8) + +-if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang") +- if(ENABLE_COVERAGE) +- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g ") +- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0") +- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs") +- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage") +- set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") +- endif() +-endif () +- + # test +-include_directories(../src) +-add_executable(test.exe test.c ../src/zip.c) +-add_executable(test_miniz.exe test_miniz.c) ++set(test_out test.out) ++set(test_miniz_out test_miniz.out) ++ ++add_executable(${test_out} test.c) ++target_link_libraries(${test_out} zip) ++add_executable(${test_miniz_out} test_miniz.c) ++target_link_libraries(${test_miniz_out} zip) ++ ++add_test(NAME ${test_out} COMMAND ${test_out}) ++add_test(NAME ${test_miniz_out} COMMAND ${test_miniz_out}) + +-add_test(NAME test COMMAND test.exe) +-add_test(NAME test_miniz COMMAND test_miniz.exe) ++set(test_out ${test_out} PARENT_SCOPE) ++set(test_miniz_out ${test_miniz_out} PARENT_SCOPE) +diff --git a/contrib/zip/test/test.c b/contrib/zip/test/test.c +index 454430533a..a9b2ddab1e 100644 +--- a/contrib/zip/test/test.c ++++ b/contrib/zip/test/test.c +@@ -29,6 +29,8 @@ + #define XFILE "7.txt\0" + #define XMODE 0100777 + ++#define UNIXMODE 0100644 ++ + #define UNUSED(x) (void)x + + static int total_entries = 0; +@@ -102,7 +104,8 @@ static void test_read(void) { + assert(0 == zip_entry_close(zip)); + free(buf); + buf = NULL; +- ++ bufsize = 0; ++ + assert(0 == zip_entry_open(zip, "test/test-2.txt")); + assert(strlen(TESTDATA2) == zip_entry_size(zip)); + assert(CRC32DATA2 == zip_entry_crc32(zip)); +@@ -131,7 +134,8 @@ static void test_read(void) { + assert(0 == zip_entry_close(zip)); + free(buf); + buf = NULL; +- ++ bufsize = 0; ++ + buftmp = strlen(TESTDATA1); + buf = calloc(buftmp, sizeof(char)); + assert(0 == zip_entry_open(zip, "test/test-1.txt")); +@@ -433,6 +437,35 @@ static void test_mtime(void) { + remove(ZIPNAME); + } + ++static void test_unix_permissions(void) { ++#if defined(_WIN64) || defined(_WIN32) || defined(__WIN32__) ++#else ++ // UNIX or APPLE ++ struct MZ_FILE_STAT_STRUCT file_stats; ++ ++ remove(ZIPNAME); ++ ++ struct zip_t *zip = zip_open(ZIPNAME, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w'); ++ assert(zip != NULL); ++ ++ assert(0 == zip_entry_open(zip, RFILE)); ++ assert(0 == zip_entry_write(zip, TESTDATA1, strlen(TESTDATA1))); ++ assert(0 == zip_entry_close(zip)); ++ ++ zip_close(zip); ++ ++ remove(RFILE); ++ ++ assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL)); ++ ++ assert(0 == MZ_FILE_STAT(RFILE, &file_stats)); ++ assert(UNIXMODE == file_stats.st_mode); ++ ++ remove(RFILE); ++ remove(ZIPNAME); ++#endif ++} ++ + int main(int argc, char *argv[]) { + UNUSED(argc); + UNUSED(argv); +@@ -453,6 +486,7 @@ int main(int argc, char *argv[]) { + test_write_permissions(); + test_exe_permissions(); + test_mtime(); ++ test_unix_permissions(); + + remove(ZIPNAME); + return 0; +diff --git a/contrib/zip/test/test_miniz.c b/contrib/zip/test/test_miniz.c +index ebc0564dc3..babcaecdb6 100644 +--- a/contrib/zip/test/test_miniz.c ++++ b/contrib/zip/test/test_miniz.c +@@ -23,16 +23,39 @@ int main(int argc, char *argv[]) { + uint step = 0; + int cmp_status; + uLong src_len = (uLong)strlen(s_pStr); +- uLong cmp_len = compressBound(src_len); + uLong uncomp_len = src_len; ++ uLong cmp_len; + uint8 *pCmp, *pUncomp; ++ size_t sz; + uint total_succeeded = 0; + (void)argc, (void)argv; + + printf("miniz.c version: %s\n", MZ_VERSION); + + do { ++ pCmp = (uint8 *)tdefl_compress_mem_to_heap(s_pStr, src_len, &cmp_len, 0); ++ if (!pCmp) { ++ printf("tdefl_compress_mem_to_heap failed\n"); ++ return EXIT_FAILURE; ++ } ++ if (src_len <= cmp_len) { ++ printf("tdefl_compress_mem_to_heap failed: from %u to %u bytes\n", ++ (mz_uint32)uncomp_len, (mz_uint32)cmp_len); ++ free(pCmp); ++ return EXIT_FAILURE; ++ } ++ ++ sz = tdefl_compress_mem_to_mem(pCmp, cmp_len, s_pStr, src_len, 0); ++ if (sz != cmp_len) { ++ printf("tdefl_compress_mem_to_mem failed: expected %u, got %u\n", ++ (mz_uint32)cmp_len, (mz_uint32)sz); ++ free(pCmp); ++ return EXIT_FAILURE; ++ } ++ + // Allocate buffers to hold compressed and uncompressed data. ++ free(pCmp); ++ cmp_len = compressBound(src_len); + pCmp = (mz_uint8 *)malloc((size_t)cmp_len); + pUncomp = (mz_uint8 *)malloc((size_t)src_len); + if ((!pCmp) || (!pUncomp)) { diff --git a/package/assimp/0003-closes-2954-upgrade-to-latest-greatest.patch b/package/assimp/0003-closes-2954-upgrade-to-latest-greatest.patch new file mode 100644 index 0000000000..9bd24630c5 --- /dev/null +++ b/package/assimp/0003-closes-2954-upgrade-to-latest-greatest.patch @@ -0,0 +1,243 @@ +From bb3db0ebaffc6b76de256e597ec1d1e4d2a6663f Mon Sep 17 00:00:00 2001 +From: kimkulling +Date: Mon, 9 Mar 2020 10:51:26 +0100 +Subject: [PATCH] closes https://github.com/assimp/assimp/issues/2954: upgrade + to latest greatest. + +[Retrieved from: +https://github.com/assimp/assimp/commit/bb3db0ebaffc6b76de256e597ec1d1e4d2a6663f] +Signed-off-by: Fabrice Fontaine +--- + contrib/zip/CMakeLists.txt | 8 ++---- + contrib/zip/README.md | 51 +++++++++++++++++++++++++++++++-- + contrib/zip/src/zip.c | 17 ++++++++++- + contrib/zip/src/zip.h | 13 ++++++++- + contrib/zip/test/CMakeLists.txt | 5 ---- + contrib/zip/test/test.c | 4 ++- + 6 files changed, 81 insertions(+), 17 deletions(-) + +diff --git a/contrib/zip/CMakeLists.txt b/contrib/zip/CMakeLists.txt +index 77916d2e14..f194649ede 100644 +--- a/contrib/zip/CMakeLists.txt ++++ b/contrib/zip/CMakeLists.txt +@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.0) + + project(zip + LANGUAGES C +- VERSION "0.1.15") ++ VERSION "0.1.18") + set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH}) + + option(CMAKE_DISABLE_TESTING "Disable test creation" OFF) +@@ -16,10 +16,6 @@ elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR + "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR + "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror -pedantic") +- if(ENABLE_COVERAGE) +- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage") +- set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") +- endif() + endif (MSVC) + + # zip +@@ -35,7 +31,7 @@ if (NOT CMAKE_DISABLE_TESTING) + enable_testing() + add_subdirectory(test) + find_package(Sanitizers) +- add_sanitizers(${PROJECT_NAME} ${test_out} ${test_miniz_out}) ++ add_sanitizers(${PROJECT_NAME} ${test_out}) + endif() + + #### +diff --git a/contrib/zip/README.md b/contrib/zip/README.md +index 14eb9a34c8..bdd0822b67 100644 +--- a/contrib/zip/README.md ++++ b/contrib/zip/README.md +@@ -1,10 +1,8 @@ + ### A portable (OSX/Linux/Windows), simple zip library written in C + This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API. + +-[![Windows](https://ci.appveyor.com/api/projects/status/bph8dr3jacgmjv32/branch/master?svg=true&label=windows)](https://ci.appveyor.com/project/kuba--/zip) +-[![Linux](https://travis-ci.org/kuba--/zip.svg?branch=master&label=linux%2fosx)](https://travis-ci.org/kuba--/zip) ++[![Build](https://github.com/kuba--/zip/workflows/build/badge.svg)](https://github.com/kuba--/zip/actions?query=workflow%3Abuild) + [![Version](https://badge.fury.io/gh/kuba--%2Fzip.svg)](https://github.com/kuba--/zip/releases) +-[![Codecov](https://codecov.io/gh/kuba--/zip/branch/master/graph/badge.svg)](https://codecov.io/gh/kuba--/zip) + + + # The Idea +@@ -213,6 +211,53 @@ func main() { + } + ``` + ++### Rust (ffi) ++```rust ++extern crate libc; ++use std::ffi::CString; ++ ++#[repr(C)] ++pub struct Zip { ++ _private: [u8; 0], ++} ++ ++#[link(name = "zip")] ++extern "C" { ++ fn zip_open(path: *const libc::c_char, level: libc::c_int, mode: libc::c_char) -> *mut Zip; ++ fn zip_close(zip: *mut Zip) -> libc::c_void; ++ ++ fn zip_entry_open(zip: *mut Zip, entryname: *const libc::c_char) -> libc::c_int; ++ fn zip_entry_close(zip: *mut Zip) -> libc::c_int; ++ fn zip_entry_write( ++ zip: *mut Zip, ++ buf: *const libc::c_void, ++ bufsize: libc::size_t, ++ ) -> libc::c_int; ++} ++ ++fn main() { ++ let path = CString::new("/tmp/test.zip").unwrap(); ++ let mode: libc::c_char = 'w' as libc::c_char; ++ ++ let entryname = CString::new("test.txt").unwrap(); ++ let content = "test content\0"; ++ ++ unsafe { ++ let zip: *mut Zip = zip_open(path.as_ptr(), 5, mode); ++ { ++ zip_entry_open(zip, entryname.as_ptr()); ++ { ++ let buf = content.as_ptr() as *const libc::c_void; ++ let bufsize = content.len() as libc::size_t; ++ zip_entry_write(zip, buf, bufsize); ++ } ++ zip_entry_close(zip); ++ } ++ zip_close(zip); ++ } ++} ++``` ++ + ### Ruby (ffi) + Install _ffi_ gem. + ```shell +diff --git a/contrib/zip/src/zip.c b/contrib/zip/src/zip.c +index 1abcfd8fd1..3b2821e6a3 100644 +--- a/contrib/zip/src/zip.c ++++ b/contrib/zip/src/zip.c +@@ -222,6 +222,20 @@ void zip_close(struct zip_t *zip) { + } + } + ++int zip_is64(struct zip_t *zip) { ++ if (!zip) { ++ // zip_t handler is not initialized ++ return -1; ++ } ++ ++ if (!zip->archive.m_pState) { ++ // zip state is not initialized ++ return -1; ++ } ++ ++ return (int)zip->archive.m_pState->m_zip64; ++} ++ + int zip_entry_open(struct zip_t *zip, const char *entryname) { + size_t entrylen = 0; + mz_zip_archive *pzip = NULL; +@@ -794,7 +808,8 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) { + + if (MZ_FILE_STAT(name, &file_stat) != 0) { + // problem getting information - check errno +- return -1; ++ status = -1; ++ break; + } + + if ((file_stat.st_mode & 0200) == 0) { +diff --git a/contrib/zip/src/zip.h b/contrib/zip/src/zip.h +index a48d64d6de..cd3ab5cd00 100644 +--- a/contrib/zip/src/zip.h ++++ b/contrib/zip/src/zip.h +@@ -21,7 +21,7 @@ extern "C" { + + #if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) && \ + !defined(__DEFINED_ssize_t) && !defined(__ssize_t_defined) && \ +- !defined(_SSIZE_T) && !defined(_SSIZE_T_) ++ !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(_SSIZE_T_DECLARED) + + // 64-bit Windows is the only mainstream platform + // where sizeof(long) != sizeof(void*) +@@ -37,6 +37,7 @@ typedef long ssize_t; /* byte count or error */ + #define __ssize_t_defined + #define _SSIZE_T + #define _SSIZE_T_ ++#define _SSIZE_T_DECLARED + + #endif + +@@ -90,6 +91,16 @@ extern struct zip_t *zip_open(const char *zipname, int level, char mode); + */ + extern void zip_close(struct zip_t *zip); + ++/** ++ * Determines if the archive has a zip64 end of central directory headers. ++ * ++ * @param zip zip archive handler. ++ * ++ * @return the return code - 1 (true), 0 (false), negative number (< 0) on ++ * error. ++ */ ++extern int zip_is64(struct zip_t *zip); ++ + /** + * Opens an entry by name in the zip archive. + * +diff --git a/contrib/zip/test/CMakeLists.txt b/contrib/zip/test/CMakeLists.txt +index cc060b00fe..1224115858 100644 +--- a/contrib/zip/test/CMakeLists.txt ++++ b/contrib/zip/test/CMakeLists.txt +@@ -2,15 +2,10 @@ cmake_minimum_required(VERSION 2.8) + + # test + set(test_out test.out) +-set(test_miniz_out test_miniz.out) + + add_executable(${test_out} test.c) + target_link_libraries(${test_out} zip) +-add_executable(${test_miniz_out} test_miniz.c) +-target_link_libraries(${test_miniz_out} zip) + + add_test(NAME ${test_out} COMMAND ${test_out}) +-add_test(NAME ${test_miniz_out} COMMAND ${test_miniz_out}) + + set(test_out ${test_out} PARENT_SCOPE) +-set(test_miniz_out ${test_miniz_out} PARENT_SCOPE) +diff --git a/contrib/zip/test/test.c b/contrib/zip/test/test.c +index a9b2ddab1e..9cc2248ac0 100644 +--- a/contrib/zip/test/test.c ++++ b/contrib/zip/test/test.c +@@ -47,7 +47,7 @@ static void test_write(void) { + assert(CRC32DATA1 == zip_entry_crc32(zip)); + ++total_entries; + assert(0 == zip_entry_close(zip)); +- ++ assert(0 == zip_is64(zip)); + zip_close(zip); + } + +@@ -92,6 +92,7 @@ static void test_read(void) { + size_t buftmp; + struct zip_t *zip = zip_open(ZIPNAME, 0, 'r'); + assert(zip != NULL); ++ assert(0 == zip_is64(zip)); + + assert(0 == zip_entry_open(zip, "test\\test-1.txt")); + assert(strlen(TESTDATA1) == zip_entry_size(zip)); +@@ -310,6 +311,7 @@ static void test_fwrite(void) { + assert(0 == zip_entry_open(zip, WFILE)); + assert(0 == zip_entry_fwrite(zip, WFILE)); + assert(0 == zip_entry_close(zip)); ++ assert(0 == zip_is64(zip)); + + zip_close(zip); + remove(WFILE); From patchwork Thu Jan 28 20:04:36 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Fabrice Fontaine X-Patchwork-Id: 1432999 Return-Path: X-Original-To: incoming-buildroot@patchwork.ozlabs.org Delivered-To: patchwork-incoming-buildroot@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=busybox.net (client-ip=140.211.166.137; helo=fraxinus.osuosl.org; envelope-from=buildroot-bounces@busybox.net; receiver=) Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=VBzMEL33; dkim-atps=neutral Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4DRWgV6jSLz9sWP for ; Fri, 29 Jan 2021 07:05:58 +1100 (AEDT) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 6216C86910; Thu, 28 Jan 2021 20:05:57 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id X77-ooFDdaBS; Thu, 28 Jan 2021 20:05:54 +0000 (UTC) Received: from ash.osuosl.org (ash.osuosl.org [140.211.166.34]) by fraxinus.osuosl.org (Postfix) with ESMTP id 14299868B6; Thu, 28 Jan 2021 20:05:54 +0000 (UTC) X-Original-To: buildroot@lists.busybox.net Delivered-To: buildroot@osuosl.org Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by ash.osuosl.org (Postfix) with ESMTP id D71221BF3CA for ; Thu, 28 Jan 2021 20:05:52 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id D371D86E15 for ; Thu, 28 Jan 2021 20:05:52 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id tIkDEILBvHE6 for ; Thu, 28 Jan 2021 20:05:51 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wr1-f52.google.com (mail-wr1-f52.google.com [209.85.221.52]) by whitealder.osuosl.org (Postfix) with ESMTPS id 0392786E4F for ; Thu, 28 Jan 2021 20:05:49 +0000 (UTC) Received: by mail-wr1-f52.google.com with SMTP id a1so6691265wrq.6 for ; Thu, 28 Jan 2021 12:05:48 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=6UPakNsYtFK3QZ3GPEUrA0TSADIduBOJb23dvZlbTeM=; b=VBzMEL33rkjyD3a2W29xZmsdsqA7I7vSSr/U3KlGD8O2pWCe9ucLXYLgVI+ZQ5kft+ zhjotgg6gLpqxOtpsqxBJlnf8q91kWft8yVkgtetf5mXMrHo7hQDzgRB6BcG3S3YY2ng 3HRj+byb9yo3bSLQRdpi3jF5kLiTwfNbwy1OkbNVsqj3lvEA9Fl+koEoNN0HQRqJcb0a rZQsb8uBnc0tBfJYYdu9ALUrC4KsUszE5UWrJWfs9DIomDsI+UPAO8hDm7k4dNCQR4p6 uCDtn9tVpyLbfItyp7ss+B+ITUAAYG8sgQSCob/sSKEeSllfTrrJtfYCa1YYNcdRjOGO 3vSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=6UPakNsYtFK3QZ3GPEUrA0TSADIduBOJb23dvZlbTeM=; b=H57/6oSdetMVF2GOQq+TuxALSrPZ4SVURx8IpDdXaoBlhLmLzfdkKamXuXoiOPorwk Iy6Dt0YE2fLO4BDpsCjMBLNAeoVujXbjgQhS1VrsFS2vvxogcJT93+Cz229R0L4VuYzB sfSAX/+/Ki7qn6DZSsnKTtseweARm2MpBp4MyWuPBNu+pqoi4voXHwVGBTj/5uAf7atZ GYATBa3bYvhNSWYbzjjE/AaeDAeAgNJhobOxw0DHXTHkjCmNTnwqH2PBV/1ZAw/N5eFa 6M6FjB8aoyCoffWEnOICqsA8x2IiAuY0JUKvNvl4q75nM5FdxWBOOEvh9uW3TCKPR7g7 5A2A== X-Gm-Message-State: AOAM5319I3pvB7Ravx188HntX5vI20Q4HKqKgwgKnieNQ3c97gEM3RDx 6ft5d2nWT7dcOyjwDPmXamnYSsM3h29R+g== X-Google-Smtp-Source: ABdhPJypD0//FZc6vVPJhznfl2KHpkLqrPYgGoLMQYiIA8anUEDOZNgRw0cuHtICai/LjZODiSPtIw== X-Received: by 2002:adf:f009:: with SMTP id j9mr800834wro.35.1611864347244; Thu, 28 Jan 2021 12:05:47 -0800 (PST) Received: from kali.home (2a01cb0881b76d00c2afd0dfa851d2b9.ipv6.abo.wanadoo.fr. [2a01:cb08:81b7:6d00:c2af:d0df:a851:d2b9]) by smtp.gmail.com with ESMTPSA id k131sm7170628wmb.37.2021.01.28.12.05.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 28 Jan 2021 12:05:46 -0800 (PST) From: Fabrice Fontaine To: buildroot@buildroot.org Date: Thu, 28 Jan 2021 21:04:36 +0100 Message-Id: <20210128200436.4162618-4-fontaine.fabrice@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> References: <20210128200436.4162618-1-fontaine.fabrice@gmail.com> MIME-Version: 1.0 Subject: [Buildroot] [PATCH v2,4/4] package/assimp: depends on libzlib X-BeenThere: buildroot@busybox.net X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion and development of buildroot List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Peter Seiderer , Samuel Martin , Fabrice Fontaine Errors-To: buildroot-bounces@busybox.net Sender: "buildroot" assimp doesn't build with zlib-ng because Z_EXPORT and z_crc_t are used by the bundled unzip source code Signed-off-by: Fabrice Fontaine --- package/assimp/Config.in | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/package/assimp/Config.in b/package/assimp/Config.in index 42bfee945d..c535240efc 100644 --- a/package/assimp/Config.in +++ b/package/assimp/Config.in @@ -2,7 +2,7 @@ config BR2_PACKAGE_ASSIMP bool "assimp" depends on BR2_INSTALL_LIBSTDCPP depends on BR2_USE_WCHAR - select BR2_PACKAGE_ZLIB + depends on BR2_PACKAGE_LIBZLIB help Open Asset Import Library (assimp) is a portable Open Source library to import various well-known 3D model formats in a @@ -13,4 +13,8 @@ config BR2_PACKAGE_ASSIMP http://www.assimp.org comment "assimp needs a toolchain w/ C++, wchar" + depends on BR2_PACKAGE_LIBZLIB depends on !BR2_INSTALL_LIBSTDCPP || !BR2_USE_WCHAR + +comment "assimp needs libzlib" + depends on !BR2_PACKAGE_LIBZLIB