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>
This commit is contained in:
jimmyandClaude Haiku 5.5 committed 2026-11-11 14:10:55 +13:00
1 parent 47f4eba0d6
commit 4cd3bc7973
294 files changed
+48954 -301

No files matched your search

@@ -0,0 +1,94 @@
cmake_minimum_required(VERSION 3.5)
if(ESP_PLATFORM)
# Used for reconfiguration of the project
# Executed by idf.py reconfigure
set(EXTRA_COMPONENT_DIRS ../../)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(mdns_host_unit_test_config)
return()
endif()
project(mdns_host_unit_test C)
# Set ENABLE_UNIT_TESTS with a default of OFF
if(NOT DEFINED UNIT_TESTS)
set(UNIT_TESTS "OFF" CACHE STRING "Unit tests: OFF, test_receiver, test_sender, test_cache, test_browse")
else()
set(ENABLE_UNIT_TESTS 1)
message(STATUS "Unit testing enabled with UNIT_TESTS=${UNIT_TESTS}")
endif()
# Set variables for directories
set(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(STUB_DIR ${TEST_DIR}/stubs)
set(MDNS_DIR ${TEST_DIR}/../../)
set(COMPONENT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../)
set(ESP_NETIF_LINUX_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../host_test/components/esp_netif_linux/include)
set(COMMON_COMPONENTS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../common_components/linux_compat/)
set(IDF_COMPONENTS_DIR "$ENV{IDF_PATH}/components")
include_directories(
${TEST_DIR}
${STUB_DIR}
${TEST_DIR}/build/config
${COMMON_COMPONENTS_DIR}/freertos/include
${COMMON_COMPONENTS_DIR}/esp_timer/include
${IDF_COMPONENTS_DIR}/esp_event/include
${IDF_COMPONENTS_DIR}/esp_netif/include
${IDF_COMPONENTS_DIR}/esp_common/include
${IDF_COMPONENTS_DIR}/esp_system/include
${IDF_COMPONENTS_DIR}/log/include
${IDF_COMPONENTS_DIR}/esp_hw_support/etm/include
${IDF_COMPONENTS_DIR}/soc/linux/include
${IDF_COMPONENTS_DIR}/esp_rom/include
${IDF_COMPONENTS_DIR}/heap/include
${IDF_COMPONENTS_DIR}/esp_rom/linux/include/linux/
${ESP_NETIF_LINUX_DIR}
${COMPONENT_DIR}
${COMPONENT_DIR}/include
${COMPONENT_DIR}/private_include
)
# Source files
set(SOURCES
${STUB_DIR}/mdns_mem_caps.c
${STUB_DIR}/esp_idf.c
${STUB_DIR}/mdns_networking.c
${STUB_DIR}/mdns_engine.c
${MDNS_DIR}/mdns_receive.c
${MDNS_DIR}/mdns_utils.c
${MDNS_DIR}/mdns_browser.c
${MDNS_DIR}/mdns_querier.c
${MDNS_DIR}/mdns_responder.c
${MDNS_DIR}/mdns_send.c
${MDNS_DIR}/mdns_pcb.c
${MDNS_DIR}/mdns_netif.c
${MDNS_DIR}/mdns_cache.c
)
if(ENABLE_UNIT_TESTS)
include(unity/unit_test.cmake)
else()
list(APPEND SOURCES main.c)
endif()
add_executable(${PROJECT_NAME} ${SOURCES})
# Add libbsd if available
find_library(LIB_BSD bsd)
if(LIB_BSD)
target_link_libraries(${PROJECT_NAME} PRIVATE ${LIB_BSD})
elseif(NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
message(WARNING "Missing LIBBSD library. Install libbsd-dev package and/or check linker directories.")
endif()
# Sanitizers for AFL fuzzing (unit tests enable these in unity/enable_testing.cmake)
if(NOT ENABLE_UNIT_TESTS)
target_compile_options(${PROJECT_NAME} PRIVATE -fsanitize=address -fsanitize=undefined)
target_link_options(${PROJECT_NAME} PRIVATE -fsanitize=address -fsanitize=undefined)
endif()
# Enable testing if unit tests are enabled
if(ENABLE_UNIT_TESTS)
include(unity/enable_testing.cmake)
endif()
@@ -0,0 +1,81 @@
# mDNS host unit tests and fuzzing
This directory builds the mDNS component as a Linux host binary with stubs for ESP-IDF networking. It supports two modes:
- **Unit tests** — Unity/CMock regression tests (ASan/UBSan enabled)
- **Fuzzing** — AFL++ harness that feeds random packets into the receive path
## Prerequisites
- ESP-IDF installed and `IDF_PATH` set (`. $IDF_PATH/export.sh`)
- `libbsd-dev`
- For unit tests: `ruby` (CMock code generation)
- For fuzzing: AFL++ (`afl-cc`, `afl-fuzz`) and `dnslib` (`pip install dnslib`)
From the repository root:
```bash
cd components/mdns/tests/host_unit_test
```
Run `idf.py reconfigure` once before building. This generates `build/config/` headers used by the host build.
## Unit tests
Available test suites (pass one to `-DUNIT_TESTS=`):
| Suite | Description |
|-------|-------------|
| `test_receiver` | Packet receive / parse path |
| `test_sender` | Packet send path |
| `test_browse` | Browse lifecycle, cache replay, service filtering, goodbye/rediscovery |
| `test_cache` | Cached record insert/update/remove, sync batching, and result projection |
Example — build and run the receiver tests:
```bash
. $IDF_PATH/export.sh
idf.py reconfigure
mkdir -p build2 && cd build2
cmake -DUNIT_TESTS=test_receiver ..
cmake --build .
ctest --extra-verbose
```
Or run the binary directly:
```bash
./mdns_host_unit_test --test
```
Repeat with `-DUNIT_TESTS=test_sender` or `-DUNIT_TESTS=test_browse` in a separate build directory.
## Fuzzer tests
Build the AFL-instrumented harness (no `-DUNIT_TESTS`; uses `main.c`):
```bash
export IDF_PATH=/path/to/esp-idf # required in the fuzz container
cd input && python generate_cases.py && cd ..
cmake -B build2 -S . -G Ninja -DCMAKE_C_COMPILER=afl-cc
cmake --build build2
afl-fuzz -i input -o out -- build2/mdns_host_unit_test
```
The harness reads packets from stdin and exercises IPv4/IPv6 and port 5353/53 combinations. Crashes are written to `out/default/crashes/`.
### Reproducing a crash
Build the non-unit-test binary with a normal compiler, then pass a crash file:
```bash
cmake -B build2 -S .
cmake --build build2
./build2/mdns_host_unit_test out/default/crashes/id_000000,...
```
With sanitizers enabled, ASan/UBSan report buffer overruns and undefined behaviour directly during unit tests and fuzzing.
@@ -0,0 +1,166 @@
# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Unlicense OR CC0-1.0
from dnslib import (AAAA, PTR, RR, SRV, TXT, A, DNSHeader, DNSQuestion,
DNSRecord)
def create_mdns_packet(queries, answers, additional, output_file='mdns_packet.bin'):
dns_header = DNSHeader(id=0, qr=1, aa=1, ra=0)
dns_record = DNSRecord(dns_header)
for qname, qtype in queries:
dns_record.add_question(DNSQuestion(qname, qtype))
for name, qtype, value, ttl in answers:
if qtype == 'A':
rr = RR(name, rdata=A(value), ttl=ttl)
elif qtype == 'PTR':
rr = RR(name, rdata=PTR(value), ttl=ttl)
elif qtype == 'TXT':
rr = RR(name, rdata=TXT(value), ttl=ttl)
elif qtype == 'AAAA':
rr = RR(name, rdata=AAAA(value), ttl=ttl)
elif qtype == 'SRV':
# SRV value should be in format: "priority weight port target"
parts = value.split()
priority, weight, port = map(int, parts[:3])
target = parts[3]
rr = RR(name, rdata=SRV(priority, weight, port, target), ttl=ttl)
else:
print(f'Unsupported type: {qtype}')
continue
dns_record.add_answer(rr)
for name, qtype, value, ttl in additional:
if qtype == 'A':
rr = RR(name, rdata=A(value), ttl=ttl)
elif qtype == 'TXT':
rr = RR(name, rdata=TXT(value), ttl=ttl)
elif qtype == 'AAAA':
rr = RR(name, rdata=AAAA(value), ttl=ttl)
elif qtype == 'SRV':
parts = value.split()
priority, weight, port = map(int, parts[:3])
target = parts[3]
rr = RR(name, rdata=SRV(priority, weight, port, target), ttl=ttl)
else:
print(f'Unsupported type: {qtype}')
continue
dns_record.add_ar(rr)
mdns_payload = dns_record.pack()
with open(output_file, 'wb') as f:
f.write(mdns_payload)
print(f'mDNS packet saved as {output_file}')
# Test case 1: Basic hostname queries
queries = [
('test4.local.', 1), # A record for main hostname
('test.local.', 1), # A record for main hostname
]
answers = [
]
additional = [
]
create_mdns_packet(queries, answers, additional, 'test_hostname_queries.bin')
print('Test case 1: Hostname queries')
# Test case 2: HTTP service discovery with subtypes
queries = [
('_http._tcp.local.', 12), # PTR query
('subtype._sub._http._tcp.local.', 12), # Subtype query
]
answers = [
('_http._tcp.local.', 'PTR', 'inst1._http._tcp.local.', 120),
('_http._tcp.local.', 'PTR', 'inst2._http._tcp.local.', 120),
('subtype._sub._http._tcp.local.', 'PTR', 'inst1._http._tcp.local.', 120),
]
additional = [
('inst1._http._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('inst1._http._tcp.local.', 'TXT', 'board=esp32\0tcp_check=no\0ssh_upload=no\0auth_upload=no', 120),
('inst2._http._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('inst2._http._tcp.local.', 'TXT', 'board=esp32\0tcp_check=no\0ssh_upload=no\0auth_upload=no', 120),
]
create_mdns_packet(queries, answers, additional, 'test_http_services.bin')
print('Test case 2: HTTP service discovery with subtypes')
# Test case 3: Scanner service discovery
queries = [
('_scanner._tcp.local.', 12), # PTR query
]
answers = [
('_scanner._tcp.local.', 'PTR', 'inst4._scanner._tcp.local.', 120),
('_scanner._tcp.local.', 'PTR', 'inst5._scanner._tcp.local.', 120),
]
additional = [
('inst4._scanner._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('inst5._scanner._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
]
create_mdns_packet(queries, answers, additional, 'test_scanner_services.bin')
print('Test case 3: Scanner service discovery')
# Test case 4: UDP service (sleep protocol)
queries = [
('_sleep._udp.local.', 12), # PTR query
]
answers = [
('_sleep._udp.local.', 'PTR', 'inst7._sleep._udp.local.', 120),
]
additional = [
('inst7._sleep._udp.local.', 'SRV', '0 0 80 test.local.', 120),
]
create_mdns_packet(queries, answers, additional, 'test_udp_service.bin')
print('Test case 4: UDP service discovery')
# Test case 5: Async queries from main.c
queries = [
('host_name.local.', 1), # A query
('host_name2.local.', 28), # AAAA query
('minifritz._http._tcp.local.', 12), # PTR query
]
answers = [
('host_name.local.', 'A', '192.168.1.10', 120),
('host_name2.local.', 'AAAA', 'fe80::1234', 120),
('minifritz._http._tcp.local.', 'PTR', 'minifritz._http._tcp.local.', 120),
]
additional = [
('minifritz._http._tcp.local.', 'SRV', '0 0 80 minifritz.local.', 120),
('minifritz.local.', 'A', '192.168.1.20', 120),
]
create_mdns_packet(queries, answers, additional, 'test_async_queries.bin')
print('Test case 5: Async queries')
# Test case 6: Multiple services on same instance
queries = [
('_http._tcp.local.', 12),
('_scanner._tcp.local.', 12),
]
answers = [
('_http._tcp.local.', 'PTR', 'inst1._http._tcp.local.', 120),
('_http._tcp.local.', 'PTR', 'inst2._http._tcp.local.', 120),
('_http._tcp.local.', 'PTR', 'inst3._http._tcp.local.', 120),
('_scanner._tcp.local.', 'PTR', 'inst4._scanner._tcp.local.', 120),
]
additional = [
('inst1._http._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('inst2._http._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('test.local.', 'A', '192.168.1.100', 120),
]
create_mdns_packet(queries, answers, additional, 'test_multiple_services.bin')
print('Test case 6: Multiple services')
# Test case 7: Subtype queries for different hosts
queries = [
('subtype._sub._http._tcp.local.', 12),
('subtype3._sub._http._tcp.local.', 12),
]
answers = [
('subtype._sub._http._tcp.local.', 'PTR', 'inst1._http._tcp.local.', 120),
('subtype3._sub._http._tcp.local.', 'PTR', 'inst2._http._tcp.local.', 120),
]
additional = [
('inst1._http._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('inst2._http._tcp.local.', 'SRV', '0 0 80 test.local.', 120),
('test.local.', 'A', '192.168.1.100', 120),
]
create_mdns_packet(queries, answers, additional, 'test_subtype_queries.bin')
print('Test case 7: Subtype queries')
@@ -0,0 +1,129 @@
/*
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include "esp_err.h"
#include "mdns.h"
#include "mdns_receive.h"
#include "mdns_responder.h"
#include "mdns_querier.h"
#include "mdns_browser.h"
#include "mdns_mem_caps.h"
esp_err_t mdns_packet_push(esp_ip_addr_t *addr, int port, mdns_if_t tcpip_if, uint8_t*data, size_t len);
mdns_search_once_t *s_a, *s_aaaa, *s_ptr, *s_srv, *s_txt;
static void browse_notifier(mdns_result_t *result)
{
(void)result;
}
void init_responder(void)
{
mdns_ip_addr_t addr = { .addr = { .u_addr = ESP_IPADDR_TYPE_V4 } };
addr.addr.u_addr.ip4.addr = 0x11111111;
mdns_txt_item_t txt[4] = {
{"board", "esp32"},
{"tcp_check", "no"},
{"ssh_upload", "no"},
{"auth_upload", "no"}
};
mdns_priv_responder_init();
mdns_hostname_set("test");
mdns_instance_name_set("test2");
mdns_delegate_hostname_add("test3", NULL);
mdns_delegate_hostname_add("test4", &addr);
mdns_service_add("inst1", "_http", "_tcp", 80, txt, 4);
mdns_service_subtype_add_for_host("inst1", "_http", "_tcp", "test", "subtype");
mdns_service_add("inst2", "_http", "_tcp", 80, txt, 1);
mdns_service_subtype_add_for_host("inst2", "_http", "_tcp", "test", "subtype3");
mdns_service_add("inst3", "_http", "_tcp", 80, NULL, 0);
mdns_service_add_for_host("deleg1", "_http", "_tcp", "test3", 80, txt, 2);
mdns_service_add_for_host(NULL, "_http", "_tcp", "test4", 80, txt, 2);
mdns_service_add(NULL, "_scanner", "_tcp", 80, NULL, 0);
mdns_service_add("inst5", "_scanner", "_tcp", 80, NULL, 0);
mdns_service_add("inst6", "_http", "_tcp", 80, NULL, 0);
mdns_service_add("inst7", "_sleep", "_udp", 80, NULL, 0);
s_a = mdns_query_async_new("host_name", NULL, NULL, MDNS_TYPE_A, 1000, 1, NULL);
s_aaaa = mdns_query_async_new("host_name2", NULL, NULL, MDNS_TYPE_AAAA, 1000, 1, NULL);
s_ptr = mdns_query_async_new("minifritz", "_http", "_tcp", MDNS_TYPE_PTR, 1000, 1, NULL);
s_srv = mdns_query_async_new("fritz", "_http", "_tcp", MDNS_TYPE_SRV, 1000, 1, NULL);
s_txt = mdns_query_async_new("fritz", "_http", "_tcp", MDNS_TYPE_TXT, 1000, 1, NULL);
mdns_browse_new("_http", "_tcp", browse_notifier);
mdns_browse_new("_scanner", "_tcp", browse_notifier);
mdns_browse_new("_sleep", "_udp", browse_notifier);
}
void deinit_responder(void)
{
mdns_priv_search_once_free(s_a);
mdns_priv_search_once_free(s_aaaa);
mdns_priv_search_once_free(s_ptr);
mdns_priv_search_once_free(s_srv);
mdns_priv_search_once_free(s_txt);
mdns_priv_query_free();
mdns_priv_browse_free();
mdns_service_remove_all();
mdns_priv_responder_free();
s_a = NULL;
s_aaaa = NULL;
s_ptr = NULL;
s_srv = NULL;
s_txt = NULL;
}
static void send_packet(bool ip4, bool mdns_port, uint8_t*data, size_t len)
{
esp_ip_addr_t addr4 = ESP_IP4ADDR_INIT(192, 168, 1, 1);
esp_ip_addr_t addr6 = ESP_IP6ADDR_INIT(0x000002ff, 0, 0, 0xfe800000);
esp_ip_addr_t *addr = ip4 ? &addr4 : &addr6;
int port = mdns_port ? 53 : 5353;
if (mdns_packet_push(addr, port, 0, data, len) != ESP_OK) {
printf("Failed to push packet\n");
}
}
int main(int argc, char **argv)
{
init_responder();
// Original fuzzing code
uint8_t buf[1460];
FILE *file;
size_t len = 1460;
memset(buf, 0, len);
#ifndef __AFL_LOOP
//
// Note: parameter1 is a file (mangled packet) which caused the crash
if (argc != 2) {
printf("Non-instrumentation mode: please supply a file name created by AFL to reproduce crash\n");
return 1;
}
file = fopen(argv[1], "r");
assert(file >= 0);
len = fread(buf, 1, 1460, file);
fclose(file);
{
#else
while (__AFL_LOOP(1000)) {
memset(buf, 0, 1460);
size_t len = read(0, buf, 1460);
#endif
send_packet(true, true, buf, len);
send_packet(true, false, buf, len);
send_packet(false, true, buf, len);
send_packet(false, false, buf, len);
}
deinit_responder();
return 0;
}
@@ -0,0 +1,6 @@
# This file was generated using idf.py save-defconfig. It can be edited manually.
# Espressif IoT Development Framework (ESP-IDF) 5.5.0 Project Minimal Configuration
#
CONFIG_MDNS_PREDEF_NETIF_STA=n
CONFIG_MDNS_PREDEF_NETIF_AP=n
CONFIG_MDNS_PREDEF_NETIF_ETH=n
@@ -0,0 +1,10 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#if __has_include("esp_assert.h")
#include_next "esp_assert.h"
#else
#define ESP_STATIC_ASSERT _Static_assert
#endif
@@ -0,0 +1,105 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include "esp_log.h"
#include "esp_netif.h"
#include "freertos/FreeRTOS.h"
#include "mdns_test_clock.h"
static int64_t s_clock_us = 0;
void mdns_test_clock_reset(void)
{
s_clock_us = 0;
}
bool mdns_test_clock_advance_us(int64_t delta_us)
{
if (delta_us < 0 || delta_us > INT64_MAX - s_clock_us) {
return false;
}
s_clock_us += delta_us;
return true;
}
void esp_log(esp_log_config_t config, const char* tag, const char* format, ...)
{}
uint32_t esp_log_timestamp(void)
{
return 0;
}
uint32_t esp_get_free_heap_size(void)
{
return 0;
}
esp_netif_t *esp_netif_get_handle_from_ifkey(const char *if_key)
{
return (esp_netif_t*)1;
}
esp_err_t esp_netif_get_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_info)
{
ip_info->ip.addr = 0xC0A80164; // 192.168.1.100
ip_info->netmask.addr = 0xFFFFFF00; // 255.255.255.0
ip_info->gw.addr = 0xC0A80101; // 192.168.1.1
return ESP_OK;
}
esp_err_t esp_netif_get_ip6_linklocal(esp_netif_t *esp_netif, esp_ip6_addr_t *if_ip6)
{
if_ip6->addr[0] = 0xFE80;
if_ip6->addr[1] = 0x0000;
if_ip6->addr[2] = 0x0000;
if_ip6->addr[3] = 0x0001;
return ESP_OK;
}
uint32_t esp_random(void)
{
return 0;
}
TickType_t xTaskGetTickCount(void)
{
return (TickType_t)(s_clock_us / 1000 / portTICK_PERIOD_MS);
}
int esp_netif_get_all_ip6(esp_netif_t *esp_netif, esp_ip6_addr_t if_ip6[])
{
if_ip6[0].addr[0] = 0xFE80;
if_ip6[0].addr[1] = 0x0000;
if_ip6[0].addr[2] = 0x0000;
if_ip6[0].addr[3] = 0x0001;
return 1;
}
BaseType_t xSemaphoreGive(QueueHandle_t xQueue)
{
return pdPASS;
}
BaseType_t xSemaphoreTake(QueueHandle_t xQueue, TickType_t xTicksToWait)
{
return pdPASS;
}
QueueHandle_t xSemaphoreCreateBinary(void)
{
return (QueueHandle_t)1;
}
void vQueueDelete(QueueHandle_t xQueue)
{
}
int64_t esp_timer_get_time(void)
{
return s_clock_us;
}
@@ -0,0 +1,61 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include "mdns.h"
#include "mdns_private.h"
#include "mdns_querier.h"
#include "mdns_browser.h"
#include "mdns_send.h"
#include "mdns_responder.h"
#include "mdns_receive.h"
#include "mdns_mem_caps.h"
static void execute_action(mdns_action_t *action)
{
switch (action->type) {
case ACTION_SYSTEM_EVENT:
break;
case ACTION_SEARCH_ADD:
case ACTION_SEARCH_SEND:
case ACTION_SEARCH_END:
mdns_priv_query_action(action, ACTION_RUN);
break;
case ACTION_BROWSE_START:
case ACTION_BROWSE_END:
mdns_priv_browse_action(action, ACTION_RUN);
break;
case ACTION_TX_HANDLE:
mdns_priv_send_action(action, ACTION_RUN);
break;
case ACTION_RX_HANDLE:
mdns_priv_receive_action(action, ACTION_RUN);
break;
case ACTION_HOSTNAME_SET:
case ACTION_INSTANCE_SET:
case ACTION_DELEGATE_HOSTNAME_ADD:
case ACTION_DELEGATE_HOSTNAME_SET_ADDR:
case ACTION_DELEGATE_HOSTNAME_REMOVE:
mdns_priv_responder_action(action, ACTION_RUN);
break;
default:
break;
}
mdns_mem_free(action);
}
bool mdns_priv_queue_action(mdns_action_t *action)
{
execute_action(action);
return true;
}
void mdns_priv_service_lock(void)
{
}
void mdns_priv_service_unlock(void)
{
}
@@ -0,0 +1,89 @@
/*
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <string.h>
#include "mdns_mem_caps.h"
#include "mdns_mem_caps_test.h"
static size_t s_allocation_counts;
size_t mdns_mem_get_allocation_counts(void)
{
return s_allocation_counts;
}
void *mdns_mem_malloc(size_t size)
{
void *ptr = malloc(size);
if (ptr) {
s_allocation_counts++;
}
return ptr;
}
void *mdns_mem_calloc(size_t num, size_t size)
{
void *ptr = calloc(num, size);
if (ptr) {
s_allocation_counts++;
}
return ptr;
}
void mdns_mem_free(void *ptr)
{
if (ptr) {
if (s_allocation_counts > 0) {
s_allocation_counts--;
}
free(ptr);
}
}
char *mdns_mem_strdup(const char *s)
{
if (s == NULL) {
return NULL;
}
size_t len = strlen(s) + 1;
char *new_str = mdns_mem_malloc(len);
if (new_str == NULL) {
return NULL;
}
return memcpy(new_str, s, len);
}
char *mdns_mem_strndup(const char *s, size_t n)
{
if (s == NULL) {
return NULL;
}
size_t len = strnlen(s, n);
char *new_str = mdns_mem_malloc(len + 1);
if (new_str == NULL) {
return NULL;
}
memcpy(new_str, s, len);
new_str[len] = '\0';
return new_str;
}
void *mdns_mem_task_malloc(size_t size)
{
return mdns_mem_malloc(size);
}
void mdns_mem_task_free(void *ptr)
{
mdns_mem_free(ptr);
}
@@ -0,0 +1,10 @@
/*
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#pragma once
#include <stddef.h>
size_t mdns_mem_get_allocation_counts(void);
@@ -0,0 +1,90 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "mdns_networking.h"
#include "mdns_mem_caps.h"
#include "mdns_service.h"
struct pbuf {
void *payload;
size_t len;
};
bool mdns_priv_if_ready(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
return true; // Default to ready for testing
}
esp_err_t mdns_priv_if_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
return ESP_OK;
}
esp_err_t mdns_priv_if_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{
return ESP_OK;
}
size_t mdns_priv_if_write(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, const esp_ip_addr_t *ip, uint16_t port, uint8_t *data, size_t len)
{
return len; // Return the input length as if all data was sent successfully
}
void *mdns_priv_get_packet_data(mdns_rx_packet_t *packet)
{
return packet->pb->payload;
}
size_t mdns_priv_get_packet_len(mdns_rx_packet_t *packet)
{
return packet->pb->len;
}
void mdns_priv_packet_free(mdns_rx_packet_t *packet)
{
mdns_mem_free(packet->pb->payload);
mdns_mem_free(packet->pb);
mdns_mem_free(packet);
}
esp_err_t mdns_packet_push(esp_ip_addr_t *addr, int port, mdns_if_t tcpip_if, uint8_t*data, size_t len)
{
// Allocate the packet structure and pass it to the mdns main engine
mdns_rx_packet_t *packet = (mdns_rx_packet_t *) mdns_mem_calloc(1, sizeof(mdns_rx_packet_t));
struct pbuf *packet_pbuf = mdns_mem_calloc(1, sizeof(struct pbuf));
uint8_t *buf = mdns_mem_malloc(len);
if (packet == NULL || packet_pbuf == NULL || buf == NULL) {
mdns_mem_free(buf);
mdns_mem_free(packet_pbuf);
mdns_mem_free(packet);
return ESP_ERR_NO_MEM;
}
memcpy(buf, data, len);
packet_pbuf->payload = buf;
packet_pbuf->len = len;
packet->tcpip_if = tcpip_if;
packet->pb = packet_pbuf;
packet->src_port = port;
memcpy(&packet->src, addr, sizeof(esp_ip_addr_t));
memset(&packet->dest, 0, sizeof(esp_ip_addr_t));
packet->multicast = 1;
packet->dest.type = packet->src.type;
packet->ip_protocol = packet->src.type == ESP_IPADDR_TYPE_V4 ? MDNS_IP_PROTOCOL_V4 : MDNS_IP_PROTOCOL_V6;
mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t));
if (!action) {
return ESP_ERR_NO_MEM;
}
action->type = ACTION_RX_HANDLE;
action->data.rx_handle.packet = packet;
if (!mdns_priv_queue_action(action)) {
mdns_mem_free(action);
mdns_mem_free(packet->pb->payload);
mdns_mem_free(packet->pb);
mdns_mem_free(packet);
return ESP_ERR_NO_MEM;
}
return ESP_OK;
}
@@ -0,0 +1,21 @@
/*
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#pragma once
#include <stdbool.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
void mdns_test_clock_reset(void);
bool mdns_test_clock_advance_us(int64_t delta_us);
#ifdef __cplusplus
}
#endif
@@ -0,0 +1,886 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
/*
* Automatically generated file. DO NOT EDIT.
* Espressif IoT Development Framework (ESP-IDF) 5.5.0 Configuration Header
*/
#pragma once
#define CONFIG_SOC_BROWNOUT_RESET_SUPPORTED "Not determined"
#define CONFIG_SOC_TWAI_BRP_DIV_SUPPORTED "Not determined"
#define CONFIG_SOC_DPORT_WORKAROUND "Not determined"
#define CONFIG_SOC_CAPS_ECO_VER_MAX 301
#define CONFIG_SOC_ADC_SUPPORTED 1
#define CONFIG_SOC_DAC_SUPPORTED 1
#define CONFIG_SOC_UART_SUPPORTED 1
#define CONFIG_SOC_MCPWM_SUPPORTED 1
#define CONFIG_SOC_GPTIMER_SUPPORTED 1
#define CONFIG_SOC_SDMMC_HOST_SUPPORTED 1
#define CONFIG_SOC_BT_SUPPORTED 1
#define CONFIG_SOC_PCNT_SUPPORTED 1
#define CONFIG_SOC_PHY_SUPPORTED 1
#define CONFIG_SOC_WIFI_SUPPORTED 1
#define CONFIG_SOC_SDIO_SLAVE_SUPPORTED 1
#define CONFIG_SOC_TWAI_SUPPORTED 1
#define CONFIG_SOC_EFUSE_SUPPORTED 1
#define CONFIG_SOC_EMAC_SUPPORTED 1
#define CONFIG_SOC_ULP_SUPPORTED 1
#define CONFIG_SOC_CCOMP_TIMER_SUPPORTED 1
#define CONFIG_SOC_RTC_FAST_MEM_SUPPORTED 1
#define CONFIG_SOC_RTC_SLOW_MEM_SUPPORTED 1
#define CONFIG_SOC_RTC_MEM_SUPPORTED 1
#define CONFIG_SOC_I2S_SUPPORTED 1
#define CONFIG_SOC_RMT_SUPPORTED 1
#define CONFIG_SOC_SDM_SUPPORTED 1
#define CONFIG_SOC_GPSPI_SUPPORTED 1
#define CONFIG_SOC_LEDC_SUPPORTED 1
#define CONFIG_SOC_I2C_SUPPORTED 1
#define CONFIG_SOC_SUPPORT_COEXISTENCE 1
#define CONFIG_SOC_AES_SUPPORTED 1
#define CONFIG_SOC_MPI_SUPPORTED 1
#define CONFIG_SOC_SHA_SUPPORTED 1
#define CONFIG_SOC_FLASH_ENC_SUPPORTED 1
#define CONFIG_SOC_SECURE_BOOT_SUPPORTED 1
#define CONFIG_SOC_TOUCH_SENSOR_SUPPORTED 1
#define CONFIG_SOC_BOD_SUPPORTED 1
#define CONFIG_SOC_ULP_FSM_SUPPORTED 1
#define CONFIG_SOC_CLK_TREE_SUPPORTED 1
#define CONFIG_SOC_MPU_SUPPORTED 1
#define CONFIG_SOC_WDT_SUPPORTED 1
#define CONFIG_SOC_SPI_FLASH_SUPPORTED 1
#define CONFIG_SOC_RNG_SUPPORTED 1
#define CONFIG_SOC_LIGHT_SLEEP_SUPPORTED 1
#define CONFIG_SOC_DEEP_SLEEP_SUPPORTED 1
#define CONFIG_SOC_LP_PERIPH_SHARE_INTERRUPT 1
#define CONFIG_SOC_PM_SUPPORTED 1
#define CONFIG_SOC_DPORT_WORKAROUND_DIS_INTERRUPT_LVL 5
#define CONFIG_SOC_XTAL_SUPPORT_26M 1
#define CONFIG_SOC_XTAL_SUPPORT_40M 1
#define CONFIG_SOC_XTAL_SUPPORT_AUTO_DETECT 1
#define CONFIG_SOC_ADC_RTC_CTRL_SUPPORTED 1
#define CONFIG_SOC_ADC_DIG_CTRL_SUPPORTED 1
#define CONFIG_SOC_ADC_DMA_SUPPORTED 1
#define CONFIG_SOC_ADC_PERIPH_NUM 2
#define CONFIG_SOC_ADC_MAX_CHANNEL_NUM 10
#define CONFIG_SOC_ADC_ATTEN_NUM 4
#define CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM 2
#define CONFIG_SOC_ADC_PATT_LEN_MAX 16
#define CONFIG_SOC_ADC_DIGI_MIN_BITWIDTH 9
#define CONFIG_SOC_ADC_DIGI_MAX_BITWIDTH 12
#define CONFIG_SOC_ADC_DIGI_RESULT_BYTES 2
#define CONFIG_SOC_ADC_DIGI_DATA_BYTES_PER_CONV 4
#define CONFIG_SOC_ADC_DIGI_MONITOR_NUM 0
#define CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH 2
#define CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW 20
#define CONFIG_SOC_ADC_RTC_MIN_BITWIDTH 9
#define CONFIG_SOC_ADC_RTC_MAX_BITWIDTH 12
#define CONFIG_SOC_ADC_SHARED_POWER 1
#define CONFIG_SOC_SHARED_IDCACHE_SUPPORTED 1
#define CONFIG_SOC_IDCACHE_PER_CORE 1
#define CONFIG_SOC_CPU_CORES_NUM 2
#define CONFIG_SOC_CPU_INTR_NUM 32
#define CONFIG_SOC_CPU_HAS_FPU 1
#define CONFIG_SOC_HP_CPU_HAS_MULTIPLE_CORES 1
#define CONFIG_SOC_CPU_BREAKPOINTS_NUM 2
#define CONFIG_SOC_CPU_WATCHPOINTS_NUM 2
#define CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE 64
#define CONFIG_SOC_DAC_CHAN_NUM 2
#define CONFIG_SOC_DAC_RESOLUTION 8
#define CONFIG_SOC_DAC_DMA_16BIT_ALIGN 1
#define CONFIG_SOC_GPIO_PORT 1
#define CONFIG_SOC_GPIO_PIN_COUNT 40
#define CONFIG_SOC_GPIO_VALID_GPIO_MASK 0xFFFFFFFFFF
#define CONFIG_SOC_GPIO_IN_RANGE_MAX 39
#define CONFIG_SOC_GPIO_OUT_RANGE_MAX 33
#define CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK 0xEF0FEA
#define CONFIG_SOC_GPIO_CLOCKOUT_BY_IO_MUX 1
#define CONFIG_SOC_GPIO_CLOCKOUT_CHANNEL_NUM 3
#define CONFIG_SOC_GPIO_SUPPORT_HOLD_IO_IN_DSLP 1
#define CONFIG_SOC_I2C_NUM 2
#define CONFIG_SOC_HP_I2C_NUM 2
#define CONFIG_SOC_I2C_FIFO_LEN 32
#define CONFIG_SOC_I2C_CMD_REG_NUM 16
#define CONFIG_SOC_I2C_SUPPORT_SLAVE 1
#define CONFIG_SOC_I2C_SUPPORT_APB 1
#define CONFIG_SOC_I2C_SUPPORT_10BIT_ADDR 1
#define CONFIG_SOC_I2C_STOP_INDEPENDENT 1
#define CONFIG_SOC_I2S_NUM 2
#define CONFIG_SOC_I2S_HW_VERSION_1 1
#define CONFIG_SOC_I2S_SUPPORTS_APLL 1
#define CONFIG_SOC_I2S_SUPPORTS_PLL_F160M 1
#define CONFIG_SOC_I2S_SUPPORTS_PDM 1
#define CONFIG_SOC_I2S_SUPPORTS_PDM_TX 1
#define CONFIG_SOC_I2S_SUPPORTS_PCM2PDM 1
#define CONFIG_SOC_I2S_SUPPORTS_PDM_RX 1
#define CONFIG_SOC_I2S_SUPPORTS_PDM2PCM 1
#define CONFIG_SOC_I2S_PDM_MAX_TX_LINES 1
#define CONFIG_SOC_I2S_PDM_MAX_RX_LINES 1
#define CONFIG_SOC_I2S_SUPPORTS_ADC_DAC 1
#define CONFIG_SOC_I2S_SUPPORTS_ADC 1
#define CONFIG_SOC_I2S_SUPPORTS_DAC 1
#define CONFIG_SOC_I2S_SUPPORTS_LCD_CAMERA 1
#define CONFIG_SOC_I2S_MAX_DATA_WIDTH 24
#define CONFIG_SOC_I2S_TRANS_SIZE_ALIGN_WORD 1
#define CONFIG_SOC_I2S_LCD_I80_VARIANT 1
#define CONFIG_SOC_LCD_I80_SUPPORTED 1
#define CONFIG_SOC_LCD_I80_BUSES 2
#define CONFIG_SOC_LCD_I80_BUS_WIDTH 24
#define CONFIG_SOC_LEDC_HAS_TIMER_SPECIFIC_MUX 1
#define CONFIG_SOC_LEDC_SUPPORT_APB_CLOCK 1
#define CONFIG_SOC_LEDC_SUPPORT_REF_TICK 1
#define CONFIG_SOC_LEDC_SUPPORT_HS_MODE 1
#define CONFIG_SOC_LEDC_TIMER_NUM 4
#define CONFIG_SOC_LEDC_CHANNEL_NUM 8
#define CONFIG_SOC_LEDC_TIMER_BIT_WIDTH 20
#define CONFIG_SOC_MCPWM_GROUPS 2
#define CONFIG_SOC_MCPWM_TIMERS_PER_GROUP 3
#define CONFIG_SOC_MCPWM_OPERATORS_PER_GROUP 3
#define CONFIG_SOC_MCPWM_COMPARATORS_PER_OPERATOR 2
#define CONFIG_SOC_MCPWM_GENERATORS_PER_OPERATOR 2
#define CONFIG_SOC_MCPWM_TRIGGERS_PER_OPERATOR 2
#define CONFIG_SOC_MCPWM_GPIO_FAULTS_PER_GROUP 3
#define CONFIG_SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP 1
#define CONFIG_SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER 3
#define CONFIG_SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP 3
#define CONFIG_SOC_MMU_PERIPH_NUM 2
#define CONFIG_SOC_MMU_LINEAR_ADDRESS_REGION_NUM 3
#define CONFIG_SOC_MPU_MIN_REGION_SIZE 0x20000000
#define CONFIG_SOC_MPU_REGIONS_MAX_NUM 8
#define CONFIG_SOC_PCNT_GROUPS 1
#define CONFIG_SOC_PCNT_UNITS_PER_GROUP 8
#define CONFIG_SOC_PCNT_CHANNELS_PER_UNIT 2
#define CONFIG_SOC_PCNT_THRES_POINT_PER_UNIT 2
#define CONFIG_SOC_RMT_GROUPS 1
#define CONFIG_SOC_RMT_TX_CANDIDATES_PER_GROUP 8
#define CONFIG_SOC_RMT_RX_CANDIDATES_PER_GROUP 8
#define CONFIG_SOC_RMT_CHANNELS_PER_GROUP 8
#define CONFIG_SOC_RMT_MEM_WORDS_PER_CHANNEL 64
#define CONFIG_SOC_RMT_SUPPORT_REF_TICK 1
#define CONFIG_SOC_RMT_SUPPORT_APB 1
#define CONFIG_SOC_RMT_CHANNEL_CLK_INDEPENDENT 1
#define CONFIG_SOC_RTCIO_PIN_COUNT 18
#define CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED 1
#define CONFIG_SOC_RTCIO_HOLD_SUPPORTED 1
#define CONFIG_SOC_RTCIO_WAKE_SUPPORTED 1
#define CONFIG_SOC_SDM_GROUPS 1
#define CONFIG_SOC_SDM_CHANNELS_PER_GROUP 8
#define CONFIG_SOC_SDM_CLK_SUPPORT_APB 1
#define CONFIG_SOC_SPI_HD_BOTH_INOUT_SUPPORTED 1
#define CONFIG_SOC_SPI_AS_CS_SUPPORTED 1
#define CONFIG_SOC_SPI_PERIPH_NUM 3
#define CONFIG_SOC_SPI_DMA_CHAN_NUM 2
#define CONFIG_SOC_SPI_MAX_CS_NUM 3
#define CONFIG_SOC_SPI_SUPPORT_CLK_APB 1
#define CONFIG_SOC_SPI_MAXIMUM_BUFFER_SIZE 64
#define CONFIG_SOC_SPI_MAX_PRE_DIVIDER 8192
#define CONFIG_SOC_MEMSPI_SRC_FREQ_80M_SUPPORTED 1
#define CONFIG_SOC_MEMSPI_SRC_FREQ_40M_SUPPORTED 1
#define CONFIG_SOC_MEMSPI_SRC_FREQ_26M_SUPPORTED 1
#define CONFIG_SOC_MEMSPI_SRC_FREQ_20M_SUPPORTED 1
#define CONFIG_SOC_TIMER_GROUPS 2
#define CONFIG_SOC_TIMER_GROUP_TIMERS_PER_GROUP 2
#define CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH 64
#define CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS 4
#define CONFIG_SOC_TIMER_GROUP_SUPPORT_APB 1
#define CONFIG_SOC_LP_TIMER_BIT_WIDTH_LO 32
#define CONFIG_SOC_LP_TIMER_BIT_WIDTH_HI 16
#define CONFIG_SOC_TOUCH_SENSOR_VERSION 1
#define CONFIG_SOC_TOUCH_SENSOR_NUM 10
#define CONFIG_SOC_TOUCH_SUPPORT_SLEEP_WAKEUP 1
#define CONFIG_SOC_TOUCH_SAMPLE_CFG_NUM 1
#define CONFIG_SOC_TWAI_CONTROLLER_NUM 1
#define CONFIG_SOC_TWAI_BRP_MIN 2
#define CONFIG_SOC_TWAI_CLK_SUPPORT_APB 1
#define CONFIG_SOC_TWAI_SUPPORT_MULTI_ADDRESS_LAYOUT 1
#define CONFIG_SOC_UART_NUM 3
#define CONFIG_SOC_UART_HP_NUM 3
#define CONFIG_SOC_UART_SUPPORT_APB_CLK 1
#define CONFIG_SOC_UART_SUPPORT_REF_TICK 1
#define CONFIG_SOC_UART_FIFO_LEN 128
#define CONFIG_SOC_UART_BITRATE_MAX 5000000
#define CONFIG_SOC_UART_WAKEUP_SUPPORT_ACTIVE_THRESH_MODE 1
#define CONFIG_SOC_SPIRAM_SUPPORTED 1
#define CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE 1
#define CONFIG_SOC_SHA_SUPPORT_PARALLEL_ENG 1
#define CONFIG_SOC_SHA_ENDIANNESS_BE 1
#define CONFIG_SOC_SHA_SUPPORT_SHA1 1
#define CONFIG_SOC_SHA_SUPPORT_SHA256 1
#define CONFIG_SOC_SHA_SUPPORT_SHA384 1
#define CONFIG_SOC_SHA_SUPPORT_SHA512 1
#define CONFIG_SOC_MPI_MEM_BLOCKS_NUM 4
#define CONFIG_SOC_MPI_OPERATIONS_NUM 1
#define CONFIG_SOC_RSA_MAX_BIT_LEN 4096
#define CONFIG_SOC_AES_SUPPORT_AES_128 1
#define CONFIG_SOC_AES_SUPPORT_AES_192 1
#define CONFIG_SOC_AES_SUPPORT_AES_256 1
#define CONFIG_SOC_SECURE_BOOT_V1 1
#define CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS 1
#define CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX 32
#define CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE 21
#define CONFIG_SOC_PM_SUPPORT_EXT0_WAKEUP 1
#define CONFIG_SOC_PM_SUPPORT_EXT1_WAKEUP 1
#define CONFIG_SOC_PM_SUPPORT_EXT_WAKEUP 1
#define CONFIG_SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP 1
#define CONFIG_SOC_PM_SUPPORT_RTC_PERIPH_PD 1
#define CONFIG_SOC_PM_SUPPORT_RTC_FAST_MEM_PD 1
#define CONFIG_SOC_PM_SUPPORT_RTC_SLOW_MEM_PD 1
#define CONFIG_SOC_PM_SUPPORT_RC_FAST_PD 1
#define CONFIG_SOC_PM_SUPPORT_VDDSDIO_PD 1
#define CONFIG_SOC_PM_SUPPORT_MODEM_PD 1
#define CONFIG_SOC_CONFIGURABLE_VDDSDIO_SUPPORTED 1
#define CONFIG_SOC_PM_MODEM_PD_BY_SW 1
#define CONFIG_SOC_CLK_APLL_SUPPORTED 1
#define CONFIG_SOC_CLK_RC_FAST_D256_SUPPORTED 1
#define CONFIG_SOC_RTC_SLOW_CLK_SUPPORT_RC_FAST_D256 1
#define CONFIG_SOC_CLK_RC_FAST_SUPPORT_CALIBRATION 1
#define CONFIG_SOC_CLK_XTAL32K_SUPPORTED 1
#define CONFIG_SOC_CLK_LP_FAST_SUPPORT_XTAL_D4 1
#define CONFIG_SOC_SDMMC_USE_IOMUX 1
#define CONFIG_SOC_SDMMC_NUM_SLOTS 2
#define CONFIG_SOC_WIFI_WAPI_SUPPORT 1
#define CONFIG_SOC_WIFI_CSI_SUPPORT 1
#define CONFIG_SOC_WIFI_MESH_SUPPORT 1
#define CONFIG_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW 1
#define CONFIG_SOC_WIFI_NAN_SUPPORT 1
#define CONFIG_SOC_BLE_SUPPORTED 1
#define CONFIG_SOC_BLE_MESH_SUPPORTED 1
#define CONFIG_SOC_BT_CLASSIC_SUPPORTED 1
#define CONFIG_SOC_BLUFI_SUPPORTED 1
#define CONFIG_SOC_BT_H2C_ENC_KEY_CTRL_ENH_VSC_SUPPORTED 1
#define CONFIG_SOC_ULP_HAS_ADC 1
#define CONFIG_SOC_PHY_COMBO_MODULE 1
#define CONFIG_SOC_EMAC_RMII_CLK_OUT_INTERNAL_LOOPBACK 1
#define CONFIG_IDF_CMAKE 1
#define CONFIG_IDF_TOOLCHAIN "gcc"
#define CONFIG_IDF_TOOLCHAIN_GCC 1
#define CONFIG_IDF_TARGET_ARCH_XTENSA 1
#define CONFIG_IDF_TARGET_ARCH "xtensa"
#define CONFIG_IDF_TARGET "esp32"
#define CONFIG_IDF_INIT_VERSION "5.5.0"
#define CONFIG_IDF_TARGET_ESP32 1
#define CONFIG_IDF_FIRMWARE_CHIP_ID 0x0000
#define CONFIG_APP_BUILD_TYPE_APP_2NDBOOT 1
#define CONFIG_APP_BUILD_GENERATE_BINARIES 1
#define CONFIG_APP_BUILD_BOOTLOADER 1
#define CONFIG_APP_BUILD_USE_FLASH_SECTIONS 1
#define CONFIG_BOOTLOADER_COMPILE_TIME_DATE 1
#define CONFIG_BOOTLOADER_PROJECT_VER 1
#define CONFIG_BOOTLOADER_OFFSET_IN_FLASH 0x1000
#define CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE 1
#define CONFIG_BOOTLOADER_LOG_VERSION_1 1
#define CONFIG_BOOTLOADER_LOG_VERSION 1
#define CONFIG_BOOTLOADER_LOG_LEVEL_INFO 1
#define CONFIG_BOOTLOADER_LOG_LEVEL 3
#define CONFIG_BOOTLOADER_LOG_TIMESTAMP_SOURCE_CPU_TICKS 1
#define CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT 1
#define CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V 1
#define CONFIG_BOOTLOADER_REGION_PROTECTION_ENABLE 1
#define CONFIG_BOOTLOADER_WDT_ENABLE 1
#define CONFIG_BOOTLOADER_WDT_TIME_MS 9000
#define CONFIG_BOOTLOADER_RESERVE_RTC_SIZE 0x0
#define CONFIG_SECURE_BOOT_V1_SUPPORTED 1
#define CONFIG_APP_COMPILE_TIME_DATE 1
#define CONFIG_APP_RETRIEVE_LEN_ELF_SHA 9
#define CONFIG_ESP_ROM_HAS_CRC_LE 1
#define CONFIG_ESP_ROM_HAS_CRC_BE 1
#define CONFIG_ESP_ROM_HAS_MZ_CRC32 1
#define CONFIG_ESP_ROM_HAS_JPEG_DECODE 1
#define CONFIG_ESP_ROM_HAS_UART_BUF_SWITCH 1
#define CONFIG_ESP_ROM_NEEDS_SWSETUP_WORKAROUND 1
#define CONFIG_ESP_ROM_HAS_NEWLIB 1
#define CONFIG_ESP_ROM_HAS_NEWLIB_NANO_FORMAT 1
#define CONFIG_ESP_ROM_HAS_NEWLIB_32BIT_TIME 1
#define CONFIG_ESP_ROM_HAS_SW_FLOAT 1
#define CONFIG_ESP_ROM_USB_OTG_NUM -1
#define CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM -1
#define CONFIG_ESP_ROM_SUPPORT_DEEP_SLEEP_WAKEUP_STUB 1
#define CONFIG_ESP_ROM_HAS_OUTPUT_PUTC_FUNC 1
#define CONFIG_ESPTOOLPY_FLASHMODE_DIO 1
#define CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR 1
#define CONFIG_ESPTOOLPY_FLASHMODE "dio"
#define CONFIG_ESPTOOLPY_FLASHFREQ_40M 1
#define CONFIG_ESPTOOLPY_FLASHFREQ "40m"
#define CONFIG_ESPTOOLPY_FLASHSIZE_2MB 1
#define CONFIG_ESPTOOLPY_FLASHSIZE "2MB"
#define CONFIG_ESPTOOLPY_BEFORE_RESET 1
#define CONFIG_ESPTOOLPY_BEFORE "default_reset"
#define CONFIG_ESPTOOLPY_AFTER_RESET 1
#define CONFIG_ESPTOOLPY_AFTER "hard_reset"
#define CONFIG_ESPTOOLPY_MONITOR_BAUD 115200
#define CONFIG_PARTITION_TABLE_SINGLE_APP 1
#define CONFIG_PARTITION_TABLE_CUSTOM_FILENAME "partitions.csv"
#define CONFIG_PARTITION_TABLE_FILENAME "partitions_singleapp.csv"
#define CONFIG_PARTITION_TABLE_OFFSET 0x8000
#define CONFIG_PARTITION_TABLE_MD5 1
#define CONFIG_COMPILER_OPTIMIZATION_DEBUG 1
#define CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE 1
#define CONFIG_COMPILER_ASSERT_NDEBUG_EVALUATE 1
#define CONFIG_COMPILER_FLOAT_LIB_FROM_GCCLIB 1
#define CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL 2
#define CONFIG_COMPILER_HIDE_PATHS_MACROS 1
#define CONFIG_COMPILER_STACK_CHECK_MODE_NONE 1
#define CONFIG_COMPILER_DISABLE_DEFAULT_ERRORS 1
#define CONFIG_COMPILER_RT_LIB_GCCLIB 1
#define CONFIG_COMPILER_RT_LIB_NAME "gcc"
#define CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING 1
#define CONFIG_APPTRACE_DEST_NONE 1
#define CONFIG_APPTRACE_DEST_UART_NONE 1
#define CONFIG_APPTRACE_UART_TASK_PRIO 1
#define CONFIG_APPTRACE_LOCK_ENABLE 1
#define CONFIG_TWAI_ERRATA_FIX_BUS_OFF_REC 1
#define CONFIG_TWAI_ERRATA_FIX_TX_INTR_LOST 1
#define CONFIG_TWAI_ERRATA_FIX_RX_FRAME_INVALID 1
#define CONFIG_TWAI_ERRATA_FIX_RX_FIFO_CORRUPT 1
#define CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM 1
#define CONFIG_ADC_DISABLE_DAC 1
#define CONFIG_ADC_CAL_EFUSE_TP_ENABLE 1
#define CONFIG_ADC_CAL_EFUSE_VREF_ENABLE 1
#define CONFIG_ADC_CAL_LUT_ENABLE 1
#define CONFIG_EFUSE_CODE_SCHEME_COMPAT_3_4 1
#define CONFIG_EFUSE_MAX_BLK_LEN 192
#define CONFIG_ESP_TLS_USING_MBEDTLS 1
#define CONFIG_ADC_CALI_EFUSE_TP_ENABLE 1
#define CONFIG_ADC_CALI_EFUSE_VREF_ENABLE 1
#define CONFIG_ADC_CALI_LUT_ENABLE 1
#define CONFIG_ADC_DISABLE_DAC_OUTPUT 1
#define CONFIG_ESP_COEX_ENABLED 1
#define CONFIG_ESP_ERR_TO_NAME_LOOKUP 1
#define CONFIG_DAC_DMA_AUTO_16BIT_ALIGN 1
#define CONFIG_GPTIMER_ISR_HANDLER_IN_IRAM 1
#define CONFIG_GPTIMER_OBJ_CACHE_SAFE 1
#define CONFIG_I2C_MASTER_ISR_HANDLER_IN_IRAM 1
#define CONFIG_RMT_ISR_HANDLER_IN_IRAM 1
#define CONFIG_RMT_OBJ_CACHE_SAFE 1
#define CONFIG_SPI_MASTER_ISR_IN_IRAM 1
#define CONFIG_SPI_SLAVE_ISR_IN_IRAM 1
#define CONFIG_ETH_ENABLED 1
#define CONFIG_ETH_USE_ESP32_EMAC 1
#define CONFIG_ETH_PHY_INTERFACE_RMII 1
#define CONFIG_ETH_RMII_CLK_INPUT 1
#define CONFIG_ETH_RMII_CLK_IN_GPIO 0
#define CONFIG_ETH_DMA_BUFFER_SIZE 512
#define CONFIG_ETH_DMA_RX_BUFFER_NUM 10
#define CONFIG_ETH_DMA_TX_BUFFER_NUM 10
#define CONFIG_ETH_USE_SPI_ETHERNET 1
#define CONFIG_ESP_EVENT_POST_FROM_ISR 1
#define CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR 1
#define CONFIG_ESP_GDBSTUB_ENABLED 1
#define CONFIG_ESP_GDBSTUB_SUPPORT_TASKS 1
#define CONFIG_ESP_GDBSTUB_MAX_TASKS 32
#define CONFIG_ESPHID_TASK_SIZE_BT 2048
#define CONFIG_ESPHID_TASK_SIZE_BLE 4096
#define CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS 1
#define CONFIG_ESP_HTTP_CLIENT_EVENT_POST_TIMEOUT 2000
#define CONFIG_HTTPD_MAX_REQ_HDR_LEN 1024
#define CONFIG_HTTPD_MAX_URI_LEN 512
#define CONFIG_HTTPD_ERR_RESP_NO_DELAY 1
#define CONFIG_HTTPD_PURGE_BUF_LEN 32
#define CONFIG_HTTPD_SERVER_EVENT_POST_TIMEOUT 2000
#define CONFIG_ESP_HTTPS_OTA_EVENT_POST_TIMEOUT 2000
#define CONFIG_ESP_HTTPS_SERVER_EVENT_POST_TIMEOUT 2000
#define CONFIG_ESP32_REV_MIN_0 1
#define CONFIG_ESP32_REV_MIN 0
#define CONFIG_ESP32_REV_MIN_FULL 0
#define CONFIG_ESP_REV_MIN_FULL 0
#define CONFIG_ESP32_REV_MAX_FULL 399
#define CONFIG_ESP_REV_MAX_FULL 399
#define CONFIG_ESP_EFUSE_BLOCK_REV_MIN_FULL 0
#define CONFIG_ESP_EFUSE_BLOCK_REV_MAX_FULL 99
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA 1
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP 1
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_BT 1
#define CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH 1
#define CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES_FOUR 1
#define CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES 4
#define CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR 1
#define CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES 4
#define CONFIG_ESP_SLEEP_FLASH_LEAKAGE_WORKAROUND 1
#define CONFIG_ESP_SLEEP_RTC_BUS_ISO_WORKAROUND 1
#define CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY 2000
#define CONFIG_ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS 1
#define CONFIG_RTC_CLK_SRC_INT_RC 1
#define CONFIG_RTC_CLK_CAL_CYCLES 1024
#define CONFIG_PERIPH_CTRL_FUNC_IN_IRAM 1
#define CONFIG_XTAL_FREQ_40 1
#define CONFIG_XTAL_FREQ 40
#define CONFIG_ESP_BROWNOUT_DET 1
#define CONFIG_ESP_BROWNOUT_DET_LVL_SEL_0 1
#define CONFIG_ESP_BROWNOUT_DET_LVL 0
#define CONFIG_ESP_BROWNOUT_USE_INTR 1
#define CONFIG_ESP_SPI_BUS_LOCK_ISR_FUNCS_IN_IRAM 1
#define CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL 120
#define CONFIG_ESP_NETIF_TCPIP_LWIP 1
#define CONFIG_ESP_NETIF_USES_TCPIP_WITH_BSD_API 1
#define CONFIG_ESP_NETIF_REPORT_DATA_TRAFFIC 1
#define CONFIG_ESP_PHY_ENABLED 1
#define CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE 1
#define CONFIG_ESP_PHY_MAX_WIFI_TX_POWER 20
#define CONFIG_ESP_PHY_MAX_TX_POWER 20
#define CONFIG_ESP_PHY_RF_CAL_PARTIAL 1
#define CONFIG_ESP_PHY_CALIBRATION_MODE 0
#define CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160 1
#define CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ 160
#define CONFIG_ESP32_TRACEMEM_RESERVE_DRAM 0x0
#define CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT 1
#define CONFIG_ESP_SYSTEM_PANIC_REBOOT_DELAY_SECONDS 0
#define CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE 32
#define CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE 2304
#define CONFIG_ESP_MAIN_TASK_STACK_SIZE 3584
#define CONFIG_ESP_MAIN_TASK_AFFINITY_CPU0 1
#define CONFIG_ESP_MAIN_TASK_AFFINITY 0x0
#define CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE 2048
#define CONFIG_ESP_CONSOLE_UART_DEFAULT 1
#define CONFIG_ESP_CONSOLE_UART 1
#define CONFIG_ESP_CONSOLE_UART_NUM 0
#define CONFIG_ESP_CONSOLE_ROM_SERIAL_PORT_NUM 0
#define CONFIG_ESP_CONSOLE_UART_BAUDRATE 115200
#define CONFIG_ESP_INT_WDT 1
#define CONFIG_ESP_INT_WDT_TIMEOUT_MS 300
#define CONFIG_ESP_INT_WDT_CHECK_CPU1 1
#define CONFIG_ESP_TASK_WDT_EN 1
#define CONFIG_ESP_TASK_WDT_INIT 1
#define CONFIG_ESP_TASK_WDT_TIMEOUT_S 5
#define CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0 1
#define CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1 1
#define CONFIG_ESP_DEBUG_OCDAWARE 1
#define CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_4 1
#define CONFIG_ESP_IPC_TASK_STACK_SIZE 1024
#define CONFIG_ESP_IPC_USES_CALLERS_PRIORITY 1
#define CONFIG_ESP_IPC_ISR_ENABLE 1
#define CONFIG_ESP_TIME_FUNCS_USE_RTC_TIMER 1
#define CONFIG_ESP_TIME_FUNCS_USE_ESP_TIMER 1
#define CONFIG_ESP_TIMER_TASK_STACK_SIZE 3584
#define CONFIG_ESP_TIMER_INTERRUPT_LEVEL 1
#define CONFIG_ESP_TIMER_TASK_AFFINITY 0x0
#define CONFIG_ESP_TIMER_TASK_AFFINITY_CPU0 1
#define CONFIG_ESP_TIMER_ISR_AFFINITY_CPU0 1
#define CONFIG_ESP_TIMER_IMPL_TG0_LAC 1
#define CONFIG_ESP_WIFI_ENABLED 1
#define CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM 10
#define CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM 32
#define CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER 1
#define CONFIG_ESP_WIFI_TX_BUFFER_TYPE 1
#define CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM 32
#define CONFIG_ESP_WIFI_STATIC_RX_MGMT_BUFFER 1
#define CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUF 0
#define CONFIG_ESP_WIFI_RX_MGMT_BUF_NUM_DEF 5
#define CONFIG_ESP_WIFI_AMPDU_TX_ENABLED 1
#define CONFIG_ESP_WIFI_TX_BA_WIN 6
#define CONFIG_ESP_WIFI_AMPDU_RX_ENABLED 1
#define CONFIG_ESP_WIFI_RX_BA_WIN 6
#define CONFIG_ESP_WIFI_NVS_ENABLED 1
#define CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0 1
#define CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN 752
#define CONFIG_ESP_WIFI_MGMT_SBUF_NUM 32
#define CONFIG_ESP_WIFI_IRAM_OPT 1
#define CONFIG_ESP_WIFI_RX_IRAM_OPT 1
#define CONFIG_ESP_WIFI_ENABLE_WPA3_SAE 1
#define CONFIG_ESP_WIFI_ENABLE_SAE_PK 1
#define CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT 1
#define CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA 1
#define CONFIG_ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME 50
#define CONFIG_ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME 10
#define CONFIG_ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME 15
#define CONFIG_ESP_WIFI_STA_DISCONNECTED_PM_ENABLE 1
#define CONFIG_ESP_WIFI_GMAC_SUPPORT 1
#define CONFIG_ESP_WIFI_SOFTAP_SUPPORT 1
#define CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM 7
#define CONFIG_ESP_WIFI_MBEDTLS_CRYPTO 1
#define CONFIG_ESP_WIFI_MBEDTLS_TLS_CLIENT 1
#define CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT 1
#define CONFIG_ESP_COREDUMP_ENABLE_TO_NONE 1
#define CONFIG_FATFS_VOLUME_COUNT 2
#define CONFIG_FATFS_LFN_NONE 1
#define CONFIG_FATFS_SECTOR_4096 1
#define CONFIG_FATFS_CODEPAGE_437 1
#define CONFIG_FATFS_CODEPAGE 437
#define CONFIG_FATFS_FS_LOCK 0
#define CONFIG_FATFS_TIMEOUT_MS 10000
#define CONFIG_FATFS_PER_FILE_CACHE 1
#define CONFIG_FATFS_USE_STRFUNC_NONE 1
#define CONFIG_FATFS_VFS_FSTAT_BLKSIZE 0
#define CONFIG_FATFS_LINK_LOCK 1
#define CONFIG_FREERTOS_HZ 100
#define CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY 1
#define CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS 1
#define CONFIG_FREERTOS_IDLE_TASK_STACKSIZE 1536
#define CONFIG_FREERTOS_MAX_TASK_NAME_LEN 16
#define CONFIG_FREERTOS_USE_TIMERS 1
#define CONFIG_FREERTOS_TIMER_SERVICE_TASK_NAME "Tmr Svc"
#define CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY 1
#define CONFIG_FREERTOS_TIMER_SERVICE_TASK_CORE_AFFINITY 0x7FFFFFFF
#define CONFIG_FREERTOS_TIMER_TASK_PRIORITY 1
#define CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH 2048
#define CONFIG_FREERTOS_TIMER_QUEUE_LENGTH 10
#define CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE 0
#define CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES 1
#define CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER 1
#define CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS 1
#define CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER 1
#define CONFIG_FREERTOS_ISR_STACKSIZE 1536
#define CONFIG_FREERTOS_INTERRUPT_BACKTRACE 1
#define CONFIG_FREERTOS_TICK_SUPPORT_CORETIMER 1
#define CONFIG_FREERTOS_CORETIMER_0 1
#define CONFIG_FREERTOS_SYSTICK_USES_CCOUNT 1
#define CONFIG_FREERTOS_PORT 1
#define CONFIG_FREERTOS_NO_AFFINITY 0x7FFFFFFF
#define CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION 1
#define CONFIG_FREERTOS_DEBUG_OCDAWARE 1
#define CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT 1
#define CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH 1
#define CONFIG_FREERTOS_NUMBER_OF_CORES 2
#define CONFIG_HAL_ASSERTION_EQUALS_SYSTEM 1
#define CONFIG_HAL_DEFAULT_ASSERTION_LEVEL 2
#define CONFIG_HEAP_POISONING_DISABLED 1
#define CONFIG_HEAP_TRACING_OFF 1
#define CONFIG_LOG_VERSION_1 1
#define CONFIG_LOG_VERSION 1
#define CONFIG_LOG_DEFAULT_LEVEL_INFO 1
#define CONFIG_LOG_DEFAULT_LEVEL 3
#define CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT 1
#define CONFIG_LOG_MAXIMUM_LEVEL 3
#define CONFIG_LOG_DYNAMIC_LEVEL_CONTROL 1
#define CONFIG_LOG_TAG_LEVEL_IMPL_CACHE_AND_LINKED_LIST 1
#define CONFIG_LOG_TAG_LEVEL_CACHE_BINARY_MIN_HEAP 1
#define CONFIG_LOG_TAG_LEVEL_IMPL_CACHE_SIZE 31
#define CONFIG_LOG_TIMESTAMP_SOURCE_RTOS 1
#define CONFIG_LWIP_ENABLE 1
#define CONFIG_LWIP_LOCAL_HOSTNAME "espressif"
#define CONFIG_LWIP_TCPIP_TASK_PRIO 18
#define CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES 1
#define CONFIG_LWIP_TIMERS_ONDEMAND 1
#define CONFIG_LWIP_ND6 1
#define CONFIG_LWIP_MAX_SOCKETS 10
#define CONFIG_LWIP_SO_REUSE 1
#define CONFIG_LWIP_SO_REUSE_RXTOALL 1
#define CONFIG_LWIP_IP_DEFAULT_TTL 64
#define CONFIG_LWIP_IP4_FRAG 1
#define CONFIG_LWIP_IP6_FRAG 1
#define CONFIG_LWIP_IP_REASS_MAX_PBUFS 10
#define CONFIG_LWIP_ESP_GRATUITOUS_ARP 1
#define CONFIG_LWIP_GARP_TMR_INTERVAL 60
#define CONFIG_LWIP_ESP_MLDV6_REPORT 1
#define CONFIG_LWIP_MLDV6_TMR_INTERVAL 40
#define CONFIG_LWIP_TCPIP_RECVMBOX_SIZE 32
#define CONFIG_LWIP_DHCP_DOES_ARP_CHECK 1
#define CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID 1
#define CONFIG_LWIP_DHCP_OPTIONS_LEN 68
#define CONFIG_LWIP_NUM_NETIF_CLIENT_DATA 0
#define CONFIG_LWIP_DHCP_COARSE_TIMER_SECS 1
#define CONFIG_LWIP_DHCPS 1
#define CONFIG_LWIP_DHCPS_LEASE_UNIT 60
#define CONFIG_LWIP_DHCPS_MAX_STATION_NUM 8
#define CONFIG_LWIP_DHCPS_STATIC_ENTRIES 1
#define CONFIG_LWIP_DHCPS_ADD_DNS 1
#define CONFIG_LWIP_IPV4 1
#define CONFIG_LWIP_IPV6 1
#define CONFIG_LWIP_IPV6_NUM_ADDRESSES 3
#define CONFIG_LWIP_NETIF_LOOPBACK 1
#define CONFIG_LWIP_LOOPBACK_MAX_PBUFS 8
#define CONFIG_LWIP_MAX_ACTIVE_TCP 16
#define CONFIG_LWIP_MAX_LISTENING_TCP 16
#define CONFIG_LWIP_TCP_HIGH_SPEED_RETRANSMISSION 1
#define CONFIG_LWIP_TCP_MAXRTX 12
#define CONFIG_LWIP_TCP_SYNMAXRTX 12
#define CONFIG_LWIP_TCP_MSS 1440
#define CONFIG_LWIP_TCP_TMR_INTERVAL 250
#define CONFIG_LWIP_TCP_MSL 60000
#define CONFIG_LWIP_TCP_FIN_WAIT_TIMEOUT 20000
#define CONFIG_LWIP_TCP_SND_BUF_DEFAULT 5760
#define CONFIG_LWIP_TCP_WND_DEFAULT 5760
#define CONFIG_LWIP_TCP_RECVMBOX_SIZE 6
#define CONFIG_LWIP_TCP_ACCEPTMBOX_SIZE 6
#define CONFIG_LWIP_TCP_QUEUE_OOSEQ 1
#define CONFIG_LWIP_TCP_OOSEQ_TIMEOUT 6
#define CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS 4
#define CONFIG_LWIP_TCP_OVERSIZE_MSS 1
#define CONFIG_LWIP_TCP_RTO_TIME 1500
#define CONFIG_LWIP_MAX_UDP_PCBS 16
#define CONFIG_LWIP_UDP_RECVMBOX_SIZE 6
#define CONFIG_LWIP_CHECKSUM_CHECK_ICMP 1
#define CONFIG_LWIP_TCPIP_TASK_STACK_SIZE 3072
#define CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY 1
#define CONFIG_LWIP_TCPIP_TASK_AFFINITY 0x7FFFFFFF
#define CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE 3
#define CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS 5
#define CONFIG_LWIP_IPV6_ND6_NUM_PREFIXES 5
#define CONFIG_LWIP_IPV6_ND6_NUM_ROUTERS 3
#define CONFIG_LWIP_IPV6_ND6_NUM_DESTINATIONS 10
#define CONFIG_LWIP_ICMP 1
#define CONFIG_LWIP_MAX_RAW_PCBS 16
#define CONFIG_LWIP_SNTP_MAX_SERVERS 1
#define CONFIG_LWIP_SNTP_UPDATE_DELAY 3600000
#define CONFIG_LWIP_SNTP_STARTUP_DELAY 1
#define CONFIG_LWIP_SNTP_MAXIMUM_STARTUP_DELAY 5000
#define CONFIG_LWIP_DNS_MAX_HOST_IP 1
#define CONFIG_LWIP_DNS_MAX_SERVERS 3
#define CONFIG_LWIP_BRIDGEIF_MAX_PORTS 7
#define CONFIG_LWIP_ESP_LWIP_ASSERT 1
#define CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT 1
#define CONFIG_LWIP_HOOK_IP6_ROUTE_NONE 1
#define CONFIG_LWIP_HOOK_ND6_GET_GW_NONE 1
#define CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_NONE 1
#define CONFIG_LWIP_HOOK_DHCP_EXTRA_OPTION_NONE 1
#define CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE 1
#define CONFIG_LWIP_HOOK_DNS_EXT_RESOLVE_NONE 1
#define CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT 1
#define CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC 1
#define CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN 1
#define CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN 16384
#define CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN 4096
#define CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE 1
#define CONFIG_MBEDTLS_PKCS7_C 1
#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE 1
#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL 1
#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS 200
#define CONFIG_MBEDTLS_CMAC_C 1
#define CONFIG_MBEDTLS_HARDWARE_AES 1
#define CONFIG_MBEDTLS_GCM_SUPPORT_NON_AES_CIPHER 1
#define CONFIG_MBEDTLS_HARDWARE_MPI 1
#define CONFIG_MBEDTLS_HARDWARE_SHA 1
#define CONFIG_MBEDTLS_ROM_MD5 1
#define CONFIG_MBEDTLS_HAVE_TIME 1
#define CONFIG_MBEDTLS_ECDSA_DETERMINISTIC 1
#define CONFIG_MBEDTLS_SHA512_C 1
#define CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT 1
#define CONFIG_MBEDTLS_TLS_SERVER 1
#define CONFIG_MBEDTLS_TLS_CLIENT 1
#define CONFIG_MBEDTLS_TLS_ENABLED 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_RSA 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA 1
#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA 1
#define CONFIG_MBEDTLS_SSL_RENEGOTIATION 1
#define CONFIG_MBEDTLS_SSL_PROTO_TLS1_2 1
#define CONFIG_MBEDTLS_SSL_ALPN 1
#define CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS 1
#define CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS 1
#define CONFIG_MBEDTLS_AES_C 1
#define CONFIG_MBEDTLS_CCM_C 1
#define CONFIG_MBEDTLS_GCM_C 1
#define CONFIG_MBEDTLS_PEM_PARSE_C 1
#define CONFIG_MBEDTLS_PEM_WRITE_C 1
#define CONFIG_MBEDTLS_X509_CRL_PARSE_C 1
#define CONFIG_MBEDTLS_X509_CSR_PARSE_C 1
#define CONFIG_MBEDTLS_ECP_C 1
#define CONFIG_MBEDTLS_PK_PARSE_EC_EXTENDED 1
#define CONFIG_MBEDTLS_PK_PARSE_EC_COMPRESSED 1
#define CONFIG_MBEDTLS_ECDH_C 1
#define CONFIG_MBEDTLS_ECDSA_C 1
#define CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED 1
#define CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED 1
#define CONFIG_MBEDTLS_ECP_NIST_OPTIM 1
#define CONFIG_MBEDTLS_ERROR_STRINGS 1
#define CONFIG_MBEDTLS_FS_IO 1
#define CONFIG_MQTT_PROTOCOL_311 1
#define CONFIG_MQTT_TRANSPORT_SSL 1
#define CONFIG_MQTT_TRANSPORT_WEBSOCKET 1
#define CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE 1
#define CONFIG_LIBC_NEWLIB 1
#define CONFIG_LIBC_STDOUT_LINE_ENDING_CRLF 1
#define CONFIG_LIBC_STDIN_LINE_ENDING_CR 1
#define CONFIG_LIBC_TIME_SYSCALL_USE_RTC_HRT 1
#define CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0 1
#define CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1 1
#define CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2 1
#define CONFIG_PTHREAD_TASK_PRIO_DEFAULT 5
#define CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT 3072
#define CONFIG_PTHREAD_STACK_MIN 768
#define CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY 1
#define CONFIG_PTHREAD_TASK_CORE_DEFAULT -1
#define CONFIG_PTHREAD_TASK_NAME_DEFAULT "pthread"
#define CONFIG_MMU_PAGE_SIZE_64KB 1
#define CONFIG_MMU_PAGE_MODE "64KB"
#define CONFIG_MMU_PAGE_SIZE 0x10000
#define CONFIG_SPI_FLASH_BROWNOUT_RESET_XMC 1
#define CONFIG_SPI_FLASH_BROWNOUT_RESET 1
#define CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US 50
#define CONFIG_SPI_FLASH_PLACE_FUNCTIONS_IN_IRAM 1
#define CONFIG_SPI_FLASH_ROM_DRIVER_PATCH 1
#define CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS 1
#define CONFIG_SPI_FLASH_YIELD_DURING_ERASE 1
#define CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS 20
#define CONFIG_SPI_FLASH_ERASE_YIELD_TICKS 1
#define CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE 8192
#define CONFIG_SPI_FLASH_VENDOR_XMC_SUPPORTED 1
#define CONFIG_SPI_FLASH_VENDOR_GD_SUPPORTED 1
#define CONFIG_SPI_FLASH_VENDOR_ISSI_SUPPORTED 1
#define CONFIG_SPI_FLASH_VENDOR_MXIC_SUPPORTED 1
#define CONFIG_SPI_FLASH_VENDOR_WINBOND_SUPPORTED 1
#define CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP 1
#define CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP 1
#define CONFIG_SPI_FLASH_SUPPORT_GD_CHIP 1
#define CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP 1
#define CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE 1
#define CONFIG_SPIFFS_MAX_PARTITIONS 3
#define CONFIG_SPIFFS_CACHE 1
#define CONFIG_SPIFFS_CACHE_WR 1
#define CONFIG_SPIFFS_PAGE_CHECK 1
#define CONFIG_SPIFFS_GC_MAX_RUNS 10
#define CONFIG_SPIFFS_PAGE_SIZE 256
#define CONFIG_SPIFFS_OBJ_NAME_LEN 32
#define CONFIG_SPIFFS_USE_MAGIC 1
#define CONFIG_SPIFFS_USE_MAGIC_LENGTH 1
#define CONFIG_SPIFFS_META_LENGTH 4
#define CONFIG_SPIFFS_USE_MTIME 1
#define CONFIG_WS_TRANSPORT 1
#define CONFIG_WS_BUFFER_SIZE 1024
#define CONFIG_UNITY_ENABLE_FLOAT 1
#define CONFIG_UNITY_ENABLE_DOUBLE 1
#define CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER 1
#define CONFIG_VFS_SUPPORT_IO 1
#define CONFIG_VFS_SUPPORT_DIR 1
#define CONFIG_VFS_SUPPORT_SELECT 1
#define CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT 1
#define CONFIG_VFS_SUPPORT_TERMIOS 1
#define CONFIG_VFS_MAX_COUNT 8
#define CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS 1
#define CONFIG_VFS_INITIALIZE_DEV_NULL 1
#define CONFIG_WL_SECTOR_SIZE_4096 1
#define CONFIG_WL_SECTOR_SIZE 4096
#define CONFIG_WIFI_PROV_SCAN_MAX_ENTRIES 16
#define CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT 30
#define CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN 1
#define CONFIG_MDNS_MAX_INTERFACES 3
#define CONFIG_MDNS_MAX_SERVICES 10
#define CONFIG_MDNS_TASK_PRIORITY 1
#define CONFIG_MDNS_ACTION_QUEUE_LEN 16
#define CONFIG_MDNS_TASK_STACK_SIZE 4096
#define CONFIG_MDNS_TASK_AFFINITY_CPU0 1
#define CONFIG_MDNS_TASK_AFFINITY 0x0
#define CONFIG_MDNS_TASK_CREATE_FROM_INTERNAL 1
#define CONFIG_MDNS_MEMORY_ALLOC_INTERNAL 1
#define CONFIG_MDNS_SERVICE_ADD_TIMEOUT_MS 2000
#define CONFIG_MDNS_TIMER_PERIOD_MS 100
#define CONFIG_MDNS_ENABLE_CONSOLE_CLI 1
#define CONFIG_MDNS_ENABLE_BROWSE 1
#define CONFIG_MDNS_MULTIPLE_INSTANCE 1
/* List of deprecated options */
#define CONFIG_ADC2_DISABLE_DAC CONFIG_ADC_DISABLE_DAC
#define CONFIG_BROWNOUT_DET CONFIG_ESP_BROWNOUT_DET
#define CONFIG_BROWNOUT_DET_LVL CONFIG_ESP_BROWNOUT_DET_LVL
#define CONFIG_BROWNOUT_DET_LVL_SEL_0 CONFIG_ESP_BROWNOUT_DET_LVL_SEL_0
#define CONFIG_COMPILER_OPTIMIZATION_DEFAULT CONFIG_COMPILER_OPTIMIZATION_DEBUG
#define CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG CONFIG_COMPILER_OPTIMIZATION_DEBUG
#define CONFIG_CONSOLE_UART CONFIG_ESP_CONSOLE_UART
#define CONFIG_CONSOLE_UART_BAUDRATE CONFIG_ESP_CONSOLE_UART_BAUDRATE
#define CONFIG_CONSOLE_UART_DEFAULT CONFIG_ESP_CONSOLE_UART_DEFAULT
#define CONFIG_CONSOLE_UART_NUM CONFIG_ESP_CONSOLE_UART_NUM
#define CONFIG_ESP32_APPTRACE_DEST_NONE CONFIG_APPTRACE_DEST_NONE
#define CONFIG_ESP32_APPTRACE_LOCK_ENABLE CONFIG_APPTRACE_LOCK_ENABLE
#define CONFIG_ESP32_BROWNOUT_DET CONFIG_ESP_BROWNOUT_DET
#define CONFIG_ESP32_BROWNOUT_DET_LVL CONFIG_ESP_BROWNOUT_DET_LVL
#define CONFIG_ESP32_BROWNOUT_DET_LVL_SEL_0 CONFIG_ESP_BROWNOUT_DET_LVL_SEL_0
#define CONFIG_ESP32_DEBUG_OCDAWARE CONFIG_ESP_DEBUG_OCDAWARE
#define CONFIG_ESP32_DEEP_SLEEP_WAKEUP_DELAY CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY
#define CONFIG_ESP32_DEFAULT_CPU_FREQ_160 CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160
#define CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ
#define CONFIG_ESP32_DEFAULT_PTHREAD_CORE_NO_AFFINITY CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY
#define CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE CONFIG_ESP_COREDUMP_ENABLE_TO_NONE
#define CONFIG_ESP32_PANIC_PRINT_REBOOT CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT
#define CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE
#define CONFIG_ESP32_PHY_MAX_TX_POWER CONFIG_ESP_PHY_MAX_TX_POWER
#define CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER CONFIG_ESP_PHY_MAX_WIFI_TX_POWER
#define CONFIG_ESP32_PTHREAD_STACK_MIN CONFIG_PTHREAD_STACK_MIN
#define CONFIG_ESP32_PTHREAD_TASK_CORE_DEFAULT CONFIG_PTHREAD_TASK_CORE_DEFAULT
#define CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT CONFIG_PTHREAD_TASK_NAME_DEFAULT
#define CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT CONFIG_PTHREAD_TASK_PRIO_DEFAULT
#define CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT
#define CONFIG_ESP32_RTC_CLK_CAL_CYCLES CONFIG_RTC_CLK_CAL_CYCLES
#define CONFIG_ESP32_RTC_CLK_SRC_INT_RC CONFIG_RTC_CLK_SRC_INT_RC
#define CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC CONFIG_RTC_CLK_SRC_INT_RC
#define CONFIG_ESP32_TIME_SYSCALL_USE_RTC_FRC1 CONFIG_LIBC_TIME_SYSCALL_USE_RTC_HRT
#define CONFIG_ESP32_TIME_SYSCALL_USE_RTC_HRT CONFIG_LIBC_TIME_SYSCALL_USE_RTC_HRT
#define CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED CONFIG_ESP_WIFI_AMPDU_RX_ENABLED
#define CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED CONFIG_ESP_WIFI_AMPDU_TX_ENABLED
#define CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM
#define CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER
#define CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM
#define CONFIG_ESP32_WIFI_ENABLED CONFIG_ESP_WIFI_ENABLED
#define CONFIG_ESP32_WIFI_ENABLE_WPA3_OWE_STA CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA
#define CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE CONFIG_ESP_WIFI_ENABLE_WPA3_SAE
#define CONFIG_ESP32_WIFI_IRAM_OPT CONFIG_ESP_WIFI_IRAM_OPT
#define CONFIG_ESP32_WIFI_MGMT_SBUF_NUM CONFIG_ESP_WIFI_MGMT_SBUF_NUM
#define CONFIG_ESP32_WIFI_NVS_ENABLED CONFIG_ESP_WIFI_NVS_ENABLED
#define CONFIG_ESP32_WIFI_RX_BA_WIN CONFIG_ESP_WIFI_RX_BA_WIN
#define CONFIG_ESP32_WIFI_RX_IRAM_OPT CONFIG_ESP_WIFI_RX_IRAM_OPT
#define CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN
#define CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM
#define CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0 CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0
#define CONFIG_ESP32_WIFI_TX_BA_WIN CONFIG_ESP_WIFI_TX_BA_WIN
#define CONFIG_ESP32_WIFI_TX_BUFFER_TYPE CONFIG_ESP_WIFI_TX_BUFFER_TYPE
#define CONFIG_ESP32_XTAL_FREQ CONFIG_XTAL_FREQ
#define CONFIG_ESP32_XTAL_FREQ_40 CONFIG_XTAL_FREQ_40
#define CONFIG_ESP_GRATUITOUS_ARP CONFIG_LWIP_ESP_GRATUITOUS_ARP
#define CONFIG_ESP_SLEEP_DEEP_SLEEP_WAKEUP_DELAY CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY
#define CONFIG_ESP_SYSTEM_BROWNOUT_INTR CONFIG_ESP_BROWNOUT_USE_INTR
#define CONFIG_ESP_TASK_WDT CONFIG_ESP_TASK_WDT_INIT
#define CONFIG_FLASHMODE_DIO CONFIG_ESPTOOLPY_FLASHMODE_DIO
#define CONFIG_FOUR_UNIVERSAL_MAC_ADDRESS CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR
#define CONFIG_GARP_TMR_INTERVAL CONFIG_LWIP_GARP_TMR_INTERVAL
#define CONFIG_GDBSTUB_MAX_TASKS CONFIG_ESP_GDBSTUB_MAX_TASKS
#define CONFIG_GDBSTUB_SUPPORT_TASKS CONFIG_ESP_GDBSTUB_SUPPORT_TASKS
#define CONFIG_INT_WDT CONFIG_ESP_INT_WDT
#define CONFIG_INT_WDT_CHECK_CPU1 CONFIG_ESP_INT_WDT_CHECK_CPU1
#define CONFIG_INT_WDT_TIMEOUT_MS CONFIG_ESP_INT_WDT_TIMEOUT_MS
#define CONFIG_IPC_TASK_STACK_SIZE CONFIG_ESP_IPC_TASK_STACK_SIZE
#define CONFIG_LOG_BOOTLOADER_LEVEL CONFIG_BOOTLOADER_LOG_LEVEL
#define CONFIG_LOG_BOOTLOADER_LEVEL_INFO CONFIG_BOOTLOADER_LOG_LEVEL_INFO
#define CONFIG_MAIN_TASK_STACK_SIZE CONFIG_ESP_MAIN_TASK_STACK_SIZE
#define CONFIG_MONITOR_BAUD CONFIG_ESPTOOLPY_MONITOR_BAUD
#define CONFIG_NEWLIB_STDIN_LINE_ENDING_CR CONFIG_LIBC_STDIN_LINE_ENDING_CR
#define CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF CONFIG_LIBC_STDOUT_LINE_ENDING_CRLF
#define CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT CONFIG_LIBC_TIME_SYSCALL_USE_RTC_HRT
#define CONFIG_NUMBER_OF_UNIVERSAL_MAC_ADDRESS CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES
#define CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE
#define CONFIG_OPTIMIZATION_ASSERTION_LEVEL CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL
#define CONFIG_OPTIMIZATION_LEVEL_DEBUG CONFIG_COMPILER_OPTIMIZATION_DEBUG
#define CONFIG_POST_EVENTS_FROM_IRAM_ISR CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR
#define CONFIG_POST_EVENTS_FROM_ISR CONFIG_ESP_EVENT_POST_FROM_ISR
#define CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS
#define CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS
#define CONFIG_STACK_CHECK_NONE CONFIG_COMPILER_STACK_CHECK_MODE_NONE
#define CONFIG_SUPPORT_TERMIOS CONFIG_VFS_SUPPORT_TERMIOS
#define CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT
#define CONFIG_SYSTEM_EVENT_QUEUE_SIZE CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE
#define CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE
#define CONFIG_TASK_WDT CONFIG_ESP_TASK_WDT_INIT
#define CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
#define CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
#define CONFIG_TASK_WDT_TIMEOUT_S CONFIG_ESP_TASK_WDT_TIMEOUT_S
#define CONFIG_TCPIP_RECVMBOX_SIZE CONFIG_LWIP_TCPIP_RECVMBOX_SIZE
#define CONFIG_TCPIP_TASK_AFFINITY CONFIG_LWIP_TCPIP_TASK_AFFINITY
#define CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY
#define CONFIG_TCPIP_TASK_STACK_SIZE CONFIG_LWIP_TCPIP_TASK_STACK_SIZE
#define CONFIG_TCP_MAXRTX CONFIG_LWIP_TCP_MAXRTX
#define CONFIG_TCP_MSL CONFIG_LWIP_TCP_MSL
#define CONFIG_TCP_MSS CONFIG_LWIP_TCP_MSS
#define CONFIG_TCP_OVERSIZE_MSS CONFIG_LWIP_TCP_OVERSIZE_MSS
#define CONFIG_TCP_QUEUE_OOSEQ CONFIG_LWIP_TCP_QUEUE_OOSEQ
#define CONFIG_TCP_RECVMBOX_SIZE CONFIG_LWIP_TCP_RECVMBOX_SIZE
#define CONFIG_TCP_SND_BUF_DEFAULT CONFIG_LWIP_TCP_SND_BUF_DEFAULT
#define CONFIG_TCP_SYNMAXRTX CONFIG_LWIP_TCP_SYNMAXRTX
#define CONFIG_TCP_WND_DEFAULT CONFIG_LWIP_TCP_WND_DEFAULT
#define CONFIG_TIMER_QUEUE_LENGTH CONFIG_FREERTOS_TIMER_QUEUE_LENGTH
#define CONFIG_TIMER_TASK_PRIORITY CONFIG_FREERTOS_TIMER_TASK_PRIORITY
#define CONFIG_TIMER_TASK_STACK_DEPTH CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH
#define CONFIG_TIMER_TASK_STACK_SIZE CONFIG_ESP_TIMER_TASK_STACK_SIZE
#define CONFIG_TRACEMEM_RESERVE_DRAM CONFIG_ESP32_TRACEMEM_RESERVE_DRAM
#define CONFIG_UDP_RECVMBOX_SIZE CONFIG_LWIP_UDP_RECVMBOX_SIZE
#define CONFIG_WPA_MBEDTLS_CRYPTO CONFIG_ESP_WIFI_MBEDTLS_CRYPTO
#define CONFIG_WPA_MBEDTLS_TLS_CLIENT CONFIG_ESP_WIFI_MBEDTLS_TLS_CLIENT
@@ -0,0 +1,17 @@
---
:cmock:
:mock_prefix: mock_
:plugins:
- :callback
- :ignore
- :expect_any_args
- :array
- :return_thru_ptr
:strippables:
- '(?:extern|static)\s+'
:treat_as:
uint8_t: HEX8
uint16_t: HEX16
uint32_t: UINT32
int8_t: INT8
bool: UINT8
@@ -0,0 +1,160 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include "esp_err.h"
#include "unity.h"
#include "create_test_packet.h"
// Encode a domain name in DNS format (length byte + characters)
size_t encode_dns_name(uint8_t* buffer, const char* name)
{
size_t pos = 0;
const char* segment_start = name;
// Process each segment (separated by dots)
for (const char* p = name; ; p++) {
if (*p == '.' || *p == 0) {
// Calculate segment length
size_t segment_len = p - segment_start;
// Write length byte
buffer[pos++] = segment_len;
// Write segment characters
for (size_t i = 0; i < segment_len; i++) {
buffer[pos++] = segment_start[i];
}
// If at end of string, exit loop
if (*p == 0) {
break;
}
// Move to next segment
segment_start = p + 1;
}
}
// Add null terminator
buffer[pos++] = 0;
return pos;
}
// Create an mDNS test packet from arrays of queries and answers
uint8_t* create_mdns_test_packet(
mdns_test_query_t queries[], size_t query_count,
mdns_test_answer_t answers[], size_t answer_count,
mdns_test_answer_t additional[], size_t additional_count,
size_t* packet_len)
{
// Allocate buffer for packet (max reasonable size for test)
uint8_t* packet = malloc(1460);
size_t pos = 0;
// DNS Header (12 bytes)
// Transaction ID
packet[pos++] = 0x00;
packet[pos++] = 0x00;
// Flags (QR=1 for response if there are answers, AA=1)
uint16_t flags = 0x0000;
if (answer_count > 0) {
flags |= 0x8400; // QR=1, AA=1
}
packet[pos++] = (flags >> 8) & 0xFF;
packet[pos++] = flags & 0xFF;
// Counts
packet[pos++] = 0x00;
packet[pos++] = query_count & 0xFF; // QDCOUNT
packet[pos++] = 0x00;
packet[pos++] = answer_count & 0xFF; // ANCOUNT
packet[pos++] = 0x00;
packet[pos++] = 0x00; // NSCOUNT
packet[pos++] = 0x00;
packet[pos++] = additional_count & 0xFF; // ARCOUNT
// Add queries
for (size_t i = 0; i < query_count; i++) {
// Encode name
pos += encode_dns_name(packet + pos, queries[i].name);
// Type
packet[pos++] = (queries[i].type >> 8) & 0xFF;
packet[pos++] = queries[i].type & 0xFF;
// Class
packet[pos++] = (queries[i].class >> 8) & 0xFF;
packet[pos++] = queries[i].class & 0xFF;
}
// Add answers
for (size_t i = 0; i < answer_count; i++) {
// Encode name
pos += encode_dns_name(packet + pos, answers[i].name);
// Type
packet[pos++] = (answers[i].type >> 8) & 0xFF;
packet[pos++] = answers[i].type & 0xFF;
// Class
packet[pos++] = (answers[i].class >> 8) & 0xFF;
packet[pos++] = answers[i].class & 0xFF;
// TTL (4 bytes)
packet[pos++] = (answers[i].ttl >> 24) & 0xFF;
packet[pos++] = (answers[i].ttl >> 16) & 0xFF;
packet[pos++] = (answers[i].ttl >> 8) & 0xFF;
packet[pos++] = answers[i].ttl & 0xFF;
// Data length
packet[pos++] = (answers[i].data_len >> 8) & 0xFF;
packet[pos++] = answers[i].data_len & 0xFF;
// Data
if (answers[i].data && answers[i].data_len > 0) {
memcpy(packet + pos, answers[i].data, answers[i].data_len);
pos += answers[i].data_len;
}
}
// Add additional records
for (size_t i = 0; i < additional_count; i++) {
// Encode name
pos += encode_dns_name(packet + pos, additional[i].name);
// Type
packet[pos++] = (additional[i].type >> 8) & 0xFF;
packet[pos++] = additional[i].type & 0xFF;
// Class
packet[pos++] = (additional[i].class >> 8) & 0xFF;
packet[pos++] = additional[i].class & 0xFF;
// TTL (4 bytes)
packet[pos++] = (additional[i].ttl >> 24) & 0xFF;
packet[pos++] = (additional[i].ttl >> 16) & 0xFF;
packet[pos++] = (additional[i].ttl >> 8) & 0xFF;
packet[pos++] = additional[i].ttl & 0xFF;
// Data length
packet[pos++] = (additional[i].data_len >> 8) & 0xFF;
packet[pos++] = additional[i].data_len & 0xFF;
// Data
if (additional[i].data && additional[i].data_len > 0) {
memcpy(packet + pos, additional[i].data, additional[i].data_len);
pos += additional[i].data_len;
}
}
*packet_len = pos;
return packet;
}
@@ -0,0 +1,31 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#pragma once
// Structure for a DNS query
typedef struct {
const char* name; // Name to query (e.g., "test.local")
uint16_t type; // Query type (e.g., MDNS_TYPE_A)
uint16_t class; // Query class (typically 1 for IN)
} mdns_test_query_t;
// Structure for a DNS answer record
typedef struct {
const char* name; // Name this record refers to
uint16_t type; // Record type
uint16_t class; // Record class
uint32_t ttl; // Time to live
uint16_t data_len; // Length of data
uint8_t* data; // Record data
} mdns_test_answer_t;
uint8_t* create_mdns_test_packet(
mdns_test_query_t queries[], size_t query_count,
mdns_test_answer_t answers[], size_t answer_count,
mdns_test_answer_t additional[], size_t additional_count,
size_t* packet_len);
size_t encode_dns_name(uint8_t* buffer, const char* name);
@@ -0,0 +1,11 @@
enable_testing()
add_test(NAME ${PROJECT_NAME} COMMAND ${PROJECT_NAME} --test)
add_custom_target(generate_mocks
DEPENDS ${MOCK_OUTPUTS}
)
add_dependencies(${PROJECT_NAME} generate_mocks)
# Add sanitizers: Please comment out when debugging
target_link_options(${PROJECT_NAME} PRIVATE -fsanitize=address -fsanitize=undefined)
target_compile_options(${PROJECT_NAME} PRIVATE -fsanitize=address -fsanitize=undefined)
@@ -0,0 +1,311 @@
/*
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stdint.h>
#include <string.h>
#include "mdns.h"
#include "mdns_browser.h"
#include "mdns_cache.h"
#include "mdns_mem_caps.h"
#include "mdns_private.h"
#include "mock_mdns_pcb.h"
#include "unity.h"
#define INSTANCE "cached-service"
#define SERVICE "_cachetest"
#define PROTO "_tcp"
#define HOSTNAME "cache-host"
#define PORT 8080
#define TTL 120
#define SUBTYPE "alpha"
#define TXT_VAL "value"
#define TXT_VAL_LEN 5
static uint8_t s_netif_storage;
static const mdns_txt_linked_item_t s_txt = {
.key = "key",
.value = TXT_VAL,
.value_len = TXT_VAL_LEN,
.next = NULL,
};
static const esp_ip_addr_t s_addr = ESP_IP4ADDR_INIT(192, 168, 1, 100);
static size_t s_notify_calls;
static uint32_t s_last_ttl;
static size_t s_subtype_calls;
static uint32_t s_subtype_ttl;
static esp_netif_t *test_netif(void)
{
return (esp_netif_t *)&s_netif_storage;
}
static void assert_browse_result(const mdns_result_t *result)
{
// Results belong to the browser and are only valid during this callback.
TEST_ASSERT_NOT_NULL(result);
TEST_ASSERT_NULL(result->next);
TEST_ASSERT_EQUAL_PTR(test_netif(), result->esp_netif);
TEST_ASSERT_EQUAL(MDNS_IP_PROTOCOL_V4, result->ip_protocol);
TEST_ASSERT_EQUAL_STRING(INSTANCE, result->instance_name);
TEST_ASSERT_EQUAL_STRING(SERVICE, result->service_type);
TEST_ASSERT_EQUAL_STRING(PROTO, result->proto);
TEST_ASSERT_EQUAL_STRING(HOSTNAME, result->hostname);
TEST_ASSERT_EQUAL_UINT16(PORT, result->port);
TEST_ASSERT_NOT_NULL(result->txt);
TEST_ASSERT_EQUAL_UINT8(TXT_VAL_LEN, result->txt_value_len[0]);
TEST_ASSERT_EQUAL_size_t(1, result->txt_count);
TEST_ASSERT_NOT_NULL(result->addr);
TEST_ASSERT_EQUAL(ESP_IPADDR_TYPE_V4, result->addr->addr.type);
TEST_ASSERT_EQUAL_UINT32(s_addr.u_addr.ip4.addr, result->addr->addr.u_addr.ip4.addr);
}
static void browse_callback(mdns_result_t *result)
{
assert_browse_result(result);
TEST_ASSERT_NULL(result->subtype);
s_notify_calls++;
s_last_ttl = result->ttl;
}
static void subtype_callback(mdns_result_t *result)
{
assert_browse_result(result);
TEST_ASSERT_EQUAL_STRING(SUBTYPE, result->subtype);
s_subtype_calls++;
s_subtype_ttl = result->ttl;
}
static void unexpected_callback(mdns_result_t *result)
{
(void)result;
TEST_FAIL_MESSAGE("A non-matching browse received a notification");
}
static mdns_txt_linked_item_t *clone_txt(const mdns_txt_linked_item_t *src_txt)
{
mdns_txt_linked_item_t *item = mdns_mem_calloc(1, sizeof(mdns_txt_linked_item_t));
TEST_ASSERT_NOT_NULL(item);
item->key = mdns_mem_strdup(src_txt->key);
TEST_ASSERT_NOT_NULL(item->key);
item->value_len = src_txt->value_len;
if (src_txt->value_len > 0) {
item->value = mdns_mem_malloc(src_txt->value_len);
TEST_ASSERT_NOT_NULL(item->value);
memcpy(item->value, src_txt->value, src_txt->value_len);
}
return item;
}
static void cache_service_details(void)
{
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_srv(test_netif(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, INSTANCE, SERVICE, PROTO,
0, 0, PORT, TTL));
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_txt(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, clone_txt(&s_txt), TTL));
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_addr(test_netif(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, &s_addr, TTL));
}
static void cache_service(void)
{
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, TTL));
cache_service_details();
}
void mdns_test_set_up(void)
{
mdns_priv_browse_free();
mdns_priv_cache_clear();
s_notify_calls = 0;
s_last_ttl = 0;
s_subtype_calls = 0;
s_subtype_ttl = 0;
}
void mdns_test_tear_down(void)
{
mdns_priv_browse_free();
mdns_priv_cache_clear();
}
void setup_cmock(void)
{
mdns_priv_probe_all_pcbs_CMockIgnore();
mdns_priv_pcb_announce_CMockIgnore();
mdns_priv_pcb_send_bye_service_CMockIgnore();
mdns_priv_pcb_check_probing_services_CMockIgnore();
mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
mdsn_priv_pcb_is_inited_IgnoreAndReturn(false);
}
static void test_browse_add_delete_sequence(void)
{
const char *other_service = "_other";
// Register A and reject an immediate duplicate.
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
TEST_ASSERT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
// Register B without affecting A.
TEST_ASSERT_NOT_NULL(mdns_browse_new(other_service, PROTO, unexpected_callback));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(other_service, PROTO));
// Delete A. B remains registered, and deleting A again must fail.
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(SERVICE, PROTO));
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(SERVICE, PROTO));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(other_service, PROTO));
TEST_ASSERT_EQUAL(ESP_FAIL, mdns_browse_delete(SERVICE, PROTO));
// A can be registered again immediately after deletion.
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(SERVICE, PROTO));
TEST_ASSERT_TRUE(mdns_priv_browse_has_service(other_service, PROTO));
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(SERVICE, PROTO));
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(other_service, PROTO));
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(SERVICE, PROTO));
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(other_service, PROTO));
}
static void test_browse_cached_result_and_delete(void)
{
// Consume pending updates before registering the browse.
// The initial callback must come from replaying the cache on browse start.
cache_service();
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(0, s_notify_calls);
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
TEST_ASSERT_EQUAL(ESP_OK, mdns_browse_delete(SERVICE, PROTO));
TEST_ASSERT_FALSE(mdns_priv_browse_has_service(SERVICE, PROTO));
// Further cache changes must not call the deleted browse notifier.
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_srv(test_netif(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, INSTANCE, SERVICE, PROTO,
0, 0, PORT + 1, TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
}
static void test_browse_matches_service_and_requires_ptr(void)
{
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
TEST_ASSERT_NOT_NULL(mdns_browse_new("_other", PROTO, unexpected_callback));
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, "_udp", unexpected_callback));
// SRV, TXT and addresses alone do not establish a browse result.
cache_service_details();
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(0, s_notify_calls);
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
}
static void test_browse_goodbye_and_rediscovery(void)
{
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
cache_service();
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
// Cache goodbye should notify the browse.
TEST_ASSERT_NOT_EQUAL(MDNS_CACHE_ERROR, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_notify_calls);
TEST_ASSERT_EQUAL_UINT32(0, s_last_ttl);
// The same browse remains active and can discover the service again.
cache_service();
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_notify_calls);
TEST_ASSERT_EQUAL_UINT32(TTL, s_last_ttl);
}
static void test_browse_subtype_update_filtering(void)
{
TEST_ASSERT_NOT_NULL(mdns_browse_new(SERVICE, PROTO, browse_callback));
TEST_ASSERT_NOT_NULL(mdns_browse_new_with_subtype(SERVICE, PROTO, SUBTYPE, subtype_callback));
cache_service();
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_notify_calls);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE, TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_subtype_calls);
// Changes to shared record (SRV/TXT/ADDR) TTLs reach both browsers.
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, INSTANCE, SERVICE, PROTO,
0, 0, PORT, TTL + 1));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_notify_calls);
TEST_ASSERT_EQUAL_size_t(2, s_subtype_calls);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, clone_txt(&s_txt), TTL + 1));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_notify_calls);
TEST_ASSERT_EQUAL_size_t(3, s_subtype_calls);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, &s_addr, TTL + 1));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(4, s_notify_calls);
TEST_ASSERT_EQUAL_size_t(4, s_subtype_calls);
// Base and subtype PTR updates notify only their matching browser.
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, TTL + 1));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(5, s_notify_calls);
TEST_ASSERT_EQUAL_size_t(4, s_subtype_calls);
TEST_ASSERT_EQUAL_UINT32(TTL + 1, s_last_ttl);
TEST_ASSERT_EQUAL_UINT32(TTL, s_subtype_ttl);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE, TTL + 2));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(5, s_notify_calls);
TEST_ASSERT_EQUAL_size_t(5, s_subtype_calls);
TEST_ASSERT_EQUAL_UINT32(TTL + 1, s_last_ttl);
TEST_ASSERT_EQUAL_UINT32(TTL + 2, s_subtype_ttl);
}
void run_unity_tests(void)
{
UNITY_BEGIN();
RUN_TEST(test_browse_add_delete_sequence);
RUN_TEST(test_browse_cached_result_and_delete);
RUN_TEST(test_browse_matches_service_and_requires_ptr);
RUN_TEST(test_browse_goodbye_and_rediscovery);
RUN_TEST(test_browse_subtype_update_filtering);
UNITY_END();
}
@@ -0,0 +1,6 @@
# Mock pcb to disable network queries. Use real browser and cache.
set(MOCK_FILES
"mdns_pcb"
)
list(APPEND SOURCES unity/${UNIT_TESTS}/test_browse.c)
@@ -0,0 +1,982 @@
/*
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <strings.h>
#include "esp_netif_ip_addr.h"
#include "esp_netif_types.h"
#include "mdns.h"
#include "mdns_cache.h"
#include "mdns_mem_caps.h"
#include "mdns_mem_caps_test.h"
#include "mdns_private.h"
#include "mdns_test_clock.h"
#include "mock_mdns_browser.h"
#include "unity.h"
#include "unity_internals.h"
#define INSTANCE "_instance"
#define SERVICE "_http"
#define PROTO "_tcp"
#define HOSTNAME "device"
#define SUBTYPE_A "alpha"
#define SUBTYPE_B "beta"
#define PTR_TTL 120
#define SRV_TTL 130
#define TXT_TTL 140
#define ADDR_TTL 150
#define SRV_PRIORITY 10
#define SRV_WEIGHT 20
#define SRV_PORT 8080
typedef struct {
size_t update_calls;
size_t goodbye_calls;
bool update_result;
bool goodbye_result;
mdns_cache_record_mask_t records;
mdns_ip_protocol_t ip_protocol;
const esp_netif_t *esp_netif;
bool ptr_present;
bool srv_present;
bool txt_present;
uint32_t ptr_ttl;
uint32_t srv_ttl;
uint32_t txt_ttl;
uint16_t priority;
uint16_t weight;
uint16_t port;
size_t address_count;
size_t txt_count;
size_t subtype_count;
// These pointers are references to the pointers in service cache item during tests,
// and should only be used after SUBTYPE/TXT/ADDR cache has been updated and before service cache is cleaned!
// Do not manually free them, they should be maintained by mdns_cache.
const mdns_txt_linked_item_t *txt;
const mdns_cache_addr_t *addr;
const mdns_cache_subtype_t *subtype;
const mdns_cache_entry_t *entry;
const mdns_service_cache_t *service_cache;
char hostname[MDNS_NAME_BUF_LEN];
char instance[MDNS_NAME_BUF_LEN];
char service[MDNS_NAME_BUF_LEN];
char proto[MDNS_NAME_BUF_LEN];
char goodbye_subtype[MDNS_NAME_BUF_LEN];
} cache_observer_t;
static cache_observer_t s_observer;
// Provide mock `esp_netif_t` pointers
static uint8_t s_netif_storage_a;
// ----------------- Helper functions -----------------
static esp_netif_t *test_netif_a(void)
{
return (esp_netif_t *)&s_netif_storage_a;
}
static void reset_observer(void)
{
memset(&s_observer, 0, sizeof(s_observer));
s_observer.update_result = true;
s_observer.goodbye_result = true;
}
static void copy_optional_string(char *dst, size_t dst_size, const char *src)
{
if (!src) {
dst[0] = '\0';
return;
}
strncpy(dst, src, dst_size - 1);
dst[dst_size - 1] = '\0';
}
static size_t count_addresses(const mdns_cache_addr_t *addr)
{
size_t count = 0;
while (addr) {
count++;
addr = addr->next;
}
return count;
}
static size_t count_txt(const mdns_txt_linked_item_t *txt)
{
size_t count = 0;
while (txt) {
count++;
txt = txt->next;
}
return count;
}
static size_t count_subtype(const mdns_cache_subtype_t *subtype)
{
size_t count = 0;
while (subtype) {
count++;
subtype = subtype->next;
}
return count;
}
static void capture_cache(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
mdns_cache_record_mask_t records)
{
TEST_ASSERT_NOT_NULL(entry);
TEST_ASSERT_NOT_NULL(service);
s_observer.records = records;
s_observer.ip_protocol = entry->ip_protocol;
s_observer.esp_netif = entry->esp_netif;
s_observer.ptr_present = service->ptr_present;
s_observer.srv_present = service->srv_present;
s_observer.txt_present = service->txt_present;
s_observer.ptr_ttl = service->ptr_ttl;
s_observer.srv_ttl = service->srv_ttl;
s_observer.txt_ttl = service->txt_ttl;
s_observer.priority = service->priority;
s_observer.weight = service->weight;
s_observer.port = service->port;
s_observer.address_count = count_addresses(entry->addr_list);
s_observer.txt_count = count_txt(service->txt_list);
s_observer.subtype_count = count_subtype(service->subtype_list);
s_observer.txt = service->txt_list;
s_observer.addr = entry->addr_list;
s_observer.subtype = service->subtype_list;
s_observer.entry = entry;
s_observer.service_cache = service;
copy_optional_string(s_observer.hostname, sizeof(s_observer.hostname), entry->hostname);
copy_optional_string(s_observer.instance, sizeof(s_observer.instance), service->instance_name);
copy_optional_string(s_observer.service, sizeof(s_observer.service), service->service);
copy_optional_string(s_observer.proto, sizeof(s_observer.proto), service->proto);
}
static bool browse_update_callback(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
mdns_cache_record_mask_t records, int cmock_num_calls)
{
(void)cmock_num_calls;
s_observer.update_calls++;
capture_cache(entry, service, records);
return s_observer.update_result;
}
static bool browse_goodbye_callback(const mdns_cache_entry_t *entry, const mdns_service_cache_t *service,
const char *subtype, int cmock_num_calls)
{
(void)cmock_num_calls;
s_observer.goodbye_calls++;
capture_cache(entry, service, 0);
copy_optional_string(s_observer.goodbye_subtype, sizeof(s_observer.goodbye_subtype), subtype);
return s_observer.goodbye_result;
}
static mdns_txt_linked_item_t *clone_txt(const mdns_txt_linked_item_t *src_txt)
{
mdns_txt_linked_item_t *item = mdns_mem_calloc(1, sizeof(mdns_txt_linked_item_t));
TEST_ASSERT_NOT_NULL(item);
item->key = mdns_mem_strdup(src_txt->key);
TEST_ASSERT_NOT_NULL(item->key);
item->value_len = src_txt->value_len;
if (src_txt->value_len > 0) {
item->value = mdns_mem_malloc(src_txt->value_len);
TEST_ASSERT_NOT_NULL(item->value);
memcpy(item->value, src_txt->value, src_txt->value_len);
}
return item;
}
static bool find_txt_in_txt_list(const mdns_txt_linked_item_t *txt_list, const mdns_txt_linked_item_t *target)
{
if (!txt_list || !target) {
return false;
}
for (const mdns_txt_linked_item_t *it = txt_list; it; it = it->next) {
if (strcasecmp(it->key, target->key) == 0) {
if (it->value_len != target->value_len) {
return false; // Do not allow duplicated keys
}
return it->value_len == 0 || memcmp(it->value, target->value, it->value_len) == 0;
}
}
return false;
}
static bool assert_subtype_in_list(const mdns_cache_subtype_t *subtype_list, const char *subtype, uint32_t ttl)
{
if (!subtype_list || !subtype) {
return false;
}
for (const mdns_cache_subtype_t *it = subtype_list; it; it = it->next) {
if (strcasecmp(it->subtype, subtype) == 0) {
return it->ttl == ttl;
}
}
return false;
}
static esp_ip_addr_t make_ipv4(uint32_t address)
{
esp_ip_addr_t addr = {0};
addr.type = ESP_IPADDR_TYPE_V4;
addr.u_addr.ip4.addr = address;
return addr;
}
static esp_ip_addr_t make_ipv6(const uint32_t address[4])
{
esp_ip_addr_t addr = {0};
addr.type = ESP_IPADDR_TYPE_V6;
for (int i = 0; i < 4; i++) {
addr.u_addr.ip6.addr[i] = address[i];
}
return addr;
}
static void assert_memory(size_t baseline)
{
TEST_ASSERT_EQUAL_size_t(baseline, mdns_mem_get_allocation_counts());
}
static mdns_cache_update_result_t update_test_record(mdns_cache_record_type_t record_type, bool goodbye)
{
static const mdns_txt_linked_item_t txt = {
.key = "key",
.value = "value",
.value_len = 5,
.next = NULL,
};
const esp_ip_addr_t addr = make_ipv4(0x0101A8C0);
switch (record_type) {
case MDNS_CACHE_RECORD_PTR:
return mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, goodbye ? 0 : PTR_TTL);
case MDNS_CACHE_RECORD_SRV:
return mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, goodbye ? 0 : SRV_TTL);
case MDNS_CACHE_RECORD_TXT:
return mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, clone_txt(&txt), goodbye ? 0 : TXT_TTL);
case MDNS_CACHE_RECORD_ADDR:
return mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME,
&addr, goodbye ? 0 : ADDR_TTL);
default:
TEST_FAIL_MESSAGE("Invalid record type");
return MDNS_CACHE_ERROR;
}
}
static void insert_complete_service(void)
{
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, update_test_record(MDNS_CACHE_RECORD_PTR, false));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_SRV, false));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_TXT, false));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_ADDR, false));
}
static void assert_observed_complete_service(void)
{
TEST_ASSERT_EQUAL_PTR(test_netif_a(), s_observer.esp_netif);
TEST_ASSERT_EQUAL(MDNS_IP_PROTOCOL_V4, s_observer.ip_protocol);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_TRUE(s_observer.srv_present);
TEST_ASSERT_TRUE(s_observer.txt_present);
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.ptr_ttl);
TEST_ASSERT_EQUAL_UINT32(SRV_TTL, s_observer.srv_ttl);
TEST_ASSERT_EQUAL_UINT32(TXT_TTL, s_observer.txt_ttl);
TEST_ASSERT_EQUAL_UINT16(SRV_PRIORITY, s_observer.priority);
TEST_ASSERT_EQUAL_UINT16(SRV_WEIGHT, s_observer.weight);
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, s_observer.port);
TEST_ASSERT_EQUAL_size_t(1, s_observer.txt_count);
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
TEST_ASSERT_EQUAL_STRING(HOSTNAME, s_observer.hostname);
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
}
// Project only while the cache pointers captured by the callback are still valid.
static mdns_result_t *project_observed_service(void)
{
mdns_result_t *result = NULL;
TEST_ASSERT_EQUAL(ESP_OK, mdns_priv_service_cache_to_result(s_observer.entry, s_observer.service_cache, &result));
TEST_ASSERT_NOT_NULL(result);
return result;
}
static void assert_complete_result(const mdns_result_t *result)
{
TEST_ASSERT_EQUAL_PTR(test_netif_a(), result->esp_netif);
TEST_ASSERT_EQUAL(MDNS_IP_PROTOCOL_V4, result->ip_protocol);
TEST_ASSERT_EQUAL_STRING(INSTANCE, result->instance_name);
TEST_ASSERT_EQUAL_STRING(SERVICE, result->service_type);
TEST_ASSERT_EQUAL_STRING(PROTO, result->proto);
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, result->ttl);
TEST_ASSERT_EQUAL_STRING(HOSTNAME, result->hostname);
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, result->port);
TEST_ASSERT_EQUAL_size_t(1, result->txt_count);
TEST_ASSERT_NOT_NULL(result->txt);
TEST_ASSERT_NOT_NULL(result->txt_value_len);
TEST_ASSERT_EQUAL_STRING("key", result->txt[0].key);
TEST_ASSERT_EQUAL_UINT8(5, result->txt_value_len[0]);
TEST_ASSERT_EQUAL_MEMORY("value", result->txt[0].value, 5);
TEST_ASSERT_NOT_NULL(result->addr);
TEST_ASSERT_EQUAL(ESP_IPADDR_TYPE_V4, result->addr->addr.type);
TEST_ASSERT_EQUAL_UINT32(0x0101A8C0, result->addr->addr.u_addr.ip4.addr);
TEST_ASSERT_NULL(result->addr->next);
TEST_ASSERT_NULL(result->next);
}
// ----------------- Test functions -----------------
void mdns_test_set_up(void)
{
mdns_priv_cache_clear();
mdns_test_clock_reset();
reset_observer();
}
void mdns_test_tear_down(void)
{
mdns_priv_cache_clear();
}
void setup_cmock(void)
{
mdns_priv_browse_update_from_service_cache_Stub(browse_update_callback);
mdns_priv_browse_notify_ptr_goodbye_from_service_cache_Stub(browse_goodbye_callback);
mdns_priv_browse_notify_from_service_cache_IgnoreAndReturn(true);
}
static void test_cache_ptr_add_repeat_update_remove(void)
{
size_t baseline = mdns_mem_get_allocation_counts();
// Scenario 1: Add new PTR record
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_PTR, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.ptr_ttl);
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
// Scenario 2: Update the same service cache with identical PTR TTL
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// Scenario 3: Update the same service cache with different PTR TTL
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT32(240, s_observer.ptr_ttl);
// Scenario 4: Remove cache with PTR TTL=0
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
assert_memory(baseline);
}
static void test_cache_srv_add_repeat_update_remove(void)
{
size_t baseline = mdns_mem_get_allocation_counts();
// Scenario 1: Add new SRV record
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV, s_observer.records);
TEST_ASSERT_TRUE(s_observer.srv_present);
TEST_ASSERT_EQUAL_UINT32(SRV_TTL, s_observer.srv_ttl);
TEST_ASSERT_EQUAL_STRING(HOSTNAME, s_observer.hostname);
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
TEST_ASSERT_EQUAL_UINT16(SRV_PRIORITY, s_observer.priority);
TEST_ASSERT_EQUAL_UINT16(SRV_WEIGHT, s_observer.weight);
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, s_observer.port);
// Scenario 2: Update the same service cache with identical priority, weight, port, and SRV TTL
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// Scenario 3: Update the same service cache with different SRV record
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, 30, 40, 8081, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT32(240, s_observer.srv_ttl);
TEST_ASSERT_EQUAL_UINT16(30, s_observer.priority);
TEST_ASSERT_EQUAL_UINT16(40, s_observer.weight);
TEST_ASSERT_EQUAL_UINT16(8081, s_observer.port);
// Scenario 4: Remove cache with SRV TTL=0
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
assert_memory(baseline);
}
static void test_cache_txt_add_repeat_update_remove(void)
{
static const uint8_t binary_arr[] = {0, 0, 0, 0, 255};
// Normal TXT item
static const mdns_txt_linked_item_t txt_1 = {
.key = "key1",
.value = "value",
.value_len = 5,
.next = NULL,
};
// Simulate TXT item with no value
static const mdns_txt_linked_item_t txt_2 = {
.key = "key2",
.value = NULL,
.value_len = 0,
.next = NULL,
};
// Simulate TXT item with binary value
static const mdns_txt_linked_item_t txt_3 = {
.key = "key2",
.value = (char *)binary_arr,
.value_len = sizeof(binary_arr),
.next = NULL,
};
size_t baseline = mdns_mem_get_allocation_counts();
// Scenario 1: Add new TXT record
mdns_txt_linked_item_t *test1_txt1 = clone_txt(&txt_1);
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, test1_txt1, TXT_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_TXT, s_observer.records);
TEST_ASSERT_TRUE(s_observer.txt_present);
TEST_ASSERT_EQUAL_UINT32(TXT_TTL, s_observer.txt_ttl);
TEST_ASSERT_EQUAL_STRING(INSTANCE, s_observer.instance);
TEST_ASSERT_EQUAL_STRING(SERVICE, s_observer.service);
TEST_ASSERT_EQUAL_STRING(PROTO, s_observer.proto);
TEST_ASSERT_EQUAL_size_t(1, s_observer.txt_count);
// Scenario 2: Update the same service cache with identical TXT item and TTL
mdns_txt_linked_item_t *test2_txt1 = clone_txt(&txt_1);
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, test2_txt1, TXT_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// Scenario 3: Update the same service cache with different TXT item and TTL
mdns_txt_linked_item_t *test3_txt1 = clone_txt(&txt_1);
mdns_txt_linked_item_t *test3_txt2 = clone_txt(&txt_2);
test3_txt1->next = test3_txt2;
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, test3_txt1, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT32(240, s_observer.txt_ttl);
TEST_ASSERT_EQUAL_size_t(2, s_observer.txt_count);
// Scenario 4: Update the same service cache with a TXT item different in value
mdns_txt_linked_item_t *test4_txt1 = clone_txt(&txt_1);
mdns_txt_linked_item_t *test4_txt3 = clone_txt(&txt_3);
test4_txt1->next = test4_txt3;
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, test4_txt1, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(2, s_observer.txt_count);
TEST_ASSERT_TRUE(find_txt_in_txt_list(s_observer.txt, &txt_3));
// Scenario 5: Remove cache with TXT TTL=0
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, NULL, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
assert_memory(baseline);
}
static void test_cache_addr_add_repeat_update_remove(void)
{
static const uint32_t ip6_addr[4] = {0x20010db8, 0, 0, 0x00000001};
static const uint32_t ip4_addr_1 = 0x0101A8C0;
static const uint32_t ip4_addr_2 = 0x0201A8C0;
const esp_ip_addr_t addr_1 = make_ipv4(ip4_addr_1);
const esp_ip_addr_t addr_2 = make_ipv4(ip4_addr_2);
const esp_ip_addr_t addr_3 = make_ipv6(ip6_addr);
// Because currently `mdns_priv_cache_process_sync()` only notifies browses, we need to setup an SRV record to establish a service cache.
// So that `browse_update_callback()` stub can update `s_observer`.
(void)mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL);
size_t baseline = mdns_mem_get_allocation_counts();
// Scenario 1: Add new A record
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_1, ADDR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_ADDR | MDNS_CACHE_RECORD_SRV, s_observer.records);
TEST_ASSERT_NOT_NULL(s_observer.addr);
TEST_ASSERT_EQUAL_UINT32(ADDR_TTL, s_observer.addr->ttl);
TEST_ASSERT_EQUAL_UINT32(ip4_addr_1, s_observer.addr->addr.u_addr.ip4.addr);
TEST_ASSERT_EQUAL_STRING(HOSTNAME, s_observer.hostname);
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
// Scenario 2: Update the same service cache with identical A record
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_1, ADDR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// Scenario 3: Update the A record with new TTL
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_1, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT32(240, s_observer.addr->ttl);
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
// Scenario 4: Add new A record
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_2, ADDR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(2, s_observer.address_count);
// Scenario 5: Add new AAAA record
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_3, ADDR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(4, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(3, s_observer.address_count);
// Scenario 6: Remove all addresses with TTL=0
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_1, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(5, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(2, s_observer.address_count);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_2, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(6, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V6, HOSTNAME,
&addr_3, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(7, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
assert_memory(baseline);
// Scenario 7: `mdns_priv_cache_update_existing_addr()` cannot create new entry
size_t baseline_s7 = mdns_mem_get_allocation_counts();
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, &addr_1, ADDR_TTL));
assert_memory(baseline_s7);
(void)mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, SRV_TTL);
baseline_s7 = mdns_mem_get_allocation_counts();
// `mdns_priv_cache_update_existing_addr()` only updates if a consumer is subscribing to a service under the same entry
mdns_priv_browse_has_service_IgnoreAndReturn(true);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, &addr_1, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(8, s_observer.update_calls);
mdns_priv_browse_has_service_IgnoreAndReturn(false);
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, &addr_1, 300));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(8, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT32(240, s_observer.addr->ttl);
mdns_priv_browse_has_service_IgnoreAndReturn(true);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_existing_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
HOSTNAME, &addr_1, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(9, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
assert_memory(baseline_s7);
}
static void test_cache_record_order_and_result_projection(void)
{
const mdns_cache_record_type_t orders[][4] = {
{ MDNS_CACHE_RECORD_PTR, MDNS_CACHE_RECORD_SRV, MDNS_CACHE_RECORD_TXT, MDNS_CACHE_RECORD_ADDR },
{ MDNS_CACHE_RECORD_PTR, MDNS_CACHE_RECORD_ADDR, MDNS_CACHE_RECORD_TXT, MDNS_CACHE_RECORD_SRV },
};
for (size_t i = 0; i < sizeof(orders) / sizeof(orders[0]); i++) {
mdns_priv_cache_clear();
reset_observer();
for (size_t j = 0; j < sizeof(orders[i]) / sizeof(orders[i][0]); j++) {
mdns_cache_update_result_t status = update_test_record(orders[i][j], false);
TEST_ASSERT_TRUE(status == MDNS_CACHE_ADDED || status == MDNS_CACHE_UPDATED);
}
// All record updates are delivered in a single notification
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
assert_observed_complete_service();
mdns_result_t *result = project_observed_service();
assert_complete_result(result);
mdns_query_results_free(result);
}
}
static void test_cache_service_record_goodbyes(void)
{
insert_complete_service();
mdns_priv_cache_process_sync();
assert_observed_complete_service();
reset_observer();
// Remove TXT while preserving SRV and addresses.
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_TXT, true));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_TXT, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_TRUE(s_observer.srv_present);
TEST_ASSERT_FALSE(s_observer.txt_present);
mdns_result_t *result = project_observed_service();
TEST_ASSERT_NULL(result->txt);
TEST_ASSERT_NULL(result->txt_value_len);
TEST_ASSERT_EQUAL_size_t(0, result->txt_count);
TEST_ASSERT_EQUAL_STRING(HOSTNAME, result->hostname);
TEST_ASSERT_EQUAL_UINT16(SRV_PORT, result->port);
TEST_ASSERT_NOT_NULL(result->addr);
mdns_query_results_free(result);
// Remove SRV. Cached addresses remain but must not appear in the result.
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_SRV, true));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_FALSE(s_observer.srv_present);
TEST_ASSERT_NOT_NULL(s_observer.addr);
result = project_observed_service();
TEST_ASSERT_NULL(result->hostname);
TEST_ASSERT_EQUAL_UINT16(0, result->port);
TEST_ASSERT_NULL(result->addr);
mdns_query_results_free(result);
// Remove the remaining address without removing PTR.
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, update_test_record(MDNS_CACHE_RECORD_ADDR, true));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_ADDR, s_observer.records);
TEST_ASSERT_NULL(s_observer.addr);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.ptr_ttl);
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
}
static void test_cache_expiry_extend_and_notify(void)
{
static const mdns_txt_linked_item_t txt = {
.key = "key",
.value = "value",
.value_len = 5,
.next = NULL,
};
const esp_ip_addr_t addr = make_ipv4(0x0101A8C0);
size_t baseline = mdns_mem_get_allocation_counts();
// Scenario 1: Extend PTR TTL and test records expire one by one.
// Initial state: t = 0s
insert_complete_service();
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_A, 160));
mdns_priv_cache_process_sync();
assert_observed_complete_service();
reset_observer();
// t = 60s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(60 * MDNS_US_PER_SEC));
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
// PTR, SRV, TXT, ADDR will be expired at t = 180s, 130s, 140s, 150s respectively.
// subtype A will expire at t = 160s.
// t = 120s: Base PTR survives the original expiration time.
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(60 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
// t = 129s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(0, s_observer.update_calls);
// t = 130s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_FALSE(s_observer.srv_present);
TEST_ASSERT_TRUE(s_observer.txt_present);
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
// t = 139s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// t = 140s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_TXT, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_FALSE(s_observer.txt_present);
TEST_ASSERT_EQUAL_size_t(0, s_observer.txt_count);
TEST_ASSERT_EQUAL_size_t(1, s_observer.address_count);
// t = 149s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
// t = 150s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_ADDR, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
// t = 159s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(9 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
// t = 160s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
TEST_ASSERT_EQUAL_STRING(SUBTYPE_A, s_observer.goodbye_subtype);
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
// t = 179s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(19 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
// t = 180s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.goodbye_calls);
TEST_ASSERT_EQUAL_STRING("", s_observer.goodbye_subtype);
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
assert_memory(baseline);
// Scenario 2: Records expire at the same time.
// Initial state: t = 0s
mdns_priv_cache_clear();
mdns_test_clock_reset();
reset_observer();
baseline = mdns_mem_get_allocation_counts();
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, update_test_record(MDNS_CACHE_RECORD_PTR, false));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_srv(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME, INSTANCE,
SERVICE, PROTO, SRV_PRIORITY, SRV_WEIGHT, SRV_PORT, 60));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_txt(test_netif_a(), MDNS_IP_PROTOCOL_V4, INSTANCE,
SERVICE, PROTO, clone_txt(&txt), 60));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_addr(test_netif_a(), MDNS_IP_PROTOCOL_V4, HOSTNAME,
&addr, 60));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// t = 59s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(59 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// t = 60s, SRV, TXT, ADDR will be expired at the same time.
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(1 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(0, s_observer.goodbye_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SRV | MDNS_CACHE_RECORD_TXT | MDNS_CACHE_RECORD_ADDR, s_observer.records);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_FALSE(s_observer.srv_present);
TEST_ASSERT_FALSE(s_observer.txt_present);
TEST_ASSERT_EQUAL_size_t(0, s_observer.address_count);
TEST_ASSERT_EQUAL_size_t(0, s_observer.txt_count);
// t = 120s
TEST_ASSERT_TRUE(mdns_test_clock_advance_us(60 * MDNS_US_PER_SEC));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
assert_memory(baseline);
}
static void test_cache_subtype_add_repeat_update_remove(void)
{
size_t baseline = mdns_mem_get_allocation_counts();
// Scenario 1: Add a subtype without establishing a base PTR.
TEST_ASSERT_EQUAL(MDNS_CACHE_ADDED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_A, PTR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT8(MDNS_CACHE_RECORD_SUBTYPE, s_observer.records);
TEST_ASSERT_FALSE(s_observer.ptr_present);
TEST_ASSERT_NOT_NULL(s_observer.subtype);
TEST_ASSERT_EQUAL_STRING(SUBTYPE_A, s_observer.subtype->subtype);
TEST_ASSERT_EQUAL_UINT32(PTR_TTL, s_observer.subtype->ttl);
TEST_ASSERT_EQUAL_size_t(1, s_observer.subtype_count);
// Scenario 2: Repeating the subtype does not add a duplicate or notify again.
TEST_ASSERT_EQUAL(MDNS_CACHE_NO_CHANGE, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_A, PTR_TTL));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.update_calls);
// Scenario 3: Changing the TTL notifies the browser.
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_A, 240));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.update_calls);
TEST_ASSERT_EQUAL_UINT32(240, s_observer.subtype->ttl);
// Scenario 4: Base PTR/specific subtype update/removal will not notify others
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, PTR_TTL));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_B, 180));
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
TEST_ASSERT_TRUE(s_observer.ptr_present);
TEST_ASSERT_EQUAL_size_t(2, s_observer.subtype_count);
TEST_ASSERT_EQUAL_UINT32(s_observer.ptr_ttl, PTR_TTL);
TEST_ASSERT_TRUE(assert_subtype_in_list(s_observer.subtype, SUBTYPE_A, 240));
TEST_ASSERT_TRUE(assert_subtype_in_list(s_observer.subtype, SUBTYPE_B, 180));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, NULL, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(1, s_observer.goodbye_calls);
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
TEST_ASSERT_FALSE(s_observer.ptr_present);
TEST_ASSERT_EQUAL_size_t(2, s_observer.subtype_count);
TEST_ASSERT_EQUAL_STRING("", s_observer.goodbye_subtype);
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_A, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(2, s_observer.goodbye_calls);
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
// Goodbye captures the last subtype before removal; no update follows cache deletion.
TEST_ASSERT_EQUAL_size_t(2, s_observer.subtype_count);
TEST_ASSERT_EQUAL_STRING(SUBTYPE_A, s_observer.goodbye_subtype);
TEST_ASSERT_TRUE(assert_subtype_in_list(s_observer.subtype, SUBTYPE_B, 180));
TEST_ASSERT_EQUAL(MDNS_CACHE_UPDATED, mdns_priv_cache_update_ptr(test_netif_a(), MDNS_IP_PROTOCOL_V4,
INSTANCE, SERVICE, PROTO, SUBTYPE_B, 0));
mdns_priv_cache_remove_expired_records(esp_timer_get_time());
mdns_priv_cache_process_sync();
TEST_ASSERT_EQUAL_size_t(3, s_observer.goodbye_calls);
TEST_ASSERT_EQUAL_size_t(3, s_observer.update_calls);
// Goodbye captures the last subtype before removal; no update follows cache deletion.
TEST_ASSERT_EQUAL_size_t(1, s_observer.subtype_count);
TEST_ASSERT_EQUAL_STRING(SUBTYPE_B, s_observer.goodbye_subtype);
assert_memory(baseline);
}
void run_unity_tests(void)
{
UNITY_BEGIN();
RUN_TEST(test_cache_ptr_add_repeat_update_remove);
RUN_TEST(test_cache_srv_add_repeat_update_remove);
RUN_TEST(test_cache_txt_add_repeat_update_remove);
RUN_TEST(test_cache_addr_add_repeat_update_remove);
RUN_TEST(test_cache_record_order_and_result_projection);
RUN_TEST(test_cache_service_record_goodbyes);
RUN_TEST(test_cache_expiry_extend_and_notify);
RUN_TEST(test_cache_subtype_add_repeat_update_remove);
UNITY_END();
}
@@ -0,0 +1,6 @@
# Test mdns_cache in isolation. Browse-facing functions are mocked.
set(MOCK_FILES
"mdns_browser"
)
list(APPEND SOURCES unity/${UNIT_TESTS}/test_cache.c)
@@ -0,0 +1,244 @@
/*
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include "unity.h"
#include "create_test_packet.h"
#include "unity_main.h"
#include "mock_mdns_pcb.h"
#include "mock_mdns_send.h"
#include "mdns_private.h"
#include "mdns_utils.h"
#include "mdns_responder.h"
typedef struct {
size_t count;
char hostname[MDNS_NAME_BUF_LEN];
} hostname_changed_callback_context_t;
static void hostname_changed_callback(const char *hostname, void *arg)
{
hostname_changed_callback_context_t *context = arg;
++context->count;
strncpy(context->hostname, hostname, sizeof(context->hostname));
context->hostname[sizeof(context->hostname) - 1] = '\0';
}
static void test_hostname_changed_callback(void)
{
hostname_changed_callback_context_t context = { 0 };
TEST_ASSERT_EQUAL(ESP_OK, mdns_register_hostname_changed_callback(hostname_changed_callback, &context));
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname"));
TEST_ASSERT_EQUAL_UINT(1, context.count);
TEST_ASSERT_EQUAL_STRING("renamed-hostname", context.hostname);
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname"));
TEST_ASSERT_EQUAL_UINT(1, context.count);
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname-again"));
TEST_ASSERT_EQUAL_UINT(2, context.count);
TEST_ASSERT_EQUAL_STRING("renamed-hostname-again", context.hostname);
}
static void test_mdns_hostname_queries(void)
{
// Define the queries for test4.local and test.local
mdns_test_query_t queries[] = {
{ "test4.local", 1, 1 }, // A record for test4.local
{ "test.local", 1, 1 } // A record for test.local
};
// Create and send the packet
size_t packet_len;
uint8_t* packet = create_mdns_test_packet(
queries, 2, // Queries
NULL, 0, // No answers
NULL, 0, // No additional records
&packet_len
);
send_test_packet_multiple(packet, packet_len);
}
// Example of a more complex test with answers and additional records
static void test_mdns_with_answers(void)
{
// Define a query for _http._tcp.local PTR record
mdns_test_query_t queries[] = {
{ "_http._tcp.local", 12, 1 } // PTR record
};
// Example data for a PTR record (simplified)
uint8_t ptr_data[200];
size_t ptr_data_len = encode_dns_name(ptr_data, "test._http._tcp.local");
// Define an answer for the PTR record
mdns_test_answer_t answers[] = {
{ "_http._tcp.local", 12, 1, 120, ptr_data_len, ptr_data }
};
// Create and send the packet
size_t packet_len;
uint8_t* packet = create_mdns_test_packet(
queries, 1, // Single query
answers, 1, // Single answer
NULL, 0, // No additional records
&packet_len
);
send_test_packet_multiple(packet, packet_len);
}
/*
* Regression test for fa84ee6: packets shorter than MDNS_HEAD_LEN (12) must
* be rejected before reading the additional RR count at offset 10.
* An 11-byte AFL input (id_000005) previously passed the old check and read
* one byte past the RX buffer.
*/
static void test_mdns_reject_short_packet(void)
{
static const uint8_t eleven_byte_packet[] = {
0x00, 0xc0, 0x32, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x54, 0x01
};
for (size_t len = 0; len < MDNS_HEAD_LEN; len++) {
const uint8_t *data = eleven_byte_packet;
send_packet(true, true, (uint8_t *)data, len);
send_packet(true, false, (uint8_t *)data, len);
send_packet(false, true, (uint8_t *)data, len);
send_packet(false, false, (uint8_t *)data, len);
}
}
static void test_mdns_subtype_any_question_is_not_a_probe(void)
{
mdns_test_query_t queries[] = {
{ "subtype._sub._http._tcp.local", MDNS_TYPE_ANY, 1 },
};
size_t packet_len;
uint8_t *packet = create_mdns_test_packet(queries, 1, NULL, 0, NULL, 0, &packet_len);
send_test_packet_multiple(packet, packet_len);
}
static void test_mdns_reject_misplaced_sub_label(void)
{
uint8_t fqdn[MDNS_NAME_BUF_LEN] = {};
mdns_name_t name = {};
size_t fqdn_len = encode_dns_name(fqdn, "instance._http._sub._tcp.local");
TEST_ASSERT_NOT_NULL(mdns_utils_parse_fqdn(fqdn, fqdn, &name, fqdn_len));
TEST_ASSERT_TRUE(name.invalid);
fqdn_len = encode_dns_name(fqdn, "subtype._sub._http._tcp.local");
TEST_ASSERT_NOT_NULL(mdns_utils_parse_fqdn(fqdn, fqdn, &name, fqdn_len));
TEST_ASSERT_FALSE(name.invalid);
TEST_ASSERT_TRUE(name.sub);
}
static void mdns_priv_create_answer_from_parsed_packet_Callback(mdns_parsed_packet_t* parsed_packet, int cmock_num_calls)
{
printf("callback\n");
if (parsed_packet->questions && parsed_packet->questions->sub && parsed_packet->questions->type == MDNS_TYPE_ANY) {
TEST_ASSERT_FALSE(parsed_packet->probe);
}
}
static size_t count_registered_services(void)
{
size_t count = 0;
for (mdns_srv_item_t *a = mdns_priv_get_services(); a; a = a->next) {
count++;
}
return count;
}
static size_t s_parsed_question_count;
static size_t s_parsed_sdptr_count;
static void discovery_dedup_answer_callback(mdns_parsed_packet_t *parsed_packet, int cmock_num_calls)
{
(void)cmock_num_calls;
s_parsed_question_count = 0;
s_parsed_sdptr_count = 0;
TEST_ASSERT_TRUE(parsed_packet->discovery);
for (mdns_parsed_question_t *q = parsed_packet->questions; q; q = q->next) {
s_parsed_question_count++;
if (q->type == MDNS_TYPE_SDPTR) {
s_parsed_sdptr_count++;
}
}
}
/*
* Duplicate _services._dns-sd._udp.local PTR questions must expand the service
* list only once. Without the guard, each copy allocates one SDPTR question per
* registered service (heap amplification).
*/
static void test_mdns_discovery_questions_deduped(void)
{
size_t service_count = count_registered_services();
TEST_ASSERT_GREATER_THAN(0, service_count);
mdns_test_query_t queries[] = {
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
{ "_services._dns-sd._udp.local", MDNS_TYPE_PTR, 1 },
};
mdns_priv_create_answer_from_parsed_packet_Stub(discovery_dedup_answer_callback);
size_t packet_len;
uint8_t *packet = create_mdns_test_packet(queries, 4, NULL, 0, NULL, 0, &packet_len);
TEST_ASSERT_NOT_NULL(packet);
send_packet(true, true, packet, packet_len);
free(packet);
TEST_ASSERT_EQUAL(service_count, s_parsed_sdptr_count);
TEST_ASSERT_EQUAL(service_count, s_parsed_question_count);
mdns_priv_create_answer_from_parsed_packet_Stub(mdns_priv_create_answer_from_parsed_packet_Callback);
}
void setup_cmock(void)
{
mdns_priv_probe_all_pcbs_CMockIgnore();
mdns_priv_pcb_announce_CMockIgnore();
mdns_priv_pcb_send_bye_service_CMockIgnore();
mdns_priv_pcb_check_probing_services_CMockIgnore();
mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
mdns_priv_clear_tx_queue_CMockIgnore();
mdns_priv_remove_scheduled_service_packets_CMockIgnore();
mdns_priv_create_answer_from_parsed_packet_Stub(mdns_priv_create_answer_from_parsed_packet_Callback);
}
void run_unity_tests(void)
{
UNITY_BEGIN();
// Run hostname queries test
RUN_TEST(test_mdns_hostname_queries);
RUN_TEST(test_hostname_changed_callback);
// Run test with answers
RUN_TEST(test_mdns_with_answers);
RUN_TEST(test_mdns_reject_short_packet);
RUN_TEST(test_mdns_subtype_any_question_is_not_a_probe);
RUN_TEST(test_mdns_reject_misplaced_sub_label);
RUN_TEST(test_mdns_discovery_questions_deduped);
UNITY_END();
}
@@ -0,0 +1,7 @@
# Testing mDNS receiver, so mocking pbb and send
set(MOCK_FILES
"mdns_pcb"
"mdns_send"
)
list(APPEND SOURCES unity/${UNIT_TESTS}/test_receiver.c)
@@ -0,0 +1,58 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include "unity.h"
#include "unity_main.h"
#include "mock_mdns_pcb.h"
#include "mdns_send.h"
#include "mdns_mem_caps_test.h"
void setup_cmock(void)
{
mdns_priv_probe_all_pcbs_CMockIgnore();
mdns_priv_pcb_announce_CMockIgnore();
mdns_priv_pcb_send_bye_service_CMockIgnore();
mdns_priv_pcb_check_probing_services_CMockIgnore();
mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
}
static void test_dispatch_tx_packet(void)
{
mdns_tx_packet_t p = {};
mdns_priv_dispatch_tx_packet(&p);
}
static void test_cleanup_tx_action_of_scheduled_packet(void)
{
size_t baseline = mdns_mem_get_allocation_counts();
mdns_tx_packet_t *packet = mdns_priv_alloc_packet(0, MDNS_IP_PROTOCOL_V4);
TEST_ASSERT_NOT_NULL(packet);
mdns_priv_send_after(packet, 0);
// State left by mdns_priv_send_packets() for a due packet whose action has not run yet:
// the packet is marked as queued and stays linked in the TX queue
packet->queued = true;
mdns_action_t action = { .type = ACTION_TX_HANDLE };
action.data.tx_handle.packet = packet;
// mdns_free() cleans up the pending actions first, then clears the TX queue
mdns_priv_send_action(&action, ACTION_CLEANUP);
mdns_priv_clear_tx_queue();
TEST_ASSERT_EQUAL_size_t(baseline, mdns_mem_get_allocation_counts());
}
void run_unity_tests(void)
{
UNITY_BEGIN();
// Run hostname queries test
RUN_TEST(test_dispatch_tx_packet);
RUN_TEST(test_cleanup_tx_action_of_scheduled_packet);
UNITY_END();
}
@@ -0,0 +1,6 @@
# Testing mDNS sender, need to mock pbb
set(MOCK_FILES
"mdns_pcb"
)
list(APPEND SOURCES unity/${UNIT_TESTS}/test_sender.c)
@@ -0,0 +1,67 @@
set(UNITY_DIR "$ENV{IDF_PATH}/components/unity")
set(CMOCK_DIR "$ENV{IDF_PATH}/components/cmock")
include_directories(${UNITY_DIR}/unity/src)
add_definitions(-DENABLE_UNIT_TESTS)
# Use ruby command directly instead of looking for ruby.exe
find_program(RUBY_EXECUTABLE ruby)
if(NOT RUBY_EXECUTABLE)
message(FATAL_ERROR "Ruby is required for CMock but was not found!")
endif()
include(unity/${UNIT_TESTS}/unit_test.cmake)
# Verify headers exist and create mock commands for each
foreach(mock_file ${MOCK_FILES})
set(header_path "${COMPONENT_DIR}/private_include/${mock_file}.h")
if(NOT EXISTS ${header_path})
message(FATAL_ERROR "Cannot find ${mock_file}.h at ${header_path}")
endif()
list(APPEND MOCK_OUTPUTS
${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.c
${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.h
)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.c
${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.h
COMMAND ${RUBY_EXECUTABLE}
${CMOCK_DIR}/CMock/lib/cmock.rb
-o${CMAKE_CURRENT_SOURCE_DIR}/unity/cmock_config.yml
${header_path}
DEPENDS ${header_path}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating mock for ${mock_file}.h"
)
endforeach()
# Include CMock headers
include_directories(
${CMOCK_DIR}/CMock/src
${CMAKE_CURRENT_BINARY_DIR}/mocks
${UNITY_DIR}/unity/src
${UNITY_DIR}/include
unity
)
# Create directory for generated mocks
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/mocks)
foreach(mock_file ${MOCK_FILES})
list(REMOVE_ITEM SOURCES ${MDNS_DIR}/${mock_file}.c)
endforeach()
# Add test-related sources
list(APPEND SOURCES
${UNITY_DIR}/unity/src/unity.c
${CMOCK_DIR}/CMock/src/cmock.c
unity/unity_main.c
unity/create_test_packet.c
)
# Add all generated mock files
foreach(mock_file ${MOCK_FILES})
list(APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/mocks/mock_${mock_file}.c)
endforeach()
@@ -0,0 +1,162 @@
/*
* SPDX-FileCopyrightText: 2025-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include "esp_err.h"
#include "unity.h"
#include "mdns_receive.h"
#include "mdns_responder.h"
#include "mdns_mem_caps.h"
#include "mdns_test_clock.h"
// Weak set-up and tear-down functions that can be overridden by unit tests
void __attribute__((weak)) mdns_test_set_up(void)
{
}
void __attribute__((weak)) mdns_test_tear_down(void)
{
}
void setUp(void)
{
mdns_test_set_up();
}
void tearDown(void)
{
mdns_test_tear_down();
}
// Sample test case - update based on the actual functionality in mdns_receive.c
void test_init(void)
{
}
esp_err_t mdns_packet_push(esp_ip_addr_t *addr, int port, mdns_if_t tcpip_if, uint8_t*data, size_t len);
mdns_search_once_t *s_a, *s_aaaa, *s_ptr, *s_srv, *s_txt;
void init_responder(void)
{
mdns_ip_addr_t addr = { .addr = { .u_addr = ESP_IPADDR_TYPE_V4 } };
addr.addr.u_addr.ip4.addr = 0x11111111;
mdns_txt_item_t txt[4] = {
{"board", "esp32"},
{"tcp_check", "no"},
{"ssh_upload", "no"},
{"auth_upload", "no"}
};
mdns_priv_responder_init();
mdns_hostname_set("test");
mdns_instance_name_set("test2");
mdns_delegate_hostname_add("test3", NULL);
mdns_delegate_hostname_add("test4", &addr);
mdns_service_add("inst1", "_http", "_tcp", 80, txt, 4);
mdns_service_subtype_add_for_host("inst1", "_http", "_tcp", "test", "subtype");
mdns_service_add("inst2", "_http", "_tcp", 80, txt, 1);
mdns_service_subtype_add_for_host("inst2", "_http", "_tcp", "test", "subtype3");
mdns_service_add("inst3", "_http", "_tcp", 80, NULL, 0);
mdns_service_add_for_host("deleg1", "_http", "_tcp", "test3", 80, txt, 2);
mdns_service_add_for_host(NULL, "_http", "_tcp", "test4", 80, txt, 2);
mdns_service_add(NULL, "_scanner", "_tcp", 80, NULL, 0);
mdns_service_add("inst5", "_scanner", "_tcp", 80, NULL, 0);
mdns_service_add("inst6", "_http", "_tcp", 80, NULL, 0);
mdns_service_add("inst7", "_sleep", "_udp", 80, NULL, 0);
s_a = mdns_query_async_new("host_name", NULL, NULL, MDNS_TYPE_A, 1000, 1, NULL);
s_aaaa = mdns_query_async_new("host_name2", NULL, NULL, MDNS_TYPE_AAAA, 1000, 1, NULL);
s_ptr = mdns_query_async_new("minifritz", "_http", "_tcp", MDNS_TYPE_PTR, 1000, 1, NULL);
s_srv = mdns_query_async_new("fritz", "_http", "_tcp", MDNS_TYPE_SRV, 1000, 1, NULL);
s_txt = mdns_query_async_new("fritz", "_http", "_tcp", MDNS_TYPE_TXT, 1000, 1, NULL);
}
void deinit_responder(void)
{
mdns_query_async_delete(s_a);
mdns_query_async_delete(s_aaaa);
mdns_query_async_delete(s_ptr);
mdns_query_async_delete(s_srv);
mdns_query_async_delete(s_txt);
mdns_service_remove_all();
mdns_priv_responder_free();
}
void send_packet(bool ip4, bool mdns_port, uint8_t*data, size_t len)
{
esp_ip_addr_t addr4 = ESP_IP4ADDR_INIT(192, 168, 1, 1);
esp_ip_addr_t addr6 = ESP_IP6ADDR_INIT(0x000002ff, 0, 0, 0xfe800000);
esp_ip_addr_t *addr = ip4 ? &addr4 : &addr6;
int port = mdns_port ? 53 : 5353;
if (mdns_packet_push(addr, port, 0, data, len) != ESP_OK) {
printf("Failed to push packet\n");
}
}
// Helper function to send a test packet with different configurations and clean up
void send_test_packet_multiple(uint8_t* packet, size_t packet_len)
{
if (packet) {
// Test with different packet configurations
send_packet(true, true, packet, packet_len);
send_packet(true, false, packet, packet_len);
send_packet(false, true, packet, packet_len);
send_packet(false, false, packet, packet_len);
// Free the packet
free(packet);
} else {
printf("Failed to create test packet\n");
}
}
void test_mdns_receive_from_file(const char* filename)
{
uint8_t buf[1460];
FILE *file = fopen(filename, "r");
TEST_ASSERT_NOT_NULL_MESSAGE(file, "Failed to open test packet file");
size_t len = fread(buf, 1, 1460, file);
fclose(file);
// Test with different packet configurations
send_packet(true, true, buf, len);
send_packet(true, false, buf, len);
send_packet(false, true, buf, len);
send_packet(false, false, buf, len);
// Add assertions here based on expected behavior
// For example:
// TEST_ASSERT_EQUAL(expected_result, actual_result);
}
void run_unity_tests(void);
void setup_cmock(void);
int main(int argc, char **argv)
{
if (argc >= 2 && strcmp(argv[1], "--test") == 0) {
mdns_test_clock_reset();
setup_cmock();
init_responder();
run_unity_tests();
// Propagate Unity assertion failures to CTest through the process exit code.
const int test_status = Unity.TestFailures == 0U ? 0 : 1;
deinit_responder();
return test_status;
}
printf("Unit test configuration: run with --test argument\n");
return 1;
}
@@ -0,0 +1,10 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#pragma once
#include <stdbool.h>
void send_packet(bool ip4, bool mdns_port, uint8_t*data, size_t len);
void send_test_packet_multiple(uint8_t* packet, size_t packet_len);