Bump release to match upstream

.dmidecode.metadata

@@ -1 +1 @@
-80898f5e95d905080426fdff7899d81eb4f888c2 SOURCES/dmidecode-3.5.tar.xz
+99b8a9deaf0a003083a5a5fadcb8c016e4ebdaa4 SOURCES/dmidecode-3.3.tar.xz

.gitignore

@@ -1 +1 @@
-SOURCES/dmidecode-3.5.tar.xz
+SOURCES/dmidecode-3.3.tar.xz

SOURCES/0001-Consistently-use-read_file-when-reading-from-a-dump-.patch

@@ -1,64 +0,0 @@
-From c76ddda0ba0aa99a55945e3290095c2ec493c892 Mon Sep 17 00:00:00 2001
-From: Jean Delvare <jdelvare@suse.de>
-Date: Wed, 26 Apr 2023 15:44:27 +0200
-Subject: [PATCH] Consistently use read_file() when reading from a dump file
-
-Use read_file() instead of mem_chunk() to read the entry point from a
-dump file. This is faster, and consistent with how we then read the
-actual DMI table from that dump file.
-
-This made no functional difference so far, which is why it went
-unnoticed for years. But now that a file type check was added to the
-mem_chunk() function, we must stop using it to read from regular
-files.
-
-This will again allow root to use the --from-dump option.
-
-Signed-off-by: Jean Delvare <jdelvare@suse.de>
-Tested-by: Jerry Hoemann <jerry.hoemann@hpe.com>
----
- dmidecode.c | 11 +++++++++--
- 1 file changed, 9 insertions(+), 2 deletions(-)
-
-diff --git a/dmidecode.c b/dmidecode.c
-index 54f59c1..52ddbf1 100644
---- a/dmidecode.c
-+++ b/dmidecode.c
-@@ -6025,17 +6025,25 @@ int main(int argc, char * const argv[])
- 		pr_comment("dmidecode %s", VERSION);
- 
- 	/* Read from dump if so instructed */
-+	size = 0x20;
- 	if (opt.flags & FLAG_FROM_DUMP)
- 	{
- 		if (!(opt.flags & FLAG_QUIET))
- 			pr_info("Reading SMBIOS/DMI data from file %s.",
- 				opt.dumpfile);
--		if ((buf = mem_chunk(0, 0x20, opt.dumpfile)) == NULL)
-+		if ((buf = read_file(0, &size, opt.dumpfile)) == NULL)
- 		{
- 			ret = 1;
- 			goto exit_free;
- 		}
- 
-+		/* Truncated entry point can't be processed */
-+		if (size < 0x20)
-+		{
-+			ret = 1;
-+			goto done;
-+		}
-+
- 		if (memcmp(buf, "_SM3_", 5) == 0)
- 		{
- 			if (smbios3_decode(buf, opt.dumpfile, 0))
-@@ -6059,7 +6067,6 @@ int main(int argc, char * const argv[])
- 	 * contain one of several types of entry points, so read enough for
- 	 * the largest one, then determine what type it contains.
- 	 */
--	size = 0x20;
- 	if (!(opt.flags & FLAG_NO_SYSFS)
- 	 && (buf = read_file(0, &size, SYS_ENTRY_FILE)) != NULL)
- 	{
--- 
-2.43.0
-

SOURCES/0001-dmidecode-Add-new-system-slot-types-from-SMBIOS-spec.patch

@@ -0,0 +1,75 @@
+From 0d40ff02f2ae692c34cfd63b0617abf66ea58c5e Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Wed, 21 Oct 2020 15:24:40 +0200
+Subject: [PATCH 1/2] dmidecode: Add new system slot types from SMBIOS spec
+ 3.4.0
+
+Based on an earlier patch from Prabhakar Pujeri (Dell).
+
+Version 3.4.0 of the SMBIOS specification adds 14 new system slot
+types and updates 2 (DMI type 9).
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
+---
+ dmidecode.c | 26 ++++++++++++++++++++------
+ 1 file changed, 20 insertions(+), 6 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 981fe9697458..0e480d3e337b 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -1931,11 +1931,16 @@ static const char *dmi_slot_type(u8 code)
+ 		"MXM Type IV",
+ 		"MXM 3.0 Type A",
+ 		"MXM 3.0 Type B",
+-		"PCI Express 2 SFF-8639",
+-		"PCI Express 3 SFF-8639",
++		"PCI Express 2 SFF-8639 (U.2)",
++		"PCI Express 3 SFF-8639 (U.2)",
+ 		"PCI Express Mini 52-pin with bottom-side keep-outs",
+ 		"PCI Express Mini 52-pin without bottom-side keep-outs",
+-		"PCI Express Mini 76-pin" /* 0x23 */
++		"PCI Express Mini 76-pin"
++		"PCI Express 4 SFF-8639 (U.2)",
++		"PCI Express 5 SFF-8639 (U.2)",
++		"OCP NIC 3.0 Small Form Factor (SFF)",
++		"OCP NIC 3.0 Large Form Factor (LFF)",
++		"OCP NIC Prior to 3.0" /* 0x28 */
+ 	};
+ 	static const char *type_0x30[] = {
+ 		"CXL FLexbus 1.0" /* 0x30 */
+@@ -1970,18 +1975,27 @@ static const char *dmi_slot_type(u8 code)
+ 		"PCI Express 4 x2",
+ 		"PCI Express 4 x4",
+ 		"PCI Express 4 x8",
+-		"PCI Express 4 x16" /* 0xBD */
++		"PCI Express 4 x16",
++		"PCI Express 5",
++		"PCI Express 5 x1",
++		"PCI Express 5 x2",
++		"PCI Express 5 x4",
++		"PCI Express 5 x8",
++		"PCI Express 5 x16",
++		"PCI Express 6+",
++		"EDSFF E1",
++		"EDSFF E3" /* 0xC6 */
+ 	};
+ 	/*
+ 	 * Note to developers: when adding entries to these lists, check if
+ 	 * function dmi_slot_id below needs updating too.
+ 	 */
+ 
+-	if (code >= 0x01 && code <= 0x23)
++	if (code >= 0x01 && code <= 0x28)
+ 		return type[code - 0x01];
+ 	if (code == 0x30)
+ 		return type_0x30[code - 0x30];
+-	if (code >= 0xA0 && code <= 0xBD)
++	if (code >= 0xA0 && code <= 0xC6)
+ 		return type_0xA0[code - 0xA0];
+ 	return out_of_spec;
+ }
+-- 
+2.17.1
+

SOURCES/0002-dmidecode-Add-new-processor-characteristics-bits-from-SMBIOS-s.patch

@@ -0,0 +1,40 @@
+From b289de9deb325eeef7919a1f4e3ac1f93b099c16 Mon Sep 17 00:00:00 2001
+From: Prabhakar pujeri <prabhakar.pujeri@gmail.com>
+Date: Fri, 23 Oct 2020 17:45:16 +0200
+Subject: [PATCH] Add new processor characteristics bits from SMBIOS spec 3.4.0
+
+* The bit to indicate 128-bit capable processor
+* The bit to indicate processor supports returning ARM64  SoC ID
+
+Signed-off-by: Coiby Xu <coxu@redhat.com>
+---
+ dmidecode.c | 6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 31a49e4..67f6048 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -1388,7 +1388,9 @@ static void dmi_processor_characteristics(const char *attr, u16 code)
+ 		"Hardware Thread",
+ 		"Execute Protection",
+ 		"Enhanced Virtualization",
+-		"Power/Performance Control" /* 7 */
++		"Power/Performance Control",
++		"128-bit Capable"
++		"Arm64 SoC ID" /* 9 */
+ 	};
+ 
+ 	if ((code & 0x00FC) == 0)
+@@ -1398,7 +1400,7 @@ static void dmi_processor_characteristics(const char *attr, u16 code)
+ 		int i;
+ 
+ 		pr_list_start(attr, NULL);
+-		for (i = 2; i <= 7; i++)
++		for (i = 2; i <= 9; i++)
+ 			if (code & (1 << i))
+ 				pr_list_item("%s", characteristics[i - 2]);
+ 		pr_list_end();
+-- 
+2.31.1
+

