- 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>
1436 lines
55 KiB
C
1436 lines
55 KiB
C
|
|
/*
|
|
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
#include <string.h>
|
|
#include "sdkconfig.h"
|
|
#include "esp_log.h"
|
|
#include "mdns_private.h"
|
|
#include "mdns_networking.h"
|
|
#include "mdns.h"
|
|
#include "mdns_mem_caps.h"
|
|
#include "mdns_utils.h"
|
|
#include "mdns_debug.h"
|
|
#include "mdns_netif.h"
|
|
#include "mdns_send.h"
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
#include "mdns_browser.h"
|
|
#endif
|
|
#include "mdns_querier.h"
|
|
#include "mdns_pcb.h"
|
|
#include "mdns_responder.h"
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
#include "mdns_cache.h"
|
|
#endif
|
|
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
typedef struct mdns_rx_staged_ip_s {
|
|
char hostname[MDNS_NAME_BUF_LEN];
|
|
esp_ip_addr_t ip;
|
|
uint32_t ttl;
|
|
struct mdns_rx_staged_ip_s *next;
|
|
} mdns_rx_staged_ip_t;
|
|
#endif
|
|
|
|
static const char *TAG = "mdns_receive";
|
|
|
|
/**
|
|
* @brief Check if parsed name is discovery
|
|
*/
|
|
static bool is_discovery(mdns_name_t *name, uint16_t type)
|
|
{
|
|
return (
|
|
(name->host[0] && !strcasecmp(name->host, "_services"))
|
|
&& (name->service[0] && !strcasecmp(name->service, "_dns-sd"))
|
|
&& (name->proto[0] && !strcasecmp(name->proto, "_udp"))
|
|
&& (name->domain[0] && !strcasecmp(name->domain, MDNS_UTILS_DEFAULT_DOMAIN))
|
|
&& type == MDNS_TYPE_PTR
|
|
);
|
|
}
|
|
|
|
static mdns_srv_item_t *get_service_item_subtype(const char *subtype, const char *service, const char *proto)
|
|
{
|
|
mdns_srv_item_t *s = mdns_priv_get_services();
|
|
while (s) {
|
|
if (mdns_utils_service_match(s->service, service, proto, NULL)) {
|
|
mdns_subtype_t *subtype_item = s->service->subtype;
|
|
while (subtype_item) {
|
|
if (!strcasecmp(subtype_item->subtype, subtype)) {
|
|
return s;
|
|
}
|
|
subtype_item = subtype_item->next;
|
|
}
|
|
}
|
|
s = s->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* @brief Check if the parsed name is ours (matches service or host name)
|
|
*/
|
|
static bool is_ours(mdns_name_t *name)
|
|
{
|
|
//domain have to be "local"
|
|
if (mdns_utils_str_null_or_empty(name->domain) || (strcasecmp(name->domain, MDNS_UTILS_DEFAULT_DOMAIN)
|
|
#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
|
|
&& strcasecmp(name->domain, "arpa")
|
|
#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
|
|
)) {
|
|
return false;
|
|
}
|
|
|
|
//if service and proto are empty, host must match out hostname
|
|
if (mdns_utils_str_null_or_empty(name->service) && mdns_utils_str_null_or_empty(name->proto)) {
|
|
if (!mdns_utils_str_null_or_empty(name->host)
|
|
&& !mdns_utils_str_null_or_empty(mdns_priv_get_global_hostname())
|
|
&& mdns_utils_hostname_is_ours(name->host)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//if service or proto is empty, name is invalid
|
|
if (mdns_utils_str_null_or_empty(name->service) || mdns_utils_str_null_or_empty(name->proto)) {
|
|
return false;
|
|
}
|
|
|
|
|
|
//find the service
|
|
mdns_srv_item_t *service;
|
|
if (name->sub) {
|
|
service = get_service_item_subtype(name->host, name->service, name->proto);
|
|
} else if (mdns_utils_str_null_or_empty(name->host)) {
|
|
service = mdns_utils_get_service_item(name->service, name->proto, NULL);
|
|
} else {
|
|
service = mdns_utils_get_service_item_instance(name->host, name->service, name->proto, NULL);
|
|
}
|
|
if (!service) {
|
|
return false;
|
|
}
|
|
|
|
//if query is PTR query and we have service, we have success
|
|
if (name->sub || mdns_utils_str_null_or_empty(name->host)) {
|
|
return true;
|
|
}
|
|
|
|
//OK we have host in the name. find what is the instance of the service
|
|
const char *instance = mdns_utils_get_service_instance_name(service->service);
|
|
if (instance == NULL) {
|
|
return false;
|
|
}
|
|
|
|
//compare the instance against the name
|
|
if (strcasecmp(name->host, instance) == 0) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Duplicate string or return error
|
|
*/
|
|
static esp_err_t strdup_check(char **out, char *in)
|
|
{
|
|
if (in && in[0]) {
|
|
*out = mdns_mem_strdup(in);
|
|
if (!*out) {
|
|
return ESP_FAIL;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
*out = NULL;
|
|
return ESP_OK;
|
|
}
|
|
|
|
/*
|
|
* @brief Appends/increments a number to name/instance in case of collision
|
|
* */
|
|
static char *mangle_name(char *in)
|
|
{
|
|
char *p = strrchr(in, '-');
|
|
int suffix = 0;
|
|
if (p == NULL) {
|
|
//No - in ``in``
|
|
suffix = 2;
|
|
} else {
|
|
char *endp = NULL;
|
|
suffix = strtol(p + 1, &endp, 10);
|
|
if (*endp != 0) {
|
|
//suffix is not numerical
|
|
suffix = 2;
|
|
p = NULL; //so we append -suffix to the entire string
|
|
}
|
|
}
|
|
char *ret;
|
|
if (p == NULL) {
|
|
//need to add -2 to string
|
|
ret = mdns_mem_malloc(strlen(in) + 3);
|
|
if (ret == NULL) {
|
|
HOOK_MALLOC_FAILED;
|
|
return NULL;
|
|
}
|
|
sprintf(ret, "%s-2", in);
|
|
} else {
|
|
size_t in_len = strlen(in);
|
|
ret = mdns_mem_malloc(in_len + 2); //one extra byte in case 9-10 or 99-100 etc
|
|
if (ret == NULL) {
|
|
HOOK_MALLOC_FAILED;
|
|
return NULL;
|
|
}
|
|
memcpy(ret, in, in_len);
|
|
int baseLen = p - in; //length of 'bla' in 'bla-123'
|
|
//overwrite suffix with new suffix
|
|
sprintf(ret + baseLen, "-%d", suffix + 1);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get number of items in TXT parsed data
|
|
*/
|
|
static int get_txt_items_count(const uint8_t *data, size_t len)
|
|
{
|
|
if (len == 1) {
|
|
return 0;
|
|
}
|
|
|
|
int num_items = 0;
|
|
size_t i = 0;
|
|
|
|
while (i < len) {
|
|
uint8_t item_len = data[i++];
|
|
if (!item_len) {
|
|
// Single byte '\0' is an empty string, ignored
|
|
continue;
|
|
}
|
|
if (item_len > len - i) {
|
|
return -1;//error
|
|
}
|
|
i += item_len;
|
|
num_items++;
|
|
}
|
|
return num_items;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the length of TXT item's key name
|
|
*/
|
|
static int get_txt_item_len(const uint8_t *data, size_t len)
|
|
{
|
|
if (*data == '=') {
|
|
return -1;
|
|
}
|
|
for (size_t i = 0; i < len; i++) {
|
|
if (data[i] == '=') {
|
|
return i;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
|
|
static esp_err_t parse_txt_item_data(const uint8_t *data, size_t item_len, const char **key_out, char **value_out,
|
|
uint8_t *value_len_out)
|
|
{
|
|
int key_len = get_txt_item_len(data, item_len);
|
|
if (key_len < 0) {
|
|
// Invalid item with no key
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
*key_out = mdns_mem_strndup((const char *)data, key_len);
|
|
if (!*key_out) {
|
|
HOOK_MALLOC_FAILED;
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
// Skips '=' only if presents
|
|
int value_index = key_len + ((key_len < item_len) ? 1 : 0);
|
|
uint8_t value_len = item_len > value_index ? item_len - value_index : 0;
|
|
*value_len_out = value_len;
|
|
|
|
if (key_len < item_len) {
|
|
*value_out = (char *)mdns_mem_calloc(value_len + 1, sizeof(char));
|
|
if (!*value_out) {
|
|
HOOK_MALLOC_FAILED;
|
|
mdns_mem_free((char *)*key_out);
|
|
*key_out = NULL;
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
memcpy(*value_out, data + value_index, value_len);
|
|
} else {
|
|
*value_out = NULL;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Create TXT result array from parsed TXT data
|
|
*/
|
|
static void result_txt_create(const uint8_t *data, size_t len, mdns_txt_item_t **out_txt, uint8_t **out_value_len,
|
|
size_t *out_count)
|
|
{
|
|
*out_txt = NULL;
|
|
*out_value_len = NULL;
|
|
*out_count = 0;
|
|
|
|
int num_items = get_txt_items_count(data, len);
|
|
if (num_items < 0 || num_items > SIZE_MAX / sizeof(mdns_txt_item_t)) {
|
|
// Error: num_items is incorrect (or too large to allocate)
|
|
return;
|
|
}
|
|
|
|
if (!num_items) {
|
|
return;
|
|
}
|
|
|
|
mdns_txt_item_t *txt = (mdns_txt_item_t *)mdns_mem_calloc(num_items, sizeof(mdns_txt_item_t));
|
|
if (!txt) {
|
|
HOOK_MALLOC_FAILED;
|
|
return;
|
|
}
|
|
uint8_t *txt_value_len = (uint8_t *)mdns_mem_calloc(num_items, sizeof(uint8_t));
|
|
if (!txt_value_len) {
|
|
mdns_mem_free(txt);
|
|
HOOK_MALLOC_FAILED;
|
|
return;
|
|
}
|
|
|
|
uint16_t data_index = 0;
|
|
size_t txt_num = 0;
|
|
|
|
while (data_index < len && txt_num < num_items) {
|
|
uint8_t item_len = data[data_index++];
|
|
if (item_len == 0) {
|
|
continue;
|
|
}
|
|
|
|
if ((data_index + item_len) > len) {
|
|
goto handle_error;//error
|
|
}
|
|
|
|
esp_err_t err = parse_txt_item_data(data + data_index, item_len, &txt[txt_num].key, (char **)&txt[txt_num].value,
|
|
&txt_value_len[txt_num]);
|
|
data_index += item_len;
|
|
|
|
switch (err) {
|
|
case ESP_OK:
|
|
txt_num++;
|
|
break;
|
|
case ESP_ERR_INVALID_ARG:
|
|
// Invalid item with no key
|
|
continue;
|
|
default:
|
|
goto handle_error;
|
|
}
|
|
}
|
|
|
|
if (txt_num == 0) {
|
|
mdns_mem_free(txt);
|
|
mdns_mem_free(txt_value_len);
|
|
return;
|
|
}
|
|
|
|
*out_txt = txt;
|
|
*out_count = txt_num;
|
|
*out_value_len = txt_value_len;
|
|
return;
|
|
|
|
handle_error :
|
|
for (int y = 0; y < txt_num; y++) {
|
|
mdns_txt_item_t *t = &txt[y];
|
|
mdns_mem_free((char *)t->key);
|
|
mdns_mem_free((char *)t->value);
|
|
}
|
|
mdns_mem_free(txt_value_len);
|
|
mdns_mem_free(txt);
|
|
}
|
|
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
static bool result_txt_linked_list_create(const uint8_t *data, size_t len, mdns_txt_linked_item_t **out_txt)
|
|
{
|
|
*out_txt = NULL;
|
|
mdns_txt_linked_item_t *txt_linked_list = NULL;
|
|
mdns_txt_linked_item_t **txt_ptr = &txt_linked_list;
|
|
uint16_t data_index = 0;
|
|
int txt_num = 0;
|
|
int num_items = get_txt_items_count(data, len);
|
|
if (num_items < 0 || num_items > SIZE_MAX / sizeof(mdns_txt_item_t)) {
|
|
// Error: num_items is incorrect (or too large to allocate)
|
|
return false;
|
|
}
|
|
if (num_items == 0) {
|
|
// Empty TXT, no need to allocate
|
|
return true;
|
|
}
|
|
|
|
while (data_index < len && txt_num < num_items) {
|
|
uint8_t item_len = data[data_index++];
|
|
if (item_len == 0) {
|
|
continue;
|
|
}
|
|
if ((data_index + item_len) > len) {
|
|
goto error;
|
|
}
|
|
|
|
*txt_ptr = (mdns_txt_linked_item_t *)mdns_mem_calloc(1, sizeof(mdns_txt_linked_item_t));
|
|
if (!*txt_ptr) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto error;
|
|
}
|
|
|
|
esp_err_t err = parse_txt_item_data(data + data_index, item_len, &(*txt_ptr)->key, &(*txt_ptr)->value,
|
|
&(*txt_ptr)->value_len);
|
|
|
|
data_index += item_len;
|
|
switch (err) {
|
|
case ESP_OK:
|
|
txt_num++;
|
|
txt_ptr = &(*txt_ptr)->next;
|
|
break;
|
|
case ESP_ERR_INVALID_ARG:
|
|
// Invalid item with no key
|
|
mdns_mem_free(*txt_ptr);
|
|
*txt_ptr = NULL;
|
|
continue;
|
|
default:
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
*out_txt = txt_linked_list;
|
|
return true;
|
|
|
|
error:
|
|
mdns_utils_free_txt_linked_list(txt_linked_list);
|
|
return false;
|
|
}
|
|
#endif /* CONFIG_MDNS_ENABLE_BROWSE */
|
|
|
|
#ifdef CONFIG_LWIP_IPV4
|
|
/**
|
|
* @brief Detect IPv4 address collision
|
|
*/
|
|
static int check_a_collision(esp_ip4_addr_t *ip, mdns_if_t tcpip_if)
|
|
{
|
|
esp_netif_ip_info_t if_ip_info;
|
|
esp_netif_ip_info_t other_ip_info;
|
|
if (!ip->addr) {
|
|
return 1;//denial! they win
|
|
}
|
|
if (esp_netif_get_ip_info(mdns_priv_get_esp_netif(tcpip_if), &if_ip_info)) {
|
|
return 1;//they win
|
|
}
|
|
int ret = memcmp((uint8_t *)&if_ip_info.ip.addr, (uint8_t *)&ip->addr, sizeof(esp_ip4_addr_t));
|
|
if (ret > 0) {
|
|
return -1;//we win
|
|
} else if (ret < 0) {
|
|
//is it the other interface?
|
|
mdns_if_t other_if = mdns_priv_netif_get_other_interface(tcpip_if);
|
|
if (other_if == MDNS_MAX_INTERFACES) {
|
|
return 1;//AP interface! They win
|
|
}
|
|
if (esp_netif_get_ip_info(mdns_priv_get_esp_netif(other_if), &other_ip_info)) {
|
|
return 1;//IPv4 not active! They win
|
|
}
|
|
if (ip->addr != other_ip_info.ip.addr) {
|
|
return 1;//IPv4 not ours! They win
|
|
}
|
|
mdns_priv_pcb_set_duplicate(tcpip_if);
|
|
return 2;//they win
|
|
}
|
|
return 0;//same
|
|
}
|
|
#endif /* CONFIG_LWIP_IPV4 */
|
|
|
|
#ifdef CONFIG_LWIP_IPV6
|
|
/**
|
|
* @brief Detect IPv6 address collision
|
|
*/
|
|
static int check_aaaa_collision(esp_ip6_addr_t *ip, mdns_if_t tcpip_if)
|
|
{
|
|
struct esp_ip6_addr if_ip6;
|
|
struct esp_ip6_addr other_ip6;
|
|
if (mdns_utils_ipv6_address_is_zero(*ip)) {
|
|
return 1;//denial! they win
|
|
}
|
|
if (esp_netif_get_ip6_linklocal(mdns_priv_get_esp_netif(tcpip_if), &if_ip6)) {
|
|
return 1;//they win
|
|
}
|
|
int ret = memcmp((uint8_t *)&if_ip6.addr, (uint8_t *)ip->addr, MDNS_UTILS_SIZEOF_IP6_ADDR);
|
|
if (ret > 0) {
|
|
return -1;//we win
|
|
} else if (ret < 0) {
|
|
//is it the other interface?
|
|
mdns_if_t other_if = mdns_priv_netif_get_other_interface(tcpip_if);
|
|
if (other_if == MDNS_MAX_INTERFACES) {
|
|
return 1;//AP interface! They win
|
|
}
|
|
if (esp_netif_get_ip6_linklocal(mdns_priv_get_esp_netif(other_if), &other_ip6)) {
|
|
return 1;//IPv6 not active! They win
|
|
}
|
|
if (memcmp((uint8_t *)&other_ip6.addr, (uint8_t *)ip->addr, MDNS_UTILS_SIZEOF_IP6_ADDR)) {
|
|
return 1;//IPv6 not ours! They win
|
|
}
|
|
mdns_priv_pcb_set_duplicate(tcpip_if);
|
|
return 2;//they win
|
|
}
|
|
return 0;//same
|
|
}
|
|
#endif /* CONFIG_LWIP_IPV6 */
|
|
|
|
/**
|
|
* @brief Detect TXT collision
|
|
*/
|
|
static int check_txt_collision(mdns_service_t *service, const uint8_t *data, size_t len)
|
|
{
|
|
size_t data_len = 0;
|
|
if (len <= 1 && service->txt) { // len==0 means incorrect packet (and handled by the packet parser)
|
|
// but handled here again to fix clang-tidy warning on VLA "uint8_t our[0];"
|
|
return -1;//we win
|
|
} else if (len > 1 && !service->txt) {
|
|
return 1;//they win
|
|
} else if (len <= 1 && !service->txt) {
|
|
return 0;//same
|
|
}
|
|
|
|
mdns_txt_linked_item_t *txt = service->txt;
|
|
while (txt) {
|
|
data_len += 1 /* record-len */ + strlen(txt->key) + txt->value_len + (txt->value ? 1 : 0 /* "=" */);
|
|
txt = txt->next;
|
|
}
|
|
|
|
if (len > data_len) {
|
|
return 1;//they win
|
|
} else if (len < data_len) {
|
|
return -1;//we win
|
|
}
|
|
|
|
uint16_t index = 0;
|
|
/* Packet-sized TXT must not be a VLA on the mDNS task stack. */
|
|
uint8_t *ours = mdns_mem_malloc(len);
|
|
if (!ours) {
|
|
return 0;
|
|
}
|
|
|
|
txt = service->txt;
|
|
while (txt) {
|
|
mdns_priv_append_one_txt_record_entry(ours, &index, txt);
|
|
txt = txt->next;
|
|
}
|
|
|
|
int ret = memcmp(ours, data, len);
|
|
mdns_mem_free(ours);
|
|
if (ret > 0) {
|
|
return -1;//we win
|
|
} else if (ret < 0) {
|
|
return 1;//they win
|
|
}
|
|
return 0;//same
|
|
}
|
|
|
|
/**
|
|
* @brief Detect SRV collision
|
|
*/
|
|
static int check_srv_collision(mdns_service_t *service, uint16_t priority, uint16_t weight, uint16_t port, const char *host, const char *domain)
|
|
{
|
|
if (mdns_utils_str_null_or_empty(mdns_priv_get_global_hostname())) {
|
|
return 0;
|
|
}
|
|
|
|
size_t our_host_len = strlen(mdns_priv_get_global_hostname());
|
|
size_t our_len = 14 + our_host_len;
|
|
|
|
size_t their_host_len = strlen(host);
|
|
size_t their_domain_len = strlen(domain);
|
|
size_t their_len = 9 + their_host_len + their_domain_len;
|
|
|
|
if (their_len > our_len) {
|
|
return 1;//they win
|
|
} else if (their_len < our_len) {
|
|
return -1;//we win
|
|
}
|
|
|
|
/*
|
|
* Names are bounded by MDNS_NAME_MAX_LEN. Keep the compare buffers fixed so
|
|
* GCC does not allocate them with a runtime SP adjustment.
|
|
*/
|
|
enum {
|
|
MDNS_SRV_OUR_DATA_MAX = 14 + MDNS_NAME_MAX_LEN,
|
|
MDNS_SRV_THEIR_DATA_MAX = 9 + (2 * MDNS_NAME_MAX_LEN),
|
|
};
|
|
if (our_host_len > MDNS_NAME_MAX_LEN || their_host_len > MDNS_NAME_MAX_LEN ||
|
|
their_domain_len > MDNS_NAME_MAX_LEN || our_len > MDNS_SRV_OUR_DATA_MAX ||
|
|
their_len > MDNS_SRV_THEIR_DATA_MAX) {
|
|
return 1;//they win
|
|
}
|
|
|
|
uint16_t our_index = 0;
|
|
uint8_t our_data[MDNS_SRV_OUR_DATA_MAX];
|
|
mdns_utils_append_u16(our_data, &our_index, service->priority);
|
|
mdns_utils_append_u16(our_data, &our_index, service->weight);
|
|
mdns_utils_append_u16(our_data, &our_index, service->port);
|
|
our_data[our_index++] = our_host_len;
|
|
memcpy(our_data + our_index, mdns_priv_get_global_hostname(), our_host_len);
|
|
our_index += our_host_len;
|
|
our_data[our_index++] = 5;
|
|
memcpy(our_data + our_index, MDNS_UTILS_DEFAULT_DOMAIN, 5);
|
|
our_index += 5;
|
|
our_data[our_index++] = 0;
|
|
|
|
uint16_t their_index = 0;
|
|
uint8_t their_data[MDNS_SRV_THEIR_DATA_MAX];
|
|
mdns_utils_append_u16(their_data, &their_index, priority);
|
|
mdns_utils_append_u16(their_data, &their_index, weight);
|
|
mdns_utils_append_u16(their_data, &their_index, port);
|
|
their_data[their_index++] = their_host_len;
|
|
memcpy(their_data + their_index, host, their_host_len);
|
|
their_index += their_host_len;
|
|
their_data[their_index++] = their_domain_len;
|
|
memcpy(their_data + their_index, domain, their_domain_len);
|
|
their_index += their_domain_len;
|
|
their_data[their_index++] = 0;
|
|
|
|
int ret = memcmp(our_data, their_data, our_len);
|
|
if (ret > 0) {
|
|
return -1;//we win
|
|
} else if (ret < 0) {
|
|
return 1;//they win
|
|
}
|
|
return 0;//same
|
|
}
|
|
|
|
/**
|
|
* @brief Check if the parsed name is self-hosted, i.e. we should resolve conflicts
|
|
*/
|
|
static bool is_name_selfhosted(mdns_name_t *name)
|
|
{
|
|
if (mdns_utils_str_null_or_empty(mdns_priv_get_global_hostname())) { // self-hostname needs to be defined
|
|
return false;
|
|
}
|
|
|
|
// hostname only -- check if selfhosted name
|
|
if (mdns_utils_str_null_or_empty(name->service) && mdns_utils_str_null_or_empty(name->proto) &&
|
|
strcasecmp(name->host, mdns_priv_get_global_hostname()) == 0) {
|
|
return true;
|
|
}
|
|
|
|
// service -- check if selfhosted service
|
|
mdns_srv_item_t *srv = mdns_utils_get_service_item(name->service, name->proto, NULL);
|
|
if (srv && strcasecmp(mdns_priv_get_global_hostname(), srv->service->hostname) == 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Called from parser to check if question matches particular service
|
|
*/
|
|
static bool question_matches(mdns_parsed_question_t *question, uint16_t type, mdns_srv_item_t *service)
|
|
{
|
|
if (question->type != type) {
|
|
return false;
|
|
}
|
|
if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) {
|
|
return true;
|
|
} else if (type == MDNS_TYPE_PTR || type == MDNS_TYPE_SDPTR) {
|
|
if (question->service && question->proto && question->domain
|
|
&& !strcasecmp(service->service->service, question->service)
|
|
&& !strcasecmp(service->service->proto, question->proto)
|
|
&& !strcasecmp(MDNS_UTILS_DEFAULT_DOMAIN, question->domain)) {
|
|
if (!service->service->instance) {
|
|
return true;
|
|
} else if (service->service->instance && question->host && !strcasecmp(service->service->instance, question->host)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else if (service && (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT)) {
|
|
const char *name = mdns_utils_get_service_instance_name(service->service);
|
|
if (name && question->host && question->service && question->proto && question->domain
|
|
&& !strcasecmp(name, question->host)
|
|
&& !strcasecmp(service->service->service, question->service)
|
|
&& !strcasecmp(service->service->proto, question->proto)
|
|
&& !strcasecmp(MDNS_UTILS_DEFAULT_DOMAIN, question->domain)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Removes saved question from parsed data
|
|
*/
|
|
static void remove_parsed_question(mdns_parsed_packet_t *parsed_packet, uint16_t type, mdns_srv_item_t *service)
|
|
{
|
|
mdns_parsed_question_t *q = parsed_packet->questions;
|
|
|
|
if (!q) {
|
|
return;
|
|
}
|
|
|
|
if (question_matches(q, type, service)) {
|
|
parsed_packet->questions = q->next;
|
|
mdns_mem_free(q->host);
|
|
mdns_mem_free(q->service);
|
|
mdns_mem_free(q->proto);
|
|
mdns_mem_free(q->domain);
|
|
mdns_mem_free(q);
|
|
return;
|
|
}
|
|
|
|
while (q->next) {
|
|
mdns_parsed_question_t *p = q->next;
|
|
if (question_matches(p, type, service)) {
|
|
q->next = p->next;
|
|
mdns_mem_free(p->host);
|
|
mdns_mem_free(p->service);
|
|
mdns_mem_free(p->proto);
|
|
mdns_mem_free(p->domain);
|
|
mdns_mem_free(p);
|
|
return;
|
|
}
|
|
q = q->next;
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
static void rx_staged_ip_free(mdns_rx_staged_ip_t *staged_ip)
|
|
{
|
|
while (staged_ip) {
|
|
mdns_rx_staged_ip_t *next = staged_ip->next;
|
|
mdns_mem_free(staged_ip);
|
|
staged_ip = next;
|
|
}
|
|
}
|
|
|
|
static void rx_staged_ip_add(mdns_rx_staged_ip_t **staged_ip, const char *hostname, const esp_ip_addr_t *ip, uint32_t ttl)
|
|
{
|
|
if (!staged_ip || mdns_utils_str_null_or_empty(hostname) || !ip) {
|
|
return;
|
|
}
|
|
|
|
mdns_rx_staged_ip_t *new_staged_ip = (mdns_rx_staged_ip_t *)mdns_mem_calloc(1, sizeof(mdns_rx_staged_ip_t));
|
|
if (!new_staged_ip) {
|
|
HOOK_MALLOC_FAILED;
|
|
return;
|
|
}
|
|
|
|
strncpy(new_staged_ip->hostname, hostname, MDNS_NAME_BUF_LEN - 1);
|
|
new_staged_ip->hostname[MDNS_NAME_BUF_LEN - 1] = '\0';
|
|
new_staged_ip->ip = *ip;
|
|
new_staged_ip->ttl = ttl;
|
|
new_staged_ip->next = *staged_ip;
|
|
*staged_ip = new_staged_ip;
|
|
}
|
|
|
|
static void rx_staged_ips_apply(const esp_netif_t *esp_netif, mdns_ip_protocol_t ip_protocol,
|
|
const mdns_rx_staged_ip_t *staged_ips)
|
|
{
|
|
if (!esp_netif || !staged_ips) {
|
|
return;
|
|
}
|
|
|
|
for (const mdns_rx_staged_ip_t *it = staged_ips; it; it = it->next) {
|
|
(void)mdns_priv_cache_update_existing_addr(esp_netif, ip_protocol, it->hostname, &it->ip, it->ttl);
|
|
}
|
|
}
|
|
#endif /* CONFIG_MDNS_ENABLE_BROWSE */
|
|
|
|
/**
|
|
* @brief main packet parser
|
|
*
|
|
* @param packet the packet
|
|
*/
|
|
static void mdns_parse_packet(mdns_rx_packet_t *packet)
|
|
{
|
|
static mdns_name_t n;
|
|
mdns_header_t header;
|
|
const uint8_t *data = mdns_priv_get_packet_data(packet);
|
|
size_t len = mdns_priv_get_packet_len(packet);
|
|
const uint8_t *content = data + MDNS_HEAD_LEN;
|
|
bool do_not_reply = false;
|
|
mdns_search_once_t *search_result = NULL;
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
bool packet_has_cache_consumer = false;
|
|
mdns_browse_t *browse_result = NULL;
|
|
mdns_rx_staged_ip_t *staged_ips = NULL;
|
|
#endif
|
|
|
|
DBG_RX_PACKET(packet, data, len);
|
|
|
|
#ifndef CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES
|
|
// Check if the packet wasn't sent by us
|
|
#ifdef CONFIG_LWIP_IPV4
|
|
if (packet->ip_protocol == MDNS_IP_PROTOCOL_V4) {
|
|
esp_netif_ip_info_t if_ip_info;
|
|
if (esp_netif_get_ip_info(mdns_priv_get_esp_netif(packet->tcpip_if), &if_ip_info) == ESP_OK &&
|
|
memcmp(&if_ip_info.ip.addr, &packet->src.u_addr.ip4.addr, sizeof(esp_ip4_addr_t)) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
#endif /* CONFIG_LWIP_IPV4 */
|
|
#ifdef CONFIG_LWIP_IPV6
|
|
if (packet->ip_protocol == MDNS_IP_PROTOCOL_V6) {
|
|
struct esp_ip6_addr if_ip6;
|
|
if (esp_netif_get_ip6_linklocal(mdns_priv_get_esp_netif(packet->tcpip_if), &if_ip6) == ESP_OK &&
|
|
memcmp(&if_ip6, &packet->src.u_addr.ip6, sizeof(esp_ip6_addr_t)) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
#endif /* CONFIG_LWIP_IPV6 */
|
|
#endif // CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES
|
|
|
|
// Check for the minimum size of mdns packet
|
|
if (len < MDNS_HEAD_LEN) {
|
|
return;
|
|
}
|
|
|
|
mdns_parsed_packet_t *parsed_packet = (mdns_parsed_packet_t *)mdns_mem_malloc(sizeof(mdns_parsed_packet_t));
|
|
if (!parsed_packet) {
|
|
HOOK_MALLOC_FAILED;
|
|
return;
|
|
}
|
|
memset(parsed_packet, 0, sizeof(mdns_parsed_packet_t));
|
|
|
|
mdns_name_t *name = &n;
|
|
memset(name, 0, sizeof(mdns_name_t));
|
|
|
|
header.id = mdns_utils_read_u16(data, MDNS_HEAD_ID_OFFSET);
|
|
header.flags = mdns_utils_read_u16(data, MDNS_HEAD_FLAGS_OFFSET);
|
|
header.questions = mdns_utils_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET);
|
|
header.answers = mdns_utils_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET);
|
|
header.servers = mdns_utils_read_u16(data, MDNS_HEAD_SERVERS_OFFSET);
|
|
header.additional = mdns_utils_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET);
|
|
|
|
if (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE && packet->src_port != MDNS_SERVICE_PORT) {
|
|
mdns_mem_free(parsed_packet);
|
|
return;
|
|
}
|
|
|
|
//if we have not set the hostname, we can not answer questions
|
|
if (header.questions && !header.answers && mdns_utils_str_null_or_empty(mdns_priv_get_global_hostname())) {
|
|
mdns_mem_free(parsed_packet);
|
|
return;
|
|
}
|
|
|
|
parsed_packet->tcpip_if = packet->tcpip_if;
|
|
parsed_packet->ip_protocol = packet->ip_protocol;
|
|
parsed_packet->multicast = packet->multicast;
|
|
parsed_packet->authoritative = (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE);
|
|
parsed_packet->distributed = header.flags == MDNS_FLAGS_DISTRIBUTED;
|
|
parsed_packet->id = header.id;
|
|
esp_netif_ip_addr_copy(&parsed_packet->src, &packet->src);
|
|
parsed_packet->src_port = packet->src_port;
|
|
parsed_packet->records = NULL;
|
|
|
|
if (header.questions) {
|
|
uint8_t qs = header.questions;
|
|
|
|
while (qs--) {
|
|
content = mdns_utils_parse_fqdn(data, content, name, len);
|
|
if (!content) {
|
|
header.answers = 0;
|
|
header.additional = 0;
|
|
header.servers = 0;
|
|
goto clear_rx_packet; // error
|
|
}
|
|
|
|
if (content + MDNS_CLASS_OFFSET + 1 >= data + len) {
|
|
goto clear_rx_packet; // malformed packet, won't read behind it
|
|
}
|
|
uint16_t type = mdns_utils_read_u16(content, MDNS_TYPE_OFFSET);
|
|
uint16_t mdns_class = mdns_utils_read_u16(content, MDNS_CLASS_OFFSET);
|
|
bool unicast = !!(mdns_class & 0x8000);
|
|
mdns_class &= 0x7FFF;
|
|
content = content + 4;
|
|
|
|
if (mdns_class != 0x0001 || name->invalid) { // bad class or invalid name for this question entry
|
|
continue;
|
|
}
|
|
|
|
if (is_discovery(name, type)) {
|
|
// Already expanded this packet's DNS-SD enumeration questions.
|
|
if (parsed_packet->discovery) {
|
|
continue;
|
|
}
|
|
parsed_packet->discovery = true;
|
|
mdns_srv_item_t *a = mdns_priv_get_services();
|
|
while (a) {
|
|
mdns_parsed_question_t *question = (mdns_parsed_question_t *)mdns_mem_calloc(1, sizeof(mdns_parsed_question_t));
|
|
if (!question) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto clear_rx_packet;
|
|
}
|
|
question->next = parsed_packet->questions;
|
|
parsed_packet->questions = question;
|
|
|
|
question->unicast = unicast;
|
|
question->type = MDNS_TYPE_SDPTR;
|
|
question->host = NULL;
|
|
question->service = mdns_mem_strdup(a->service->service);
|
|
question->proto = mdns_mem_strdup(a->service->proto);
|
|
question->domain = mdns_mem_strdup(MDNS_UTILS_DEFAULT_DOMAIN);
|
|
if (!question->service || !question->proto || !question->domain) {
|
|
goto clear_rx_packet;
|
|
}
|
|
a = a->next;
|
|
}
|
|
continue;
|
|
}
|
|
if (!is_ours(name)) {
|
|
continue;
|
|
}
|
|
|
|
if (type == MDNS_TYPE_ANY && !name->sub && !mdns_utils_str_null_or_empty(name->host)) {
|
|
parsed_packet->probe = true;
|
|
}
|
|
|
|
mdns_parsed_question_t *question = (mdns_parsed_question_t *)mdns_mem_calloc(1, sizeof(mdns_parsed_question_t));
|
|
if (!question) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto clear_rx_packet;
|
|
}
|
|
question->next = parsed_packet->questions;
|
|
parsed_packet->questions = question;
|
|
|
|
question->unicast = unicast;
|
|
question->type = type;
|
|
question->sub = name->sub;
|
|
if (strdup_check(&(question->host), name->host)
|
|
|| strdup_check(&(question->service), name->service)
|
|
|| strdup_check(&(question->proto), name->proto)
|
|
|| strdup_check(&(question->domain), name->domain)) {
|
|
goto clear_rx_packet;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (header.questions && !parsed_packet->questions && !parsed_packet->discovery && !header.answers) {
|
|
goto clear_rx_packet;
|
|
} else if (header.answers || header.servers || header.additional) {
|
|
uint16_t recordIndex = 0;
|
|
|
|
while (content < (data + len)) {
|
|
search_result = NULL;
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
browse_result = NULL;
|
|
#endif
|
|
|
|
content = mdns_utils_parse_fqdn(data, content, name, len);
|
|
if (!content) {
|
|
goto clear_rx_packet;
|
|
}
|
|
|
|
if (content + MDNS_LEN_OFFSET + 1 >= data + len) {
|
|
goto clear_rx_packet; // malformed packet, won't read behind it
|
|
}
|
|
uint16_t type = mdns_utils_read_u16(content, MDNS_TYPE_OFFSET);
|
|
uint16_t mdns_class = mdns_utils_read_u16(content, MDNS_CLASS_OFFSET);
|
|
uint32_t ttl = mdns_utils_read_u32(content, MDNS_TTL_OFFSET);
|
|
uint16_t data_len = mdns_utils_read_u16(content, MDNS_LEN_OFFSET);
|
|
const uint8_t *data_ptr = content + MDNS_DATA_OFFSET;
|
|
mdns_class &= 0x7FFF;
|
|
|
|
content = data_ptr + data_len;
|
|
if (content > (data + len) || data_len == 0) {
|
|
goto clear_rx_packet;
|
|
}
|
|
|
|
bool discovery = false;
|
|
bool ours = false;
|
|
mdns_srv_item_t *service = NULL;
|
|
mdns_parsed_record_type_t record_type = MDNS_ANSWER;
|
|
|
|
if (recordIndex >= (header.answers + header.servers)) {
|
|
record_type = MDNS_EXTRA;
|
|
} else if (recordIndex >= (header.answers)) {
|
|
record_type = MDNS_NS;
|
|
}
|
|
recordIndex++;
|
|
|
|
if (type == MDNS_TYPE_NSEC || type == MDNS_TYPE_OPT) {
|
|
//skip NSEC and OPT
|
|
continue;
|
|
}
|
|
|
|
if (parsed_packet->discovery && is_discovery(name, type)) {
|
|
discovery = true;
|
|
} else if (!name->sub && is_ours(name)) {
|
|
ours = true;
|
|
if (name->service[0] && name->proto[0]) {
|
|
service = mdns_utils_get_service_item(name->service, name->proto, NULL);
|
|
}
|
|
} else {
|
|
if ((header.flags & MDNS_FLAGS_QUERY_REPSONSE) == 0 || record_type == MDNS_NS) {
|
|
//skip this record
|
|
continue;
|
|
}
|
|
search_result = mdns_priv_query_find(name, type, packet->tcpip_if, packet->ip_protocol);
|
|
}
|
|
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
if (type == MDNS_TYPE_PTR || (!ours && !discovery)) {
|
|
browse_result = mdns_priv_browse_find_consumer(name, type, packet->tcpip_if, packet->ip_protocol);
|
|
if (browse_result) {
|
|
packet_has_cache_consumer = true;
|
|
}
|
|
}
|
|
#endif /* CONFIG_MDNS_ENABLE_BROWSE */
|
|
|
|
if (type == MDNS_TYPE_PTR) {
|
|
size_t rdata_bound = (size_t)(data_ptr + data_len - data);
|
|
if (!mdns_utils_parse_fqdn(data, data_ptr, name, rdata_bound)) {
|
|
continue;//error
|
|
}
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
if (browse_result && !mdns_utils_str_null_or_empty(name->host)
|
|
&& !mdns_utils_str_null_or_empty(browse_result->service)
|
|
&& !mdns_utils_str_null_or_empty(browse_result->proto)) {
|
|
(void)mdns_priv_cache_update_ptr(mdns_priv_get_esp_netif(packet->tcpip_if), packet->ip_protocol,
|
|
name->host, browse_result->service, browse_result->proto,
|
|
browse_result->subtype, ttl);
|
|
}
|
|
#endif
|
|
if (search_result) {
|
|
mdns_priv_query_result_add_ptr(search_result, name->host, name->service, name->proto,
|
|
packet->tcpip_if, packet->ip_protocol, ttl);
|
|
} else if ((discovery || ours) && !name->sub && is_ours(name)) {
|
|
if (name->host[0]) {
|
|
service = mdns_utils_get_service_item_instance(name->host, name->service, name->proto, NULL);
|
|
} else {
|
|
service = mdns_utils_get_service_item(name->service, name->proto, NULL);
|
|
}
|
|
if (discovery && service) {
|
|
remove_parsed_question(parsed_packet, MDNS_TYPE_SDPTR, service);
|
|
} else if (service && parsed_packet->questions && !parsed_packet->probe) {
|
|
remove_parsed_question(parsed_packet, type, service);
|
|
} else if (service) {
|
|
//check if TTL is more than half of the full TTL value (4500)
|
|
if (ttl > (MDNS_ANSWER_PTR_TTL / 2)) {
|
|
mdns_priv_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service);
|
|
}
|
|
}
|
|
if (service) {
|
|
mdns_parsed_record_t *record = mdns_mem_malloc(sizeof(mdns_parsed_record_t));
|
|
if (!record) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto clear_rx_packet;
|
|
}
|
|
record->next = parsed_packet->records;
|
|
parsed_packet->records = record;
|
|
record->type = MDNS_TYPE_PTR;
|
|
record->record_type = MDNS_ANSWER;
|
|
record->ttl = ttl;
|
|
record->host = NULL;
|
|
record->service = NULL;
|
|
record->proto = NULL;
|
|
if (name->host[0]) {
|
|
record->host = mdns_mem_malloc(MDNS_NAME_BUF_LEN);
|
|
if (!record->host) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto clear_rx_packet;
|
|
}
|
|
memcpy(record->host, name->host, MDNS_NAME_BUF_LEN);
|
|
}
|
|
if (name->service[0]) {
|
|
record->service = mdns_mem_malloc(MDNS_NAME_BUF_LEN);
|
|
if (!record->service) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto clear_rx_packet;
|
|
}
|
|
memcpy(record->service, name->service, MDNS_NAME_BUF_LEN);
|
|
}
|
|
if (name->proto[0]) {
|
|
record->proto = mdns_mem_malloc(MDNS_NAME_BUF_LEN);
|
|
if (!record->proto) {
|
|
HOOK_MALLOC_FAILED;
|
|
goto clear_rx_packet;
|
|
}
|
|
memcpy(record->proto, name->proto, MDNS_NAME_BUF_LEN);
|
|
}
|
|
}
|
|
}
|
|
} else if (type == MDNS_TYPE_SRV) {
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
char browse_instance_name[MDNS_NAME_BUF_LEN] = {0};
|
|
memcpy(browse_instance_name, name->host, MDNS_NAME_BUF_LEN);
|
|
#endif
|
|
mdns_result_t *result = NULL;
|
|
if (search_result && search_result->type == MDNS_TYPE_PTR) {
|
|
result = search_result->result;
|
|
while (result) {
|
|
if (mdns_priv_get_esp_netif(packet->tcpip_if) == result->esp_netif
|
|
&& packet->ip_protocol == result->ip_protocol
|
|
&& result->instance_name && !strcmp(name->host, result->instance_name)) {
|
|
break;
|
|
}
|
|
result = result->next;
|
|
}
|
|
if (!result) {
|
|
result = mdns_priv_query_result_add_ptr(search_result, name->host, name->service, name->proto,
|
|
packet->tcpip_if, packet->ip_protocol, ttl);
|
|
if (!result) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
bool is_selfhosted = is_name_selfhosted(name);
|
|
size_t rdata_bound = (size_t)(data_ptr + data_len - data);
|
|
if (!mdns_utils_parse_fqdn(data, data_ptr + MDNS_SRV_FQDN_OFFSET, name, rdata_bound)) {
|
|
continue;
|
|
}
|
|
if (data_ptr + MDNS_SRV_PORT_OFFSET + 1 >= data + len) {
|
|
goto clear_rx_packet; // malformed packet, won't read behind it
|
|
}
|
|
uint16_t priority = mdns_utils_read_u16(data_ptr, MDNS_SRV_PRIORITY_OFFSET);
|
|
uint16_t weight = mdns_utils_read_u16(data_ptr, MDNS_SRV_WEIGHT_OFFSET);
|
|
uint16_t port = mdns_utils_read_u16(data_ptr, MDNS_SRV_PORT_OFFSET);
|
|
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
if (browse_result && !mdns_utils_str_null_or_empty(browse_instance_name)
|
|
&& !mdns_utils_str_null_or_empty(browse_result->service)
|
|
&& !mdns_utils_str_null_or_empty(browse_result->proto)) {
|
|
(void)mdns_priv_cache_update_srv(mdns_priv_get_esp_netif(packet->tcpip_if), packet->ip_protocol,
|
|
name->host, browse_instance_name, browse_result->service,
|
|
browse_result->proto, priority, weight, port, ttl);
|
|
}
|
|
#endif
|
|
if (search_result) {
|
|
if (search_result->type == MDNS_TYPE_PTR) {
|
|
if (!result->hostname) { // assign host/port for this entry only if not previously set
|
|
result->port = port;
|
|
result->hostname = mdns_mem_strdup(name->host);
|
|
}
|
|
} else {
|
|
mdns_priv_query_result_add_srv(search_result, name->host, port, packet->tcpip_if,
|
|
packet->ip_protocol, ttl);
|
|
}
|
|
} else if (ours) {
|
|
if (parsed_packet->questions && !parsed_packet->probe) {
|
|
remove_parsed_question(parsed_packet, type, service);
|
|
continue;
|
|
} else if (parsed_packet->distributed) {
|
|
mdns_priv_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service);
|
|
continue;
|
|
}
|
|
if (!is_selfhosted) {
|
|
continue;
|
|
}
|
|
//detect collision (-1=won, 0=none, 1=lost)
|
|
int col = 0;
|
|
if (mdns_class > 1) {
|
|
col = 1;
|
|
} else if (!mdns_class) {
|
|
col = -1;
|
|
} else if (service) { // only detect srv collision if service existed
|
|
col = check_srv_collision(service->service, priority, weight, port, name->host, name->domain);
|
|
}
|
|
if (service && col && (parsed_packet->probe || parsed_packet->authoritative)) {
|
|
if (col > 0 || !port) {
|
|
do_not_reply = true;
|
|
if (mdns_priv_pcb_is_probing(packet)) {
|
|
mdns_priv_pcb_set_probe_failed(packet);
|
|
if (!mdns_utils_str_null_or_empty(service->service->instance)) {
|
|
char *new_instance = mangle_name((char *) service->service->instance);
|
|
if (new_instance) {
|
|
mdns_mem_free((char *)service->service->instance);
|
|
service->service->instance = new_instance;
|
|
}
|
|
mdns_priv_probe_all_pcbs(&service, 1, false, false);
|
|
} else if (!mdns_utils_str_null_or_empty(mdns_priv_get_instance())) {
|
|
char *new_instance = mangle_name((char *) mdns_priv_get_instance());
|
|
if (new_instance) {
|
|
mdns_priv_set_instance(new_instance);
|
|
}
|
|
mdns_priv_restart_all_pcbs_no_instance();
|
|
} else {
|
|
char *new_host = mangle_name((char *) mdns_priv_get_global_hostname());
|
|
if (new_host) {
|
|
mdns_priv_remap_self_service_hostname(mdns_priv_get_global_hostname(), new_host);
|
|
mdns_priv_set_global_hostname(new_host);
|
|
}
|
|
mdns_priv_restart_all_pcbs();
|
|
}
|
|
} else if (service) {
|
|
mdns_priv_send_bye(packet->tcpip_if, packet->ip_protocol, &service, 1, false);
|
|
mdns_priv_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, &service, 1, false);
|
|
}
|
|
}
|
|
} else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions) {
|
|
mdns_priv_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service);
|
|
}
|
|
}
|
|
} else if (type == MDNS_TYPE_TXT) {
|
|
mdns_txt_item_t *txt = NULL;
|
|
uint8_t *txt_value_len = NULL;
|
|
size_t txt_count = 0;
|
|
|
|
mdns_result_t *result = NULL;
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
mdns_txt_linked_item_t *txt_linked_list = NULL;
|
|
if (browse_result && !mdns_utils_str_null_or_empty(name->host)
|
|
&& !mdns_utils_str_null_or_empty(browse_result->service)
|
|
&& !mdns_utils_str_null_or_empty(browse_result->proto)) {
|
|
if (result_txt_linked_list_create(data_ptr, data_len, &txt_linked_list)) {
|
|
(void)mdns_priv_cache_update_txt(mdns_priv_get_esp_netif(packet->tcpip_if), packet->ip_protocol,
|
|
name->host, browse_result->service, browse_result->proto, txt_linked_list, ttl);
|
|
txt_linked_list = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
if (search_result) {
|
|
if (search_result->type == MDNS_TYPE_PTR) {
|
|
result = search_result->result;
|
|
while (result) {
|
|
if (mdns_priv_get_esp_netif(packet->tcpip_if) == result->esp_netif
|
|
&& packet->ip_protocol == result->ip_protocol
|
|
&& result->instance_name && !strcmp(name->host, result->instance_name)) {
|
|
break;
|
|
}
|
|
result = result->next;
|
|
}
|
|
if (!result) {
|
|
result = mdns_priv_query_result_add_ptr(search_result, name->host, name->service,
|
|
name->proto,
|
|
packet->tcpip_if, packet->ip_protocol, ttl);
|
|
if (!result) {
|
|
continue;
|
|
}
|
|
}
|
|
if (!result->txt) {
|
|
result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count);
|
|
if (txt_count) {
|
|
result->txt = txt;
|
|
result->txt_count = txt_count;
|
|
result->txt_value_len = txt_value_len;
|
|
}
|
|
}
|
|
} else {
|
|
result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count);
|
|
if (txt_count) {
|
|
mdns_priv_query_result_add_txt(search_result, txt, txt_value_len, txt_count,
|
|
packet->tcpip_if, packet->ip_protocol, ttl);
|
|
}
|
|
}
|
|
} else if (ours) {
|
|
if (parsed_packet->questions && !parsed_packet->probe && service) {
|
|
remove_parsed_question(parsed_packet, type, service);
|
|
continue;
|
|
}
|
|
if (!is_name_selfhosted(name)) {
|
|
continue;
|
|
}
|
|
//detect collision (-1=won, 0=none, 1=lost)
|
|
int col = 0;
|
|
if (mdns_class > 1) {
|
|
col = 1;
|
|
} else if (!mdns_class) {
|
|
col = -1;
|
|
} else if (service) { // only detect txt collision if service existed
|
|
col = check_txt_collision(service->service, data_ptr, data_len);
|
|
}
|
|
if (col && !mdns_priv_pcb_is_probing(packet) && service) {
|
|
do_not_reply = true;
|
|
mdns_priv_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, &service, 1, true);
|
|
} else if (ttl > (MDNS_ANSWER_TXT_TTL / 2) && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !mdns_priv_pcb_is_probing(
|
|
packet)) {
|
|
mdns_priv_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service);
|
|
}
|
|
}
|
|
|
|
}
|
|
#ifdef CONFIG_LWIP_IPV6
|
|
else if (type == MDNS_TYPE_AAAA) { // ipv6
|
|
if (data_len < MDNS_ANSWER_AAAA_SIZE) {
|
|
continue; // malformed AAAA record, RDATA smaller than an IPv6 address
|
|
}
|
|
esp_ip_addr_t ip6;
|
|
ip6.type = ESP_IPADDR_TYPE_V6;
|
|
memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE);
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
if (packet_has_cache_consumer) {
|
|
rx_staged_ip_add(&staged_ips, name->host, &ip6, ttl);
|
|
}
|
|
#endif
|
|
if (search_result) {
|
|
//check for more applicable searches (PTR & A/AAAA at the same time)
|
|
while (search_result) {
|
|
mdns_priv_query_result_add_ip(search_result, name->host, &ip6, packet->tcpip_if,
|
|
packet->ip_protocol, ttl);
|
|
search_result = mdns_priv_query_find_from(search_result->next, name, type, packet->tcpip_if,
|
|
packet->ip_protocol);
|
|
}
|
|
} else if (ours) {
|
|
if (parsed_packet->questions && !parsed_packet->probe) {
|
|
remove_parsed_question(parsed_packet, type, NULL);
|
|
continue;
|
|
}
|
|
if (!is_name_selfhosted(name)) {
|
|
continue;
|
|
}
|
|
//detect collision (-1=won, 0=none, 1=lost)
|
|
int col = 0;
|
|
if (mdns_class > 1) {
|
|
col = 1;
|
|
} else if (!mdns_class) {
|
|
col = -1;
|
|
} else {
|
|
col = check_aaaa_collision(&(ip6.u_addr.ip6), packet->tcpip_if);
|
|
}
|
|
if (col == 2) {
|
|
goto clear_rx_packet;
|
|
} else if (col == 1) {
|
|
do_not_reply = true;
|
|
if (mdns_priv_pcb_is_probing(packet)) {
|
|
if (col && (parsed_packet->probe || parsed_packet->authoritative)) {
|
|
mdns_priv_pcb_set_probe_failed(packet);
|
|
char *new_host = mangle_name((char *) mdns_priv_get_global_hostname());
|
|
if (new_host) {
|
|
mdns_priv_remap_self_service_hostname(mdns_priv_get_global_hostname(), new_host);
|
|
mdns_priv_set_global_hostname(new_host);
|
|
}
|
|
mdns_priv_restart_all_pcbs();
|
|
}
|
|
} else {
|
|
mdns_priv_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, NULL, 0, true);
|
|
}
|
|
} else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !mdns_priv_pcb_is_probing(
|
|
packet)) {
|
|
mdns_priv_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, NULL);
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif /* CONFIG_LWIP_IPV6 */
|
|
#ifdef CONFIG_LWIP_IPV4
|
|
else if (type == MDNS_TYPE_A) {
|
|
if (data_len < 4) {
|
|
continue; // malformed A record, RDATA smaller than an IPv4 address
|
|
}
|
|
esp_ip_addr_t ip;
|
|
ip.type = ESP_IPADDR_TYPE_V4;
|
|
memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4);
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
if (packet_has_cache_consumer) {
|
|
rx_staged_ip_add(&staged_ips, name->host, &ip, ttl);
|
|
}
|
|
#endif
|
|
if (search_result) {
|
|
//check for more applicable searches (PTR & A/AAAA at the same time)
|
|
while (search_result) {
|
|
mdns_priv_query_result_add_ip(search_result, name->host, &ip, packet->tcpip_if,
|
|
packet->ip_protocol, ttl);
|
|
search_result = mdns_priv_query_find_from(search_result->next, name, type, packet->tcpip_if,
|
|
packet->ip_protocol);
|
|
}
|
|
} else if (ours) {
|
|
if (parsed_packet->questions && !parsed_packet->probe) {
|
|
remove_parsed_question(parsed_packet, type, NULL);
|
|
continue;
|
|
}
|
|
if (!is_name_selfhosted(name)) {
|
|
continue;
|
|
}
|
|
//detect collision (-1=won, 0=none, 1=lost)
|
|
int col = 0;
|
|
if (mdns_class > 1) {
|
|
col = 1;
|
|
} else if (!mdns_class) {
|
|
col = -1;
|
|
} else {
|
|
col = check_a_collision(&(ip.u_addr.ip4), packet->tcpip_if);
|
|
}
|
|
if (col == 2) {
|
|
goto clear_rx_packet;
|
|
} else if (col == 1) {
|
|
do_not_reply = true;
|
|
if (mdns_priv_pcb_is_probing(packet)) {
|
|
if (col && (parsed_packet->probe || parsed_packet->authoritative)) {
|
|
mdns_priv_pcb_set_probe_failed(packet);
|
|
char *new_host = mangle_name((char *) mdns_priv_get_global_hostname());
|
|
if (new_host) {
|
|
mdns_priv_remap_self_service_hostname(mdns_priv_get_global_hostname(), new_host);
|
|
mdns_priv_set_global_hostname(new_host);
|
|
}
|
|
mdns_priv_restart_all_pcbs();
|
|
}
|
|
} else {
|
|
mdns_priv_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, NULL, 0, true);
|
|
}
|
|
} else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !mdns_priv_pcb_is_probing(
|
|
packet)) {
|
|
mdns_priv_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, NULL);
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif /* CONFIG_LWIP_IPV4 */
|
|
}
|
|
//end while
|
|
if (parsed_packet->authoritative) {
|
|
mdns_priv_query_done();
|
|
}
|
|
}
|
|
|
|
if (!do_not_reply && mdns_priv_pcb_is_after_probing(packet) && (parsed_packet->questions || parsed_packet->discovery)) {
|
|
mdns_priv_create_answer_from_parsed_packet(parsed_packet);
|
|
}
|
|
|
|
clear_rx_packet:
|
|
#ifdef CONFIG_MDNS_ENABLE_BROWSE
|
|
rx_staged_ips_apply(mdns_priv_get_esp_netif(packet->tcpip_if), packet->ip_protocol, staged_ips);
|
|
rx_staged_ip_free(staged_ips);
|
|
#endif /* CONFIG_MDNS_ENABLE_BROWSE */
|
|
while (parsed_packet->questions) {
|
|
mdns_parsed_question_t *question = parsed_packet->questions;
|
|
parsed_packet->questions = parsed_packet->questions->next;
|
|
if (question->host) {
|
|
mdns_mem_free(question->host);
|
|
}
|
|
if (question->service) {
|
|
mdns_mem_free(question->service);
|
|
}
|
|
if (question->proto) {
|
|
mdns_mem_free(question->proto);
|
|
}
|
|
if (question->domain) {
|
|
mdns_mem_free(question->domain);
|
|
}
|
|
mdns_mem_free(question);
|
|
}
|
|
while (parsed_packet->records) {
|
|
mdns_parsed_record_t *record = parsed_packet->records;
|
|
parsed_packet->records = parsed_packet->records->next;
|
|
if (record->host) {
|
|
mdns_mem_free(record->host);
|
|
}
|
|
if (record->service) {
|
|
mdns_mem_free(record->service);
|
|
}
|
|
if (record->proto) {
|
|
mdns_mem_free(record->proto);
|
|
}
|
|
record->next = NULL;
|
|
mdns_mem_free(record);
|
|
}
|
|
mdns_mem_free(parsed_packet);
|
|
}
|
|
|
|
void mdns_priv_receive_action(mdns_action_t *action, mdns_action_subtype_t type)
|
|
{
|
|
if (action->type != ACTION_RX_HANDLE) {
|
|
abort();
|
|
}
|
|
if (type == ACTION_RUN) {
|
|
mdns_parse_packet(action->data.rx_handle.packet);
|
|
mdns_priv_packet_free(action->data.rx_handle.packet);
|
|
} else if (type == ACTION_CLEANUP) {
|
|
mdns_priv_packet_free(action->data.rx_handle.packet);
|
|
}
|
|
}
|