/* * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ #include "mdns.h" #include "mdns_private.h" #include "mdns_networking.h" #include "esp_log.h" #include #include #ifdef MDNS_ENABLE_DEBUG void mdns_debug_packet(const uint8_t * data, size_t len); #endif #ifndef ARRAY_SIZE #define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) #endif // Internal size of IPv6 address is defined here as size of AAAA record in mdns packet // since the ip6_addr_t is defined in lwip and depends on using IPv6 zones #define _MDNS_SIZEOF_IP6_ADDR (MDNS_ANSWER_AAAA_SIZE) static const char * MDNS_DEFAULT_DOMAIN = "local"; static const char * MDNS_SUB_STR = "_sub"; mdns_server_t * _mdns_server = NULL; static mdns_host_item_t * _mdns_host_list = NULL; static mdns_host_item_t _mdns_self_host; static const char *TAG = "MDNS"; static volatile TaskHandle_t _mdns_service_task_handle = NULL; static SemaphoreHandle_t _mdns_service_semaphore = NULL; 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, 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, esp_ip_addr_t * ip, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl); 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, uint32_t ttl); static void _mdns_search_result_add_txt(mdns_search_once_t *search, mdns_txt_item_t *txt, uint8_t *txt_value_len, size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl); static mdns_result_t * _mdns_search_result_add_ptr(mdns_search_once_t * search, const char * instance, const char * service_type, const char * proto, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl); static bool _mdns_append_host_list_in_services(mdns_out_answer_t ** destination, mdns_srv_item_t * services[], size_t services_len, bool flush, bool bye); static bool _mdns_append_host_list(mdns_out_answer_t ** destination, bool flush, bool bye); static void _mdns_remap_self_service_hostname(const char *old_hostname, const char *new_hostname); /* * @brief Internal collection of mdns supported interfaces * */ static esp_netif_t * s_esp_netifs[MDNS_IF_MAX] = {}; /* * @brief Convert mdns if to esp-netif handle */ esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if) { if (tcpip_if < MDNS_IF_MAX) { if (s_esp_netifs[tcpip_if] == NULL) { // if local netif copy is NULL, try to search for the default interface key if (tcpip_if == MDNS_IF_STA) { s_esp_netifs[MDNS_IF_STA] = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"); } else if (tcpip_if == MDNS_IF_AP) { s_esp_netifs[MDNS_IF_AP] = esp_netif_get_handle_from_ifkey("WIFI_AP_DEF"); #if CONFIG_ETH_ENABLED } else if (tcpip_if == MDNS_IF_ETH) { s_esp_netifs[MDNS_IF_ETH] = esp_netif_get_handle_from_ifkey("ETH_DEF"); #endif } } return s_esp_netifs[tcpip_if]; } return NULL; } /* * @brief Clean internal mdns interface's pointer */ static inline void _mdns_clean_netif_ptr(mdns_if_t tcpip_if) { if (tcpip_if < MDNS_IF_MAX) { s_esp_netifs[tcpip_if] = NULL; } } /* * @brief Convert esp-netif handle to mdns if */ static mdns_if_t _mdns_get_if_from_esp_netif(esp_netif_t *interface) { for (int i=0; iservice, service) && !strcasecmp(srv->proto, proto) && (_str_null_or_empty(hostname) || !strcasecmp(srv->hostname, hostname)); } /** * @brief finds service from given service type * @param server the server * @param service service type to match * @param proto proto to match * @param hostname hostname of the service (if non-null) * * @return the service item if found or NULL on error */ static mdns_srv_item_t * _mdns_get_service_item(const char * service, const char * proto, const char * hostname) { mdns_srv_item_t * s = _mdns_server->services; while (s) { if (_mdns_service_match(s->service, service, proto, hostname)) { return s; } s = s->next; } return NULL; } static mdns_srv_item_t * _mdns_get_service_item_subtype(const char *subtype, const char * service, const char * proto) { mdns_srv_item_t * s = _mdns_server->services; while (s) { if (_mdns_service_match(s->service, service, proto, NULL)) { mdns_subtype_t *subtype_item = s->service->subtype; while(subtype_item) { if (!strcasecmp(subtype_item->subtype, subtype)) { return s; } subtype_item = subtype_item->next; } } s = s->next; } return NULL; } static mdns_host_item_t * mdns_get_host_item(const char * hostname) { if (hostname == NULL || strcasecmp(hostname, _mdns_server->hostname) == 0) { return &_mdns_self_host; } mdns_host_item_t * host = _mdns_host_list; while (host != NULL) { if (strcasecmp(host->hostname, hostname) == 0) { return host; } host = host->next; } return NULL; } static bool _mdns_can_add_more_services(void) { mdns_srv_item_t * s = _mdns_server->services; uint16_t service_num = 0; while (s) { service_num ++; s = s->next; if (service_num >= MDNS_MAX_SERVICES) { return false; } } return true; } esp_err_t _mdns_send_rx_action(mdns_rx_packet_t * packet) { mdns_action_t * action = NULL; action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_RX_HANDLE; action->data.rx_handle.packet = packet; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } static const char *_mdns_get_default_instance_name(void) { if (_mdns_server && !_str_null_or_empty(_mdns_server->instance)) { return _mdns_server->instance; } if (_mdns_server && !_str_null_or_empty(_mdns_server->hostname)) { return _mdns_server->hostname; } return NULL; } /** * @brief Get the service name of a service */ static const char * _mdns_get_service_instance_name(const mdns_service_t * service) { if (service && !_str_null_or_empty(service->instance)) { return service->instance; } return _mdns_get_default_instance_name(); } static bool _mdns_instance_name_match(const char *lhs, const char *rhs) { if (lhs == NULL) { lhs = _mdns_get_default_instance_name(); } if (rhs == NULL) { rhs = _mdns_get_default_instance_name(); } return !strcasecmp(lhs, rhs); } static bool _mdns_service_match_instance(const mdns_service_t *srv, const char *instance, const char *service, const char *proto, const char *hostname) { return !strcasecmp(srv->service, service) && _mdns_instance_name_match(srv->instance, instance) && !strcasecmp(srv->proto, proto) && (_str_null_or_empty(hostname) || !strcasecmp(srv->hostname, hostname)); } static mdns_srv_item_t *_mdns_get_service_item_instance(const char *instance, const char *service, const char *proto, const char *hostname) { mdns_srv_item_t *s = _mdns_server->services; while (s) { if (instance) { if (_mdns_service_match_instance(s->service, instance, service, proto, hostname)) { return s; } } else { if (_mdns_service_match(s->service, service, proto, hostname)) { return s; } } s = s->next; } return NULL; } /** * @brief reads MDNS FQDN into mdns_name_t structure * FQDN is in format: [hostname.|[instance.]_service._proto.]local. * * @param packet MDNS packet * @param start Starting point of FQDN * @param name mdns_name_t structure to populate * @param buf temporary char buffer * * @return the address after the parsed FQDN in the packet or NULL on error */ static const uint8_t * _mdns_read_fqdn(const uint8_t * packet, const uint8_t * start, mdns_name_t * name, char * buf) { size_t index = 0; while (start[index]) { if (name->parts == 4) { name->invalid = true; } uint8_t len = start[index++]; if (len < 0xC0) { if (len > 63) { //length can not be more than 63 return NULL; } uint8_t i; for (i=0; iparts == 1 && buf[0] != '_' && (strcasecmp(buf, MDNS_DEFAULT_DOMAIN) != 0) && (strcasecmp(buf, "arpa") != 0) && (strcasecmp(buf, "ip6") != 0) && (strcasecmp(buf, "in-addr") != 0)) { strlcat(name->host, ".", sizeof(name->host)); strlcat(name->host, buf, sizeof(name->host)); } else if (strcasecmp(buf, MDNS_SUB_STR) == 0) { name->sub = 1; } else if (!name->invalid) { char* mdns_name_ptrs[]={name->host, name->service, name->proto, name->domain}; memcpy(mdns_name_ptrs[name->parts++], buf, len+1); } } else { size_t address = (((uint16_t)len & 0x3F) << 8) | start[index++]; if ((packet + address) >= start) { //reference address can not be after where we are return NULL; } if (_mdns_read_fqdn(packet, packet + address, name, buf)) { return start + index; } return NULL; } } return start + index + 1; } /** * @brief sets uint16_t value in a packet * * @param packet MDNS packet * @param index offset of uint16_t value * @param value the value to set */ static inline void _mdns_set_u16(uint8_t * packet, uint16_t index, uint16_t value) { if ((index + 1) >= MDNS_MAX_PACKET_SIZE) { return; } packet[index] = (value >> 8) & 0xFF; packet[index+1] = value & 0xFF; } /** * @brief appends byte in a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param value the value to set * * @return length of added data: 0 on error or 1 on success */ static inline uint8_t _mdns_append_u8(uint8_t * packet, uint16_t * index, uint8_t value) { if (*index >= MDNS_MAX_PACKET_SIZE) { return 0; } packet[*index] = value; *index += 1; return 1; } /** * @brief appends uint16_t in a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param value the value to set * * @return length of added data: 0 on error or 2 on success */ static inline uint8_t _mdns_append_u16(uint8_t * packet, uint16_t * index, uint16_t value) { if ((*index + 1) >= MDNS_MAX_PACKET_SIZE) { return 0; } _mdns_append_u8(packet, index, (value >> 8) & 0xFF); _mdns_append_u8(packet, index, value & 0xFF); return 2; } /** * @brief appends uint32_t in a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param value the value to set * * @return length of added data: 0 on error or 4 on success */ static inline uint8_t _mdns_append_u32(uint8_t * packet, uint16_t * index, uint32_t value) { if ((*index + 3) >= MDNS_MAX_PACKET_SIZE) { return 0; } _mdns_append_u8(packet, index, (value >> 24) & 0xFF); _mdns_append_u8(packet, index, (value >> 16) & 0xFF); _mdns_append_u8(packet, index, (value >> 8) & 0xFF); _mdns_append_u8(packet, index, value & 0xFF); return 4; } /** * @brief appends answer type, class, ttl and data length to a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param type answer type * @param ttl answer ttl * * @return length of added data: 0 on error or 10 on success */ static inline uint8_t _mdns_append_type(uint8_t * packet, uint16_t * index, uint8_t type, bool flush, uint32_t ttl) { if ((*index + 10) >= MDNS_MAX_PACKET_SIZE) { return 0; } uint16_t mdns_class = MDNS_CLASS_IN; if (flush) { mdns_class = MDNS_CLASS_IN_FLUSH_CACHE; } if (type == MDNS_ANSWER_PTR) { _mdns_append_u16(packet, index, MDNS_TYPE_PTR); _mdns_append_u16(packet, index, mdns_class); } else if (type == MDNS_ANSWER_TXT) { _mdns_append_u16(packet, index, MDNS_TYPE_TXT); _mdns_append_u16(packet, index, mdns_class); } else if (type == MDNS_ANSWER_SRV) { _mdns_append_u16(packet, index, MDNS_TYPE_SRV); _mdns_append_u16(packet, index, mdns_class); } else if (type == MDNS_ANSWER_A) { _mdns_append_u16(packet, index, MDNS_TYPE_A); _mdns_append_u16(packet, index, mdns_class); } else if (type == MDNS_ANSWER_AAAA) { _mdns_append_u16(packet, index, MDNS_TYPE_AAAA); _mdns_append_u16(packet, index, mdns_class); } else { return 0; } _mdns_append_u32(packet, index, ttl); _mdns_append_u16(packet, index, 0); return 10; } static inline uint8_t _mdns_append_string_with_len(uint8_t * packet, uint16_t * index, const char * string, uint8_t len) { if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { return 0; } _mdns_append_u8(packet, index, len); memcpy(packet + *index, string, len); *index += len; return len + 1; } /** * @brief appends single string to a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param string the string to append * * @return length of added data: 0 on error or length of the string + 1 on success */ static inline uint8_t _mdns_append_string(uint8_t * packet, uint16_t * index, const char * string) { uint8_t len = strlen(string); if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { return 0; } _mdns_append_u8(packet, index, len); memcpy(packet + *index, string, len); *index += len; return len + 1; } /** * @brief appends one TXT record ("key=value" or "key") * * @param packet MDNS packet * @param index offset in the packet * @param txt one txt record * * @return length of added data: length of the added txt value + 1 on success * 0 if data won't fit the packet * -1 if invalid TXT entry */ static inline int append_one_txt_record_entry(uint8_t * packet, uint16_t * index, mdns_txt_linked_item_t * txt) { if (txt == NULL || txt->key == NULL) { return -1; } size_t key_len = strlen(txt->key); size_t len = key_len + txt->value_len + (txt->value ? 1 : 0); if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { return 0; } _mdns_append_u8(packet, index, len); memcpy(packet + *index, txt->key, key_len); if (txt->value) { packet[*index + key_len] = '='; memcpy(packet + *index + key_len + 1, txt->value, txt->value_len); } *index += len; return len + 1; } /** * @brief appends FQDN to a packet, incrementing the index and * compressing the output if previous occurrence of the string (or part of it) has been found * * @param packet MDNS packet * @param index offset in the packet * @param strings string array containing the parts of the FQDN * @param count number of strings in the array * * @return length of added data: 0 on error or length on success */ static uint16_t _mdns_append_fqdn(uint8_t * packet, uint16_t * index, const char * strings[], uint8_t count) { if (!count) { //empty string so terminate return _mdns_append_u8(packet, index, 0); } mdns_name_t name; static char buf[MDNS_NAME_BUF_LEN]; uint8_t len = strlen(strings[0]); //try to find first the string length in the packet (if it exists) uint8_t * len_location = (uint8_t *)memchr(packet, (char)len, *index); while (len_location) { //check if the string after len_location is the string that we are looking for if (memcmp(len_location+1, strings[0], len)) { //not continuing with our string search_next: //try and find the length byte further in the packet len_location = (uint8_t *)memchr(len_location+1, (char)len, *index - (len_location+1 - packet)); continue; } //seems that we might have found the string that we are looking for //read the destination into name and compare name.parts = 0; name.sub = 0; name.host[0] = 0; name.service[0] = 0; name.proto[0] = 0; name.domain[0] = 0; const uint8_t * content = _mdns_read_fqdn(packet, len_location, &name, buf); if (!content) { //not a readable fqdn? return 0; } if (name.parts == count) { uint8_t i; for (i=0; iservice; str[1] = service->proto; str[2] = MDNS_DEFAULT_DOMAIN; part_length = _mdns_append_fqdn(packet, index, sd_str, 4); record_length += part_length; part_length = _mdns_append_type(packet, index, MDNS_ANSWER_PTR, flush, MDNS_ANSWER_PTR_TTL); if (!part_length) { return 0; } record_length += part_length; uint16_t data_len_location = *index - 2; part_length = _mdns_append_fqdn(packet, index, str, 3); if (!part_length) { return 0; } _mdns_set_u16(packet, data_len_location, part_length); record_length += part_length; return record_length; } /** * @brief appends TXT record for service to a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param server the server that is hosting the service * @param service the service to add record for * * @return length of added data: 0 on error or length on success */ static uint16_t _mdns_append_txt_record(uint8_t * packet, uint16_t * index, mdns_service_t * service, bool flush, bool bye) { const char * str[4]; uint16_t record_length = 0; uint8_t part_length; if (service == NULL) { return 0; } str[0] = _mdns_get_service_instance_name(service); str[1] = service->service; str[2] = service->proto; str[3] = MDNS_DEFAULT_DOMAIN; if (!str[0]) { return 0; } part_length = _mdns_append_fqdn(packet, index, str, 4); if (!part_length) { return 0; } record_length += part_length; part_length = _mdns_append_type(packet, index, MDNS_ANSWER_TXT, flush, bye?0:MDNS_ANSWER_TXT_TTL); if (!part_length) { return 0; } record_length += part_length; uint16_t data_len_location = *index - 2; uint16_t data_len = 0; mdns_txt_linked_item_t * txt = service->txt; while (txt) { int l = append_one_txt_record_entry(packet, index, txt); if (l > 0) { data_len += l; } else if (l == 0) { // TXT entry won't fit into the mdns packet return 0; } txt = txt->next; } if (!data_len) { data_len = 1; packet[*index] = 0; *index = *index + 1; } _mdns_set_u16(packet, data_len_location, data_len); record_length += data_len; return record_length; } /** * @brief appends SRV record for service to a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param server the server that is hosting the service * @param service the service to add record for * * @return length of added data: 0 on error or length on success */ static uint16_t _mdns_append_srv_record(uint8_t * packet, uint16_t * index, mdns_service_t * service, bool flush, bool bye) { const char * str[4]; uint16_t record_length = 0; uint8_t part_length; if (service == NULL) { return 0; } str[0] = _mdns_get_service_instance_name(service); str[1] = service->service; str[2] = service->proto; str[3] = MDNS_DEFAULT_DOMAIN; if (!str[0]) { return 0; } part_length = _mdns_append_fqdn(packet, index, str, 4); if (!part_length) { return 0; } record_length += part_length; part_length = _mdns_append_type(packet, index, MDNS_ANSWER_SRV, flush, bye?0:MDNS_ANSWER_SRV_TTL); if (!part_length) { return 0; } record_length += part_length; uint16_t data_len_location = *index - 2; part_length = 0; part_length += _mdns_append_u16(packet, index, service->priority); part_length += _mdns_append_u16(packet, index, service->weight); part_length += _mdns_append_u16(packet, index, service->port); if (part_length != 6) { return 0; } if (service->hostname) { str[0] = service->hostname; } else { str[0] = _mdns_server->hostname; } str[1] = MDNS_DEFAULT_DOMAIN; if (_str_null_or_empty(str[0])) { return 0; } part_length = _mdns_append_fqdn(packet, index, str, 2); if (!part_length) { return 0; } _mdns_set_u16(packet, data_len_location, part_length + 6); record_length += part_length + 6; return record_length; } /** * @brief appends A record to a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param hostname the hostname address to add * @param ip the IP address to add * * @return length of added data: 0 on error or length on success */ static uint16_t _mdns_append_a_record(uint8_t * packet, uint16_t * index, const char * hostname, uint32_t ip, bool flush, bool bye) { const char * str[2]; uint16_t record_length = 0; uint8_t part_length; str[0] = hostname; str[1] = MDNS_DEFAULT_DOMAIN; if (_str_null_or_empty(str[0])) { return 0; } part_length = _mdns_append_fqdn(packet, index, str, 2); if (!part_length) { return 0; } record_length += part_length; part_length = _mdns_append_type(packet, index, MDNS_ANSWER_A, flush, bye?0:MDNS_ANSWER_A_TTL); if (!part_length) { return 0; } record_length += part_length; uint16_t data_len_location = *index - 2; if ((*index + 3) >= MDNS_MAX_PACKET_SIZE) { return 0; } _mdns_append_u8(packet, index, ip & 0xFF); _mdns_append_u8(packet, index, (ip >> 8) & 0xFF); _mdns_append_u8(packet, index, (ip >> 16) & 0xFF); _mdns_append_u8(packet, index, (ip >> 24) & 0xFF); _mdns_set_u16(packet, data_len_location, 4); record_length += 4; return record_length; } #if CONFIG_LWIP_IPV6 /** * @brief appends AAAA record to a packet, incrementing the index * * @param packet MDNS packet * @param index offset in the packet * @param hostname the hostname address to add * @param ipv6 the IPv6 address to add * * @return length of added data: 0 on error or length on success */ static uint16_t _mdns_append_aaaa_record(uint8_t * packet, uint16_t * index, const char * hostname, uint8_t * ipv6, bool flush, bool bye) { const char * str[2]; uint16_t record_length = 0; uint8_t part_length; str[0] = hostname; str[1] = MDNS_DEFAULT_DOMAIN; if (_str_null_or_empty(str[0])) { return 0; } part_length = _mdns_append_fqdn(packet, index, str, 2); if (!part_length) { return 0; } record_length += part_length; part_length = _mdns_append_type(packet, index, MDNS_ANSWER_AAAA, flush, bye?0:MDNS_ANSWER_AAAA_TTL); if (!part_length) { return 0; } record_length += part_length; uint16_t data_len_location = *index - 2; if ((*index + MDNS_ANSWER_AAAA_SIZE) > MDNS_MAX_PACKET_SIZE) { return 0; } part_length = MDNS_ANSWER_AAAA_SIZE; memcpy(packet + *index, ipv6, part_length); *index += part_length; _mdns_set_u16(packet, data_len_location, part_length); record_length += part_length; return record_length; } #endif /** * @brief Append question to packet */ static uint16_t _mdns_append_question(uint8_t * packet, uint16_t * index, mdns_out_question_t * q) { const char * str[4]; uint8_t str_index = 0; uint8_t part_length; if (q->host) { str[str_index++] = q->host; } if (q->service) { str[str_index++] = q->service; } if (q->proto) { str[str_index++] = q->proto; } if (q->domain) { str[str_index++] = q->domain; } part_length = _mdns_append_fqdn(packet, index, str, str_index); if (!part_length) { return 0; } part_length += _mdns_append_u16(packet, index, q->type); part_length += _mdns_append_u16(packet, index, q->unicast?0x8001:0x0001); return part_length; } /** * @brief Helper to get either ETH or STA if the other is provided * Used when two interfaces are on the same subnet */ static mdns_if_t _mdns_get_other_if (mdns_if_t tcpip_if) { if (tcpip_if == MDNS_IF_STA) { return MDNS_IF_ETH; } else if (tcpip_if == MDNS_IF_ETH) { return MDNS_IF_STA; } return MDNS_IF_MAX; } /** * @brief Check if interface is duplicate (two interfaces on the same subnet) */ static bool _mdns_if_is_dup(mdns_if_t tcpip_if) { mdns_if_t other_if = _mdns_get_other_if (tcpip_if); if (other_if == MDNS_IF_MAX) { return false; } if (_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state == PCB_DUP || _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state == PCB_DUP || _mdns_server->interfaces[other_if].pcbs[MDNS_IP_PROTOCOL_V4].state == PCB_DUP || _mdns_server->interfaces[other_if].pcbs[MDNS_IP_PROTOCOL_V6].state == PCB_DUP ) { return true; } return false; } #if CONFIG_LWIP_IPV6 /** * @brief Check if IPv6 address is NULL */ static bool _ipv6_address_is_zero(esp_ip6_addr_t ip6) { uint8_t i; uint8_t * data = (uint8_t *)ip6.addr; for (i=0; i<_MDNS_SIZEOF_IP6_ADDR; i++) { if (data[i]) { return false; } } return true; } #endif static uint8_t _mdns_append_host_answer(uint8_t * packet, uint16_t * index, mdns_host_item_t * host, uint8_t address_type, bool flush, bool bye) { mdns_ip_addr_t * addr = host->address_list; uint8_t num_records = 0; while (addr != NULL) { if (addr->addr.type == address_type) { if (address_type == ESP_IPADDR_TYPE_V4 && _mdns_append_a_record(packet, index, host->hostname, addr->addr.u_addr.ip4.addr, flush, bye) <= 0) { break; } #if CONFIG_LWIP_IPV6 if (address_type == ESP_IPADDR_TYPE_V6 && _mdns_append_aaaa_record(packet, index, host->hostname, (uint8_t *)addr->addr.u_addr.ip6.addr, flush, bye) <= 0) { break; } #endif // CONFIG_LWIP_IPV6 num_records++; } addr = addr->next; } return num_records; } /** * @brief Append PTR answers to packet * * @return number of answers added to the packet */ static uint8_t _mdns_append_service_ptr_answers(uint8_t *packet, uint16_t *index, mdns_service_t *service, bool flush, bool bye) { uint8_t appended_answers = 0; if (_mdns_append_ptr_record(packet, index, _mdns_get_service_instance_name(service), service->service, service->proto, flush, bye) <= 0) { return appended_answers; } appended_answers++; mdns_subtype_t *subtype = service->subtype; while (subtype) { appended_answers += (_mdns_append_subtype_ptr_record(packet, index, _mdns_get_service_instance_name(service), subtype->subtype, service->service, service->proto, flush, bye) > 0); subtype = subtype->next; } return appended_answers; } /** * @brief Append answer to 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, mdns_if_t tcpip_if) { if (answer->type == MDNS_TYPE_PTR) { if (answer->service) { return _mdns_append_service_ptr_answers(packet, index, answer->service, answer->flush, answer->bye); } else { return _mdns_append_ptr_record(packet, index, answer->custom_instance, answer->custom_service, answer->custom_proto, answer->flush, answer->bye) > 0; } } else if (answer->type == MDNS_TYPE_SRV) { return _mdns_append_srv_record(packet, index, answer->service, answer->flush, answer->bye) > 0; } else if (answer->type == MDNS_TYPE_TXT) { return _mdns_append_txt_record(packet, index, answer->service, answer->flush, answer->bye) > 0; } else if (answer->type == MDNS_TYPE_SDPTR) { return _mdns_append_sdptr_record(packet, index, answer->service, answer->flush, answer->bye) > 0; } else if (answer->type == MDNS_TYPE_A) { if (answer->host == &_mdns_self_host) { 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) { return 0; } if (esp_netif_get_ip_info(_mdns_get_esp_netif(tcpip_if), &if_ip_info)) { return 0; } if (_mdns_append_a_record(packet, index, _mdns_server->hostname, if_ip_info.ip.addr, answer->flush, answer->bye) <= 0) { return 0; } if (!_mdns_if_is_dup(tcpip_if)) { return 1; } mdns_if_t other_if = _mdns_get_other_if (tcpip_if); if (esp_netif_get_ip_info(_mdns_get_esp_netif(other_if), &if_ip_info)) { return 1; } if (_mdns_append_a_record(packet, index, _mdns_server->hostname, if_ip_info.ip.addr, answer->flush, answer->bye) > 0) { return 2; } return 1; } else if (answer->host != NULL) { return _mdns_append_host_answer(packet, index, answer->host, ESP_IPADDR_TYPE_V4, answer->flush, answer->bye); } } #if CONFIG_LWIP_IPV6 else if (answer->type == MDNS_TYPE_AAAA) { if (answer->host == &_mdns_self_host) { 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) { return 0; } if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(tcpip_if), &if_ip6)) { return 0; } if (_ipv6_address_is_zero(if_ip6)) { return 0; } if (_mdns_append_aaaa_record(packet, index, _mdns_server->hostname, (uint8_t*)if_ip6.addr, answer->flush, answer->bye) <= 0) { return 0; } if (!_mdns_if_is_dup(tcpip_if)) { return 1; } mdns_if_t other_if = _mdns_get_other_if (tcpip_if); if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(other_if), &if_ip6)) { return 1; } if (_mdns_append_aaaa_record(packet, index, _mdns_server->hostname, (uint8_t*)if_ip6.addr, answer->flush, answer->bye) > 0) { return 2; } return 1; } else if (answer->host != NULL) { return _mdns_append_host_answer(packet, index, answer->host, ESP_IPADDR_TYPE_V6, answer->flush, answer->bye); } } #endif return 0; } /** * @brief sends a packet * * @param p the packet */ static void _mdns_dispatch_tx_packet(mdns_tx_packet_t * p) { static uint8_t packet[MDNS_MAX_PACKET_SIZE]; uint16_t index = MDNS_HEAD_LEN; memset(packet, 0, MDNS_HEAD_LEN); mdns_out_question_t * q; mdns_out_answer_t * a; uint8_t count; _mdns_set_u16(packet, MDNS_HEAD_FLAGS_OFFSET, p->flags); _mdns_set_u16(packet, MDNS_HEAD_ID_OFFSET, p->id); count = 0; q = p->questions; while (q) { if (_mdns_append_question(packet, &index, q)) { count++; } q = q->next; } _mdns_set_u16(packet, MDNS_HEAD_QUESTIONS_OFFSET, count); count = 0; a = p->answers; while (a) { count += _mdns_append_answer(packet, &index, a, p->tcpip_if); a = a->next; } _mdns_set_u16(packet, MDNS_HEAD_ANSWERS_OFFSET, count); count = 0; a = p->servers; while (a) { count += _mdns_append_answer(packet, &index, a, p->tcpip_if); a = a->next; } _mdns_set_u16(packet, MDNS_HEAD_SERVERS_OFFSET, count); count = 0; a = p->additional; while (a) { count += _mdns_append_answer(packet, &index, a, p->tcpip_if); a = a->next; } _mdns_set_u16(packet, MDNS_HEAD_ADDITIONAL_OFFSET, count); #ifdef MDNS_ENABLE_DEBUG _mdns_dbg_printf("\nTX[%u][%u]: ", p->tcpip_if, p->ip_protocol); if (p->dst.type == ESP_IPADDR_TYPE_V4) { _mdns_dbg_printf("To: " IPSTR ":%u, ", IP2STR(&p->dst.u_addr.ip4), p->port); } else { _mdns_dbg_printf("To: " IPV6STR ":%u, ", IPV62STR(p->dst.u_addr.ip6), p->port); } mdns_debug_packet(packet, index); #endif _mdns_udp_pcb_write(p->tcpip_if, p->ip_protocol, &p->dst, p->port, packet, index); } /** * @brief frees a packet * * @param packet the packet */ static void _mdns_free_tx_packet(mdns_tx_packet_t * packet) { if (!packet) { return; } mdns_out_question_t * q = packet->questions; while (q) { mdns_out_question_t * next = q->next; if (q->own_dynamic_memory) { free((char *)q->host); free((char *)q->service); free((char *)q->proto); free((char *)q->domain); } free(q); q = next; } queueFree(mdns_out_answer_t, packet->answers); queueFree(mdns_out_answer_t, packet->servers); queueFree(mdns_out_answer_t, packet->additional); free(packet); } /** * @brief schedules a packet to be sent after given milliseconds * * @param packet the packet * @param ms_after number of milliseconds after which the packet should be dispatched */ static void _mdns_schedule_tx_packet(mdns_tx_packet_t * packet, uint32_t ms_after) { if (!packet) { return; } packet->send_at = (xTaskGetTickCount() * portTICK_PERIOD_MS) + ms_after; packet->next = NULL; if (!_mdns_server->tx_queue_head || _mdns_server->tx_queue_head->send_at > packet->send_at) { packet->next = _mdns_server->tx_queue_head; _mdns_server->tx_queue_head = packet; return; } mdns_tx_packet_t * q = _mdns_server->tx_queue_head; while (q->next && q->next->send_at <= packet->send_at) { q = q->next; } packet->next = q->next; q->next = packet; } /** * @brief free all packets scheduled for sending */ static void _mdns_clear_tx_queue_head(void) { mdns_tx_packet_t * q; while (_mdns_server->tx_queue_head) { q = _mdns_server->tx_queue_head; _mdns_server->tx_queue_head = _mdns_server->tx_queue_head->next; _mdns_free_tx_packet(q); } } /** * @brief clear packets scheduled for sending on a specific interface * * @param tcpip_if the interface * @param ip_protocol pcb type V4/V6 */ 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; while (_mdns_server->tx_queue_head && _mdns_server->tx_queue_head->tcpip_if == tcpip_if && _mdns_server->tx_queue_head->ip_protocol == ip_protocol) { q = _mdns_server->tx_queue_head; _mdns_server->tx_queue_head = _mdns_server->tx_queue_head->next; _mdns_free_tx_packet(q); } if (_mdns_server->tx_queue_head) { q = _mdns_server->tx_queue_head; while (q->next) { if (q->next->tcpip_if == tcpip_if && q->next->ip_protocol == ip_protocol) { p = q->next; q->next = p->next; _mdns_free_tx_packet(p); } else { q = q->next; } } } } /** * @brief get the next packet scheduled for sending on a specific interface * * @param tcpip_if the interface * @param ip_protocol pcb type V4/V6 */ 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; while (q) { if (q->tcpip_if == tcpip_if && q->ip_protocol == ip_protocol) { return q; } q = q->next; } return NULL; } /** * @brief Find, remove and free answer from the scheduled packets */ 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}; if (!service) { service = &s; } mdns_tx_packet_t * q = _mdns_server->tx_queue_head; while (q) { if (q->tcpip_if == tcpip_if && q->ip_protocol == ip_protocol && q->distributed) { mdns_out_answer_t * a = q->answers; if (a->type == type && a->service == service->service) { q->answers = q->answers->next; free(a); } else { while (a->next) { if (a->next->type == type && a->next->service == service->service) { mdns_out_answer_t * b = a->next; a->next = b->next; free(b); break; } a = a->next; } } } q = q->next; } } /** * @brief Remove and free answer from answer list (destination) */ static void _mdns_dealloc_answer(mdns_out_answer_t ** destination, uint16_t type, mdns_srv_item_t * service) { mdns_out_answer_t * d = *destination; if (!d) { return; } mdns_srv_item_t s = {NULL, NULL}; if (!service) { service = &s; } if (d->type == type && d->service == service->service) { *destination = d->next; free(d); return; } while (d->next) { mdns_out_answer_t * a = d->next; if (a->type == type && a->service == service->service) { d->next = a->next; free(a); return; } d = d->next; } } /** * @brief Allocate new answer and add it to answer list (destination) */ static bool _mdns_alloc_answer(mdns_out_answer_t ** destination, uint16_t type, mdns_service_t * service, mdns_host_item_t * host, bool flush, bool bye) { mdns_out_answer_t * d = *destination; while (d) { if (d->type == type && d->service == service && d->host == host) { return true; } d = d->next; } mdns_out_answer_t * a = (mdns_out_answer_t *)malloc(sizeof(mdns_out_answer_t)); if (!a) { HOOK_MALLOC_FAILED; return false; } a->type = type; a->service = service; a->host = host; a->custom_service = NULL; a->bye = bye; a->flush = flush; a->next = NULL; queueToEnd(mdns_out_answer_t, *destination, a); return true; } /** * @brief Allocate new packet for sending */ 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)); if (!packet) { HOOK_MALLOC_FAILED; return NULL; } memset((uint8_t*)packet, 0, sizeof(mdns_tx_packet_t)); packet->tcpip_if = tcpip_if; packet->ip_protocol = ip_protocol; packet->port = MDNS_SERVICE_PORT; if (ip_protocol == MDNS_IP_PROTOCOL_V4) { esp_ip_addr_t addr = ESP_IP4ADDR_INIT(224, 0, 0, 251); memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t)); } #if CONFIG_LWIP_IPV6 else { esp_ip_addr_t addr = ESP_IP6ADDR_INIT(0x000002ff, 0, 0, 0xfb000000); memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t)); } #endif return packet; } static bool _mdns_create_answer_from_service(mdns_tx_packet_t * packet, mdns_service_t * service, mdns_parsed_question_t * question, bool shared, bool send_flush) { mdns_host_item_t * host = mdns_get_host_item(service->hostname); if (question->type == MDNS_TYPE_PTR || question->type == MDNS_TYPE_ANY) { if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, service, NULL, false, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, service, NULL, send_flush, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, service, NULL, send_flush, false) || !_mdns_alloc_answer(shared ? &packet->additional : &packet->answers, MDNS_TYPE_A, service, host, send_flush, false) || !_mdns_alloc_answer(shared ? &packet->additional : &packet->answers, MDNS_TYPE_AAAA, service, host, send_flush, false)) { return false; } } else if (question->type == MDNS_TYPE_SRV) { if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, service, NULL, send_flush, false) || !_mdns_alloc_answer(&packet->additional, MDNS_TYPE_A, service, host, send_flush, false) || !_mdns_alloc_answer(&packet->additional, MDNS_TYPE_AAAA, service, host, send_flush, false)) { return false; } } else if (question->type == MDNS_TYPE_TXT) { if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, service, NULL, send_flush, false)) { return false; } } else if (question->type == MDNS_TYPE_SDPTR) { shared = true; if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SDPTR, service, NULL, false, false)) { return false; } } return true; } static bool _mdns_create_answer_from_hostname(mdns_tx_packet_t * packet, const char * hostname, bool send_flush) { mdns_host_item_t * host = mdns_get_host_item(hostname); if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_A, NULL, host, send_flush, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_AAAA, NULL, host, send_flush, false)) { return false; } return true; } static bool _mdns_service_match_ptr_question(const mdns_service_t *service, const mdns_parsed_question_t *question) { if (!_mdns_service_match(service, question->service, question->proto, NULL)) { return false; } // The question parser stores anything before _type._proto in question->host // So the question->host can be subtype or instance name based on its content if (question->sub) { mdns_subtype_t *subtype = service->subtype; while (subtype) { if (!strcasecmp(subtype->subtype, question->host)) { return true; } subtype = subtype->next; } return false; } if (question->host) { if (strcasecmp(_mdns_get_service_instance_name(service), question->host) != 0) { return false; } } return true; } /** * @brief Create answer packet to questions from parsed packet */ static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_packet) { if (!parsed_packet->questions) { return; } bool send_flush = parsed_packet->src_port == MDNS_SERVICE_PORT; bool unicast = false; bool shared = false; mdns_tx_packet_t *packet = _mdns_alloc_packet_default(parsed_packet->tcpip_if, parsed_packet->ip_protocol); if (!packet) { return; } packet->flags = MDNS_FLAGS_AUTHORITATIVE; packet->distributed = parsed_packet->distributed; packet->id = parsed_packet->id; mdns_parsed_question_t *q = parsed_packet->questions; while (q) { shared = q->type == MDNS_TYPE_PTR || q->type == MDNS_TYPE_SDPTR || !parsed_packet->probe; if (q->type == MDNS_TYPE_SRV || q->type == MDNS_TYPE_TXT) { mdns_srv_item_t *service = _mdns_get_service_item_instance(q->host, q->service, q->proto, NULL); if (!_mdns_create_answer_from_service(packet, service->service, q, shared, send_flush)) { _mdns_free_tx_packet(packet); return; } } else if (q->service && q->proto) { mdns_srv_item_t *service = _mdns_server->services; while (service) { if (_mdns_service_match_ptr_question(service->service, q)) { if (!_mdns_create_answer_from_service(packet, service->service, q, shared, send_flush)) { _mdns_free_tx_packet(packet); return; } } service = service->next; } } else if (q->type == MDNS_TYPE_A || q->type == MDNS_TYPE_AAAA) { if (!_mdns_create_answer_from_hostname(packet, q->host, send_flush)) { _mdns_free_tx_packet(packet); return; } } else if (q->type == MDNS_TYPE_ANY) { if (!_mdns_append_host_list(&packet->answers, send_flush, false)) { _mdns_free_tx_packet(packet); return; } } else if (!_mdns_alloc_answer(&packet->answers, q->type, NULL, NULL, send_flush, false)) { _mdns_free_tx_packet(packet); return; } #ifdef MDNS_REPEAT_QUERY_IN_RESPONSE if (parsed_packet->src_port != MDNS_SERVICE_PORT && // Repeat the queries only for "One-Shot mDNS queries" (q->type == MDNS_TYPE_ANY || q->type == MDNS_TYPE_A || q->type == MDNS_TYPE_AAAA)) { mdns_out_question_t * out_question = malloc(sizeof(mdns_out_question_t)); if (out_question == NULL) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); return; } out_question->type = q->type; out_question->unicast = q->unicast; out_question->host = q->host; q->host = NULL; out_question->service = q->service; q->service = NULL; out_question->proto = q->proto; q->proto = NULL; out_question->domain = q->domain; q->domain = NULL; out_question->next = NULL; out_question->own_dynamic_memory = true; queueToEnd(mdns_out_question_t, packet->questions, out_question); } #endif // MDNS_REPEAT_QUERY_IN_RESPONSE if (q->unicast) { unicast = true; } q = q->next; } if (unicast || !send_flush) { memcpy(&packet->dst, &parsed_packet->src, sizeof(esp_ip_addr_t)); packet->port = parsed_packet->src_port; } static uint8_t share_step = 0; if (shared) { _mdns_schedule_tx_packet(packet, 25 + (share_step * 25)); share_step = (share_step + 1) & 0x03; } else { _mdns_dispatch_tx_packet(packet); _mdns_free_tx_packet(packet); } } /** * @brief Check if question is already in the list */ static bool _mdns_question_exists(mdns_out_question_t * needle, mdns_out_question_t * haystack) { while (haystack) { if (haystack->type == needle->type && haystack->host == needle->host && haystack->service == needle->service && haystack->proto == needle->proto) { return true; } haystack = haystack->next; } return false; } static bool _mdns_append_host(mdns_out_answer_t ** destination, mdns_host_item_t * host, bool flush, bool bye) { if (!_mdns_alloc_answer(destination, MDNS_TYPE_A, NULL, host, flush, bye)) { return false; } if (!_mdns_alloc_answer(destination, MDNS_TYPE_AAAA, NULL, host, flush, bye)) { return false; } return true; } static bool _mdns_append_host_list_in_services(mdns_out_answer_t ** destination, mdns_srv_item_t * services[], size_t services_len, bool flush, bool bye) { if (services == NULL) { mdns_host_item_t * host = mdns_get_host_item(_mdns_server->hostname); if (host != NULL) { return _mdns_append_host(destination, host, flush, bye); } return true; } for (size_t i = 0; i < services_len; i++) { mdns_host_item_t *host = mdns_get_host_item(services[i]->service->hostname); if (!_mdns_append_host(destination, host, flush, bye)) { return false; } } return true; } static bool _mdns_append_host_list(mdns_out_answer_t ** destination, bool flush, bool bye) { if (!_str_null_or_empty(_mdns_server->hostname)) { mdns_host_item_t * self_host = mdns_get_host_item(_mdns_server->hostname); if (!_mdns_append_host(destination, self_host, flush, bye)) { return false; } } mdns_host_item_t * host = _mdns_host_list; while (host != NULL) { host = host->next; if (!_mdns_append_host(destination, host, flush, bye)) { return false; } } return true; } static bool _mdns_append_host_question(mdns_out_question_t **questions, const char *hostname, bool unicast) { mdns_out_question_t *q = (mdns_out_question_t *)malloc(sizeof(mdns_out_question_t)); if (!q) { HOOK_MALLOC_FAILED; return false; } q->next = NULL; q->unicast = unicast; q->type = MDNS_TYPE_ANY; q->host = hostname; q->service = NULL; q->proto = NULL; q->domain = MDNS_DEFAULT_DOMAIN; q->own_dynamic_memory = false; if (_mdns_question_exists(q, *questions)) { free(q); } else { queueToEnd(mdns_out_question_t, *questions, q); } return true; } static bool _mdns_append_host_questions_for_services(mdns_out_question_t **questions, mdns_srv_item_t *services[], size_t len, bool unicast) { if (!_str_null_or_empty(_mdns_server->hostname) && !_mdns_append_host_question(questions, _mdns_server->hostname, unicast)) { return false; } for (size_t i = 0; i < len; i++) { if (!_mdns_append_host_question(questions, services[i]->service->hostname, unicast)) { return false; } } return true; } /** * @brief Create probe packet for particular services on particular PCB */ 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); if (!packet) { return NULL; } size_t i; for (i=0; inext = NULL; q->unicast = first; q->type = MDNS_TYPE_ANY; q->host = _mdns_get_service_instance_name(services[i]->service); q->service = services[i]->service->service; q->proto = services[i]->service->proto; q->domain = MDNS_DEFAULT_DOMAIN; q->own_dynamic_memory = false; if (!q->host || _mdns_question_exists(q, packet->questions)) { free(q); continue; } else { queueToEnd(mdns_out_question_t, packet->questions, q); } if (!q->host || !_mdns_alloc_answer(&packet->servers, MDNS_TYPE_SRV, services[i]->service, NULL, false, false)) { _mdns_free_tx_packet(packet); return NULL; } } if (include_ip) { if (!_mdns_append_host_questions_for_services(&packet->questions, services, len, first)) { _mdns_free_tx_packet(packet); return NULL; } if (!_mdns_append_host_list_in_services(&packet->servers, services, len, false, false)) { _mdns_free_tx_packet(packet); return NULL; } } return packet; } /** * @brief Create announce packet for particular services on particular PCB */ 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); if (!packet) { return NULL; } packet->flags = MDNS_FLAGS_AUTHORITATIVE; uint8_t i; for (i=0; ianswers, MDNS_TYPE_SDPTR, services[i]->service, NULL, false, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, services[i]->service, NULL, false, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, services[i]->service, NULL, true, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, services[i]->service, NULL, true, false)) { _mdns_free_tx_packet(packet); return NULL; } } if (include_ip) { if (!_mdns_append_host_list_in_services(&packet->servers, services, len, true, false)) { _mdns_free_tx_packet(packet); return NULL; } } return packet; } /** * @brief Convert probe packet to announce */ static mdns_tx_packet_t * _mdns_create_announce_from_probe(mdns_tx_packet_t * probe) { mdns_tx_packet_t * packet = _mdns_alloc_packet_default(probe->tcpip_if, probe->ip_protocol); if (!packet) { return NULL; } packet->flags = MDNS_FLAGS_AUTHORITATIVE; mdns_out_answer_t * s = probe->servers; while (s) { if (s->type == MDNS_TYPE_SRV) { if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SDPTR, s->service, NULL, false, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, s->service, NULL, false, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, s->service, NULL, true, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, s->service, NULL, true, false)) { _mdns_free_tx_packet(packet); return NULL; } mdns_host_item_t *host = mdns_get_host_item(s->service->hostname); if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_A, NULL, host, true, false) || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_AAAA, NULL, host, true, false)) { _mdns_free_tx_packet(packet); return NULL; } } else if (s->type == MDNS_TYPE_A || s->type == MDNS_TYPE_AAAA) { if (!_mdns_alloc_answer(&packet->answers, s->type, NULL, s->host, true, false)) { _mdns_free_tx_packet(packet); return NULL; } } s = s->next; } return packet; } /** * @brief Send by for particular services on particular PCB */ 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); if (!packet) { return; } packet->flags = MDNS_FLAGS_AUTHORITATIVE; size_t i; for (i=0; ianswers, MDNS_TYPE_PTR, services[i]->service, NULL, true, true)) { _mdns_free_tx_packet(packet); return; } } if (include_ip) { _mdns_append_host_list_in_services(&packet->answers, services, len, true, true); } _mdns_dispatch_tx_packet(packet); _mdns_free_tx_packet(packet); } /** * @brief Send probe for additional services on particular PCB */ 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]; size_t services_final_len = len; if (PCB_STATE_IS_PROBING(pcb)) { services_final_len += pcb->probe_services_len; } mdns_srv_item_t ** _services = NULL; if (services_final_len) { _services = (mdns_srv_item_t **)malloc(sizeof(mdns_srv_item_t *) * services_final_len); if (!_services) { HOOK_MALLOC_FAILED; return; } size_t i; for (i=0; iprobe_services) { for (i=0; iprobe_services_len; i++) { _services[len+i] = pcb->probe_services[i]; } free(pcb->probe_services); } } probe_ip = pcb->probe_ip || probe_ip; pcb->probe_ip = false; pcb->probe_services = NULL; pcb->probe_services_len = 0; pcb->probe_running = false; mdns_tx_packet_t * packet = _mdns_create_probe_packet(tcpip_if, ip_protocol, _services, services_final_len, true, probe_ip); if (!packet) { free(_services); return; } pcb->probe_ip = probe_ip; pcb->probe_services = _services; pcb->probe_services_len = services_final_len; pcb->probe_running = true; _mdns_schedule_tx_packet(packet, ((pcb->failed_probes > 5)?1000:120) + (esp_random() & 0x7F)); pcb->state = PCB_PROBE_1; } /** * @brief Send probe for particular services on particular PCB * * Tests possible duplication on probing service structure and probes only for new entries. * - If pcb probing then add only non-probing services and restarts probing * - If pcb not probing, run probing for all specified services */ 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_clear_pcb_tx_queue_head(tcpip_if, ip_protocol); if (_str_null_or_empty(_mdns_server->hostname)) { pcb->state = PCB_RUNNING; return; } if (PCB_STATE_IS_PROBING(pcb)) { // Looking for already probing services to resolve duplications mdns_srv_item_t * new_probe_services[len]; int new_probe_service_len = 0; bool found; for (size_t j=0; j < len; ++j) { found = false; for (int i=0; i < pcb->probe_services_len; ++i) { if (pcb->probe_services[i] == services[j]) { found = true; break; } } if (!found) { new_probe_services[new_probe_service_len++] = services[j]; } } // init probing for newly added services _mdns_init_pcb_probe_new_service(tcpip_if, ip_protocol, new_probe_service_len?new_probe_services:NULL, new_probe_service_len, probe_ip); } else { // not probing, so init for all services _mdns_init_pcb_probe_new_service(tcpip_if, ip_protocol, services, len, probe_ip); } } /** * @brief Restart the responder on particular PCB */ static void _mdns_restart_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) { size_t srv_count = 0; mdns_srv_item_t * a = _mdns_server->services; while (a) { srv_count++; a = a->next; } mdns_srv_item_t * services[srv_count]; size_t i = 0; a = _mdns_server->services; while (a) { services[i++] = a; a = a->next; } _mdns_init_pcb_probe(tcpip_if, ip_protocol, services, srv_count, true); } /** * @brief Send by for particular services */ static void _mdns_send_bye(mdns_srv_item_t ** services, size_t len, bool include_ip) { uint8_t i, j; if (_str_null_or_empty(_mdns_server->hostname)) { return; } for (i=0; iinterfaces[i].pcbs[j].pcb && _mdns_server->interfaces[i].pcbs[j].state == PCB_RUNNING) { _mdns_pcb_send_bye((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip); } } } } /** * @brief Send announcement on particular PCB */ 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]; size_t i; if (_pcb->pcb) { if (PCB_STATE_IS_PROBING(_pcb)) { _mdns_init_pcb_probe(tcpip_if, ip_protocol, services, len, include_ip); } else if (PCB_STATE_IS_ANNOUNCING(_pcb)) { mdns_tx_packet_t * p = _mdns_get_next_pcb_packet(tcpip_if, ip_protocol); if (p) { for (i=0; ianswers, MDNS_TYPE_SDPTR, services[i]->service, NULL, false, false) || !_mdns_alloc_answer(&p->answers, MDNS_TYPE_PTR, services[i]->service, NULL, false, false) || !_mdns_alloc_answer(&p->answers, MDNS_TYPE_SRV, services[i]->service, NULL, true, false) || !_mdns_alloc_answer(&p->answers, MDNS_TYPE_TXT, services[i]->service, NULL, true, false)) { break; } } if (include_ip) { _mdns_dealloc_answer(&p->additional, MDNS_TYPE_A, NULL); _mdns_dealloc_answer(&p->additional, MDNS_TYPE_AAAA, NULL); _mdns_append_host_list_in_services(&p->answers, services, len, true, false); } _pcb->state = PCB_ANNOUNCE_1; } } else if (_pcb->state == PCB_RUNNING) { if (_str_null_or_empty(_mdns_server->hostname)) { return; } _pcb->state = PCB_ANNOUNCE_1; mdns_tx_packet_t * p = _mdns_create_announce_packet(tcpip_if, ip_protocol, services, len, include_ip); if (p) { _mdns_schedule_tx_packet(p, 0); } } } } /** * @brief Send probe on all active PCBs */ 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; for (i=0; iinterfaces[i].pcbs[j].pcb) { mdns_pcb_t * _pcb = &_mdns_server->interfaces[i].pcbs[j]; if (clear_old_probe) { free(_pcb->probe_services); _pcb->probe_services = NULL; _pcb->probe_services_len = 0; _pcb->probe_running = false; } _mdns_init_pcb_probe((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, probe_ip); } } } } /** * @brief Send announcement on all active PCBs */ static void _mdns_announce_all_pcbs(mdns_srv_item_t ** services, size_t len, bool include_ip) { uint8_t i, j; for (i=0; iservices; while (a) { srv_count++; a = a->next; } if (!srv_count) { return; } mdns_srv_item_t * services[srv_count]; size_t i = 0; a = _mdns_server->services; while (a) { services[i++] = a; a = a->next; } _mdns_send_bye(services, srv_count, include_ip); } /** * @brief Stop the responder on all services without instance */ static void _mdns_send_bye_all_pcbs_no_instance(bool include_ip) { size_t srv_count = 0; mdns_srv_item_t * a = _mdns_server->services; while (a) { if (!a->service->instance) { srv_count++; } a = a->next; } if (!srv_count) { return; } mdns_srv_item_t * services[srv_count]; size_t i = 0; a = _mdns_server->services; while (a) { if (!a->service->instance) { services[i++] = a; } a = a->next; } _mdns_send_bye(services, srv_count, include_ip); } /** * @brief Restart the responder on all services without instance */ static void _mdns_restart_all_pcbs_no_instance(void) { size_t srv_count = 0; mdns_srv_item_t * a = _mdns_server->services; while (a) { if (!a->service->instance) { srv_count++; } a = a->next; } if (!srv_count) { return; } mdns_srv_item_t * services[srv_count]; size_t i = 0; a = _mdns_server->services; while (a) { if (!a->service->instance) { services[i++] = a; } a = a->next; } _mdns_probe_all_pcbs(services, srv_count, false, true); } /** * @brief Restart the responder on all active PCBs */ static void _mdns_restart_all_pcbs(void) { _mdns_clear_tx_queue_head(); size_t srv_count = 0; mdns_srv_item_t * a = _mdns_server->services; while (a) { srv_count++; a = a->next; } mdns_srv_item_t * services[srv_count]; size_t l = 0; a = _mdns_server->services; while (a) { services[l++] = a; a = a->next; } _mdns_probe_all_pcbs(services, srv_count, true, true); } /** * @brief creates/allocates new text item list * @param num_items service number of txt items or 0 * @param txt service txt items array or NULL * * @return pointer to the linked txt item list or NULL */ static mdns_txt_linked_item_t * _mdns_allocate_txt(size_t num_items, mdns_txt_item_t txt[]) { mdns_txt_linked_item_t * new_txt = NULL; size_t i = 0; if (num_items) { for (i=0; ikey = strdup(txt[i].key); if (!new_item->key) { free(new_item); break; } new_item->value = strdup(txt[i].value); if (!new_item->value) { free((char *)new_item->key); free(new_item); break; } new_item->value_len = strlen(new_item->value); new_item->next = new_txt; new_txt = new_item; } } return new_txt; } /** * @brief Deallocate the txt linked list * @param txt pointer to the txt pointer to free, noop if txt==NULL */ static void _mdns_free_linked_txt(mdns_txt_linked_item_t *txt) { mdns_txt_linked_item_t *t; while (txt) { t = txt; txt = txt->next; free((char *)t->value); free((char *)t->key); free(t); } } /** * @brief creates/allocates new service * @param service service type * @param proto service proto * @param hostname service hostname * @param port service port * @param instance service instance * @param num_items service number of txt items or 0 * @param txt service txt items array or NULL * * @return pointer to the service or NULL on error */ static mdns_service_t * _mdns_create_service(const char * service, const char * proto, const char * hostname, uint16_t port, const char * instance, size_t num_items, mdns_txt_item_t txt[]) { mdns_service_t * s = (mdns_service_t *)calloc(1, sizeof(mdns_service_t)); if (!s) { HOOK_MALLOC_FAILED; return NULL; } mdns_txt_linked_item_t * new_txt = _mdns_allocate_txt(num_items, txt); if (num_items && new_txt == NULL) { goto fail; } s->priority = 0; s->weight = 0; s->instance = instance?strndup(instance, MDNS_NAME_BUF_LEN - 1):NULL; s->txt = new_txt; s->port = port; s->subtype = NULL; if (hostname) { s->hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!s->hostname) { goto fail; } } else { s->hostname = NULL; } s->service = strndup(service, MDNS_NAME_BUF_LEN - 1); if (!s->service) { goto fail; } s->proto = strndup(proto, MDNS_NAME_BUF_LEN - 1); if (!s->proto) { goto fail; } return s; fail: _mdns_free_linked_txt(s->txt); free((char *)s->instance); free((char *)s->service); free((char *)s->proto); free((char *)s->hostname); free(s); return NULL; } /** * @brief Remove and free service answer from answer list (destination) */ static void _mdns_dealloc_scheduled_service_answers(mdns_out_answer_t ** destination, mdns_service_t * service) { mdns_out_answer_t * d = *destination; if (!d) { return; } while (d && d->service == service) { *destination = d->next; free(d); d = *destination; } while (d && d->next) { mdns_out_answer_t * a = d->next; if (a->service == service) { d->next = a->next; free(a); } else { d = d->next; } } } /** * @brief Find, remove and free answers and scheduled packets for service */ static void _mdns_remove_scheduled_service_packets(mdns_service_t * service) { if (!service) { return; } mdns_tx_packet_t * p = NULL; mdns_tx_packet_t * q = _mdns_server->tx_queue_head; while (q) { bool had_answers = (q->answers != NULL); _mdns_dealloc_scheduled_service_answers(&(q->answers), service); _mdns_dealloc_scheduled_service_answers(&(q->additional), service); _mdns_dealloc_scheduled_service_answers(&(q->servers), service); mdns_pcb_t * _pcb = &_mdns_server->interfaces[q->tcpip_if].pcbs[q->ip_protocol]; if(_pcb->pcb) { if (PCB_STATE_IS_PROBING(_pcb)) { uint8_t i; //check if we are probing this service for (i=0; i<_pcb->probe_services_len; i++) { mdns_srv_item_t * s = _pcb->probe_services[i]; if (s->service == service){ break; } } if (i < _pcb->probe_services_len) { if (_pcb->probe_services_len > 1) { uint8_t n; for (n=(i+1); n<_pcb->probe_services_len; n++) { _pcb->probe_services[n-1] = _pcb->probe_services[n]; } _pcb->probe_services_len--; } else { _pcb->probe_services_len = 0; free(_pcb->probe_services); _pcb->probe_services = NULL; if (!_pcb->probe_ip) { _pcb->probe_running = false; _pcb->state = PCB_RUNNING; } } if (q->questions) { mdns_out_question_t * qsn = NULL; mdns_out_question_t * qs = q->questions; if (qs->type == MDNS_TYPE_ANY && qs->service && strcmp(qs->service, service->service) == 0 && qs->proto && strcmp(qs->proto, service->proto) == 0) { q->questions = q->questions->next; free(qs); } else while (qs->next) { qsn = qs->next; if (qsn->type == MDNS_TYPE_ANY && qsn->service && strcmp(qsn->service, service->service) == 0 && qsn->proto && strcmp(qsn->proto, service->proto) == 0) { qs->next = qsn->next; free(qsn); break; } qs = qs->next; } } } } else if (PCB_STATE_IS_ANNOUNCING(_pcb)) { //if answers were cleared, set to running if (had_answers && q->answers == NULL) { _pcb->state = PCB_RUNNING; } } } p = q; q = q->next; if(!p->questions && !p->answers && !p->additional && !p->servers){ queueDetach(mdns_tx_packet_t, _mdns_server->tx_queue_head, p); _mdns_free_tx_packet(p); } } } /** * @brief free service memory * * @param service the service */ static void _mdns_free_service(mdns_service_t * service) { if (!service) { return; } free((char *)service->instance); free((char *)service->service); free((char *)service->proto); free((char *)service->hostname); while (service->txt) { mdns_txt_linked_item_t * s = service->txt; service->txt = service->txt->next; free((char *)s->key); free((char *)s->value); free(s); } while (service->subtype) { mdns_subtype_t * next = service->subtype->next; free((char *)service->subtype->subtype); free(service->subtype); service->subtype = next; } free(service); } /* * Received Packet Handling * */ /** * @brief Detect SRV collision */ static int _mdns_check_srv_collision(mdns_service_t * service, uint16_t priority, uint16_t weight, uint16_t port, const char * host, const char * domain) { if (_str_null_or_empty(_mdns_server->hostname)) { return 0; } size_t our_host_len = strlen(_mdns_server->hostname); size_t our_len = 14 + our_host_len; size_t their_host_len = strlen(host); size_t their_domain_len = strlen(domain); size_t their_len = 9 + their_host_len + their_domain_len; if (their_len > our_len) { return 1;//they win } else if (their_len < our_len) { return -1;//we win } uint16_t our_index = 0; uint8_t our_data[our_len]; _mdns_append_u16(our_data, &our_index, service->priority); _mdns_append_u16(our_data, &our_index, service->weight); _mdns_append_u16(our_data, &our_index, service->port); our_data[our_index++] = our_host_len; memcpy(our_data + our_index, _mdns_server->hostname, our_host_len); our_index += our_host_len; our_data[our_index++] = 5; memcpy(our_data + our_index, MDNS_DEFAULT_DOMAIN, 5); our_index += 5; our_data[our_index++] = 0; uint16_t their_index = 0; uint8_t their_data[their_len]; _mdns_append_u16(their_data, &their_index, priority); _mdns_append_u16(their_data, &their_index, weight); _mdns_append_u16(their_data, &their_index, port); their_data[their_index++] = their_host_len; memcpy(their_data + their_index, host, their_host_len); their_index += their_host_len; their_data[their_index++] = their_domain_len; memcpy(their_data + their_index, domain, their_domain_len); their_index += their_domain_len; their_data[their_index++] = 0; int ret = memcmp(our_data, their_data, our_len); if (ret > 0) { return -1;//we win } else if (ret < 0) { return 1;//they win } return 0;//same } /** * @brief Detect TXT collision */ static int _mdns_check_txt_collision(mdns_service_t * service, const uint8_t * data, size_t len) { size_t data_len = 0; if (len == 1 && service->txt) { return -1;//we win } else if (len > 1 && !service->txt) { return 1;//they win } else if (len == 1 && !service->txt) { return 0;//same } mdns_txt_linked_item_t * txt = service->txt; while (txt) { data_len += 1 /* record-len */ + strlen(txt->key) + txt->value_len + (txt->value ? 1 : 0 /* "=" */); txt = txt->next; } if (len > data_len) { return 1;//they win } else if (len < data_len) { return -1;//we win } uint8_t ours[len]; uint16_t index = 0; txt = service->txt; while (txt) { append_one_txt_record_entry(ours, &index, txt); txt = txt->next; } int ret = memcmp(ours, data, len); if (ret > 0) { return -1;//we win } else if (ret < 0) { return 1;//they win } return 0;//same } /** * @brief Set interface as duplicate if another is found on the same subnet */ static void _mdns_dup_interface(mdns_if_t tcpip_if) { uint8_t i; mdns_if_t other_if = _mdns_get_other_if (tcpip_if); if (other_if == MDNS_IF_MAX) { return; // no other interface found } for (i=0; iinterfaces[other_if].pcbs[i].pcb) { //stop this interface and mark as dup if (_mdns_server->interfaces[tcpip_if].pcbs[i].pcb) { _mdns_clear_pcb_tx_queue_head(tcpip_if, i); _mdns_pcb_deinit(tcpip_if, i); } _mdns_server->interfaces[tcpip_if].pcbs[i].state = PCB_DUP; _mdns_announce_pcb(other_if, i, NULL, 0, true); } } } /** * @brief Detect IPv4 address collision */ static int _mdns_check_a_collision(esp_ip4_addr_t * ip, mdns_if_t tcpip_if) { esp_netif_ip_info_t if_ip_info; esp_netif_ip_info_t other_ip_info; if (!ip->addr) { return 1;//denial! they win } if (esp_netif_get_ip_info(_mdns_get_esp_netif(tcpip_if), &if_ip_info)) { return 1;//they win } int ret = memcmp((uint8_t*)&if_ip_info.ip.addr, (uint8_t*)&ip->addr, sizeof(esp_ip4_addr_t)); if (ret > 0) { return -1;//we win } else if (ret < 0) { //is it the other interface? mdns_if_t other_if = _mdns_get_other_if (tcpip_if); if (other_if == MDNS_IF_MAX) { return 1;//AP interface! They win } if (esp_netif_get_ip_info(_mdns_get_esp_netif(other_if), &other_ip_info)) { return 1;//IPv4 not active! They win } if (ip->addr != other_ip_info.ip.addr) { return 1;//IPv4 not ours! They win } _mdns_dup_interface(tcpip_if); return 2;//they win } return 0;//same } #if CONFIG_LWIP_IPV6 /** * @brief Detect IPv6 address collision */ static int _mdns_check_aaaa_collision(esp_ip6_addr_t * ip, mdns_if_t tcpip_if) { struct esp_ip6_addr if_ip6; struct esp_ip6_addr other_ip6; if (_ipv6_address_is_zero(*ip)) { return 1;//denial! they win } if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(tcpip_if), &if_ip6)) { return 1;//they win } int ret = memcmp((uint8_t*)&if_ip6.addr, (uint8_t*)ip->addr, _MDNS_SIZEOF_IP6_ADDR); if (ret > 0) { return -1;//we win } else if (ret < 0) { //is it the other interface? mdns_if_t other_if = _mdns_get_other_if (tcpip_if); if (other_if == MDNS_IF_MAX) { return 1;//AP interface! They win } if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(other_if), &other_ip6)) { return 1;//IPv6 not active! They win } if (memcmp((uint8_t*)&other_ip6.addr, (uint8_t*)ip->addr, _MDNS_SIZEOF_IP6_ADDR)) { return 1;//IPv6 not ours! They win } _mdns_dup_interface(tcpip_if); return 2;//they win } return 0;//same } #endif static bool _hostname_is_ours(const char * hostname) { if (strcasecmp(hostname, _mdns_server->hostname) == 0) { return true; } mdns_host_item_t * host = _mdns_host_list; while (host != NULL) { if (strcasecmp(hostname, host->hostname) == 0) { return true; } host = host->next; } return false; } static bool _mdns_delegate_hostname_add(const char * hostname, mdns_ip_addr_t * address_list) { if (_hostname_is_ours(hostname)) { return true; } mdns_host_item_t * host = (mdns_host_item_t *)malloc(sizeof(mdns_host_item_t)); if (host == NULL) { return false; } host->address_list = address_list; host->hostname = hostname; host->next = _mdns_host_list; _mdns_host_list = host; return true; } static void free_address_list(mdns_ip_addr_t * address_list) { while (address_list != NULL) { mdns_ip_addr_t * next = address_list->next; free(address_list); address_list = next; } } static mdns_ip_addr_t * copy_address_list(const mdns_ip_addr_t * address_list) { mdns_ip_addr_t * head = NULL; mdns_ip_addr_t * tail = NULL; while (address_list != NULL) { mdns_ip_addr_t * addr = (mdns_ip_addr_t *)malloc(sizeof(mdns_ip_addr_t)); if (addr == NULL) { free_address_list(head); return NULL; } addr->addr = address_list->addr; addr->next = NULL; if (head == NULL) { head = addr; tail = addr; } else { tail->next = addr; tail = tail->next; } address_list = address_list->next; } return head; } static bool _mdns_delegate_hostname_remove(const char * hostname) { mdns_srv_item_t * srv = _mdns_server->services; mdns_srv_item_t * prev_srv = NULL; while (srv) { if (strcasecmp(srv->service->hostname, hostname) == 0) { mdns_srv_item_t * to_free = srv; _mdns_send_bye(&srv, 1, false); _mdns_remove_scheduled_service_packets(srv->service); if (prev_srv == NULL) { _mdns_server->services = srv->next; srv = srv->next; } else { prev_srv->next = srv->next; srv = srv->next; } _mdns_free_service(to_free->service); free(to_free); } else { prev_srv = srv; srv = srv->next; } } mdns_host_item_t * host = _mdns_host_list; mdns_host_item_t * prev_host = NULL; while (host != NULL) { if (strcasecmp(hostname, host->hostname) == 0) { if (prev_host == NULL) { _mdns_host_list = host->next; } else { prev_host->next = host->next; } free_address_list(host->address_list); free((char *)host->hostname); free(host); break; } else { prev_host = host; host = host->next; } } return true; } /** * @brief Check if parsed name is discovery */ static bool _mdns_name_is_discovery(mdns_name_t * name, uint16_t type) { return ( (name->host && name->host[0] && !strcasecmp(name->host, "_services")) && (name->service && name->service[0] && !strcasecmp(name->service, "_dns-sd")) && (name->proto && name->proto[0] && !strcasecmp(name->proto, "_udp")) && (name->domain && name->domain[0] && !strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN)) && type == MDNS_TYPE_PTR ); } /** * @brief Check if the parsed name is ours (matches service or host name) */ static bool _mdns_name_is_ours(mdns_name_t * name) { //domain have to be "local" if (_str_null_or_empty(name->domain) || strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN)) { return false; } //if service and proto are empty, host must match out hostname if (_str_null_or_empty(name->service) && _str_null_or_empty(name->proto)) { if (!_str_null_or_empty(name->host) && !_str_null_or_empty(_mdns_server->hostname) && _hostname_is_ours(name->host)) { return true; } return false; } //if service or proto is empty, name is invalid if (_str_null_or_empty(name->service) || _str_null_or_empty(name->proto)) { return false; } //find the service mdns_srv_item_t * service; if (name->sub) { service = _mdns_get_service_item_subtype(name->host, name->service, name->proto); } else if (_str_null_or_empty(name->host)) { service = _mdns_get_service_item(name->service, name->proto, NULL); } else { service = _mdns_get_service_item_instance(name->host, name->service, name->proto, NULL); } if (!service) { return false; } //if query is PTR query and we have service, we have success if (name->sub || _str_null_or_empty(name->host)) { return true; } //OK we have host in the name. find what is the instance of the service const char * instance = _mdns_get_service_instance_name(service->service); if (instance == NULL) { return false; } //compare the instance against the name if (strcasecmp(name->host, instance) == 0) { return true; } return false; } /** * @brief read uint16_t from a packet * @param packet the packet * @param index index in the packet where the value starts * * @return the value */ static inline uint16_t _mdns_read_u16(const uint8_t * packet, uint16_t index) { return (uint16_t)(packet[index]) << 8 | packet[index+1]; } /** * @brief read uint32_t from a packet * @param packet the packet * @param index index in the packet where the value starts * * @return the value */ static inline uint32_t _mdns_read_u32(const uint8_t * packet, uint16_t index) { return (uint32_t)(packet[index]) << 24 | (uint32_t)(packet[index+1]) << 16 | (uint32_t)(packet[index+2]) << 8 | packet[index+3]; } /** * @brief reads and formats MDNS FQDN into mdns_name_t structure * * @param packet MDNS packet * @param start Starting point of FQDN * @param name mdns_name_t structure to populate * * @return the address after the parsed FQDN in the packet or NULL on error */ static const uint8_t * _mdns_parse_fqdn(const uint8_t * packet, const uint8_t * start, mdns_name_t * name) { name->parts = 0; name->sub = 0; name->host[0] = 0; name->service[0] = 0; name->proto[0] = 0; name->domain[0] = 0; name->invalid = false; static char buf[MDNS_NAME_BUF_LEN]; const uint8_t * next_data = (uint8_t*)_mdns_read_fqdn(packet, start, name, buf); if (!next_data) { return 0; } if (!name->parts || name->invalid) { return next_data; } if (name->parts == 3) { memmove((uint8_t*)name + (MDNS_NAME_BUF_LEN), (uint8_t*)name, 3*(MDNS_NAME_BUF_LEN)); name->host[0] = 0; } else if (name->parts == 2) { memmove((uint8_t*)(name->domain), (uint8_t*)(name->service), (MDNS_NAME_BUF_LEN)); name->service[0] = 0; name->proto[0] = 0; } if (strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN) == 0 || strcasecmp(name->domain, "arpa") == 0) { return next_data; } name->invalid = true; // mark the current name invalid, but continue with other question return next_data; } /** * @brief Called from parser to check if question matches particular service */ static bool _mdns_question_matches(mdns_parsed_question_t * question, uint16_t type, mdns_srv_item_t * service) { if (question->type != type) { return false; } if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) { return true; } else if (type == MDNS_TYPE_PTR || type == MDNS_TYPE_SDPTR) { if (question->service && question->proto && question->domain && !strcasecmp(service->service->service, question->service) && !strcasecmp(service->service->proto, question->proto) && !strcasecmp(MDNS_DEFAULT_DOMAIN, question->domain)) { return true; } } else if (service && (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT)) { const char * name = _mdns_get_service_instance_name(service->service); if (name && question->host && question->service && question->proto && question->domain && !strcasecmp(name, question->host) && !strcasecmp(service->service->service, question->service) && !strcasecmp(service->service->proto, question->proto) && !strcasecmp(MDNS_DEFAULT_DOMAIN, question->domain)) { return true; } } return false; } /** * @brief Removes saved question from parsed data */ static void _mdns_remove_parsed_question(mdns_parsed_packet_t * parsed_packet, uint16_t type, mdns_srv_item_t * service) { mdns_parsed_question_t * q = parsed_packet->questions; if (_mdns_question_matches(q, type, service)) { parsed_packet->questions = q->next; free(q->host); free(q->service); free(q->proto); free(q->domain); free(q); return; } while (q->next) { mdns_parsed_question_t * p = q->next; if (_mdns_question_matches(p, type, service)) { q->next = p->next; free(p->host); free(p->service); free(p->proto); free(p->domain); free(p); return; } q = q->next; } } /** * @brief Get number of items in TXT parsed data */ static int _mdns_txt_items_count_get(const uint8_t * data, size_t len) { if (len == 1) { return 0; } int num_items = 0; uint16_t i=0; size_t partLen = 0; while (i < len) { partLen = data[i++]; if (!partLen) { break; } if ((i+partLen) > len) { return -1;//error } i+=partLen; num_items++; } return num_items; } /** * @brief Get the length of TXT item's key name */ static int _mdns_txt_item_name_get_len(const uint8_t * data, size_t len) { if (*data == '=') { return -1; } for (size_t i = 0; i < len; i++) { if (data[i] == '=') { return i; } } return len; } /** * @brief Create TXT result array from parsed TXT data */ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_item_t **out_txt, uint8_t **out_value_len, size_t *out_count) { *out_txt = NULL; *out_count = 0; uint16_t i=0, y; size_t partLen = 0; int num_items = _mdns_txt_items_count_get(data, len); if (num_items < 0) { return;//error } if (!num_items) { return; } mdns_txt_item_t * txt = (mdns_txt_item_t *)malloc(sizeof(mdns_txt_item_t) * num_items); if (!txt) { HOOK_MALLOC_FAILED; return; } uint8_t * txt_value_len = (uint8_t *)malloc(num_items); if (!txt_value_len) { free(txt); HOOK_MALLOC_FAILED; return; } memset(txt, 0, sizeof(mdns_txt_item_t) * num_items); memset(txt_value_len, 0, num_items); size_t txt_num = 0; while (i < len) { partLen = data[i++]; if (!partLen) { break; } if ((i+partLen) > len) { goto handle_error;//error } int name_len = _mdns_txt_item_name_get_len(data+i, partLen); if (name_len < 0) {//invalid item (no name) i += partLen; continue; } char * key = (char *)malloc(name_len + 1); if (!key) { HOOK_MALLOC_FAILED; goto handle_error;//error } mdns_txt_item_t * t = &txt[txt_num]; uint8_t * value_len = &txt_value_len[txt_num]; txt_num++; memcpy(key, data + i, name_len); key[name_len] = 0; i += name_len + 1; t->key = key; int new_value_len = partLen - name_len - 1; if (new_value_len > 0) { char * value = (char *)malloc(new_value_len + 1); if (!value) { HOOK_MALLOC_FAILED; goto handle_error;//error } memcpy(value, data + i, new_value_len); value[new_value_len] = 0; *value_len = new_value_len; i += new_value_len; t->value = value; } } *out_txt = txt; *out_count = txt_num; *out_value_len = txt_value_len; return; handle_error : for (y=0; ykey); free((char *)t->value); } free(txt_value_len); free(txt); } /** * @brief Duplicate string or return error */ static esp_err_t _mdns_strdup_check(char ** out, char * in) { if (in && in[0]) { *out = strdup(in); if (!*out) { return ESP_FAIL; } return ESP_OK; } *out = NULL; return ESP_OK; } /** * @brief main packet parser * * @param packet the packet */ void mdns_parse_packet(mdns_rx_packet_t * packet) { static mdns_name_t n; mdns_header_t header; const uint8_t * data = _mdns_get_packet_data(packet); size_t len = _mdns_get_packet_len(packet); const uint8_t * content = data + MDNS_HEAD_LEN; bool do_not_reply = false; mdns_search_once_t * search_result = NULL; #ifdef MDNS_ENABLE_DEBUG _mdns_dbg_printf("\nRX[%u][%u]: ", packet->tcpip_if, (uint32_t)packet->ip_protocol); if (packet->src.type == ESP_IPADDR_TYPE_V4) { _mdns_dbg_printf("From: " IPSTR ":%u, To: " IPSTR ", ", IP2STR(&packet->src.u_addr.ip4), packet->src_port, IP2STR(&packet->dest.u_addr.ip4)); } else { _mdns_dbg_printf("From: " IPV6STR ":%u, To: " IPV6STR ", ", IPV62STR(packet->src.u_addr.ip6), packet->src_port, IPV62STR(packet->dest.u_addr.ip6)); } mdns_debug_packet(data, len); #endif mdns_parsed_packet_t * parsed_packet = (mdns_parsed_packet_t *)malloc(sizeof(mdns_parsed_packet_t)); if (!parsed_packet) { HOOK_MALLOC_FAILED; return; } memset(parsed_packet, 0, sizeof(mdns_parsed_packet_t)); mdns_name_t * name = &n; memset(name, 0, sizeof(mdns_name_t)); header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET); header.flags.value = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET); header.questions = _mdns_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET); header.answers = _mdns_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET); header.servers = _mdns_read_u16(data, MDNS_HEAD_SERVERS_OFFSET); header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET); if (header.flags.value == MDNS_FLAGS_AUTHORITATIVE && packet->src_port != MDNS_SERVICE_PORT) { free(parsed_packet); return; } //if we have not set the hostname, we can not answer questions if (header.questions && !header.answers && _str_null_or_empty(_mdns_server->hostname)) { free(parsed_packet); return; } parsed_packet->tcpip_if = packet->tcpip_if; parsed_packet->ip_protocol = packet->ip_protocol; parsed_packet->multicast = packet->multicast; parsed_packet->authoritative = header.flags.value == MDNS_FLAGS_AUTHORITATIVE; parsed_packet->distributed = header.flags.value == MDNS_FLAGS_DISTRIBUTED; parsed_packet->id = header.id; esp_netif_ip_addr_copy(&parsed_packet->src, &packet->src); parsed_packet->src_port = packet->src_port; if (header.questions) { uint8_t qs = header.questions; while (qs--) { content = _mdns_parse_fqdn(data, content, name); if (!content) { header.answers = 0; header.additional = 0; header.servers = 0; goto clear_rx_packet;//error } uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); bool unicast = !!(mdns_class & 0x8000); mdns_class &= 0x7FFF; content = content + 4; if (mdns_class != 0x0001 || name->invalid) {//bad class or invalid name for this question entry continue; } if (_mdns_name_is_discovery(name, type)) { //service discovery parsed_packet->discovery = true; mdns_srv_item_t * a = _mdns_server->services; while (a) { mdns_parsed_question_t * question = (mdns_parsed_question_t *)calloc(1, sizeof(mdns_parsed_question_t)); if (!question) { HOOK_MALLOC_FAILED; goto clear_rx_packet; } question->next = parsed_packet->questions; parsed_packet->questions = question; question->unicast = unicast; question->type = MDNS_TYPE_SDPTR; question->host = NULL; question->service = strdup(a->service->service); question->proto = strdup(a->service->proto); question->domain = strdup(MDNS_DEFAULT_DOMAIN); if (!question->service || !question->proto || !question->domain) { goto clear_rx_packet; } a = a->next; } continue; } if (!_mdns_name_is_ours(name)) { continue; } if (type == MDNS_TYPE_ANY && !_str_null_or_empty(name->host)) { parsed_packet->probe = true; } mdns_parsed_question_t * question = (mdns_parsed_question_t *)calloc(1, sizeof(mdns_parsed_question_t)); if (!question) { HOOK_MALLOC_FAILED; goto clear_rx_packet; } question->next = parsed_packet->questions; parsed_packet->questions = question; question->unicast = unicast; question->type = type; question->sub = name->sub; if (_mdns_strdup_check(&(question->host), name->host) || _mdns_strdup_check(&(question->service), name->service) || _mdns_strdup_check(&(question->proto), name->proto) || _mdns_strdup_check(&(question->domain), name->domain)) { goto clear_rx_packet; } } } if (header.questions && !parsed_packet->questions && !parsed_packet->discovery && !header.answers) { goto clear_rx_packet; } else if (header.answers || header.servers || header.additional) { uint16_t recordIndex = 0; while (content < (data + len)) { content = _mdns_parse_fqdn(data, content, name); if (!content) { goto clear_rx_packet;//error } uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); uint32_t ttl = _mdns_read_u32(content, MDNS_TTL_OFFSET); uint16_t data_len = _mdns_read_u16(content, MDNS_LEN_OFFSET); const uint8_t * data_ptr = content + MDNS_DATA_OFFSET; mdns_class &= 0x7FFF; content = data_ptr + data_len; if (content > (data + len)) { goto clear_rx_packet; } bool discovery = false; bool ours = false; mdns_srv_item_t * service = NULL; mdns_parsed_record_type_t record_type = MDNS_ANSWER; if (recordIndex >= (header.answers + header.servers)) { record_type = MDNS_EXTRA; } else if (recordIndex >= (header.answers)) { record_type = MDNS_NS; } recordIndex++; if (type == MDNS_TYPE_NSEC || type == MDNS_TYPE_OPT) { //skip NSEC and OPT continue; } if (parsed_packet->discovery && _mdns_name_is_discovery(name, type)) { discovery = true; } else if (!name->sub && _mdns_name_is_ours(name)) { ours = true; if (name->service && name->service[0] && name->proto && name->proto[0]) { service = _mdns_get_service_item(name->service, name->proto, NULL); } } else { if (!parsed_packet->authoritative || record_type == MDNS_NS) { //skip this record continue; } search_result = _mdns_search_find_from(_mdns_server->search_once, name, type, packet->tcpip_if, packet->ip_protocol); } if (type == MDNS_TYPE_PTR) { if (!_mdns_parse_fqdn(data, data_ptr, name)) { continue;//error } if (search_result) { _mdns_search_result_add_ptr(search_result, name->host, name->service, name->proto, packet->tcpip_if, packet->ip_protocol, ttl); } else if ((discovery || ours) && !name->sub && _mdns_name_is_ours(name)) { if (discovery) { service = _mdns_get_service_item(name->service, name->proto, NULL); _mdns_remove_parsed_question(parsed_packet, MDNS_TYPE_SDPTR, service); } else if (service && parsed_packet->questions && !parsed_packet->probe) { _mdns_remove_parsed_question(parsed_packet, type, service); } else if (service) { //check if TTL is more than half of the full TTL value (4500) if (ttl > 2250) { _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); } } } } else if (type == MDNS_TYPE_SRV) { mdns_result_t * result = NULL; if (search_result && search_result->type == MDNS_TYPE_PTR) { result = search_result->result; while (result) { if (packet->tcpip_if == result->tcpip_if && packet->ip_protocol == result->ip_protocol && result->instance_name && !strcmp(name->host, result->instance_name)) { break; } result = result->next; } if (!result) { result = _mdns_search_result_add_ptr(search_result, name->host, name->service, name->proto, packet->tcpip_if, packet->ip_protocol, ttl); if (!result) { continue;//error } } } if (!_mdns_parse_fqdn(data, data_ptr + MDNS_SRV_FQDN_OFFSET, name)) { continue;//error } uint16_t priority = _mdns_read_u16(data_ptr, MDNS_SRV_PRIORITY_OFFSET); uint16_t weight = _mdns_read_u16(data_ptr, MDNS_SRV_WEIGHT_OFFSET); uint16_t port = _mdns_read_u16(data_ptr, MDNS_SRV_PORT_OFFSET); if (search_result) { if (search_result->type == MDNS_TYPE_PTR) { if (!result->hostname) { // assign host/port for this entry only if not previously set result->port = port; result->hostname = strdup(name->host); } } else { _mdns_search_result_add_srv(search_result, name->host, port, packet->tcpip_if, packet->ip_protocol, ttl); } } else if (ours) { if (parsed_packet->questions && !parsed_packet->probe) { _mdns_remove_parsed_question(parsed_packet, type, service); continue; } else if (parsed_packet->distributed) { _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); continue; } //detect collision (-1=won, 0=none, 1=lost) int col = 0; if (mdns_class > 1) { col = 1; } else if (!mdns_class) { col = -1; } else if (service) { // only detect srv collision if service existed col = _mdns_check_srv_collision(service->service, priority, weight, port, name->host, name->domain); } if (service && col && (parsed_packet->probe || parsed_packet->authoritative)) { if (col > 0 || !port) { do_not_reply = true; if (_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].failed_probes++; if (!_str_null_or_empty(service->service->instance)) { char * new_instance = _mdns_mangle_name((char *)service->service->instance); if (new_instance) { free((char *)service->service->instance); service->service->instance = new_instance; } _mdns_probe_all_pcbs(&service, 1, false, false); } else if (!_str_null_or_empty(_mdns_server->instance)) { char * new_instance = _mdns_mangle_name((char *)_mdns_server->instance); if (new_instance) { free((char *)_mdns_server->instance); _mdns_server->instance = new_instance; } _mdns_restart_all_pcbs_no_instance(); } else { char * new_host = _mdns_mangle_name((char *)_mdns_server->hostname); if (new_host) { _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); free((char *)_mdns_server->hostname); _mdns_server->hostname = new_host; _mdns_self_host.hostname = new_host; } _mdns_restart_all_pcbs(); } } else if (service) { _mdns_pcb_send_bye(packet->tcpip_if, packet->ip_protocol, &service, 1, false); _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, &service, 1, false); } } } else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions) { _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); } } } else if (type == MDNS_TYPE_TXT) { if (search_result) { mdns_txt_item_t * txt = NULL; uint8_t *txt_value_len = NULL; size_t txt_count = 0; mdns_result_t * result = NULL; if (search_result->type == MDNS_TYPE_PTR) { result = search_result->result; while (result) { if (packet->tcpip_if == result->tcpip_if && packet->ip_protocol == result->ip_protocol && result->instance_name && !strcmp(name->host, result->instance_name)) { break; } result = result->next; } if (!result) { result = _mdns_search_result_add_ptr(search_result, name->host, name->service, name->proto, packet->tcpip_if, packet->ip_protocol, ttl); if (!result) { continue;//error } } if (!result->txt) { _mdns_result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count); if (txt_count) { result->txt = txt; result->txt_count = txt_count; result->txt_value_len = txt_value_len; } } } else { _mdns_result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count); if (txt_count) { _mdns_search_result_add_txt(search_result, txt, txt_value_len, txt_count, packet->tcpip_if, packet->ip_protocol, ttl); } } } else if (ours) { if (parsed_packet->questions && !parsed_packet->probe) { _mdns_remove_parsed_question(parsed_packet, type, service); continue; } //detect collision (-1=won, 0=none, 1=lost) int col = 0; if (mdns_class > 1) { col = 1; } else if (!mdns_class) { col = -1; } else if (service) { // only detect txt collision if service existed col = _mdns_check_txt_collision(service->service, data_ptr, data_len); } if (col && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running && service) { do_not_reply = true; _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, &service, 1, true); } else if (ttl > 2250 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); } } } #if CONFIG_LWIP_IPV6 else if (type == MDNS_TYPE_AAAA) {//ipv6 esp_ip_addr_t ip6; ip6.type = ESP_IPADDR_TYPE_V6; memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE); if (search_result) { //check for more applicable searches (PTR & A/AAAA at the same time) while (search_result) { _mdns_search_result_add_ip(search_result, name->host, &ip6, packet->tcpip_if, packet->ip_protocol, ttl); search_result = _mdns_search_find_from(search_result->next, name, type, packet->tcpip_if, packet->ip_protocol); } } else if (ours) { if (parsed_packet->questions && !parsed_packet->probe) { _mdns_remove_parsed_question(parsed_packet, type, NULL); continue; } //detect collision (-1=won, 0=none, 1=lost) int col = 0; if (mdns_class > 1) { col = 1; } else if (!mdns_class) { col = -1; } else { col = _mdns_check_aaaa_collision(&(ip6.u_addr.ip6), packet->tcpip_if); } if (col == 2) { goto clear_rx_packet; } else if (col == 1) { do_not_reply = true; if (_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { if (col && (parsed_packet->probe || parsed_packet->authoritative)) { _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].failed_probes++; char * new_host = _mdns_mangle_name((char *)_mdns_server->hostname); if (new_host) { _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); free((char *)_mdns_server->hostname); _mdns_server->hostname = new_host; _mdns_self_host.hostname = new_host; } _mdns_restart_all_pcbs(); } } else { _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, NULL, 0, true); } } else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, NULL); } } } #endif else if (type == MDNS_TYPE_A) { esp_ip_addr_t ip; ip.type = ESP_IPADDR_TYPE_V4; memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4); if (search_result) { //check for more applicable searches (PTR & A/AAAA at the same time) while (search_result) { _mdns_search_result_add_ip(search_result, name->host, &ip, packet->tcpip_if, packet->ip_protocol, ttl); search_result = _mdns_search_find_from(search_result->next, name, type, packet->tcpip_if, packet->ip_protocol); } } else if (ours) { if (parsed_packet->questions && !parsed_packet->probe) { _mdns_remove_parsed_question(parsed_packet, type, NULL); continue; } //detect collision (-1=won, 0=none, 1=lost) int col = 0; if (mdns_class > 1) { col = 1; } else if (!mdns_class) { col = -1; } else { col = _mdns_check_a_collision(&(ip.u_addr.ip4), packet->tcpip_if); } if (col == 2) { goto clear_rx_packet; } else if (col == 1) { do_not_reply = true; if (_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { if (col && (parsed_packet->probe || parsed_packet->authoritative)) { _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].failed_probes++; char * new_host = _mdns_mangle_name((char *)_mdns_server->hostname); if (new_host) { _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); free((char *)_mdns_server->hostname); _mdns_server->hostname = new_host; _mdns_self_host.hostname = new_host; } _mdns_restart_all_pcbs(); } } else { _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, NULL, 0, true); } } else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, NULL); } } } } //end while if (parsed_packet->authoritative) { _mdns_search_finish_done(); } } if (!do_not_reply && _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].state > PCB_PROBE_3 && (parsed_packet->questions || parsed_packet->discovery)) { _mdns_create_answer_from_parsed_packet(parsed_packet); } clear_rx_packet: while (parsed_packet->questions) { mdns_parsed_question_t * question = parsed_packet->questions; parsed_packet->questions = parsed_packet->questions->next; if (question->host) { free(question->host); } if (question->service) { free(question->service); } if (question->proto) { free(question->proto); } if (question->domain) { free(question->domain); } free(question); } free(parsed_packet); } /** * @brief Enable mDNS interface */ 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_pcb_init(tcpip_if, ip_protocol)) { return; } } _mdns_restart_pcb(tcpip_if, ip_protocol); } /** * @brief Disable mDNS interface */ void _mdns_disable_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) { _mdns_clean_netif_ptr(tcpip_if); if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) { _mdns_clear_pcb_tx_queue_head(tcpip_if, ip_protocol); _mdns_pcb_deinit(tcpip_if, ip_protocol); mdns_if_t other_if = _mdns_get_other_if (tcpip_if); 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_enable_pcb(other_if, ip_protocol); } } _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state = PCB_OFF; } /** * @brief Dispatch interface changes based on system events */ static void _mdns_handle_system_event(esp_event_base_t event_base, int32_t event_id, esp_netif_t* interface) { if (!_mdns_server) { return; } esp_netif_dhcp_status_t dcst; if (event_base == WIFI_EVENT) { switch(event_id) { case WIFI_EVENT_STA_CONNECTED: if (!esp_netif_dhcpc_get_status(_mdns_get_esp_netif(MDNS_IF_STA), &dcst)) { if (dcst == ESP_NETIF_DHCP_STOPPED) { _mdns_enable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4); } } break; case WIFI_EVENT_STA_DISCONNECTED: _mdns_disable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V6); break; case WIFI_EVENT_AP_START: _mdns_enable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V4); break; case WIFI_EVENT_AP_STOP: _mdns_disable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V6); break; default: break; } } #if CONFIG_ETH_ENABLED else if (event_base == ETH_EVENT) { switch (event_id) { case ETHERNET_EVENT_CONNECTED: if (!esp_netif_dhcpc_get_status(_mdns_get_esp_netif(MDNS_IF_ETH), &dcst)) { if (dcst == ESP_NETIF_DHCP_STOPPED) { _mdns_enable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4); } } break; case ETHERNET_EVENT_DISCONNECTED: _mdns_disable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4); _mdns_disable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V6); break; default: break; } } #endif else if (event_base == IP_EVENT) { switch (event_id) { case IP_EVENT_STA_GOT_IP: _mdns_enable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4); _mdns_announce_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V6, NULL, 0, true); break; #if CONFIG_ETH_ENABLED case IP_EVENT_ETH_GOT_IP: _mdns_enable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4); break; #endif case IP_EVENT_GOT_IP6: { mdns_if_t mdns_if = _mdns_get_if_from_esp_netif(interface); if (mdns_if != MDNS_IF_MAX) { _mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6); _mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V4, NULL, 0, true); } } break; default: break; } } } /* * MDNS Search * */ /** * @brief Free search structure (except the results) */ static void _mdns_search_free(mdns_search_once_t * search) { free(search->instance); free(search->service); free(search->proto); vSemaphoreDelete(search->done_semaphore); free(search); } /** * @brief Allocate new search structure */ static mdns_search_once_t *_mdns_search_init(const char *name, const char *service, const char *proto, uint16_t type, bool unicast, uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier) { mdns_search_once_t * search = (mdns_search_once_t *)malloc(sizeof(mdns_search_once_t)); if (!search) { HOOK_MALLOC_FAILED; return NULL; } memset(search, 0, sizeof(mdns_search_once_t)); search->done_semaphore = xSemaphoreCreateBinary(); if (!search->done_semaphore) { free(search); return NULL; } if (!_str_null_or_empty(name)) { search->instance = strndup(name, MDNS_NAME_BUF_LEN-1); if (!search->instance) { _mdns_search_free(search); return NULL; } } if (!_str_null_or_empty(service)) { search->service = strndup(service, MDNS_NAME_BUF_LEN-1); if (!search->service) { _mdns_search_free(search); return NULL; } } if (!_str_null_or_empty(proto)) { search->proto = strndup(proto, MDNS_NAME_BUF_LEN-1); if (!search->proto) { _mdns_search_free(search); return NULL; } } search->type = type; search->unicast = unicast; search->timeout = timeout; search->num_results = 0; search->max_results = max_results; search->result = NULL; search->state = SEARCH_INIT; search->sent_at = 0; search->started_at = xTaskGetTickCount() * portTICK_PERIOD_MS; search->notifier = notifier; search->next = NULL; return search; } /** * @brief Mark search as finished and remove it from search chain */ static void _mdns_search_finish(mdns_search_once_t * search) { search->state = SEARCH_OFF; queueDetach(mdns_search_once_t, _mdns_server->search_once, search); if (search->notifier) { search->notifier(search); } xSemaphoreGive(search->done_semaphore); } /** * @brief Add new search to the search chain */ static void _mdns_search_add(mdns_search_once_t * search) { search->next = _mdns_server->search_once; _mdns_server->search_once = search; } /** * @brief Called from parser to finish any searches that have reached maximum results */ static void _mdns_search_finish_done(void) { mdns_search_once_t * search = _mdns_server->search_once; mdns_search_once_t * s = NULL; while (search) { s = search; search = search->next; if (s->max_results && s->num_results >= s->max_results) { _mdns_search_finish(s); } } } /** * @brief Create linked IP (copy) from parsed one */ 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)); if (!a) { HOOK_MALLOC_FAILED; return NULL; } memset(a, 0 , sizeof(mdns_ip_addr_t)); a->addr.type = ip->type; if (ip->type == ESP_IPADDR_TYPE_V6) { memcpy(a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16); } else { a->addr.u_addr.ip4.addr = ip->u_addr.ip4.addr; } return a; } static inline void _mdns_result_update_ttl(mdns_result_t * r, uint32_t ttl) { r->ttl = r->ttl < ttl ? r->ttl : ttl; } /** * @brief Chain new IP to search result */ static void _mdns_result_add_ip(mdns_result_t * r, esp_ip_addr_t * ip) { mdns_ip_addr_t * a = r->addr; while (a) { if (a->addr.type == ip->type) { if (a->addr.type == ESP_IPADDR_TYPE_V4 && a->addr.u_addr.ip4.addr == ip->u_addr.ip4.addr) { return; } if (a->addr.type == ESP_IPADDR_TYPE_V6 && !memcmp(a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16)) { return; } } a = a->next; } a = _mdns_result_addr_create_ip(ip); if (!a) { return; } a->next = r->addr; r->addr = a; } /** * @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, esp_ip_addr_t * ip, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl) { mdns_result_t * r = NULL; mdns_ip_addr_t * a = NULL; if ((search->type == MDNS_TYPE_A && ip->type == ESP_IPADDR_TYPE_V4) || (search->type == MDNS_TYPE_AAAA && ip->type == ESP_IPADDR_TYPE_V6) || search->type == MDNS_TYPE_ANY) { r = search->result; while (r) { if (r->tcpip_if == tcpip_if && r->ip_protocol == ip_protocol) { _mdns_result_add_ip(r, ip); _mdns_result_update_ttl(r, ttl); return; } r = r->next; } if (!search->max_results || search->num_results < search->max_results) { r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; return; } memset(r, 0 , sizeof(mdns_result_t)); a = _mdns_result_addr_create_ip(ip); if (!a) { free(r); return; } a->next = r->addr; r->hostname = strdup(hostname); r->addr = a; r->tcpip_if = tcpip_if; r->ip_protocol = ip_protocol; r->next = search->result; r->ttl = ttl; search->result = r; search->num_results++; } } else if (search->type == MDNS_TYPE_PTR || search->type == MDNS_TYPE_SRV) { r = search->result; while (r) { if (r->tcpip_if == tcpip_if && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) { _mdns_result_add_ip(r, ip); _mdns_result_update_ttl(r, ttl); break; } r = r->next; } } } /** * @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, const char * service_type, const char * proto, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl) { mdns_result_t * r = search->result; while (r) { if (r->tcpip_if == tcpip_if && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name)) { _mdns_result_update_ttl(r, ttl); return r; } r = r->next; } if (!search->max_results || search->num_results < search->max_results) { r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; return NULL; } memset(r, 0 , sizeof(mdns_result_t)); r->instance_name = strdup(instance); r->service_type = strdup(service_type); r->proto = strdup(proto); if (!r->instance_name) { free(r); return NULL; } r->tcpip_if = tcpip_if; r->ip_protocol = ip_protocol; r->ttl = ttl; r->next = search->result; search->result = r; search->num_results++; return r; } return NULL; } /** * @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, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl) { mdns_result_t * r = search->result; while (r) { if (r->tcpip_if == tcpip_if && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) { _mdns_result_update_ttl(r, ttl); return; } r = r->next; } if (!search->max_results || search->num_results < search->max_results) { r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; return; } memset(r, 0 , sizeof(mdns_result_t)); r->hostname = strdup(hostname); if (!r->hostname) { free(r); return; } if (search->instance) { r->instance_name = strdup(search->instance); } r->service_type = strdup(search->service); r->proto = strdup(search->proto); r->port = port; r->tcpip_if = tcpip_if; r->ip_protocol = ip_protocol; r->ttl = ttl; r->next = search->result; search->result = r; search->num_results++; } } /** * @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, uint8_t *txt_value_len, size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl) { mdns_result_t * r = search->result; while (r) { if (r->tcpip_if == tcpip_if && r->ip_protocol == ip_protocol) { if (r->txt) { goto free_txt; } r->txt = txt; r->txt_value_len = txt_value_len; r->txt_count = txt_count; _mdns_result_update_ttl(r, ttl); return; } r = r->next; } if (!search->max_results || search->num_results < search->max_results) { r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; goto free_txt; } memset(r, 0 , sizeof(mdns_result_t)); r->txt = txt; r->txt_value_len = txt_value_len; r->txt_count = txt_count; r->tcpip_if = tcpip_if; r->ip_protocol = ip_protocol; r->ttl = ttl; r->next = search->result; search->result = r; search->num_results++; } return; free_txt: for (size_t i=0; istate == SEARCH_OFF) { s = s->next; continue; } if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) { if ((s->type == MDNS_TYPE_ANY && s->service != NULL) || (s->type != MDNS_TYPE_ANY && s->type != type && s->type != MDNS_TYPE_PTR && s->type != MDNS_TYPE_SRV)) { s = s->next; continue; } if (s->type != MDNS_TYPE_PTR && s->type != MDNS_TYPE_SRV) { if (!strcasecmp(name->host, s->instance)) { return s; } s = s->next; continue; } r = s->result; while (r) { if (r->tcpip_if == tcpip_if && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(name->host, r->hostname)) { return s; } r = r->next; } s = s->next; continue; } if (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT) { if ((s->type == MDNS_TYPE_ANY && s->service == NULL) || (s->type != MDNS_TYPE_ANY && s->type != type && s->type != MDNS_TYPE_PTR)) { s = s->next; continue; } if (strcasecmp(name->service, s->service) || strcasecmp(name->proto, s->proto)) { s = s->next; continue; } if (s->type != MDNS_TYPE_PTR) { if (s->instance && strcasecmp(name->host, s->instance) == 0) { return s; } s = s->next; continue; } return s; } if (type == MDNS_TYPE_PTR && type == s->type && !strcasecmp(name->service, s->service) && !strcasecmp(name->proto, s->proto)) { return s; } s = s->next; } return NULL; } /** * @brief Create search packet for particular interface */ 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_tx_packet_t * packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); if (!packet) { return NULL; } mdns_out_question_t * q = (mdns_out_question_t *)malloc(sizeof(mdns_out_question_t)); if (!q) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); return NULL; } q->next = NULL; q->unicast = search->unicast; q->type = search->type; q->host = search->instance; q->service = search->service; q->proto = search->proto; q->domain = MDNS_DEFAULT_DOMAIN; q->own_dynamic_memory = false; queueToEnd(mdns_out_question_t, packet->questions, q); if (search->type == MDNS_TYPE_PTR) { r = search->result; while (r) { //full record on the same interface is available if (r->tcpip_if != tcpip_if || r->ip_protocol != ip_protocol || r->instance_name == NULL || r->hostname == NULL || r->addr == NULL) { r = r->next; continue; } mdns_out_answer_t * a = (mdns_out_answer_t *)malloc(sizeof(mdns_out_answer_t)); if (!a) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); return NULL; } a->type = MDNS_TYPE_PTR; a->service = NULL; a->custom_instance = r->instance_name; a->custom_service = search->service; a->custom_proto = search->proto; a->bye = false; a->flush = false; a->next = NULL; queueToEnd(mdns_out_answer_t, packet->answers, a); r = r->next; } } return packet; } /** * @brief Send search packet to particular interface */ 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; if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb && _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state > PCB_INIT) { packet = _mdns_create_search_packet(search, tcpip_if, ip_protocol); if (!packet) { return; } _mdns_dispatch_tx_packet(packet); _mdns_free_tx_packet(packet); } } /** * @brief Send search packet to all available interfaces */ static void _mdns_search_send(mdns_search_once_t * search) { mdns_search_once_t* queue = _mdns_server->search_once; bool found = false; // looking for this search in active searches while (queue) { if (queue == search) { found = true; break; } queue = queue->next; } if (!found) { // no longer active -> skip sending this search return; } uint8_t i, j; for (i=0; iinterfaces[p->tcpip_if].pcbs[p->ip_protocol]; uint32_t send_after = 1000; if (pcb->state == PCB_OFF) { _mdns_free_tx_packet(p); return; } _mdns_dispatch_tx_packet(p); switch(pcb->state) { case PCB_PROBE_1: q = p->questions; while (q) { q->unicast = false; q = q->next; } //fallthrough case PCB_PROBE_2: _mdns_schedule_tx_packet(p, 250); pcb->state = (mdns_pcb_state_t)((uint8_t)(pcb->state) + 1); break; case PCB_PROBE_3: a = _mdns_create_announce_from_probe(p); if (!a) { _mdns_schedule_tx_packet(p, 250); break; } pcb->probe_running = false; pcb->probe_ip = false; pcb->probe_services_len = 0; pcb->failed_probes = 0; free(pcb->probe_services); pcb->probe_services = NULL; _mdns_free_tx_packet(p); p = a; send_after = 250; //fallthrough case PCB_ANNOUNCE_1: //fallthrough case PCB_ANNOUNCE_2: _mdns_schedule_tx_packet(p, send_after); pcb->state = (mdns_pcb_state_t)((uint8_t)(pcb->state) + 1); break; case PCB_ANNOUNCE_3: pcb->state = PCB_RUNNING; _mdns_free_tx_packet(p); break; default: _mdns_free_tx_packet(p); break; } } static void _mdns_remap_self_service_hostname(const char * old_hostname, const char * new_hostname) { mdns_srv_item_t * service = _mdns_server->services; while (service) { if (strcmp(service->service->hostname, old_hostname) == 0) { free((char *)service->service->hostname); service->service->hostname = strdup(new_hostname); } service = service->next; } } /** * @brief Free action data */ static void _mdns_free_action(mdns_action_t * action) { switch(action->type) { case ACTION_HOSTNAME_SET: free(action->data.hostname_set.hostname); break; case ACTION_INSTANCE_SET: free(action->data.instance); break; case ACTION_SERVICE_ADD: _mdns_free_service(action->data.srv_add.service->service); free(action->data.srv_add.service); break; case ACTION_SERVICE_INSTANCE_SET: free(action->data.srv_instance.instance); break; case ACTION_SERVICE_TXT_REPLACE: _mdns_free_linked_txt(action->data.srv_txt_replace.txt); break; case ACTION_SERVICE_TXT_SET: free(action->data.srv_txt_set.key); free(action->data.srv_txt_set.value); break; case ACTION_SERVICE_TXT_DEL: free(action->data.srv_txt_del.key); break; case ACTION_SERVICE_SUBTYPE_ADD: free(action->data.srv_subtype_add.subtype); break; case ACTION_SEARCH_ADD: //fallthrough case ACTION_SEARCH_SEND: //fallthrough case ACTION_SEARCH_END: _mdns_search_free(action->data.search_add.search); break; case ACTION_TX_HANDLE: _mdns_free_tx_packet(action->data.tx_handle.packet); break; case ACTION_RX_HANDLE: _mdns_packet_free(action->data.rx_handle.packet); break; case ACTION_DELEGATE_HOSTNAME_ADD: free((char *)action->data.delegate_hostname.hostname); free_address_list(action->data.delegate_hostname.address_list); break; case ACTION_DELEGATE_HOSTNAME_REMOVE: free((char *)action->data.delegate_hostname.hostname); break; default: break; } free(action); } /** * @brief Called from service thread to execute given action */ static void _mdns_execute_action(mdns_action_t * action) { mdns_srv_item_t * a = NULL; mdns_service_t * service; char * key; char * value; char *subtype; mdns_subtype_t *subtype_item; mdns_txt_linked_item_t * txt, * t; switch(action->type) { case ACTION_SYSTEM_EVENT: _mdns_handle_system_event(action->data.sys_event.event_base, action->data.sys_event.event_id, action->data.sys_event.interface); break; case ACTION_HOSTNAME_SET: _mdns_send_bye_all_pcbs_no_instance(true); _mdns_remap_self_service_hostname(_mdns_server->hostname, action->data.hostname_set.hostname); free((char*)_mdns_server->hostname); _mdns_server->hostname = action->data.hostname_set.hostname; _mdns_self_host.hostname = action->data.hostname_set.hostname; _mdns_restart_all_pcbs(); xTaskNotifyGive(action->data.hostname_set.calling_task); break; case ACTION_INSTANCE_SET: _mdns_send_bye_all_pcbs_no_instance(false); free((char*)_mdns_server->instance); _mdns_server->instance = action->data.instance; _mdns_restart_all_pcbs_no_instance(); break; case ACTION_SERVICE_ADD: action->data.srv_add.service->next = _mdns_server->services; _mdns_server->services = action->data.srv_add.service; _mdns_probe_all_pcbs(&action->data.srv_add.service, 1, false, false); break; case ACTION_SERVICE_INSTANCE_SET: if (action->data.srv_instance.service->service->instance) { _mdns_send_bye(&action->data.srv_instance.service, 1, false); free((char*)action->data.srv_instance.service->service->instance); } action->data.srv_instance.service->service->instance = action->data.srv_instance.instance; _mdns_probe_all_pcbs(&action->data.srv_instance.service, 1, false, false); break; case ACTION_SERVICE_PORT_SET: action->data.srv_port.service->service->port = action->data.srv_port.port; _mdns_announce_all_pcbs(&action->data.srv_port.service, 1, true); break; case ACTION_SERVICE_TXT_REPLACE: service = action->data.srv_txt_replace.service->service; txt = service->txt; service->txt = NULL; _mdns_free_linked_txt(txt); service->txt = action->data.srv_txt_replace.txt; _mdns_announce_all_pcbs(&action->data.srv_txt_replace.service, 1, false); break; case ACTION_SERVICE_TXT_SET: service = action->data.srv_txt_set.service->service; key = action->data.srv_txt_set.key; value = action->data.srv_txt_set.value; txt = service->txt; while (txt) { if (strcmp(txt->key, key) == 0) { free((char *)txt->value); free(key); txt->value = value; txt->value_len = action->data.srv_txt_set.value_len; break; } txt = txt->next; } if (!txt) { txt = (mdns_txt_linked_item_t *)malloc(sizeof(mdns_txt_linked_item_t)); if (!txt) { HOOK_MALLOC_FAILED; _mdns_free_action(action); return; } txt->key = key; txt->value = value; txt->value_len = action->data.srv_txt_set.value_len; txt->next = service->txt; service->txt = txt; } _mdns_announce_all_pcbs(&action->data.srv_txt_set.service, 1, false); break; case ACTION_SERVICE_TXT_DEL: service = action->data.srv_txt_del.service->service; key = action->data.srv_txt_del.key; txt = service->txt; if (!txt) { break; } if (strcmp(txt->key, key) == 0) { service->txt = txt->next; free((char *)txt->key); free((char *)txt->value); free(txt); } else { while (txt->next) { if (strcmp(txt->next->key, key) == 0) { t = txt->next; txt->next = t->next; free((char *)t->key); free((char *)t->value); free(t); break; } else { txt = txt->next; } } } free(key); _mdns_announce_all_pcbs(&action->data.srv_txt_set.service, 1, false); break; case ACTION_SERVICE_SUBTYPE_ADD: service = action->data.srv_subtype_add.service->service; subtype = action->data.srv_subtype_add.subtype; subtype_item = (mdns_subtype_t *)malloc(sizeof(mdns_subtype_t)); if (!subtype_item) { HOOK_MALLOC_FAILED; _mdns_free_action(action); return; } subtype_item->subtype = subtype; subtype_item->next = service->subtype; service->subtype = subtype_item; break; case ACTION_SERVICE_DEL: a = _mdns_server->services; if (action->data.srv_del.service) { if (_mdns_server->services == action->data.srv_del.service) { _mdns_server->services = a->next; _mdns_send_bye(&a, 1, false); _mdns_remove_scheduled_service_packets(a->service); _mdns_free_service(a->service); free(a); } else { while (a->next && a->next != action->data.srv_del.service) { a = a->next; } if (a->next == action->data.srv_del.service) { mdns_srv_item_t * b = a->next; a->next = a->next->next; _mdns_send_bye(&b, 1, false); _mdns_remove_scheduled_service_packets(b->service); _mdns_free_service(b->service); free(b); } } } break; case ACTION_SERVICES_CLEAR: _mdns_send_final_bye(false); a = _mdns_server->services; _mdns_server->services = NULL; while (a) { mdns_srv_item_t * s = a; a = a->next; _mdns_remove_scheduled_service_packets(s->service); _mdns_free_service(s->service); free(s); } break; case ACTION_SEARCH_ADD: _mdns_search_add(action->data.search_add.search); break; case ACTION_SEARCH_SEND: _mdns_search_send(action->data.search_add.search); break; case ACTION_SEARCH_END: _mdns_search_finish(action->data.search_add.search); break; case ACTION_TX_HANDLE: { mdns_tx_packet_t * p = _mdns_server->tx_queue_head; // packet to be handled should be at tx head, but must be consistent with the one pushed to action queue if (p && p==action->data.tx_handle.packet && p->queued) { p->queued = false; // clearing, as the packet might be reused (pushed and transmitted again) _mdns_server->tx_queue_head = p->next; _mdns_tx_handle_packet(p); } else { ESP_LOGD(TAG, "Skipping transmit of an unexpected packet!"); } } break; case ACTION_RX_HANDLE: mdns_parse_packet(action->data.rx_handle.packet); _mdns_packet_free(action->data.rx_handle.packet); break; case ACTION_DELEGATE_HOSTNAME_ADD: _mdns_delegate_hostname_add(action->data.delegate_hostname.hostname, action->data.delegate_hostname.address_list); break; case ACTION_DELEGATE_HOSTNAME_REMOVE: _mdns_delegate_hostname_remove(action->data.delegate_hostname.hostname); free((char *)action->data.delegate_hostname.hostname); break; default: break; } free(action); } /** * @brief Queue search action */ static esp_err_t _mdns_send_search_action(mdns_action_type_t type, mdns_search_once_t * search) { mdns_action_t * action = NULL; action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = type; action->data.search_add.search = search; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } /** * @brief Called from timer task to run mDNS responder * * periodically checks first unqueued packet (from tx head). * if it is scheduled to be transmitted, then pushes the packet to action queue to be handled. * */ static void _mdns_scheduler_run(void) { MDNS_SERVICE_LOCK(); mdns_tx_packet_t * p = _mdns_server->tx_queue_head; mdns_action_t * action = NULL; // find first unqueued packet while (p && p->queued) { p = p->next; } if (!p) { MDNS_SERVICE_UNLOCK(); return; } if ((int32_t)(p->send_at - (xTaskGetTickCount() * portTICK_PERIOD_MS)) < 0) { action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (action) { action->type = ACTION_TX_HANDLE; action->data.tx_handle.packet = p; p->queued = true; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); p->queued = false; } } else { HOOK_MALLOC_FAILED; // continue } } MDNS_SERVICE_UNLOCK(); } /** * @brief Called from timer task to run active searches */ static void _mdns_search_run(void) { MDNS_SERVICE_LOCK(); mdns_search_once_t * s = _mdns_server->search_once; uint32_t now = xTaskGetTickCount() * portTICK_PERIOD_MS; if (!s) { MDNS_SERVICE_UNLOCK(); return; } while (s) { if (s->state != SEARCH_OFF) { if (now > (s->started_at + s->timeout)) { s->state = SEARCH_OFF; if (_mdns_send_search_action(ACTION_SEARCH_END, s) != ESP_OK) { s->state = SEARCH_RUNNING; } } else if (s->state == SEARCH_INIT || (now - s->sent_at) > 1000) { s->state = SEARCH_RUNNING; s->sent_at = now; if (_mdns_send_search_action(ACTION_SEARCH_SEND, s) != ESP_OK) { s->sent_at -= 1000; } } } s = s->next; } MDNS_SERVICE_UNLOCK(); } /** * @brief the main MDNS service task. Packets are received and parsed here */ static void _mdns_service_task(void *pvParameters) { mdns_action_t * a = NULL; for (;;) { if (_mdns_server && _mdns_server->action_queue) { if (xQueueReceive(_mdns_server->action_queue, &a, portMAX_DELAY) == pdTRUE) { if (a->type == ACTION_TASK_STOP) { break; } MDNS_SERVICE_LOCK(); _mdns_execute_action(a); MDNS_SERVICE_UNLOCK(); } } else { vTaskDelay(500 * portTICK_PERIOD_MS); } } _mdns_service_task_handle = NULL; vTaskDelete(NULL); } static void _mdns_timer_cb(void * arg) { _mdns_scheduler_run(); _mdns_search_run(); } static esp_err_t _mdns_start_timer(void){ esp_timer_create_args_t timer_conf = { .callback = _mdns_timer_cb, .arg = NULL, .dispatch_method = ESP_TIMER_TASK, .name = "mdns_timer" }; esp_err_t err = esp_timer_create(&timer_conf, &(_mdns_server->timer_handle)); if (err) { return err; } return esp_timer_start_periodic(_mdns_server->timer_handle, MDNS_TIMER_PERIOD_US); } static esp_err_t _mdns_stop_timer(void){ esp_err_t err = ESP_OK; if (_mdns_server->timer_handle) { err = esp_timer_stop(_mdns_server->timer_handle); if (err) { return err; } err = esp_timer_delete(_mdns_server->timer_handle); } return err; } /** * @brief Start the service thread if not running * * @return * - ESP_OK on success * - ESP_FAIL on error */ static esp_err_t _mdns_service_task_start(void) { if (!_mdns_service_semaphore) { _mdns_service_semaphore = xSemaphoreCreateMutex(); if (!_mdns_service_semaphore) { return ESP_FAIL; } } MDNS_SERVICE_LOCK(); if (_mdns_start_timer()) { MDNS_SERVICE_UNLOCK(); return ESP_FAIL; } if (!_mdns_service_task_handle) { xTaskCreatePinnedToCore(_mdns_service_task, "mdns", MDNS_SERVICE_STACK_DEPTH, NULL, MDNS_TASK_PRIORITY, (TaskHandle_t * const)(&_mdns_service_task_handle), MDNS_TASK_AFFINITY); if (!_mdns_service_task_handle) { _mdns_stop_timer(); MDNS_SERVICE_UNLOCK(); vSemaphoreDelete(_mdns_service_semaphore); _mdns_service_semaphore = NULL; return ESP_FAIL; } } MDNS_SERVICE_UNLOCK(); return ESP_OK; } /** * @brief Stop the service thread * * @return * - ESP_OK */ static esp_err_t _mdns_service_task_stop(void) { _mdns_stop_timer(); if (_mdns_service_task_handle) { mdns_action_t action; mdns_action_t * a = &action; action.type = ACTION_TASK_STOP; if (xQueueSend(_mdns_server->action_queue, &a, (portTickType)0) != pdPASS) { vTaskDelete(_mdns_service_task_handle); _mdns_service_task_handle = NULL; } while (_mdns_service_task_handle) { vTaskDelay(10 / portTICK_PERIOD_MS); } } vSemaphoreDelete(_mdns_service_semaphore); _mdns_service_semaphore = NULL; return ESP_OK; } /* * Public Methods * */ esp_err_t mdns_handle_system_event(void *ctx, system_event_t *event) { /* no-op, kept for compatibility */ return ESP_OK; } static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) { if (!_mdns_server) { return; } mdns_action_t * action = (mdns_action_t *)calloc(1, sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return; } action->type = ACTION_SYSTEM_EVENT; action->data.sys_event.event_base = event_base; action->data.sys_event.event_id = event_id; if (event_base == IP_EVENT && event_id == IP_EVENT_GOT_IP6) { ip_event_got_ip6_t* event = (ip_event_got_ip6_t*) event_data; action->data.sys_event.interface = event->esp_netif; } if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); } } esp_err_t mdns_init(void) { esp_err_t err = ESP_OK; if (_mdns_server) { return err; } _mdns_server = (mdns_server_t *)malloc(sizeof(mdns_server_t)); if (!_mdns_server) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } memset((uint8_t*)_mdns_server, 0, sizeof(mdns_server_t)); // zero-out local copy of netifs to initiate a fresh search by interface key whenever a netif ptr is needed memset(s_esp_netifs, 0, sizeof(s_esp_netifs)); _mdns_server->lock = xSemaphoreCreateMutex(); if (!_mdns_server->lock) { err = ESP_ERR_NO_MEM; goto free_server; } _mdns_server->action_queue = xQueueCreate(MDNS_ACTION_QUEUE_LEN, sizeof(mdns_action_t *)); if (!_mdns_server->action_queue) { err = ESP_ERR_NO_MEM; goto free_lock; } if ((err = esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL)) != ESP_OK) { goto free_event_handlers; } if ((err = esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL)) != ESP_OK) { goto free_event_handlers; } #if CONFIG_ETH_ENABLED if ((err = esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL)) != ESP_OK) { goto free_event_handlers; } #endif uint8_t i; #if CONFIG_LWIP_IPV6 esp_ip6_addr_t tmp_addr6; #endif esp_netif_ip_info_t if_ip_info; for (i=0; iaction_queue); free_lock: vSemaphoreDelete(_mdns_server->lock); free_server: free(_mdns_server); _mdns_server = NULL; return err; } void mdns_free(void) { uint8_t i, j; if (!_mdns_server) { return; } // Unregister handlers before destroying the mdns internals to avoid receiving async events while deinit esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler); esp_event_handler_unregister(IP_EVENT, ESP_EVENT_ANY_ID, &event_handler); #if CONFIG_ETH_ENABLED esp_event_handler_unregister(ETH_EVENT, ESP_EVENT_ANY_ID, &event_handler); #endif mdns_service_remove_all(); _mdns_service_task_stop(); for (i=0; ihostname); free((char*)_mdns_server->instance); if (_mdns_server->action_queue) { mdns_action_t * c; while (xQueueReceive(_mdns_server->action_queue, &c, 0) == pdTRUE) { _mdns_free_action(c); } vQueueDelete(_mdns_server->action_queue); } _mdns_clear_tx_queue_head(); while (_mdns_server->search_once) { mdns_search_once_t * h = _mdns_server->search_once; _mdns_server->search_once = h->next; free(h->instance); free(h->service); free(h->proto); vSemaphoreDelete(h->done_semaphore); if (h->result) { mdns_query_results_free(h->result); } free(h); } vSemaphoreDelete(_mdns_server->lock); free(_mdns_server); _mdns_server = NULL; } esp_err_t mdns_hostname_set(const char * hostname) { if (!_mdns_server) { return ESP_ERR_INVALID_ARG; } if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } char * new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_HOSTNAME_SET; action->data.hostname_set.hostname = new_hostname; action->data.hostname_set.calling_task = xTaskGetCurrentTaskHandle(); if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(new_hostname); free(action); return ESP_ERR_NO_MEM; } xTaskNotifyWait(0, 0, NULL, portMAX_DELAY); return ESP_OK; } esp_err_t mdns_delegate_hostname_add(const char * hostname, const mdns_ip_addr_t * address_list) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1) || address_list == NULL) { return ESP_ERR_INVALID_ARG; } char * new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_DELEGATE_HOSTNAME_ADD; action->data.delegate_hostname.hostname = new_hostname; action->data.delegate_hostname.address_list = copy_address_list(address_list); if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(new_hostname); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_delegate_hostname_remove(const char * hostname) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } char * new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_DELEGATE_HOSTNAME_REMOVE; action->data.delegate_hostname.hostname = new_hostname; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(new_hostname); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } bool mdns_hostname_exists(const char * hostname) { return _hostname_is_ours(hostname); } esp_err_t mdns_instance_name_set(const char * instance) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } if (_str_null_or_empty(instance) || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } char * new_instance = strndup(instance, MDNS_NAME_BUF_LEN - 1); if (!new_instance) { return ESP_ERR_NO_MEM; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; free(new_instance); return ESP_ERR_NO_MEM; } action->type = ACTION_INSTANCE_SET; action->data.instance = new_instance; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(new_instance); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } /* * MDNS SERVICES * */ esp_err_t mdns_service_add_for_host(const char * instance, const char * service, const char * proto, const char * hostname, uint16_t port, mdns_txt_item_t txt[], size_t num_items) { if (!_mdns_server || _str_null_or_empty(service) || _str_null_or_empty(proto) || !port) { return ESP_ERR_INVALID_ARG; } if (!_mdns_can_add_more_services()) { return ESP_ERR_NO_MEM; } mdns_srv_item_t * item = _mdns_get_service_item_instance(instance, service, proto, hostname); if (item) { return ESP_ERR_INVALID_ARG; } mdns_service_t * s = _mdns_create_service(service, proto, hostname, port, instance, num_items, txt); if (!s) { return ESP_ERR_NO_MEM; } item = (mdns_srv_item_t *)malloc(sizeof(mdns_srv_item_t)); if (!item) { HOOK_MALLOC_FAILED; _mdns_free_service(s); return ESP_ERR_NO_MEM; } item->service = s; item->next = NULL; mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; _mdns_free_service(s); free(item); return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_ADD; action->data.srv_add.service = item; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { _mdns_free_service(s); free(item); free(action); return ESP_ERR_NO_MEM; } size_t start = xTaskGetTickCount(); size_t timeout_ticks = pdMS_TO_TICKS(MDNS_SERVICE_ADD_TIMEOUT_MS); while (_mdns_get_service_item_instance(instance, service, proto, hostname) == NULL) { uint32_t expired = xTaskGetTickCount() - start; if (expired >= timeout_ticks) { return ESP_FAIL; // Timeout } vTaskDelay(MIN(10 / portTICK_RATE_MS, timeout_ticks - expired)); } return ESP_OK; } esp_err_t mdns_service_add(const char * instance, const char * service, const char * proto, uint16_t port, mdns_txt_item_t txt[], size_t num_items) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_add_for_host(instance, service, proto, _mdns_server->hostname, port, txt, num_items); } bool mdns_service_exists(const char * service_type, const char * proto, const char * hostname) { return _mdns_get_service_item(service_type, proto, hostname) != NULL; } bool mdns_service_exists_with_instance(const char *instance, const char *service_type, const char *proto, const char *hostname) { return _mdns_get_service_item_instance(instance, service_type, proto, hostname) != NULL; } esp_err_t mdns_service_port_set_for_host(const char *instance, const char * service, const char * proto, const char * hostname, uint16_t port) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || !port) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t * s = _mdns_get_service_item_instance(instance, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_PORT_SET; action->data.srv_port.service = s; action->data.srv_port.port = port; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_port_set(const char * service, const char * proto, uint16_t port) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_port_set_for_host(NULL, service, proto, _mdns_server->hostname, port); } esp_err_t mdns_service_txt_set_for_host(const char * instance, const char * service, const char * proto, const char * hostname, mdns_txt_item_t txt[], uint8_t num_items) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || (num_items && txt == NULL)) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t * s = _mdns_get_service_item_instance(instance, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } mdns_txt_linked_item_t * new_txt = NULL; if (num_items){ new_txt = _mdns_allocate_txt(num_items, txt); if (!new_txt) { return ESP_ERR_NO_MEM; } } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; _mdns_free_linked_txt(new_txt); return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_TXT_REPLACE; action->data.srv_txt_replace.service = s; action->data.srv_txt_replace.txt = new_txt; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { _mdns_free_linked_txt(new_txt); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_txt_set(const char * service, const char * proto, mdns_txt_item_t txt[], uint8_t num_items) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_txt_set_for_host(NULL, service, proto, _mdns_server->hostname, txt, num_items); } esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char * instance, const char *service, const char *proto, const char *hostname, const char *key, const char *value, uint8_t value_len) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || _str_null_or_empty(key) || (!value && value_len)) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_TXT_SET; action->data.srv_txt_set.service = s; action->data.srv_txt_set.key = strdup(key); if (!action->data.srv_txt_set.key) { free(action); return ESP_ERR_NO_MEM; } if (value_len > 0) { action->data.srv_txt_set.value = (char *)malloc(value_len); if (!action->data.srv_txt_set.value) { free(action->data.srv_txt_set.key); free(action); return ESP_ERR_NO_MEM; } memcpy(action->data.srv_txt_set.value, value, value_len); action->data.srv_txt_set.value_len = value_len; } else { action->data.srv_txt_set.value = NULL; action->data.srv_txt_set.value_len = 0; } if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action->data.srv_txt_set.key); free(action->data.srv_txt_set.value); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_txt_item_set_for_host(const char * instance, const char *service, const char *proto, const char *hostname, const char *key, const char *value) { return mdns_service_txt_item_set_for_host_with_explicit_value_len(instance, service, proto, hostname, key, value, strlen(value)); } esp_err_t mdns_service_txt_item_set(const char *service, const char *proto, const char *key, const char *value) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_txt_item_set_for_host_with_explicit_value_len(NULL, service, proto, _mdns_server->hostname, key, value, strlen(value)); } esp_err_t mdns_service_txt_item_set_with_explicit_value_len(const char *service, const char *proto, const char *key, const char *value, uint8_t value_len) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_txt_item_set_for_host_with_explicit_value_len(NULL, service, proto, _mdns_server->hostname, key, value, value_len); } esp_err_t mdns_service_txt_item_remove_for_host(const char * instance, const char * service, const char * proto, const char * hostname, const char * key) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || _str_null_or_empty(key)) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t * s = _mdns_get_service_item_instance(instance, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_TXT_DEL; action->data.srv_txt_del.service = s; action->data.srv_txt_del.key = strdup(key); if (!action->data.srv_txt_del.key) { free(action); return ESP_ERR_NO_MEM; } if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action->data.srv_txt_del.key); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_txt_item_remove(const char * service, const char * proto, const char * key) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_txt_item_remove_for_host(NULL, service, proto, _mdns_server->hostname, key); } esp_err_t mdns_service_subtype_add_for_host(const char *instance_name, const char *service, const char *proto, const char *hostname, const char *subtype) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || _str_null_or_empty(subtype)) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t * s = _mdns_get_service_item_instance(instance_name, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_SUBTYPE_ADD; action->data.srv_subtype_add.service = s; action->data.srv_subtype_add.subtype = strdup(subtype); if (!action->data.srv_subtype_add.subtype) { free(action); return ESP_ERR_NO_MEM; } if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action->data.srv_subtype_add.subtype); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_instance_name_set_for_host(const char * instance_old, const char * service, const char * proto, const char * hostname, const char * instance) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto)) { return ESP_ERR_INVALID_ARG; } if (_str_null_or_empty(instance) || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t * s = _mdns_get_service_item_instance(instance_old, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } char * new_instance = strndup(instance, MDNS_NAME_BUF_LEN - 1); if (!new_instance) { return ESP_ERR_NO_MEM; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; free(new_instance); return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_INSTANCE_SET; action->data.srv_instance.service = s; action->data.srv_instance.instance = new_instance; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(new_instance); free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_instance_name_set(const char * service, const char * proto, const char * instance) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_instance_name_set_for_host(NULL, service, proto, _mdns_server->hostname, instance); } esp_err_t mdns_service_remove_for_host(const char * instance, const char * service, const char * proto, const char * hostname) { if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto)) { return ESP_ERR_INVALID_ARG; } mdns_srv_item_t * s = _mdns_get_service_item_instance(instance, service, proto, hostname); if (!s) { return ESP_ERR_NOT_FOUND; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICE_DEL; action->data.srv_del.service = s; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } esp_err_t mdns_service_remove(const char * service_type, const char * proto) { if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } return mdns_service_remove_for_host(NULL, service_type, proto, _mdns_server->hostname); } esp_err_t mdns_service_remove_all(void) { if (!_mdns_server) { return ESP_ERR_INVALID_ARG; } if (!_mdns_server->services) { return ESP_OK; } mdns_action_t * action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; } action->type = ACTION_SERVICES_CLEAR; if (xQueueSend(_mdns_server->action_queue, &action, (portTickType)0) != pdPASS) { free(action); return ESP_ERR_NO_MEM; } return ESP_OK; } /* * MDNS QUERY * */ void mdns_query_results_free(mdns_result_t * results) { mdns_result_t * r; mdns_ip_addr_t * a; while (results) { r = results; free((char *)(r->hostname)); free((char *)(r->instance_name)); free((char *)(r->service_type)); free((char *)(r->proto)); for (size_t i=0; itxt_count; i++) { free((char *)(r->txt[i].key)); free((char *)(r->txt[i].value)); } free(r->txt); free(r->txt_value_len); while (r->addr) { a = r->addr; r->addr = r->addr->next; free(a); } results = results->next; free(r); } } esp_err_t mdns_query_async_delete(mdns_search_once_t* search) { if (!search) { return ESP_ERR_INVALID_ARG; } if (search->state != SEARCH_OFF) { return ESP_ERR_INVALID_STATE; } MDNS_SERVICE_LOCK(); _mdns_search_free(search); MDNS_SERVICE_UNLOCK(); return ESP_OK; } bool mdns_query_async_get_results(mdns_search_once_t* search, uint32_t timeout, mdns_result_t ** results, uint8_t * num_results) { if (xSemaphoreTake(search->done_semaphore, pdMS_TO_TICKS(timeout)) == pdTRUE) { if (results) { *results = search->result; } if (num_results) { *num_results = search->num_results; } return true; } return false; } mdns_search_once_t *mdns_query_async_new(const char *name, const char *service, const char *proto, uint16_t type, uint32_t timeout, size_t max_results, mdns_query_notify_t notifier) { mdns_search_once_t *search = NULL; if (!_mdns_server || !timeout || _str_null_or_empty(service) != _str_null_or_empty(proto)) { return NULL; } search = _mdns_search_init(name, service, proto, type, type != MDNS_TYPE_PTR, timeout, max_results, notifier); if (!search) { return NULL; } if (_mdns_send_search_action(ACTION_SEARCH_ADD, search)) { _mdns_search_free(search); return NULL; } return search; } esp_err_t mdns_query_generic(const char * name, const char * service, const char * proto, uint16_t type, mdns_query_transmission_type_t transmission_type, uint32_t timeout, size_t max_results, mdns_result_t ** results) { mdns_search_once_t * search = NULL; *results = NULL; if (!_mdns_server) { return ESP_ERR_INVALID_STATE; } if (!timeout || _str_null_or_empty(service) != _str_null_or_empty(proto)) { return ESP_ERR_INVALID_ARG; } search = _mdns_search_init(name, service, proto, type, transmission_type == MDNS_QUERY_UNICAST, timeout, max_results, NULL); if (!search) { return ESP_ERR_NO_MEM; } if (_mdns_send_search_action(ACTION_SEARCH_ADD, search)) { _mdns_search_free(search); return ESP_ERR_NO_MEM; } xSemaphoreTake(search->done_semaphore, portMAX_DELAY); *results = search->result; _mdns_search_free(search); return ESP_OK; } esp_err_t mdns_query(const char * name, const char * service_type, const char * proto, uint16_t type, uint32_t timeout, size_t max_results, mdns_result_t ** results) { return mdns_query_generic(name, service_type, proto, type, type != MDNS_TYPE_PTR, timeout, max_results, results); } esp_err_t mdns_query_ptr(const char * service, const char * proto, uint32_t timeout, size_t max_results, mdns_result_t ** results) { if (_str_null_or_empty(service) || _str_null_or_empty(proto)) { return ESP_ERR_INVALID_ARG; } return mdns_query(NULL, service, proto, MDNS_TYPE_PTR, timeout, max_results, results); } esp_err_t mdns_query_srv(const char * instance, const char * service, const char * proto, uint32_t timeout, mdns_result_t ** result) { if (_str_null_or_empty(instance) || _str_null_or_empty(service) || _str_null_or_empty(proto)) { return ESP_ERR_INVALID_ARG; } return mdns_query(instance, service, proto, MDNS_TYPE_SRV, timeout, 1, result); } esp_err_t mdns_query_txt(const char * instance, const char * service, const char * proto, uint32_t timeout, mdns_result_t ** result) { if (_str_null_or_empty(instance) || _str_null_or_empty(service) || _str_null_or_empty(proto)) { return ESP_ERR_INVALID_ARG; } return mdns_query(instance, service, proto, MDNS_TYPE_TXT, timeout, 1, result); } esp_err_t mdns_query_a(const char * name, uint32_t timeout, esp_ip4_addr_t * addr) { mdns_result_t * result = NULL; esp_err_t err; if (_str_null_or_empty(name)) { return ESP_ERR_INVALID_ARG; } if (strstr(name, ".local")) { ESP_LOGW(TAG, "Please note that hostname must not contain domain name, as mDNS uses '.local' domain"); } err = mdns_query(name, NULL, NULL, MDNS_TYPE_A, timeout, 1, &result); if (err) { return err; } if (!result) { return ESP_ERR_NOT_FOUND; } mdns_ip_addr_t * a = result->addr; while (a) { if (a->addr.type == ESP_IPADDR_TYPE_V4) { addr->addr = a->addr.u_addr.ip4.addr; mdns_query_results_free(result); return ESP_OK; } a = a->next; } mdns_query_results_free(result); return ESP_ERR_NOT_FOUND; } #if CONFIG_LWIP_IPV6 esp_err_t mdns_query_aaaa(const char * name, uint32_t timeout, esp_ip6_addr_t * addr) { mdns_result_t * result = NULL; esp_err_t err; if (_str_null_or_empty(name)) { return ESP_ERR_INVALID_ARG; } if (strstr(name, ".local")) { ESP_LOGW(TAG, "Please note that hostname must not contain domain name, as mDNS uses '.local' domain"); } err = mdns_query(name, NULL, NULL, MDNS_TYPE_AAAA, timeout, 1, &result); if (err) { return err; } if (!result) { return ESP_ERR_NOT_FOUND; } mdns_ip_addr_t * a = result->addr; while (a) { if (a->addr.type == ESP_IPADDR_TYPE_V6) { memcpy(addr->addr, a->addr.u_addr.ip6.addr, 16); mdns_query_results_free(result); return ESP_OK; } a = a->next; } mdns_query_results_free(result); return ESP_ERR_NOT_FOUND; } #endif #ifdef MDNS_ENABLE_DEBUG void mdns_debug_packet(const uint8_t * data, size_t len) { static mdns_name_t n; mdns_header_t header; const uint8_t * content = data + MDNS_HEAD_LEN; uint32_t t = xTaskGetTickCount() * portTICK_PERIOD_MS; mdns_name_t * name = &n; memset(name, 0, sizeof(mdns_name_t)); _mdns_dbg_printf("Packet[%u]: ", t); header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET); header.flags.value = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET); header.questions = _mdns_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET); header.answers = _mdns_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET); header.servers = _mdns_read_u16(data, MDNS_HEAD_SERVERS_OFFSET); header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET); _mdns_dbg_printf("%s", (header.flags.value == MDNS_FLAGS_AUTHORITATIVE)?"AUTHORITATIVE\n": (header.flags.value == MDNS_FLAGS_DISTRIBUTED)?"DISTRIBUTED\n": (header.flags.value == 0)?"\n":" " ); if (header.flags.value && header.flags.value != MDNS_FLAGS_AUTHORITATIVE) { _mdns_dbg_printf("0x%04X\n", header.flags.value); } if (header.questions) { uint8_t qs = header.questions; while (qs--) { content = _mdns_parse_fqdn(data, content, name); if (!content) { header.answers = 0; header.additional = 0; header.servers = 0; _mdns_dbg_printf("ERROR: parse header questions\n"); break; } uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); bool unicast = !!(mdns_class & 0x8000); mdns_class &= 0x7FFF; content = content + 4; _mdns_dbg_printf(" Q: "); if (unicast) { _mdns_dbg_printf("*U* "); } if (type == MDNS_TYPE_PTR) { _mdns_dbg_printf("%s.%s%s.%s.%s. PTR ", name->host, name->sub?"_sub.":"", name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_SRV) { _mdns_dbg_printf("%s.%s%s.%s.%s. SRV ", name->host, name->sub?"_sub.":"", name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_TXT) { _mdns_dbg_printf("%s.%s%s.%s.%s. TXT ", name->host, name->sub?"_sub.":"", name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_A) { _mdns_dbg_printf("%s.%s. A ", name->host, name->domain); } else if (type == MDNS_TYPE_AAAA) { _mdns_dbg_printf("%s.%s. AAAA ", name->host, name->domain); } else if (type == MDNS_TYPE_NSEC) { _mdns_dbg_printf("%s.%s%s.%s.%s. NSEC ", name->host, name->sub?"_sub.":"", name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_ANY) { _mdns_dbg_printf("%s.%s%s.%s.%s. ANY ", name->host, name->sub?"_sub.":"", name->service, name->proto, name->domain); } else { _mdns_dbg_printf("%s.%s%s.%s.%s. %04X ", name->host, name->sub?"_sub.":"", name->service, name->proto, name->domain, type); } if (mdns_class == 0x0001) { _mdns_dbg_printf("IN"); } else { _mdns_dbg_printf("%04X", mdns_class); } _mdns_dbg_printf("\n"); } } if (header.answers || header.servers || header.additional) { uint16_t recordIndex = 0; while (content < (data + len)) { content = _mdns_parse_fqdn(data, content, name); if (!content) { _mdns_dbg_printf("ERROR: parse mdns records\n"); break; } uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); uint32_t ttl = _mdns_read_u32(content, MDNS_TTL_OFFSET); uint16_t data_len = _mdns_read_u16(content, MDNS_LEN_OFFSET); const uint8_t * data_ptr = content + MDNS_DATA_OFFSET; bool flush = !!(mdns_class & 0x8000); mdns_class &= 0x7FFF; content = data_ptr + data_len; if (content > (data + len)) { _mdns_dbg_printf("ERROR: content length overflow\n"); break; } mdns_parsed_record_type_t record_type = MDNS_ANSWER; if (recordIndex >= (header.answers + header.servers)) { record_type = MDNS_EXTRA; } else if (recordIndex >= (header.answers)) { record_type = MDNS_NS; } recordIndex++; if (record_type == MDNS_EXTRA) { _mdns_dbg_printf(" X"); } else if (record_type == MDNS_NS) { _mdns_dbg_printf(" S"); } else { _mdns_dbg_printf(" A"); } if (type == MDNS_TYPE_PTR) { _mdns_dbg_printf(": %s%s%s.%s.%s. PTR ", name->host, name->host[0]?".":"", name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_SRV) { _mdns_dbg_printf(": %s.%s.%s.%s. SRV ", name->host, name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_TXT) { _mdns_dbg_printf(": %s.%s.%s.%s. TXT ", name->host, name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_A) { _mdns_dbg_printf(": %s.%s. A ", name->host, name->domain); } else if (type == MDNS_TYPE_AAAA) { _mdns_dbg_printf(": %s.%s. AAAA ", name->host, name->domain); } else if (type == MDNS_TYPE_NSEC) { _mdns_dbg_printf(": %s.%s.%s.%s. NSEC ", name->host, name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_ANY) { _mdns_dbg_printf(": %s.%s.%s.%s. ANY ", name->host, name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_OPT) { _mdns_dbg_printf(": . OPT "); } else { _mdns_dbg_printf(": %s.%s.%s.%s. %04X ", name->host, name->service, name->proto, name->domain, type); } if (mdns_class == 0x0001) { _mdns_dbg_printf("IN "); } else { _mdns_dbg_printf("%04X ", mdns_class); } if (flush) { _mdns_dbg_printf("FLUSH "); } _mdns_dbg_printf("%u ", ttl); _mdns_dbg_printf("[%u] ", data_len); if (type == MDNS_TYPE_PTR) { if (!_mdns_parse_fqdn(data, data_ptr, name)) { _mdns_dbg_printf("ERROR: parse PTR\n"); continue; } _mdns_dbg_printf("%s.%s.%s.%s.\n", name->host, name->service, name->proto, name->domain); } else if (type == MDNS_TYPE_SRV) { if (!_mdns_parse_fqdn(data, data_ptr + MDNS_SRV_FQDN_OFFSET, name)) { _mdns_dbg_printf("ERROR: parse SRV\n"); continue; } uint16_t priority = _mdns_read_u16(data_ptr, MDNS_SRV_PRIORITY_OFFSET); uint16_t weight = _mdns_read_u16(data_ptr, MDNS_SRV_WEIGHT_OFFSET); uint16_t port = _mdns_read_u16(data_ptr, MDNS_SRV_PORT_OFFSET); _mdns_dbg_printf("%u %u %u %s.%s.\n", priority, weight, port, name->host, name->domain); } else if (type == MDNS_TYPE_TXT) { uint16_t i=0, y; while (i < data_len) { uint8_t partLen = data_ptr[i++]; if ((i+partLen) > data_len) { _mdns_dbg_printf("ERROR: parse TXT\n"); break; } char txt[partLen+1]; for (y=0; yhost, name->service, name->proto, name->domain); size_t diff = new_ptr - old_ptr; data_len -= diff; data_ptr = new_ptr; } size_t i; for (i=0; i