SOURCES/0003-dmidecode-Missing-comma-in-the-dmi_slot_type.patch

@@ -0,0 +1,45 @@
+From ac6a64496fc99a5cc05ebe4dd7d1b88f60041009 Mon Sep 17 00:00:00 2001
+From: Lianbo Jiang <lijiang@redhat.com>
+Date: Thu, 10 Dec 2020 11:21:21 +0100
+Subject: [PATCH] Missing comma in the dmi_slot_type()
+
+In the initialization of "type", a suspicious concatenated string
+"PCI Express Mini 76-pinPCI Express 4 SFF-8639 (U.2)" is produced
+due to a missing comma between lines.
+
+[JD: Fixed a similar bug in dmi_processor_characteristics.]
+
+Fixes: b289de9deb32 ("Add new processor characteristics bits from SMBIOS spec 3.4.0")
+Fixes: c54348130a2a ("dmidecode: Add new system slot types from SMBIOS spec 3.4.0")
+Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Signed-off-by: Coiby Xu <coxu@redhat.com>
+---
+ dmidecode.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index ac96395..4c98553 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -1389,7 +1389,7 @@ static void dmi_processor_characteristics(const char *attr, u16 code)
+ 		"Execute Protection",
+ 		"Enhanced Virtualization",
+ 		"Power/Performance Control",
+-		"128-bit Capable"
++		"128-bit Capable",
+ 		"Arm64 SoC ID" /* 9 */
+ 	};
+ 
+@@ -1939,7 +1939,7 @@ static const char *dmi_slot_type(u8 code)
+ 		"PCI Express 3 SFF-8639 (U.2)",
+ 		"PCI Express Mini 52-pin with bottom-side keep-outs",
+ 		"PCI Express Mini 52-pin without bottom-side keep-outs",
+-		"PCI Express Mini 76-pin"
++		"PCI Express Mini 76-pin",
+ 		"PCI Express 4 SFF-8639 (U.2)",
+ 		"PCI Express 5 SFF-8639 (U.2)",
+ 		"OCP NIC 3.0 Small Form Factor (SFF)",
+-- 
+2.31.1
+

