fix(mdns): Cleanup mdns sender

david-cermak · david-cermak · commit 1738b7073aeb · 2025-04-02T10:17:47.000+02:00
diff --git a/components/mdns/mdns_browser.c b/components/mdns/mdns_browser.c
@@ -587,7 +587,7 @@ void mdns_priv_browse_result_add_srv(mdns_browse_t *browse, const char *hostname
     add_browse_result(out_sync_browse, r);
 }
 
-/**4
+/**
  * @brief  Browse sync result
  */
 esp_err_t mdns_priv_browse_sync(mdns_browse_sync_t *browse_sync)
diff --git a/components/mdns/mdns_receive.c b/components/mdns/mdns_receive.c
@@ -736,9 +736,9 @@ static void mdns_parse_packet(mdns_rx_packet_t *packet)
             question->type = type;
             question->sub = name->sub;
             if (strdup_check(&(question->host), name->host)
-                || strdup_check(&(question->service), name->service)
-                || strdup_check(&(question->proto), name->proto)
-                || strdup_check(&(question->domain), name->domain)) {
+                    || strdup_check(&(question->service), name->service)
+                    || strdup_check(&(question->proto), name->proto)
+                    || strdup_check(&(question->domain), name->domain)) {
                 goto clear_rx_packet;
             }
         }
diff --git a/components/mdns/mdns_responder.c b/components/mdns/mdns_responder.c
@@ -45,6 +45,19 @@ esp_err_t mdns_priv_responder_init(void)
     return ESP_OK;
 }
 
+static void free_delegated_hostnames(void)
+{
+    mdns_host_item_t *host = s_server->host_list;
+    while (host != NULL) {
+        mdns_utils_free_address_list(host->address_list);
+        mdns_mem_free((char *)host->hostname);
+        mdns_host_item_t *item = host;
+        host = host->next;
+        mdns_mem_free(item);
+    }
+    s_server->host_list = NULL;
+}
+
 void mdns_priv_responder_free(void)
 {
     if (s_server->action_sema != NULL) {
@@ -56,6 +69,7 @@ void mdns_priv_responder_free(void)
     }
     mdns_mem_free((char *)s_server->hostname);
     mdns_mem_free((char *)s_server->instance);
+    free_delegated_hostnames();
     mdns_mem_free(s_server);
     s_server = NULL;
 }
