fix(mdns): Cleanup mdns sender

Author: david-cermak

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;
             }
         }

components/mdns/mdns_responder.c

@@ -424,7 +424,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;
@@ -520,15 +520,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:

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 */

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);

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);
 }
 

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();