- 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>
537 lines
16 KiB
C
537 lines
16 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
#include <string.h>
|
|
#include "mdns_private.h"
|
|
#include "mdns_browser.h"
|
|
#include "mdns_mem_caps.h"
|
|
#include "mdns_debug.h"
|
|
#include "mdns_utils.h"
|
|
#include "mdns_querier.h"
|
|
#include "mdns_responder.h"
|
|
#include "mdns_netif.h"
|
|
#include "mdns_service.h"
|
|
#include "esp_log.h"
|
|
#include "mdns_cache.h"
|
|
|
|
#define MDNS_CACHE_RECORD_BROWSE_SHARED (mdns_cache_record_mask_t) \
|
|
(MDNS_CACHE_RECORD_SRV | MDNS_CACHE_RECORD_TXT | MDNS_CACHE_RECORD_ADDR)
|
|
#define MDNS_SUBTYPE_MAX_LEN 63
|
|
|
|
static const char *TAG = "mdns_browser";
|
|
|
|
static mdns_browse_t *s_browse;
|
|
|
|
/**
|
|
* @brief Browse action
|
|
*/
|
|
static esp_err_t send_browse_action(mdns_action_type_t type, mdns_browse_t *browse)
|
|
{
|
|
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.browse_add.browse = browse;
|
|
if (!mdns_priv_queue_action(action)) {
|
|
mdns_mem_free(action);
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Free a browse item (Not free the list).
|
|
*/
|
|
static void browse_item_free(mdns_browse_t *browse)
|
|
{
|
|
if (!browse) {
|
|
return;
|
|
}
|
|
|
|
mdns_mem_free(browse->service);
|
|
mdns_mem_free(browse->proto);
|
|
mdns_mem_free(browse->subtype);
|
|
mdns_mem_free(browse);
|
|
}
|
|
|
|
/**
|
|
* @brief Send PTR query packet to all available interfaces for browsing.
|
|
*/
|
|
static void browse_send(mdns_browse_t *browse, mdns_if_t interface, mdns_ip_protocol_t ip_protocol)
|
|
{
|
|
// Using search once for sending the PTR query
|
|
mdns_search_once_t search = {0};
|
|
|
|
search.instance = NULL;
|
|
search.service = browse->service;
|
|
search.proto = browse->proto;
|
|
search.subtype = browse->subtype;
|
|
search.type = MDNS_TYPE_PTR;
|
|
search.unicast = false;
|
|
search.result = NULL;
|
|
search.next = NULL;
|
|
mdns_priv_query_send(&search, interface, ip_protocol);
|
|
}
|
|
|
|
void mdns_priv_browse_send_by_ip_protocol(mdns_if_t mdns_if, mdns_ip_protocol_t ip_protocol)
|
|
{
|
|
for (mdns_browse_t *browse = s_browse; browse; browse = browse->next) {
|
|
if (browse->state == BROWSE_RUNNING) {
|
|
browse_send(browse, mdns_if, ip_protocol);
|
|
}
|
|
}
|
|
}
|
|
|
|
void mdns_priv_browse_free(void)
|
|
{
|
|
while (s_browse) {
|
|
mdns_browse_t *b = s_browse;
|
|
s_browse = s_browse->next;
|
|
browse_item_free(b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Check if a browse matches a given service and proto.
|
|
*/
|
|
static bool browse_matches_identity(const mdns_browse_t *browse, const char *service, const char *proto)
|
|
{
|
|
return browse && mdns_utils_str_case_equal(browse->service, service) && mdns_utils_str_case_equal(browse->proto, proto);
|
|
}
|
|
|
|
/**
|
|
* @brief Check if a browse matches a given service, proto, and possible subtype.
|
|
*/
|
|
static bool browse_matches_identity_with_subtype(const mdns_browse_t *browse, const char *service, const char *proto, const char *subtype)
|
|
{
|
|
return browse_matches_identity(browse, service, proto) && mdns_utils_str_case_equal_nullable(browse->subtype, subtype);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the non-BROWSE_OFF browse item with the given service, proto, and subtype.
|
|
*/
|
|
static mdns_browse_t *get_non_off_browse_item(const char *service, const char *proto, const char *subtype)
|
|
{
|
|
for (mdns_browse_t *it = s_browse; it; it = it->next) {
|
|
if (it->state != BROWSE_OFF && browse_matches_identity_with_subtype(it, service, proto, subtype)) {
|
|
return it;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool mdns_priv_browse_has_service(const char *service, const char *proto)
|
|
{
|
|
for (const mdns_browse_t *it = s_browse; it; it = it->next) {
|
|
if (it->state == BROWSE_RUNNING && browse_matches_identity(it, service, proto)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool mdns_priv_browse_has_subtype(const char *service, const char *proto, const char *subtype)
|
|
{
|
|
for (const mdns_browse_t *it = s_browse; it; it = it->next) {
|
|
if (it->state == BROWSE_RUNNING && browse_matches_identity_with_subtype(it, service, proto, subtype)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Remove and free the browse from browse linked list
|
|
*/
|
|
static void browse_finish(mdns_browse_t *browse)
|
|
{
|
|
if (!browse) {
|
|
return;
|
|
}
|
|
|
|
for (mdns_browse_t *it = s_browse; it; it = it->next) {
|
|
if (it == browse) {
|
|
queueDetach(mdns_browse_t, s_browse, it);
|
|
browse_item_free(it);
|
|
mdns_priv_cache_trim_unsubscribed_records(esp_timer_get_time());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Allocate new browse structure
|
|
*/
|
|
static mdns_browse_t *browse_init(const char *service, const char *proto, const char *subtype, mdns_browse_notify_t notifier)
|
|
{
|
|
mdns_browse_t *browse = (mdns_browse_t *)mdns_mem_malloc(sizeof(mdns_browse_t));
|
|
|
|
if (!browse) {
|
|
HOOK_MALLOC_FAILED;
|
|
return NULL;
|
|
}
|
|
memset(browse, 0, sizeof(mdns_browse_t));
|
|
|
|
browse->state = BROWSE_INIT;
|
|
if (!mdns_utils_str_null_or_empty(service)) {
|
|
browse->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1);
|
|
if (!browse->service) {
|
|
browse_item_free(browse);
|
|
HOOK_MALLOC_FAILED;
|
|
return NULL;
|
|
}
|
|
}
|
|
if (!mdns_utils_str_null_or_empty(proto)) {
|
|
browse->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1);
|
|
if (!browse->proto) {
|
|
browse_item_free(browse);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (!mdns_utils_str_null_or_empty(subtype)) {
|
|
browse->subtype = mdns_mem_strndup(subtype, MDNS_NAME_BUF_LEN - 1);
|
|
if (!browse->subtype) {
|
|
browse_item_free(browse);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
browse->notifier = notifier;
|
|
return browse;
|
|
}
|
|
|
|
/**
|
|
* @brief Send initial PTR queries for a registered browse.
|
|
*/
|
|
static void browse_start(mdns_browse_t *browse)
|
|
{
|
|
if (!browse || browse->state != BROWSE_INIT) {
|
|
return;
|
|
}
|
|
browse->state = BROWSE_RUNNING;
|
|
mdns_priv_cache_notify_browse(browse);
|
|
for (uint8_t interface_idx = 0; interface_idx < MDNS_MAX_INTERFACES; interface_idx++) {
|
|
for (uint8_t protocol_idx = 0; protocol_idx < MDNS_IP_PROTOCOL_MAX; protocol_idx++) {
|
|
browse_send(browse, (mdns_if_t) interface_idx, (mdns_ip_protocol_t) protocol_idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
mdns_browse_t *mdns_priv_browse_find_consumer(mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
|
|
{
|
|
for (mdns_browse_t *it = s_browse; it; it = it->next) {
|
|
if (it->state != BROWSE_RUNNING) {
|
|
continue;
|
|
}
|
|
// For browse, we only care about PTR, SRV, TXT, A and AAAA
|
|
switch (type) {
|
|
case MDNS_TYPE_PTR: {
|
|
bool subtype_matches = name->sub ? mdns_utils_str_case_equal(name->host, it->subtype) :
|
|
mdns_utils_str_null_or_empty(it->subtype);
|
|
if (mdns_utils_str_case_equal(name->service, it->service) && mdns_utils_str_case_equal(name->proto, it->proto)
|
|
&& subtype_matches) {
|
|
return it;
|
|
}
|
|
break;
|
|
}
|
|
case MDNS_TYPE_SRV:
|
|
case MDNS_TYPE_TXT:
|
|
if (mdns_utils_str_case_equal(name->service, it->service) && mdns_utils_str_case_equal(name->proto, it->proto)) {
|
|
return it;
|
|
}
|
|
break;
|
|
case MDNS_TYPE_A:
|
|
case MDNS_TYPE_AAAA:
|
|
if (mdns_priv_cache_host_has_service(name->host, mdns_priv_get_esp_netif(tcpip_if),
|
|
ip_protocol, it->service, it->proto)) {
|
|
return it;
|
|
}
|
|
break;
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void mdns_priv_browse_action(mdns_action_t *action, mdns_action_subtype_t type)
|
|
{
|
|
if (type == ACTION_RUN) {
|
|
switch (action->type) {
|
|
case ACTION_BROWSE_START:
|
|
browse_start(action->data.browse_add.browse);
|
|
break;
|
|
case ACTION_BROWSE_END:
|
|
browse_finish(action->data.browse_add.browse);
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Check if a running browse `_service._proto` matches a service cache `_service._proto`.
|
|
*/
|
|
static bool browse_matches_service_cache(const mdns_browse_t *browse, const mdns_service_cache_t *service)
|
|
{
|
|
return browse && service && browse->state == BROWSE_RUNNING && browse->notifier
|
|
&& mdns_utils_str_case_equal(browse->service, service->service)
|
|
&& mdns_utils_str_case_equal(browse->proto, service->proto);
|
|
}
|
|
|
|
/**
|
|
* @brief Check if a running browse matches a service cache with service name, proto, and possible subtype.
|
|
* If subtype node is found in cache and `out_subtype` is valid, the subtype node in cache will be passed to it.
|
|
*/
|
|
static bool browse_matches_service_cache_with_subtype(const mdns_browse_t *browse, const mdns_service_cache_t *service, const mdns_cache_subtype_t **out_subtype)
|
|
{
|
|
const mdns_cache_subtype_t* subtype_node = NULL;
|
|
if (out_subtype) {
|
|
*out_subtype = NULL;
|
|
}
|
|
|
|
if (!browse_matches_service_cache(browse, service)) {
|
|
return false;
|
|
}
|
|
|
|
if (mdns_utils_str_null_or_empty(browse->subtype)) {
|
|
return service->ptr_present;
|
|
}
|
|
|
|
subtype_node = mdns_priv_cache_service_find_subtype(service, browse->subtype);
|
|
if (out_subtype) {
|
|
*out_subtype = subtype_node;
|
|
}
|
|
return subtype_node != NULL;
|
|
}
|
|
|
|
/**
|
|
* @brief Build and sync a temporary result for a browse from cache.
|
|
*/
|
|
static bool browse_build_and_notify_temp_result(mdns_browse_t *browse, const mdns_cache_entry_t *entry,
|
|
const mdns_service_cache_t *service, const mdns_cache_subtype_t *subtype,
|
|
bool goodbye)
|
|
{
|
|
mdns_result_t *result = NULL;
|
|
esp_err_t ret = mdns_priv_service_cache_to_result(entry, service, &result);
|
|
if (ret != ESP_OK) {
|
|
return false;
|
|
}
|
|
|
|
if (!mdns_utils_str_null_or_empty(browse->subtype)) {
|
|
if (subtype) {
|
|
result->ttl = subtype->ttl;
|
|
}
|
|
result->subtype = mdns_mem_strdup(browse->subtype);
|
|
if (!result->subtype) {
|
|
HOOK_MALLOC_FAILED;
|
|
mdns_priv_query_results_free(result);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
result->next = NULL;
|
|
if (goodbye) {
|
|
result->ttl = 0;
|
|
}
|
|
|
|
DBG_BROWSE_RESULTS(result, browse);
|
|
if (browse->notifier) {
|
|
browse->notifier(result);
|
|
}
|
|
|
|
mdns_priv_query_results_free(result);
|
|
return true;
|
|
}
|
|
|
|
static bool browse_need_update(const mdns_browse_t *browse, const mdns_service_cache_t *service,
|
|
const mdns_cache_subtype_t *subtype, mdns_cache_record_mask_t records)
|
|
{
|
|
if (!browse || !service) {
|
|
return false;
|
|
}
|
|
|
|
// SRV, TXT, A, AAAA changed, notify all browses with identical service and proto.
|
|
if (records & MDNS_CACHE_RECORD_BROWSE_SHARED) {
|
|
return true;
|
|
}
|
|
|
|
// Normal PTR update with no subtype, only notify no-subtype browses.
|
|
if (mdns_utils_str_null_or_empty(browse->subtype)) {
|
|
return (records & MDNS_CACHE_RECORD_PTR) != 0;
|
|
}
|
|
|
|
// For subtype update, only notify if the subtype in cache is pending sync.
|
|
if (!(records & MDNS_CACHE_RECORD_SUBTYPE)) {
|
|
return false;
|
|
}
|
|
return subtype && subtype->pending_sync;
|
|
}
|
|
|
|
bool mdns_priv_browse_update_from_service_cache(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
|
|
mdns_cache_record_mask_t records)
|
|
{
|
|
if (!entry || !service) {
|
|
return false;
|
|
}
|
|
|
|
bool updated = true;
|
|
|
|
for (mdns_browse_t *browse = s_browse; browse; browse = browse->next) {
|
|
const mdns_cache_subtype_t *subtype = NULL;
|
|
if (!browse_matches_service_cache_with_subtype(browse, service, &subtype)) {
|
|
continue;
|
|
}
|
|
if (!browse_need_update(browse, service, subtype, records)) {
|
|
continue;
|
|
}
|
|
updated &= browse_build_and_notify_temp_result(browse, entry, service, subtype, false);
|
|
}
|
|
|
|
return updated;
|
|
}
|
|
|
|
bool mdns_priv_browse_notify_from_service_cache(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
|
|
mdns_browse_t *browse)
|
|
{
|
|
const mdns_cache_subtype_t *subtype = NULL;
|
|
|
|
if (!entry || !service || !browse) {
|
|
return false;
|
|
}
|
|
|
|
if (!browse_matches_service_cache_with_subtype(browse, service, &subtype)) {
|
|
return true;
|
|
}
|
|
|
|
return browse_build_and_notify_temp_result(browse, entry, service, subtype, false);
|
|
}
|
|
|
|
bool mdns_priv_browse_notify_ptr_goodbye_from_service_cache(const mdns_cache_entry_t *entry,
|
|
const mdns_service_cache_t *service,
|
|
const char *subtype)
|
|
{
|
|
if (!entry || !service) {
|
|
return false;
|
|
}
|
|
|
|
bool notified = true;
|
|
|
|
for (mdns_browse_t *browse = s_browse; browse; browse = browse->next) {
|
|
if (!browse_matches_service_cache(browse, service)) {
|
|
continue;
|
|
}
|
|
|
|
if (!mdns_utils_str_case_equal_nullable(browse->subtype, subtype)) {
|
|
continue;
|
|
}
|
|
|
|
notified &= browse_build_and_notify_temp_result(browse, entry, service, NULL, true);
|
|
}
|
|
|
|
return notified;
|
|
}
|
|
|
|
|
|
/**
|
|
* @defgroup MDNS_PUBLIC_API
|
|
*/
|
|
mdns_browse_t *mdns_browse_new(const char *service, const char *proto, mdns_browse_notify_t notifier)
|
|
{
|
|
return mdns_browse_new_with_subtype(service, proto, NULL, notifier);
|
|
}
|
|
|
|
mdns_browse_t *mdns_browse_new_with_subtype(const char *service, const char *proto, const char *subtype, mdns_browse_notify_t notifier)
|
|
{
|
|
mdns_browse_t *browse = NULL;
|
|
|
|
if (!mdns_priv_is_server_init() || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
|
|
return NULL;
|
|
}
|
|
|
|
// Subtype identifier length limit defined in RFC 6763 Section 7.2
|
|
if (subtype && strlen(subtype) > MDNS_SUBTYPE_MAX_LEN) {
|
|
ESP_LOGE(TAG, "Subtype string length must not exceed %d bytes", MDNS_SUBTYPE_MAX_LEN);
|
|
return NULL;
|
|
}
|
|
|
|
browse = browse_init(service, proto, subtype, notifier);
|
|
if (!browse) {
|
|
return NULL;
|
|
}
|
|
|
|
mdns_priv_service_lock();
|
|
// Check if the browse already exists before sending action
|
|
if (get_non_off_browse_item(service, proto, subtype)) {
|
|
bool has_subtype = !mdns_utils_str_null_or_empty(subtype);
|
|
ESP_LOGW(TAG, "Browse already exists: %s%s%s.%s", has_subtype ? subtype : "",
|
|
has_subtype ? "._sub." : "", browse->service, browse->proto);
|
|
goto error;
|
|
}
|
|
|
|
if (send_browse_action(ACTION_BROWSE_START, browse) != ESP_OK) {
|
|
ESP_LOGE(TAG, "Failed to send browse start action");
|
|
goto error;
|
|
}
|
|
|
|
browse->next = s_browse;
|
|
s_browse = browse;
|
|
mdns_priv_service_unlock();
|
|
return browse;
|
|
|
|
error:
|
|
browse_item_free(browse);
|
|
mdns_priv_service_unlock();
|
|
return NULL;
|
|
}
|
|
|
|
esp_err_t mdns_browse_delete(const char *service, const char *proto)
|
|
{
|
|
return mdns_browse_delete_with_subtype(service, proto, NULL);
|
|
}
|
|
|
|
esp_err_t mdns_browse_delete_with_subtype(const char *service, const char *proto, const char *subtype)
|
|
{
|
|
mdns_browse_t *browse = NULL;
|
|
|
|
if (!mdns_priv_is_server_init() || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
// Subtype identifier length limit defined in RFC 6763 Section 7.2
|
|
if (subtype && strlen(subtype) > MDNS_SUBTYPE_MAX_LEN) {
|
|
ESP_LOGE(TAG, "Subtype string length must not exceed 63 bytes");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
mdns_priv_service_lock();
|
|
browse = get_non_off_browse_item(service, proto, subtype);
|
|
if (!browse) {
|
|
mdns_priv_service_unlock();
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
mdns_browse_state_t prev_state = browse->state;
|
|
browse->state = BROWSE_OFF;
|
|
|
|
if (send_browse_action(ACTION_BROWSE_END, browse) != ESP_OK) {
|
|
browse->state = prev_state;
|
|
mdns_priv_service_unlock();
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
mdns_priv_service_unlock();
|
|
return ESP_OK;
|
|
}
|