nrf_rpc: Add functionality for invoking remote shell cmd via rpc

The functionality allows the nrf_rpc client to invoke nrf_rpc server
shell command and obtain the command's output.

This commit adds the new nrf_rpc client shell subcommand: 'remote_shell'

Example of use:

rpc remote_shell device list

devices:
- clock@10e000 (READY)
- gpio@10a000 (READY)
- gpio@d8200 (READY)
- gpio@50400 (READY)
- psa-rng (READY)
- uart@c7000 (READY)
- uart@c6000 (READY)
- spi@4a000 (READY)
- rram-controller@5004b000 (READY)
- mx25r6435f@0 (READY)
- ieee802154 (READY)
- temp@d7000 (READY)

Signed-off-by: Lukasz Maciejonczyk <lukasz.maciejonczyk@nordicsemi.no>

Author: lmaciejonczyk

include/nrf_rpc/nrf_rpc_dev_info.h

@@ -19,7 +19,17 @@
  *  @retval version of the remote on success.
  *  @retval NULL on failure.
  */
-const char *nrf_rpc_get_ncs_commit_sha(void);
+char *nrf_rpc_get_ncs_commit_sha(void);
+
+/** @brief Invoke the remote server shell command.
+ *
+ *  @param[in] argc Number of arguments.
+ *  @param[in] argv Array of arguments.
+ *
+ *  @retval Command output on success.
+ *  @retval NULL on failure.
+ */
+char *nrf_rpc_invoke_remote_shell_cmd(size_t argc, char *argv[]);
 
 /**
  * @}

samples/nrf_rpc/protocols_serialization/client/src/dev_info_shell.c

@@ -9,16 +9,41 @@
 
 static int remote_version_cmd(const struct shell *sh, size_t argc, char *argv[])
 {
-	const char *version = nrf_rpc_get_ncs_commit_sha();
+	char *version = nrf_rpc_get_ncs_commit_sha();
+
+	if (!version) {
+		shell_error(sh, "Failed to get remote version");
+		return -ENOEXEC;
+	}
 
 	shell_print(sh, "Remote version: %s", version);
 
+	k_free(version);
+
+	return 0;
+}
+
+static int remote_shell_cmd(const struct shell *sh, size_t argc, char *argv[])
+{
+	char *output = nrf_rpc_invoke_remote_shell_cmd(argc - 1, argv + 1);
+
+	if (!output) {
+		shell_error(sh, "Failed to invoke remote shell command");
+		return -ENOEXEC;
+	}
+
+	shell_print(sh, "%s", output);
+
+	k_free(output);
+
 	return 0;
 }
 
 SHELL_STATIC_SUBCMD_SET_CREATE(util_cmds,
 			       SHELL_CMD_ARG(remote_version, NULL, "Get server version",
 					     remote_version_cmd, 1, 0),
+			       SHELL_CMD_ARG(remote_shell, NULL, "Call remote shell command",
+					     remote_shell_cmd, 2, 255),
 			       SHELL_SUBCMD_SET_END);
 
 SHELL_CMD_ARG_REGISTER(rpc, &util_cmds, "nRF RPC utility commands", NULL, 1, 0);

samples/nrf_rpc/protocols_serialization/server/Kconfig

@@ -27,6 +27,9 @@ config ZMS
 config NVS
 	default y if !(SOC_FLASH_NRF_RRAM || SOC_FLASH_NRF_MRAM)
 
+config SHELL_BACKEND_SERIAL
+	default n if NRF_RPC_REMOTE_SHELL
+
 if LOG
 
 choice LOG_MODE

subsys/nrf_rpc/dev_info/Kconfig

@@ -37,4 +37,16 @@ config DEV_INFO_RPC_INITIALIZE_NRF_RPC
 	  Initialize nRF RPC library during the system startup. Disabling this
 	  option allow user to initialize it in a different way.
 
+config NRF_RPC_REMOTE_SHELL
+	bool "Remote shell"
+	depends on NRF_RPC_DEV_INFO_SERVER
+	select SHELL
+	select SHELL_BACKEND_DUMMY
+	default y
+	help
+	  Enable access to remote shell via NRF_RPC.
+
+config SHELL_BACKEND_DUMMY_BUF_SIZE
+	default 1024 if NRF_RPC_REMOTE_SHELL
+
 endif # NRF_RPC_DEV_INFO

subsys/nrf_rpc/dev_info/client/dev_info_client.c

@@ -13,26 +13,111 @@
 
 NRF_RPC_GROUP_DECLARE(dev_info_group);
 
-static char version[16];
+#define MAX_ARGV_SIZE 255
 
-const char *nrf_rpc_get_ncs_commit_sha(void)
+static char *allocate_buffer_and_decode_str(struct nrf_rpc_cbor_ctx *ctx,
+					    enum def_info_rpc_cmd_server cmd)
 {
-	struct nrf_rpc_cbor_ctx ctx;
-	size_t size = ARRAY_SIZE(version);
+	const void *ptr;
+	size_t len;
+	char *output = NULL;
+
+	ptr = nrf_rpc_decode_str_ptr_and_len(ctx, &len);
+
+	if (ptr) {
+		output = k_malloc(len + 1);
+		if (output) {
+			memcpy(output, ptr, len);
+			output[len] = '\0';
+		}
+	}
+
+	if (!nrf_rpc_decoding_done_and_check(&dev_info_group, ctx)) {
+		nrf_rpc_err(-EBADMSG, NRF_RPC_ERR_SRC_RECV, &dev_info_group, cmd,
+			    NRF_RPC_PACKET_TYPE_RSP);
+		k_free(output);
+		return NULL;
+	}
 
-	memset(version, 0, ARRAY_SIZE(version));
+	return output;
+}
+
+char *nrf_rpc_get_ncs_commit_sha(void)
+{
+	struct nrf_rpc_cbor_ctx ctx;
 
 	NRF_RPC_CBOR_ALLOC(&dev_info_group, ctx, 0);
 
 	nrf_rpc_cbor_cmd_rsp_no_err(&dev_info_group, DEV_INFO_RPC_GET_VERSION, &ctx);
 
-	nrf_rpc_decode_str(&ctx, version, size);
+	return allocate_buffer_and_decode_str(&ctx, DEV_INFO_RPC_GET_VERSION);
+}
+
+static size_t get_cmd_len(size_t argc, char *argv[])
+{
+	size_t len = 0;
+
+	for (size_t i = 0; i < argc; i++) {
+		if (argv[i] == NULL) {
+			return 0;
+		}
+
+		len += strnlen(argv[i], MAX_ARGV_SIZE) + 1;
+	}
+
+	return len;
+}
+
+static size_t create_cmd_line(char *buffer, size_t cmd_buffer_size, size_t argc, char *argv[])
+{
+	size_t len = 0;
+
+	for (size_t i = 0; i < argc; i++) {
+		if (argv[i] == NULL) {
+			return 0;
+		}
+
+		size_t arg_len = strnlen(argv[i], MAX_ARGV_SIZE);
+
+		if (len + arg_len + 1 > cmd_buffer_size) {
+			return 0;
+		}
+		memcpy(buffer + len, argv[i], arg_len);
+		len += arg_len;
+		buffer[len++] = ' ';
+	}
+
+	buffer[len - 1] = '\0';
 
-	if (!nrf_rpc_decoding_done_and_check(&dev_info_group, &ctx)) {
-		nrf_rpc_err(-EBADMSG, NRF_RPC_ERR_SRC_RECV, &dev_info_group,
-			    DEV_INFO_RPC_GET_VERSION, NRF_RPC_PACKET_TYPE_RSP);
+	return len;
+}
+
+char *nrf_rpc_invoke_remote_shell_cmd(size_t argc, char *argv[])
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	size_t cmd_buffer_size = get_cmd_len(argc, argv);
+	char *cmd_buffer = k_malloc(cmd_buffer_size);
+
+	if (!cmd_buffer) {
+		nrf_rpc_err(-ENOMEM, NRF_RPC_ERR_SRC_SEND, &dev_info_group,
+			    DEV_INFO_RPC_INVOKE_SHELL_CMD, NRF_RPC_PACKET_TYPE_CMD);
 		return NULL;
 	}
 
-	return version;
+	size_t cmd_len = create_cmd_line(cmd_buffer, cmd_buffer_size, argc, argv);
+
+	if (!cmd_len) {
+		nrf_rpc_err(-ENOMEM, NRF_RPC_ERR_SRC_SEND, &dev_info_group,
+			    DEV_INFO_RPC_INVOKE_SHELL_CMD, NRF_RPC_PACKET_TYPE_CMD);
+		k_free(cmd_buffer);
+		return NULL;
+	}
+
+	NRF_RPC_CBOR_ALLOC(&dev_info_group, ctx, 3 + cmd_len);
+
+	nrf_rpc_encode_str(&ctx, cmd_buffer, cmd_len);
+
+	nrf_rpc_cbor_cmd_rsp_no_err(&dev_info_group, DEV_INFO_RPC_INVOKE_SHELL_CMD, &ctx);
+
+	return allocate_buffer_and_decode_str(&ctx, DEV_INFO_RPC_INVOKE_SHELL_CMD);
 }

subsys/nrf_rpc/dev_info/common/dev_info_rpc_ids.h

@@ -9,8 +9,9 @@
 
 /** @brief Command IDs accepted by the device information over RPC server.
  */