SOURCES/0004-dmidecode-Skip-details-of-uninstalled-memory-modules.patch

@@ -0,0 +1,35 @@
+From 02ff0488f7d7a0f7e69ff7141236cbc1392c3b4c Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Fri, 30 Oct 2020 15:36:19 +0100
+Subject: [PATCH 2/2] dmidecode: Skip details of uninstalled memory modules
+
+If a memory slot is empty then by definition the fields containing
+the memory module details are irrelevant. Best case they are filled
+with "Unused" and "None", but in some cases they are even invalid
+because the manufacturer did not bother setting the fields to
+valid neutral values. So it is better to not print these fields
+at all, so as to not confuse the user.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
+---
+ dmidecode.c | 3 +++
+ 1 file changed, 3 insertions(+)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 0e480d3e337b..657a1341470b 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -4465,6 +4465,9 @@ static void dmi_decode(const struct dmi_header *h, u16 ver)
+ 				dmi_memory_device_type(data[0x12]));
+ 			dmi_memory_device_type_detail(WORD(data + 0x13));
+ 			if (h->length < 0x17) break;
++			/* If no module is present, the remaining fields are irrelevant */
++			if (WORD(data + 0x0C) == 0)
++				break;
+ 			dmi_memory_device_speed("Speed", WORD(data + 0x15));
+ 			if (h->length < 0x1B) break;
+ 			pr_attr("Manufacturer", "%s",
+-- 
+2.17.1
+

SOURCES/0005-dmidecode-Add-new-processor-upgrades-from-SMBIOS-spec-3.4.0.patch

@@ -0,0 +1,34 @@
+From b3b4c29f38b29a6ac3779ff97363d42fd3061c4a Mon Sep 17 00:00:00 2001
+From: Prabhakar pujeri <prabhakar.pujeri@gmail.com>
+Date: Mon, 19 Oct 2020 14:38:04 +0200
+Subject: [PATCH] Add new processor upgrades from SMBIOS spec 3.4.0
+
+Added 2 more new values (0x3D and 0x3E).
+
+Signed-off-by: Coiby Xu <coxu@redhat.com>
+---
+ dmidecode.c | 6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 97ba941..eb5a5af 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -1355,10 +1355,12 @@ static const char *dmi_processor_upgrade(u8 code)
+ 		"Socket LGA2066",
+ 		"Socket BGA1392",
+ 		"Socket BGA1510",
+-		"Socket BGA1528" /* 0x3C */
++		"Socket BGA1528",
++		"Socket LGA4189",
++		"Socket LGA1200" /* 0x3E */
+ 	};
+ 
+-	if (code >= 0x01 && code <= 0x3C)
++	if (code >= 0x01 && code <= 0x3E)
+ 		return upgrade[code - 0x01];
+ 	return out_of_spec;
+ }
+-- 
+2.31.1
+

