net: openthread: rpc: add otUdpIsOpen

Add serialization of otUdpIsOpen() API.

Signed-off-by: Damian Krolik <[email protected]>

Author: Damian-Nordic

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

@@ -532,6 +532,11 @@ static int cmd_test_udp_init(const struct shell *sh, size_t argc, char *argv[])
 	otSockAddr listen_sock_addr;
 	otError error;
 
+	if (otUdpIsOpen(NULL, &udp_socket)) {
+		shell_info(sh, "Skipping initialization: socket already open");
+		return 0;
+	}
+
 	memset(&udp_socket, 0, sizeof(udp_socket));
 	memset(&listen_sock_addr, 0, sizeof(listen_sock_addr));
 

subsys/net/openthread/rpc/client/ot_rpc_udp.c

@@ -135,7 +135,7 @@ otError otUdpOpen(otInstance *aInstance, otUdpSocket *aSocket, otUdpReceive aCal
 	aSocket->mContext = aContext;
 	aSocket->mHandler = aCallback;
 
-	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, sizeof(key) + 2);
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, sizeof(key) + 1);
 	nrf_rpc_encode_uint(&ctx, key);
 	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_UDP_OPEN, &ctx, ot_rpc_decode_error, &error);
 
@@ -164,3 +164,25 @@ otError otUdpSend(otInstance *aInstance, otUdpSocket *aSocket, otMessage *aMessa
 
 	return error;
 }
+
+bool otUdpIsOpen(otInstance *aInstance, const otUdpSocket *aSocket)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	ot_socket_key key = (ot_socket_key)aSocket;
+	bool open;
+
+	ARG_UNUSED(aInstance);
+	__ASSERT_NO_MSG(aSocket != NULL);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, sizeof(key) + 1);
+	nrf_rpc_encode_uint(&ctx, key);
+	nrf_rpc_cbor_cmd_rsp_no_err(&ot_group, OT_RPC_CMD_UDP_IS_OPEN, &ctx);
+
+	open = nrf_rpc_decode_bool(&ctx);
+
+	if (!nrf_rpc_decoding_done_and_check(&ot_group, &ctx)) {
+		ot_rpc_report_rsp_decoding_error(OT_RPC_CMD_UDP_IS_OPEN);
+	}
+
+	return open;
+}

subsys/net/openthread/rpc/common/ot_rpc_ids.h

@@ -106,6 +106,7 @@ enum ot_rpc_cmd_server {
 	OT_RPC_CMD_MESSAGE_READ,
 	OT_RPC_CMD_MESSAGE_GET_THREAD_LINK_INFO,
 	OT_RPC_CMD_UDP_OPEN,
+	OT_RPC_CMD_UDP_IS_OPEN,
 	OT_RPC_CMD_UDP_SEND,
 	OT_RPC_CMD_UDP_BIND,
 	OT_RPC_CMD_UDP_CLOSE,

subsys/net/openthread/rpc/server/CMakeLists.txt

@@ -21,9 +21,6 @@ zephyr_library_sources(
   ot_rpc_netdiag.c
   ot_rpc_srp_client.c
   ot_rpc_thread.c
-)
-
-zephyr_library_sources_ifdef(CONFIG_NET_L2_OPENTHREAD
   ot_rpc_udp.c
 )
 

subsys/net/openthread/rpc/server/ot_rpc_udp.c

@@ -279,13 +279,41 @@ static void ot_rpc_udp_connect(const struct nrf_rpc_group *group, struct nrf_rpc
 	nrf_rpc_cbor_rsp_no_err(group, &rsp_ctx);
 }
 
+static void ot_rpc_udp_is_open(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx,
+			       void *handler_data)
+{
+	bool open = false;
+	ot_socket_key soc_key;
+	nrf_udp_socket *socket;
+
+	soc_key = nrf_rpc_decode_uint(ctx);
+
+	if (!nrf_rpc_decoding_done_and_check(group, ctx)) {
+		ot_rpc_report_cmd_decoding_error(OT_RPC_CMD_UDP_IS_OPEN);
+		return;
+	}
+
+	ot_rpc_mutex_lock();
+	socket = nrf_udp_find_socket(soc_key);
+
+	if (socket) {
+		open = otUdpIsOpen(openthread_get_default_instance(), &socket->mSocket);
+	}
+
+	ot_rpc_mutex_unlock();
+	nrf_rpc_rsp_send_bool(group, open);
+}
+
 NRF_RPC_CBOR_CMD_DECODER(ot_group, ot_rpc_udp_bind, OT_RPC_CMD_UDP_BIND, ot_rpc_udp_bind, NULL);
 
 NRF_RPC_CBOR_CMD_DECODER(ot_group, ot_rpc_udp_close, OT_RPC_CMD_UDP_CLOSE, ot_rpc_udp_close, NULL);
 
 NRF_RPC_CBOR_CMD_DECODER(ot_group, ot_rpc_udp_connect, OT_RPC_CMD_UDP_CONNECT, ot_rpc_udp_connect,
 			 NULL);
 
+NRF_RPC_CBOR_CMD_DECODER(ot_group, ot_rpc_udp_is_open, OT_RPC_CMD_UDP_IS_OPEN, ot_rpc_udp_is_open,
+			 NULL);
+
 NRF_RPC_CBOR_CMD_DECODER(ot_group, ot_rpc_udp_open, OT_RPC_CMD_UDP_OPEN, ot_rpc_udp_open, NULL);
 
 NRF_RPC_CBOR_CMD_DECODER(ot_group, ot_rpc_udp_send, OT_RPC_CMD_UDP_SEND, ot_rpc_udp_send, NULL);

tests/subsys/net/openthread/rpc/client/src/udp_suite.c

@@ -243,4 +243,32 @@ ZTEST(ot_rpc_udp, test_udp_receive)
 	zassert_equal(handle_udp_receive_fake.arg1_val, (otMessage *)1);
 }
 