-enum ot_rpc_cmd_server {
+enum def_info_rpc_cmd_server {
 	DEV_INFO_RPC_GET_VERSION = 0,
+	DEV_INFO_RPC_INVOKE_SHELL_CMD = 1,
 };
 
 #endif /* DEV_INFO_RPC_IDS_H_ */

subsys/nrf_rpc/dev_info/server/dev_info_server.c

@@ -10,6 +10,10 @@
 #include <ncs_commit.h>
 #include <dev_info_rpc_ids.h>
 
+#if defined(CONFIG_NRF_RPC_REMOTE_SHELL)
+#include <zephyr/shell/shell_dummy.h>
+#endif
+
 NRF_RPC_GROUP_DECLARE(dev_info_group);
 
 static void get_server_version(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx,
@@ -34,3 +38,68 @@ static void get_server_version(const struct nrf_rpc_group *group, struct nrf_rpc
 
 NRF_RPC_CBOR_CMD_DECODER(dev_info_group, get_server_version, DEV_INFO_RPC_GET_VERSION,
 			 get_server_version, NULL);
+
+#if defined(CONFIG_NRF_RPC_REMOTE_SHELL)
+static int shell_exec(const char *line)
+{
+	const struct shell *sh = shell_backend_dummy_get_ptr();
+
+	shell_backend_dummy_clear_output(sh);
+	return shell_execute_cmd(sh, line);
+}
+
+const char *shell_get_output(size_t *len)
+{
+	return shell_backend_dummy_get_output(shell_backend_dummy_get_ptr(), len);
+}
+#endif /* CONFIG_NRF_RPC_REMOTE_SHELL */
+
+static void remote_shell_cmd(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx,
+			     void *handler_data)
+{
+	struct nrf_rpc_cbor_ctx rsp_ctx;
+	char *cmd_buffer = NULL;
+	const void *ptr;
+	size_t len = 0;
+	const char *output = NULL;
+
+	ptr = nrf_rpc_decode_str_ptr_and_len(ctx, &len);
+
+	if (ptr) {
+		cmd_buffer = k_malloc(len + 1);
+		if (cmd_buffer) {
+			memcpy(cmd_buffer, ptr, len);
+			cmd_buffer[len] = '\0';
+		}
+	}
+
+	if (!nrf_rpc_decoding_done_and_check(group, ctx)) {
+		nrf_rpc_err(-EBADMSG, NRF_RPC_ERR_SRC_RECV, group, DEV_INFO_RPC_INVOKE_SHELL_CMD,
+			    NRF_RPC_PACKET_TYPE_CMD);
+		goto exit;
+	}
+
+	if (!ptr || !cmd_buffer) {
+		goto exit;
+	}
+
+#if defined(CONFIG_NRF_RPC_REMOTE_SHELL)
+	shell_exec(cmd_buffer);
+	output = shell_get_output(&len);
+#else
+	output = "Remote shell is disabled on the server. "
+		 "Enable CONFIG_NRF_RPC_REMOTE_SHELL to use it.";
+	len = strnlen(output, 255);
+#endif /* CONFIG_NRF_RPC_REMOTE_SHELL */
+
+	NRF_RPC_CBOR_ALLOC(group, rsp_ctx, 3 + len);
+
+	nrf_rpc_encode_str(&rsp_ctx, output, len);
+	nrf_rpc_cbor_rsp_no_err(group, &rsp_ctx);
+
+exit:
+	k_free(cmd_buffer);
+}
+
+NRF_RPC_CBOR_CMD_DECODER(dev_info_group, remote_shell_cmd, DEV_INFO_RPC_INVOKE_SHELL_CMD,
+			 remote_shell_cmd, NULL);

tests/subsys/nrf_rpc/dev_info/client/src/dev_info_suite.c

@@ -40,4 +40,26 @@ ZTEST(dev_info_rpc_client, test_get_version)
 	zexpect_str_equal(commit, version);
 }
 
+ZTEST(dev_info_rpc_client, test_invoke_shell_cmd)
+{
+
+	const size_t argc = 2;
+	static const char *const argv[] = {"say", "hello", NULL};
+	const char *hello = "HelloWorld\0";
+	char *reply = NULL;
+
+	mock_nrf_rpc_tr_expect_add(
+		RPC_CMD(DEV_INFO_RPC_INVOKE_SHELL_CMD, 0x6a, 's', 'a', 'y', ' ', 'h', 'e', 'l', 'l',
+			'o', '\0'),
+		RPC_RSP(0x6b, 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd', '\0'));
+	reply = nrf_rpc_invoke_remote_shell_cmd(argc, (char **)argv);
+	mock_nrf_rpc_tr_expect_done();
+
+	zexpect_str_equal(hello, reply);
+
+	if (reply) {
+		k_free(reply);
+	}
+}
+
 ZTEST_SUITE(dev_info_rpc_client, NULL, NULL, tc_setup, NULL, NULL);

tests/subsys/nrf_rpc/dev_info/server/prj.conf

@@ -18,3 +18,4 @@ CONFIG_KERNEL_MEM_POOL=y
 CONFIG_HEAP_MEM_POOL_SIZE=4096
 CONFIG_NRF_RPC_DEV_INFO=y
 CONFIG_NRF_RPC_DEV_INFO_SERVER=y
+CONFIG_NRF_RPC_REMOTE_SHELL=n

tests/subsys/nrf_rpc/dev_info/server/src/dev_info_suite.c

@@ -34,4 +34,19 @@ ZTEST(dev_info_rpc_server, test_get_server_version)
 	mock_nrf_rpc_tr_expect_done();
 }
 
+ZTEST(dev_info_rpc_server, test_invoke_shell_cmd)
+{
+	mock_nrf_rpc_tr_expect_add(
+		RPC_RSP(0x78, 0x55, 'R', 'e', 'm', 'o', 't', 'e', ' ', 's', 'h', 'e', 'l', 'l', ' ',
+			'i', 's', ' ', 'd', 'i', 's', 'a', 'b', 'l', 'e', 'd', ' ', 'o', 'n', ' ',
+			't', 'h', 'e', ' ', 's', 'e', 'r', 'v', 'e', 'r', '.', ' ', 'E', 'n', 'a',
+			'b', 'l', 'e', ' ', 'C', 'O', 'N', 'F', 'I', 'G', '_', 'N', 'R', 'F', '_',
+			'R', 'P', 'C', '_', 'R', 'E', 'M', 'O', 'T', 'E', '_', 'S', 'H', 'E', 'L',
+			'L', ' ', 't', 'o', ' ', 'u', 's', 'e', ' ', 'i', 't', '.'),
+		NO_RSP);
+	mock_nrf_rpc_tr_receive(RPC_CMD(DEV_INFO_RPC_INVOKE_SHELL_CMD, 0x6a, 's', 'a', 'y', ' ',
+					'h', 'e', 'l', 'l', 'o', '\0'));
+	mock_nrf_rpc_tr_expect_done();
+}
+
 ZTEST_SUITE(dev_info_rpc_server, NULL, NULL, tc_setup, NULL, NULL);