fix(mdns): Minor cleanup of packet parser

Author: david-cermak

components/mdns/CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 
 set(MDNS_MEMORY "mdns_mem_caps.c")
 
-set(MDNS_CORE "mdns.c" "mdns_packet.c" "mdns_utils.c" "mdns_debug.c" "mdns_browser.c" "mdns_send.c" "mdns_netif.c"
+set(MDNS_CORE "mdns.c" "mdns_receive.c" "mdns_utils.c" "mdns_debug.c" "mdns_browser.c" "mdns_send.c" "mdns_netif.c"
                 "mdns_querier.c" "mdns_responder.c")
 #set(MDNS_CORE "mdns.c" )
 

components/mdns/mdns.c

@@ -18,7 +18,7 @@
 #include "mdns_mem_caps.h"
 #include "mdns_utils.h"
 #include "mdns_debug.h"
-#include "mdns_browse.h"
+#include "mdns_browser.h"
 #include "mdns_netif.h"
 #include "mdns_send.h"
 #include "mdns_receive.h"

components/mdns/mdns_browser.c

@@ -5,7 +5,7 @@
  */
 #include <string.h>
 #include "mdns_private.h"
-#include "mdns_browse.h"
+#include "mdns_browser.h"
 #include "mdns_send.h"
 #include "mdns_mem_caps.h"
 #include "mdns_debug.h"
@@ -318,3 +318,311 @@ void mdns_browse_action(mdns_action_t *action, mdns_action_subtype_t type)
     }
 
 }