+ZTEST(ot_rpc_udp, test_otUdpIsOpen_true)
+{
+	bool open;
+	otUdpSocket socket;
+
+	mock_nrf_rpc_tr_expect_add(
+		RPC_CMD(OT_RPC_CMD_UDP_IS_OPEN, CBOR_UINT32((ot_socket_key)&socket)),
+		RPC_RSP(CBOR_TRUE));
+	open = otUdpIsOpen(NULL, &socket);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_true(open);
+}
+
+ZTEST(ot_rpc_udp, test_otUdpIsOpen_false)
+{
+	bool open;
+	otUdpSocket socket;
+
+	mock_nrf_rpc_tr_expect_add(
+		RPC_CMD(OT_RPC_CMD_UDP_IS_OPEN, CBOR_UINT32((ot_socket_key)&socket)),
+		RPC_RSP(CBOR_FALSE));
+	open = otUdpIsOpen(NULL, &socket);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_false(open);
+}
+
 ZTEST_SUITE(ot_rpc_udp, NULL, NULL, tc_setup, tc_clean, NULL);

tests/subsys/net/openthread/rpc/server/src/udp_suite.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <mock_nrf_rpc_transport.h>
+#include <ot_rpc_ids.h>
+#include <test_rpc_env.h>
+
+#include <zephyr/fff.h>
+#include <zephyr/kernel.h>
+#include <zephyr/ztest.h>
+
+#include <openthread/udp.h>
+
+#define FOREACH_FAKE(f)                                                                            \
+	f(otUdpIsOpen);                                                                            \
+	f(otUdpOpen);                                                                              \
+	f(otUdpClose);                                                                             \
+	f(otUdpBind);                                                                              \
+	f(otUdpConnect);                                                                           \
+	f(otUdpSend)
+
+FAKE_VALUE_FUNC(bool, otUdpIsOpen, otInstance *, const otUdpSocket *);
+FAKE_VALUE_FUNC(otError, otUdpOpen, otInstance *, otUdpSocket *, otUdpReceive, void *);
+FAKE_VALUE_FUNC(otError, otUdpClose, otInstance *, otUdpSocket *);
+FAKE_VALUE_FUNC(otError, otUdpBind, otInstance *, otUdpSocket *, const otSockAddr *,
+		otNetifIdentifier);
+FAKE_VALUE_FUNC(otError, otUdpConnect, otInstance *, otUdpSocket *, const otSockAddr *);
+FAKE_VALUE_FUNC(otError, otUdpSend, otInstance *, otUdpSocket *, otMessage *,
+		const otMessageInfo *);
+
+static void nrf_rpc_err_handler(const struct nrf_rpc_err_report *report)
+{
+	zassert_ok(report->code);
+}
+
+static void tc_setup(void *f)
+{
+	mock_nrf_rpc_tr_expect_add(RPC_INIT_REQ, RPC_INIT_RSP);
+	zassert_ok(nrf_rpc_init(nrf_rpc_err_handler));
+	mock_nrf_rpc_tr_expect_reset();
+
+	FOREACH_FAKE(RESET_FAKE);
+	FFF_RESET_HISTORY();
+}
+
+/*
+ * Test reception of otUdpIsOpen() command with non-existent socket key.
+ * Test serialization of the result: false.
+ */
+ZTEST(ot_rpc_udp, test_otUdpIsOpen_false)
+{
+	mock_nrf_rpc_tr_expect_add(RPC_RSP(CBOR_FALSE), NO_RSP);
+	mock_nrf_rpc_tr_receive(RPC_CMD(OT_RPC_CMD_UDP_IS_OPEN, CBOR_UINT32(1)));
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_equal(otUdpIsOpen_fake.call_count, 0);
+}
+
+ZTEST_SUITE(ot_rpc_udp, NULL, NULL, tc_setup, NULL, NULL);