From patchwork Mon Aug 10 04:52:50 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gavini, Sumanth" X-Patchwork-Id: 94839 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3B189C5AD4E for ; Mon, 10 Aug 2026 04:53:22 +0000 (UTC) Received: from mx0a-0064b401.pphosted.com (mx0a-0064b401.pphosted.com [205.220.166.238]) by mx.groups.io with SMTP id smtpd.msgproc02-g2.23023.1786337596197096000 for ; Sun, 09 Aug 2026 21:53:16 -0700 Authentication-Results: mx.groups.io; dkim=pass header.i=@windriver.com header.s=PPS06212021 header.b=bN7E78BU; spf=permerror, err=parse error for token &{10 18 %{ir}.%{v}.%{d}.spf.has.pphosted.com}: invalid domain name (domain: windriver.com, ip: 205.220.166.238, mailfrom: prvs=26826cd257=sumanth.gavini@windriver.com) Received: from pps.filterd (m0250810.ppops.net [127.0.0.1]) by mx0a-0064b401.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 67A4iwHN1002694 for ; Sun, 9 Aug 2026 21:53:15 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=windriver.com; h=cc:content-transfer-encoding:content-type:date:from :in-reply-to:message-id:mime-version:references:subject:to; s= PPS06212021; bh=x9cpNuI3VIdkbqqHYyIsM4KilmKYjbFbzEUOAFAz9CI=; b= bN7E78BUnbjW40bUeGIGticXtOHT+oByO+4mIPpgOXQ9g1Umt4ynn/6ID5NMcZkY P+uxuzsJsq/DkPuN7y+2ZiJrwZG6uESOU50nxoLXZfbRg6VfxEAGspGjPipBoRJU rm+Ktgm5/T/4aWhh0PcblXAt0G9cYPqO0tuil8RLzekShG8jUgYytRn3Q3JQEI9A TGJxUnjEKTrftLd+azk7Gz02jPQ5UmAPWgzd34xSdXO+ShAPKpVY4l558LDRe3/H 1qsgvQ+ibHr29vnHJpSELd2kPdB/I/965Ypme1Ig9v6vw+mOVbST3tNlJnPgHgrK S7Oae4b22im/Rw1a2ERfOA== Received: from bn1pr04cu002.outbound.protection.outlook.com (mail-eastus2azon11010012.outbound.protection.outlook.com [52.101.56.12]) by mx0a-0064b401.pphosted.com (PPS) with ESMTPS id 4fwyr1smpc-2 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Sun, 09 Aug 2026 21:53:15 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=EuP2+abyIC9/QsBk/HABdqFFd5B0bBhPbPLHt6EH73CC+I/VwUY7X7Q1fa4e6zs/QMq3ePXFNpg+GkNS67v/pn96H8AWv3vtUZdEMRKxc7chIw1xNQHC3kfgmfGCBIWP8v8qmo0YXXqQBFDknVedZHguWr6XLBJU5HPWQ3ji6ZIiudY89/WPcv4Cc6FifK1NQ8deylGLTLwCJXgjJvv9vTLFI2hCjKcxOz0sVx37fDwjh5pycflmiQaCPrEHmvIxfWMRMjNaaS6l/d8vANdU5Le096eKLwvuaDtsRcq8/L9u/KCQCa6rrg2ayhiycYp1BkLvRxLoO01Fo4xhW5ytHw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=x9cpNuI3VIdkbqqHYyIsM4KilmKYjbFbzEUOAFAz9CI=; b=bJr5Ey5WKL+KLwJcm9t/ModXUmPhYB/JhjtFDUE1mlt79h5g1LRYnovBnYbqF0xG7WAtyszapT53ksssKpajE4eCy10I0a0Tj0C+DZPuyQockbAFJMdOinZw470sRcFsQVf8t3Vmbc76E03gVnU7ZJxeGRSWgpjZ5yB4QrDTkgdM7L3lhSl8+ARTxSmHBiE380hirRu09E8fDFolLKVJTFdnjdxNz9TtXgoFqIafkbABip6nJZ5fk37cXknQ/zmfbQdAjKBTijTy4Y1C3oMyA7VWnU1mCv2Cn9C/rtlxqxRWCtUUY/XBFUemEMyuQTCOjtXNtPzfc9UhhKGoQuYCWA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=windriver.com; dmarc=pass action=none header.from=windriver.com; dkim=pass header.d=windriver.com; arc=none Received: from IA3PR11MB9256.namprd11.prod.outlook.com (2603:10b6:208:57f::21) by PH7PR11MB7595.namprd11.prod.outlook.com (2603:10b6:510:27a::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.292.25; Mon, 10 Aug 2026 04:53:13 +0000 Received: from IA3PR11MB9256.namprd11.prod.outlook.com ([fe80::8355:9462:c4fe:5a23]) by IA3PR11MB9256.namprd11.prod.outlook.com ([fe80::8355:9462:c4fe:5a23%4]) with mapi id 15.21.0270.016; Mon, 10 Aug 2026 04:53:12 +0000 From: Sumanth Gavini To: openembedded-core@lists.openembedded.org Cc: alex.kanavin@gmail.com, mathieu.dubois-briand@bootlin.com, mattware@cisco.com, esparlin@cisco.com, peter.marko@siemens.com, randy.macleod@windriver.com Subject: [PATCH v13 10/10] libarchive: Add RPM format reader to support rpm 6 Date: Sun, 9 Aug 2026 21:52:50 -0700 Message-ID: <20260810045250.3903576-11-sumanth.gavini@windriver.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20260810045250.3903576-1-sumanth.gavini@windriver.com> References: <20260810045250.3903576-1-sumanth.gavini@windriver.com> X-ClientProxiedBy: SJ0PR05CA0120.namprd05.prod.outlook.com (2603:10b6:a03:334::35) To IA3PR11MB9256.namprd11.prod.outlook.com (2603:10b6:208:57f::21) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: IA3PR11MB9256:EE_|PH7PR11MB7595:EE_ X-MS-Office365-Filtering-Correlation-Id: fbd745f4-e5b1-4f54-71de-08def69b47d7 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|1800799024|366016|52116014|376014|23010399003|18002099003|22082099003|13003099007|25016099003|12006099003|38350700014|6133799003|56012099006|11063799006|10067099003|29003799003; X-Microsoft-Antispam-Message-Info: s9L6IH052NuJxlQah1PQJcbRonh6XBDbL2rQgsejDTwiuSwe8jgbdfvcVwAgmacpvyuEEcrorCDA0LfaaiytkMTwwZRmt8CPilQAhRYCgvElbqv8XPWWduQpYjICCZ3OS8kK0kbg84mQDKwNrERNAbmP7jMlkDPLGEqEa3ngT5Hq3JLHyYGyU8GBApWwPiLr5xR4ZuePe0lLP0PTnJIKRc1j1QJRPNdrlkwkxagGUdrtCSpYZ5upaON3FPLuEcscxo24FIEmeryAdPRgaYAtUEZMk5vK58sgItI8NTLP6kLPzzaoh7Dc4dy+HE0sUVYum7SqIOdC4W/rniWfpNY8Z9gIvGB0OGmyX8rFUnQfV2u1rqtN6pKVPpH9SrLW8NeLdYBhmLNj/LfjMHNzJbW38Ug2HlWId/slvSW+eyyJEQvF9uxS4qSWbovBJYSqI0kL5cbDL+ymP/IaKe4i+/lO40/5Rn24P031S3cs/PAKCG6oB64ZUqYKsBX0jH6YVctKHgn7NMp5MDI1AjrrrN/qQ9WCtf8FJitdbDybLmHagc6kZZKzMWK2/LgHISUp1qDJubajea2WSe1ByGKAeXeptaFSF7T5fFiZ2pG92K9mnPJiNu9XXLuxgRi+pUs0kDgB3jC4ti1HTXhcZy022OzNLUOAaNMz0P8auVdS3HCcxA8= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:IA3PR11MB9256.namprd11.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(1800799024)(366016)(52116014)(376014)(23010399003)(18002099003)(22082099003)(13003099007)(25016099003)(12006099003)(38350700014)(6133799003)(56012099006)(11063799006)(10067099003)(29003799003);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: EsGcGYfEsDkNeffS0ydkNIkXSbKE0IQEh4JYKD7Vf3i8Sk0WXYf8Ea3eTTXhVc9nqeX9sDKUAf0SyL/QlexguM7CAnCfAgoLHKy9T3FMDsrhl8tWiinfxlQ1Z/WA9+6gOq7OfR95dSP3Q095P5ARzlSDXQfWS4q9PVNnKdI9yT5YuOhveDv480rh/ByEJOyRHoz+gra5ga0cjoZ1e6muXj+QMmzsUANF51nox0VERzZsaBVx5OJMikujVhDw2eusOv2++yfMQLqLREnS7q4weWWxkYkaQtUI3llQg5UFWLqh6mZkDH+Lj7oYKC9uzkKjGEBVrA/nmSMSSTi1/DrPPQAkZmAJ8HhF96m4vPwcqfRmVpNQklF1nhbawJCWtZupyrvrqkG52X7G691KhCCN3gLlotn7oEBs07lkTlCx9wq0MZFopyDIzIbtN534bP+/xASa/tM4N+ckv3W9I6RntuxpjF+Hogr3N7tnUw69MMtCPHLgo9DfYLfWlyLfUuTvSaZWUfPme+6RPt5/j0NyC9CtTkn7Ga7WcH0iIxO+tb2MpkYRQDS6EEvS4XMF6YoYvFSpl6FjtiylwUbnakRYF7c9PDIiwUr3o1+Jnu3pzLtPQ48pvngpm71d/iI+NT1oJ1ZBPzJ+pTkpsRiBvGnmAB0dhY6ea+SlyRjki7l9Ard9kB7/NiFKlT3TnAyOuAwJbMPOkXut9aZDWX6LZt5fKuJ4sW/gy3n72fNAA5yCF7S3FBI5l2hYVFkHv1vo7kZPEWvFh5DoGhBFgucZT1a/M9Bf9m4cl8NugwM1X5ROmTjYD8CVoN7B8xLfeNWPf7DSpUWqP7IGgxzcWq3qvVb/WbFososxrnahD2o0affO+uTeU9Z0eGCLeHy6dq7wGNxY+SDywTEbH1+q6w9LHhryhSIYSYpNGKI7I+ROoOvsTh/WDuMwdkmWBnSdDHDvhTZTS1DCycyFmW+jeeClW1ZJdprQISMydvKLJBu13AQwxLK/2zhwOuZjTU9F2u4SJ8tiIMZEEapaY3AEEiFOVvd52DdcTjcCkn27TZokN6+JZyiXyMhHHWOeVZn1+RvgGVRWCLnXPKyikyi5RWt9M6VgvAPBKKvRW6PaA49HV3OI6i2GJlN+m1Eh/f+q537+SKse3uOedoA2PLMx3gW127IxRnOu2KadCZfMSNVDHTZZ8mMfUUHv6pkR9SFvZ92kGjB6lQqM942GEUVOI7ChDqX3/td5jeY+1CaCTTPMTHilGgw13z8EsmQ1uyGqvs5fsV6vKXs5yGY3WBg4t7Y/f03MyqmLEB5sPWwr+1KWnKFwVkxsxTI9a69vJSKYLvPmIqiU1kUtgQEhXnxLlsHdL0FvpMGMrqB9d5Yt7cOLk9Y8agnMs4VtYHydS++Al27/OKqPYz/CERGFC+9c6M0EnFFLIh58/taoeODaa8UX0TpauA23twotzvM8OVWw3Jxmn+bwOGnq69/h+0qC6xt7U+Bf+mt7y0q/3XHWaLhy5gD5vehQc2VcIGkOzJ3sRSDKDVApr9hub0ojEoOT5XfDUfRIIS603o8oJKbXIH6MR9czv6uzF0eR+w0ZvoczM+xl2HhEa8hGLIYrK0DCdN4nv+7u1TrRK17RZZeJ4qjlezKT/SiMEfCvEMD4u3L9vvvFUYHuyC4y8AoDFEFJqI+5kaqJgtH8dsCHGqCv2jOveIbsHsJxzOhsCJSi9qtdk6L3usoYcn3ijYBJcHaGHbU2OXk3pbSw+7TcFqFS73vs2tJ9FUs= X-Exchange-RoutingPolicyChecked: EqQ8QTcj/PS8jDkPr6OOp1suZWcThYhTvjSQ7vHhbyZGgRttqos+y0mg52/ILoGCvY36G7OxuR9GnAhZNMoIvILz6cvdUUjDczvnEMfuLzkpMD406KJXTgH1cncRV2S+jL/pAEjRQx5UYWcSrjGrlp4t6WdgVAAPQL1P0I+MSNTjQbS4fAIeIkBr42P/sa1B6VHXqGODxSdWE49FEtbRPPFYWmnKjSGaeOkR+1tTUep6HnKwuKoSnE06yIRZ6VGsg++T5FWBU+X39e68BvidTqfVmGNQQ6xfHc04OwnmINyeL6yjQTpyFENwhmF+9roVX1IlOqi3OnNKo20elSca2Q== X-OriginatorOrg: windriver.com X-MS-Exchange-CrossTenant-Network-Message-Id: fbd745f4-e5b1-4f54-71de-08def69b47d7 X-MS-Exchange-CrossTenant-AuthSource: IA3PR11MB9256.namprd11.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 10 Aug 2026 04:53:12.0708 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 8ddb2873-a1ad-4a18-ae4e-4644631433be X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: ru3uUBZP2yT9oC6XiKmFE/76HRPnbiDHu6XsB2S+9iS44AiOdlPYFwOi+11btCN9cdIqeawpCHJNqXprcUPK67wSlsdGbTMAkNRBZgcPmJo= X-MS-Exchange-Transport-CrossTenantHeadersStamped: PH7PR11MB7595 X-Proofpoint-Reinject: loops=2 maxloops=12 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwODEwMDAzOCBTYWx0ZWRfX1fKX3aLGOBEJ PhKDXGKT0w/tP2G6WJTEkhBee2yxXRUehyhihS7Lq35Uryn3x90EGsMxfWl7U7mdW5N1mu/UasW anV6xC44U6Qf8g4QKc6bhcR3AETf9Lk0y0JvyWvPDDlHg2vOL2qKfdJGBLjRisRiXa/ZGcdoXHm ROMRP9GHXgeNyspAKZXUFisQO183aHovdOMSNgQSQlu/EuqLW9p78oaPRVUM7aMx/fJSlxDWP/s dP6HabIZaJd2XZipkvtMJRaPrH9zxtQvembuTohquZlnkTLoOYmPjnYW1uEZwHvKaFUitjJSgB9 pFrE4UNlFL1xfQfm9fTFQaVnq/GThM83kypRSwP0FwdhHJpiFUGNs5E3jM4doTknDJDKKAYUC6g bRKurXMIB24oiWHcyINOgdN2QdkEhRmDn5gppk+Jo2QsXoEpq7+b1q+qlwVCVW5iofl2SXEVEHS XYt7kbpOtpgkcqA6wwg== X-Proofpoint-Spam-Info: AW1haW4tMjYwODEwMDAzOCBTYWx0ZWRfX1uVrp5NuiY3n wHn38Ft0TZ4i7xJDD4ZyHbGRFI05pJK0kyeEG8k8EYkLVvL4v9srYswPzRUGIkQBwsm0GphQvP2 S4RKxCYBwMTv6CMQthVOIqOvk4S/DVdeuP/DjH4WSYv8YLkqkttU X-Authority-Analysis: v=2.4 cv=Z5Lc2nRA c=1 sm=1 tr=0 ts=6a79593b cx=c_pps a=CjRpyDoPu1ZhyeacGh9KdQ==:117 a=6eWqkTHjU83fiwn7nKZWdM+Sl24=:19 a=z/mQ4Ysz8XfWz/Q5cLBRGdckG28=:19 a=lCpzRmAYbLLaTzLvsPZ7Mbvzbb8=:19 a=xqWC_Br6kY4A:10 a=Sv0fKeRqtYgA:10 a=VkNPw1HP01LnGYTKEx00:22 a=bi6dqmuHe4P4UrxVR6um:22 a=HK-ge7EqtdluswH-FwHe:22 a=NEAV23lmAAAA:8 a=3uWsZ661AAAA:8 a=t7CeM3EgAAAA:8 a=xumDe5_XqNxy1WfVeCAA:9 a=fYNom5PXsM5enKJDCoVv:22 a=FdTzh2GWekK77mhwV6Dw:22 X-Proofpoint-ORIG-GUID: YN7KMmWSzFqTVErQPc94-5SK4M9C97yv X-Proofpoint-GUID: idGwPk3dy5CwhH0cjM9Zfjh_Ysu-GU4q X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1176,Hydra:6.1.134,FMLib:17.12.100.49 definitions=2026-08-09_07,2026-08-07_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 clxscore=1015 phishscore=0 malwarescore=0 adultscore=0 lowpriorityscore=0 suspectscore=0 bulkscore=0 priorityscore=1501 impostorscore=0 spamscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2606150000 definitions=main-2608100038 List-Id: X-Webhook-Received: from 45-33-107-173.ip.linodeusercontent.com [45.33.107.173] by aws-us-west-2-korg-lkml-1.web.codeaurora.org with HTTPS for ; Mon, 10 Aug 2026 04:53:22 -0000 X-Groupsio-URL: https://lists.openembedded.org/g/openembedded-core/message/243102 * Added 0004-Convert-RPM-reader-into-a-proper-format.patch to convert the RPM reader into a proper format handler. This is needed because RPM 6 changed its internal payload structure and the existing RPM filter (which only strips headers and passes payload through) can no longer parse RPM 6 packages. Without this patch, debuginfod (elfutils) cannot scan RPM 6 packages: libarchive error: cannot open archive from pipe: Unrecognized archive format The existing RPM filter is kept unchanged for API compatibility. The new format reader coexists with it - debuginfod and other tools that use archive_read_support_format_all() will use the format reader for RPM 6 packages. Fixed: $ oe-selftest -r debuginfod.Debuginfod.test_debuginfod_native $ oe-selftest -r debuginfod.Debuginfod.test_debuginfod_qemu $ bitbake core-image-ptest-libarchive:do_testimage (libarchive_test PASS) The patch is from: [https://github.com/libarchive/libarchive/pull/2846] Signed-off-by: Sumanth Gavini --- ...vert-RPM-reader-into-a-proper-format.patch | 1400 +++++++++++++++++ .../libarchive/libarchive_3.8.9.bb | 1 + 2 files changed, 1401 insertions(+) create mode 100644 meta/recipes-extended/libarchive/libarchive/0004-Convert-RPM-reader-into-a-proper-format.patch diff --git a/meta/recipes-extended/libarchive/libarchive/0004-Convert-RPM-reader-into-a-proper-format.patch b/meta/recipes-extended/libarchive/libarchive/0004-Convert-RPM-reader-into-a-proper-format.patch new file mode 100644 index 0000000000..29d12bb539 --- /dev/null +++ b/meta/recipes-extended/libarchive/libarchive/0004-Convert-RPM-reader-into-a-proper-format.patch @@ -0,0 +1,1400 @@ +From 2606336bce3a7f66cc6c8af28687a82536c9086c Mon Sep 17 00:00:00 2001 +From: Davide Beatrici +Date: Sun, 9 Aug 2026 14:14:59 -0700 +Subject: [PATCH] libarchive: Convert RPM reader into a proper format + +This adds a new RPM format reader that can handle RPM 6 packages +with their new internal structure. The existing RPM filter is kept +unchanged for API compatibility. + +Without this patch, debuginfod cannot scan RPM 6 packages: + libarchive error: cannot open archive from pipe: Unrecognized + archive format + +Upstream-Status: Submitted [https://github.com/libarchive/libarchive/pull/2846] + +Signed-off-by: Sumanth Gavini +--- + Makefile.am | 1 + + contrib/android/Android.mk | 1 + + libarchive/CMakeLists.txt | 1 + + libarchive/archive.h | 6 + + libarchive/archive_read.c | 9 +- + libarchive/archive_read_private.h | 2 +- + libarchive/archive_read_set_format.c | 3 + + libarchive/archive_read_support_filter_all.c | 2 + + .../archive_read_support_filter_by_code.c | 2 + + libarchive/archive_read_support_format_all.c | 1 + + libarchive/archive_read_support_format_rpm.c | 1126 +++++++++++++++++ + libarchive/test/test_archive_read_support.c | 2 +- + .../test_read_format_cpio_svr4_bzip2_rpm.c | 4 +- + .../test_read_format_cpio_svr4_gzip_rpm.c | 4 +- + 14 files changed, 1162 insertions(+), 15 deletions(-) + create mode 100644 libarchive/archive_read_support_format_rpm.c + +diff --git a/Makefile.am b/Makefile.am +index c96b3bc..725e20c 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -210,6 +210,7 @@ libarchive_la_SOURCES= \ + libarchive/archive_read_support_format_rar.c \ + libarchive/archive_read_support_format_rar5.c \ + libarchive/archive_read_support_format_raw.c \ ++ libarchive/archive_read_support_format_rpm.c \ + libarchive/archive_read_support_format_tar.c \ + libarchive/archive_read_support_format_warc.c \ + libarchive/archive_read_support_format_xar.c \ +diff --git a/contrib/android/Android.mk b/contrib/android/Android.mk +index 9e1c72f..3d1f087 100644 +--- a/contrib/android/Android.mk ++++ b/contrib/android/Android.mk +@@ -91,6 +91,7 @@ libarchive_src_files := libarchive/archive_acl.c \ + libarchive/archive_read_support_format_rar.c \ + libarchive/archive_read_support_format_rar5.c \ + libarchive/archive_read_support_format_raw.c \ ++ libarchive/archive_read_support_format_rpm.c \ + libarchive/archive_read_support_format_tar.c \ + libarchive/archive_read_support_format_warc.c \ + libarchive/archive_read_support_format_xar.c \ +diff --git a/libarchive/CMakeLists.txt b/libarchive/CMakeLists.txt +index b296637..d132123 100644 +--- a/libarchive/CMakeLists.txt ++++ b/libarchive/CMakeLists.txt +@@ -110,6 +110,7 @@ SET(libarchive_SOURCES + archive_read_support_format_rar.c + archive_read_support_format_rar5.c + archive_read_support_format_raw.c ++ archive_read_support_format_rpm.c + archive_read_support_format_tar.c + archive_read_support_format_warc.c + archive_read_support_format_xar.c +diff --git a/libarchive/archive.h b/libarchive/archive.h +index a7de6f6..89c60b3 100644 +--- a/libarchive/archive.h ++++ b/libarchive/archive.h +@@ -314,7 +314,9 @@ typedef const char *archive_passphrase_callback(struct archive *, + #define ARCHIVE_FILTER_LZMA 5 + #define ARCHIVE_FILTER_XZ 6 + #define ARCHIVE_FILTER_UU 7 ++#if ARCHIVE_VERSION_NUMBER < 4000000 + #define ARCHIVE_FILTER_RPM 8 ++#endif + #define ARCHIVE_FILTER_LZIP 9 + #define ARCHIVE_FILTER_LRZIP 10 + #define ARCHIVE_FILTER_LZOP 11 +@@ -385,6 +387,7 @@ typedef const char *archive_passphrase_callback(struct archive *, + #define ARCHIVE_FORMAT_7ZIP 0xE0000 + #define ARCHIVE_FORMAT_WARC 0xF0000 + #define ARCHIVE_FORMAT_RAR_V5 0x100000 ++#define ARCHIVE_FORMAT_RPM 0x110000 + + /* + * Codes returned by archive_read_format_capabilities(). +@@ -478,7 +481,9 @@ __LA_DECL int archive_read_support_filter_program(struct archive *, + __LA_DECL int archive_read_support_filter_program_signature + (struct archive *, const char * /* cmd */, + const void * /* match */, size_t); ++#if ARCHIVE_VERSION_NUMBER < 4000000 + __LA_DECL int archive_read_support_filter_rpm(struct archive *); ++#endif + __LA_DECL int archive_read_support_filter_uu(struct archive *); + __LA_DECL int archive_read_support_filter_xz(struct archive *); + __LA_DECL int archive_read_support_filter_zstd(struct archive *); +@@ -499,6 +504,7 @@ __LA_DECL int archive_read_support_format_mtree(struct archive *); + __LA_DECL int archive_read_support_format_rar(struct archive *); + __LA_DECL int archive_read_support_format_rar5(struct archive *); + __LA_DECL int archive_read_support_format_raw(struct archive *); ++__LA_DECL int archive_read_support_format_rpm(struct archive *); + __LA_DECL int archive_read_support_format_tar(struct archive *); + __LA_DECL int archive_read_support_format_warc(struct archive *); + __LA_DECL int archive_read_support_format_xar(struct archive *); +diff --git a/libarchive/archive_read.c b/libarchive/archive_read.c +index 406d84d..150bd31 100644 +--- a/libarchive/archive_read.c ++++ b/libarchive/archive_read.c +@@ -1296,13 +1296,18 @@ __archive_read_register_bidder(struct archive_read *a, + int i, number_slots; + + archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC, +- ARCHIVE_STATE_NEW, "__archive_read_register_bidder"); ++ ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER, ++ "__archive_read_register_bidder"); + + number_slots = sizeof(a->bidders) / sizeof(a->bidders[0]); + + for (i = 0; i < number_slots; i++) { +- if (a->bidders[i].vtable != NULL) ++ if (a->bidders[i].vtable != NULL) { ++ if (a->bidders[i].vtable == vtable) ++ /* Already registered. */ ++ return (ARCHIVE_OK); + continue; ++ } + memset(a->bidders + i, 0, sizeof(a->bidders[0])); + bidder = (a->bidders + i); + bidder->data = bidder_data; +diff --git a/libarchive/archive_read_private.h b/libarchive/archive_read_private.h +index e30b6c2..9ff3602 100644 +--- a/libarchive/archive_read_private.h ++++ b/libarchive/archive_read_private.h +@@ -212,7 +212,7 @@ struct archive_read { + int (*cleanup)(struct archive_read *); + int (*format_capabilties)(struct archive_read *); + int (*has_encrypted_entries)(struct archive_read *); +- } formats[16]; ++ } formats[18]; + struct archive_format_descriptor *format; /* Active format. */ + + /* +diff --git a/libarchive/archive_read_set_format.c b/libarchive/archive_read_set_format.c +index 552ab12..6a176e3 100644 +--- a/libarchive/archive_read_set_format.c ++++ b/libarchive/archive_read_set_format.c +@@ -81,6 +81,9 @@ archive_read_set_format(struct archive *_a, int code) + case ARCHIVE_FORMAT_RAW: + str = "raw"; + break; ++ case ARCHIVE_FORMAT_RPM: ++ str = "rpm"; ++ break; + case ARCHIVE_FORMAT_TAR: + str = "tar"; + break; +diff --git a/libarchive/archive_read_support_filter_all.c b/libarchive/archive_read_support_filter_all.c +index f086773..cc5c2b2 100644 +--- a/libarchive/archive_read_support_filter_all.c ++++ b/libarchive/archive_read_support_filter_all.c +@@ -60,8 +60,10 @@ archive_read_support_filter_all(struct archive *a) + archive_read_support_filter_xz(a); + /* The decode code doesn't use an outside library. */ + archive_read_support_filter_uu(a); ++#if ARCHIVE_VERSION_NUMBER < 4000000 + /* The decode code doesn't use an outside library. */ + archive_read_support_filter_rpm(a); ++#endif + /* The decode code always uses "lrzip -d -q" command-line. */ + archive_read_support_filter_lrzip(a); + /* Lzop decompress falls back to "lzop -d" command-line. */ +diff --git a/libarchive/archive_read_support_filter_by_code.c b/libarchive/archive_read_support_filter_by_code.c +index 4c8b6cb..d3c7d21 100644 +--- a/libarchive/archive_read_support_filter_by_code.c ++++ b/libarchive/archive_read_support_filter_by_code.c +@@ -49,8 +49,10 @@ archive_read_support_filter_by_code(struct archive *a, int filter_code) + return archive_read_support_filter_xz(a); + case ARCHIVE_FILTER_UU: + return archive_read_support_filter_uu(a); ++#if ARCHIVE_VERSION_NUMBER < 4000000 + case ARCHIVE_FILTER_RPM: + return archive_read_support_filter_rpm(a); ++#endif + case ARCHIVE_FILTER_LZIP: + return archive_read_support_filter_lzip(a); + case ARCHIVE_FILTER_LRZIP: +diff --git a/libarchive/archive_read_support_format_all.c b/libarchive/archive_read_support_format_all.c +index a2c5a4c..729b4c4 100644 +--- a/libarchive/archive_read_support_format_all.c ++++ b/libarchive/archive_read_support_format_all.c +@@ -58,6 +58,7 @@ archive_read_support_format_all(struct archive *a) + archive_read_support_format_empty(a); + archive_read_support_format_lha(a); + archive_read_support_format_mtree(a); ++ archive_read_support_format_rpm(a); + archive_read_support_format_tar(a); + archive_read_support_format_xar(a); + archive_read_support_format_warc(a); +diff --git a/libarchive/archive_read_support_format_rpm.c b/libarchive/archive_read_support_format_rpm.c +new file mode 100644 +index 0000000..fe0e500 +--- /dev/null ++++ b/libarchive/archive_read_support_format_rpm.c +@@ -0,0 +1,1126 @@ ++/*- ++ * Copyright (c) 2026 Davide Beatrici ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES ++ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ++ * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, ++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF ++ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++#include "archive_platform.h" ++ ++#ifdef HAVE_ERRNO_H ++#include ++#endif ++ ++#ifdef HAVE_STDLIB_H ++#include ++#endif ++#ifdef HAVE_STRING_H ++#include ++#endif ++ ++#include "archive.h" ++#include "archive_endian.h" ++#include "archive_entry.h" ++#include "archive_entry_locale.h" ++#include "archive_private.h" ++#include "archive_read_private.h" ++ ++#define MAX_NFILES 100000 ++#define STR_SIZE_LIMIT (1024 * 1024) /* 1 MiB */ ++ ++#define LEAD_MAGIC "\xed\xab\xee\xdb" ++#define HEADER_MAGIC "\x8e\xad\xe8\x01\x00\x00\x00\x00" ++ ++#define CPIO_END_MARK "TRAILER!!!" ++#define CPIO_END_MARK_SIZE 10 ++ ++#define CPIO_HEADER_STR_SIZE 16 ++#define CPIO_HEADER_SVR_SIZE 110 ++#define CPIO_HEADER_SVR_PATH_OFF 94 ++ ++#define CPIO_MAGIC_SIZE 6 ++#define CPIO_MAGIC_STR "07070X" ++#define CPIO_MAGIC_SVR4_CRC "070702" ++#define CPIO_MAGIC_SVR4_NOCRC "070701" ++ ++#define TAG_FILESIZES 1028 ++#define TAG_FILEMODES 1030 ++#define TAG_FILERDEVS 1033 ++#define TAG_FILEMTIMES 1034 ++#define TAG_FILEUSERNAMES 1039 ++#define TAG_FILEGROUPNAMES 1040 ++#define TAG_FILEDEVICES 1095 ++#define TAG_FILEINODES 1096 ++ ++#define TAG_DIRINDEXES 1116 ++#define TAG_BASENAMES 1117 ++#define TAG_DIRNAMES 1118 ++ ++#define TAG_PAYLOADCOMPRESSOR 1125 ++ ++#define TAG_LONGFILESIZES 5008 ++ ++enum rpm_cpio_format { ++ CPIO_UNKNOWN, ++ CPIO_STR, ++ CPIO_SVR4_CRC, ++ CPIO_SVR4_NOCRC ++}; ++ ++struct rpm_file_info { ++ char *pathname; ++ char *uname; ++ char *gname; ++ uint64_t size; ++ uint16_t mode; ++ int32_t dev; ++ int16_t rdev; ++ uint32_t mtime; ++ uint32_t ino; ++}; ++ ++struct rpm_inode_info { ++ uint32_t n_files; ++ struct rpm_file_info **files; ++ uint32_t n_processed; ++}; ++ ++struct rpm_inode_temp_entry { ++ uint64_t ino; ++ struct rpm_file_info **files; ++ uint32_t n_files; ++ size_t capacity; ++ struct rpm_inode_temp_entry *next; ++}; ++ ++struct rpm_lead { ++ unsigned char magic[4]; ++ unsigned char major, minor; ++ short type; ++ short archnum; ++ char name[66]; ++ short osnum; ++ short signature_type; ++ char reserved[16]; ++}; ++ ++struct rpm_header { ++ unsigned char magic[8]; ++ uint32_t n_entries; ++ uint32_t data_size; ++}; ++ ++struct rpm_entry { ++ uint32_t tag; ++ uint32_t type; ++ int32_t offset; ++ uint32_t count; ++}; ++ ++struct rpm { ++ enum { ++ ST_LEAD, ++ ST_HEADER, ++ ST_PADDING, ++ ST_ARCHIVE ++ } state; ++ uint8_t first_header; ++ ++ char *compressor; ++ ++ uint32_t n_files; ++ uint32_t n_inodes; ++ struct rpm_file_info *files; ++ struct rpm_inode_info *inodes; ++ ++ struct inode_hash_entry { ++ uint64_t ino; ++ struct rpm_inode_info *info; ++ struct inode_hash_entry *next; ++ } **inode_hash; ++ ++ size_t inode_hash_size; ++ ++ ssize_t entry_bytes_remaining; ++ ssize_t entry_bytes_unconsumed; ++ ssize_t entry_offset; ++ ssize_t entry_padding; ++}; ++ ++static int archive_read_format_rpm_bid(struct archive_read *, int); ++static int archive_read_format_rpm_read_header(struct archive_read *, ++ struct archive_entry *); ++static int archive_read_format_rpm_read_data(struct archive_read *, ++ const void **, size_t *, int64_t *); ++static int archive_read_format_rpm_read_data_skip(struct archive_read *); ++static int archive_read_format_rpm_cleanup(struct archive_read *); ++ ++static int rpm_add_entry(struct archive_read *, struct archive_entry *); ++static int rpm_parse_main_header(struct archive_read *, ++ const struct rpm_header *header); ++ ++static struct rpm_inode_info *rpm_get_inode(struct archive_read *, uint32_t); ++static enum rpm_cpio_format rpm_get_cpio_format(struct archive_read *); ++static uint8_t rpm_is_eof(struct archive_read *); ++ ++static uint16_t rpm_be16_at(const void *buf_start, ++ const void *buf_end, const size_t off); ++static uint32_t rpm_be32_at(const void *buf_start, ++ const void *buf_end, const size_t off); ++static uint64_t rpm_be64_at(const void *buf_start, ++ const void *buf_end, const size_t off); ++ ++static inline size_t rpm_limit_bytes(size_t, size_t); ++static char *rpm_strndup(struct archive_read *, const char *, size_t); ++static char *rpm_strread(struct archive_read *, size_t); ++static void rpm_strcat(struct archive_string *, const void *, const void *); ++static const char *rpm_strlist_at(const char *, const void *, ++ uint64_t, uint64_t); ++ ++static void rpm_free_inode_temp_hash(struct rpm_inode_temp_entry **, size_t); ++ ++int ++archive_read_support_format_rpm(struct archive *_a) ++{ ++ struct archive_read *a = (struct archive_read *)_a; ++ struct rpm *rpm; ++ int r; ++ ++ archive_check_magic(_a, ARCHIVE_READ_MAGIC, ++ ARCHIVE_STATE_NEW, "archive_read_support_format_rpm"); ++ ++ rpm = calloc(1, sizeof(*rpm)); ++ if (!rpm) { ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate rpm data"); ++ return ARCHIVE_FATAL; ++ } ++ ++ r = __archive_read_register_format(a, ++ rpm, ++ "rpm", ++ archive_read_format_rpm_bid, ++ NULL, ++ archive_read_format_rpm_read_header, ++ archive_read_format_rpm_read_data, ++ archive_read_format_rpm_read_data_skip, ++ NULL, ++ archive_read_format_rpm_cleanup, ++ NULL, ++ NULL); ++ ++ if (r != ARCHIVE_OK) ++ free(rpm); ++ ++ return ARCHIVE_OK; ++} ++ ++static int ++archive_read_format_rpm_bid(struct archive_read *a, int best_bid) ++{ ++ const unsigned char *p; ++ ++ (void)best_bid; ++ ++ if ((p = __archive_read_ahead(a, sizeof(LEAD_MAGIC) - 1, NULL)) == NULL) ++ return -1; ++ ++ if (memcmp(p, LEAD_MAGIC, sizeof(LEAD_MAGIC) - 1) == 0) ++ return 48; ++ else ++ return ARCHIVE_WARN; ++} ++ ++static int ++archive_read_format_rpm_read_header(struct archive_read *a, ++ struct archive_entry *entry) ++{ ++ struct rpm *rpm = a->format->data; ++ const unsigned char *p; ++ int r; ++ ++ a->archive.archive_format = ARCHIVE_FORMAT_RPM; ++ ++ for (;;) { ++ switch (rpm->state) { ++ case ST_LEAD: { ++ const struct rpm_lead *lead = __archive_read_ahead(a, sizeof(*lead), NULL); ++ if (lead == NULL) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Truncated lead"); ++ return ARCHIVE_FATAL; ++ } ++ ++ if (memcmp(lead->magic, LEAD_MAGIC, sizeof(lead->magic)) != 0) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Unrecognized lead"); ++ return ARCHIVE_FATAL; ++ } ++ ++ __archive_read_consume(a, sizeof(*lead)); ++ ++ rpm->state = ST_HEADER; ++ rpm->first_header = 1; ++ break; ++ } ++ case ST_HEADER: { ++ struct rpm_header header; ++ ++ p = __archive_read_ahead(a, sizeof(header), NULL); ++ if (p == NULL) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Truncated header"); ++ return ARCHIVE_FATAL; ++ } ++ ++ memcpy(&header, p, sizeof(header)); ++ ++ if (memcmp(header.magic, HEADER_MAGIC, sizeof(header.magic)) != 0) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Unrecognized header"); ++ return ARCHIVE_FATAL; ++ } ++ ++ header.n_entries = archive_be32dec(&header.n_entries); ++ header.data_size = archive_be32dec(&header.data_size); ++ ++ __archive_read_consume(a, sizeof(header)); ++ ++ r = rpm_parse_main_header(a, &header); ++ if (r != ARCHIVE_OK) ++ return r; ++ ++ rpm->state = ST_PADDING; ++ break; ++ } ++ case ST_PADDING: { ++ for (;;) { ++ p = __archive_read_ahead(a, 1, NULL); ++ if (p == NULL) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Truncated padding"); ++ return ARCHIVE_FATAL; ++ } ++ ++ if (*p != 0) ++ break; ++ ++ __archive_read_consume(a, 1); ++ } ++ ++ if (rpm->first_header) { ++ rpm->first_header = 0; ++ rpm->state = ST_HEADER; ++ } else { ++ enum rpm_cpio_format cpio_format; ++ ++ if (!rpm->compressor) { ++ /* No compression. */ ++ } else if (strcmp(rpm->compressor, "zstd") == 0) { ++ r = archive_read_append_filter(&a->archive, ARCHIVE_FILTER_ZSTD); ++ } else if (strcmp(rpm->compressor, "xz") == 0) { ++ archive_read_append_filter(&a->archive, ARCHIVE_FILTER_XZ); ++ } else if (strcmp(rpm->compressor, "gzip") == 0) { ++ archive_read_append_filter(&a->archive, ARCHIVE_FILTER_GZIP); ++ } else if (strcmp(rpm->compressor, "bzip2") == 0) { ++ archive_read_append_filter(&a->archive, ARCHIVE_FILTER_BZIP2); ++ } else if (strcmp(rpm->compressor, "lzma") == 0) { ++ archive_read_append_filter(&a->archive, ARCHIVE_FILTER_LZMA); ++ } else { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Unrecognized compressor: %s", rpm->compressor); ++ return ARCHIVE_FATAL; ++ } ++ ++ if (r != ARCHIVE_OK) { ++ archive_set_error(&a->archive, r, "Cannot append %s filter", ++ rpm->compressor); ++ return r; ++ } ++ ++ cpio_format = rpm_get_cpio_format(a); ++ switch (cpio_format) { ++ case CPIO_STR: ++ a->archive.archive_format_name = "RPM (stripped CPIO)"; ++ break; ++ case CPIO_SVR4_CRC: ++ a->archive.archive_format_name = "RPM (SVR4 cpio with CRC)"; ++ break; ++ case CPIO_SVR4_NOCRC: ++ a->archive.archive_format_name = "RPM (SVR4 cpio with no CRC)"; ++ break; ++ case CPIO_UNKNOWN: ++ default: ++ return ARCHIVE_FATAL; ++ } ++ ++ rpm->state = ST_ARCHIVE; ++ } ++ break; ++ } ++ case ST_ARCHIVE: ++ return rpm_add_entry(a, entry); ++ } ++ } ++} ++ ++static int ++archive_read_format_rpm_read_data(struct archive_read *a, ++ const void **buff, size_t *size, int64_t *offset) ++{ ++ struct rpm *rpm = a->format->data; ++ ssize_t bytes_read; ++ ++ if (rpm->entry_bytes_unconsumed > 0) { ++ __archive_read_consume(a, rpm->entry_bytes_unconsumed); ++ rpm->entry_bytes_unconsumed = 0; ++ } ++ ++ if (rpm->entry_bytes_remaining > 0) { ++ *buff = __archive_read_ahead(a, 1, &bytes_read); ++ if (bytes_read <= 0) ++ return ARCHIVE_FATAL; ++ ++ if (bytes_read > rpm->entry_bytes_remaining) ++ bytes_read = (ssize_t)rpm->entry_bytes_remaining; ++ ++ *size = bytes_read; ++ rpm->entry_bytes_unconsumed = bytes_read; ++ *offset = rpm->entry_offset; ++ rpm->entry_offset += bytes_read; ++ rpm->entry_bytes_remaining -= bytes_read; ++ ++ return ARCHIVE_OK; ++ } else { ++ if (rpm->entry_padding != ++ __archive_read_consume(a, rpm->entry_padding)) { ++ return ARCHIVE_FATAL; ++ } ++ ++ rpm->entry_padding = 0; ++ *buff = NULL; ++ *size = 0; ++ *offset = rpm->entry_offset; ++ ++ return ARCHIVE_EOF; ++ } ++} ++ ++static int ++archive_read_format_rpm_read_data_skip(struct archive_read *a) ++{ ++ struct rpm *rpm = a->format->data; ++ const ssize_t to_skip = rpm->entry_bytes_remaining + rpm->entry_padding ++ + rpm->entry_bytes_unconsumed; ++ ++ if (to_skip != __archive_read_consume(a, to_skip)) ++ return ARCHIVE_FATAL; ++ ++ rpm->entry_bytes_remaining = 0; ++ rpm->entry_padding = 0; ++ rpm->entry_bytes_unconsumed = 0; ++ ++ return ARCHIVE_OK; ++} ++ ++static int ++archive_read_format_rpm_cleanup(struct archive_read *a) ++{ ++ struct rpm *rpm = a->format->data; ++ size_t i; ++ ++ free(rpm->compressor); ++ ++ if (rpm->inode_hash) { ++ for (i = 0; i < rpm->inode_hash_size; ++i) { ++ free(rpm->inode_hash[i]); ++ } ++ ++ free(rpm->inode_hash); ++ } ++ ++ if (rpm->inodes != NULL) { ++ for (i = 0; i < rpm->n_inodes; i++) { ++ free(rpm->inodes[i].files); ++ } ++ ++ free(rpm->inodes); ++ } ++ ++ if (rpm->files != NULL) { ++ for (i = 0; i < rpm->n_files; i++) { ++ free(rpm->files[i].pathname); ++ free(rpm->files[i].uname); ++ free(rpm->files[i].gname); ++ } ++ ++ free(rpm->files); ++ } ++ ++ free(rpm); ++ ++ a->format->data = NULL; ++ ++ return ARCHIVE_OK; ++} ++ ++static int ++rpm_add_entry(struct archive_read *a, struct archive_entry *entry) ++{ ++ struct rpm *rpm = a->format->data; ++ struct rpm_file_info *file = NULL; ++ struct rpm_inode_info *inode; ++ uint64_t idx_ino; ++ const void *p; ++ ++ const enum rpm_cpio_format cpio_format = rpm_get_cpio_format(a); ++ ++ p = __archive_read_ahead(a, CPIO_HEADER_STR_SIZE, NULL); ++ if (!p) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Premature EOF"); ++ return ARCHIVE_FATAL; ++ } ++ ++ char hex_str[9] = {0}; ++ memcpy(hex_str, p + CPIO_MAGIC_SIZE, sizeof(idx_ino)); ++ idx_ino = strtoull(hex_str, NULL, 16); ++ ++ switch (cpio_format) { ++ case CPIO_STR: ++ __archive_read_consume(a, CPIO_HEADER_STR_SIZE); ++ ++ if (rpm_is_eof(a)) ++ return ARCHIVE_EOF; ++ ++ if (idx_ino >= rpm->n_files) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "File index %" PRIu64 " out of range (max %u)", idx_ino, rpm->n_files - 1); ++ return ARCHIVE_FATAL; ++ } ++ ++ file = &rpm->files[idx_ino]; ++ inode = rpm_get_inode(a, file->ino); ++ if (!inode) ++ return ARCHIVE_FATAL; ++ ++ break; ++ case CPIO_SVR4_CRC: ++ case CPIO_SVR4_NOCRC: { ++ size_t i; ++ uint64_t size; ++ char *path; ++ ++ p = __archive_read_ahead(a, CPIO_HEADER_SVR_SIZE, NULL); ++ if (!p) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Truncated SVR4 header"); ++ return ARCHIVE_FATAL; ++ } ++ ++ memcpy(hex_str, p + CPIO_HEADER_SVR_PATH_OFF, sizeof(size)); ++ ++ __archive_read_consume(a, CPIO_HEADER_SVR_SIZE); ++ ++ if (rpm_is_eof(a)) ++ return ARCHIVE_EOF; ++ ++ inode = rpm_get_inode(a, idx_ino); ++ if (!inode) ++ return ARCHIVE_FATAL; ++ ++ size = strtoull(hex_str, NULL, 16); ++ ++ path = rpm_strread(a, size); ++ if (!path) ++ return ARCHIVE_FATAL; ++ ++ for (i = 0; i < inode->n_files; ++i) { ++ if (strcmp(inode->files[i]->pathname, path) == 0) { ++ file = inode->files[i]; ++ break; ++ } ++ } ++ ++ free(path); ++ ++ if (!file) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Path not found"); ++ return ARCHIVE_FATAL; ++ } ++ ++ /* Pad name to 2 more than a multiple of 4. */ ++ size += (2 - size) & 3; ++ __archive_read_consume(a, size); ++ ++ break; ++ } ++ default: ++ return ARCHIVE_FATAL; ++ } ++ ++ archive_entry_set_pathname_utf8(entry, file->pathname); ++ archive_entry_set_uname_utf8(entry, file->uname); ++ archive_entry_set_gname_utf8(entry, file->gname); ++ archive_entry_set_dev(entry, file->dev); ++ archive_entry_set_ino(entry, file->ino); ++ archive_entry_set_mode(entry, file->mode); ++ archive_entry_set_rdev(entry, file->rdev); ++ archive_entry_set_mtime(entry, file->mtime, 0); ++ archive_entry_set_nlink(entry, inode->n_files); ++ ++ /* Hardlink: only last entry carries payload */ ++ if (++inode->n_processed == inode->n_files) ++ rpm->entry_bytes_remaining = file->size; ++ else ++ rpm->entry_bytes_remaining = 0; ++ ++ /* Pad file contents to a multiple of 4. */ ++ rpm->entry_padding = 3 & -rpm->entry_bytes_remaining; ++ rpm->entry_offset = 0; ++ rpm->entry_bytes_unconsumed = 0; ++ ++ if (S_ISLNK(file->mode)) { ++ char *target = rpm_strread(a, file->size); ++ if (!target) ++ return ARCHIVE_FATAL; ++ ++ __archive_read_consume(a, rpm->entry_bytes_remaining); ++ rpm->entry_bytes_remaining = 0; ++ ++ archive_entry_set_symlink_utf8(entry, target); ++ ++ free(target); ++ } ++ ++ archive_entry_set_size(entry, rpm->entry_bytes_remaining); ++ ++ return ARCHIVE_OK; ++} ++ ++static int ++rpm_parse_main_header(struct archive_read *a, const struct rpm_header *header) ++{ ++ struct rpm *rpm = a->format->data; ++ ++ struct rpm_header_parse { ++ uint32_t n_files; ++ ++ const char *basenames; ++ uint32_t n_basenames; ++ ++ const char *dirnames; ++ uint32_t n_dirnames; ++ ++ const char *usernames; ++ uint32_t n_usernames; ++ ++ const char *groupnames; ++ uint32_t n_groupnames; ++ ++ union { ++ const int64_t *filesizes64; ++ const int32_t *filesizes32; ++ }; ++ uint8_t is_filesizes64; ++ ++ const int32_t *dirindexes; ++ const int16_t *filemodes; ++ const int32_t *filedevices; ++ const int16_t *filerdevs; ++ const int32_t *filemtimes; ++ const int32_t *fileinodes; ++ } hp; ++ ++ const struct rpm_entry *entries; ++ struct rpm_inode_temp_entry **temp_hash; ++ size_t hlen, temp_hash_size = 1; ++ uint64_t i, ino = 0; ++ ++ memset(&hp, 0, sizeof(hp)); ++ ++ hlen = sizeof(struct rpm_entry) ++ * (size_t)header->n_entries ++ + (size_t)header->data_size; ++ ++ entries = __archive_read_ahead(a, hlen, NULL); ++ if (entries == NULL) ++ return ARCHIVE_EOF; ++ ++ if (rpm->first_header) { ++ __archive_read_consume(a, hlen); ++ return ARCHIVE_OK; ++ } ++ ++ for (i = 0; i < header->n_entries; i++) { ++ uint32_t tag, cnt; ++ int32_t off; ++ const void *p; ++ ++ tag = archive_be32dec(&entries[i].tag); ++ off = archive_be32dec(&entries[i].offset); ++ cnt = archive_be32dec(&entries[i].count); ++ ++ if (off < 0 || (uint32_t)off >= header->data_size) ++ continue; ++ ++ p = (const uint8_t *)&entries[header->n_entries] + off; ++ ++ switch (tag) { ++ case TAG_PAYLOADCOMPRESSOR: ++ rpm->compressor = rpm_strndup(a, p ? p : "", 0); ++ break; ++ case TAG_BASENAMES: ++ hp.basenames = p; ++ hp.n_basenames = cnt; ++ break; ++ case TAG_DIRNAMES: ++ hp.dirnames = p; ++ hp.n_dirnames = cnt; ++ break; ++ case TAG_FILEUSERNAMES: ++ hp.usernames = p; ++ hp.n_usernames = cnt; ++ break; ++ case TAG_FILEGROUPNAMES: ++ hp.groupnames = p; ++ hp.n_groupnames = cnt; ++ break; ++ case TAG_LONGFILESIZES: ++ hp.filesizes64 = p; ++ hp.n_files = cnt; ++ hp.is_filesizes64 = 1; ++ break; ++ case TAG_FILESIZES: ++ /* This tag should never appear when Longfilesizes is present, ++ * but checking doesn't hurt. */ ++ if (!hp.is_filesizes64) { ++ hp.filesizes32 = p; ++ hp.n_files = cnt; ++ } ++ break; ++ case TAG_DIRINDEXES: ++ hp.dirindexes = p; ++ break; ++ case TAG_FILEINODES: ++ hp.fileinodes = p; ++ break; ++ case TAG_FILEMODES: ++ hp.filemodes = p; ++ break; ++ case TAG_FILEDEVICES: ++ hp.filedevices = p; ++ break; ++ case TAG_FILERDEVS: ++ hp.filerdevs = p; ++ break; ++ case TAG_FILEMTIMES: ++ hp.filemtimes = p; ++ break; ++ } ++ } ++ ++ if (hp.n_files >= MAX_NFILES) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "n_files out of range"); ++ return ARCHIVE_FATAL; ++ } ++ ++ rpm->files = calloc(hp.n_files, sizeof(*rpm->files)); ++ if (rpm->files == NULL) { ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate files data"); ++ return ARCHIVE_FATAL; ++ } ++ ++ rpm->n_files = hp.n_files; ++ ++ while (temp_hash_size < hp.n_files * 2) ++ temp_hash_size <<= 1; ++ ++ temp_hash = calloc(temp_hash_size, sizeof(*temp_hash)); ++ if (!temp_hash) { ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate temp hash"); ++ return ARCHIVE_FATAL; ++ } ++ ++ for (i = 0; i < hp.n_files; i++) { ++ const void *hbuf_end = (const uint8_t *)entries + hlen; ++ struct rpm_file_info *file = &rpm->files[i]; ++ struct rpm_inode_temp_entry *group; ++ struct archive_string as; ++ const char *dname, *bname, *uname, *gname; ++ size_t bucket; ++ ++ if (hp.dirindexes != NULL) { ++ const uint32_t diri = rpm_be32_at(hp.dirindexes, hbuf_end, i); ++ ++ if (diri >= hp.n_dirnames) { ++ rpm_free_inode_temp_hash(temp_hash, temp_hash_size); ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "dirindex out of range"); ++ return ARCHIVE_FATAL; ++ } ++ ++ dname = rpm_strlist_at(hp.dirnames, hbuf_end, diri, hp.n_dirnames); ++ } else ++ dname = NULL; ++ ++ bname = rpm_strlist_at(hp.basenames, hbuf_end, i, hp.n_basenames); ++ uname = rpm_strlist_at(hp.usernames, hbuf_end, i, hp.n_usernames); ++ gname = rpm_strlist_at(hp.groupnames, hbuf_end, i, hp.n_groupnames); ++ ++ archive_string_init(&as); ++ archive_strappend_char(&as, '.'); ++ rpm_strcat(&as, dname, hbuf_end); ++ rpm_strcat(&as, bname, hbuf_end); ++ file->pathname = strdup(as.s); ++ archive_string_free(&as); ++ ++ file->uname = rpm_strndup(a, uname ? uname : "", 0); ++ file->gname = rpm_strndup(a, gname ? gname : "", 0); ++ ++ if (hp.is_filesizes64) ++ file->size = rpm_be64_at(hp.filesizes64, hbuf_end, i); ++ else ++ file->size = rpm_be32_at(hp.filesizes32, hbuf_end, i); ++ file->mode = rpm_be16_at(hp.filemodes, hbuf_end, i); ++ file->dev = rpm_be32_at(hp.filedevices, hbuf_end, i); ++ file->rdev = rpm_be16_at(hp.filerdevs, hbuf_end, i); ++ file->mtime = rpm_be32_at(hp.filemtimes, hbuf_end, i); ++ file->ino = rpm_be32_at(hp.fileinodes, hbuf_end, i); ++ ++ bucket = file->ino & (temp_hash_size - 1); ++ group = temp_hash[bucket]; ++ ++ while (group) { ++ if (group->ino == file->ino) ++ break; ++ ++ group = group->next; ++ } ++ ++ if (!group) { ++ group = calloc(1, sizeof(*group)); ++ if (!group) { ++ rpm_free_inode_temp_hash(temp_hash, temp_hash_size); ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate inode group"); ++ return ARCHIVE_FATAL; ++ } ++ ++ group->ino = file->ino; ++ group->files = NULL; ++ group->n_files = 0; ++ group->capacity = 0; ++ ++ group->next = temp_hash[bucket]; ++ temp_hash[bucket] = group; ++ } ++ ++ if (group->n_files >= group->capacity) { ++ group->capacity = group->capacity ? group->capacity * 2 : 8; ++ void *prev_ptr = group->files; ++ ++ group->files = realloc(group->files, group->capacity * sizeof(*group->files)); ++ if (!group->files) { ++ free(prev_ptr); ++ rpm_free_inode_temp_hash(temp_hash, temp_hash_size); ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't grow inode file list"); ++ return ARCHIVE_FATAL; ++ } ++ } ++ ++ group->files[group->n_files++] = file; ++ } ++ ++ rpm->n_inodes = 0; ++ for (i = 0; i < temp_hash_size; i++) { ++ for (struct rpm_inode_temp_entry *e = temp_hash[i]; e; e = e->next) ++ rpm->n_inodes++; ++ } ++ ++ rpm->inodes = calloc(rpm->n_inodes, sizeof(*rpm->inodes)); ++ if (!rpm->inodes) { ++ rpm_free_inode_temp_hash(temp_hash, temp_hash_size); ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate inodes array"); ++ return ARCHIVE_FATAL; ++ } ++ ++ for (i = 0; i < temp_hash_size; i++) { ++ struct rpm_inode_temp_entry *e = temp_hash[i]; ++ while (e) { ++ struct rpm_inode_info *info = &rpm->inodes[ino++]; ++ info->n_files = e->n_files; ++ info->files = e->files; ++ info->n_processed = 0; ++ ++ struct rpm_inode_temp_entry *next = e->next; ++ free(e); ++ e = next; ++ } ++ } ++ ++ free(temp_hash); ++ ++ rpm->inode_hash_size = 1; ++ while (rpm->inode_hash_size < rpm->n_inodes * 2) ++ rpm->inode_hash_size <<= 1; ++ ++ rpm->inode_hash = calloc(rpm->inode_hash_size, sizeof(*rpm->inode_hash)); ++ if (!rpm->inode_hash) { ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate inode hash"); ++ return ARCHIVE_FATAL; ++ } ++ ++ for (i = 0; i < rpm->n_inodes; i++) { ++ uint64_t raw = rpm->inodes[i].files[0]->ino; ++ size_t bucket = raw & (rpm->inode_hash_size - 1); ++ ++ struct inode_hash_entry *e = malloc(sizeof(*e)); ++ if (!e) { ++ archive_set_error(&a->archive, ++ ENOMEM, ++ "Can't allocate inode hash entry"); ++ return ARCHIVE_FATAL; ++ } ++ ++ e->ino = raw; ++ e->info = &rpm->inodes[i]; ++ e->next = rpm->inode_hash[bucket]; ++ rpm->inode_hash[bucket] = e; ++ } ++ ++ __archive_read_consume(a, hlen); ++ ++ return ARCHIVE_OK; ++} ++ ++static struct rpm_inode_info * ++rpm_get_inode(struct archive_read *a, const uint32_t ino) ++{ ++ const struct rpm *rpm = a->format->data; ++ struct inode_hash_entry *e; ++ size_t bucket; ++ ++ if (!rpm->inode_hash) ++ return NULL; ++ ++ bucket = ino & (rpm->inode_hash_size - 1); ++ ++ for (e = rpm->inode_hash[bucket]; e; e = e->next) ++ if (e->ino == ino) ++ return e->info; ++ ++ return NULL; ++} ++ ++static enum rpm_cpio_format ++rpm_get_cpio_format(struct archive_read *a) ++{ ++ const char *magic = __archive_read_ahead(a, CPIO_MAGIC_SIZE, NULL); ++ if (!magic) { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Premature EOF"); ++ return ARCHIVE_FATAL; ++ } ++ ++ if (memcmp(magic, CPIO_MAGIC_STR, CPIO_MAGIC_SIZE) == 0) ++ return CPIO_STR; ++ else if (memcmp(magic, CPIO_MAGIC_SVR4_CRC, CPIO_MAGIC_SIZE) == 0) ++ return CPIO_SVR4_CRC; ++ else if (memcmp(magic, CPIO_MAGIC_SVR4_NOCRC, CPIO_MAGIC_SIZE) == 0) ++ return CPIO_SVR4_NOCRC; ++ else { ++ archive_set_error(&a->archive, ++ ARCHIVE_ERRNO_FILE_FORMAT, ++ "Unrecognized magic"); ++ return CPIO_UNKNOWN; ++ } ++} ++ ++static uint8_t ++rpm_is_eof(struct archive_read *a) ++{ ++ const void *p = __archive_read_ahead(a, CPIO_END_MARK_SIZE, NULL); ++ if (!p) ++ return 1; ++ ++ return memcmp(p, CPIO_END_MARK, CPIO_END_MARK_SIZE) == 0; ++} ++ ++static uint16_t ++rpm_be16_at(const void *buf_start, const void *buf_end, size_t off) ++{ ++ off *= sizeof(uint16_t); ++ ++ if (!buf_start || (buf_end <= buf_start) || ++ (size_t)(buf_end - buf_start) < (off + sizeof(uint16_t))) ++ return 0; ++ ++ return archive_be16dec(buf_start + off); ++} ++ ++static uint32_t ++rpm_be32_at(const void *buf_start, const void *buf_end, size_t off) ++{ ++ off *= sizeof(uint32_t); ++ ++ if (!buf_start || (buf_end <= buf_start) || ++ (size_t)(buf_end - buf_start) < (off + sizeof(uint32_t))) ++ return 0; ++ ++ return archive_be32dec(buf_start + off); ++} ++ ++static uint64_t ++rpm_be64_at(const void *buf_start, const void *buf_end, size_t off) ++{ ++ off *= sizeof(uint64_t); ++ ++ if (!buf_start || (buf_end <= buf_start) || ++ (size_t)(buf_end - buf_start) < (off + sizeof(uint64_t))) ++ return 0; ++ ++ return archive_be64dec(buf_start + off); ++} ++ ++static inline size_t ++rpm_limit_bytes(const size_t bytes, const size_t max) ++{ ++ return (bytes > max ? max : bytes); ++} ++ ++static char * ++rpm_strndup(struct archive_read *a, const char *s, size_t len) ++{ ++ if (s == NULL) ++ return NULL; ++ ++ if (len == 0) ++ len = strnlen(s, STR_SIZE_LIMIT); ++ ++ if (len > STR_SIZE_LIMIT) { ++ archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, ++ "String too long (malformed?)"); ++ return NULL; ++ } ++ ++ return strndup(s, len); ++} ++ ++static char * ++rpm_strread(struct archive_read *a, size_t len) { ++ const void *p; ++ ++ if (len > STR_SIZE_LIMIT) { ++ archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, ++ "String too long"); ++ return NULL; ++ } ++ ++ p = __archive_read_ahead(a, len, NULL); ++ if (!p) { ++ archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, ++ "Truncated string"); ++ return NULL; ++ } ++ ++ return rpm_strndup(a, p, len); ++} ++ ++static void ++rpm_strcat(struct archive_string *a, const void *s, const void *buf_end) ++{ ++ if (!s || s >= buf_end) ++ return; ++ ++ archive_strncat(a, s, rpm_limit_bytes(buf_end - s, STR_SIZE_LIMIT)); ++} ++ ++static const char * ++rpm_strlist_at(const char *p, const void *end, uint64_t i, uint64_t n) ++{ ++ uint64_t k; ++ ++ if (p == NULL || i >= n || (const char *)end < p) ++ return NULL; ++ ++ for (k = 0; k < n; k++) { ++ const uint64_t max_len = rpm_limit_bytes((const char *)end - p, ++ STR_SIZE_LIMIT); ++ const uint64_t len = strnlen(p, max_len); ++ if (len == max_len) ++ /* Unterminated or absurdly long string. */ ++ return NULL; ++ ++ if (k == i) ++ return p; ++ ++ p += len + 1; ++ ++ if (p >= (const char *)end) ++ return NULL; ++ } ++ ++ return NULL; ++} ++ ++static void ++rpm_free_inode_temp_hash(struct rpm_inode_temp_entry **hash, const size_t hash_size) ++{ ++ for (size_t i = 0; i < hash_size; i++) { ++ struct rpm_inode_temp_entry *e = hash[i]; ++ while (e) { ++ struct rpm_inode_temp_entry *next = e->next; ++ free(e->files); ++ free(e); ++ e = next; ++ } ++ } ++ ++ free(hash); ++} +diff --git a/libarchive/test/test_archive_read_support.c b/libarchive/test/test_archive_read_support.c +index b0c9280..bc256a1 100644 +--- a/libarchive/test/test_archive_read_support.c ++++ b/libarchive/test/test_archive_read_support.c +@@ -91,6 +91,7 @@ DEFINE_TEST(test_archive_read_support) + test_filter_or_format(archive_read_support_format_iso9660); + test_filter_or_format(archive_read_support_format_lha); + test_filter_or_format(archive_read_support_format_mtree); ++ test_filter_or_format(archive_read_support_format_rpm); + test_filter_or_format(archive_read_support_format_tar); + test_filter_or_format(archive_read_support_format_xar); + test_filter_or_format(archive_read_support_format_zip); +@@ -140,7 +141,6 @@ DEFINE_TEST(test_archive_read_support) + test_filter_or_format(archive_read_support_filter_lzip); + test_filter_or_format(archive_read_support_filter_lzma); + test_filter_or_format(archive_read_support_filter_none); +- test_filter_or_format(archive_read_support_filter_rpm); + test_filter_or_format(archive_read_support_filter_uu); + test_filter_or_format(archive_read_support_filter_xz); + } +diff --git a/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c b/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c +index 1c421df..550b5be 100644 +--- a/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c ++++ b/libarchive/test/test_read_format_cpio_svr4_bzip2_rpm.c +@@ -97,8 +97,6 @@ DEFINE_TEST(test_read_format_cpio_svr4_bzip2_rpm) + return; + } + assertEqualIntA(a, ARCHIVE_OK, r); +- assertEqualIntA(a, ARCHIVE_OK, +- archive_read_support_filter_rpm(a)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); + extract_reference_file(name); + assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2)); +@@ -121,7 +119,7 @@ DEFINE_TEST(test_read_format_cpio_svr4_bzip2_rpm) + /* Verify that the format detection worked. */ + assertEqualInt(archive_filter_code(a, 0), ARCHIVE_FILTER_BZIP2); + assertEqualString(archive_filter_name(a, 0), "bzip2"); +- assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_NOCRC); ++ assertEqualInt(archive_format(a), ARCHIVE_FORMAT_RPM); + + assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); + assertEqualInt(ARCHIVE_OK, archive_read_free(a)); +diff --git a/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c b/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c +index 6062c48..11dbbb4 100644 +--- a/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c ++++ b/libarchive/test/test_read_format_cpio_svr4_gzip_rpm.c +@@ -97,8 +97,6 @@ DEFINE_TEST(test_read_format_cpio_svr4_gzip_rpm) + return; + } + assertEqualIntA(a, ARCHIVE_OK, r); +- assertEqualIntA(a, ARCHIVE_OK, +- archive_read_support_filter_rpm(a)); + assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a)); + extract_reference_file(name); + assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, name, 2)); +@@ -121,7 +119,7 @@ DEFINE_TEST(test_read_format_cpio_svr4_gzip_rpm) + /* Verify that the format detection worked. */ + assertEqualInt(archive_filter_code(a, 0), ARCHIVE_FILTER_GZIP); + assertEqualString(archive_filter_name(a, 0), "gzip"); +- assertEqualInt(archive_format(a), ARCHIVE_FORMAT_CPIO_SVR4_NOCRC); ++ assertEqualInt(archive_format(a), ARCHIVE_FORMAT_RPM); + + assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); + assertEqualInt(ARCHIVE_OK, archive_read_free(a)); diff --git a/meta/recipes-extended/libarchive/libarchive_3.8.9.bb b/meta/recipes-extended/libarchive/libarchive_3.8.9.bb index 9d7bfef231..f88761fb94 100644 --- a/meta/recipes-extended/libarchive/libarchive_3.8.9.bb +++ b/meta/recipes-extended/libarchive/libarchive_3.8.9.bb @@ -35,6 +35,7 @@ SRC_URI = "https://libarchive.org/downloads/libarchive-${PV}.tar.gz \ file://0001-append_filter-Verify-that-bidder-and-filter-match.patch \ file://0002-append_filter-Use-last-bidder-for-filter.patch \ file://0003-Remove-bidder-name.patch \ + file://0004-Convert-RPM-reader-into-a-proper-format.patch \ " UPSTREAM_CHECK_URI = "https://www.libarchive.org/"