Merge tag 'v2025.01-rc3' into next

Prepare v2025.01-rc3

5 files changed, 219 insertions, 5 deletions

diff --git a/test/cmd/Makefile b/test/cmd/Makefile
index 0055330dbec..583e7c2eec4 100644
--- a/test/cmd/Makefile
+++ b/test/cmd/Makefile
@@ -5,6 +5,7 @@
 
 obj-y += cmd_ut_cmd.o
 
+obj-$(CONFIG_$(XPL_)CMDLINE) += command.o
 ifdef CONFIG_HUSH_PARSER
 obj-$(CONFIG_CONSOLE_RECORD) += test_echo.o
 endif
@@ -18,6 +19,7 @@ obj-$(CONFIG_CMD_BDI) += bdinfo.o
 obj-$(CONFIG_COREBOOT_SYSINFO) += coreboot.o
 obj-$(CONFIG_CMD_FDT) += fdt.o
 obj-$(CONFIG_CONSOLE_TRUETYPE) += font.o
+obj-$(CONFIG_CMD_HASH) += hash.o
 obj-$(CONFIG_CMD_HISTORY) += history.o
 obj-$(CONFIG_CMD_LOADM) += loadm.o
 obj-$(CONFIG_CMD_MEMINFO) += meminfo.o
diff --git a/test/cmd/bdinfo.c b/test/cmd/bdinfo.c
index 770b3bfb560..bb419ab2394 100644
--- a/test/cmd/bdinfo.c
+++ b/test/cmd/bdinfo.c
@@ -107,7 +107,7 @@ static int lmb_test_dump_region(struct unit_test_state *uts,
 	enum lmb_flags flags;
 	int i;
 
-	ut_assert_nextline(" %s.count = 0x%hx", name, lmb_rgn_lst->count);
+	ut_assert_nextline(" %s.count = %#x", name, lmb_rgn_lst->count);
 
 	for (i = 0; i < lmb_rgn_lst->count; i++) {
 		base = rgn[i].base;
@@ -119,7 +119,7 @@ static int lmb_test_dump_region(struct unit_test_state *uts,
 			ut_assert_nextlinen(" %s[%d]\t[", name, i);
 			continue;
 		}
-		ut_assert_nextlinen(" %s[%d]\t[0x%llx-0x%llx], 0x%08llx bytes flags: ",
+		ut_assert_nextlinen(" %s[%d]\t[%#llx-%#llx], %#llx bytes, flags: ",
 				    name, i, base, end, size);
 	}
 
diff --git a/test/cmd/command.c b/test/cmd/command.c
new file mode 100644
index 00000000000..5ec93d490ba
--- /dev/null
+++ b/test/cmd/command.c
@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2012, The Chromium Authors
+ */
+
+#define DEBUG
+
+#include <command.h>
+#include <env.h>
+#include <log.h>
+#include <string.h>
+#include <linux/errno.h>
+#include <test/cmd.h>
+#include <test/ut.h>
+
+static const char test_cmd[] = "setenv list 1\n setenv list ${list}2; "
+		"setenv list ${list}3\0"
+		"setenv list ${list}4";
+
+static int command_test(struct unit_test_state *uts)
+{
+	char long_str[CONFIG_SYS_CBSIZE + 42];
+
+	printf("%s: Testing commands\n", __func__);
+	run_command("env default -f -a", 0);
+
+	/* commands separated by \n */
+	run_command_list("setenv list 1\n setenv list ${list}1", -1, 0);
+	ut_assert(!strcmp("11", env_get("list")));
+
+	/* command followed by \n and nothing else */
+	run_command_list("setenv list 1${list}\n", -1, 0);
+	ut_assert(!strcmp("111", env_get("list")));
+
+	/* a command string with \0 in it. Stuff after \0 should be ignored */
+	run_command("setenv list", 0);
+	run_command_list(test_cmd, sizeof(test_cmd), 0);
+	ut_assert(!strcmp("123", env_get("list")));
+
+	/*
+	 * a command list where we limit execution to only the first command
+	 * using the length parameter.
+	 */
+	run_command_list("setenv list 1\n setenv list ${list}2; "
+		"setenv list ${list}3", strlen("setenv list 1"), 0);
+	ut_assert(!strcmp("1", env_get("list")));
+
+	ut_asserteq(1, run_command("false", 0));
+	ut_assertok(run_command("echo", 0));
+	ut_asserteq(1, run_command_list("false", -1, 0));
+	ut_assertok(run_command_list("echo", -1, 0));
+
+#ifdef CONFIG_HUSH_PARSER
+	run_command("setenv foo 'setenv black 1\nsetenv adder 2'", 0);
+	run_command("run foo", 0);
+	ut_assertnonnull(env_get("black"));
+	ut_asserteq(0, strcmp("1", env_get("black")));
+	ut_assertnonnull(env_get("adder"));
+	ut_asserteq(0, strcmp("2", env_get("adder")));
+#endif
+
+	ut_assertok(run_command("", 0));
+	ut_assertok(run_command(" ", 0));
+
+	ut_asserteq(1, run_command("'", 0));
+
+	/* Variadic function test-cases */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-zero-length"
+	ut_assertok(run_commandf(""));
+#pragma GCC diagnostic pop
+	ut_assertok(run_commandf(" "));
+	ut_asserteq(1, run_commandf("'"));
+
+	ut_assertok(run_commandf("env %s %s", "delete -f", "list"));
+	/*
+	 * Expected: "## Error: "list" not defined"
+	 * (disabled to avoid pytest bailing out)
+	 *
+	 * ut_asserteq(1, run_commandf("printenv list"));
+	 */
+
+	memset(long_str, 'x', sizeof(long_str));
+	ut_asserteq(-ENOSPC, run_commandf("Truncation case: %s", long_str));
+
+	if (IS_ENABLED(CONFIG_HUSH_PARSER)) {
+		ut_assertok(run_commandf("env %s %s %s %s", "delete -f",
+					 "adder", "black", "foo"));
+		ut_assertok(run_commandf(
+			"setenv foo 'setenv %s 1\nsetenv %s 2'",
+			"black", "adder"));
+		ut_assertok(run_command("run foo", 0));
+		ut_assertnonnull(env_get("black"));
+		ut_asserteq(0, strcmp("1", env_get("black")));
+		ut_assertnonnull(env_get("adder"));
+		ut_asserteq(0, strcmp("2", env_get("adder")));
+	}
+
+	/* Clean up before exit */
+	ut_assertok(run_command("env default -f -a", 0));
+
+	/* put back the FDT environment */
+	ut_assertok(env_set("from_fdt", "yes"));
+
+	printf("%s: Everything went swimmingly\n", __func__);
+	return 0;
+}
+CMD_TEST(command_test, 0);
diff --git a/test/cmd/hash.c b/test/cmd/hash.c
new file mode 100644
index 00000000000..296dd762b31
--- /dev/null
+++ b/test/cmd/hash.c
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Tests for hash command
+ *
+ * Copyright 2024, Heinrich Schuchardt <[email protected]>
+ */
+
+#include <command.h>
+#include <dm.h>
+#include <dm/test.h>
+#include <test/test.h>
+#include <test/ut.h>
+
+static int dm_test_cmd_hash_md5(struct unit_test_state *uts)
+{
+	if (!CONFIG_IS_ENABLED(MD5)) {
+		ut_assert(run_command("hash md5 $loadaddr 0", 0));
+
+		return 0;
+	}
+
+	ut_assertok(run_command("hash md5 $loadaddr 0", 0));
+	console_record_readline(uts->actual_str, sizeof(uts->actual_str));
+	ut_asserteq_ptr(uts->actual_str,
+			strstr(uts->actual_str, "md5 for "));
+	ut_assert(strstr(uts->actual_str,
+			 "d41d8cd98f00b204e9800998ecf8427e"));
+	ut_assert_console_end();
+
+	ut_assertok(run_command("hash md5 $loadaddr 0 foo; echo $foo", 0));
+	console_record_readline(uts->actual_str, sizeof(uts->actual_str));
+	ut_asserteq_ptr(uts->actual_str,
+			strstr(uts->actual_str, "md5 for "));
+	ut_assert(strstr(uts->actual_str,
+			 "d41d8cd98f00b204e9800998ecf8427e"));
+	ut_assertok(ut_check_console_line(uts,
+					  "d41d8cd98f00b204e9800998ecf8427e"));
+
+	if (!CONFIG_IS_ENABLED(HASH_VERIFY)) {
+		ut_assert(run_command("hash -v sha256 $loadaddr 0 foo", 0));
+		ut_assertok(ut_check_console_line(
+				uts, "hash - compute hash message digest"));
+
+		return 0;
+	}
+
+	ut_assertok(run_command("hash -v md5 $loadaddr 0 foo", 0));
+	ut_assert_console_end();
+
+	env_set("foo", "ffffffffffffffffffffffffffffffff");
+	ut_assert(run_command("hash -v md5 $loadaddr 0 foo", 0));
+	console_record_readline(uts->actual_str, sizeof(uts->actual_str));
+	ut_assert(strstr(uts->actual_str, "!="));
+	ut_assert_console_end();
+
+	return 0;
+}
+DM_TEST(dm_test_cmd_hash_md5, UTF_CONSOLE);
+
+static int dm_test_cmd_hash_sha256(struct unit_test_state *uts)
+{
+	if (!CONFIG_IS_ENABLED(SHA256)) {
+		ut_assert(run_command("hash sha256 $loadaddr 0", 0));
+
+		return 0;
+	}
+
+	ut_assertok(run_command("hash sha256 $loadaddr 0", 0));
+	console_record_readline(uts->actual_str, sizeof(uts->actual_str));
+	ut_asserteq_ptr(uts->actual_str,
+			strstr(uts->actual_str, "sha256 for "));
+	ut_assert(strstr(uts->actual_str,
+			 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"));
+	ut_assert_console_end();
+
+	ut_assertok(run_command("hash sha256 $loadaddr 0 foo; echo $foo", 0));
+	console_record_readline(uts->actual_str, sizeof(uts->actual_str));
+	ut_asserteq_ptr(uts->actual_str,
+			strstr(uts->actual_str, "sha256 for "));
+	ut_assert(strstr(uts->actual_str,
+			 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"));
+	ut_assertok(ut_check_console_line(
+			uts, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"));
+
+	if (!CONFIG_IS_ENABLED(HASH_VERIFY)) {
+		ut_assert(run_command("hash -v sha256 $loadaddr 0 foo", 0));
+		ut_assertok(ut_check_console_line(
+				uts, "hash - compute hash message digest"));
+
+		return 0;
+	}
+
+	ut_assertok(run_command("hash -v sha256 $loadaddr 0 foo", 0));
+	ut_assert_console_end();
+
+	env_set("foo", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+	ut_assert(run_command("hash -v sha256 $loadaddr 0 foo", 0));
+	console_record_readline(uts->actual_str, sizeof(uts->actual_str));
+	ut_assert(strstr(uts->actual_str, "!="));
+	ut_assert_console_end();
+
+	return 0;
+}
+DM_TEST(dm_test_cmd_hash_sha256, UTF_CONSOLE);
diff --git a/test/cmd/mbr.c b/test/cmd/mbr.c
index b14137e589a..d137378a3be 100644
--- a/test/cmd/mbr.c
+++ b/test/cmd/mbr.c
@@ -257,8 +257,8 @@ static int mbr_test_run(struct unit_test_state *uts)
 		strlen(mbr_parts_p3) +
 		max(strlen(mbr_parts_p4), strlen(mbr_parts_p5)) +
 		strlen(mbr_parts_tail);
-	ut_assertf(sizeof(mbr_parts_buf) >= mbr_parts_max, "Buffer avail: %ld; buffer req: %ld\n",
-		sizeof(mbr_parts_buf), mbr_parts_max);
+	ut_assertf(sizeof(mbr_parts_buf) >= mbr_parts_max, "Buffer avail: %zd; buffer req: %ld\n",
+		   sizeof(mbr_parts_buf), mbr_parts_max);
 
 	mbr_wbuf = map_sysmem(mbr_wa, BLKSZ);
 	ebr_wbuf = map_sysmem(ebr_wa, BLKSZ);
@@ -277,7 +277,7 @@ static int mbr_test_run(struct unit_test_state *uts)
 				 (ulong)0xbffe00 / BLKSZ));
 
 	/* Test one MBR partition */
-	init_write_buffers(mbr_wbuf, sizeof(mbr_wbuf), ebr_wbuf, sizeof(ebr_wbuf), __LINE__);
+	init_write_buffers(mbr_wbuf, BLKSZ, ebr_wbuf, BLKSZ, __LINE__);
 	ut_assertok(build_mbr_parts(mbr_parts_buf, sizeof(mbr_parts_buf), 1));
 	ut_assertok(run_commandf("write mmc 6:0 %lx 0 1", mbr_wa));
 	memset(rbuf, '\0', BLKSZ);