SOURCES/0006-dmidecode-Add-new-memory-device-types-from-SMBIOS-spec-3.4.0.patch

@@ -0,0 +1,34 @@
+From 7e25483a392e292c58cea67ba4d052856c2f35d0 Mon Sep 17 00:00:00 2001
+From: Prabhakar pujeri <prabhakar.pujeri@gmail.com>
+Date: Mon, 19 Oct 2020 14:38:04 +0200
+Subject: [PATCH] Add new memory device types from SMBIOS spec 3.4.0
+
+Added 2 more new values (0x22 and 0x23).
+
+Signed-off-by: Coiby Xu <coxu@redhat.com>
+---
+ dmidecode.c | 6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 8b6f5af..97ba941 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -2639,10 +2639,12 @@ static const char *dmi_memory_device_type(u8 code)
+ 		"LPDDR4",
+ 		"Logical non-volatile device",
+ 		"HBM",
+-		"HBM2" /* 0x21 */
++		"HBM2",
++		"DDR5",
++		"LPDDR5" /* 0x23 */
+ 	};
+ 
+-	if (code >= 0x01 && code <= 0x21)
++	if (code >= 0x01 && code <= 0x23)
+ 		return type[code - 0x01];
+ 	return out_of_spec;
+ }
+-- 
+2.31.1
+

SOURCES/0007-dmidecode-Fix-crash-with-u-option.patch

