From c4dad9381ff77dd03d20a64e2c60bf07329ab3a8 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Wed, 14 Aug 2024 10:52:54 +0800 Subject: [PATCH 1/3] feat(openthread): Replace netconn external resolve hook with dns external hook --- components/lwip/Kconfig | 18 +++-- .../openthread/src/esp_openthread_dns64.c | 75 +++++++++++++++++-- 2 files changed, 81 insertions(+), 12 deletions(-) diff --git a/components/lwip/Kconfig b/components/lwip/Kconfig index e4201511e6..b9524eeaf8 100644 --- a/components/lwip/Kconfig +++ b/components/lwip/Kconfig @@ -1178,10 +1178,9 @@ menu "LWIP" choice LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE prompt "Netconn external resolve Hook" - default LWIP_HOOK_NETCONN_EXT_RESOLVE_DEFAULT if OPENTHREAD_DNS64_CLIENT - default LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE if !OPENTHREAD_DNS64_CLIENT + default LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE help - Enables custom DNS resolve hook. + Enables custom DNS resolve hook (without callback). Setting this to "default" provides weak implementation stub that could be overwritten in application code. Setting this to "custom" provides hook's declaration @@ -1196,11 +1195,20 @@ menu "LWIP" endchoice + config LWIP_HOOK_DNS_EXTERNAL_RESOLVE_SELECT_CUSTOM + bool + default n + help + This hidden option helps configure the DNS external resolve + hook for external components like OpenThread. It ensures that + `LWIP_HOOK_DNS_EXT_RESOLVE_CUSTOM` is selected without directly + adding a dependency in the choice construct. + choice LWIP_HOOK_DNS_EXTERNAL_RESOLVE prompt "DNS external resolve Hook" - default LWIP_HOOK_DNS_EXT_RESOLVE_NONE + default LWIP_HOOK_DNS_EXT_RESOLVE_CUSTOM if LWIP_HOOK_DNS_EXTERNAL_RESOLVE_SELECT_CUSTOM help - Enables custom DNS resolve hook. + Enables custom DNS resolve hook (with callback). Setting this to "custom" provides hook's declaration only and expects the application to implement it. diff --git a/components/openthread/src/esp_openthread_dns64.c b/components/openthread/src/esp_openthread_dns64.c index 252bc3d12e..b6963c0d92 100644 --- a/components/openthread/src/esp_openthread_dns64.c +++ b/components/openthread/src/esp_openthread_dns64.c @@ -1,28 +1,40 @@ /* - * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ #include "esp_openthread_dns64.h" #include "esp_netif.h" +#include "esp_openthread_lock.h" #include "esp_openthread_state.h" #include "esp_openthread_netif_glue.h" #include "esp_check.h" #include "esp_event.h" #include "esp_log.h" -#include "openthread/instance.h" -#include "openthread/netdata.h" #include "lwip_default_hooks.h" #include "lwip/api.h" +#include "lwip/def.h" #include "lwip/dns.h" +#include "lwip/opt.h" +#include "openthread/instance.h" +#include "openthread/netdata.h" #define TAG "OT_DNS64" +typedef struct dns_resolve_entry { + char name[DNS_MAX_NAME_LENGTH]; + dns_found_callback found; + void *callback_arg; + bool is_using; +} dns_resolve_entry_t; + +static dns_resolve_entry_t s_dns_resolve_entry[DNS_TABLE_SIZE]; + esp_err_t esp_openthread_dns64_client_init(void) { - dns_setserver(OPENTHREAD_DNS_SERVER_INDEX, NULL); + memset(s_dns_resolve_entry, 0, sizeof(s_dns_resolve_entry)); return ESP_OK; } @@ -73,11 +85,13 @@ esp_err_t esp_openthread_get_nat64_prefix(ip6_addr_t *nat64_prefix) otExternalRouteConfig route; memset(&route, 0, sizeof(route)); + esp_openthread_task_switching_lock_acquire(portMAX_DELAY); while (otNetDataGetNextRoute(instance, &iter, &route) == OT_ERROR_NONE) { if (route.mNat64) { break; } } + esp_openthread_task_switching_lock_release(); if (route.mNat64) { memcpy(nat64_prefix->addr, route.mPrefix.mPrefix.mFields.m8, sizeof(nat64_prefix->addr)); @@ -87,14 +101,61 @@ esp_err_t esp_openthread_get_nat64_prefix(ip6_addr_t *nat64_prefix) } } -int lwip_hook_netconn_external_resolve(const char *name, ip_addr_t *addr, u8_t addrtype, err_t *err) +static void dns_found_handler(const char *name, const ip_addr_t *ipaddr, void *callback_arg) { - if (addrtype == NETCONN_DNS_IPV4 || esp_netif_get_default_netif() != esp_openthread_get_netif()) { + dns_resolve_entry_t *resolve_entry = (dns_resolve_entry_t *)callback_arg; + if (resolve_entry && resolve_entry->found) { + if (lwip_strnicmp(name, resolve_entry->name, sizeof(resolve_entry->name)) == 0) { + ip_addr_t ipaddr_copy = *ipaddr; + ip6_addr_t nat64_prefix; + if (ipaddr_copy.type == IPADDR_TYPE_V4 && esp_openthread_get_nat64_prefix(&nat64_prefix) == ESP_OK) { + ipaddr_copy.type = IPADDR_TYPE_V6; + memcpy(ipaddr_copy.u_addr.ip6.addr, nat64_prefix.addr, sizeof(nat64_prefix.addr)); + ipaddr_copy.u_addr.ip6.addr[3] = ipaddr->u_addr.ip4.addr; + ipaddr_copy.u_addr.ip6.zone = IP6_NO_ZONE; + } + resolve_entry->found(name, &ipaddr_copy, resolve_entry->callback_arg); + } + resolve_entry->is_using = false; + } +} + +static dns_resolve_entry_t *find_free_dns_resolve_entry(void) +{ + for (uint8_t i = 0; i < DNS_TABLE_SIZE; ++i) { + if (s_dns_resolve_entry[i].is_using == false) { + return &s_dns_resolve_entry[i]; + } + } + return NULL; +} + +int lwip_hook_dns_external_resolve(const char *name, ip_addr_t *addr, dns_found_callback found, void *callback_arg, + u8_t addrtype, err_t *err) +{ + if (addrtype == LWIP_DNS_ADDRTYPE_IPV4 || esp_netif_get_default_netif() != esp_openthread_get_netif()) { // If the DNS address type is IPv4 or the openthread netif is not the default netif, skip this hook. return 0; } - *err = netconn_gethostbyname_addrtype(name, addr, NETCONN_DNS_IPV4); + dns_resolve_entry_t *entry = find_free_dns_resolve_entry(); + if (!entry) { + ESP_LOGE(TAG, "Cannot find free dns resolve entry"); + *err = ERR_MEM; + return 1; + } + + strncpy(entry->name, name, strnlen(name, sizeof(entry->name) - 1)); + entry->name[strnlen(name, sizeof(entry->name) - 1)] = 0; + entry->found = found; + entry->callback_arg = callback_arg; + entry->is_using = true; + + *err = dns_gethostbyname_addrtype(name, addr, dns_found_handler, entry, LWIP_DNS_ADDRTYPE_IPV4); + if (*err != ERR_INPROGRESS) { + // If dns query is not enqueued, mark the entry not being used. + entry->is_using = false; + } if (*err == ERR_OK && addr->type == IPADDR_TYPE_V4) { ip4_addr_t addr_copy = addr->u_addr.ip4; ip6_addr_t nat64_prefix; From b2f25ae9d6d61672f245e7e338c141cf817ce924 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Wed, 9 Oct 2024 10:11:21 +0800 Subject: [PATCH 2/3] fix(openthread): Add check for ip address in DNS external resolve hook --- components/openthread/src/esp_openthread_dns64.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/openthread/src/esp_openthread_dns64.c b/components/openthread/src/esp_openthread_dns64.c index b6963c0d92..d49dd63cdf 100644 --- a/components/openthread/src/esp_openthread_dns64.c +++ b/components/openthread/src/esp_openthread_dns64.c @@ -105,7 +105,7 @@ static void dns_found_handler(const char *name, const ip_addr_t *ipaddr, void *c { dns_resolve_entry_t *resolve_entry = (dns_resolve_entry_t *)callback_arg; if (resolve_entry && resolve_entry->found) { - if (lwip_strnicmp(name, resolve_entry->name, sizeof(resolve_entry->name)) == 0) { + if (ipaddr && lwip_strnicmp(name, resolve_entry->name, sizeof(resolve_entry->name)) == 0) { ip_addr_t ipaddr_copy = *ipaddr; ip6_addr_t nat64_prefix; if (ipaddr_copy.type == IPADDR_TYPE_V4 && esp_openthread_get_nat64_prefix(&nat64_prefix) == ESP_OK) { From 73c2b569a148f99a78c7877dc2a6c70018d9d6dc Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Thu, 14 Nov 2024 19:39:45 +0800 Subject: [PATCH 3/3] fix(openthread): Fix invalid host resolving for Thread end devices --- components/openthread/src/esp_openthread_dns64.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/components/openthread/src/esp_openthread_dns64.c b/components/openthread/src/esp_openthread_dns64.c index d49dd63cdf..af3246d844 100644 --- a/components/openthread/src/esp_openthread_dns64.c +++ b/components/openthread/src/esp_openthread_dns64.c @@ -105,7 +105,9 @@ static void dns_found_handler(const char *name, const ip_addr_t *ipaddr, void *c { dns_resolve_entry_t *resolve_entry = (dns_resolve_entry_t *)callback_arg; if (resolve_entry && resolve_entry->found) { - if (ipaddr && lwip_strnicmp(name, resolve_entry->name, sizeof(resolve_entry->name)) == 0) { + if (!ipaddr) { + resolve_entry->found(name, NULL, resolve_entry->callback_arg); + } else if (lwip_strnicmp(name, resolve_entry->name, sizeof(resolve_entry->name)) == 0) { ip_addr_t ipaddr_copy = *ipaddr; ip6_addr_t nat64_prefix; if (ipaddr_copy.type == IPADDR_TYPE_V4 && esp_openthread_get_nat64_prefix(&nat64_prefix) == ESP_OK) {