espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-30 18:57:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

mdns: update mdns to use esp-netif for mdns supported services such as STA, AP, ETH

Browse Source 
removes also include dependency on lwip to use esp_netif defined address fields and structures


* Original commit: espressif/esp-idf@19e24fe61e
This commit is contained in:
David Cermak
2019-08-31 19:06:54 +02:00
committed by suren-gabrielyan-espressif
parent dfcefc38fd
commit 48b819bbc1
8 changed files with 226 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/mdns/CMakeLists.txt
View File

@ -3,5 +3,5 @@ idf_component_register(SRCS "mdns.c"
"mdns_networking.c" "mdns_networking.c"
INCLUDE_DIRS "include" INCLUDE_DIRS "include"
PRIV_INCLUDE_DIRS "private_include" PRIV_INCLUDE_DIRS "private_include"
REQUIRES lwip mbedtls console tcpip_adapter) REQUIRES lwip mbedtls console esp_netif)

18
components/mdns/include/mdns.h
View File

@ -18,7 +18,7 @@
extern "C" { extern "C" {
#endif #endif
#include <tcpip_adapter.h> #include <esp_netif.h>
#include "esp_event.h" #include "esp_event.h"
#define MDNS_TYPE_A 0x0001 #define MDNS_TYPE_A 0x0001
@ -52,17 +52,25 @@ typedef struct {
* @brief mDNS query linked list IP item * @brief mDNS query linked list IP item
*/ */
typedef struct mdns_ip_addr_s { typedef struct mdns_ip_addr_s {
ip_addr_t addr; /*!< IP address */ esp_ip_addr_t addr; /*!< IP address */
struct mdns_ip_addr_s * next; /*!< next IP, or NULL for the last IP in the list */ struct mdns_ip_addr_s * next; /*!< next IP, or NULL for the last IP in the list */
} mdns_ip_addr_t; } mdns_ip_addr_t;
typedef enum mdns_if_internal {
MDNS_IF_STA = 0,
MDNS_IF_AP = 1,
MDNS_IF_ETH = 2,
MDNS_IF_MAX
} mdns_if_t;
/** /**
* @brief mDNS query result structure * @brief mDNS query result structure
*/ */
typedef struct mdns_result_s { typedef struct mdns_result_s {
struct mdns_result_s * next; /*!< next result, or NULL for the last result in the list */ struct mdns_result_s * next; /*!< next result, or NULL for the last result in the list */
tcpip_adapter_if_t tcpip_if; /*!< interface on which the result came (AP/STA/ETH) */ mdns_if_t tcpip_if; /*!< interface index */
mdns_ip_protocol_t ip_protocol; /*!< ip_protocol type of the interface (v4/v6) */ mdns_ip_protocol_t ip_protocol; /*!< ip_protocol type of the interface (v4/v6) */
// PTR // PTR
char * instance_name; /*!< instance name */ char * instance_name; /*!< instance name */
@ -329,7 +337,7 @@ esp_err_t mdns_query_txt(const char * instance_name, const char * service_type,
* - ESP_ERR_NO_MEM memory error * - ESP_ERR_NO_MEM memory error
* - ESP_ERR_INVALID_ARG parameter error * - ESP_ERR_INVALID_ARG parameter error
*/ */
esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, ip4_addr_t * addr); esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, esp_ip4_addr_t * addr);
/** /**
* @brief Query mDNS for A record * @brief Query mDNS for A record
@ -344,7 +352,7 @@ esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, ip4_addr_t * ad
* - ESP_ERR_NO_MEM memory error * - ESP_ERR_NO_MEM memory error
* - ESP_ERR_INVALID_ARG parameter error * - ESP_ERR_INVALID_ARG parameter error
*/ */
esp_err_t mdns_query_aaaa(const char * host_name, uint32_t timeout, ip6_addr_t * addr); esp_err_t mdns_query_aaaa(const char * host_name, uint32_t timeout, esp_ip6_addr_t * addr);
/** /**
* @brief System event handler * @brief System event handler

269
components/mdns/mdns.c
View File

@ -37,11 +37,42 @@ static volatile TaskHandle_t _mdns_service_task_handle = NULL;
static SemaphoreHandle_t _mdns_service_semaphore = NULL; static SemaphoreHandle_t _mdns_service_semaphore = NULL;
static void _mdns_search_finish_done(void); static void _mdns_search_finish_done(void);
static mdns_search_once_t * _mdns_search_find_from(mdns_search_once_t * search, mdns_name_t * name, uint16_t type, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); static mdns_search_once_t * _mdns_search_find_from(mdns_search_once_t * search, mdns_name_t * name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
static void _mdns_search_result_add_ip(mdns_search_once_t * search, const char * hostname, ip_addr_t * ip, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); static void _mdns_search_result_add_ip(mdns_search_once_t * search, const char * hostname, esp_ip_addr_t * ip, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
static void _mdns_search_result_add_srv(mdns_search_once_t * search, const char * hostname, uint16_t port, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); static void _mdns_search_result_add_srv(mdns_search_once_t * search, const char * hostname, uint16_t port, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
static void _mdns_search_result_add_txt(mdns_search_once_t * search, mdns_txt_item_t * txt, size_t txt_count, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); static void _mdns_search_result_add_txt(mdns_search_once_t * search, mdns_txt_item_t * txt, size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
static mdns_result_t * _mdns_search_result_add_ptr(mdns_search_once_t * search, const char * instance, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); static mdns_result_t * _mdns_search_result_add_ptr(mdns_search_once_t * search, const char * instance, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
/*
* @brief Internal collection of mdns supported interfaces
*
*/
static esp_netif_t * s_esp_netifs[MDNS_IF_MAX] = {};
/*
* @brief Convert mnds if to esp-netif handle
*/
esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if)
{
if (tcpip_if < MDNS_IF_MAX) {
return s_esp_netifs[tcpip_if];
}
return NULL;
}
/*
* @brief Convert esp-netif handle to mnds if
*/
static mdns_if_t _mdns_get_if_from_esp_netif(esp_netif_t *interface)
{
for (int i=0; i<MDNS_IF_MAX; ++i) {
if (interface == s_esp_netifs[i])
return i;
}
return MDNS_IF_MAX;
}
static inline bool _str_null_or_empty(const char * str){ static inline bool _str_null_or_empty(const char * str){
return (str == NULL || *str == 0); return (str == NULL || *str == 0);
@ -801,23 +832,23 @@ static uint16_t _mdns_append_question(uint8_t * packet, uint16_t * index, mdns_o
* @brief Helper to get either ETH or STA if the other is provided * @brief Helper to get either ETH or STA if the other is provided
* Used when two interfaces are on the same subnet * Used when two interfaces are on the same subnet
*/ */
static tcpip_adapter_if_t _mdns_get_other_if (tcpip_adapter_if_t tcpip_if) static mdns_if_t _mdns_get_other_if (mdns_if_t tcpip_if)
{ {
if (tcpip_if == TCPIP_ADAPTER_IF_STA) { if (tcpip_if == MDNS_IF_STA) {
return TCPIP_ADAPTER_IF_ETH; return MDNS_IF_ETH;
} else if (tcpip_if == TCPIP_ADAPTER_IF_ETH) { } else if (tcpip_if == MDNS_IF_ETH) {
return TCPIP_ADAPTER_IF_STA; return MDNS_IF_STA;
} }
return TCPIP_ADAPTER_IF_MAX; return MDNS_IF_MAX;
} }
/** /**
* @brief Check if interface is duplicate (two interfaces on the same subnet) * @brief Check if interface is duplicate (two interfaces on the same subnet)
*/ */
static bool _mdns_if_is_dup(tcpip_adapter_if_t tcpip_if) static bool _mdns_if_is_dup(mdns_if_t tcpip_if)
{ {
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
if (other_if == TCPIP_ADAPTER_IF_MAX) { if (other_if == MDNS_IF_MAX) {
return false; return false;
} }
if (_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state == PCB_DUP if (_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state == PCB_DUP
@ -833,7 +864,7 @@ static bool _mdns_if_is_dup(tcpip_adapter_if_t tcpip_if)
/** /**
* @brief Check if IPv6 address is NULL * @brief Check if IPv6 address is NULL
*/ */
static bool _ipv6_address_is_zero(ip6_addr_t ip6) static bool _ipv6_address_is_zero(esp_ip6_addr_t ip6)
{ {
uint8_t i; uint8_t i;
uint8_t * data = (uint8_t *)ip6.addr; uint8_t * data = (uint8_t *)ip6.addr;
@ -850,7 +881,7 @@ static bool _ipv6_address_is_zero(ip6_addr_t ip6)
* *
* @return number of answers added to the packet * @return number of answers added to the packet
*/ */
static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_answer_t * answer, tcpip_adapter_if_t tcpip_if) static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_answer_t * answer, mdns_if_t tcpip_if)
{ {
if (answer->type == MDNS_TYPE_PTR) { if (answer->type == MDNS_TYPE_PTR) {
@ -871,11 +902,11 @@ static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_
} else if (answer->type == MDNS_TYPE_SDPTR) { } else if (answer->type == MDNS_TYPE_SDPTR) {
return _mdns_append_sdptr_record(packet, index, answer->service, answer->flush, answer->bye) > 0; return _mdns_append_sdptr_record(packet, index, answer->service, answer->flush, answer->bye) > 0;
} else if (answer->type == MDNS_TYPE_A) { } else if (answer->type == MDNS_TYPE_A) {
tcpip_adapter_ip_info_t if_ip_info; esp_netif_ip_info_t if_ip_info;
if (!_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].pcb && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state != PCB_DUP) { if (!_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].pcb && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state != PCB_DUP) {
return 0; return 0;
} }
if (tcpip_adapter_get_ip_info(tcpip_if, &if_ip_info)) { if (esp_netif_get_ip_info(_mdns_get_esp_netif(tcpip_if), &if_ip_info)) {
return 0; return 0;
} }
if (_mdns_append_a_record(packet, index, if_ip_info.ip.addr, answer->flush, answer->bye) <= 0) { if (_mdns_append_a_record(packet, index, if_ip_info.ip.addr, answer->flush, answer->bye) <= 0) {
@ -884,8 +915,8 @@ static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_
if (!_mdns_if_is_dup(tcpip_if)) { if (!_mdns_if_is_dup(tcpip_if)) {
return 1; return 1;
} }
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
if (tcpip_adapter_get_ip_info(other_if, &if_ip_info)) { if (esp_netif_get_ip_info(_mdns_get_esp_netif(other_if), &if_ip_info)) {
return 1; return 1;
} }
if (_mdns_append_a_record(packet, index, if_ip_info.ip.addr, answer->flush, answer->bye) > 0) { if (_mdns_append_a_record(packet, index, if_ip_info.ip.addr, answer->flush, answer->bye) > 0) {
@ -893,11 +924,11 @@ static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_
} }
return 1; return 1;
} else if (answer->type == MDNS_TYPE_AAAA) { } else if (answer->type == MDNS_TYPE_AAAA) {
struct ip6_addr if_ip6; struct esp_ip6_addr if_ip6;
if (!_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].pcb && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state != PCB_DUP) { if (!_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].pcb && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state != PCB_DUP) {
return 0; return 0;
} }
if (tcpip_adapter_get_ip6_linklocal(tcpip_if, &if_ip6)) { if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(tcpip_if), &if_ip6)) {
return 0; return 0;
} }
if (_ipv6_address_is_zero(if_ip6)) { if (_ipv6_address_is_zero(if_ip6)) {
@ -909,8 +940,8 @@ static uint8_t _mdns_append_answer(uint8_t * packet, uint16_t * index, mdns_out_
if (!_mdns_if_is_dup(tcpip_if)) { if (!_mdns_if_is_dup(tcpip_if)) {
return 1; return 1;
} }
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
if (tcpip_adapter_get_ip6_linklocal(other_if, &if_ip6)) { if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(other_if), &if_ip6)) {
return 1; return 1;
} }
if (_mdns_append_aaaa_record(packet, index, (uint8_t*)if_ip6.addr, answer->flush, answer->bye) > 0) { if (_mdns_append_aaaa_record(packet, index, (uint8_t*)if_ip6.addr, answer->flush, answer->bye) > 0) {
@ -1046,7 +1077,7 @@ static void _mdns_clear_tx_queue_head(void)
* @param tcpip_if the interface * @param tcpip_if the interface
* @param ip_protocol pcb type V4/V6 * @param ip_protocol pcb type V4/V6
*/ */
static void _mdns_clear_pcb_tx_queue_head(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _mdns_clear_pcb_tx_queue_head(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_tx_packet_t * q, * p; mdns_tx_packet_t * q, * p;
while (_mdns_server->tx_queue_head && _mdns_server->tx_queue_head->tcpip_if == tcpip_if && _mdns_server->tx_queue_head->ip_protocol == ip_protocol) { while (_mdns_server->tx_queue_head && _mdns_server->tx_queue_head->tcpip_if == tcpip_if && _mdns_server->tx_queue_head->ip_protocol == ip_protocol) {
@ -1074,7 +1105,7 @@ static void _mdns_clear_pcb_tx_queue_head(tcpip_adapter_if_t tcpip_if, mdns_ip_p
* @param tcpip_if the interface * @param tcpip_if the interface
* @param ip_protocol pcb type V4/V6 * @param ip_protocol pcb type V4/V6
*/ */
static mdns_tx_packet_t * _mdns_get_next_pcb_packet(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static mdns_tx_packet_t * _mdns_get_next_pcb_packet(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_tx_packet_t * q = _mdns_server->tx_queue_head; mdns_tx_packet_t * q = _mdns_server->tx_queue_head;
while (q) { while (q) {
@ -1089,7 +1120,7 @@ static mdns_tx_packet_t * _mdns_get_next_pcb_packet(tcpip_adapter_if_t tcpip_if,
/** /**
* @brief Find, remove and free answer from the scheduled packets * @brief Find, remove and free answer from the scheduled packets
*/ */
static void _mdns_remove_scheduled_answer(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint16_t type, mdns_srv_item_t * service) static void _mdns_remove_scheduled_answer(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint16_t type, mdns_srv_item_t * service)
{ {
mdns_srv_item_t s = {NULL, NULL}; mdns_srv_item_t s = {NULL, NULL};
if (!service) { if (!service) {
@ -1178,7 +1209,7 @@ static bool _mdns_alloc_answer(mdns_out_answer_t ** destnation, uint16_t type, m
/** /**
* @brief Allocate new packet for sending * @brief Allocate new packet for sending
*/ */
static mdns_tx_packet_t * _mdns_alloc_packet_default(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static mdns_tx_packet_t * _mdns_alloc_packet_default(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_tx_packet_t * packet = (mdns_tx_packet_t*)malloc(sizeof(mdns_tx_packet_t)); mdns_tx_packet_t * packet = (mdns_tx_packet_t*)malloc(sizeof(mdns_tx_packet_t));
if (!packet) { if (!packet) {
@ -1192,8 +1223,8 @@ static mdns_tx_packet_t * _mdns_alloc_packet_default(tcpip_adapter_if_t tcpip_if
if (ip_protocol == MDNS_IP_PROTOCOL_V4) { if (ip_protocol == MDNS_IP_PROTOCOL_V4) {
IP_ADDR4(&packet->dst, 224, 0, 0, 251); IP_ADDR4(&packet->dst, 224, 0, 0, 251);
} else { } else {
ip_addr_t addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000); esp_ip_addr_t addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000);
memcpy(&packet->dst, &addr, sizeof(ip_addr_t)); memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t));
} }
return packet; return packet;
} }
@ -1275,7 +1306,7 @@ static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t * parsed
q = q->next; q = q->next;
} }
if (unicast || !send_flush) { if (unicast || !send_flush) {
memcpy(&packet->dst, &parsed_packet->src, sizeof(ip_addr_t)); memcpy(&packet->dst, &parsed_packet->src, sizeof(esp_ip_addr_t));
packet->port = parsed_packet->src_port; packet->port = parsed_packet->src_port;
} }
@ -1309,7 +1340,7 @@ static bool _mdns_question_exists(mdns_out_question_t * needle, mdns_out_questio
/** /**
* @brief Create probe packet for particular services on particular PCB * @brief Create probe packet for particular services on particular PCB
*/ */
static mdns_tx_packet_t * _mdns_create_probe_packet(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t * services[], size_t len, bool first, bool include_ip) static mdns_tx_packet_t * _mdns_create_probe_packet(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t * services[], size_t len, bool first, bool include_ip)
{ {
mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol);
if (!packet) { if (!packet) {
@ -1385,7 +1416,7 @@ static mdns_tx_packet_t * _mdns_create_probe_packet(tcpip_adapter_if_t tcpip_if,
/** /**
* @brief Create announce packet for particular services on particular PCB * @brief Create announce packet for particular services on particular PCB
*/ */
static mdns_tx_packet_t * _mdns_create_announce_packet(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t * services[], size_t len, bool include_ip) static mdns_tx_packet_t * _mdns_create_announce_packet(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t * services[], size_t len, bool include_ip)
{ {
mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol);
if (!packet) { if (!packet) {
@ -1451,7 +1482,7 @@ static mdns_tx_packet_t * _mdns_create_announce_from_probe(mdns_tx_packet_t * pr
/** /**
* @brief Send by for particular services on particular PCB * @brief Send by for particular services on particular PCB
*/ */
static void _mdns_pcb_send_bye(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool include_ip) static void _mdns_pcb_send_bye(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool include_ip)
{ {
mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol);
if (!packet) { if (!packet) {
@ -1476,7 +1507,7 @@ static void _mdns_pcb_send_bye(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t i
/** /**
* @brief Send probe for additional services on particular PCB * @brief Send probe for additional services on particular PCB
*/ */
static void _mdns_init_pcb_probe_new_service(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool probe_ip) static void _mdns_init_pcb_probe_new_service(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool probe_ip)
{ {
mdns_pcb_t * pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol]; mdns_pcb_t * pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol];
size_t services_final_len = len; size_t services_final_len = len;
@ -1532,7 +1563,7 @@ static void _mdns_init_pcb_probe_new_service(tcpip_adapter_if_t tcpip_if, mdns_i
* - If pcb probing then add only non-probing services and restarts probing * - If pcb probing then add only non-probing services and restarts probing
* - If pcb not probing, run probing for all specified services * - If pcb not probing, run probing for all specified services
*/ */
static void _mdns_init_pcb_probe(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool probe_ip) static void _mdns_init_pcb_probe(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool probe_ip)
{ {
mdns_pcb_t * pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol]; mdns_pcb_t * pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol];
@ -1572,7 +1603,7 @@ static void _mdns_init_pcb_probe(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t
/** /**
* @brief Restart the responder on particular PCB * @brief Restart the responder on particular PCB
*/ */
static void _mdns_restart_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _mdns_restart_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
size_t srv_count = 0; size_t srv_count = 0;
mdns_srv_item_t * a = _mdns_server->services; mdns_srv_item_t * a = _mdns_server->services;
@ -1600,10 +1631,10 @@ static void _mdns_send_bye(mdns_srv_item_t ** services, size_t len, bool include
return; return;
} }
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) { for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
if (_mdns_server->interfaces[i].pcbs[j].pcb && _mdns_server->interfaces[i].pcbs[j].state == PCB_RUNNING) { if (_mdns_server->interfaces[i].pcbs[j].pcb && _mdns_server->interfaces[i].pcbs[j].state == PCB_RUNNING) {
_mdns_pcb_send_bye((tcpip_adapter_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip); _mdns_pcb_send_bye((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip);
} }
} }
} }
@ -1612,7 +1643,7 @@ static void _mdns_send_bye(mdns_srv_item_t ** services, size_t len, bool include
/** /**
* @brief Send announcement on particular PCB * @brief Send announcement on particular PCB
*/ */
static void _mdns_announce_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool include_ip) static void _mdns_announce_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t ** services, size_t len, bool include_ip)
{ {
mdns_pcb_t * _pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol]; mdns_pcb_t * _pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol];
size_t i; size_t i;
@ -1659,7 +1690,7 @@ static void _mdns_announce_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t i
static void _mdns_probe_all_pcbs(mdns_srv_item_t ** services, size_t len, bool probe_ip, bool clear_old_probe) static void _mdns_probe_all_pcbs(mdns_srv_item_t ** services, size_t len, bool probe_ip, bool clear_old_probe)
{ {
uint8_t i, j; uint8_t i, j;
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) { for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
if (_mdns_server->interfaces[i].pcbs[j].pcb) { if (_mdns_server->interfaces[i].pcbs[j].pcb) {
mdns_pcb_t * _pcb = &_mdns_server->interfaces[i].pcbs[j]; mdns_pcb_t * _pcb = &_mdns_server->interfaces[i].pcbs[j];
@ -1669,7 +1700,7 @@ static void _mdns_probe_all_pcbs(mdns_srv_item_t ** services, size_t len, bool p
_pcb->probe_services_len = 0; _pcb->probe_services_len = 0;
_pcb->probe_running = false; _pcb->probe_running = false;
} }
_mdns_init_pcb_probe((tcpip_adapter_if_t)i, (mdns_ip_protocol_t)j, services, len, probe_ip); _mdns_init_pcb_probe((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, probe_ip);
} }
} }
} }
@ -1681,9 +1712,9 @@ static void _mdns_probe_all_pcbs(mdns_srv_item_t ** services, size_t len, bool p
static void _mdns_announce_all_pcbs(mdns_srv_item_t ** services, size_t len, bool include_ip) static void _mdns_announce_all_pcbs(mdns_srv_item_t ** services, size_t len, bool include_ip)
{ {
uint8_t i, j; uint8_t i, j;
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) { for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
_mdns_announce_pcb((tcpip_adapter_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip); _mdns_announce_pcb((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip);
} }
} }
} }
@ -2141,10 +2172,10 @@ static int _mdns_check_txt_collision(mdns_service_t * service, const uint8_t * d
/** /**
* @brief Set interface as duplicate if another is found on the same subnet * @brief Set interface as duplicate if another is found on the same subnet
*/ */
static void _mdns_dup_interface(tcpip_adapter_if_t tcpip_if) static void _mdns_dup_interface(mdns_if_t tcpip_if)
{ {
uint8_t i; uint8_t i;
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
for (i=0; i<MDNS_IP_PROTOCOL_MAX; i++) { for (i=0; i<MDNS_IP_PROTOCOL_MAX; i++) {
if (_mdns_server->interfaces[other_if].pcbs[i].pcb) { if (_mdns_server->interfaces[other_if].pcbs[i].pcb) {
//stop this interface and mark as dup //stop this interface and mark as dup
@ -2161,27 +2192,27 @@ static void _mdns_dup_interface(tcpip_adapter_if_t tcpip_if)
/** /**
* @brief Detect IPv4 address collision * @brief Detect IPv4 address collision
*/ */
static int _mdns_check_a_collision(ip4_addr_t * ip, tcpip_adapter_if_t tcpip_if) static int _mdns_check_a_collision(esp_ip4_addr_t * ip, mdns_if_t tcpip_if)
{ {
tcpip_adapter_ip_info_t if_ip_info; esp_netif_ip_info_t if_ip_info;
tcpip_adapter_ip_info_t other_ip_info; esp_netif_ip_info_t other_ip_info;
if (!ip->addr) { if (!ip->addr) {
return 1;//denial! they win return 1;//denial! they win
} }
if (tcpip_adapter_get_ip_info(tcpip_if, &if_ip_info)) { if (esp_netif_get_ip_info(_mdns_get_esp_netif(tcpip_if), &if_ip_info)) {
return 1;//they win return 1;//they win
} }
int ret = memcmp((uint8_t*)&if_ip_info.ip.addr, (uint8_t*)&ip->addr, sizeof(ip4_addr_t)); int ret = memcmp((uint8_t*)&if_ip_info.ip.addr, (uint8_t*)&ip->addr, sizeof(esp_ip4_addr_t));
if (ret > 0) { if (ret > 0) {
return -1;//we win return -1;//we win
} else if (ret < 0) { } else if (ret < 0) {
//is it the other interface? //is it the other interface?
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
if (other_if == TCPIP_ADAPTER_IF_MAX) { if (other_if == MDNS_IF_MAX) {
return 1;//AP interface! They win return 1;//AP interface! They win
} }
if (tcpip_adapter_get_ip_info(other_if, &other_ip_info)) { if (esp_netif_get_ip_info(_mdns_get_esp_netif(other_if), &other_ip_info)) {
return 1;//IPv4 not active! They win return 1;//IPv4 not active! They win
} }
if (ip->addr != other_ip_info.ip.addr) { if (ip->addr != other_ip_info.ip.addr) {
@ -2196,14 +2227,14 @@ static int _mdns_check_a_collision(ip4_addr_t * ip, tcpip_adapter_if_t tcpip_if)
/** /**
* @brief Detect IPv6 address collision * @brief Detect IPv6 address collision
*/ */
static int _mdns_check_aaaa_collision(ip6_addr_t * ip, tcpip_adapter_if_t tcpip_if) static int _mdns_check_aaaa_collision(esp_ip6_addr_t * ip, mdns_if_t tcpip_if)
{ {
struct ip6_addr if_ip6; struct esp_ip6_addr if_ip6;
struct ip6_addr other_ip6; struct esp_ip6_addr other_ip6;
if (_ipv6_address_is_zero(*ip)) { if (_ipv6_address_is_zero(*ip)) {
return 1;//denial! they win return 1;//denial! they win
} }
if (tcpip_adapter_get_ip6_linklocal(tcpip_if, &if_ip6)) { if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(tcpip_if), &if_ip6)) {
return 1;//they win return 1;//they win
} }
int ret = memcmp((uint8_t*)&if_ip6.addr, (uint8_t*)ip->addr, _MDNS_SIZEOF_IP6_ADDR); int ret = memcmp((uint8_t*)&if_ip6.addr, (uint8_t*)ip->addr, _MDNS_SIZEOF_IP6_ADDR);
@ -2211,11 +2242,11 @@ static int _mdns_check_aaaa_collision(ip6_addr_t * ip, tcpip_adapter_if_t tcpip_
return -1;//we win return -1;//we win
} else if (ret < 0) { } else if (ret < 0) {
//is it the other interface? //is it the other interface?
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
if (other_if == TCPIP_ADAPTER_IF_MAX) { if (other_if == MDNS_IF_MAX) {
return 1;//AP interface! They win return 1;//AP interface! They win
} }
if (tcpip_adapter_get_ip6_linklocal(other_if, &other_ip6)) { if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(other_if), &other_ip6)) {
return 1;//IPv6 not active! They win return 1;//IPv6 not active! They win
} }
if (memcmp((uint8_t*)&other_ip6.addr, (uint8_t*)ip->addr, _MDNS_SIZEOF_IP6_ADDR)) { if (memcmp((uint8_t*)&other_ip6.addr, (uint8_t*)ip->addr, _MDNS_SIZEOF_IP6_ADDR)) {
@ -2917,7 +2948,7 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
} }
} else if (type == MDNS_TYPE_AAAA) {//ipv6 } else if (type == MDNS_TYPE_AAAA) {//ipv6
ip_addr_t ip6; esp_ip_addr_t ip6;
ip6.type = IPADDR_TYPE_V6; ip6.type = IPADDR_TYPE_V6;
memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE); memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE);
if (search_result) { if (search_result) {
@ -2963,7 +2994,7 @@ void mdns_parse_packet(mdns_rx_packet_t * packet)
} }
} else if (type == MDNS_TYPE_A) { } else if (type == MDNS_TYPE_A) {
ip_addr_t ip; esp_ip_addr_t ip;
ip.type = IPADDR_TYPE_V4; ip.type = IPADDR_TYPE_V4;
memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4); memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4);
if (search_result) { if (search_result) {
@ -3037,7 +3068,7 @@ clear_rx_packet:
/** /**
* @brief Enable mDNS interface * @brief Enable mDNS interface
*/ */
void _mdns_enable_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) void _mdns_enable_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
if (!_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) { if (!_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) {
if (_mdns_pcb_init(tcpip_if, ip_protocol)) { if (_mdns_pcb_init(tcpip_if, ip_protocol)) {
@ -3050,13 +3081,13 @@ void _mdns_enable_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protoco
/** /**
* @brief Disable mDNS interface * @brief Disable mDNS interface
*/ */
void _mdns_disable_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) void _mdns_disable_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) { if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) {
_mdns_clear_pcb_tx_queue_head(tcpip_if, ip_protocol); _mdns_clear_pcb_tx_queue_head(tcpip_if, ip_protocol);
_mdns_pcb_deinit(tcpip_if, ip_protocol); _mdns_pcb_deinit(tcpip_if, ip_protocol);
tcpip_adapter_if_t other_if = _mdns_get_other_if (tcpip_if); mdns_if_t other_if = _mdns_get_other_if (tcpip_if);
if (other_if != TCPIP_ADAPTER_IF_MAX && _mdns_server->interfaces[other_if].pcbs[ip_protocol].state == PCB_DUP) { if (other_if != MDNS_IF_MAX && _mdns_server->interfaces[other_if].pcbs[ip_protocol].state == PCB_DUP) {
_mdns_server->interfaces[other_if].pcbs[ip_protocol].state = PCB_OFF; _mdns_server->interfaces[other_if].pcbs[ip_protocol].state = PCB_OFF;
_mdns_enable_pcb(other_if, ip_protocol); _mdns_enable_pcb(other_if, ip_protocol);
} }
@ -3068,32 +3099,41 @@ void _mdns_disable_pcb(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protoc
* @brief Dispatch interface changes based on system events * @brief Dispatch interface changes based on system events
*/ */
static void _mdns_handle_system_event(esp_event_base_t event_base, static void _mdns_handle_system_event(esp_event_base_t event_base,
int32_t event_id, tcpip_adapter_if_t interface) int32_t event_id, esp_netif_t* interface)
{ {
if (!_mdns_server) { if (!_mdns_server) {
return; return;
} }
tcpip_adapter_dhcp_status_t dcst; // Initialize handles to esp-netif if appropriate mdns supported interface started
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
s_esp_netifs[MDNS_IF_STA] = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
} else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_START) {
s_esp_netifs[MDNS_IF_AP] = esp_netif_get_handle_from_ifkey("WIFI_AP_DEF");
} else if (event_base == ETH_EVENT && event_id == ETHERNET_EVENT_START) {
s_esp_netifs[MDNS_IF_ETH] = esp_netif_get_handle_from_ifkey("ETH_DEF");
}
esp_netif_dhcp_status_t dcst;
if (event_base == WIFI_EVENT) { if (event_base == WIFI_EVENT) {
switch(event_id) { switch(event_id) {
case WIFI_EVENT_STA_CONNECTED: case WIFI_EVENT_STA_CONNECTED:
if (!tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_STA, &dcst)) { if (!esp_netif_dhcpc_get_status(_mdns_get_esp_netif(MDNS_IF_STA), &dcst)) {
if (dcst == TCPIP_ADAPTER_DHCP_STOPPED) { if (dcst == ESP_NETIF_DHCP_STOPPED) {
_mdns_enable_pcb(TCPIP_ADAPTER_IF_STA, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4);
} }
} }
break; break;
case WIFI_EVENT_STA_DISCONNECTED: case WIFI_EVENT_STA_DISCONNECTED:
_mdns_disable_pcb(TCPIP_ADAPTER_IF_STA, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4);
_mdns_disable_pcb(TCPIP_ADAPTER_IF_STA, MDNS_IP_PROTOCOL_V6); _mdns_disable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V6);
break; break;
case WIFI_EVENT_AP_START: case WIFI_EVENT_AP_START:
_mdns_enable_pcb(TCPIP_ADAPTER_IF_AP, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V4);
break; break;
case WIFI_EVENT_AP_STOP: case WIFI_EVENT_AP_STOP:
_mdns_disable_pcb(TCPIP_ADAPTER_IF_AP, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V4);
_mdns_disable_pcb(TCPIP_ADAPTER_IF_AP, MDNS_IP_PROTOCOL_V6); _mdns_disable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V6);
break; break;
default: default:
break; break;
@ -3103,15 +3143,15 @@ static void _mdns_handle_system_event(esp_event_base_t event_base,
else if (event_base == ETH_EVENT) { else if (event_base == ETH_EVENT) {
switch (event_id) { switch (event_id) {
case ETHERNET_EVENT_CONNECTED: case ETHERNET_EVENT_CONNECTED:
if (!tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_ETH, &dcst)) { if (!esp_netif_dhcpc_get_status(_mdns_get_esp_netif(MDNS_IF_ETH), &dcst)) {
if (dcst == TCPIP_ADAPTER_DHCP_STOPPED) { if (dcst == ESP_NETIF_DHCP_STOPPED) {
_mdns_enable_pcb(TCPIP_ADAPTER_IF_ETH, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4);
} }
} }
break; break;
case ETHERNET_EVENT_DISCONNECTED: case ETHERNET_EVENT_DISCONNECTED:
_mdns_disable_pcb(TCPIP_ADAPTER_IF_ETH, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4);
_mdns_disable_pcb(TCPIP_ADAPTER_IF_ETH, MDNS_IP_PROTOCOL_V6); _mdns_disable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V6);
break; break;
default: default:
break; break;
@ -3121,17 +3161,21 @@ static void _mdns_handle_system_event(esp_event_base_t event_base,
else if (event_base == IP_EVENT) { else if (event_base == IP_EVENT) {
switch (event_id) { switch (event_id) {
case IP_EVENT_STA_GOT_IP: case IP_EVENT_STA_GOT_IP:
_mdns_enable_pcb(TCPIP_ADAPTER_IF_STA, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4);
_mdns_announce_pcb(TCPIP_ADAPTER_IF_STA, MDNS_IP_PROTOCOL_V6, NULL, 0, true); _mdns_announce_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V6, NULL, 0, true);
break; break;
#if CONFIG_ETH_ENABLED #if CONFIG_ETH_ENABLED
case IP_EVENT_ETH_GOT_IP: case IP_EVENT_ETH_GOT_IP:
_mdns_enable_pcb(TCPIP_ADAPTER_IF_ETH, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4);
break; break;
#endif #endif
case IP_EVENT_GOT_IP6: case IP_EVENT_GOT_IP6:
_mdns_enable_pcb(interface, MDNS_IP_PROTOCOL_V6); {
_mdns_announce_pcb(interface, MDNS_IP_PROTOCOL_V4, NULL, 0, true); mdns_if_t mdns_if = _mdns_get_if_from_esp_netif(interface);
_mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6);
_mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V4, NULL, 0, true);
}
break; break;
default: default:
break; break;
@ -3248,7 +3292,7 @@ static void _mdns_search_finish_done(void)
/** /**
* @brief Create linked IP (copy) from parsed one * @brief Create linked IP (copy) from parsed one
*/ */
static mdns_ip_addr_t * _mdns_result_addr_create_ip(ip_addr_t * ip) static mdns_ip_addr_t * _mdns_result_addr_create_ip(esp_ip_addr_t * ip)
{ {
mdns_ip_addr_t * a = (mdns_ip_addr_t *)malloc(sizeof(mdns_ip_addr_t)); mdns_ip_addr_t * a = (mdns_ip_addr_t *)malloc(sizeof(mdns_ip_addr_t));
if (!a) { if (!a) {
@ -3268,7 +3312,7 @@ static mdns_ip_addr_t * _mdns_result_addr_create_ip(ip_addr_t * ip)
/** /**
* @brief Chain new IP to search result * @brief Chain new IP to search result
*/ */
static void _mdns_result_add_ip(mdns_result_t * r, ip_addr_t * ip) static void _mdns_result_add_ip(mdns_result_t * r, esp_ip_addr_t * ip)
{ {
mdns_ip_addr_t * a = r->addr; mdns_ip_addr_t * a = r->addr;
while (a) { while (a) {
@ -3293,7 +3337,7 @@ static void _mdns_result_add_ip(mdns_result_t * r, ip_addr_t * ip)
/** /**
* @brief Called from parser to add A/AAAA data to search result * @brief Called from parser to add A/AAAA data to search result
*/ */
static void _mdns_search_result_add_ip(mdns_search_once_t * search, const char * hostname, ip_addr_t * ip, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _mdns_search_result_add_ip(mdns_search_once_t * search, const char * hostname, esp_ip_addr_t * ip, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_result_t * r = NULL; mdns_result_t * r = NULL;
mdns_ip_addr_t * a = NULL; mdns_ip_addr_t * a = NULL;
@ -3346,7 +3390,7 @@ static void _mdns_search_result_add_ip(mdns_search_once_t * search, const char *
/** /**
* @brief Called from parser to add PTR data to search result * @brief Called from parser to add PTR data to search result
*/ */
static mdns_result_t * _mdns_search_result_add_ptr(mdns_search_once_t * search, const char * instance, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static mdns_result_t * _mdns_search_result_add_ptr(mdns_search_once_t * search, const char * instance, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_result_t * r = search->result; mdns_result_t * r = search->result;
while (r) { while (r) {
@ -3382,7 +3426,7 @@ static mdns_result_t * _mdns_search_result_add_ptr(mdns_search_once_t * search,
/** /**
* @brief Called from parser to add SRV data to search result * @brief Called from parser to add SRV data to search result
*/ */
static void _mdns_search_result_add_srv(mdns_search_once_t * search, const char * hostname, uint16_t port, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _mdns_search_result_add_srv(mdns_search_once_t * search, const char * hostname, uint16_t port, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_result_t * r = search->result; mdns_result_t * r = search->result;
while (r) { while (r) {
@ -3416,7 +3460,7 @@ static void _mdns_search_result_add_srv(mdns_search_once_t * search, const char
/** /**
* @brief Called from parser to add TXT data to search result * @brief Called from parser to add TXT data to search result
*/ */
static void _mdns_search_result_add_txt(mdns_search_once_t * search, mdns_txt_item_t * txt, size_t txt_count, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _mdns_search_result_add_txt(mdns_search_once_t * search, mdns_txt_item_t * txt, size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
int i; int i;
mdns_result_t * r = search->result; mdns_result_t * r = search->result;
@ -3460,7 +3504,7 @@ free_txt:
/** /**
* @brief Called from packet parser to find matching running search * @brief Called from packet parser to find matching running search
*/ */
static mdns_search_once_t * _mdns_search_find_from(mdns_search_once_t * s, mdns_name_t * name, uint16_t type, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static mdns_search_once_t * _mdns_search_find_from(mdns_search_once_t * s, mdns_name_t * name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_result_t * r = NULL; mdns_result_t * r = NULL;
while (s) { while (s) {
@ -3530,7 +3574,7 @@ static mdns_search_once_t * _mdns_search_find_from(mdns_search_once_t * s, mdns_
/** /**
* @brief Create search packet for partidular interface * @brief Create search packet for partidular interface
*/ */
static mdns_tx_packet_t * _mdns_create_search_packet(mdns_search_once_t * search, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static mdns_tx_packet_t * _mdns_create_search_packet(mdns_search_once_t * search, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_result_t * r = NULL; mdns_result_t * r = NULL;
mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); mdns_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol);
@ -3586,7 +3630,7 @@ static mdns_tx_packet_t * _mdns_create_search_packet(mdns_search_once_t * search
/** /**
* @brief Send search packet to particular interface * @brief Send search packet to particular interface
*/ */
static void _mdns_search_send_pcb(mdns_search_once_t * search, tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _mdns_search_send_pcb(mdns_search_once_t * search, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_tx_packet_t * packet = NULL; mdns_tx_packet_t * packet = NULL;
if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb && _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state > PCB_INIT) { if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb && _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state > PCB_INIT) {
@ -3621,9 +3665,9 @@ static void _mdns_search_send(mdns_search_once_t * search)
} }
uint8_t i, j; uint8_t i, j;
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) { for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
_mdns_search_send_pcb(search, (tcpip_adapter_if_t)i, (mdns_ip_protocol_t)j); _mdns_search_send_pcb(search, (mdns_if_t)i, (mdns_ip_protocol_t)j);
} }
} }
} }
@ -4161,7 +4205,7 @@ static void event_handler(void* arg, esp_event_base_t event_base,
action->data.sys_event.event_id = event_id; action->data.sys_event.event_id = event_id;
if (event_base == IP_EVENT && event_id == IP_EVENT_GOT_IP6) { if (event_base == IP_EVENT && event_id == IP_EVENT_GOT_IP6) {
ip_event_got_ip6_t* event = (ip_event_got_ip6_t*) event_data; ip_event_got_ip6_t* event = (ip_event_got_ip6_t*) event_data;
action->data.sys_event.interface = tcpip_adapter_if_from_esp_netif(event->esp_netif); action->data.sys_event.interface = event->esp_netif;
} }
if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) {
@ -4207,14 +4251,14 @@ esp_err_t mdns_init(void)
} }
#endif #endif
uint8_t i; uint8_t i;
ip6_addr_t tmp_addr6; esp_ip6_addr_t tmp_addr6;
tcpip_adapter_ip_info_t if_ip_info; esp_netif_ip_info_t if_ip_info;
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
if (!tcpip_adapter_get_ip6_linklocal(i, &tmp_addr6) && !_ipv6_address_is_zero(tmp_addr6)) { if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(i), &tmp_addr6) && !_ipv6_address_is_zero(tmp_addr6)) {
_mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V6); _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V6);
} }
if (!tcpip_adapter_get_ip_info(i, &if_ip_info) && if_ip_info.ip.addr) { if (!esp_netif_get_ip_info(_mdns_get_esp_netif(i), &if_ip_info) && if_ip_info.ip.addr) {
_mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V4); _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V4);
} }
} }
@ -4228,7 +4272,7 @@ esp_err_t mdns_init(void)
return ESP_OK; return ESP_OK;
free_all_and_disable_pcbs: free_all_and_disable_pcbs:
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
_mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V6); _mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V6);
_mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V4);
} }
@ -4255,7 +4299,7 @@ void mdns_free(void)
} }
mdns_service_remove_all(); mdns_service_remove_all();
_mdns_service_task_stop(); _mdns_service_task_stop();
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) { for (j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
_mdns_pcb_deinit(i, j); _mdns_pcb_deinit(i, j);
} }
@ -4711,7 +4755,7 @@ esp_err_t mdns_query_txt(const char * instance, const char * service, const char
return mdns_query(instance, service, proto, MDNS_TYPE_TXT, timeout, 1, result); return mdns_query(instance, service, proto, MDNS_TYPE_TXT, timeout, 1, result);
} }
esp_err_t mdns_query_a(const char * name, uint32_t timeout, ip4_addr_t * addr) esp_err_t mdns_query_a(const char * name, uint32_t timeout, esp_ip4_addr_t * addr)
{ {
mdns_result_t * result = NULL; mdns_result_t * result = NULL;
esp_err_t err; esp_err_t err;
@ -4744,7 +4788,7 @@ esp_err_t mdns_query_a(const char * name, uint32_t timeout, ip4_addr_t * addr)
return ESP_ERR_NOT_FOUND; return ESP_ERR_NOT_FOUND;
} }
esp_err_t mdns_query_aaaa(const char * name, uint32_t timeout, ip6_addr_t * addr) esp_err_t mdns_query_aaaa(const char * name, uint32_t timeout, esp_ip6_addr_t * addr)
{ {
mdns_result_t * result = NULL; mdns_result_t * result = NULL;
esp_err_t err; esp_err_t err;
@ -4964,12 +5008,17 @@ void mdns_debug_packet(const uint8_t * data, size_t len)
} }
_mdns_dbg_printf("\n"); _mdns_dbg_printf("\n");
} else if (type == MDNS_TYPE_AAAA) { } else if (type == MDNS_TYPE_AAAA) {
<<<<<<< HEAD
ip6_addr_t ip6; ip6_addr_t ip6;
memcpy(&ip6, data_ptr, MDNS_ANSWER_AAAA_SIZE); memcpy(&ip6, data_ptr, MDNS_ANSWER_AAAA_SIZE);
=======
esp_ip6_addr_t ip6;
memcpy(&ip6, data_ptr, sizeof(esp_ip6_addr_t));
>>>>>>> mdns: update mdns to use esp-netif for mdns supported services such as STA, AP, ETH
_mdns_dbg_printf(IPV6STR "\n", IPV62STR(ip6)); _mdns_dbg_printf(IPV6STR "\n", IPV62STR(ip6));
} else if (type == MDNS_TYPE_A) { } else if (type == MDNS_TYPE_A) {
ip4_addr_t ip; esp_ip4_addr_t ip;
memcpy(&ip, data_ptr, sizeof(ip4_addr_t)); memcpy(&ip, data_ptr, sizeof(esp_ip4_addr_t));
_mdns_dbg_printf(IPSTR "\n", IP2STR(&ip)); _mdns_dbg_printf(IPSTR "\n", IP2STR(&ip));
} else if (type == MDNS_TYPE_NSEC) { } else if (type == MDNS_TYPE_NSEC) {
const uint8_t * old_ptr = data_ptr; const uint8_t * old_ptr = data_ptr;

6
components/mdns/mdns_console.c
View File

@ -42,7 +42,7 @@ static void mdns_print_results(mdns_result_t * results)
} }
a = r->addr; a = r->addr;
while (a) { while (a) {
if (a->addr.type == IPADDR_TYPE_V6) { if (a->addr.type == ESP_IPADDR_TYPE_V6) {
printf(" AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6)); printf(" AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
} else { } else {
printf(" A : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4))); printf(" A : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
@ -81,7 +81,7 @@ static int cmd_mdns_query_a(int argc, char** argv)
printf("Query A: %s.local, Timeout: %d\n", hostname, timeout); printf("Query A: %s.local, Timeout: %d\n", hostname, timeout);
struct ip4_addr addr; struct esp_ip4_addr addr;
addr.addr = 0; addr.addr = 0;
esp_err_t err = mdns_query_a(hostname, timeout, &addr); esp_err_t err = mdns_query_a(hostname, timeout, &addr);
@ -138,7 +138,7 @@ static int cmd_mdns_query_aaaa(int argc, char** argv)
printf("Query AAAA: %s.local, Timeout: %d\n", hostname, timeout); printf("Query AAAA: %s.local, Timeout: %d\n", hostname, timeout);
struct ip6_addr addr; struct esp_ip6_addr addr;
memset(addr.addr, 0, 16); memset(addr.addr, 0, 16);
esp_err_t err = mdns_query_aaaa(hostname, timeout, &addr); esp_err_t err = mdns_query_aaaa(hostname, timeout, &addr);

48
components/mdns/mdns_networking.c
View File

@ -6,6 +6,7 @@
#include <string.h> #include <string.h>
#include "mdns_networking.h" #include "mdns_networking.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_netif_net_stack.h"
extern mdns_server_t * _mdns_server; extern mdns_server_t * _mdns_server;
@ -60,21 +61,18 @@ static void _udp_pcb_main_deinit(void)
/** /**
* @brief Low level UDP Multicast membership control * @brief Low level UDP Multicast membership control
*/ */
static esp_err_t _udp_join_group(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, bool join) static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protocol, bool join)
{ {
struct netif * netif = NULL; struct netif * netif = NULL;
void * nif = NULL; esp_netif_t *tcpip_if = _mdns_get_esp_netif(if_inx);
if (!tcpip_adapter_is_netif_up(tcpip_if)) { if (!esp_netif_is_netif_up(tcpip_if)) {
// Network interface went down before event propagated, skipping IGMP config // Network interface went down before event propagated, skipping IGMP config
return ESP_ERR_INVALID_STATE; return ESP_ERR_INVALID_STATE;
} }
esp_err_t err = tcpip_adapter_get_netif(tcpip_if, &nif); netif = esp_netif_get_netif_impl(tcpip_if);
if (err) { assert(netif);
return ESP_ERR_INVALID_ARG;
}
netif = (struct netif *)nif;
if (ip_protocol == MDNS_IP_PROTOCOL_V4) { if (ip_protocol == MDNS_IP_PROTOCOL_V4) {
ip_addr_t multicast_addr; ip_addr_t multicast_addr;
@ -126,7 +124,7 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
continue; continue;
} }
packet->tcpip_if = TCPIP_ADAPTER_IF_MAX; packet->tcpip_if = MDNS_IF_MAX;
packet->pb = this_pb; packet->pb = this_pb;
packet->src_port = rport; packet->src_port = rport;
memcpy(&packet->src, raddr, sizeof(ip_addr_t)); memcpy(&packet->src, raddr, sizeof(ip_addr_t));
@ -145,12 +143,10 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
//lwip does not return the proper pcb if you have more than one for the same multicast address (but different interfaces) //lwip does not return the proper pcb if you have more than one for the same multicast address (but different interfaces)
struct netif * netif = NULL; struct netif * netif = NULL;
void * nif = NULL;
struct udp_pcb * pcb = NULL; struct udp_pcb * pcb = NULL;
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
pcb = _mdns_server->interfaces[i].pcbs[packet->ip_protocol].pcb; pcb = _mdns_server->interfaces[i].pcbs[packet->ip_protocol].pcb;
tcpip_adapter_get_netif (i, &nif); netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i));
netif = (struct netif *)nif;
if (pcb && netif && netif == ip_current_input_netif ()) { if (pcb && netif && netif == ip_current_input_netif ()) {
if (packet->src.type == IPADDR_TYPE_V4) { if (packet->src.type == IPADDR_TYPE_V4) {
if ((packet->src.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr) != (netif->ip_addr.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr)) { if ((packet->src.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr) != (netif->ip_addr.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr)) {
@ -179,7 +175,7 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
*/ */
static bool _udp_pcb_is_in_use(void){ static bool _udp_pcb_is_in_use(void){
int i, p; int i, p;
for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) { for (i=0; i<MDNS_IF_MAX; i++) {
for (p=0; p<MDNS_IP_PROTOCOL_MAX; p++) { for (p=0; p<MDNS_IP_PROTOCOL_MAX; p++) {
if(_mdns_server->interfaces[i].pcbs[p].pcb){ if(_mdns_server->interfaces[i].pcbs[p].pcb){
return true; return true;
@ -192,7 +188,7 @@ static bool _udp_pcb_is_in_use(void){
/** /**
* @brief Stop PCB Main code * @brief Stop PCB Main code
*/ */
static void _udp_pcb_deinit(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static void _udp_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
if (!_mdns_server) { if (!_mdns_server) {
return; return;
@ -217,7 +213,7 @@ static void _udp_pcb_deinit(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_p
/** /**
* @brief Start PCB Main code * @brief Start PCB Main code
*/ */
static esp_err_t _udp_pcb_init(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) static esp_err_t _udp_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
if (!_mdns_server || _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) { if (!_mdns_server || _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) {
return ESP_ERR_INVALID_STATE; return ESP_ERR_INVALID_STATE;
@ -240,7 +236,7 @@ static esp_err_t _udp_pcb_init(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t i
typedef struct { typedef struct {
struct tcpip_api_call_data call; struct tcpip_api_call_data call;
tcpip_adapter_if_t tcpip_if; mdns_if_t tcpip_if;
mdns_ip_protocol_t ip_protocol; mdns_ip_protocol_t ip_protocol;
struct pbuf *pbt; struct pbuf *pbt;
const ip_addr_t *ip; const ip_addr_t *ip;
@ -274,7 +270,7 @@ static err_t _mdns_pcb_deinit_api(struct tcpip_api_call_data *api_call_msg)
* - _mdns prefixed * - _mdns prefixed
* - commented in mdns_networking.h header * - commented in mdns_networking.h header
*/ */
esp_err_t _mdns_pcb_init(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) esp_err_t _mdns_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_api_call_t msg = { mdns_api_call_t msg = {
.tcpip_if = tcpip_if, .tcpip_if = tcpip_if,
@ -284,7 +280,7 @@ esp_err_t _mdns_pcb_init(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_prot
return msg.err; return msg.err;
} }
esp_err_t _mdns_pcb_deinit(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
{ {
mdns_api_call_t msg = { mdns_api_call_t msg = {
.tcpip_if = tcpip_if, .tcpip_if = tcpip_if,
@ -299,19 +295,19 @@ static err_t _mdns_udp_pcb_write_api(struct tcpip_api_call_data *api_call_msg)
void * nif = NULL; void * nif = NULL;
mdns_api_call_t * msg = (mdns_api_call_t *)api_call_msg; mdns_api_call_t * msg = (mdns_api_call_t *)api_call_msg;
mdns_pcb_t * _pcb = &_mdns_server->interfaces[msg->tcpip_if].pcbs[msg->ip_protocol]; mdns_pcb_t * _pcb = &_mdns_server->interfaces[msg->tcpip_if].pcbs[msg->ip_protocol];
esp_err_t err = tcpip_adapter_get_netif(msg->tcpip_if, &nif); nif = esp_netif_get_netif_impl(_mdns_get_esp_netif(msg->tcpip_if));
if (err) { if (!nif) {
pbuf_free(msg->pbt); pbuf_free(msg->pbt);
msg->err = err; msg->err = ERR_IF;
return err; return ERR_IF;
} }
err = udp_sendto_if (_pcb->pcb, msg->pbt, msg->ip, msg->port, (struct netif *)nif); esp_err_t err = udp_sendto_if (_pcb->pcb, msg->pbt, msg->ip, msg->port, (struct netif *)nif);
pbuf_free(msg->pbt); pbuf_free(msg->pbt);
msg->err = err; msg->err = err;
return err; return err;
} }
size_t _mdns_udp_pcb_write(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, const ip_addr_t *ip, uint16_t port, uint8_t * data, size_t len) size_t _mdns_udp_pcb_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)
{ {
struct pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); struct pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
if (pbt == NULL) { if (pbt == NULL) {
@ -323,7 +319,7 @@ size_t _mdns_udp_pcb_write(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_pr
.tcpip_if = tcpip_if, .tcpip_if = tcpip_if,
.ip_protocol = ip_protocol, .ip_protocol = ip_protocol,
.pbt = pbt, .pbt = pbt,
.ip = ip, .ip = (ip_addr_t *)ip,
.port = port .port = port
}; };
tcpip_api_call(_mdns_udp_pcb_write_api, &msg.call); tcpip_api_call(_mdns_udp_pcb_write_api, &msg.call);

6
components/mdns/private_include/mdns_networking.h
View File

@ -34,12 +34,12 @@ esp_err_t _mdns_send_rx_action(mdns_rx_packet_t * packet);
/** /**
* @brief Start PCB * @brief Start PCB
*/ */
esp_err_t _mdns_pcb_init(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); esp_err_t _mdns_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
/** /**
* @brief Stop PCB * @brief Stop PCB
*/ */
esp_err_t _mdns_pcb_deinit(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
/** /**
* @brief send packet over UDP * @brief send packet over UDP
@ -50,6 +50,6 @@ esp_err_t _mdns_pcb_deinit(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_pr
* *
* @return length of sent packet or 0 on error * @return length of sent packet or 0 on error
*/ */
size_t _mdns_udp_pcb_write(tcpip_adapter_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, const ip_addr_t *ip, uint16_t port, uint8_t * data, size_t len); size_t _mdns_udp_pcb_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);
#endif /* ESP_MDNS_NETWORKING_H_ */ #endif /* ESP_MDNS_NETWORKING_H_ */

30
components/mdns/private_include/mdns_private.h
View File

@ -214,10 +214,10 @@ typedef struct mdns_parsed_record_s {
} mdns_parsed_record_t; } mdns_parsed_record_t;
typedef struct { typedef struct {
tcpip_adapter_if_t tcpip_if; mdns_if_t tcpip_if;
mdns_ip_protocol_t ip_protocol; mdns_ip_protocol_t ip_protocol;
//struct udp_pcb *pcb; //struct udp_pcb *pcb;
ip_addr_t src; esp_ip_addr_t src;
uint16_t src_port; uint16_t src_port;
uint8_t multicast; uint8_t multicast;
uint8_t authoritative; uint8_t authoritative;
@ -229,11 +229,11 @@ typedef struct {
} mdns_parsed_packet_t; } mdns_parsed_packet_t;
typedef struct { typedef struct {
tcpip_adapter_if_t tcpip_if; mdns_if_t tcpip_if;
mdns_ip_protocol_t ip_protocol; mdns_ip_protocol_t ip_protocol;
struct pbuf *pb; struct pbuf *pb;
ip_addr_t src; esp_ip_addr_t src;
ip_addr_t dest; esp_ip_addr_t dest;
uint16_t src_port; uint16_t src_port;
uint8_t multicast; uint8_t multicast;
} mdns_rx_packet_t; } mdns_rx_packet_t;
@ -283,9 +283,9 @@ typedef struct mdns_out_answer_s {
typedef struct mdns_tx_packet_s { typedef struct mdns_tx_packet_s {
struct mdns_tx_packet_s * next; struct mdns_tx_packet_s * next;
uint32_t send_at; uint32_t send_at;
tcpip_adapter_if_t tcpip_if; mdns_if_t tcpip_if;
mdns_ip_protocol_t ip_protocol; mdns_ip_protocol_t ip_protocol;
ip_addr_t dst; esp_ip_addr_t dst;
uint16_t port; uint16_t port;
uint16_t flags; uint16_t flags;
uint8_t distributed; uint8_t distributed;
@ -333,7 +333,7 @@ typedef struct mdns_search_once_s {
typedef struct mdns_server_s { typedef struct mdns_server_s {
struct { struct {
mdns_pcb_t pcbs[MDNS_IP_PROTOCOL_MAX]; mdns_pcb_t pcbs[MDNS_IP_PROTOCOL_MAX];
} interfaces[TCPIP_ADAPTER_IF_MAX]; } interfaces[MDNS_IF_MAX];
const char * hostname; const char * hostname;
const char * instance; const char * instance;
mdns_srv_item_t * services; mdns_srv_item_t * services;
@ -352,7 +352,7 @@ typedef struct {
struct { struct {
esp_event_base_t event_base; esp_event_base_t event_base;
int32_t event_id; int32_t event_id;
tcpip_adapter_if_t interface; esp_netif_t* interface;
} sys_event; } sys_event;
struct { struct {
mdns_srv_item_t * service; mdns_srv_item_t * service;
@ -393,4 +393,16 @@ typedef struct {
} data; } data;
} mdns_action_t; } mdns_action_t;
/*
* @brief Convert mnds if to esp-netif handle
*
* @param tcpip_if mdns supported interface as internal enum
*
* @return
* - ptr to esp-netif on success
* - NULL if no available netif for current interface index
*/
esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if);
#endif /* MDNS_PRIVATE_H_ */ #endif /* MDNS_PRIVATE_H_ */

11
examples/protocols/mdns/main/mdns_example_main.c
View File

@ -9,18 +9,15 @@
#include <string.h> #include <string.h>
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h" #include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h" #include "esp_event.h"
#include "esp_log.h" #include "esp_log.h"
#include "nvs_flash.h" #include "nvs_flash.h"
#include "tcpip_adapter.h" #include "esp_netif.h"
#include "protocol_examples_common.h" #include "protocol_examples_common.h"
#include "mdns.h" #include "mdns.h"
#include "driver/gpio.h" #include "driver/gpio.h"
#include <sys/socket.h> #include "netdb.h"
#include <netdb.h>
#define EXAMPLE_MDNS_INSTANCE CONFIG_MDNS_INSTANCE #define EXAMPLE_MDNS_INSTANCE CONFIG_MDNS_INSTANCE
@ -88,7 +85,7 @@ static void mdns_print_results(mdns_result_t * results){
} }
a = r->addr; a = r->addr;
while(a){ while(a){
if(a->addr.type == IPADDR_TYPE_V6){ if(a->addr.type == ESP_IPADDR_TYPE_V6){
printf(" AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6)); printf(" AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
} else { } else {
printf(" A : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4))); printf(" A : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
@ -123,7 +120,7 @@ static void query_mdns_host(const char * host_name)
{ {
ESP_LOGI(TAG, "Query A: %s.local", host_name); ESP_LOGI(TAG, "Query A: %s.local", host_name);
struct ip4_addr addr; struct esp_ip4_addr addr;
addr.addr = 0; addr.addr = 0;
esp_err_t err = mdns_query_a(host_name, 2000, &addr); esp_err_t err = mdns_query_a(host_name, 2000, &addr);