Files
led-driver/managed_components/espressif__mdns/mdns_querier.c
T
jimmyandClaude Haiku 5.5 4cd3bc7973 feat: DDP frame sync over UDP broadcast, DDP acks, DDP enable setting
- Driver acks each completed DDP frame; the test waits for the acks before broadcasting the sync.
- Sync listener on UDP 4049: a frame is held until the next sync, then shown.
- DDP pixels are shown at full brightness, ignoring the device brightness settings.
- "DDP and sync receive on" setting (NVS, network API, web UI); off ignores DDP and sync packets.
- ddp_test.py: finds devices on the subnet, drives them in lockstep at a fixed rate, runs animations.
- /api/ddp reports sync counters for diagnosis.
- Includes in-progress WebSocket, multi-driver web UI and Wi-Fi work from the same tree.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-11 14:10:55 +13:00

991 lines
31 KiB
C

/*
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#include "sdkconfig.h"
#include "mdns_private.h"
#include "mdns_querier.h"
#include "mdns_mem_caps.h"
#include "mdns_utils.h"
#include "mdns_send.h"
#include "esp_log.h"
#include "mdns_pcb.h"
#include "mdns_netif.h"
#include "mdns_responder.h"
#include "mdns_service.h"
static const char *TAG = "mdns_querier";
static mdns_search_once_t *s_search_once;
static esp_err_t send_search_action(mdns_action_type_t type, mdns_search_once_t *search);
static void search_free(mdns_search_once_t *search);
void mdns_priv_query_results_free(mdns_result_t *results)
{
mdns_result_t *r;
mdns_ip_addr_t *a;
while (results) {
r = results;
mdns_mem_free((char *)(r->hostname));
mdns_mem_free((char *)(r->instance_name));
mdns_mem_free((char *)(r->service_type));
mdns_mem_free((char *)(r->proto));
mdns_mem_free((char *)(r->subtype));
for (size_t i = 0; i < r->txt_count; i++) {
mdns_mem_free((char *)(r->txt[i].key));
mdns_mem_free((char *)(r->txt[i].value));
}
mdns_mem_free(r->txt);
mdns_mem_free(r->txt_value_len);
while (r->addr) {
a = r->addr;
r->addr = r->addr->next;
mdns_mem_free(a);
}
results = results->next;
mdns_mem_free(r);
}
}
/**
* @brief Check if a search is still in the search_once linked list.
* Must be called with service lock held.
*/
static bool search_is_in_list(mdns_search_once_t *search)
{
mdns_search_once_t *s = s_search_once;
while (s) {
if (s == search) {
return true;
}
s = s->next;
}
return false;
}
/**
* @brief Mark search as finished and remove it from search chain.
*
* Guards against stale pointers: mdns_query_async_delete() may have already
* detached and freed this search while an ACTION_SEARCH_END was still queued.
* The notifier is cleared before calling to prevent double-invocation if
* search_finish() is reached from both mdns_priv_query_done() (max results)
* and ACTION_SEARCH_END (timeout) for the same search.
*/
static void search_finish(mdns_search_once_t *search)
{
if (!search_is_in_list(search)) {
return; /* Already freed by mdns_query_async_delete() */
}
search->state = SEARCH_OFF;
queueDetach(mdns_search_once_t, s_search_once, search);
if (search->notifier) {
mdns_query_notify_t notifier = search->notifier;
search->notifier = NULL;
notifier(search);
}
xSemaphoreGive(search->done_semaphore);
}
/**
* @brief Add new search to the search chain
*/
void search_add(mdns_search_once_t *search)
{
search->next = s_search_once;
s_search_once = search;
}
/**
* @brief Send search packet to all available interfaces
*/
static void search_send(mdns_search_once_t *search)
{
mdns_search_once_t *queue = s_search_once;
bool found = false;
// looking for this search in active searches
while (queue) {
if (queue == search) {
found = true;
break;
}
queue = queue->next;
}
if (!found) {
// no longer active -> skip sending this search
return;
}
uint8_t i, j;
for (i = 0; i < MDNS_MAX_INTERFACES; i++) {
for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) {
mdns_priv_query_send(search, (mdns_if_t) i, (mdns_ip_protocol_t) j);
}
}
}
void mdns_priv_query_action(mdns_action_t *action, mdns_action_subtype_t type)
{
if (type == ACTION_RUN) {
switch (action->type) {
case ACTION_SEARCH_ADD:
search_add(action->data.search_add.search);
break;
case ACTION_SEARCH_SEND:
search_send(action->data.search_add.search);
break;
case ACTION_SEARCH_END:
search_finish(action->data.search_add.search);
break;
default:
abort();
}
return;
}
if (type == ACTION_CLEANUP) {
/* ADD actions hold searches not yet in the list — always safe to free.
* SEND/END actions reference searches that may have been removed and
* freed by mdns_query_async_delete(). Only free if still in the list. */
if (action->type == ACTION_SEARCH_ADD ||
search_is_in_list(action->data.search_add.search)) {
search_free(action->data.search_add.search);
}
}
}
/**
* @brief Called from timer task to run active searches
*/
void mdns_priv_query_start_stop(void)
{
mdns_priv_service_lock();
mdns_search_once_t *s = s_search_once;
uint32_t now = xTaskGetTickCount() * portTICK_PERIOD_MS;
if (!s) {
mdns_priv_service_unlock();
return;
}
while (s) {
if (s->state != SEARCH_OFF) {
if (now > (s->started_at + s->timeout)) {
s->state = SEARCH_OFF;
if (send_search_action(ACTION_SEARCH_END, s) != ESP_OK) {
s->state = SEARCH_RUNNING;
}
} else if (s->state == SEARCH_INIT || (now - s->sent_at) > 1000) {
s->state = SEARCH_RUNNING;
s->sent_at = now;
if (send_search_action(ACTION_SEARCH_SEND, s) != ESP_OK) {
s->sent_at -= 1000;
}
}
}
s = s->next;
}
mdns_priv_service_unlock();
}
void mdns_priv_search_once_free(mdns_search_once_t *search)
{
if (!search) {
return;
}
queueDetach(mdns_search_once_t, s_search_once, search);
mdns_mem_free(search->instance);
mdns_mem_free(search->service);
mdns_mem_free(search->proto);
vSemaphoreDelete(search->done_semaphore);
if (search->result) {
mdns_priv_query_results_free(search->result);
}
mdns_mem_free(search);
}
void mdns_priv_query_free(void)
{
while (s_search_once) {
mdns_search_once_t *h = s_search_once;
s_search_once = h->next;
mdns_mem_free(h->instance);
mdns_mem_free(h->service);
mdns_mem_free(h->proto);
vSemaphoreDelete(h->done_semaphore);
if (h->result) {
mdns_priv_query_results_free(h->result);
}
mdns_mem_free(h);
}
}
/**
* @brief Called from parser to finish any searches that have reached maximum results
*/
void mdns_priv_query_done(void)
{
mdns_search_once_t *search = s_search_once;
mdns_search_once_t *s = NULL;
while (search) {
s = search;
search = search->next;
if (s->max_results && s->num_results >= s->max_results) {
search_finish(s);
}
}
}
/**
* @brief Called from packet parser to find matching running search
*/
mdns_search_once_t *mdns_priv_query_find_from(mdns_search_once_t *s, mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
mdns_result_t *r = NULL;
while (s) {
if (s->state == SEARCH_OFF) {
s = s->next;
continue;
}
if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) {
if ((s->type == MDNS_TYPE_ANY && s->service != NULL)
|| (s->type != MDNS_TYPE_ANY && s->type != type && s->type != MDNS_TYPE_PTR && s->type != MDNS_TYPE_SRV)) {
s = s->next;
continue;
}
if (s->type != MDNS_TYPE_PTR && s->type != MDNS_TYPE_SRV) {
if (!strcasecmp(name->host, s->instance)) {
return s;
}
s = s->next;
continue;
}
r = s->result;
while (r) {
if (r->esp_netif == mdns_priv_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(name->host, r->hostname)) {
return s;
}
r = r->next;
}
s = s->next;
continue;
}
if (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT) {
if ((s->type == MDNS_TYPE_ANY && s->service == NULL)
|| (s->type != MDNS_TYPE_ANY && s->type != type && s->type != MDNS_TYPE_PTR)) {
s = s->next;
continue;
}
if (strcasecmp(name->service, s->service)
|| strcasecmp(name->proto, s->proto)) {
s = s->next;
continue;
}
if (s->type != MDNS_TYPE_PTR) {
if (s->instance && strcasecmp(name->host, s->instance) == 0) {
return s;
}
s = s->next;
continue;
}
return s;
}
if (type == MDNS_TYPE_PTR && type == s->type) {
// Multi-label service names (e.g. "_services._dns-sd") are parsed into
// host + service fields; reconstruct the compound name for comparison.
if (name->host[0] && s->service && strchr(s->service, '.')) {
char compound[MDNS_NAME_BUF_LEN * 2];
snprintf(compound, sizeof(compound), "%s.%s", name->host, name->service);
if (!strcasecmp(compound, s->service) && !strcasecmp(name->proto, s->proto)) {
return s;
}
} else if (s->service && s->proto && !strcasecmp(name->service, s->service) && !strcasecmp(name->proto, s->proto)) {
return s;
}
}
s = s->next;
}
return NULL;
}
mdns_search_once_t *mdns_priv_query_find(mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
return mdns_priv_query_find_from(s_search_once, name, type, tcpip_if, ip_protocol);
}
/**
* @brief Create search packet for particular interface
*/
static mdns_tx_packet_t *create_search_packet(mdns_search_once_t *search, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
mdns_result_t *r = NULL;
mdns_tx_packet_t *packet = mdns_priv_alloc_packet(tcpip_if, ip_protocol);
if (!packet) {
return NULL;
}
mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t));
if (!q) {
HOOK_MALLOC_FAILED;
mdns_priv_free_tx_packet(packet);
return NULL;
}
q->next = NULL;
q->unicast = search->unicast;
q->type = search->type;
q->host = search->instance;
q->service = search->service;
q->proto = search->proto;
q->domain = MDNS_UTILS_DEFAULT_DOMAIN;
q->subtype = search->subtype;
q->own_dynamic_memory = false;
// Multi-label service names (e.g. "_services._dns-sd") need splitting into
// separate DNS labels: host="_services", service="_dns-sd"
if (search->service) {
char *dot = strchr(search->service, '.');
if (dot && dot > search->service) {
size_t host_len = dot - search->service;
size_t service_len = strlen(dot + 1);
if (host_len < MDNS_NAME_BUF_LEN && service_len < MDNS_NAME_BUF_LEN && service_len > 0) {
size_t proto_len = search->proto ? strlen(search->proto) : 0;
size_t domain_len = strlen(MDNS_UTILS_DEFAULT_DOMAIN);
char *host_part = mdns_mem_malloc(host_len + 1);
char *service_part = mdns_mem_malloc(service_len + 1);
char *proto_part = proto_len > 0 ? mdns_mem_malloc(proto_len + 1) : NULL;
char *domain_part = mdns_mem_malloc(domain_len + 1);
if (!host_part || !service_part || !domain_part || (proto_len && !proto_part)) {
ESP_LOGW(TAG, "Failed to allocate memory for multi-label service query");
mdns_mem_free(host_part);
mdns_mem_free(service_part);
mdns_mem_free(proto_part);
mdns_mem_free(domain_part);
mdns_mem_free(q);
mdns_priv_free_tx_packet(packet);
return NULL;
}
memcpy(host_part, search->service, host_len);
host_part[host_len] = '\0';
memcpy(service_part, dot + 1, service_len);
service_part[service_len] = '\0';
if (proto_part) {
memcpy(proto_part, search->proto, proto_len);
proto_part[proto_len] = '\0';
}
memcpy(domain_part, MDNS_UTILS_DEFAULT_DOMAIN, domain_len);
domain_part[domain_len] = '\0';
q->host = host_part;
q->service = service_part;
q->proto = proto_part;
q->domain = domain_part;
q->own_dynamic_memory = true;
}
}
}
queueToEnd(mdns_out_question_t, packet->questions, q);
if (search->type == MDNS_TYPE_PTR) {
r = search->result;
while (r) {
//full record on the same interface is available
if (r->esp_netif != mdns_priv_get_esp_netif(tcpip_if) || r->ip_protocol != ip_protocol || r->instance_name == NULL || r->hostname == NULL || r->addr == NULL) {
r = r->next;
continue;
}
mdns_out_answer_t *a = (mdns_out_answer_t *)mdns_mem_malloc(sizeof(mdns_out_answer_t));
if (!a) {
HOOK_MALLOC_FAILED;
mdns_priv_free_tx_packet(packet);
return NULL;
}
a->type = MDNS_TYPE_PTR;
a->service = NULL;
a->custom_instance = r->instance_name;
a->custom_service = search->service;
a->custom_proto = search->proto;
a->bye = false;
a->flush = false;
a->next = NULL;
queueToEnd(mdns_out_answer_t, packet->answers, a);
r = r->next;
}
}
return packet;
}
/**
* @brief Send search packet to particular interface
*/
void mdns_priv_query_send(mdns_search_once_t *search, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
mdns_tx_packet_t *packet = NULL;
if (mdsn_priv_pcb_is_inited(tcpip_if, ip_protocol)) {
packet = create_search_packet(search, tcpip_if, ip_protocol);
if (!packet) {
return;
}
mdns_priv_dispatch_tx_packet(packet);
mdns_priv_free_tx_packet(packet);
}
}
/**
* @brief Free search structure (except the results)
*/
static void search_free(mdns_search_once_t *search)
{
mdns_mem_free(search->instance);
mdns_mem_free(search->service);
mdns_mem_free(search->proto);
vSemaphoreDelete(search->done_semaphore);
mdns_mem_free(search);
}
/**
* @brief Allocate new search structure
*/
static mdns_search_once_t *search_init(const char *name, const char *service, const char *proto, uint16_t type, bool unicast,
uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier)
{
mdns_search_once_t *search = (mdns_search_once_t *)mdns_mem_malloc(sizeof(mdns_search_once_t));
if (!search) {
HOOK_MALLOC_FAILED;
return NULL;
}
memset(search, 0, sizeof(mdns_search_once_t));
search->done_semaphore = xSemaphoreCreateBinary();
if (!search->done_semaphore) {
mdns_mem_free(search);
return NULL;
}
if (!mdns_utils_str_null_or_empty(name)) {
search->instance = mdns_mem_strndup(name, MDNS_NAME_BUF_LEN - 1);
if (!search->instance) {
search_free(search);
return NULL;
}
}
if (!mdns_utils_str_null_or_empty(service)) {
search->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1);
if (!search->service) {
search_free(search);
return NULL;
}
}
if (!mdns_utils_str_null_or_empty(proto)) {
search->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1);
if (!search->proto) {
search_free(search);
return NULL;
}
}
search->type = type;
search->unicast = unicast;
search->timeout = timeout;
search->num_results = 0;
search->max_results = max_results;
search->result = NULL;
search->state = SEARCH_INIT;
search->sent_at = 0;
search->started_at = xTaskGetTickCount() * portTICK_PERIOD_MS;
search->notifier = notifier;
search->next = NULL;
return search;
}
/**
* @brief Queue search action
*/
static esp_err_t send_search_action(mdns_action_type_t type, mdns_search_once_t *search)
{
mdns_action_t *action = NULL;
action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t));
if (!action) {
HOOK_MALLOC_FAILED;
return ESP_ERR_NO_MEM;
}
action->type = type;
action->data.search_add.search = search;
if (!mdns_priv_queue_action(action)) {
mdns_mem_free(action);
return ESP_ERR_NO_MEM;
}
return ESP_OK;
}
/**
* @brief Called from parser to add TXT data to search result
*/
void mdns_priv_query_result_add_txt(mdns_search_once_t *search, mdns_txt_item_t *txt, uint8_t *txt_value_len,
size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol,
uint32_t ttl)
{
mdns_result_t *r = search->result;
while (r) {
if (r->esp_netif == mdns_priv_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol) {
if (r->txt) {
goto free_txt;
}
r->txt = txt;
r->txt_value_len = txt_value_len;
r->txt_count = txt_count;
mdns_priv_query_update_result_ttl(r, ttl);
return;
}
r = r->next;
}
if (!search->max_results || search->num_results < search->max_results) {
r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t));
if (!r) {
HOOK_MALLOC_FAILED;
goto free_txt;
}
memset(r, 0, sizeof(mdns_result_t));
r->txt = txt;
r->txt_value_len = txt_value_len;
r->txt_count = txt_count;
r->esp_netif = mdns_priv_get_esp_netif(tcpip_if);
r->ip_protocol = ip_protocol;
r->ttl = ttl;
r->next = search->result;
search->result = r;
search->num_results++;
return;
}
free_txt:
for (size_t i = 0; i < txt_count; i++) {
mdns_mem_free((char *)(txt[i].key));
mdns_mem_free((char *)(txt[i].value));
}
mdns_mem_free(txt);
mdns_mem_free(txt_value_len);
}
/**
* @brief Chain new IP to search result
*/
static void result_add_ip(mdns_result_t *r, esp_ip_addr_t *ip)
{
mdns_ip_addr_t *a = r->addr;
while (a) {
if (a->addr.type == ip->type) {
#ifdef CONFIG_LWIP_IPV4
if (a->addr.type == ESP_IPADDR_TYPE_V4 && a->addr.u_addr.ip4.addr == ip->u_addr.ip4.addr) {
return;
}
#endif
#ifdef CONFIG_LWIP_IPV6
if (a->addr.type == ESP_IPADDR_TYPE_V6 && !memcmp(a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16)) {
return;
}
#endif
}
a = a->next;
}
a = mdns_priv_result_addr_create_ip(ip);
if (!a) {
return;
}
a->next = r->addr;
r->addr = a;
}
/**
* @brief Called from parser to add A/AAAA data to search result
*/
void mdns_priv_query_result_add_ip(mdns_search_once_t *search, const char *hostname, esp_ip_addr_t *ip,
mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl)
{
mdns_result_t *r = NULL;
mdns_ip_addr_t *a = NULL;
if ((search->type == MDNS_TYPE_A && ip->type == ESP_IPADDR_TYPE_V4)
|| (search->type == MDNS_TYPE_AAAA && ip->type == ESP_IPADDR_TYPE_V6)
|| search->type == MDNS_TYPE_ANY) {
r = search->result;
while (r) {
if (r->esp_netif == mdns_priv_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol) {
result_add_ip(r, ip);
mdns_priv_query_update_result_ttl(r, ttl);
return;
}
r = r->next;
}
if (!search->max_results || search->num_results < search->max_results) {
r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t));
if (!r) {
HOOK_MALLOC_FAILED;
return;
}
memset(r, 0, sizeof(mdns_result_t));
a = mdns_priv_result_addr_create_ip(ip);
if (!a) {
mdns_mem_free(r);
return;
}
a->next = r->addr;
r->hostname = mdns_mem_strdup(hostname);
r->addr = a;
r->esp_netif = mdns_priv_get_esp_netif(tcpip_if);
r->ip_protocol = ip_protocol;
r->next = search->result;
r->ttl = ttl;
search->result = r;
search->num_results++;
}
} else if (search->type == MDNS_TYPE_PTR || search->type == MDNS_TYPE_SRV) {
r = search->result;
while (r) {
if (r->esp_netif == mdns_priv_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) {
result_add_ip(r, ip);
mdns_priv_query_update_result_ttl(r, ttl);
break;
}
r = r->next;
}
}
}
/**
* @brief Called from parser to add SRV data to search result
*/
void mdns_priv_query_result_add_srv(mdns_search_once_t *search, const char *hostname, uint16_t port,
mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl)
{
mdns_result_t *r = search->result;
while (r) {
if (r->esp_netif == mdns_priv_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) {
mdns_priv_query_update_result_ttl(r, ttl);
return;
}
r = r->next;
}
if (!search->max_results || search->num_results < search->max_results) {
r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t));
if (!r) {
HOOK_MALLOC_FAILED;
return;
}
memset(r, 0, sizeof(mdns_result_t));
r->hostname = mdns_mem_strdup(hostname);
if (!r->hostname) {
mdns_mem_free(r);
return;
}
if (search->instance) {
r->instance_name = mdns_mem_strdup(search->instance);
}
r->service_type = mdns_mem_strdup(search->service);
r->proto = mdns_mem_strdup(search->proto);
r->port = port;
r->esp_netif = mdns_priv_get_esp_netif(tcpip_if);
r->ip_protocol = ip_protocol;
r->ttl = ttl;
r->next = search->result;
search->result = r;
search->num_results++;
}
}
/**
* @brief Called from parser to add PTR data to search result
*/
mdns_result_t *mdns_priv_query_result_add_ptr(mdns_search_once_t *search, const char *instance,
const char *service_type, const char *proto, mdns_if_t tcpip_if,
mdns_ip_protocol_t ip_protocol, uint32_t ttl)
{
mdns_result_t *r = search->result;
while (r) {
if (r->esp_netif == mdns_priv_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !mdns_utils_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name)) {
mdns_priv_query_update_result_ttl(r, ttl);
return r;
}
r = r->next;
}
if (!search->max_results || search->num_results < search->max_results) {
r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t));
if (!r) {
HOOK_MALLOC_FAILED;
return NULL;
}
memset(r, 0, sizeof(mdns_result_t));
r->instance_name = mdns_mem_strdup(instance);
r->service_type = mdns_mem_strdup(service_type);
r->proto = mdns_mem_strdup(proto);
if (!r->instance_name) {
mdns_mem_free(r);
return NULL;
}
r->esp_netif = mdns_priv_get_esp_netif(tcpip_if);
r->ip_protocol = ip_protocol;
r->ttl = ttl;
r->next = search->result;
search->result = r;
search->num_results++;
return r;
}
return NULL;
}
mdns_ip_addr_t *mdns_priv_result_addr_create_ip(esp_ip_addr_t *ip)
{
mdns_ip_addr_t *a = (mdns_ip_addr_t *)mdns_mem_malloc(sizeof(mdns_ip_addr_t));
if (!a) {
HOOK_MALLOC_FAILED;
return NULL;
}
memset(a, 0, sizeof(mdns_ip_addr_t));
a->addr.type = ip->type;
if (ip->type == ESP_IPADDR_TYPE_V6) {
memcpy(a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16);
} else {
a->addr.u_addr.ip4.addr = ip->u_addr.ip4.addr;
}
return a;
}
/**
* @brief MDNS_PUBLIC_API
* */
void mdns_query_results_free(mdns_result_t *results)
{
mdns_priv_service_lock();
mdns_priv_query_results_free(results);
mdns_priv_service_unlock();
}
esp_err_t mdns_query_async_delete(mdns_search_once_t *search)
{
if (!search) {
return ESP_ERR_INVALID_ARG;
}
mdns_priv_service_lock();
if (search->state != SEARCH_OFF) {
mdns_priv_service_unlock();
return ESP_ERR_INVALID_STATE;
}
/* Defensively detach from the search list before freeing.
* Normally search_finish() already called queueDetach, but in the race
* window (timer set SEARCH_OFF, ACTION_SEARCH_END not yet processed)
* the search may still be in the list. Without this, search_finish()
* or the CLEANUP handler would access freed memory. */
queueDetach(mdns_search_once_t, s_search_once, search);
search->notifier = NULL;
search_free(search);
mdns_priv_service_unlock();
return ESP_OK;
}
bool mdns_query_async_get_results(mdns_search_once_t *search, uint32_t timeout, mdns_result_t **results, uint8_t *num_results)
{
if (xSemaphoreTake(search->done_semaphore, pdMS_TO_TICKS(timeout)) == pdTRUE) {
if (results) {
*results = search->result;
}
if (num_results) {
*num_results = search->num_results;
}
return true;
}
return false;
}
mdns_search_once_t *mdns_query_async_new(const char *name, const char *service, const char *proto, uint16_t type,
uint32_t timeout, size_t max_results, mdns_query_notify_t notifier)
{
mdns_search_once_t *search = NULL;
if (!mdns_priv_is_server_init() || !timeout || mdns_utils_str_null_or_empty(service) != mdns_utils_str_null_or_empty(proto)) {
return NULL;
}
search = search_init(name, service, proto, type, type != MDNS_TYPE_PTR, timeout, max_results, notifier);
if (!search) {
return NULL;
}
if (send_search_action(ACTION_SEARCH_ADD, search)) {
search_free(search);
return NULL;
}
return search;
}
esp_err_t mdns_query_generic(const char *name, const char *service, const char *proto, uint16_t type, mdns_query_transmission_type_t transmission_type, uint32_t timeout, size_t max_results, mdns_result_t **results)
{
mdns_search_once_t *search = NULL;
*results = NULL;
if (!mdns_priv_is_server_init()) {
return ESP_ERR_INVALID_STATE;
}
if (!timeout || mdns_utils_str_null_or_empty(service) != mdns_utils_str_null_or_empty(proto)) {
return ESP_ERR_INVALID_ARG;
}
search = search_init(name, service, proto, type, transmission_type == MDNS_QUERY_UNICAST, timeout, max_results,
NULL);
if (!search) {
return ESP_ERR_NO_MEM;
}
if (send_search_action(ACTION_SEARCH_ADD, search)) {
search_free(search);
return ESP_ERR_NO_MEM;
}
xSemaphoreTake(search->done_semaphore, portMAX_DELAY);
*results = search->result;
search_free(search);
return ESP_OK;
}
esp_err_t mdns_query(const char *name, const char *service_type, const char *proto, uint16_t type, uint32_t timeout, size_t max_results, mdns_result_t **results)
{
// PTR queries should be multicast, all other types should be unicast
mdns_query_transmission_type_t transmission_type = (type == MDNS_TYPE_PTR) ? MDNS_QUERY_MULTICAST : MDNS_QUERY_UNICAST;
return mdns_query_generic(name, service_type, proto, type, transmission_type, timeout, max_results, results);
}
esp_err_t mdns_query_ptr(const char *service, const char *proto, uint32_t timeout, size_t max_results, mdns_result_t **results)
{
if (mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
return ESP_ERR_INVALID_ARG;
}
return mdns_query(NULL, service, proto, MDNS_TYPE_PTR, timeout, max_results, results);
}
esp_err_t mdns_query_srv(const char *instance, const char *service, const char *proto, uint32_t timeout, mdns_result_t **result)
{
if (mdns_utils_str_null_or_empty(instance) || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
return ESP_ERR_INVALID_ARG;
}
return mdns_query(instance, service, proto, MDNS_TYPE_SRV, timeout, 1, result);
}
esp_err_t mdns_query_txt(const char *instance, const char *service, const char *proto, uint32_t timeout, mdns_result_t **result)
{
if (mdns_utils_str_null_or_empty(instance) || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
return ESP_ERR_INVALID_ARG;
}
return mdns_query(instance, service, proto, MDNS_TYPE_TXT, timeout, 1, result);
}
#ifdef CONFIG_LWIP_IPV4
esp_err_t mdns_query_a(const char *name, uint32_t timeout, esp_ip4_addr_t *addr)
{
mdns_result_t *result = NULL;
esp_err_t err;
if (mdns_utils_str_null_or_empty(name)) {
return ESP_ERR_INVALID_ARG;
}
if (strstr(name, ".local")) {
ESP_LOGW(TAG, "Please note that hostname must not contain domain name, as mDNS uses '.local' domain");
}
err = mdns_query(name, NULL, NULL, MDNS_TYPE_A, timeout, 1, &result);
if (err) {
return err;
}
if (!result) {
return ESP_ERR_NOT_FOUND;
}
mdns_ip_addr_t *a = result->addr;
while (a) {
if (a->addr.type == ESP_IPADDR_TYPE_V4) {
addr->addr = a->addr.u_addr.ip4.addr;
mdns_query_results_free(result);
return ESP_OK;
}
a = a->next;
}
mdns_query_results_free(result);
return ESP_ERR_NOT_FOUND;
}
#endif /* CONFIG_LWIP_IPV4 */
#ifdef CONFIG_LWIP_IPV6
esp_err_t mdns_query_aaaa(const char *name, uint32_t timeout, esp_ip6_addr_t *addr)
{
mdns_result_t *result = NULL;
esp_err_t err;
if (mdns_utils_str_null_or_empty(name)) {
return ESP_ERR_INVALID_ARG;
}
if (strstr(name, ".local")) {
ESP_LOGW(TAG, "Please note that hostname must not contain domain name, as mDNS uses '.local' domain");
}
err = mdns_query(name, NULL, NULL, MDNS_TYPE_AAAA, timeout, 1, &result);
if (err) {
return err;
}
if (!result) {
return ESP_ERR_NOT_FOUND;
}
mdns_ip_addr_t *a = result->addr;
while (a) {
if (a->addr.type == ESP_IPADDR_TYPE_V6) {
memcpy(addr->addr, a->addr.u_addr.ip6.addr, 16);
mdns_query_results_free(result);
return ESP_OK;
}
a = a->next;
}
mdns_query_results_free(result);
return ESP_ERR_NOT_FOUND;
}
#endif /* CONFIG_LWIP_IPV6 */