+
+/**
+ * @brief  Add result to browse, only add when the result is a new one.
+ */
+static esp_err_t _mdns_add_browse_result(mdns_browse_sync_t *sync_browse, mdns_result_t *r)
+{
+    mdns_browse_result_sync_t *sync_r = sync_browse->sync_result;
+    while (sync_r) {
+        if (sync_r->result == r) {
+            break;
+        }
+        sync_r = sync_r->next;
+    }
+    if (!sync_r) {
+        // Do not find, need to add the result to the list
+        mdns_browse_result_sync_t *new = (mdns_browse_result_sync_t *)mdns_mem_malloc(sizeof(mdns_browse_result_sync_t));
+
+        if (!new) {
+            HOOK_MALLOC_FAILED;
+            return ESP_ERR_NO_MEM;
+        }
+        new->result = r;
+        new->next = sync_browse->sync_result;
+        sync_browse->sync_result = new;
+    }
+    return ESP_OK;
+}
+
+/**
+ * @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)
+{
+    if (out_sync_browse->browse == NULL) {
+        return;
+    } else {
+        if (out_sync_browse->browse != browse) {
+            return;
+        }
+    }
+    mdns_result_t *r = NULL;
+    mdns_ip_addr_t *r_a = NULL;
+    if (browse) {
+        r = browse->result;
+        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)) {
+                    r_a = r->addr;
+                    // Check if the address has already added in result.
+                    while (r_a) {
+#ifdef CONFIG_LWIP_IPV4
+                        if (r_a->addr.type == ip->type && r_a->addr.type == ESP_IPADDR_TYPE_V4 && r_a->addr.u_addr.ip4.addr == ip->u_addr.ip4.addr) {
+                            break;
+                        }
+#endif
+#ifdef CONFIG_LWIP_IPV6
+                        if (r_a->addr.type == ip->type && r_a->addr.type == ESP_IPADDR_TYPE_V6 && !memcmp(r_a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16)) {
+                            break;
+                        }
+#endif
+                        r_a = r_a->next;
+                    }
+                    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);
+                        if (!a) {
+                            return;
+                        }
+                        a->next = r->addr;
+                        r->addr = a;
+                        if (r->ttl != ttl) {
+                            if (r->ttl == 0) {
+                                r->ttl = ttl;
+                            } else {
+                                _mdns_result_update_ttl(r, ttl);
+                            }
+                        }
+                        if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) {
+                            return;
+                        }
+                        break;
+                    }
+                }
+            }
+            r = r->next;
+        }
+    }
+}
+
+static bool is_txt_item_in_list(mdns_txt_item_t txt, uint8_t txt_value_len, mdns_txt_item_t *txt_list, uint8_t *txt_value_len_list, size_t txt_count)
+{
+    for (size_t i = 0; i < txt_count; i++) {
+        if (strcmp(txt.key, txt_list[i].key) == 0) {
+            if (txt_value_len == txt_value_len_list[i] && memcmp(txt.value, txt_list[i].value, txt_value_len) == 0) {
+                return true;
+            } else {
+                // The key value is unique, so there is no need to continue searching.
+                return false;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * @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)
+{
+    if (out_sync_browse->browse == NULL) {
+        return;
+    } else {
+        if (out_sync_browse->browse != browse) {
+            return;
+        }
+    }
+    mdns_result_t *r = browse->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->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)) {
+            bool should_update = false;
+            if (r->txt) {
+                // Check if txt changed
+                if (txt_count != r->txt_count) {
+                    should_update = true;
+                } else {
+                    for (size_t txt_index = 0; txt_index < txt_count; txt_index++) {
+                        if (!is_txt_item_in_list(txt[txt_index], txt_value_len[txt_index], r->txt, r->txt_value_len, r->txt_count)) {
+                            should_update = true;
+                            break;
+                        }
+                    }
+                }
+                // If the result has a previous txt entry, we delete it and re-add.
+                for (size_t i = 0; i < r->txt_count; i++) {
+                    mdns_mem_free((char *)(r->txt[i].key));
+                    mdns_mem_free((char *)(r->txt[i].value));
+                }
+                mdns_mem_free(r->txt);
+                mdns_mem_free(r->txt_value_len);
+            }
+            r->txt = txt;
+            r->txt_value_len = txt_value_len;
+            r->txt_count = txt_count;
+            if (r->ttl != ttl) {
+                uint32_t previous_ttl = r->ttl;
+                if (r->ttl == 0) {
+                    r->ttl = ttl;
+                } else {
+                    _mdns_result_update_ttl(r, ttl);
+                }
+                if (previous_ttl != r->ttl) {
+                    should_update = true;
+                }
+            }
+            if (should_update) {
+                if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) {
+                    return;
+                }
+            }
+            return;
+        }
+        r = r->next;
+    }
+    r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t));
+    if (!r) {
+        HOOK_MALLOC_FAILED;
+        goto free_txt;
+    }
+    memset(r, 0, sizeof(mdns_result_t));
+    r->instance_name = mdns_mem_strdup(instance);
+    r->service_type = mdns_mem_strdup(service);
+    r->proto = mdns_mem_strdup(proto);
+    if (!r->instance_name || !r->service_type || !r->proto) {
+        mdns_mem_free(r->instance_name);
+        mdns_mem_free(r->service_type);
+        mdns_mem_free(r->proto);
+        mdns_mem_free(r);
+        return;
+    }
+    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->ip_protocol = ip_protocol;
+    r->ttl = ttl;
+    r->next = browse->result;
+    browse->result = r;
+    _mdns_add_browse_result(out_sync_browse, r);
+    return;
+
+free_txt:
+    for (size_t i = 0; i < txt_count; i++) {
+        mdns_mem_free((char *)(txt[i].key));
+        mdns_mem_free((char *)(txt[i].value));
+    }
+    mdns_mem_free(txt);
+    mdns_mem_free(txt_value_len);
+    return;
+}
+
+static esp_err_t _mdns_copy_address_in_previous_result(mdns_result_t *result_list, mdns_result_t *r)
+{
+    while (result_list) {
+        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);
+            if (!r->addr) {
+                return ESP_ERR_NO_MEM;
+            }
+            break;
+        } else {
+            result_list = result_list->next;
+        }
+    }
+    return ESP_OK;
+}
+
+/**
+ * @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)
+{
+    if (out_sync_browse->browse == NULL) {
+        return;
+    } else {
+        if (out_sync_browse->browse != browse) {
+            return;
+        }
+    }
+    mdns_result_t *r = browse->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->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)) {
+            if (mdns_utils_str_null_or_empty(r->hostname) || strcasecmp(hostname, r->hostname)) {
+                r->hostname = mdns_mem_strdup(hostname);
+                r->port = port;
+                if (!r->hostname) {
+                    HOOK_MALLOC_FAILED;
+                    return;
+                }
+                if (!r->addr) {
+                    esp_err_t err = _mdns_copy_address_in_previous_result(browse->result, r);
+                    if (err == ESP_ERR_NO_MEM) {
+                        return;
+                    }
+                }
+                if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) {
+                    return;
+                }
+            }
+            if (r->ttl != ttl) {
+                uint32_t previous_ttl = r->ttl;
+                if (r->ttl == 0) {
+                    r->ttl = ttl;
+                } else {
+                    _mdns_result_update_ttl(r, ttl);
+                }
+                if (previous_ttl != r->ttl) {
+                    if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) {
+                        return;
+                    }
+                }
+            }
+            return;
+        }
+        r = r->next;
+    }
+    r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t));
+    if (!r) {
+        HOOK_MALLOC_FAILED;
+        return;
+    }
+
+    memset(r, 0, sizeof(mdns_result_t));
+    r->hostname = mdns_mem_strdup(hostname);
+    r->instance_name = mdns_mem_strdup(instance);
+    r->service_type = mdns_mem_strdup(service);
+    r->proto = mdns_mem_strdup(proto);
+    if (!r->hostname || !r->instance_name || !r->service_type || !r->proto) {
+        HOOK_MALLOC_FAILED;
+        mdns_mem_free(r->hostname);
+        mdns_mem_free(r->instance_name);
+        mdns_mem_free(r->service_type);
+        mdns_mem_free(r->proto);
+        mdns_mem_free(r);
+        return;
+    }
+    r->port = port;
+    r->esp_netif = _mdns_get_esp_netif(tcpip_if);
+    r->ip_protocol = ip_protocol;
+    r->ttl = ttl;
+    r->next = browse->result;
+    browse->result = r;
+    _mdns_add_browse_result(out_sync_browse, r);
+    return;
+}

components/mdns/mdns_netif.c

@@ -14,7 +14,7 @@
 #include "mdns_mem_caps.h"
 #include "mdns_utils.h"
 #include "mdns_debug.h"
-#include "mdns_browse.h"
+#include "mdns_browser.h"
 #include "mdns_netif.h"
 #include "mdns_send.h"
 #include "mdns_responder.h"