@@ -0,0 +1,34 @@
+From 11e134e54d15e67a64c39a623f492a28df922517 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Tue, 19 Jan 2021 16:26:01 +0100
+Subject: [PATCH] dmidecode: Fix crash with -u option
+
+A segmentation fault was reported with option -u. Turns out to be a
+stupid thinko where the buffer offset was reset at the wrong loop
+depth.
+
+Reported-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+Fixes: da06888d08b9 ("dmidecode: Use the print helpers in dump mode too")
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+---
+ dmidecode.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 572cb1a..69ea0e8 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -248,9 +248,9 @@ static void dmi_dump(const struct dmi_header *h)
+ 			{
+ 				int j, l = strlen(s) + 1;
+ 
+-				off = 0;
+ 				for (row = 0; row < ((l - 1) >> 4) + 1; row++)
+ 				{
++					off = 0;
+ 					for (j = 0; j < 16 && j < l - (row << 4); j++)
+ 						off += sprintf(raw_data + off,
+ 						       j ? " %02X" : "%02X",
+-- 
+2.31.0
+

SOURCES/0008-dmidecode-Split-table-fetching-from-decoding.patch

@@ -0,0 +1,230 @@
+From 8c3a5e0d6578ebda64362d2345ba824167bacd20 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Mon, 20 Feb 2023 14:53:21 +0100
+Subject: [PATCH 1/3] dmidecode: Split table fetching from decoding
+
+Clean up function dmi_table so that it does only one thing:
+* dmi_table() is renamed to dmi_table_get(). It now retrieves the
+  DMI table, but does not process it any longer.
+* Decoding or dumping the table is now done in smbios3_decode(),
+  smbios_decode() and legacy_decode().
+No functional change.
+
+A side effect of this change is that writing the header and body of
+dump files is now done in a single location. This is required to
+further consolidate the writing of dump files.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Reviewed-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmidecode.c | 86 ++++++++++++++++++++++++++++++++++++++---------------
+ 1 file changed, 62 insertions(+), 24 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 4c98553..f743db3 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -5287,8 +5287,9 @@ static void dmi_table_decode(u8 *buf, u32 len, u16 num, u16 ver, u32 flags)
+ 	}
+ }
+ 
+-static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+-		      u32 flags)
++/* Allocates a buffer for the table, must be freed by the caller */
++static u8 *dmi_table_get(off_t base, u32 *len, u16 num, u32 ver,
++			 const char *devmem, u32 flags)
+ {
+ 	u8 *buf;
+ 
+@@ -5307,7 +5308,7 @@ static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+ 		{
+ 			if (num)
+ 				pr_info("%u structures occupying %u bytes.",
+-					num, len);
++					num, *len);
+ 			if (!(opt.flags & FLAG_FROM_DUMP))
+ 				pr_info("Table at 0x%08llX.",
+ 					(unsigned long long)base);
+@@ -5325,19 +5326,19 @@ static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+ 		 * would be the result of the kernel truncating the table on
+ 		 * parse error.
+ 		 */
+-		size_t size = len;
++		size_t size = *len;
+ 		buf = read_file(flags & FLAG_NO_FILE_OFFSET ? 0 : base,
+ 			&size, devmem);
+-		if (!(opt.flags & FLAG_QUIET) && num && size != (size_t)len)
++		if (!(opt.flags & FLAG_QUIET) && num && size != (size_t)*len)
+ 		{
+ 			fprintf(stderr, "Wrong DMI structures length: %u bytes "
+ 				"announced, only %lu bytes available.\n",
+-				len, (unsigned long)size);
++				*len, (unsigned long)size);
+ 		}
+-		len = size;
++		*len = size;
+ 	}
+ 	else
+-		buf = mem_chunk(base, len, devmem);
++		buf = mem_chunk(base, *len, devmem);
+ 
+ 	if (buf == NULL)
+ 	{
+@@ -5347,15 +5348,9 @@ static void dmi_table(off_t base, u32 len, u16 num, u32 ver, const char *devmem,
+ 			fprintf(stderr,
+ 				"Try compiling dmidecode with -DUSE_MMAP.\n");
+ #endif
+-		return;
+ 	}
+ 
+-	if (opt.flags & FLAG_DUMP_BIN)
+-		dmi_table_dump(buf, len);
+-	else
+-		dmi_table_decode(buf, len, num, ver >> 8, flags);
+-
+-	free(buf);
++	return buf;
+ }
+ 
+ 
+@@ -5390,8 +5385,9 @@ static void overwrite_smbios3_address(u8 *buf)
+ 
+ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ {
+-	u32 ver;
++	u32 ver, len;
+ 	u64 offset;
++	u8 *table;
+ 
+ 	/* Don't let checksum run beyond the buffer */
+ 	if (buf[0x06] > 0x20)
+@@ -5417,8 +5413,12 @@ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ 		return 0;
+ 	}
+ 
+-	dmi_table(((off_t)offset.h << 32) | offset.l,
+-		  DWORD(buf + 0x0C), 0, ver, devmem, flags | FLAG_STOP_AT_EOT);
++	/* Maximum length, may get trimmed */
++	len = DWORD(buf + 0x0C);
++	table = dmi_table_get(((off_t)offset.h << 32) | offset.l, &len, 0, ver,
++			      devmem, flags | FLAG_STOP_AT_EOT);
++	if (table == NULL)
++		return 1;
+ 
+ 	if (opt.flags & FLAG_DUMP_BIN)
+ 	{
+@@ -5427,18 +5427,28 @@ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_smbios3_address(crafted);
+ 
++		dmi_table_dump(table, len);
+ 		if (!(opt.flags & FLAG_QUIET))
+ 			pr_comment("Writing %d bytes to %s.", crafted[0x06],
+ 				   opt.dumpfile);
+ 		write_dump(0, crafted[0x06], crafted, opt.dumpfile, 1);
+ 	}
++	else
++	{
++		dmi_table_decode(table, len, 0, ver >> 8,
++				 flags | FLAG_STOP_AT_EOT);
++	}
++
++	free(table);
+ 
+ 	return 1;
+ }
+ 
+ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ {
+-	u16 ver;
++	u16 ver, num;
++	u32 len;
++	u8 *table;
+ 
+ 	/* Don't let checksum run beyond the buffer */
+ 	if (buf[0x05] > 0x20)
+@@ -5478,8 +5488,13 @@ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ 		pr_info("SMBIOS %u.%u present.",
+ 			ver >> 8, ver & 0xFF);
+ 
+-	dmi_table(DWORD(buf + 0x18), WORD(buf + 0x16), WORD(buf + 0x1C),
+-		ver << 8, devmem, flags);
++	/* Maximum length, may get trimmed */
++	len = WORD(buf + 0x16);
++	num = WORD(buf + 0x1C);
++	table = dmi_table_get(DWORD(buf + 0x18), &len, num, ver << 8,
++			      devmem, flags);
++	if (table == NULL)
++		return 1;
+ 
+ 	if (opt.flags & FLAG_DUMP_BIN)
+ 	{
+@@ -5488,27 +5503,43 @@ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_dmi_address(crafted + 0x10);
+ 
++		dmi_table_dump(table, len);
+ 		if (!(opt.flags & FLAG_QUIET))
+ 			pr_comment("Writing %d bytes to %s.", crafted[0x05],
+ 				   opt.dumpfile);
+ 		write_dump(0, crafted[0x05], crafted, opt.dumpfile, 1);
+ 	}
++	else
++	{
++		dmi_table_decode(table, len, num, ver, flags);
++	}
++
++	free(table);
+ 
+ 	return 1;
+ }
+ 
+ static int legacy_decode(u8 *buf, const char *devmem, u32 flags)
+ {
++	u16 ver, num;
++	u32 len;
++	u8 *table;
++
+ 	if (!checksum(buf, 0x0F))
+ 		return 0;
+ 
++	ver = ((buf[0x0E] & 0xF0) << 4) + (buf[0x0E] & 0x0F);
+ 	if (!(opt.flags & FLAG_QUIET))
+ 		pr_info("Legacy DMI %u.%u present.",
+ 			buf[0x0E] >> 4, buf[0x0E] & 0x0F);
+ 
+-	dmi_table(DWORD(buf + 0x08), WORD(buf + 0x06), WORD(buf + 0x0C),
+-		((buf[0x0E] & 0xF0) << 12) + ((buf[0x0E] & 0x0F) << 8),
+-		devmem, flags);
++	/* Maximum length, may get trimmed */
++	len = WORD(buf + 0x06);
++	num = WORD(buf + 0x0C);
++	table = dmi_table_get(DWORD(buf + 0x08), &len, num, ver << 8,
++			      devmem, flags);
++	if (table == NULL)
++		return 1;
+ 
+ 	if (opt.flags & FLAG_DUMP_BIN)
+ 	{
+@@ -5517,11 +5548,18 @@ static int legacy_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 16);
+ 		overwrite_dmi_address(crafted);
+ 
++		dmi_table_dump(table, len);
+ 		if (!(opt.flags & FLAG_QUIET))
+ 			pr_comment("Writing %d bytes to %s.", 0x0F,
+ 				   opt.dumpfile);
+ 		write_dump(0, 0x0F, crafted, opt.dumpfile, 1);
+ 	}
++	else
++	{
++		dmi_table_decode(table, len, num, ver, flags);
++	}
++
++	free(table);
+ 
+ 	return 1;
+ }
+-- 
+2.40.1
+

