fix(mdns): Rename and cleanup

Author: david-cermak

components/mdns/mdns.c

@@ -11,6 +11,7 @@
 #include "mdns_debug.h"
 #include "mdns_utils.h"
 #include "mdns_querier.h"
+#include "mdns_netif.h"
 #include "esp_log.h"
 
 static const char *TAG = "mdns_browser";
@@ -33,7 +34,7 @@ static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t
 
     action->type = type;
     action->data.browse_add.browse = browse;
-    if (!mdns_action_queue(action)) {
+    if (!mdns_priv_queue_action(action)) {
         mdns_mem_free(action);
         return ESP_ERR_NO_MEM;
     }
@@ -170,7 +171,7 @@ mdns_browse_t *mdns_browse_new(const char *service, const char *proto, mdns_brow
 {
     mdns_browse_t *browse = NULL;
 
-    if (is_mdns_server() || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
+    if (mdns_priv_is_server_init() || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
         return NULL;
     }
 
@@ -191,7 +192,7 @@ esp_err_t mdns_browse_delete(const char *service, const char *proto)
 {
     mdns_browse_t *browse = NULL;
 
-    if (!is_mdns_server() || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
+    if (!mdns_priv_is_server_init() || mdns_utils_str_null_or_empty(service) || mdns_utils_str_null_or_empty(proto)) {
         return ESP_FAIL;
     }
 
@@ -258,7 +259,7 @@ mdns_browse_t *_mdns_browse_find(mdns_name_t *name, uint16_t type, mdns_if_t tcp
         } else if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) {
             r = b->result;
             while (r) {
-                if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(name->host, r->hostname)) {
+                if (r->esp_netif == mdns_netif_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(name->host, r->hostname)) {
                     return b;
                 }
                 r = r->next;
@@ -366,7 +367,7 @@ void mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_
         while (r) {
             if (r->ip_protocol == ip_protocol) {
                 // Find the target result in browse result.
-                if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) {
+                if (r->esp_netif == mdns_netif_get_esp_netif(tcpip_if) && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) {
                     r_a = r->addr;
                     // Check if the address has already added in result.
                     while (r_a) {
@@ -385,7 +386,7 @@ void mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_
                     if (!r_a) {
                         // The current IP is a new one, add it to the link list.
                         mdns_ip_addr_t *a = NULL;
-                        a = _mdns_result_addr_create_ip(ip);
+                        a = mdns_priv_result_addr_create_ip(ip);
                         if (!a) {
                             return;
                         }
@@ -395,7 +396,7 @@ void mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_
                             if (r->ttl == 0) {
                                 r->ttl = ttl;
                             } else {
-                                _mdns_result_update_ttl(r, ttl);
+                                mdns_priv_query_update_result_ttl(r, ttl);
                             }
                         }
                         if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) {
@@ -441,7 +442,7 @@ void mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, con
     }
     mdns_result_t *r = browse->result;
     while (r) {
-        if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol &&
+        if (r->esp_netif == mdns_netif_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol &&
                 !mdns_utils_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name) &&
                 !mdns_utils_str_null_or_empty(r->service_type) && !strcasecmp(service, r->service_type) &&
                 !mdns_utils_str_null_or_empty(r->proto) && !strcasecmp(proto, r->proto)) {
@@ -474,7 +475,7 @@ void mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, con
                 if (r->ttl == 0) {
                     r->ttl = ttl;
                 } else {
-                    _mdns_result_update_ttl(r, ttl);
+                    mdns_priv_query_update_result_ttl(r, ttl);
                 }
                 if (previous_ttl != r->ttl) {
                     should_update = true;
@@ -508,7 +509,7 @@ void mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, con
     r->txt = txt;
     r->txt_value_len = txt_value_len;
     r->txt_count = txt_count;
-    r->esp_netif = _mdns_get_esp_netif(tcpip_if);
+    r->esp_netif = mdns_netif_get_esp_netif(tcpip_if);
     r->ip_protocol = ip_protocol;
     r->ttl = ttl;
     r->next = browse->result;
@@ -532,7 +533,7 @@ static esp_err_t _mdns_copy_address_in_previous_result(mdns_result_t *result_lis
         if (!mdns_utils_str_null_or_empty(result_list->hostname) && !mdns_utils_str_null_or_empty(r->hostname) && !strcasecmp(result_list->hostname, r->hostname) &&
                 result_list->ip_protocol == r->ip_protocol && result_list->addr && !r->addr) {
             // If there is a same hostname in previous result, we need to copy the address here.
-            r->addr = copy_address_list(result_list->addr);
+            r->addr = mdns_utils_copy_address_list(result_list->addr);
             if (!r->addr) {
                 return ESP_ERR_NO_MEM;
             }
@@ -559,7 +560,7 @@ void mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, con
     }
     mdns_result_t *r = browse->result;
     while (r) {
-        if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol &&
+        if (r->esp_netif == mdns_netif_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol &&
                 !mdns_utils_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name) &&
                 !mdns_utils_str_null_or_empty(r->service_type) && !strcasecmp(service, r->service_type) &&
                 !mdns_utils_str_null_or_empty(r->proto) && !strcasecmp(proto, r->proto)) {
@@ -585,7 +586,7 @@ void mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, con
                 if (r->ttl == 0) {
                     r->ttl = ttl;
                 } else {
-                    _mdns_result_update_ttl(r, ttl);
+                    mdns_priv_query_update_result_ttl(r, ttl);
                 }
                 if (previous_ttl != r->ttl) {
                     if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) {
@@ -618,7 +619,7 @@ void mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, con
         return;
     }
     r->port = port;
-    r->esp_netif = _mdns_get_esp_netif(tcpip_if);
+    r->esp_netif = mdns_netif_get_esp_netif(tcpip_if);
     r->ip_protocol = ip_protocol;
     r->ttl = ttl;
     r->next = browse->result;

components/mdns/mdns_browser.c

@@ -45,7 +45,7 @@ void static dbg_packet(const uint8_t *data, size_t len)
         uint8_t qs = header.questions;
 
         while (qs--) {
-            content = _mdns_parse_fqdn(data, content, name, len);
+            content = mdns_utils_parse_fqdn(data, content, name, len);
             if (!content || content + MDNS_CLASS_OFFSET + 1 >= data + len) {
                 header.answers = 0;
                 header.additional = 0;
@@ -96,7 +96,7 @@ void static dbg_packet(const uint8_t *data, size_t len)
 
         while (content < (data + len)) {
 
-            content = _mdns_parse_fqdn(data, content, name, len);
+            content = mdns_utils_parse_fqdn(data, content, name, len);
             if (!content) {
                 dbg_printf("ERROR: parse mdns records\n");
                 break;
@@ -164,13 +164,13 @@ void static dbg_packet(const uint8_t *data, size_t len)
             dbg_printf("%" PRIu32, ttl);
             dbg_printf("[%u] ", data_len);
             if (type == MDNS_TYPE_PTR) {
-                if (!_mdns_parse_fqdn(data, data_ptr, name, len)) {
+                if (!mdns_utils_parse_fqdn(data, data_ptr, name, len)) {
                     dbg_printf("ERROR: parse PTR\n");
                     continue;
                 }
                 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, len)) {
+                if (!mdns_utils_parse_fqdn(data, data_ptr + MDNS_SRV_FQDN_OFFSET, name, len)) {
                     dbg_printf("ERROR: parse SRV\n");
                     continue;
                 }
@@ -208,7 +208,7 @@ void static dbg_packet(const uint8_t *data, size_t len)
                 dbg_printf(IPSTR "\n", IP2STR(&ip));
             } else if (type == MDNS_TYPE_NSEC) {
                 const uint8_t *old_ptr = data_ptr;
-                const uint8_t *new_ptr = _mdns_parse_fqdn(data, data_ptr, name, len);
+                const uint8_t *new_ptr = mdns_utils_parse_fqdn(data, data_ptr, name, len);
                 if (new_ptr) {
                     dbg_printf("%s.%s.%s.%s. ", name->host, name->service, name->proto, name->domain);
                     size_t diff = new_ptr - old_ptr;

components/mdns/mdns_debug.c

@@ -117,19 +117,7 @@ static inline esp_netif_t *esp_netif_from_preset_if(mdns_predef_if_t predef_if)
     }
 }
 
-/**
- * @brief Gets the actual esp_netif pointer from the internal network interface list
- *
- * The supplied ordinal number could
- * - point to a predef netif -> "STA", "AP", "ETH"
- *      - if no entry in the list (NULL) -> check if the system added this netif
- * - point to a custom netif -> just return the entry in the list
- *      - users is responsible for the lifetime of this netif (to be valid between mdns-init -> deinit)
- *
- * @param tcpip_if Ordinal number of the interface
- * @return Pointer ot the esp_netif object if the interface is available, NULL otherwise
- */
-esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if)
+esp_netif_t *mdns_netif_get_esp_netif(mdns_if_t tcpip_if)
 {
     if (tcpip_if < MDNS_MAX_INTERFACES) {
         if (s_esp_netifs[tcpip_if].netif == NULL && s_esp_netifs[tcpip_if].predefined) {
@@ -174,7 +162,7 @@ static mdns_if_t _mdns_get_if_from_esp_netif(esp_netif_t *esp_netif)
 
 static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_actions_t event_action)
 {
-    if (!is_mdns_server() || mdns_if >= MDNS_MAX_INTERFACES) {
+    if (!mdns_priv_is_server_init() || mdns_if >= MDNS_MAX_INTERFACES) {
         return ESP_ERR_INVALID_STATE;
     }
 
@@ -187,7 +175,7 @@ static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_
     action->data.sys_event.event_action = event_action;
     action->data.sys_event.interface = mdns_if;
 
-    if (!mdns_action_queue(action)) {
+    if (!mdns_priv_queue_action(action)) {
         mdns_mem_free(action);
     }
     return ESP_OK;
@@ -216,7 +204,7 @@ static inline void post_mdns_announce_pcb(mdns_predef_if_t preset_if, mdns_ip_pr
 void mdns_preset_if_handle_system_event(void *arg, esp_event_base_t event_base,
                                         int32_t event_id, void *event_data)
 {
-    if (!is_mdns_server()) {
+    if (!mdns_priv_is_server_init()) {
         return;
     }
 
@@ -339,15 +327,15 @@ esp_err_t mdns_netif_action(esp_netif_t *esp_netif, mdns_event_actions_t event_a
 
 esp_err_t mdns_register_netif(esp_netif_t *esp_netif)
 {
-    if (!is_mdns_server()) {
+    if (!mdns_priv_is_server_init()) {
         return ESP_ERR_INVALID_STATE;
     }
 
     esp_err_t err = ESP_ERR_NO_MEM;
-    mdns_service_lock();
+    mdns_priv_service_lock();
     for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; ++i) {
         if (s_esp_netifs[i].netif == esp_netif) {
-            mdns_service_unlock();
+            mdns_priv_service_unlock();
             return ESP_ERR_INVALID_STATE;
         }
     }
@@ -359,26 +347,26 @@ esp_err_t mdns_register_netif(esp_netif_t *esp_netif)
             break;
         }
     }
-    mdns_service_unlock();
+    mdns_priv_service_unlock();
     return err;
 }
 
 esp_err_t mdns_unregister_netif(esp_netif_t *esp_netif)
 {
-    if (!is_mdns_server()) {
+    if (!mdns_priv_is_server_init()) {
         return ESP_ERR_INVALID_STATE;
     }
 
     esp_err_t err = ESP_ERR_NOT_FOUND;
-    mdns_service_lock();
+    mdns_priv_service_lock();
     for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; ++i) {
         if (!s_esp_netifs[i].predefined && s_esp_netifs[i].netif == esp_netif) {
             s_esp_netifs[i].netif = NULL;
             err = ESP_OK;
             break;
         }
     }
-    mdns_service_lock();
+    mdns_priv_service_lock();
     return err;
 }
 
@@ -419,12 +407,12 @@ esp_err_t mdns_netif_init(void)
 
     for (i = 0; i < MDNS_MAX_INTERFACES; i++) {
 #ifdef CONFIG_LWIP_IPV6
-        if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(i), &tmp_addr6) && !mdns_utils_ipv6_address_is_zero(tmp_addr6)) {
+        if (!esp_netif_get_ip6_linklocal(mdns_netif_get_esp_netif(i), &tmp_addr6) && !mdns_utils_ipv6_address_is_zero(tmp_addr6)) {
             mdns_priv_pcb_enable(i, MDNS_IP_PROTOCOL_V6);
         }
 #endif
 #ifdef CONFIG_LWIP_IPV4
-        if (!esp_netif_get_ip_info(_mdns_get_esp_netif(i), &if_ip_info) && if_ip_info.ip.addr) {
+        if (!esp_netif_get_ip_info(mdns_netif_get_esp_netif(i), &if_ip_info) && if_ip_info.ip.addr) {
             mdns_priv_pcb_enable(i, MDNS_IP_PROTOCOL_V4);
         }
 #endif

components/mdns/mdns_netif.c

@@ -107,7 +107,7 @@ static void _udp_pcb_main_deinit(void)
 static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protocol, bool join)
 {
     struct netif *netif = NULL;
-    esp_netif_t *tcpip_if = _mdns_get_esp_netif(if_inx);
+    esp_netif_t *tcpip_if = mdns_netif_get_esp_netif(if_inx);
 
     if (!esp_netif_is_netif_up(tcpip_if)) {
         // Network interface went down before event propagated, skipping IGMP config
@@ -208,7 +208,7 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
         struct netif *netif = NULL;
         bool found = false;
         for (i = 0; i < MDNS_MAX_INTERFACES; i++) {
-            netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i));
+            netif = esp_netif_get_netif_impl(mdns_netif_get_esp_netif(i));
             if (s_interfaces[i].proto && netif && netif == ip_current_input_netif()) {
 #if LWIP_IPV4
                 if (packet->src.type == IPADDR_TYPE_V4) {
@@ -353,7 +353,7 @@ static err_t _mdns_udp_pcb_write_api(struct tcpip_api_call_data *api_call_msg)
 {
     void *nif = NULL;
     mdns_api_call_t *msg = (mdns_api_call_t *)api_call_msg;
-    nif = esp_netif_get_netif_impl(_mdns_get_esp_netif(msg->tcpip_if));
+    nif = esp_netif_get_netif_impl(mdns_netif_get_esp_netif(msg->tcpip_if));
     if (!nif || !mdns_is_netif_ready(msg->tcpip_if, msg->ip_protocol) || _pcb_main == NULL) {
         pbuf_free(msg->pbt);
         msg->err = ERR_IF;

components/mdns/mdns_networking_lwip.c

@@ -23,6 +23,7 @@
 #include "esp_log.h"
 #include "mdns_mem_caps.h"
 #include "mdns_utils.h"
+#include "mdns_netif.h"
 
 #if defined(CONFIG_IDF_TARGET_LINUX)
 #include <sys/ioctl.h>
@@ -71,7 +72,7 @@ static esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet)
 
     action->type = ACTION_RX_HANDLE;
     action->data.rx_handle.packet = packet;
-    if (!mdns_action_queue(action)) {
+    if (!mdns_priv_queue_action(action)) {
         mdns_mem_free(action);
         return ESP_ERR_NO_MEM;
     }
@@ -373,7 +374,7 @@ static bool create_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
         return true;
     }
     int sock = s_interfaces[tcpip_if].sock;
-    esp_netif_t *netif = _mdns_get_esp_netif(tcpip_if);
+    esp_netif_t *netif = mdns_netif_get_esp_netif(tcpip_if);
     if (sock < 0) {
         sock = create_socket(netif);
     }