fix(mdns): Cleanup and split interfaces between modules

Author: david-cermak

components/mdns/mdns.c

@@ -127,7 +127,7 @@ static void _mdns_announce_all_pcbs(mdns_srv_item_t **services, size_t len, bool
     uint8_t i, j;
     for (i = 0; i < MDNS_MAX_INTERFACES; i++) {
         for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) {
-            _mdns_announce_pcb((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip);
+            mdns_priv_pcb_announce((mdns_if_t) i, (mdns_ip_protocol_t) j, services, len, include_ip);
         }
     }
 }
@@ -154,7 +154,7 @@ static void _mdns_send_final_bye(bool include_ip)
         services[i++] = a;
         a = a->next;
     }
-    _mdns_send_bye(services, srv_count, include_ip);
+    mdns_responder_send_bye_service(services, srv_count, include_ip);
 }
 
 /**
@@ -182,7 +182,7 @@ static void _mdns_send_bye_all_pcbs_no_instance(bool include_ip)
         }
         a = a->next;
     }
-    _mdns_send_bye(services, srv_count, include_ip);
+    mdns_responder_send_bye_service(services, srv_count, include_ip);
 }
 
 /**
@@ -470,7 +470,7 @@ static bool _mdns_delegate_hostname_remove(const char *hostname)
     while (srv) {
         if (strcasecmp(srv->service->hostname, hostname) == 0) {
             mdns_srv_item_t *to_free = srv;
-            _mdns_send_bye(&srv, 1, false);
+            mdns_responder_send_bye_service(&srv, 1, false);
             _mdns_remove_scheduled_service_packets(srv->service);
             if (prev_srv == NULL) {
                 _mdns_server->services = srv->next;
@@ -523,22 +523,22 @@ static void perform_event_action(mdns_if_t mdns_if, mdns_event_actions_t action)
         return;
     }
     if (action & MDNS_EVENT_ENABLE_IP4) {
-        _mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V4);
+        mdns_priv_pcb_enable(mdns_if, MDNS_IP_PROTOCOL_V4);
     }
     if (action & MDNS_EVENT_ENABLE_IP6) {
-        _mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6);
+        mdns_priv_pcb_enable(mdns_if, MDNS_IP_PROTOCOL_V6);
     }
     if (action & MDNS_EVENT_DISABLE_IP4) {
-        _mdns_disable_pcb(mdns_if, MDNS_IP_PROTOCOL_V4);
+        mdns_priv_pcb_disable(mdns_if, MDNS_IP_PROTOCOL_V4);
     }
     if (action & MDNS_EVENT_DISABLE_IP6) {
-        _mdns_disable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6);
+        mdns_priv_pcb_disable(mdns_if, MDNS_IP_PROTOCOL_V6);
     }
     if (action & MDNS_EVENT_ANNOUNCE_IP4) {
-        _mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V4, NULL, 0, true);
+        mdns_priv_pcb_announce(mdns_if, MDNS_IP_PROTOCOL_V4, NULL, 0, true);
     }
     if (action & MDNS_EVENT_ANNOUNCE_IP6) {
-        _mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V6, NULL, 0, true);
+        mdns_priv_pcb_announce(mdns_if, MDNS_IP_PROTOCOL_V6, NULL, 0, true);
     }
 
 #ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
@@ -614,7 +614,7 @@ static void _mdns_free_action(mdns_action_t *action)
     case ACTION_SEARCH_ADD:
     case ACTION_SEARCH_SEND:
     case ACTION_SEARCH_END:
-        mdns_query_action(action, ACTION_CLEANUP);
+        mdns_priv_query_action(action, ACTION_CLEANUP);
         break;
     case ACTION_BROWSE_ADD:
     case ACTION_BROWSE_END:
@@ -625,7 +625,7 @@ static void _mdns_free_action(mdns_action_t *action)
         mdns_send_action(action, ACTION_CLEANUP);
         break;
     case ACTION_RX_HANDLE:
-        mdns_receive_action(action, ACTION_CLEANUP);
+        mdns_priv_receive_action(action, ACTION_CLEANUP);
         break;
     case ACTION_DELEGATE_HOSTNAME_SET_ADDR:
     case ACTION_DELEGATE_HOSTNAME_ADD:
@@ -669,7 +669,7 @@ static void _mdns_execute_action(mdns_action_t *action)
     case ACTION_SEARCH_ADD:
     case ACTION_SEARCH_SEND:
     case ACTION_SEARCH_END:
-        mdns_query_action(action, ACTION_RUN);
+        mdns_priv_query_action(action, ACTION_RUN);
         break;
     case ACTION_BROWSE_ADD:
     case ACTION_BROWSE_SYNC:
@@ -681,7 +681,7 @@ static void _mdns_execute_action(mdns_action_t *action)
         mdns_send_action(action, ACTION_RUN);
         break;
     case ACTION_RX_HANDLE:
-        mdns_receive_action(action, ACTION_RUN);
+        mdns_priv_receive_action(action, ACTION_RUN);
         break;
     case ACTION_DELEGATE_HOSTNAME_ADD:
         if (!_mdns_delegate_hostname_add(action->data.delegate_hostname.hostname,
@@ -736,7 +736,7 @@ static void _mdns_service_task(void *pvParameters)
 static void _mdns_timer_cb(void *arg)
 {
     mdns_send_packets();
-    _mdns_search_run();
+    mdns_priv_query_start_stop();
 }
 
 static esp_err_t _mdns_start_timer(void)
@@ -920,14 +920,14 @@ void mdns_free(void)
     }
 
     // Unregister handlers before destroying the mdns internals to avoid receiving async events while deinit
-    unregister_predefined_handlers();
+    mdns_netif_unregister_predefined_handlers();
 
     mdns_service_remove_all();
     free_delegated_hostnames();
     _mdns_service_task_stop();
     // at this point, the service task is deleted, so we can destroy the stack size
     mdns_mem_task_free(_mdns_stack_buffer);
-    mdns_responder_deinit();
+    mdns_priv_pcb_deinit();
     mdns_mem_free((char *)_mdns_server->hostname);
     mdns_mem_free((char *)_mdns_server->instance);
     if (_mdns_server->action_queue) {
@@ -938,7 +938,7 @@ void mdns_free(void)
         vQueueDelete(_mdns_server->action_queue);
     }
     _mdns_clear_tx_queue_head();
-    mdns_search_free();
+    mdns_priv_query_free();
     mdns_browse_free();
     vSemaphoreDelete(_mdns_server->action_sema);
     mdns_mem_free(_mdns_server);
@@ -1336,7 +1336,7 @@ static mdns_result_t *_mdns_lookup_service(const char *instance, const char *ser
     }
     return results;
 handle_error:
-    _mdns_query_results_free(results);
+    mdns_priv_query_results_free(results);
     return NULL;
 }
 
@@ -1783,7 +1783,7 @@ esp_err_t mdns_service_instance_name_set_for_host(const char *instance_old, cons
     ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist");
 
     if (s->service->instance) {
-        _mdns_send_bye(&s, 1, false);
+        mdns_responder_send_bye_service(&s, 1, false);
         mdns_mem_free((char *)s->service->instance);
     }
     s->service->instance = mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1);
@@ -1823,7 +1823,7 @@ esp_err_t mdns_service_remove_for_host(const char *instance, const char *service
                 } else {
                     _mdns_server->services = a->next;
                 }
-                _mdns_send_bye(&a, 1, false);
+                mdns_responder_send_bye_service(&a, 1, false);
                 _mdns_remove_scheduled_service_packets(a->service);
                 _mdns_free_service(a->service);
                 mdns_mem_free(a);
@@ -1840,7 +1840,7 @@ esp_err_t mdns_service_remove_for_host(const char *instance, const char *service
                 } else {
                     _mdns_server->services = a->next;
                 }
-                _mdns_send_bye(&a, 1, false);
+                mdns_responder_send_bye_service(&a, 1, false);
                 _mdns_remove_scheduled_service_packets(a->service);
                 _mdns_free_service(a->service);
                 mdns_mem_free(a);

components/mdns/mdns_browser.c

@@ -48,7 +48,7 @@ static void _mdns_browse_item_free(mdns_browse_t *browse)
     mdns_mem_free(browse->service);
     mdns_mem_free(browse->proto);
     if (browse->result) {
-        _mdns_query_results_free(browse->result);
+        mdns_priv_query_results_free(browse->result);
     }
     mdns_mem_free(browse);
 }
@@ -349,8 +349,8 @@ static esp_err_t _mdns_add_browse_result(mdns_browse_sync_t *sync_browse, mdns_r
 /**
  * @brief  Called from parser to add A/AAAA data to search result
  */