SOURCES/0009-dmidecode-Write-the-whole-dump-file-at-once.patch

@@ -0,0 +1,191 @@
+From d7dff2691ab3df03a3d7ddda6be714a57ce2fec9 Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Mon, 20 Feb 2023 14:53:25 +0100
+Subject: [PATCH 2/3] dmidecode: Write the whole dump file at once
+
+When option --dump-bin is used, write the whole dump file at once,
+instead of opening and closing the file separately for the table
+and then for the entry point.
+
+As the file writing function is no longer generic, it gets moved
+from util.c to dmidecode.c.
+
+One minor functional change resulting from the new implementation is
+that the entry point is written first now, so the messages printed
+are swapped.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Reviewed-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmidecode.c | 69 +++++++++++++++++++++++++++++++++++++++--------------
+ util.c      | 40 -------------------------------
+ util.h      |  1 -
+ 3 files changed, 51 insertions(+), 59 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index f743db3..cfc7672 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -5170,11 +5170,56 @@ static void dmi_table_string(const struct dmi_header *h, const u8 *data, u16 ver
+ 	}
+ }
+ 
+-static void dmi_table_dump(const u8 *buf, u32 len)
++static int dmi_table_dump(const u8 *ep, u32 ep_len, const u8 *table,
++			  u32 table_len)
+ {
++	FILE *f;
++
++	f = fopen(opt.dumpfile, "wb");
++	if (!f)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fopen");
++		return -1;
++	}
++
++	if (!(opt.flags & FLAG_QUIET))
++		pr_comment("Writing %d bytes to %s.", ep_len, opt.dumpfile);
++	if (fwrite(ep, ep_len, 1, f) != 1)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fwrite");
++		goto err_close;
++	}
++
++	if (fseek(f, 32, SEEK_SET) != 0)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fseek");
++		goto err_close;
++	}
++
+ 	if (!(opt.flags & FLAG_QUIET))
+-		pr_comment("Writing %d bytes to %s.", len, opt.dumpfile);
+-	write_dump(32, len, buf, opt.dumpfile, 0);
++		pr_comment("Writing %d bytes to %s.", table_len, opt.dumpfile);
++	if (fwrite(table, table_len, 1, f) != 1)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fwrite");
++		goto err_close;
++	}
++
++	if (fclose(f))
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("fclose");
++		return -1;
++	}
++
++	return 0;
++
++err_close:
++	fclose(f);
++	return -1;
+ }
+ 
+ static void dmi_table_decode(u8 *buf, u32 len, u16 num, u16 ver, u32 flags)
+@@ -5427,11 +5472,7 @@ static int smbios3_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_smbios3_address(crafted);
+ 
+-		dmi_table_dump(table, len);
+-		if (!(opt.flags & FLAG_QUIET))
+-			pr_comment("Writing %d bytes to %s.", crafted[0x06],
+-				   opt.dumpfile);
+-		write_dump(0, crafted[0x06], crafted, opt.dumpfile, 1);
++		dmi_table_dump(crafted, crafted[0x06], table, len);
+ 	}
+ 	else
+ 	{
+@@ -5503,11 +5544,7 @@ static int smbios_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 32);
+ 		overwrite_dmi_address(crafted + 0x10);
+ 
+-		dmi_table_dump(table, len);
+-		if (!(opt.flags & FLAG_QUIET))
+-			pr_comment("Writing %d bytes to %s.", crafted[0x05],
+-				   opt.dumpfile);
+-		write_dump(0, crafted[0x05], crafted, opt.dumpfile, 1);
++		dmi_table_dump(crafted, crafted[0x05], table, len);
+ 	}
+ 	else
+ 	{
+@@ -5548,11 +5585,7 @@ static int legacy_decode(u8 *buf, const char *devmem, u32 flags)
+ 		memcpy(crafted, buf, 16);
+ 		overwrite_dmi_address(crafted);
+ 
+-		dmi_table_dump(table, len);
+-		if (!(opt.flags & FLAG_QUIET))
+-			pr_comment("Writing %d bytes to %s.", 0x0F,
+-				   opt.dumpfile);
+-		write_dump(0, 0x0F, crafted, opt.dumpfile, 1);
++		dmi_table_dump(crafted, 0x0F, table, len);
+ 	}
+ 	else
+ 	{
+diff --git a/util.c b/util.c
+index 04aaadd..1547096 100644
+--- a/util.c
++++ b/util.c
+@@ -259,46 +259,6 @@ void *mem_chunk(off_t base, size_t len, const char *devmem)
+ 	return p;
+ }
+ 
+-int write_dump(size_t base, size_t len, const void *data, const char *dumpfile, int add)
+-{
+-	FILE *f;
+-
+-	f = fopen(dumpfile, add ? "r+b" : "wb");
+-	if (!f)
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fopen");
+-		return -1;
+-	}
+-
+-	if (fseek(f, base, SEEK_SET) != 0)
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fseek");
+-		goto err_close;
+-	}
+-
+-	if (fwrite(data, len, 1, f) != 1)
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fwrite");
+-		goto err_close;
+-	}
+-
+-	if (fclose(f))
+-	{
+-		fprintf(stderr, "%s: ", dumpfile);
+-		perror("fclose");
+-		return -1;
+-	}
+-
+-	return 0;
+-
+-err_close:
+-	fclose(f);
+-	return -1;
+-}
+-
+ /* Returns end - start + 1, assuming start < end */
+ u64 u64_range(u64 start, u64 end)
+ {
+diff --git a/util.h b/util.h
+index 3094cf8..ef24eb9 100644
+--- a/util.h
++++ b/util.h
+@@ -27,5 +27,4 @@
+ int checksum(const u8 *buf, size_t len);
+ void *read_file(off_t base, size_t *len, const char *filename);
+ void *mem_chunk(off_t base, size_t len, const char *devmem);
+-int write_dump(size_t base, size_t len, const void *data, const char *dumpfile, int add);
+ u64 u64_range(u64 start, u64 end);
+-- 
+2.40.1
+

SOURCES/0010-dmidecode-Do-not-let-dump-bin-overwrite-an-existing-.patch

@@ -0,0 +1,56 @@
+From 84c0bf52d15a6d9d4cb3a1369320b5d653217c6b Mon Sep 17 00:00:00 2001
+From: Jean Delvare <jdelvare@suse.de>
+Date: Mon, 20 Feb 2023 14:53:31 +0100
+Subject: [PATCH] dmidecode: Do not let --dump-bin overwrite an existing file
+
+Make sure that the file passed to option --dump-bin does not already
+exist. In practice, it is rather unlikely that an honest user would
+want to overwrite an existing dump file, while this possibility
+could be used by a rogue user to corrupt a system file.
+
+Signed-off-by: Jean Delvare <jdelvare@suse.de>
+Reviewed-by: Jerry Hoemann <jerry.hoemann@hpe.com>
+---
+ dmidecode.c | 14 ++++++++++++--
+ 1 file changed, 12 insertions(+), 2 deletions(-)
+
+diff --git a/dmidecode.c b/dmidecode.c
+index 9d22b72..f4cde27 100644
+--- a/dmidecode.c
++++ b/dmidecode.c
+@@ -60,6 +60,7 @@
+  *    https://www.dmtf.org/sites/default/files/DSP0270_1.0.1.pdf
+  */
+ 
++#include <fcntl.h>
+ #include <stdio.h>
+ #include <string.h>
+ #include <strings.h>
+@@ -5156,13 +5157,22 @@ static void dmi_table_string(const struct dmi_header *h, const u8 *data, u16 ver
+ static int dmi_table_dump(const u8 *ep, u32 ep_len, const u8 *table,
+ 			  u32 table_len)
+ {
++	int fd;
+ 	FILE *f;
+ 
+-	f = fopen(opt.dumpfile, "wb");
++	fd = open(opt.dumpfile, O_WRONLY|O_CREAT|O_EXCL, 0666);
++	if (fd == -1)
++	{
++		fprintf(stderr, "%s: ", opt.dumpfile);
++		perror("open");
++		return -1;
++	}
++
++	f = fdopen(fd, "wb");
+ 	if (!f)
+ 	{
+ 		fprintf(stderr, "%s: ", opt.dumpfile);
+-		perror("fopen");
++		perror("fdopen");
+ 		return -1;
+ 	}
+ 
+-- 
+2.40.1
+

SPECS/dmidecode.spec

@@ -1,13 +1,22 @@
 Summary:        Tool to analyse BIOS DMI data
 Name:           dmidecode
-Version:        3.5
+Version:        3.3
-Release:        1%{?dist}
+Release:        5%{?dist}
 Epoch:          1
 License:        GPLv2+
 Source0:        http://download.savannah.gnu.org/releases/%{name}/%{name}-%{version}.tar.xz
 URL:            http://www.nongnu.org/dmidecode/
 
-Patch0:         0001-Consistently-use-read_file-when-reading-from-a-dump-.patch
+Patch0:        0001-dmidecode-Add-new-system-slot-types-from-SMBIOS-spec.patch
+Patch1:        0002-dmidecode-Add-new-processor-characteristics-bits-from-SMBIOS-s.patch
+Patch2:        0003-dmidecode-Missing-comma-in-the-dmi_slot_type.patch
+Patch3:        0004-dmidecode-Skip-details-of-uninstalled-memory-modules.patch
+Patch4:        0005-dmidecode-Add-new-processor-upgrades-from-SMBIOS-spec-3.4.0.patch
+Patch5:        0006-dmidecode-Add-new-memory-device-types-from-SMBIOS-spec-3.4.0.patch
+Patch6:        0007-dmidecode-Fix-crash-with-u-option.patch
+Patch7:        0008-dmidecode-Split-table-fetching-from-decoding.patch
+Patch8:        0009-dmidecode-Write-the-whole-dump-file-at-once.patch
+Patch9:        0010-dmidecode-Do-not-let-dump-bin-overwrite-an-existing-.patch
 
 BuildRequires:  gcc make
 ExclusiveArch:  %{ix86} x86_64 ia64 aarch64
@@ -45,11 +54,8 @@ make %{?_smp_mflags} DESTDIR=%{buildroot} prefix=%{_prefix} install-bin install-
 %{_mandir}/man8/*
 
 %changelog
-* Wed Dec 20 2023 Lichen Liu <lichliu@redhat.com> - 1:3.5-1
+* Fri Jun 09 2023 Lichen Liu <lichliu@redhat.com> - 1:3.3-5
-- Rebase to upstream 3.5
+- Resolves: rhbz#2186859
-
-* Thu Jun 08 2023 Lichen Liu <lichliu@redhat.com> - 1:3.3-5
-- Resolves: rhbz#2186860
 
 * Wed Jan 26 2022 Coiby Xu <coxu@redhat.com> - 1:3.3-4
 - Resolves: rhbz#2042224