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:
1 parent
47f4eba0d6
commit
4cd3bc7973
294 files changed
+48954
-301
No files matched your search
@@ -0,0 +1,16 @@
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
if(${IDF_TARGET} STREQUAL "linux")
|
||||
set(EXTRA_COMPONENT_DIRS "../../../../common_components/linux_compat")
|
||||
set(COMPONENTS main)
|
||||
endif()
|
||||
|
||||
project(mdns_host)
|
||||
|
||||
# Enable sanitizers only without console (we'd see some leaks on argtable when console exits)
|
||||
if(NOT CONFIG_TEST_CONSOLE AND CONFIG_IDF_TARGET_LINUX)
|
||||
idf_component_get_property(mdns mdns COMPONENT_LIB)
|
||||
target_link_options(${mdns} INTERFACE -fsanitize=address -fsanitize=undefined)
|
||||
endif()
|
||||
@@ -0,0 +1,33 @@
|
||||
# Setup dummy network interfaces
|
||||
|
||||
Note: Set two addresses so we could use one as source and another as destination
|
||||
```
|
||||
sudo ip link add eth2 type dummy
|
||||
sudo ip addr add 192.168.1.200/24 dev eth2
|
||||
sudo ip addr add 192.168.1.201/24 dev eth2
|
||||
sudo ip link set eth2 up
|
||||
sudo ifconfig eth2 multicast
|
||||
```
|
||||
|
||||
# Dig on a specified interface
|
||||
|
||||
```
|
||||
dig +short -b 192.168.1.200 -p 5353 @224.0.0.251 myesp.local
|
||||
```
|
||||
|
||||
or a reverse query:
|
||||
```
|
||||
dig +short -b 192.168.2.200 -p 5353 @224.0.0.251 -x 192.168.1.200
|
||||
```
|
||||
|
||||
# Run avahi to browse services
|
||||
|
||||
Avahi needs the netif to have the "multicast" flag set
|
||||
|
||||
```bash
|
||||
david@david-comp:~/esp/idf (feature/mdns_networking_socket)$ avahi-browse -a -r -p
|
||||
+;eth2;IPv6;myesp-service2;Web Site;local
|
||||
+;eth2;IPv4;myesp-service2;Web Site;local
|
||||
=;eth2;IPv6;myesp-service2;Web Site;local;myesp.local;192.168.1.200;80;"board=esp32" "u=user" "p=password"
|
||||
=;eth2;IPv4;myesp-service2;Web Site;local;myesp.local;192.168.1.200;80;"board=esp32" "u=user" "p=password"
|
||||
```
|
||||
@@ -0,0 +1,314 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
|
||||
# SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
"""Mock Bonjour-style mDNS responder for browse host tests.
|
||||
|
||||
Default response order mimics Bonjour browse answers:
|
||||
Answer: PTR
|
||||
Additional: A, AAAA, SRV, TXT
|
||||
|
||||
Use ``--goodbye-after N`` to answer the first N browse queries normally and then
|
||||
reply with a standalone PTR TTL=0 (Bonjour service removal).
|
||||
|
||||
Use ``--unsolicited-goodbye-after N`` to answer N browse queries normally and then
|
||||
multicast an unsolicited PTR TTL=0 announcement (keeps the active browse item).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import logging
|
||||
import socket
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
import dns.flags
|
||||
import dns.message
|
||||
import dns.name
|
||||
import dns.rdataclass
|
||||
import dns.rdatatype
|
||||
import dns.rrset
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
MDNS_ADDR = '224.0.0.251'
|
||||
MDNS_PORT = 5353
|
||||
|
||||
DEFAULTS = {
|
||||
'service': '_v301test',
|
||||
'proto': '_tcp',
|
||||
'instance': 'v301instance',
|
||||
'hostname': 'v301host',
|
||||
'port': 8080,
|
||||
'ipv4': '192.168.1.100',
|
||||
'ipv6': 'fe80::1234:5678:9abc:def0',
|
||||
'txt': 'vdv301=test',
|
||||
}
|
||||
|
||||
|
||||
def _fqdn(*labels: str) -> str:
|
||||
return '.'.join(labels) + '.local.'
|
||||
|
||||
|
||||
def build_goodbye_response(
|
||||
query: dns.message.Message,
|
||||
*,
|
||||
service: str,
|
||||
proto: str,
|
||||
instance: str,
|
||||
) -> dns.message.Message:
|
||||
service_name = _fqdn(service, proto)
|
||||
instance_name = _fqdn(instance, service, proto)
|
||||
|
||||
response = dns.message.make_response(query)
|
||||
response.flags |= dns.flags.AA
|
||||
response.answer.append(
|
||||
dns.rrset.from_text(service_name, 0, dns.rdataclass.IN, dns.rdatatype.PTR, instance_name)
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
def build_unsolicited_goodbye(
|
||||
*,
|
||||
service: str,
|
||||
proto: str,
|
||||
instance: str,
|
||||
) -> dns.message.Message:
|
||||
"""Build a multicast goodbye announcement (QR+AA, no question section)."""
|
||||
service_name = _fqdn(service, proto)
|
||||
instance_name = _fqdn(instance, service, proto)
|
||||
|
||||
msg = dns.message.Message(id=0)
|
||||
msg.flags = dns.flags.QR | dns.flags.AA
|
||||
msg.answer.append(
|
||||
dns.rrset.from_text(service_name, 0, dns.rdataclass.IN, dns.rdatatype.PTR, instance_name)
|
||||
)
|
||||
return msg
|
||||
|
||||
|
||||
def build_ptr_response(
|
||||
query: dns.message.Message,
|
||||
*,
|
||||
service: str,
|
||||
proto: str,
|
||||
instance: str,
|
||||
hostname: str,
|
||||
port: int,
|
||||
ipv4: str,
|
||||
ipv6: str,
|
||||
txt: str,
|
||||
srv_first: bool,
|
||||
) -> dns.message.Message:
|
||||
service_name = _fqdn(service, proto)
|
||||
instance_name = _fqdn(instance, service, proto)
|
||||
host_name = _fqdn(hostname)
|
||||
|
||||
response = dns.message.make_response(query)
|
||||
response.flags |= dns.flags.AA
|
||||
|
||||
response.answer.append(
|
||||
dns.rrset.from_text(service_name, 120, dns.rdataclass.IN, dns.rdatatype.PTR, instance_name)
|
||||
)
|
||||
|
||||
a_rr = dns.rrset.from_text(host_name, 120, dns.rdataclass.IN, dns.rdatatype.A, ipv4)
|
||||
aaaa_rr = dns.rrset.from_text(host_name, 120, dns.rdataclass.IN, dns.rdatatype.AAAA, ipv6)
|
||||
srv_rr = dns.rrset.from_text(
|
||||
instance_name,
|
||||
120,
|
||||
dns.rdataclass.IN,
|
||||
dns.rdatatype.SRV,
|
||||
f'0 0 {port} {host_name}',
|
||||
)
|
||||
txt_rr = dns.rrset.from_text(instance_name, 120, dns.rdataclass.IN, dns.rdatatype.TXT, txt)
|
||||
|
||||
if srv_first:
|
||||
response.additional = [srv_rr, txt_rr, a_rr, aaaa_rr]
|
||||
else:
|
||||
response.additional = [a_rr, aaaa_rr, srv_rr, txt_rr]
|
||||
|
||||
return response
|
||||
|
||||
|
||||
def create_socket(interface: str | None) -> socket.socket:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
|
||||
except (AttributeError, OSError):
|
||||
pass
|
||||
|
||||
if interface:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface.encode() + b'\0')
|
||||
|
||||
sock.bind(('', MDNS_PORT))
|
||||
|
||||
membership = struct.pack(
|
||||
'=4s4s',
|
||||
socket.inet_aton(MDNS_ADDR),
|
||||
socket.inet_aton('0.0.0.0'),
|
||||
)
|
||||
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, membership)
|
||||
return sock
|
||||
|
||||
|
||||
def query_matches(query: dns.message.Message, service: str, proto: str) -> bool:
|
||||
target = dns.name.from_text(_fqdn(service, proto))
|
||||
for question in query.question:
|
||||
if question.rdtype != dns.rdatatype.PTR:
|
||||
continue
|
||||
if question.name == target:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def send_mdns_response(sock: socket.socket, payload: bytes, source: tuple[str, int]) -> None:
|
||||
if source[1] == MDNS_PORT:
|
||||
destination = (MDNS_ADDR, MDNS_PORT)
|
||||
else:
|
||||
destination = source
|
||||
sock.sendto(payload, destination)
|
||||
logger.info('Sent %d byte response to %s (query source %s:%d)', len(payload), destination, *source)
|
||||
|
||||
|
||||
def send_mdns_multicast(sock: socket.socket, payload: bytes) -> None:
|
||||
destination = (MDNS_ADDR, MDNS_PORT)
|
||||
sock.sendto(payload, destination)
|
||||
logger.info('Sent %d byte multicast announcement to %s', len(payload), destination)
|
||||
|
||||
|
||||
def maybe_send_unsolicited_goodbye(sock: socket.socket, args: argparse.Namespace, response_count: int) -> bool:
|
||||
"""After N normal answers, multicast one unsolicited PTR TTL=0. Returns True if sent."""
|
||||
if args.unsolicited_goodbye_after < 0 or response_count != args.unsolicited_goodbye_after:
|
||||
return False
|
||||
if args.unsolicited_goodbye_delay > 0:
|
||||
time.sleep(args.unsolicited_goodbye_delay)
|
||||
goodbye = build_unsolicited_goodbye(
|
||||
service=args.service,
|
||||
proto=args.proto,
|
||||
instance=args.instance,
|
||||
)
|
||||
send_mdns_multicast(sock, goodbye.to_wire())
|
||||
logger.info('Multicasted unsolicited PTR goodbye (TTL=0)')
|
||||
return True
|
||||
|
||||
|
||||
def serve(args: argparse.Namespace) -> None:
|
||||
sock = create_socket(args.interface)
|
||||
order = 'SRV, TXT, A, AAAA' if args.srv_first else 'A, AAAA, SRV, TXT'
|
||||
logger.info(
|
||||
'Listening on %s:%d (%s) for PTR %s.%s.local; additional order: %s; '
|
||||
'goodbye-after=%s; unsolicited-goodbye-after=%s',
|
||||
MDNS_ADDR,
|
||||
MDNS_PORT,
|
||||
args.interface or 'all interfaces',
|
||||
args.service,
|
||||
args.proto,
|
||||
order,
|
||||
args.goodbye_after,
|
||||
args.unsolicited_goodbye_after,
|
||||
)
|
||||
|
||||
response_count = 0
|
||||
unsolicited_goodbye_sent = False
|
||||
while True:
|
||||
try:
|
||||
data, source = sock.recvfrom(9000)
|
||||
except KeyboardInterrupt:
|
||||
logger.info('Stopping responder')
|
||||
break
|
||||
|
||||
try:
|
||||
query = dns.message.from_wire(data)
|
||||
except Exception as exc: # noqa: BLE001 - ignore malformed packets
|
||||
logger.debug('Ignoring non-DNS payload from %s:%d (%s)', source[0], source[1], exc)
|
||||
continue
|
||||
|
||||
if query.flags & dns.flags.QR:
|
||||
continue
|
||||
if not query_matches(query, args.service, args.proto):
|
||||
continue
|
||||
|
||||
if args.goodbye_after >= 0 and response_count >= args.goodbye_after:
|
||||
response = build_goodbye_response(
|
||||
query,
|
||||
service=args.service,
|
||||
proto=args.proto,
|
||||
instance=args.instance,
|
||||
)
|
||||
logger.info('Answered PTR goodbye (TTL=0) from %s:%d', source[0], source[1])
|
||||
else:
|
||||
response = build_ptr_response(
|
||||
query,
|
||||
service=args.service,
|
||||
proto=args.proto,
|
||||
instance=args.instance,
|
||||
hostname=args.hostname,
|
||||
port=args.port,
|
||||
ipv4=args.ipv4,
|
||||
ipv6=args.ipv6,
|
||||
txt=args.txt,
|
||||
srv_first=args.srv_first,
|
||||
)
|
||||
logger.info('Answered PTR browse from %s:%d', source[0], source[1])
|
||||
|
||||
send_mdns_response(sock, response.to_wire(), source)
|
||||
response_count += 1
|
||||
|
||||
if not unsolicited_goodbye_sent:
|
||||
unsolicited_goodbye_sent = maybe_send_unsolicited_goodbye(sock, args, response_count)
|
||||
|
||||
|
||||
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument('--interface', default='eth0', help='Network interface for mDNS (default: eth0)')
|
||||
parser.add_argument('--service', default=DEFAULTS['service'], help='Service type without domain')
|
||||
parser.add_argument('--proto', default=DEFAULTS['proto'], help='Protocol (_tcp/_udp)')
|
||||
parser.add_argument('--instance', default=DEFAULTS['instance'], help='Service instance name')
|
||||
parser.add_argument('--hostname', default=DEFAULTS['hostname'], help='SRV target host label')
|
||||
parser.add_argument('--port', type=int, default=DEFAULTS['port'], help='SRV port')
|
||||
parser.add_argument('--ipv4', default=DEFAULTS['ipv4'], help='A record address')
|
||||
parser.add_argument('--ipv6', default=DEFAULTS['ipv6'], help='AAAA record address')
|
||||
parser.add_argument('--txt', default=DEFAULTS['txt'], help='TXT record payload')
|
||||
parser.add_argument(
|
||||
'--srv-first',
|
||||
action='store_true',
|
||||
help='Place SRV/TXT before A/AAAA (control case where browse gets addresses)',
|
||||
)
|
||||
parser.add_argument(
|
||||
'--goodbye-after',
|
||||
type=int,
|
||||
default=-1,
|
||||
help='After N normal browse responses, reply with PTR TTL=0 only (-1 disables)',
|
||||
)
|
||||
parser.add_argument(
|
||||
'--unsolicited-goodbye-after',
|
||||
type=int,
|
||||
default=-1,
|
||||
help='After N normal browse responses, multicast one unsolicited PTR TTL=0 (-1 disables)',
|
||||
)
|
||||
parser.add_argument(
|
||||
'--unsolicited-goodbye-delay',
|
||||
type=float,
|
||||
default=0.5,
|
||||
help='Seconds to wait after the Nth normal response before multicasting goodbye',
|
||||
)
|
||||
return parser.parse_args(argv)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = parse_args(argv)
|
||||
try:
|
||||
serve(args)
|
||||
except PermissionError:
|
||||
logger.error('Binding to port %d requires root or CAP_NET_BIND_SERVICE', MDNS_PORT)
|
||||
return 1
|
||||
except OSError as exc:
|
||||
logger.error('Failed to start responder: %s', exc)
|
||||
return 1
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
idf_build_get_property(idf_target IDF_TARGET)
|
||||
if(${IDF_TARGET} STREQUAL "linux")
|
||||
idf_component_register(SRCS esp_netif_linux.c
|
||||
INCLUDE_DIRS include $ENV{IDF_PATH}/components/esp_netif/include
|
||||
REQUIRES esp_event)
|
||||
else()
|
||||
idf_component_register()
|
||||
endif()
|
||||
@@ -0,0 +1,15 @@
|
||||
menu "LWIP-MOCK-CONFIG"
|
||||
|
||||
config LWIP_IPV6
|
||||
bool "Enable IPv6"
|
||||
default y
|
||||
help
|
||||
Enable/disable IPv6
|
||||
|
||||
config LWIP_IPV4
|
||||
bool "Enable IPv4"
|
||||
default y
|
||||
help
|
||||
Enable/disable IPv4
|
||||
|
||||
endmenu
|
||||
+197
@@ -0,0 +1,197 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include<stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "esp_netif.h"
|
||||
#include "esp_err.h"
|
||||
#include <string.h> //strlen
|
||||
#include <sys/socket.h>
|
||||
#include <arpa/inet.h> //inet_addr
|
||||
#include <sys/types.h>
|
||||
#include <ifaddrs.h>
|
||||
#include <net/if.h>
|
||||
#include "esp_netif_types.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
#define MAX_NETIFS 4
|
||||
|
||||
static const char *TAG = "esp_netif_linux";
|
||||
|
||||
static esp_netif_t *s_netif_list[MAX_NETIFS] = { 0 };
|
||||
|
||||
struct esp_netif_obj {
|
||||
const char *if_key;
|
||||
const char *if_desc;
|
||||
};
|
||||
|
||||
esp_netif_t *esp_netif_get_handle_from_ifkey(const char *if_key)
|
||||
{
|
||||
for (int i = 0; i < MAX_NETIFS; ++i) {
|
||||
if (s_netif_list[i] && strcmp(s_netif_list[i]->if_key, if_key) == 0) {
|
||||
return s_netif_list[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
esp_err_t esp_netif_get_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_info)
|
||||
{
|
||||
if (esp_netif == NULL) {
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
struct ifaddrs *addrs, *tmp;
|
||||
getifaddrs(&addrs);
|
||||
tmp = addrs;
|
||||
|
||||
while (tmp) {
|
||||
if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET) {
|
||||
char addr[20];
|
||||
struct sockaddr_in *pAddr = (struct sockaddr_in *) tmp->ifa_addr;
|
||||
inet_ntop(AF_INET, &pAddr->sin_addr, addr, sizeof(addr));
|
||||
if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) {
|
||||
ESP_LOGD(TAG, "AF_INET4: %s: %s\n", tmp->ifa_name, addr);
|
||||
memcpy(&ip_info->ip.addr, &pAddr->sin_addr, 4);
|
||||
}
|
||||
}
|
||||
tmp = tmp->ifa_next;
|
||||
}
|
||||
freeifaddrs(addrs);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t esp_netif_dhcpc_get_status(esp_netif_t *esp_netif, esp_netif_dhcp_status_t *status)
|
||||
{
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
int esp_netif_get_all_ip6(esp_netif_t *esp_netif, esp_ip6_addr_t if_ip6[])
|
||||
{
|
||||
if (esp_netif == NULL) {
|
||||
return 0;
|
||||
}
|
||||
struct ifaddrs *addrs, *tmp;
|
||||
int addr_count = 0;
|
||||
getifaddrs(&addrs);
|
||||
tmp = addrs;
|
||||
|
||||
while (tmp) {
|
||||
if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET6) {
|
||||
struct sockaddr_in6 *pAddr = (struct sockaddr_in6 *)tmp->ifa_addr;
|
||||
if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) {
|
||||
memcpy(&if_ip6[addr_count++], &pAddr->sin6_addr, 4 * 4);
|
||||
}
|
||||
}
|
||||
tmp = tmp->ifa_next;
|
||||
}
|
||||
|
||||
freeifaddrs(addrs);
|
||||
return addr_count;
|
||||
}
|
||||
|
||||
esp_err_t esp_netif_get_ip6_linklocal(esp_netif_t *esp_netif, esp_ip6_addr_t *if_ip6)
|
||||
{
|
||||
if (esp_netif == NULL) {
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
struct ifaddrs *addrs, *tmp;
|
||||
getifaddrs(&addrs);
|
||||
tmp = addrs;
|
||||
|
||||
while (tmp) {
|
||||
if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET6) {
|
||||
char addr[64];
|
||||
struct sockaddr_in6 *pAddr = (struct sockaddr_in6 *)tmp->ifa_addr;
|
||||
inet_ntop(AF_INET6, &pAddr->sin6_addr, addr, sizeof(addr));
|
||||
if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) {
|
||||
ESP_LOGD(TAG, "AF_INET6: %s: %s\n", tmp->ifa_name, addr);
|
||||
memcpy(if_ip6->addr, &pAddr->sin6_addr, 4 * 4);
|
||||
break;
|
||||
}
|
||||
}
|
||||
tmp = tmp->ifa_next;
|
||||
}
|
||||
|
||||
freeifaddrs(addrs);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
|
||||
int esp_netif_get_netif_impl_index(esp_netif_t *esp_netif)
|
||||
{
|
||||
if (esp_netif == NULL) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t interfaceIndex = if_nametoindex(esp_netif->if_desc);
|
||||
return interfaceIndex;
|
||||
}
|
||||
|
||||
esp_err_t esp_netif_get_netif_impl_name(esp_netif_t *esp_netif, char *name)
|
||||
{
|
||||
if (esp_netif == NULL) {
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
strcpy(name, esp_netif->if_desc);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
const char *esp_netif_get_desc(esp_netif_t *esp_netif)
|
||||
{
|
||||
if (esp_netif == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
return esp_netif->if_desc;
|
||||
}
|
||||
|
||||
esp_netif_t *esp_netif_new(const esp_netif_config_t *config)
|
||||
{
|
||||
if (esp_netif_get_handle_from_ifkey(config->base->if_key)) {
|
||||
return NULL;
|
||||
}
|
||||
esp_netif_t *netif = calloc(1, sizeof(struct esp_netif_obj));
|
||||
if (netif) {
|
||||
netif->if_desc = config->base->if_desc;
|
||||
netif->if_key = config->base->if_key;
|
||||
}
|
||||
|
||||
for (int i = 0; i < MAX_NETIFS; ++i) {
|
||||
if (s_netif_list[i] == NULL) {
|
||||
s_netif_list[i] = netif;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return netif;
|
||||
}
|
||||
|
||||
void esp_netif_destroy(esp_netif_t *esp_netif)
|
||||
{
|
||||
for (int i = 0; i < MAX_NETIFS; ++i) {
|
||||
if (s_netif_list[i] == esp_netif) {
|
||||
s_netif_list[i] = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
free(esp_netif);
|
||||
}
|
||||
|
||||
const char *esp_netif_get_ifkey(esp_netif_t *esp_netif)
|
||||
{
|
||||
return esp_netif->if_key;
|
||||
}
|
||||
|
||||
esp_err_t esp_netif_str_to_ip4(const char *src, esp_ip4_addr_t *dst)
|
||||
{
|
||||
if (src == NULL || dst == NULL) {
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
struct in_addr addr;
|
||||
if (inet_pton(AF_INET, src, &addr) != 1) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
dst->addr = addr.s_addr;
|
||||
return ESP_OK;
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
#include "esp_event.h"
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include_next "endian.h"
|
||||
@@ -0,0 +1,178 @@
|
||||
# SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
|
||||
# SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
import logging
|
||||
import re
|
||||
import socket
|
||||
import sys
|
||||
|
||||
import dns.message
|
||||
import dns.query
|
||||
import dns.rdataclass
|
||||
import dns.rdatatype
|
||||
import dns.resolver
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class DnsPythonWrapper:
|
||||
def __init__(self, server='224.0.0.251', port=5353, retries=3):
|
||||
self.server = server
|
||||
self.port = port
|
||||
self.retries = retries
|
||||
|
||||
def send_and_receive_query(self, query, timeout=3):
|
||||
logger.info(f'Sending DNS query to {self.server}:{self.port}')
|
||||
try:
|
||||
# Create a UDP socket
|
||||
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
|
||||
sock.settimeout(timeout)
|
||||
|
||||
# Send the DNS query
|
||||
query_data = query.to_wire()
|
||||
sock.sendto(query_data, (self.server, self.port))
|
||||
|
||||
# Receive the DNS response
|
||||
response_data, _ = sock.recvfrom(512) # 512 bytes is the typical size for a DNS response
|
||||
|
||||
# Parse the response
|
||||
response = dns.message.from_wire(response_data)
|
||||
|
||||
return response
|
||||
|
||||
except socket.timeout as e:
|
||||
logger.warning(f'DNS query timed out: {e}')
|
||||
return None
|
||||
except dns.exception.DNSException as e:
|
||||
logger.error(f'DNS query failed: {e}')
|
||||
return None
|
||||
|
||||
def run_query(self, name, query_type='PTR', timeout=3):
|
||||
logger.info(f'Running DNS query for {name} with type {query_type}')
|
||||
query = dns.message.make_query(name, dns.rdatatype.from_text(query_type), dns.rdataclass.IN)
|
||||
|
||||
# Print the DNS question section
|
||||
logger.info(f'DNS question section: {query.question}')
|
||||
|
||||
# Send and receive the DNS query
|
||||
response = None
|
||||
for attempt in range(1, self.retries + 1):
|
||||
logger.info(f'Attempt {attempt}/{self.retries}')
|
||||
response = self.send_and_receive_query(query, timeout)
|
||||
if response:
|
||||
break
|
||||
|
||||
if response:
|
||||
logger.info(f'DNS query response:\n{response}')
|
||||
else:
|
||||
logger.warning('No response received or response was invalid.')
|
||||
|
||||
return response
|
||||
|
||||
def parse_answer_section(self, response, query_type):
|
||||
answers = []
|
||||
if response:
|
||||
for answer in response.answer:
|
||||
if dns.rdatatype.to_text(answer.rdtype) == query_type:
|
||||
for item in answer.items:
|
||||
full_answer = (
|
||||
f'{answer.name} {answer.ttl} '
|
||||
f'{dns.rdataclass.to_text(answer.rdclass)} '
|
||||
f'{dns.rdatatype.to_text(answer.rdtype)} '
|
||||
f'{item.to_text()}'
|
||||
)
|
||||
answers.append(full_answer)
|
||||
return answers
|
||||
|
||||
def check_record(self, name, query_type, expected=True, expect=None):
|
||||
output = self.run_query(name, query_type=query_type)
|
||||
answers = self.parse_answer_section(output, query_type)
|
||||
logger.info(f'answers: {answers}')
|
||||
if expect is None:
|
||||
expect = name
|
||||
if expected:
|
||||
assert any(expect in answer for answer in answers), f"Expected record '{expect}' not in answer section"
|
||||
else:
|
||||
assert not any(expect in answer for answer in answers), f"Unexpected record '{expect}' found in answer section"
|
||||
|
||||
def parse_section(self, response, section: str, rdtype_text: str):
|
||||
"""Parse a specific response section (answer, authority, additional) for given rdtype.
|
||||
|
||||
Returns list of textual records for that rdtype.
|
||||
"""
|
||||
out = []
|
||||
if not response:
|
||||
return out
|
||||
rrsets = []
|
||||
if section == 'answer':
|
||||
rrsets = response.answer
|
||||
elif section == 'authority':
|
||||
rrsets = response.authority
|
||||
elif section == 'additional':
|
||||
rrsets = response.additional
|
||||
else:
|
||||
raise ValueError('invalid section')
|
||||
for rr in rrsets:
|
||||
if dns.rdatatype.to_text(rr.rdtype) != rdtype_text:
|
||||
continue
|
||||
for item in rr.items:
|
||||
full = (
|
||||
f'{rr.name} {rr.ttl} '
|
||||
f'{dns.rdataclass.to_text(rr.rdclass)} '
|
||||
f'{dns.rdatatype.to_text(rr.rdtype)} '
|
||||
f'{item.to_text()}'
|
||||
)
|
||||
out.append(full)
|
||||
return out
|
||||
|
||||
def check_additional(self, response, rdtype_text: str, owner_contains: str, expected: bool = True, expect_substr: str | None = None):
|
||||
"""Check Additional section for an RR of type rdtype_text whose owner includes owner_contains.
|
||||
|
||||
If expect_substr is provided, also require it to appear in the textual RR.
|
||||
"""
|
||||
records = self.parse_section(response, 'additional', rdtype_text)
|
||||
logger.info(f'additional({rdtype_text}): {records}')
|
||||
|
||||
def _matches(line: str) -> bool:
|
||||
in_owner = owner_contains in line
|
||||
has_val = (expect_substr in line) if expect_substr else True
|
||||
return in_owner and has_val
|
||||
found = any(_matches(r) for r in records)
|
||||
if expected:
|
||||
assert found, f"Expected {rdtype_text} for {owner_contains} in Additional not found"
|
||||
else:
|
||||
assert not found, f"Unexpected {rdtype_text} for {owner_contains} found in Additional"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if len(sys.argv) < 3:
|
||||
print('Usage: python dns_fixture.py <query_type> <name>')
|
||||
sys.exit(1)
|
||||
|
||||
query_type = sys.argv[1]
|
||||
name = sys.argv[2]
|
||||
ip_only = len(sys.argv) > 3 and sys.argv[3] == '--ip_only'
|
||||
if ip_only:
|
||||
logger.setLevel(logging.WARNING)
|
||||
|
||||
dns_wrapper = DnsPythonWrapper()
|
||||
if query_type == 'X' and '.' in name:
|
||||
# Sends an IPv4 reverse query
|
||||
reversed_ip = '.'.join(reversed(name.split('.')))
|
||||
name = f'{reversed_ip}.in-addr.arpa'
|
||||
query_type = 'PTR'
|
||||
response = dns_wrapper.run_query(name, query_type=query_type)
|
||||
answers = dns_wrapper.parse_answer_section(response, query_type)
|
||||
|
||||
if answers:
|
||||
for answer in answers:
|
||||
logger.info(f'DNS query response: {answer}')
|
||||
if ip_only:
|
||||
ipv4_pattern = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')
|
||||
ipv4_addresses = ipv4_pattern.findall(answer)
|
||||
if ipv4_addresses:
|
||||
print(f"{', '.join(ipv4_addresses)}")
|
||||
else:
|
||||
logger.info(f'No response for {name} with query type {query_type}')
|
||||
exit(9) # Same as dig timeout
|
||||
@@ -0,0 +1,4 @@
|
||||
idf_component_register(SRCS "main.c"
|
||||
INCLUDE_DIRS
|
||||
"."
|
||||
REQUIRES mdns console nvs_flash)
|
||||
@@ -0,0 +1,21 @@
|
||||
menu "Test Configuration"
|
||||
|
||||
config TEST_HOSTNAME
|
||||
string "mDNS Hostname"
|
||||
default "esp32-mdns"
|
||||
help
|
||||
mDNS Hostname for example to use
|
||||
|
||||
config TEST_NETIF_NAME
|
||||
string "Network interface name"
|
||||
default "eth2"
|
||||
help
|
||||
Name/ID if the network interface on which we run the mDNS host test
|
||||
|
||||
config TEST_CONSOLE
|
||||
bool "Start console"
|
||||
default n
|
||||
help
|
||||
Test uses esp_console for interactive testing.
|
||||
|
||||
endmenu
|
||||
@@ -0,0 +1,7 @@
|
||||
dependencies:
|
||||
idf: ">=5.0"
|
||||
espressif/mdns:
|
||||
version: "^1.0.0"
|
||||
override_path: "../../.."
|
||||
protocol_examples_common:
|
||||
path: ${IDF_PATH}/examples/common_components/protocol_examples_common
|
||||
@@ -0,0 +1,151 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2022-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "esp_idf_version.h"
|
||||
#include "esp_log.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_console.h"
|
||||
#include "mdns.h"
|
||||
#include "mdns_console.h"
|
||||
|
||||
static const char *TAG = "mdns-test";
|
||||
|
||||
static void mdns_test_app(esp_netif_t *interface);
|
||||
|
||||
#ifdef CONFIG_TEST_CONSOLE
|
||||
static EventGroupHandle_t s_exit_signal = NULL;
|
||||
|
||||
static int exit_console(int argc, char **argv)
|
||||
{
|
||||
#ifdef CONFIG_IDF_TARGET_LINUX
|
||||
/* Host tests do not need graceful REPL teardown; exit hard so leftover
|
||||
* console_repl / linenoise threads cannot keep the process alive. */
|
||||
ESP_LOGI(TAG, "Exit");
|
||||
exit(0);
|
||||
#else
|
||||
xEventGroupSetBits(s_exit_signal, 1);
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
#else
|
||||
static void query_mdns_host(const char *host_name)
|
||||
{
|
||||
ESP_LOGI(TAG, "Query A: %s.local", host_name);
|
||||
|
||||
struct esp_ip4_addr addr;
|
||||
addr.addr = 0;
|
||||
|
||||
esp_err_t err = mdns_query_a(host_name, 2000, &addr);
|
||||
if (err) {
|
||||
if (err == ESP_ERR_NOT_FOUND) {
|
||||
ESP_LOGW(TAG, "%x: Host was not found!", (err));
|
||||
return;
|
||||
}
|
||||
ESP_LOGE(TAG, "Query Failed: %x", (err));
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Query A: %s.local resolved to: " IPSTR, host_name, IP2STR(&addr));
|
||||
}
|
||||
#endif // TEST_CONSOLE
|
||||
|
||||
#ifndef CONFIG_IDF_TARGET_LINUX
|
||||
#include "protocol_examples_common.h"
|
||||
#include "esp_event.h"
|
||||
#include "nvs_flash.h"
|
||||
|
||||
/**
|
||||
* @brief This is an entry point for the real target device,
|
||||
* need to init few components and connect to a network interface
|
||||
*/
|
||||
void app_main(void)
|
||||
{
|
||||
ESP_ERROR_CHECK(nvs_flash_init());
|
||||
ESP_ERROR_CHECK(esp_netif_init());
|
||||
ESP_ERROR_CHECK(esp_event_loop_create_default());
|
||||
ESP_ERROR_CHECK(example_connect());
|
||||
|
||||
mdns_test_app(EXAMPLE_INTERFACE);
|
||||
|
||||
ESP_ERROR_CHECK(example_disconnect());
|
||||
}
|
||||
#else
|
||||
|
||||
/**
|
||||
* @brief This is an entry point for the linux target (simulator on host)
|
||||
* need to create a dummy WiFi station and use it as mdns network interface
|
||||
*/
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
setvbuf(stdout, NULL, _IONBF, 0);
|
||||
const esp_netif_inherent_config_t base_cg = { .if_key = "WIFI_STA_DEF", .if_desc = CONFIG_TEST_NETIF_NAME };
|
||||
esp_netif_config_t cfg = { .base = &base_cg };
|
||||
esp_netif_t *sta = esp_netif_new(&cfg);
|
||||
|
||||
mdns_test_app(sta);
|
||||
|
||||
esp_netif_destroy(sta);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void mdns_test_app(esp_netif_t *interface)
|
||||
{
|
||||
ESP_ERROR_CHECK(mdns_init());
|
||||
ESP_ERROR_CHECK(mdns_hostname_set(CONFIG_TEST_HOSTNAME));
|
||||
ESP_LOGI(TAG, "mdns hostname set to: [%s]", CONFIG_TEST_HOSTNAME);
|
||||
ESP_ERROR_CHECK(mdns_register_netif(interface));
|
||||
ESP_ERROR_CHECK(mdns_netif_action(interface, MDNS_EVENT_ENABLE_IP4 /*| MDNS_EVENT_ENABLE_IP6 */ | MDNS_EVENT_IP4_REVERSE_LOOKUP | MDNS_EVENT_IP6_REVERSE_LOOKUP));
|
||||
// Query _services._dns-sd._udp to discover available service types
|
||||
mdns_result_t *results = NULL;
|
||||
esp_err_t err = mdns_query_ptr("_services._dns-sd", "_udp", 2000, 1, &results);
|
||||
if (err) {
|
||||
ESP_LOGE(TAG, "Query for _services._dns-sd._udp failed: 0x%x", err);
|
||||
}
|
||||
for (mdns_result_t *r = results; r; r = r->next) {
|
||||
ESP_LOGI(TAG, "Discovered service: %s.%s",
|
||||
r->service_type ? r->service_type : "?",
|
||||
r->proto ? r->proto : "?");
|
||||
}
|
||||
mdns_query_results_free(results);
|
||||
|
||||
#ifdef CONFIG_TEST_CONSOLE
|
||||
esp_console_repl_t *repl = NULL;
|
||||
esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
|
||||
s_exit_signal = xEventGroupCreate();
|
||||
|
||||
repl_config.prompt = "mdns>";
|
||||
// init console REPL environment
|
||||
#if CONFIG_IDF_TARGET_LINUX && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 1, 0)
|
||||
ESP_ERROR_CHECK(esp_console_new_repl_stdio(&repl_config, &repl));
|
||||
#else
|
||||
esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
|
||||
ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl));
|
||||
#endif
|
||||
|
||||
const esp_console_cmd_t cmd_exit = {
|
||||
.command = "exit",
|
||||
.help = "exit mDNS console application",
|
||||
.hint = NULL,
|
||||
.func = exit_console,
|
||||
.argtable = NULL
|
||||
};
|
||||
ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_exit));
|
||||
mdns_console_register();
|
||||
ESP_ERROR_CHECK(esp_console_start_repl(repl));
|
||||
xEventGroupWaitBits(s_exit_signal, 1, pdTRUE, pdFALSE, portMAX_DELAY);
|
||||
repl->del(repl);
|
||||
#else
|
||||
vTaskDelay(pdMS_TO_TICKS(10000));
|
||||
query_mdns_host("david-work");
|
||||
vTaskDelay(pdMS_TO_TICKS(1000));
|
||||
#endif
|
||||
mdns_free();
|
||||
ESP_LOGI(TAG, "Exit");
|
||||
}
|
||||
@@ -0,0 +1,456 @@
|
||||
# SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
|
||||
# SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
import logging
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import pexpect
|
||||
import pytest
|
||||
from bonjour_order_responder import DEFAULTS
|
||||
from dnsfixture import DnsPythonWrapper
|
||||
from querier_responder import DEFAULTS as QUERIER_DEFAULTS
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger(__name__)
|
||||
ipv6_enabled = False
|
||||
|
||||
|
||||
def _console_line(label: str, value: str) -> str:
|
||||
"""Build a line as printed by mdns_print_results (avoids flake8 E203 on f'LABEL : {x}')."""
|
||||
return label + value
|
||||
|
||||
|
||||
class MdnsConsole:
|
||||
def __init__(self, command):
|
||||
self.process = pexpect.spawn(command, encoding='utf-8')
|
||||
self.process.logfile = open('mdns_interaction.log', 'w') # Log all interactions
|
||||
self.process.expect('mdns> ', timeout=10)
|
||||
|
||||
def send_input(self, input_data):
|
||||
logger.info(f'Sending to stdin: {input_data}')
|
||||
self.process.sendline(input_data)
|
||||
|
||||
def get_output(self, expected_data):
|
||||
logger.info(f'Expecting: {expected_data}')
|
||||
self.process.expect(expected_data, timeout=10)
|
||||
output = self.process.before.strip()
|
||||
logger.info(f'Received from stdout: {output}')
|
||||
return output
|
||||
|
||||
def wait_for_output(self, expected_data, timeout=10):
|
||||
logger.info(f'Waiting for: {expected_data}')
|
||||
self.process.expect(expected_data, timeout=timeout)
|
||||
output = (self.process.before or '') + (self.process.after or '')
|
||||
logger.info(f'Captured output while waiting: {output}')
|
||||
return output
|
||||
|
||||
def wait_for_browse_result(self, timeout=10):
|
||||
"""Wait until browse notifier printed the full result (A is last required field)."""
|
||||
return self.wait_for_output(_console_line('A : ', DEFAULTS['ipv4']), timeout=timeout)
|
||||
|
||||
def wait_for_browse_goodbye(self, timeout=10):
|
||||
"""Wait for Bonjour-style PTR TTL=0 removal notification (interface line then PTR)."""
|
||||
self.wait_for_output('TTL: 0', timeout=timeout)
|
||||
return self.wait_for_output(_console_line('PTR : ', DEFAULTS['instance']), timeout=timeout)
|
||||
|
||||
def terminate(self):
|
||||
self.send_input('exit')
|
||||
self.get_output('Exit')
|
||||
self.process.wait()
|
||||
self.process.close()
|
||||
assert self.process.exitstatus == 0
|
||||
|
||||
|
||||
def _bonjour_responder_cmd(
|
||||
srv_first: bool = False,
|
||||
goodbye_after: int = -1,
|
||||
unsolicited_goodbye_after: int = -1,
|
||||
) -> list[str]:
|
||||
cmd = [
|
||||
sys.executable,
|
||||
str(Path(__file__).with_name('bonjour_order_responder.py')),
|
||||
'--interface',
|
||||
'eth0',
|
||||
'--service',
|
||||
DEFAULTS['service'],
|
||||
'--proto',
|
||||
DEFAULTS['proto'],
|
||||
]
|
||||
if srv_first:
|
||||
cmd.append('--srv-first')
|
||||
if goodbye_after >= 0:
|
||||
cmd.extend(['--goodbye-after', str(goodbye_after)])
|
||||
if unsolicited_goodbye_after >= 0:
|
||||
cmd.extend(['--unsolicited-goodbye-after', str(unsolicited_goodbye_after)])
|
||||
return cmd
|
||||
|
||||
|
||||
def _run_bonjour_responder(
|
||||
*,
|
||||
srv_first: bool = False,
|
||||
goodbye_after: int = -1,
|
||||
unsolicited_goodbye_after: int = -1,
|
||||
label: str,
|
||||
):
|
||||
proc = subprocess.Popen(
|
||||
_bonjour_responder_cmd(
|
||||
srv_first=srv_first,
|
||||
goodbye_after=goodbye_after,
|
||||
unsolicited_goodbye_after=unsolicited_goodbye_after,
|
||||
),
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT,
|
||||
text=True,
|
||||
)
|
||||
time.sleep(0.5)
|
||||
# poll() stays None while the responder is still running after startup.
|
||||
assert proc.poll() is None, f'{label} failed to start (need eth0 and port 5353?)'
|
||||
return proc
|
||||
|
||||
|
||||
def _stop_bonjour_responder(proc):
|
||||
proc.terminate()
|
||||
try:
|
||||
proc.wait(timeout=3)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
proc.wait(timeout=3)
|
||||
|
||||
|
||||
def _run_querier_responder():
|
||||
proc = subprocess.Popen(
|
||||
[
|
||||
sys.executable,
|
||||
str(Path(__file__).with_name('querier_responder.py')),
|
||||
'--interface',
|
||||
'eth0',
|
||||
],
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT,
|
||||
text=True,
|
||||
)
|
||||
time.sleep(0.5)
|
||||
assert proc.poll() is None, 'Querier responder failed to start (need eth0 and port 5353?)'
|
||||
return proc
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def querier_responder():
|
||||
proc = _run_querier_responder()
|
||||
yield proc
|
||||
_stop_bonjour_responder(proc)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def bonjour_responder():
|
||||
proc = _run_bonjour_responder(label='Bonjour-order responder')
|
||||
yield proc
|
||||
_stop_bonjour_responder(proc)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def bonjour_responder_srv_first():
|
||||
proc = _run_bonjour_responder(srv_first=True, label='SRV-first responder')
|
||||
yield proc
|
||||
_stop_bonjour_responder(proc)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def bonjour_responder_goodbye():
|
||||
proc = _run_bonjour_responder(
|
||||
unsolicited_goodbye_after=1,
|
||||
label='Unsolicited-goodbye responder',
|
||||
)
|
||||
yield proc
|
||||
_stop_bonjour_responder(proc)
|
||||
|
||||
|
||||
@pytest.fixture(scope='module')
|
||||
def mdns_console():
|
||||
app = MdnsConsole('./build_linux_console/mdns_host.elf')
|
||||
yield app
|
||||
app.terminate()
|
||||
|
||||
|
||||
@pytest.fixture(scope='module')
|
||||
def dig_app():
|
||||
return DnsPythonWrapper()
|
||||
|
||||
|
||||
def test_mdns_init(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_init -h hostname')
|
||||
mdns_console.get_output('MDNS: Hostname: hostname')
|
||||
dig_app.check_record('hostname.local', query_type='A', expected=True)
|
||||
if ipv6_enabled:
|
||||
dig_app.check_record('hostname.local', query_type='AAAA', expected=True)
|
||||
|
||||
|
||||
def test_add_service(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_service_add _http _tcp 80 -i test_service')
|
||||
mdns_console.get_output('MDNS: Service Instance: test_service')
|
||||
mdns_console.send_input('mdns_service_lookup _http _tcp')
|
||||
mdns_console.get_output('PTR : test_service')
|
||||
dig_app.check_record('_http._tcp.local', query_type='PTR', expected=True)
|
||||
|
||||
|
||||
def test_ptr_additional_records_for_service(dig_app):
|
||||
# Query PTR for the service type and ensure SRV/TXT are in Additional (RFC 6763 §12.1)
|
||||
resp = dig_app.run_query('_http._tcp.local', query_type='PTR')
|
||||
# Answer section should have at least one PTR to the instance
|
||||
answers = dig_app.parse_answer_section(resp, 'PTR')
|
||||
assert any('test_service._http._tcp.local' in a for a in answers)
|
||||
# Additional section should include SRV and TXT for the same instance
|
||||
dig_app.check_additional(resp, 'SRV', 'test_service._http._tcp.local', expected=True)
|
||||
dig_app.check_additional(resp, 'TXT', 'test_service._http._tcp.local', expected=True)
|
||||
|
||||
|
||||
def test_instance_any_answer_records(dig_app):
|
||||
"""Query ANY for the service instance and ensure SRV/TXT are in Answer (Q/A path)."""
|
||||
resp = dig_app.run_query('test_service._http._tcp.local', query_type='ANY')
|
||||
|
||||
# Answer section should contain SRV and TXT records for the instance
|
||||
srv_answers = dig_app.parse_section(resp, 'answer', 'SRV')
|
||||
txt_answers = dig_app.parse_section(resp, 'answer', 'TXT')
|
||||
assert any('test_service._http._tcp.local' in a for a in srv_answers)
|
||||
assert any('test_service._http._tcp.local' in a for a in txt_answers)
|
||||
|
||||
# We should not see a PTR for the generic service name in the Answer section
|
||||
ptr_answers = dig_app.parse_section(resp, 'answer', 'PTR')
|
||||
assert not any('_http._tcp.local' in a for a in ptr_answers)
|
||||
|
||||
|
||||
def test_remove_service(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_service_remove _http _tcp')
|
||||
mdns_console.send_input('mdns_service_lookup _http _tcp')
|
||||
mdns_console.get_output('No results found!')
|
||||
dig_app.check_record('_http._tcp.local', query_type='PTR', expected=False)
|
||||
|
||||
|
||||
def test_delegate_host(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_delegate_host delegated 1.2.3.4')
|
||||
dig_app.check_record('delegated.local', query_type='A', expected=True)
|
||||
|
||||
|
||||
def test_undelegate_host(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_undelegate_host delegated')
|
||||
dig_app.check_record('delegated.local', query_type='A', expected=False)
|
||||
|
||||
|
||||
def test_add_delegated_service(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_delegate_host delegated 1.2.3.4')
|
||||
dig_app.check_record('delegated.local', query_type='A', expected=True)
|
||||
mdns_console.send_input('mdns_service_add _test _tcp 80 -i local')
|
||||
mdns_console.get_output('MDNS: Service Instance: local')
|
||||
mdns_console.send_input('mdns_service_add _test2 _tcp 80 -i extern -h delegated')
|
||||
mdns_console.get_output('MDNS: Service Instance: extern')
|
||||
mdns_console.send_input('mdns_service_lookup _test _tcp')
|
||||
mdns_console.get_output('PTR : local')
|
||||
mdns_console.send_input('mdns_service_lookup _test2 _tcp -d')
|
||||
mdns_console.get_output('PTR : extern')
|
||||
dig_app.check_record('_test2._tcp.local', query_type='PTR', expected=True)
|
||||
dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True)
|
||||
|
||||
|
||||
def test_service_discovery_dns_sd(dig_app):
|
||||
"""Query _services._dns-sd._udp.local PTR to discover registered service types (RFC 6763 §9)."""
|
||||
resp = dig_app.run_query('_services._dns-sd._udp.local', query_type='PTR')
|
||||
answers = dig_app.parse_answer_section(resp, 'PTR')
|
||||
assert any('_test._tcp.local' in a for a in answers), \
|
||||
f'Expected _test._tcp.local in DNS-SD response, got: {answers}'
|
||||
assert any('_test2._tcp.local' in a for a in answers), \
|
||||
f'Expected _test2._tcp.local in DNS-SD response, got: {answers}'
|
||||
|
||||
|
||||
def test_service_discovery_query(mdns_console):
|
||||
"""Test querier-side: query _services._dns-sd._udp via mdns_query_ptr (exercises multi-label splitting)."""
|
||||
mdns_console.send_input('mdns_query_ptr _services._dns-sd _udp -t 2000 -m 10')
|
||||
mdns_console.get_output('Query PTR: _services._dns-sd._udp.local')
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
def test_remove_delegated_service(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_service_remove _test2 _tcp -h delegated')
|
||||
mdns_console.send_input('mdns_service_lookup _test2 _tcp -d')
|
||||
mdns_console.get_output('No results found!')
|
||||
dig_app.check_record('_test2._tcp.local', query_type='PTR', expected=False)
|
||||
# add the delegated service again, would be used in the TXT test
|
||||
mdns_console.send_input('mdns_service_add _test2 _tcp 80 -i extern -h delegated')
|
||||
mdns_console.get_output('MDNS: Service Instance: extern')
|
||||
|
||||
|
||||
def check_txt_for_service(instance, service, proto, mdns_console, dig_app, host=None, with_inst=False):
|
||||
for_host_arg = f'-h {host}' if host is not None else ''
|
||||
for_inst_arg = f'-i {instance}' if with_inst else ''
|
||||
mdns_console.send_input(f'mdns_service_txt_set {service} {proto} {for_host_arg} {for_inst_arg} key1 value1')
|
||||
dig_app.check_record(f'{instance}.{service}.{proto}.local', query_type='SRV', expected=True)
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key1=value1')
|
||||
mdns_console.send_input(f'mdns_service_txt_set {service} {proto} {for_host_arg} {for_inst_arg} key2 value2')
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key2=value2')
|
||||
mdns_console.send_input(f'mdns_service_txt_remove {service} {proto} {for_host_arg} {for_inst_arg} key2')
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=False, expect='key2=value2')
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key1=value1')
|
||||
mdns_console.send_input(f'mdns_service_txt_replace {service} {proto} {for_host_arg} {for_inst_arg} key3=value3 key4=value4')
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=False, expect='key1=value1')
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key3=value3')
|
||||
dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key4=value4')
|
||||
|
||||
|
||||
def test_update_txt(mdns_console, dig_app):
|
||||
check_txt_for_service('local', '_test', '_tcp', mdns_console=mdns_console, dig_app=dig_app)
|
||||
check_txt_for_service('local', '_test', '_tcp', mdns_console=mdns_console, dig_app=dig_app, with_inst=True)
|
||||
|
||||
|
||||
def test_update_delegated_txt(mdns_console, dig_app):
|
||||
check_txt_for_service('extern', '_test2', '_tcp', mdns_console=mdns_console, dig_app=dig_app, host='delegated')
|
||||
check_txt_for_service('extern', '_test2', '_tcp', mdns_console=mdns_console, dig_app=dig_app, host='delegated', with_inst=True)
|
||||
|
||||
|
||||
def test_service_port_set(mdns_console, dig_app):
|
||||
dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True, expect='80')
|
||||
mdns_console.send_input('mdns_service_port_set _test _tcp 81')
|
||||
dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True, expect='81')
|
||||
mdns_console.send_input('mdns_service_port_set _test2 _tcp -h delegated 82')
|
||||
dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True, expect='82')
|
||||
mdns_console.send_input('mdns_service_port_set _test2 _tcp -h delegated -i extern 83')
|
||||
dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True, expect='83')
|
||||
mdns_console.send_input('mdns_service_port_set _test2 _tcp -h delegated -i invalid_inst 84')
|
||||
mdns_console.get_output('ESP_ERR_NOT_FOUND')
|
||||
dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True, expect='83')
|
||||
|
||||
|
||||
def test_service_subtype(mdns_console, dig_app):
|
||||
dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True)
|
||||
mdns_console.send_input('mdns_service_subtype _test _tcp _subtest -i local')
|
||||
dig_app.check_record('_subtest._sub._test._tcp.local', query_type='PTR', expected=True)
|
||||
mdns_console.send_input('mdns_service_subtype _test2 _tcp _subtest2 -i extern -h delegated')
|
||||
dig_app.check_record('_subtest2._sub._test2._tcp.local', query_type='PTR', expected=True)
|
||||
|
||||
|
||||
def test_service_set_instance(mdns_console, dig_app):
|
||||
dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True)
|
||||
mdns_console.send_input('mdns_service_instance_set _test _tcp local2')
|
||||
dig_app.check_record('local2._test._tcp.local', query_type='SRV', expected=True)
|
||||
mdns_console.send_input('mdns_service_instance_set _test2 _tcp extern2 -h delegated')
|
||||
mdns_console.send_input('mdns_service_lookup _test2 _tcp -d')
|
||||
mdns_console.get_output('PTR : extern2')
|
||||
dig_app.check_record('extern2._test2._tcp.local', query_type='SRV', expected=True)
|
||||
mdns_console.send_input('mdns_service_instance_set _test2 _tcp extern3 -h delegated -i extern')
|
||||
mdns_console.get_output('ESP_ERR_NOT_FOUND')
|
||||
|
||||
|
||||
def test_service_remove_all(mdns_console, dig_app):
|
||||
mdns_console.send_input('mdns_service_remove_all')
|
||||
mdns_console.send_input('mdns_service_lookup _test2 _tcp -d')
|
||||
mdns_console.get_output('No results found!')
|
||||
mdns_console.send_input('mdns_service_lookup _test _tcp')
|
||||
mdns_console.get_output('No results found!')
|
||||
dig_app.check_record('_test._tcp.local', query_type='PTR', expected=False)
|
||||
|
||||
|
||||
def _browse_v301test(mdns_console, *, reset_browse: bool = True):
|
||||
service = DEFAULTS['service']
|
||||
proto = DEFAULTS['proto']
|
||||
if reset_browse:
|
||||
mdns_console.send_input(f'mdns_browse_del {service} {proto}')
|
||||
mdns_console.get_output('mdns>')
|
||||
mdns_console.send_input(f'mdns_browse {service} {proto}')
|
||||
return mdns_console.wait_for_browse_result(timeout=10)
|
||||
|
||||
|
||||
def test_browse_bonjour_additional_order_includes_ip(mdns_console, bonjour_responder):
|
||||
"""Bonjour order (A/AAAA before SRV) must populate browse addresses on first response."""
|
||||
output = _browse_v301test(mdns_console)
|
||||
assert _console_line('PTR : ', DEFAULTS['instance']) in output
|
||||
assert _console_line('A : ', DEFAULTS['ipv4']) in output
|
||||
mdns_console.send_input(f"mdns_browse_del {DEFAULTS['service']} {DEFAULTS['proto']}")
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
def test_browse_srv_first_includes_ip(mdns_console, bonjour_responder_srv_first):
|
||||
"""Control case: SRV before A/AAAA should populate browse addresses."""
|
||||
output = _browse_v301test(mdns_console)
|
||||
assert _console_line('PTR : ', DEFAULTS['instance']) in output
|
||||
assert _console_line('A : ', DEFAULTS['ipv4']) in output
|
||||
mdns_console.send_input(f"mdns_browse_del {DEFAULTS['service']} {DEFAULTS['proto']}")
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
def test_browse_ptr_goodbye_notifies_removal(mdns_console, bonjour_responder_goodbye):
|
||||
"""Same live browse must see normal result then unsolicited PTR TTL=0 removal."""
|
||||
service = DEFAULTS['service']
|
||||
proto = DEFAULTS['proto']
|
||||
mdns_console.send_input(f'mdns_browse_del {service} {proto}')
|
||||
mdns_console.get_output('mdns>')
|
||||
mdns_console.send_input(f'mdns_browse {service} {proto}')
|
||||
mdns_console.wait_for_browse_result(timeout=10)
|
||||
output = mdns_console.wait_for_browse_goodbye(timeout=10)
|
||||
assert _console_line('PTR : ', DEFAULTS['instance']) in output
|
||||
mdns_console.send_input(f'mdns_browse_del {service} {proto}')
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
def test_browse_duplicate_rejected(mdns_console, bonjour_responder):
|
||||
"""Duplicate mdns_browse_new() for the same service/proto must fail and leave the original active."""
|
||||
service = DEFAULTS['service']
|
||||
proto = DEFAULTS['proto']
|
||||
mdns_console.send_input(f'mdns_browse_del {service} {proto}')
|
||||
mdns_console.get_output('mdns>')
|
||||
mdns_console.send_input(f'mdns_browse {service} {proto}')
|
||||
mdns_console.wait_for_browse_result(timeout=10)
|
||||
|
||||
mdns_console.send_input(f'mdns_browse {service} {proto}')
|
||||
mdns_console.get_output('Browse already exists')
|
||||
mdns_console.get_output('Command returned non-zero error code')
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
# Original browse remains usable (delete must succeed).
|
||||
mdns_console.send_input(f'mdns_browse_del {service} {proto}')
|
||||
out = mdns_console.get_output('mdns>')
|
||||
assert 'Command returned non-zero' not in out
|
||||
|
||||
|
||||
def test_query_a_against_peer(mdns_console, querier_responder):
|
||||
"""DUT-side sync mdns_query_a against a controlled peer (replaces test_apps QUERY_HOST)."""
|
||||
host = QUERIER_DEFAULTS['hostname']
|
||||
ipv4 = QUERIER_DEFAULTS['ipv4']
|
||||
# Safe if suite already called mdns_init; required when this test runs alone.
|
||||
mdns_console.send_input('mdns_init -h hostname')
|
||||
mdns_console.get_output('mdns>')
|
||||
mdns_console.send_input(f'mdns_query_a {host} -t 2000')
|
||||
mdns_console.get_output(f'Query A: {host}.local')
|
||||
mdns_console.get_output(ipv4)
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
def test_query_a_async_against_peer(mdns_console, querier_responder):
|
||||
"""DUT-side async A query against a controlled peer (replaces test_apps QUERY_HOST_ASYNC)."""
|
||||
host = QUERIER_DEFAULTS['hostname']
|
||||
ipv4 = QUERIER_DEFAULTS['ipv4']
|
||||
mdns_console.send_input('mdns_init -h hostname')
|
||||
mdns_console.get_output('mdns>')
|
||||
mdns_console.send_input(f'mdns_query_a_async {host} -t 2000')
|
||||
mdns_console.get_output(f'Query A async: {host}.local')
|
||||
mdns_console.get_output(f'Async query resolved to A:{ipv4}')
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
def test_query_srv_against_peer(mdns_console, querier_responder):
|
||||
"""DUT-side mdns_query_srv against a controlled peer (replaces test_apps QUERY_SERVICE)."""
|
||||
instance = QUERIER_DEFAULTS['instance']
|
||||
service = QUERIER_DEFAULTS['service']
|
||||
proto = QUERIER_DEFAULTS['proto']
|
||||
hostname = QUERIER_DEFAULTS['hostname']
|
||||
port = QUERIER_DEFAULTS['port']
|
||||
mdns_console.send_input('mdns_init -h hostname')
|
||||
mdns_console.get_output('mdns>')
|
||||
mdns_console.send_input(f'mdns_query_srv {instance} {service} {proto} -t 2000')
|
||||
mdns_console.get_output(f'Query SRV: {instance}.{service}.{proto}.local')
|
||||
mdns_console.get_output(_console_line('SRV : ', f'{hostname}.local:{port}'))
|
||||
mdns_console.get_output('mdns>')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
pytest.main(['-s', 'test_mdns.py'])
|
||||
@@ -0,0 +1,191 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
|
||||
# SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
"""Controlled mDNS peer for host querier tests (A / SRV only).
|
||||
|
||||
Answers only the configured hostname A and instance SRV questions. Ignores all
|
||||
other traffic so system mDNS probes cannot create an answer storm.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import logging
|
||||
import socket
|
||||
import struct
|
||||
import sys
|
||||
|
||||
import dns.flags
|
||||
import dns.message
|
||||
import dns.name
|
||||
import dns.rdataclass
|
||||
import dns.rdatatype
|
||||
import dns.rrset
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
MDNS_ADDR = '224.0.0.251'
|
||||
MDNS_PORT = 5353
|
||||
|
||||
DEFAULTS = {
|
||||
'hostname': 'tinytester',
|
||||
'ipv4': '127.0.0.1',
|
||||
'instance': 'ESP32',
|
||||
'service': '_http',
|
||||
'proto': '_tcp',
|
||||
'port': 100,
|
||||
}
|
||||
|
||||
|
||||
def _fqdn(*labels: str) -> str:
|
||||
return '.'.join(labels) + '.local.'
|
||||
|
||||
|
||||
def create_socket(interface: str | None) -> socket.socket:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
try:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
|
||||
except (AttributeError, OSError):
|
||||
pass
|
||||
|
||||
if interface:
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface.encode() + b'\0')
|
||||
|
||||
sock.bind(('', MDNS_PORT))
|
||||
membership = struct.pack('=4s4s', socket.inet_aton(MDNS_ADDR), socket.inet_aton('0.0.0.0'))
|
||||
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, membership)
|
||||
return sock
|
||||
|
||||
|
||||
def build_a_response(query: dns.message.Message, hostname: str, ipv4: str) -> dns.message.Message:
|
||||
host_name = _fqdn(hostname)
|
||||
# Exact QR|AA (0x8400). dnspython make_response also sets RD, which is fine for
|
||||
# answer parsing but keep mDNS-shaped packets consistent with bonjour fixtures.
|
||||
response = dns.message.Message(id=query.id)
|
||||
response.flags = dns.flags.QR | dns.flags.AA
|
||||
response.answer.append(
|
||||
dns.rrset.from_text(host_name, 120, dns.rdataclass.IN, dns.rdatatype.A, ipv4)
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
def build_srv_response(
|
||||
query: dns.message.Message,
|
||||
*,
|
||||
instance: str,
|
||||
service: str,
|
||||
proto: str,
|
||||
hostname: str,
|
||||
port: int,
|
||||
ipv4: str,
|
||||
) -> dns.message.Message:
|
||||
instance_name = _fqdn(instance, service, proto)
|
||||
host_name = _fqdn(hostname)
|
||||
response = dns.message.Message(id=query.id)
|
||||
response.flags = dns.flags.QR | dns.flags.AA
|
||||
response.answer.append(
|
||||
dns.rrset.from_text(
|
||||
instance_name,
|
||||
120,
|
||||
dns.rdataclass.IN,
|
||||
dns.rdatatype.SRV,
|
||||
f'0 0 {port} {host_name}',
|
||||
)
|
||||
)
|
||||
response.additional.append(
|
||||
dns.rrset.from_text(host_name, 120, dns.rdataclass.IN, dns.rdatatype.A, ipv4)
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
def match_question(query: dns.message.Message, args: argparse.Namespace):
|
||||
host_name = dns.name.from_text(_fqdn(args.hostname))
|
||||
instance_name = dns.name.from_text(_fqdn(args.instance, args.service, args.proto))
|
||||
for question in query.question:
|
||||
if question.rdtype == dns.rdatatype.A and question.name == host_name:
|
||||
return 'A'
|
||||
if question.rdtype == dns.rdatatype.SRV and question.name == instance_name:
|
||||
return 'SRV'
|
||||
return None
|
||||
|
||||
|
||||
def send_response(sock: socket.socket, payload: bytes, source: tuple[str, int]) -> None:
|
||||
# mDNS queries usually come from port 5353 → multicast reply; one-shot dig uses ephemeral ports.
|
||||
destination = (MDNS_ADDR, MDNS_PORT) if source[1] == MDNS_PORT else source
|
||||
sock.sendto(payload, destination)
|
||||
logger.info('Sent %d byte response to %s (from %s:%d)', len(payload), destination, *source)
|
||||
|
||||
|
||||
def serve(args: argparse.Namespace) -> None:
|
||||
sock = create_socket(args.interface)
|
||||
logger.info(
|
||||
'Querier responder on %s:%d (%s): A %s.local -> %s; SRV %s.%s.%s.local -> %s.local:%d',
|
||||
MDNS_ADDR,
|
||||
MDNS_PORT,
|
||||
args.interface or 'all interfaces',
|
||||
args.hostname,
|
||||
args.ipv4,
|
||||
args.instance,
|
||||
args.service,
|
||||
args.proto,
|
||||
args.hostname,
|
||||
args.port,
|
||||
)
|
||||
|
||||
while True:
|
||||
try:
|
||||
data, source = sock.recvfrom(9000)
|
||||
except KeyboardInterrupt:
|
||||
logger.info('Stopping querier responder')
|
||||
break
|
||||
|
||||
try:
|
||||
query = dns.message.from_wire(data)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
logger.debug('Ignoring non-DNS payload from %s:%d (%s)', source[0], source[1], exc)
|
||||
continue
|
||||
|
||||
if query.flags & dns.flags.QR:
|
||||
continue
|
||||
|
||||
kind = match_question(query, args)
|
||||
if kind == 'A':
|
||||
response = build_a_response(query, args.hostname, args.ipv4)
|
||||
elif kind == 'SRV':
|
||||
response = build_srv_response(
|
||||
query,
|
||||
instance=args.instance,
|
||||
service=args.service,
|
||||
proto=args.proto,
|
||||
hostname=args.hostname,
|
||||
port=args.port,
|
||||
ipv4=args.ipv4,
|
||||
)
|
||||
else:
|
||||
continue
|
||||
|
||||
send_response(sock, response.to_wire(), source)
|
||||
|
||||
|
||||
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--interface', default='eth0')
|
||||
parser.add_argument('--hostname', default=DEFAULTS['hostname'])
|
||||
parser.add_argument('--ipv4', default=DEFAULTS['ipv4'])
|
||||
parser.add_argument('--instance', default=DEFAULTS['instance'])
|
||||
parser.add_argument('--service', default=DEFAULTS['service'])
|
||||
parser.add_argument('--proto', default=DEFAULTS['proto'])
|
||||
parser.add_argument('--port', type=int, default=DEFAULTS['port'])
|
||||
return parser.parse_args(argv)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = parse_args(argv)
|
||||
serve(args)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,4 @@
|
||||
CONFIG_IDF_TARGET="linux"
|
||||
CONFIG_TEST_HOSTNAME="myesp"
|
||||
CONFIG_MDNS_ENABLE_DEBUG_PRINTS=y
|
||||
CONFIG_MDNS_RESPOND_REVERSE_QUERIES=y
|
||||
@@ -0,0 +1,4 @@
|
||||
CONFIG_IDF_TARGET="linux"
|
||||
CONFIG_ESP_EVENT_POST_FROM_ISR=n
|
||||
CONFIG_MDNS_ENABLE_CONSOLE_CLI=y
|
||||
CONFIG_TEST_CONSOLE=y
|
||||
@@ -0,0 +1 @@
|
||||
CONFIG_IDF_TARGET="esp32"
|
||||
@@ -0,0 +1,6 @@
|
||||
CONFIG_TEST_NETIF_NAME="eth0"
|
||||
CONFIG_ESP_EVENT_POST_FROM_ISR=n
|
||||
CONFIG_MDNS_NETWORKING_SOCKET=y
|
||||
CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES=y
|
||||
CONFIG_MDNS_PREDEF_NETIF_STA=n
|
||||
CONFIG_MDNS_PREDEF_NETIF_AP=n
|
||||
@@ -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;
|
||||
}
|
||||
Whitespace-only changes.
@@ -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)
|
||||
+311
@@ -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();
|
||||
}
|
||||
+6
@@ -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)
|
||||
+982
@@ -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();
|
||||
}
|
||||
+6
@@ -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)
|
||||
+244
@@ -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();
|
||||
}
|
||||
+7
@@ -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)
|
||||
+58
@@ -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();
|
||||
}
|
||||
+6
@@ -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);
|
||||
@@ -0,0 +1,15 @@
|
||||
# This is the project CMakeLists.txt file for the test subproject
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
|
||||
if("${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}" VERSION_GREATER_EQUAL "6.0")
|
||||
set(test_component_dir $ENV{IDF_PATH}/tools/test_apps/components)
|
||||
else()
|
||||
set(test_component_dir $ENV{IDF_PATH}/tools/unit-test-app/components)
|
||||
endif()
|
||||
|
||||
set(EXTRA_COMPONENT_DIRS ../..
|
||||
${test_component_dir})
|
||||
|
||||
project(mdns_test)
|
||||
@@ -0,0 +1,5 @@
|
||||
|
||||
idf_component_register(SRCS "test_mdns.c"
|
||||
REQUIRES test_utils
|
||||
INCLUDE_DIRS "."
|
||||
PRIV_REQUIRES unity mdns)
|
||||
@@ -0,0 +1,404 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2022-2026 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Unlicense OR CC0-1.0
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include "mdns.h"
|
||||
#include "esp_event.h"
|
||||
#include "unity.h"
|
||||
#include "test_utils.h"
|
||||
|
||||
#include "unity_fixture.h"
|
||||
#include "memory_checks.h"
|
||||
|
||||
#define MDNS_HOSTNAME "test-hostname"
|
||||
#define MDNS_DELEGATE_HOSTNAME "delegate-hostname"
|
||||
#define MDNS_INSTANCE "test-instance"
|
||||
#define MDNS_SERVICE_NAME "_http"
|
||||
#define MDNS_SERVICE_PROTO "_tcp"
|
||||
#define MDNS_SERVICE_SUBTYPE "_printer"
|
||||
#define MDNS_SERVICE_PORT 80
|
||||
|
||||
TEST_GROUP(mdns);
|
||||
|
||||
TEST_SETUP(mdns)
|
||||
{
|
||||
test_utils_record_free_mem();
|
||||
TEST_ESP_OK(test_utils_set_leak_level(0, ESP_LEAK_TYPE_CRITICAL, ESP_COMP_LEAK_GENERAL));
|
||||
}
|
||||
|
||||
TEST_TEAR_DOWN(mdns)
|
||||
{
|
||||
test_utils_finish_and_evaluate_leaks(32, 64);
|
||||
}
|
||||
|
||||
static void yield_to_all_priorities(void)
|
||||
{
|
||||
// Lower the test-task priority before testing to ensure other tasks got executed on forced context switch
|
||||
size_t test_task_prio_before = uxTaskPriorityGet(NULL);
|
||||
vTaskPrioritySet(NULL, tskIDLE_PRIORITY);
|
||||
taskYIELD(); // Let the RTOS to switch context
|
||||
vTaskPrioritySet(NULL, test_task_prio_before);
|
||||
}
|
||||
|
||||
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';
|
||||
}
|
||||
|
||||
TEST(mdns, api_fails_with_invalid_state)
|
||||
{
|
||||
TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_init());
|
||||
TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_instance_name_set(MDNS_INSTANCE));
|
||||
TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0));
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_STATE, mdns_register_hostname_changed_callback(hostname_changed_callback, NULL));
|
||||
}
|
||||
|
||||
TEST(mdns, init_deinit)
|
||||
{
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to complete initialization
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
|
||||
TEST(mdns, hostname_changed_callback)
|
||||
{
|
||||
hostname_changed_callback_context_t context = { 0 };
|
||||
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_register_hostname_changed_callback(NULL, NULL));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_register_hostname_changed_callback(hostname_changed_callback, &context));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
yield_to_all_priorities();
|
||||
TEST_ASSERT_EQUAL_UINT(1, context.count);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_HOSTNAME, context.hostname);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
yield_to_all_priorities();
|
||||
TEST_ASSERT_EQUAL_UINT(1, context.count);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set("renamed-hostname"));
|
||||
yield_to_all_priorities();
|
||||
TEST_ASSERT_EQUAL_UINT(2, context.count);
|
||||
TEST_ASSERT_EQUAL_STRING("renamed-hostname", context.hostname);
|
||||
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
|
||||
TEST(mdns, boolean_txt_null_value)
|
||||
{
|
||||
mdns_result_t *results = NULL;
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0));
|
||||
|
||||
mdns_txt_item_t txt_data[] = {
|
||||
{"bool", NULL},
|
||||
{"key", "value"},
|
||||
};
|
||||
const size_t txt_data_count = sizeof(txt_data) / sizeof(txt_data[0]);
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, txt_data, txt_data_count));
|
||||
yield_to_all_priorities();
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results->txt);
|
||||
TEST_ASSERT_EQUAL(txt_data_count, results->txt_count);
|
||||
|
||||
bool found_bool = false;
|
||||
for (size_t i = 0; i < results->txt_count; ++i) {
|
||||
if (strcmp(results->txt[i].key, "bool") == 0) {
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results->txt_value_len);
|
||||
TEST_ASSERT_EQUAL_UINT8(0, results->txt_value_len[i]);
|
||||
found_bool = true;
|
||||
}
|
||||
}
|
||||
TEST_ASSERT_TRUE(found_bool);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO));
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
|
||||
TEST(mdns, api_fails_with_expected_err)
|
||||
{
|
||||
mdns_txt_item_t serviceTxtData[CONFIG_MDNS_MAX_SERVICES] = { {NULL, NULL},
|
||||
};
|
||||
mdns_ip_addr_t addr;
|
||||
addr.addr.type = ESP_IPADDR_TYPE_V4;
|
||||
addr.addr.u_addr.ip4.addr = esp_ip4addr_aton("127.0.0.1");
|
||||
addr.next = NULL;
|
||||
for (int i = 0; i < CONFIG_MDNS_MAX_SERVICES; ++i) {
|
||||
serviceTxtData[i].key = "Key";
|
||||
serviceTxtData[i].value = "Value";
|
||||
}
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_delegate_hostname_add(MDNS_DELEGATE_HOSTNAME, &addr));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_TRUE(mdns_hostname_exists(MDNS_DELEGATE_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_instance_name_set(MDNS_INSTANCE));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, serviceTxtData, CONFIG_MDNS_MAX_SERVICES));
|
||||
TEST_ASSERT_FALSE(mdns_service_exists(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add_for_host(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME,
|
||||
MDNS_SERVICE_PORT, serviceTxtData, CONFIG_MDNS_MAX_SERVICES));
|
||||
TEST_ASSERT_TRUE(mdns_service_exists(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, serviceTxtData, CONFIG_MDNS_MAX_SERVICES));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_item_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, "key1", "value1"));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_item_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, "key1"));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_port_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 8080));
|
||||
yield_to_all_priorities(); // to remove the service with the updated txt records
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to remove the service
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_delegate_hostname_remove(MDNS_DELEGATE_HOSTNAME));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to remove the hostname
|
||||
TEST_ASSERT_FALSE(mdns_service_exists(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove_all());
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to remove all services
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_service_port_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 8080));
|
||||
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
|
||||
TEST(mdns, query_api_fails_with_expected_err)
|
||||
{
|
||||
mdns_result_t *results = NULL;
|
||||
esp_ip6_addr_t addr6;
|
||||
esp_ip4_addr_t addr4;
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
// check it is not possible to register a service or set an instance without configuring the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0));
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_instance_name_set(MDNS_INSTANCE));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
// hostname is set, now adding a service and instance should succeed
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_instance_name_set(MDNS_INSTANCE));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_query_ptr(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 10, CONFIG_MDNS_MAX_SERVICES, &results));
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_query_srv(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 10, &results));
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_query_txt(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 10, &results));
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, mdns_query_a(MDNS_HOSTNAME, 10, &addr4));
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, mdns_query_aaaa(MDNS_HOSTNAME, 10, &addr6));
|
||||
mdns_query_results_free(results);
|
||||
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
|
||||
TEST(mdns, add_remove_service)
|
||||
{
|
||||
mdns_result_t *results = NULL;
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE, results->instance_name);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_SERVICE_NAME, results->service_type);
|
||||
TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT, results->port);
|
||||
TEST_ASSERT_EQUAL(NULL, results->txt);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_subtype_add_for_host(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO,
|
||||
NULL, MDNS_SERVICE_SUBTYPE));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service_with_subtype(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO,
|
||||
MDNS_SERVICE_SUBTYPE, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE, results->instance_name);
|
||||
mdns_query_results_free(results);
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service_with_subtype(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO,
|
||||
"_unknown", 1, &results));
|
||||
TEST_ASSERT_EQUAL(NULL, results);
|
||||
|
||||
// Update service properties: port
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_port_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT + 1));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT + 1, results->port);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
// Update service properties: instance
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_instance_name_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_INSTANCE "1"));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(MDNS_INSTANCE "1", MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE "1", results->instance_name);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
// Update service properties: txt
|
||||
mdns_txt_item_t txt_data[] = {
|
||||
{"key1", "esp32"},
|
||||
{"key2", "value"},
|
||||
{"key3", "value3"},
|
||||
};
|
||||
const size_t txt_data_cout = sizeof(txt_data) / sizeof(txt_data[0]);
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, txt_data, txt_data_cout));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results->txt);
|
||||
TEST_ASSERT_EQUAL(txt_data_cout, results->txt_count);
|
||||
// compare txt values by keys
|
||||
size_t matches = 0;
|
||||
for (int i = 0; i < results->txt_count; ++i) // iterates over the results we get from mdns_lookup()
|
||||
for (int j = 0; j < txt_data_cout; ++j) // iterates over our test records
|
||||
if (strcmp(results->txt[i].key, txt_data[j].key) == 0) { // we compare the value only if the key matches
|
||||
TEST_ASSERT_EQUAL_STRING(results->txt[i].value, txt_data[j].value);
|
||||
++matches;
|
||||
}
|
||||
TEST_ASSERT_EQUAL(txt_data_cout, matches); // checks that we went over all our txt items
|
||||
mdns_query_results_free(results);
|
||||
|
||||
// Now remove the service
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_EQUAL(NULL, results);
|
||||
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
|
||||
TEST(mdns, add_remove_deleg_service)
|
||||
{
|
||||
mdns_ip_addr_t addr;
|
||||
addr.addr.type = ESP_IPADDR_TYPE_V4;
|
||||
addr.addr.u_addr.ip4.addr = esp_ip4addr_aton("127.0.0.1");
|
||||
addr.next = NULL;
|
||||
mdns_result_t *results = NULL;
|
||||
test_case_uses_tcpip();
|
||||
TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_init());
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_delegate_hostname_add(MDNS_DELEGATE_HOSTNAME, &addr));
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add_for_host(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, MDNS_SERVICE_PORT, NULL, 0));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE, results->instance_name);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_SERVICE_NAME, results->service_type);
|
||||
TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT, results->port);
|
||||
TEST_ASSERT_EQUAL(NULL, results->txt);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_subtype_add_for_host(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO,
|
||||
MDNS_DELEGATE_HOSTNAME, MDNS_SERVICE_SUBTYPE));
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service_with_subtype(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO,
|
||||
MDNS_SERVICE_SUBTYPE, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE, results->instance_name);
|
||||
mdns_query_results_free(results);
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service_with_subtype(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO,
|
||||
"_unknown", 1, &results));
|
||||
TEST_ASSERT_EQUAL(NULL, results);
|
||||
|
||||
// Update service properties: port
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_port_set_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, MDNS_SERVICE_PORT + 1));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT + 1, results->port);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
// Update service properties: instance
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_instance_name_set_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, MDNS_INSTANCE "1"));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(MDNS_INSTANCE "1", MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE "1", results->instance_name);
|
||||
mdns_query_results_free(results);
|
||||
|
||||
// Update service properties: txt
|
||||
mdns_txt_item_t txt_data[] = {
|
||||
{"key1", "esp32"},
|
||||
{"key2", "value"},
|
||||
};
|
||||
const size_t txt_data_cout = sizeof(txt_data) / sizeof(txt_data[0]);
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, txt_data, txt_data_cout));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results);
|
||||
TEST_ASSERT_NOT_EQUAL(NULL, results->txt);
|
||||
TEST_ASSERT_EQUAL(txt_data_cout, results->txt_count);
|
||||
// compare txt values by keys
|
||||
size_t matches = 0;
|
||||
for (int i = 0; i < results->txt_count; ++i) // iterates over the results we get from mdns_lookup()
|
||||
for (int j = 0; j < txt_data_cout; ++j) // iterates over our test records
|
||||
if (strcmp(results->txt[i].key, txt_data[j].key) == 0) { // we compare the value only if the key matches
|
||||
TEST_ASSERT_EQUAL_STRING(results->txt[i].value, txt_data[j].value);
|
||||
++matches;
|
||||
}
|
||||
TEST_ASSERT_EQUAL(txt_data_cout, matches); // checks that we went over all our txt items
|
||||
mdns_query_results_free(results);
|
||||
|
||||
// Now remove the service
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME));
|
||||
yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname
|
||||
TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results));
|
||||
TEST_ASSERT_EQUAL(NULL, results);
|
||||
|
||||
mdns_free();
|
||||
esp_event_loop_delete_default();
|
||||
}
|
||||
TEST_GROUP_RUNNER(mdns)
|
||||
{
|
||||
RUN_TEST_CASE(mdns, api_fails_with_invalid_state)
|
||||
RUN_TEST_CASE(mdns, api_fails_with_expected_err)
|
||||
RUN_TEST_CASE(mdns, query_api_fails_with_expected_err)
|
||||
RUN_TEST_CASE(mdns, init_deinit)
|
||||
RUN_TEST_CASE(mdns, add_remove_service)
|
||||
RUN_TEST_CASE(mdns, add_remove_deleg_service)
|
||||
RUN_TEST_CASE(mdns, boolean_txt_null_value)
|
||||
|
||||
}
|
||||
|
||||
void app_main(void)
|
||||
{
|
||||
UNITY_MAIN(mdns);
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
from pytest_embedded import Dut
|
||||
|
||||
|
||||
def test_mdns(dut: Dut) -> None:
|
||||
dut.expect_unity_test_output()
|
||||
@@ -0,0 +1,3 @@
|
||||
CONFIG_IDF_TARGET="esp32"
|
||||
CONFIG_UNITY_ENABLE_FIXTURE=y
|
||||
CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n
|
||||
@@ -0,0 +1,2 @@
|
||||
CONFIG_UNITY_ENABLE_FIXTURE=y
|
||||
CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n
|
||||
Reference in new issue
Block a user