modules: openthread: Add new Border Router functionalities.

This commit brings new platform files:
	-`border_agent`
	-`udp`
	-`mdns_socket`
	-'trel'
This commit also makes use of existing Openthread task to
process border router messages.

Signed-off-by: Cristian Bulacu <[email protected]>

Author: Cristib05

modules/openthread/Kconfig

@@ -356,13 +356,56 @@ config OPENTHREAD_PLATFORM_CARRIER_FUNCTIONS
 	help
 	  Enable support for functions such as modulated carrier and continuous carrier.
 
+menu "OpenThread Border Router"
+
 config OPENTHREAD_ZEPHYR_BORDER_ROUTER
 	bool "Adds support for Border Router functionality [EXPERIMENTAL]"
 	select EXPERIMENTAL
 	imply NET_ROUTING
 	help
 	  Enable support for Border Router using Openthread's implementation.
 
+if OPENTHREAD_ZEPHYR_BORDER_ROUTER
+
+config OPENTHREAD_ZEPHYR_BORDER_ROUTER_VENDOR_NAME
+	string "Base name from which mDNS host name will be derived."
+	default "Zephyr-OTBR"
+	help
+	  This value represents part of the mDNS host that will be register within OpenThread
+	  Border Router.
+
+config OPENTHREAD_ZEPHYR_BORDER_ROUTER_BASE_SERVICE_NAME
+	string "Base name from which a service instance name will be derived."
+	default "Zephyr-BorderRouter"
+	help
+	  This value represents part of a service instance name which will be registered
+	  within OpenThread Border Router.
+
+config OPENTHREAD_ZEPHYR_BORDER_ROUTER_MODEL_NAME
+	string "Name of the Border Agent product model"
+	default "BorderRouter"
+	help
+	  This value represents Border Agent's product model.
+
+config OPENTHREAD_ZEPHYR_BORDER_ROUTER_MAX_UDP_SERVICES
+	int "The maximum number of pollable UDP sockets to be registered in platform UDP."
+	depends on OPENTHREAD_ZEPHYR_BORDER_ROUTER
+	default 5
+	help
+	  This configuration defines the maximum number of pollable UDP sockets
+	  to be used within platform UDP module.
+
+config OPENTHREAD_ZEPHYR_BORDER_ROUTER_MSG_POOL_NUM
+	int "Maximum entries of backbone message pool."
+	default 10
+	help
+	  This value represents the maximum number of messages from backbone interface
+	  that could be stored without being processed.
+
+endif # OPENTHREAD_ZEPHYR_BORDER_ROUTER
+
+endmenu # "OpenThread Border Router"
+
 menu "OpenThread stack features"
 rsource "Kconfig.features"
 endmenu

modules/openthread/include/openthread.h

@@ -156,6 +156,13 @@ int openthread_mutex_try_lock(void);
  */
 void openthread_mutex_unlock(void);
 
+#if defined(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER)
+/**
+ * @brief Notify OpenThread task about Border Router pending work.
+ */
+void openthread_notify_border_router_work(void);
+#endif /* CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER */
+
 #ifdef __cplusplus
 }
 #endif

modules/openthread/openthread.c

@@ -43,6 +43,10 @@ LOG_MODULE_REGISTER(net_openthread_platform, CONFIG_OPENTHREAD_PLATFORM_LOG_LEVE
 #include <openthread/nat64.h>
 #endif /* CONFIG_OPENTHREAD_NAT64_TRANSLATOR */
 
+#if defined(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER)
+#include "openthread_border_router.h"
+#endif /* CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER */
+
 #define OT_STACK_SIZE (CONFIG_OPENTHREAD_THREAD_STACK_SIZE)
 
 #if defined(CONFIG_OPENTHREAD_THREAD_PREEMPTIVE)
@@ -513,6 +517,17 @@ void openthread_mutex_unlock(void)
 	(void)k_mutex_unlock(&openthread_lock);
 }
 
+#if defined(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER)
+void openthread_notify_border_router_work(void)
+{
+	int error = k_work_submit_to_queue(&openthread_work_q, &openthread_border_router_work);
+
+	if (error < 0) {
+		LOG_ERR("Failed to submit work to queue, error: %d", error);
+	}
+}
+#endif /* CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER */
+
 #ifdef CONFIG_OPENTHREAD_SYS_INIT
 static int openthread_sys_init(void)
 {

modules/openthread/platform/CMakeLists.txt

@@ -29,10 +29,15 @@ zephyr_library_sources_ifdef(CONFIG_SETTINGS settings.c)
 zephyr_library_sources_ifndef(CONFIG_LOG_BACKEND_SPINEL logging.c)
 
 zephyr_library_sources_ifdef(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER infra_if.c)
+zephyr_library_sources_ifdef(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER udp.c)
+zephyr_library_sources_ifdef(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER mdns_socket.c)
+zephyr_library_sources_ifdef(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER border_agent.c)
+zephyr_library_sources_ifdef(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER trel.c)
 
 zephyr_include_directories(.)
 
 if(CONFIG_OPENTHREAD_ZEPHYR_BORDER_ROUTER)
   zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/net/ip)