-void _mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_ip_addr_t *ip,
-                                mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse)
+void mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_ip_addr_t *ip,
+                               mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse)
 {
     if (out_sync_browse->browse == NULL) {
         return;
@@ -428,9 +428,9 @@ static bool is_txt_item_in_list(mdns_txt_item_t txt, uint8_t txt_value_len, mdns
 /**
  * @brief  Called from parser to add TXT data to search result
  */
-void _mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, const char *service, const char *proto,
-                                 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_browse_sync_t *out_sync_browse)
+void mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, const char *service, const char *proto,
+                                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_browse_sync_t *out_sync_browse)
 {
     if (out_sync_browse->browse == NULL) {
         return;
@@ -547,8 +547,8 @@ static esp_err_t _mdns_copy_address_in_previous_result(mdns_result_t *result_lis
 /**
  * @brief  Called from parser to add SRV data to search result
  */
-void _mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, const char *instance, const char *service, const char *proto,
-                                 uint16_t port, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse)
+void mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, const char *instance, const char *service, const char *proto,
+                                uint16_t port, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse)
 {
     if (out_sync_browse->browse == NULL) {
         return;

components/mdns/mdns_netif.c

@@ -72,7 +72,7 @@ static mdns_interfaces_t s_esp_netifs[MDNS_MAX_INTERFACES] = {
  * @brief  Helper to get either ETH or STA if the other is provided
  *          Used when two interfaces are on the same subnet
  */
-mdns_if_t _mdns_get_other_if(mdns_if_t tcpip_if)
+mdns_if_t mdns_netif_get_other_interface(mdns_if_t tcpip_if)
 {
     if (tcpip_if < MDNS_MAX_INTERFACES) {
         return s_esp_netifs[tcpip_if].duplicate;
@@ -146,7 +146,7 @@ esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if)
 /*
  * @brief Clean internal mdns interface's pointer
  */
-void _mdns_clean_netif_ptr(mdns_if_t tcpip_if)
+void mdns_netif_disable(mdns_if_t tcpip_if)
 {
     if (tcpip_if < MDNS_MAX_INTERFACES) {
         s_esp_netifs[tcpip_if].netif = NULL;
@@ -315,7 +315,7 @@ static inline void set_default_duplicated_interfaces(void)
     }
 }
 
-void unregister_predefined_handlers(void)
+void mdns_netif_unregister_predefined_handlers(void)
 {
 #if MDNS_ESP_WIFI_ENABLED && (CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP)
     esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event);
@@ -420,28 +420,28 @@ 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)) {
-            _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V6);
+            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) {
-            _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V4);
+            mdns_priv_pcb_enable(i, MDNS_IP_PROTOCOL_V4);
         }
 #endif
     }
     return ESP_OK;
 #if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH
 free_event_handlers:
-    unregister_predefined_handlers();
+    mdns_netif_unregister_predefined_handlers();
 #endif
     return err;
 }
 
 esp_err_t mdns_netif_deinit(void)
 {
     for (int i = 0; i < MDNS_MAX_INTERFACES; i++) {
-        _mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V6);
-        _mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V4);
+        mdns_priv_pcb_disable(i, MDNS_IP_PROTOCOL_V6);
+        mdns_priv_pcb_disable(i, MDNS_IP_PROTOCOL_V4);
         s_esp_netifs[i].duplicate = MDNS_MAX_INTERFACES;
     }
     return ESP_OK;