@@ -424,7 +438,7 @@ bool mdns_priv_delegate_hostname_add(const char *hostname, mdns_ip_addr_t *addre
 static bool delegate_hostname_set_address(const char *hostname, mdns_ip_addr_t *address_list)
 {
     if (!mdns_utils_str_null_or_empty(s_server->hostname) &&
-        strcasecmp(hostname, s_server->hostname) == 0) {
+            strcasecmp(hostname, s_server->hostname) == 0) {
         return false;
     }
     mdns_host_item_t *host = s_server->host_list;
@@ -441,19 +455,6 @@ static bool delegate_hostname_set_address(const char *hostname, mdns_ip_addr_t *
     return false;
 }
 
-void mdns_priv_free_delegated_hostnames(void)
-{
-    mdns_host_item_t *host = s_server->host_list;
-    while (host != NULL) {
-        mdns_utils_free_address_list(host->address_list);
-        mdns_mem_free((char *)host->hostname);
-        mdns_host_item_t *item = host;
-        host = host->next;
-        mdns_mem_free(item);
-    }
-    s_server->host_list = NULL;
-}
-
 static bool delegate_hostname_remove(const char *hostname)
 {
     mdns_srv_item_t *srv = s_server->services;
@@ -520,15 +521,15 @@ void mdns_priv_responder_action(mdns_action_t *action, mdns_action_subtype_t typ
             send_bye_all_pcbs_no_instance(true);
             mdns_priv_remap_self_service_hostname(s_server->hostname, action->data.hostname_set.hostname);
             mdns_mem_free((char *)s_server->hostname);
-                s_server->hostname = action->data.hostname_set.hostname;
+            s_server->hostname = action->data.hostname_set.hostname;
             s_server->self_host.hostname = action->data.hostname_set.hostname;
             mdns_priv_restart_all_pcbs();
             xSemaphoreGive(s_server->action_sema);
             break;
         case ACTION_INSTANCE_SET:
             send_bye_all_pcbs_no_instance(false);
             mdns_mem_free((char *)s_server->instance);
-                s_server->instance = action->data.instance;
+            s_server->instance = action->data.instance;
             mdns_priv_restart_all_pcbs_no_instance();
             break;
         case ACTION_DELEGATE_HOSTNAME_ADD:
diff --git a/components/mdns/mdns_send.c b/components/mdns/mdns_send.c
@@ -250,30 +250,30 @@ static mdns_host_item_t *get_host_item(const char *hostname)
 }
 
 static bool create_answer_from_service(mdns_tx_packet_t *packet, mdns_service_t *service,
-                                             mdns_parsed_question_t *question, bool shared, bool send_flush)
+                                       mdns_parsed_question_t *question, bool shared, bool send_flush)
 {
     mdns_host_item_t *host = get_host_item(service->hostname);
     bool is_delegated = (host != mdns_priv_get_self_host());
     if (question->type == MDNS_TYPE_PTR || question->type == MDNS_TYPE_ANY) {
         // According to RFC6763-section12.1, for DNS-SD, SRV, TXT and all address records
         // should be included in additional records.
         if (!mdns_priv_create_answer(&packet->answers, MDNS_TYPE_PTR, service, NULL, false, false) ||
-            !mdns_priv_create_answer(is_delegated ? &packet->additional : &packet->answers, MDNS_TYPE_SRV, service,
-                                     NULL, send_flush, false) ||
-            !mdns_priv_create_answer(is_delegated ? &packet->additional : &packet->answers, MDNS_TYPE_TXT, service,
-                                     NULL, send_flush, false) ||
-            !mdns_priv_create_answer((shared || is_delegated) ? &packet->additional : &packet->answers, MDNS_TYPE_A,
+                !mdns_priv_create_answer(is_delegated ? &packet->additional : &packet->answers, MDNS_TYPE_SRV, service,
+                                         NULL, send_flush, false) ||
+                !mdns_priv_create_answer(is_delegated ? &packet->additional : &packet->answers, MDNS_TYPE_TXT, service,
+                                         NULL, send_flush, false) ||
+                !mdns_priv_create_answer((shared || is_delegated) ? &packet->additional : &packet->answers, MDNS_TYPE_A,
                                          service, host, send_flush,
                                          false) ||
-            !mdns_priv_create_answer((shared || is_delegated) ? &packet->additional : &packet->answers,
+                !mdns_priv_create_answer((shared || is_delegated) ? &packet->additional : &packet->answers,
                                          MDNS_TYPE_AAAA, service, host,
                                          send_flush, false)) {
             return false;
         }
     } else if (question->type == MDNS_TYPE_SRV) {
         if (!mdns_priv_create_answer(&packet->answers, MDNS_TYPE_SRV, service, NULL, send_flush, false) ||
-            !mdns_priv_create_answer(&packet->additional, MDNS_TYPE_A, service, host, send_flush, false) ||
-            !mdns_priv_create_answer(&packet->additional, MDNS_TYPE_AAAA, service, host, send_flush, false)) {
+                !mdns_priv_create_answer(&packet->additional, MDNS_TYPE_A, service, host, send_flush, false) ||
+                !mdns_priv_create_answer(&packet->additional, MDNS_TYPE_AAAA, service, host, send_flush, false)) {
             return false;
         }
     } else if (question->type == MDNS_TYPE_TXT) {
@@ -292,7 +292,7 @@ static bool create_answer_from_hostname(mdns_tx_packet_t *packet, const char *ho
 {
     mdns_host_item_t *host = get_host_item(hostname);
     if (!mdns_priv_create_answer(&packet->answers, MDNS_TYPE_A, NULL, host, send_flush, false) ||
-        !mdns_priv_create_answer(&packet->answers, MDNS_TYPE_AAAA, NULL, host, send_flush, false)) {
+            !mdns_priv_create_answer(&packet->answers, MDNS_TYPE_AAAA, NULL, host, send_flush, false)) {
         return false;
     }
     return true;
@@ -411,7 +411,7 @@ static bool append_host_question(mdns_out_question_t **questions, const char *ho
 }
 
 static bool append_host_questions_for_services(mdns_out_question_t **questions, mdns_srv_item_t *services[],
-                                                     size_t len, bool unicast)
+                                               size_t len, bool unicast)
 {
     if (!mdns_utils_str_null_or_empty(mdns_priv_get_global_hostname()) &&
             !append_host_question(questions, mdns_priv_get_global_hostname(), unicast)) {
@@ -491,12 +491,12 @@ static uint8_t append_reverse_ptr_record(uint8_t *packet, uint16_t *index, const
         return 0;
     }
 
-    if (!_mdns_append_type(packet, index, MDNS_ANSWER_PTR, false, 10 /* TTL set to 10s*/)) {
+    if (!append_type(packet, index, MDNS_ANSWER_PTR, false, 10 /* TTL set to 10s*/)) {
         return 0;
     }
 
     uint16_t data_len_location = *index - 2; /* store the position of size (2=16bis) of this record */
-    const char *str[2] = {priv_get_self_host()->hostname, MDNS_UTILS_DEFAULT_DOMAIN };
+    const char *str[2] = {mdns_priv_get_self_host()->hostname, MDNS_UTILS_DEFAULT_DOMAIN };
 
     int part_length = append_fqdn(packet, index, str, 2, MDNS_MAX_PACKET_SIZE);
     if (!part_length) {
@@ -588,8 +588,7 @@ void mdns_priv_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_pac
 #ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
         } else if (q->type == MDNS_TYPE_PTR) {
             mdns_host_item_t *host = get_host_item(q->host);
-#error
-            if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, NULL, host, send_flush, false)) {
+            if (!mdns_priv_create_answer(&packet->answers, MDNS_TYPE_PTR, NULL, host, send_flush, false)) {
                 mdns_priv_free_tx_packet(packet);
                 return;
             } else {
@@ -829,8 +828,8 @@ static uint16_t append_ptr_record(uint8_t *packet, uint16_t *index, const char *
  * @return length of added data: 0 on error or length on success
  */
 static uint16_t append_subtype_ptr_record(uint8_t *packet, uint16_t *index, const char *instance,
-                                                const char *subtype, const char *service, const char *proto, bool flush,
-                                                bool bye)
+                                          const char *subtype, const char *service, const char *proto, bool flush,
+                                          bool bye)
 {
     const char *subtype_str[5] = {subtype, MDNS_SUB_STR, service, proto, MDNS_UTILS_DEFAULT_DOMAIN};
     const char *instance_str[4] = {instance, service, proto, MDNS_UTILS_DEFAULT_DOMAIN};
@@ -868,12 +867,12 @@ static uint16_t append_subtype_ptr_record(uint8_t *packet, uint16_t *index, cons
  *  @return number of answers added to the packet
  */
 static uint8_t append_service_ptr_answers(uint8_t *packet, uint16_t *index, mdns_service_t *service, bool flush,
-                                                bool bye)
+                                          bool bye)
 {
     uint8_t appended_answers = 0;
 
     if (append_ptr_record(packet, index, mdns_utils_get_service_instance_name(service), service->service,
-                                service->proto, flush, bye) <= 0) {
+                          service->proto, flush, bye) <= 0) {
         return appended_answers;
     }
     appended_answers++;
@@ -882,7 +881,7 @@ static uint8_t append_service_ptr_answers(uint8_t *packet, uint16_t *index, mdns
     while (subtype) {
         appended_answers +=
             (append_subtype_ptr_record(packet, index, mdns_utils_get_service_instance_name(service), subtype->subtype,
-                                             service->service, service->proto, flush, bye) > 0);
+                                       service->service, service->proto, flush, bye) > 0);
         subtype = subtype->next;
     }
 
@@ -1180,7 +1179,7 @@ static uint16_t append_aaaa_record(uint8_t *packet, uint16_t *index, const char
 #endif
 
 static uint8_t append_host_answer(uint8_t *packet, uint16_t *index, mdns_host_item_t *host,
-                                        uint8_t address_type, bool flush, bool bye)
+                                  uint8_t address_type, bool flush, bool bye)
 {
     mdns_ip_addr_t *addr = host->address_list;
     uint8_t num_records = 0;
@@ -1196,7 +1195,7 @@ static uint8_t append_host_answer(uint8_t *packet, uint16_t *index, mdns_host_it
 #ifdef CONFIG_LWIP_IPV6
             if (address_type == ESP_IPADDR_TYPE_V6 &&
                     append_aaaa_record(packet, index, host->hostname, (uint8_t *)addr->addr.u_addr.ip6.addr, flush,
-                                             bye) <= 0) {
+                                       bye) <= 0) {
                 break;
             }
 #endif /* CONFIG_LWIP_IPV6 */
@@ -1238,8 +1237,8 @@ static uint8_t append_answer(uint8_t *packet, uint16_t *index, mdns_out_answer_t
 #endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
         } else {
             return append_ptr_record(packet, index,
-                                           answer->custom_instance, answer->custom_service, answer->custom_proto,
-                                           answer->flush, answer->bye) > 0;
+                                     answer->custom_instance, answer->custom_service, answer->custom_proto,
+                                     answer->flush, answer->bye) > 0;
         }
     } else if (answer->type == MDNS_TYPE_SRV) {
         return append_srv_record(packet, index, answer->service, answer->flush, answer->bye) > 0;
@@ -1294,7 +1293,7 @@ static uint8_t append_answer(uint8_t *packet, uint16_t *index, mdns_out_answer_t
                     return 0;
                 }
                 if (append_aaaa_record(packet, index, mdns_priv_get_global_hostname(), (uint8_t *)if_ip6s[i].addr,
-                                             answer->flush, answer->bye) <= 0) {
+                                       answer->flush, answer->bye) <= 0) {
                     return 0;
                 }
             }
@@ -1308,13 +1307,13 @@ static uint8_t append_answer(uint8_t *packet, uint16_t *index, mdns_out_answer_t
                 return count;
             }
             if (append_aaaa_record(packet, index, mdns_priv_get_global_hostname(), (uint8_t *)other_ip6.addr,
-                                         answer->flush, answer->bye) > 0) {
+                                   answer->flush, answer->bye) > 0) {
                 return 1 + count;
             }
             return count;
         } else if (answer->host != NULL) {
             return append_host_answer(packet, index, answer->host, ESP_IPADDR_TYPE_V6, answer->flush,
-                                            answer->bye);
+                                      answer->bye);
         }
     }
 #endif /* CONFIG_LWIP_IPV6 */
diff --git a/components/mdns/mdns_service.c b/components/mdns/mdns_service.c
@@ -390,7 +390,6 @@ void mdns_free(void)
     mdns_priv_netif_unregister_predefined_handlers();
 
     mdns_service_remove_all();
-    mdns_priv_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);
diff --git a/components/mdns/private_include/mdns_responder.h b/components/mdns/private_include/mdns_responder.h
@@ -88,11 +88,6 @@ void mdns_priv_restart_all_pcbs(void);
  */
 bool mdns_priv_delegate_hostname_add(const char *hostname, mdns_ip_addr_t *address_list);
 
-/**
- * Fee delegated hostnames
- */
-void mdns_priv_free_delegated_hostnames(void);
-
 /**
  * @brief  Remaps hostname of self service
  */
diff --git a/components/mdns/tests/host_unit_test/stubs/mdns_engine.c b/components/mdns/tests/host_unit_test/stubs/mdns_engine.c
@@ -29,7 +29,7 @@ static void execute_action(mdns_action_t *action)
         break;
 
     case ACTION_TX_HANDLE:
-        mdns_send_action(action, ACTION_RUN);
+        mdns_priv_send_action(action, ACTION_RUN);
         break;
     case ACTION_RX_HANDLE:
         mdns_priv_receive_action(action, ACTION_RUN);
diff --git a/components/mdns/tests/host_unit_test/unity/test_receiver/test_receiver.c b/components/mdns/tests/host_unit_test/unity/test_receiver/test_receiver.c
@@ -74,8 +74,8 @@ void setup_cmock(void)
     mdns_priv_pcb_check_probing_services_CMockIgnore();
     mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
 
-    _mdns_clear_tx_queue_head_CMockIgnore();
-    _mdns_remove_scheduled_service_packets_CMockIgnore();
+    mdns_priv_clear_tx_queue_CMockIgnore();
+    mdns_priv_remove_scheduled_service_packets_CMockIgnore();
     mdns_priv_create_answer_from_parsed_packet_Stub(mdns_priv_create_answer_from_parsed_packet_Callback);
 }
 
diff --git a/components/mdns/tests/host_unit_test/unity/test_sender/test_sender.c b/components/mdns/tests/host_unit_test/unity/test_sender/test_sender.c
@@ -18,16 +18,12 @@ void setup_cmock(void)
     mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);
 }
 
-
-
-// Example of a more complex test with answers and additional records
 static void test_dispatch_tx_packet(void)
 {
     mdns_tx_packet_t p = {};
-    _mdns_dispatch_tx_packet(&p);
+    mdns_priv_dispatch_tx_packet(&p);
 }
 
-
 void run_unity_tests(void)
 {
     UNITY_BEGIN();

Original file line number	Diff line number	Diff line change
`@@ -587,7 +587,7 @@ void mdns_priv_browse_result_add_srv(mdns_browse_t browse, const char hostname`
`587`	`587`	`add_browse_result(out_sync_browse, r);`
`588`	`588`	`}`
`589`	`589`
`590`		`-/**4`
	`590`	`+/**`
`591`	`591`	`* @brief Browse sync result`
`592`	`592`	`*/`
`593`	`593`	`esp_err_t mdns_priv_browse_sync(mdns_browse_sync_t *browse_sync)`
Original file line number	Diff line number	Diff line change
`@@ -736,9 +736,9 @@ static void mdns_parse_packet(mdns_rx_packet_t *packet)`
`736`	`736`	`question->type = type;`
`737`	`737`	`question->sub = name->sub;`
`738`	`738`	`if (strdup_check(&(question->host), name->host)`
`739`		`- \|\| strdup_check(&(question->service), name->service)`
`740`		`- \|\| strdup_check(&(question->proto), name->proto)`
`741`		`- \|\| strdup_check(&(question->domain), name->domain)) {`
	`739`	`+ \|\| strdup_check(&(question->service), name->service)`
	`740`	`+ \|\| strdup_check(&(question->proto), name->proto)`
	`741`	`+ \|\| strdup_check(&(question->domain), name->domain)) {`
`742`	`742`	`goto clear_rx_packet;`
`743`	`743`	`}`
`744`	`744`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,8 +74,8 @@ void setup_cmock(void)`
`74`	`74`	`mdns_priv_pcb_check_probing_services_CMockIgnore();`
`75`	`75`	`mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);`
`76`	`76`
`77`		`- _mdns_clear_tx_queue_head_CMockIgnore();`
`78`		`- _mdns_remove_scheduled_service_packets_CMockIgnore();`
	`77`	`+ mdns_priv_clear_tx_queue_CMockIgnore();`
	`78`	`+ mdns_priv_remove_scheduled_service_packets_CMockIgnore();`
`79`	`79`	`mdns_priv_create_answer_from_parsed_packet_Stub(mdns_priv_create_answer_from_parsed_packet_Callback);`
`80`	`80`	`}`
`81`	`81`
Original file line number	Diff line number	Diff line change
`@@ -18,16 +18,12 @@ void setup_cmock(void)`
`18`	`18`	`mdns_priv_pcb_is_after_probing_IgnoreAndReturn(true);`
`19`	`19`	`}`
`20`	`20`
`21`		`-`
`22`		`-`
`23`		`-// Example of a more complex test with answers and additional records`
`24`	`21`	`static void test_dispatch_tx_packet(void)`
`25`	`22`	`{`
`26`	`23`	`mdns_tx_packet_t p = {};`
`27`		`- _mdns_dispatch_tx_packet(&p);`
	`24`	`+ mdns_priv_dispatch_tx_packet(&p);`
`28`	`25`	`}`
`29`	`26`
`30`		`-`
`31`	`27`	`void run_unity_tests(void)`
`32`	`28`	`{`
`33`	`29`	`UNITY_BEGIN();`