-  zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/net/l2/openthread)
+  zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/net/lib/sockets)
+  zephyr_include_directories(${ZEPHYR_BASE}/subsys/net/l2/openthread)
 endif()

modules/openthread/platform/border_agent.c

@@ -0,0 +1,235 @@
+/*
+ * Copyright 2025 NXP
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <platform-zephyr.h>
+#include <openthread/border_agent.h>
+#include <openthread/cli.h>
+#include <openthread/dns.h>
+#include <openthread/thread.h>
+#include <openthread/verhoeff_checksum.h>
+#include <openthread/platform/entropy.h>
+#include "common/code_utils.hpp"
+#include "openthread_border_router.h"
+#include <zephyr/sys/byteorder.h>
+#include <string.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <zephyr/kernel.h>
+#include <zephyr/shell/shell.h>
+
+static struct otInstance *ot_instance_ptr;
+static bool border_agent_is_init;
+
+#if defined(CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE)
+/* Byte values, 9 bytes for the key, one for null terminator. */
+static uint8_t ephemeral_key_string[10];
+
+static uint32_t ephemeral_key_timeout;
+static bool epskc_active;
+
+static otError generate_ephemeral_key(void);
+static void handle_border_agent_ephemeral_key_callback(void *context);
+static otError border_agent_enable_epskc_service(uint32_t timeout);
+
+/* shell related functions */
+static int border_agent_eph_key_shell_cmd(const struct shell *sh, size_t argc, char **argv);
+static int border_agent_eph_key_run(size_t argc, char **argv);
+
+#endif /* CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE */
+
+static void append_vendor_txt_data(uint8_t *txt_data, uint16_t *txt_data_len);
+
+otError border_agent_init(otInstance *instance)
+{
+	otError error = OT_ERROR_NONE;
+
+	ot_instance_ptr = instance;
+
+	if (!border_agent_is_init) {
+		uint8_t txt_buffer[128] = {0};
+		uint16_t txt_buffer_len = 0;
+
+		VerifyOrExit(otBorderAgentSetMeshCoPServiceBaseName(instance,
+								    otbr_base_service_instance_name)
+			     == OT_ERROR_NONE, error = OT_ERROR_FAILED);
+		append_vendor_txt_data(txt_buffer, &txt_buffer_len);
+		otBorderAgentSetVendorTxtData(instance, txt_buffer, txt_buffer_len);
+#if defined(CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE)
+		otBorderAgentEphemeralKeySetEnabled(instance, true);
+		otBorderAgentEphemeralKeySetCallback(instance,
+						     handle_border_agent_ephemeral_key_callback,
+						     instance);
+#endif /* CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE */
+
+		border_agent_is_init = true;
+	}
+exit:
+	return error;
+}
+
+void border_agent_deinit(void)
+{
+#if defined(CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE)
+	otBorderAgentEphemeralKeySetEnabled(ot_instance_ptr, false);
+	epskc_active = false;
+#endif /* CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE */
+	border_agent_is_init = false;
+}
+
+static void append_vendor_txt_data(uint8_t *txt_data, uint16_t *txt_data_len)
+{
+	*txt_data_len = 0;
+	size_t i = 0;
+	otDnsTxtEntry txt_entries[] = {
+				       {.mKey = "vn", .mValue = (uint8_t *)otbr_vendor_name,
+					.mValueLength = strlen(otbr_vendor_name)},
+				       {.mKey = "mn", .mValue = (uint8_t *)otbr_model_name,
+					.mValueLength = strlen(otbr_model_name)}};
+
+	for (i = 0; i < ARRAY_SIZE(txt_entries); ++i) {
+		const otDnsTxtEntry *entry    = &txt_entries[i];
+		uint8_t key_len   = (uint8_t)strlen(entry->mKey);
+		uint8_t total_len = key_len + 1 + entry->mValueLength; /* +1 for '=' */
+
+		txt_data[(*txt_data_len)++] = total_len;
+		memcpy(txt_data + *txt_data_len, entry->mKey, key_len);
+		*txt_data_len += key_len;
+
+		txt_data[(*txt_data_len)++] = '=';
+		memcpy(txt_data + *txt_data_len, entry->mValue, entry->mValueLength);
+		*txt_data_len += entry->mValueLength;
+	}
+
+}
+
+#if defined(CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE)
+
+/** Defining functions below as weak allows applications to implement their specific behaviour,
+ *  i.e., custom messages/used print function.
+ */
+__weak void print_ephemeral_key(const char *ephemeral_key, uint32_t timeout)
+{
+	otCliOutputFormat("\r\n Use this passcode to enable an additional device to administer "
+			  "and manage your Thread network, including adding new devices to it. "
+			  "\r\nThis passcode is not required for an app to communicate with "
+			  "existing devices on your Thread network.");
+	otCliOutputFormat("\r\n\nePSKc : %s", ephemeral_key);
+	otCliOutputFormat("\r\n\nValid for %" PRIu32 " seconds.\r\n", timeout);
+}
+
+__weak void print_ephemeral_key_expired_message(void)
+{
+	otCliOutputFormat("\r\nEphemeral Key disabled.\r\n");
+}
+
+static otError generate_ephemeral_key(void)
+{
+	otError error = OT_ERROR_NONE;
+	uint8_t i = 0;
+	uint32_t random;
+	char verhoeff_checksum;
+
+	memset(ephemeral_key_string, 0, sizeof(ephemeral_key_string));
+
+	VerifyOrExit(otPlatEntropyGet((uint8_t *)&random, sizeof(random)) == OT_ERROR_NONE,
+		     error = OT_ERROR_FAILED);
+	random %= 100000000;
+	i += snprintf((char *)ephemeral_key_string, sizeof(ephemeral_key_string),
+		      "%08u", random);
+	VerifyOrExit(otVerhoeffChecksumCalculate((const char *)ephemeral_key_string,
+		     &verhoeff_checksum) == OT_ERROR_NONE,
+		     error = OT_ERROR_FAILED);
+	snprintf((char *)&ephemeral_key_string[i], sizeof(ephemeral_key_string) - i,
+		 "%c", verhoeff_checksum);
+exit:
+	return error;
+}
+
+static void handle_border_agent_ephemeral_key_callback(void *context)
+{
+	char formatted_epskc[12] = {0};
+	otBorderAgentEphemeralKeyState eph_key_state;
+
+	eph_key_state = otBorderAgentEphemeralKeyGetState((otInstance *)context);
+
+	switch (eph_key_state) {
+	case OT_BORDER_AGENT_STATE_STOPPED:
+		if (epskc_active) {
+			epskc_active = false;
+			print_ephemeral_key_expired_message();
+		}
+		break;
+
+	case OT_BORDER_AGENT_STATE_STARTED:
+		snprintf(formatted_epskc, sizeof(formatted_epskc), "%.3s %.3s %.3s",
+			 ephemeral_key_string, ephemeral_key_string + 3,
+			 ephemeral_key_string + 6);
+		print_ephemeral_key(formatted_epskc, (uint32_t)(ephemeral_key_timeout / 1000UL));
+		epskc_active = true;
+		break;
+
+	case OT_BORDER_AGENT_STATE_CONNECTED:
+		/* connected to */
+	case OT_BORDER_AGENT_STATE_ACCEPTED:
+	default:
+		break;
+	}
+}
+static otError border_agent_enable_epskc_service(uint32_t timeout)
+{
+	otError error = OT_ERROR_NONE;
+
+	VerifyOrExit(border_agent_is_init, error = OT_ERROR_INVALID_STATE);
+
+	ephemeral_key_timeout = (timeout &&
+				   timeout >= OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT &&
+				   timeout <= OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT) ?
+				   timeout : OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT;
+
+	VerifyOrExit((generate_ephemeral_key() == OT_ERROR_NONE), error = OT_ERROR_FAILED);
+	error = otBorderAgentEphemeralKeyStart(ot_instance_ptr,
+					       (const char *)ephemeral_key_string,
+					       ephemeral_key_timeout, 0);
+
+exit:
+	return error;
+}
+
+static int border_agent_eph_key_run(size_t argc, char **argv)
+{
+	if (strcmp(argv[1], "enable") == 0) {
+		uint32_t timeout = (argc >= 1) ? strtoul(argv[2], NULL, 10) : 0;
+
+		if (border_agent_enable_epskc_service(timeout) != OT_ERROR_NONE) {
+			otCliOutputFormat("Invalid state\r\n");
+		}
+		return 0;
+	}
+
+	if (strcmp(argv[1], "help") == 0) {
+		otCliOutputFormat("ephkey enable [timeout-in-msec]\r\n");
+	}
+
+	return 0;
+}
+
+static int border_agent_eph_key_shell_cmd(const struct shell *sh, size_t argc, char **argv)
+{
+	if (argc < 2) {
+		shell_help(sh);
+		return -ENOEXEC;
+	}
+
+	border_agent_eph_key_run(argc, argv);
+
+	return 0;
+}
+#endif /* CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE */
+
+#if defined(CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE)
+SHELL_CMD_ARG_REGISTER(ephkey, NULL, "Ephemeral key support", border_agent_eph_key_shell_cmd, 2,
+		       CONFIG_SHELL_ARGC_MAX);
+#endif /* CONFIG_OPENTHREAD_BORDER_AGENT_EPHEMERAL_KEY_ENABLE */