feat(mdns): action queue abstraction

Author: david-cermak

components/mdns/mdns.c

@@ -17,50 +17,64 @@ static const char *TAG = "mdns_browser";
 
 static mdns_browse_t *s_browse;
 
-void mdns_browse_send_all(mdns_if_t mdns_if)
+/**
+ * @brief  Browse action
+ */
+static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t *browse)
 {
-    mdns_browse_t *browse = s_browse;
-    while (browse) {
-        _mdns_browse_send(browse, mdns_if);
-        browse = browse->next;
+    mdns_action_t *action = NULL;
+
+    action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t));
+
+    if (!action) {
+        HOOK_MALLOC_FAILED;
+        return ESP_ERR_NO_MEM;
     }
-}
 
-void mdns_browse_free(void)
-{
-    while (s_browse) {
-        mdns_browse_t *b = s_browse;
-        s_browse = s_browse->next;
-        _mdns_browse_item_free(b);
+    action->type = type;
+    action->data.browse_add.browse = browse;
+    if (!mdns_action_queue(action)) {
+        mdns_mem_free(action);
+        return ESP_ERR_NO_MEM;
     }
+    return ESP_OK;
 }
 
 /**
- * @brief  Mark browse as finished, remove and free it from browse chain
+ * @brief  Free a browse item (Not free the list).
  */
-void _mdns_browse_finish(mdns_browse_t *browse)
+static void _mdns_browse_item_free(mdns_browse_t *browse)
 {
-    browse->state = BROWSE_OFF;
-    mdns_browse_t *b = s_browse;
-    mdns_browse_t *target_free = NULL;
-    while (b) {
-        if (strlen(b->service) == strlen(browse->service) && memcmp(b->service, browse->service, strlen(b->service)) == 0 &&
-                strlen(b->proto) == strlen(browse->proto) && memcmp(b->proto, browse->proto, strlen(b->proto)) == 0) {
-            target_free = b;
-            b = b->next;
-            queueDetach(mdns_browse_t, s_browse, target_free);
-            _mdns_browse_item_free(target_free);
-        } else {
-            b = b->next;
+    mdns_mem_free(browse->service);
+    mdns_mem_free(browse->proto);
+    if (browse->result) {
+        _mdns_query_results_free(browse->result);
+    }
+    mdns_mem_free(browse);
+}
+
+static void _mdns_browse_sync(mdns_browse_sync_t *browse_sync)
+{
+    mdns_browse_t *browse = browse_sync->browse;
+    mdns_browse_result_sync_t *sync_result = browse_sync->sync_result;
+    while (sync_result) {
+        mdns_result_t *result = sync_result->result;
+        DBG_BROWSE_RESULTS(result, browse_sync->browse);
+        browse->notifier(result);
+        if (result->ttl == 0) {
+            queueDetach(mdns_result_t, browse->result, result);
+            // Just free current result
+            result->next = NULL;
+            mdns_query_results_free(result);
         }
+        sync_result = sync_result->next;
     }
-    _mdns_browse_item_free(browse);
 }
 
 /**
  * @brief  Send PTR query packet to all available interfaces for browsing.
  */
-void _mdns_browse_send(mdns_browse_t *browse, mdns_if_t interface)
+static void _mdns_browse_send(mdns_browse_t *browse, mdns_if_t interface)
 {
     // Using search once for sending the PTR query
     mdns_search_once_t search = {0};
@@ -78,20 +92,46 @@ void _mdns_browse_send(mdns_browse_t *browse, mdns_if_t interface)
     }
 }
 
+void mdns_browse_send_all(mdns_if_t mdns_if)
+{
+    mdns_browse_t *browse = s_browse;
+    while (browse) {
+        _mdns_browse_send(browse, mdns_if);
+        browse = browse->next;
+    }
+}
+
+void mdns_browse_free(void)
+{
+    while (s_browse) {
+        mdns_browse_t *b = s_browse;
+        s_browse = s_browse->next;
+        _mdns_browse_item_free(b);
+    }
+}
+
 /**
- * @brief  Free a browse item (Not free the list).
+ * @brief  Mark browse as finished, remove and free it from browse chain
  */
-void _mdns_browse_item_free(mdns_browse_t *browse)
+static void _mdns_browse_finish(mdns_browse_t *browse)
 {
-    mdns_mem_free(browse->service);
-    mdns_mem_free(browse->proto);
-    if (browse->result) {
-        _mdns_query_results_free(browse->result);
+    browse->state = BROWSE_OFF;
+    mdns_browse_t *b = s_browse;
+    mdns_browse_t *target_free = NULL;
+    while (b) {
+        if (strlen(b->service) == strlen(browse->service) && memcmp(b->service, browse->service, strlen(b->service)) == 0 &&
+                strlen(b->proto) == strlen(browse->proto) && memcmp(b->proto, browse->proto, strlen(b->proto)) == 0) {
+            target_free = b;
+            b = b->next;
+            queueDetach(mdns_browse_t, s_browse, target_free);
+            _mdns_browse_item_free(target_free);
+        } else {
+            b = b->next;
+        }
     }
-    mdns_mem_free(browse);
+    _mdns_browse_item_free(browse);
 }
 
-
 /**
  * @brief  Allocate new browse structure
  */
@@ -170,7 +210,7 @@ esp_err_t mdns_browse_delete(const char *service, const char *proto)
 /**
  * @brief  Add new browse to the browse chain
  */
-void _mdns_browse_add(mdns_browse_t *browse)
+static void _mdns_browse_add(mdns_browse_t *browse)
 {
     browse->state = BROWSE_RUNNING;
     mdns_browse_t *queue = s_browse;
@@ -229,3 +269,52 @@ mdns_browse_t *_mdns_browse_find(mdns_name_t *name, uint16_t type, mdns_if_t tcp
     }
     return b;
 }
+
+static void _mdns_sync_browse_result_link_free(mdns_browse_sync_t *browse_sync)
+{
+    mdns_browse_result_sync_t *current = browse_sync->sync_result;
+    mdns_browse_result_sync_t *need_free;
+    while (current) {
+        need_free = current;
+        current = current->next;
+        mdns_mem_free(need_free);
+    }
+    mdns_mem_free(browse_sync);
+}
+
+void mdns_browse_action(mdns_action_t *action, mdns_action_subtype_t type)
+{
+    if (type == ACTION_RUN) {
+        switch (action->type) {
+        case ACTION_BROWSE_ADD:
+            _mdns_browse_add(action->data.browse_add.browse);
+            break;
+        case ACTION_BROWSE_SYNC:
+            _mdns_browse_sync(action->data.browse_sync.browse_sync);
+            _mdns_sync_browse_result_link_free(action->data.browse_sync.browse_sync);
+            break;
+        case ACTION_BROWSE_END:
+            _mdns_browse_finish(action->data.browse_add.browse);
+            break;
+        default:
+            abort();
+        }
+        return;
+    }
+    if (type == ACTION_CLEANUP) {
+        switch (action->type) {
+        case ACTION_BROWSE_ADD:
+        //fallthrough
+        case ACTION_BROWSE_END:
+            _mdns_browse_item_free(action->data.browse_add.browse);
+            break;
+        case ACTION_BROWSE_SYNC:
+            _mdns_sync_browse_result_link_free(action->data.browse_sync.browse_sync);
+            break;
+        default:
+            abort();
+        }
+        return;
+    }
+
+}

components/mdns/mdns_browser.c

@@ -18,6 +18,9 @@
 #include "mdns_netif.h"
 #include "mdns_send.h"
 #include "mdns_responder.h"
+
+static const char *TAG = "mdns_netif";
+
 #if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH
 #include "esp_eth.h"
 #endif
@@ -169,6 +172,27 @@ static mdns_if_t _mdns_get_if_from_esp_netif(esp_netif_t *esp_netif)
     return MDNS_MAX_INTERFACES;
 }
 
+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) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    mdns_action_t *action = (mdns_action_t *)mdns_mem_calloc(1, sizeof(mdns_action_t));
+    if (!action) {
+        HOOK_MALLOC_FAILED;
+        return ESP_ERR_NO_MEM;
+    }
+    action->type = ACTION_SYSTEM_EVENT;
+    action->data.sys_event.event_action = event_action;
+    action->data.sys_event.interface = mdns_if;
+
+    if (mdns_action_queue(action)) {
+        mdns_mem_free(action);
+    }
+    return ESP_OK;
+}
+
 
 /**
  * @brief  Dispatch interface changes based on system events
@@ -395,7 +419,7 @@ 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) && !_ipv6_address_is_zero(tmp_addr6)) {
+        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);
         }
 #endif

components/mdns/mdns_netif.c

@@ -21,6 +21,7 @@
 #include "mdns_networking.h"
 #include "esp_netif_net_stack.h"
 #include "mdns_mem_caps.h"
+#include "mdns_utils.h"
 
 /*
  * MDNS Server Networking
@@ -44,6 +45,25 @@ static const char *TAG = "mdns_networking";
 
 static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip_addr_t *raddr, uint16_t rport);
 
+static esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet)
+{
+    mdns_action_t *action = NULL;
+
+    action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t));
+    if (!action) {
+        HOOK_MALLOC_FAILED;
+        return ESP_ERR_NO_MEM;
+    }
+
+    action->type = ACTION_RX_HANDLE;
+    action->data.rx_handle.packet = packet;
+    if (!mdns_action_queue(action)) {
+        mdns_mem_free(action);
+        return ESP_ERR_NO_MEM;
+    }
+    return ESP_OK;
+}
+
 /**
  * @brief  Low level UDP PCB Initialize
  */

components/mdns/mdns_networking_lwip.c

@@ -22,6 +22,7 @@
 #include <sys/param.h>
 #include "esp_log.h"
 #include "mdns_mem_caps.h"
+#include "mdns_utils.h"
 
 #if defined(CONFIG_IDF_TARGET_LINUX)
 #include <sys/ioctl.h>
@@ -58,6 +59,26 @@ struct pbuf  {
 #define s6_addr32 un.u32_addr
 #endif // CONFIG_IDF_TARGET_LINUX
 
+static esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet)
+{
+    mdns_action_t *action = NULL;
+
+    action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t));
+    if (!action) {
+        HOOK_MALLOC_FAILED;
+        return ESP_ERR_NO_MEM;
+    }
+
+    action->type = ACTION_RX_HANDLE;
+    action->data.rx_handle.packet = packet;
+    if (!mdns_action_queue(action)) {
+        mdns_mem_free(action);
+        return ESP_ERR_NO_MEM;
+    }
+    return ESP_OK;
+}
+
+
 static void __attribute__((constructor)) ctor_networking_socket(void)
 {
     for (int i = 0; i < sizeof(s_interfaces) / sizeof(s_interfaces[0]); ++i) {

components/mdns/mdns_networking_socket.c

@@ -20,6 +20,29 @@
 
 static const char *TAG = "mdns_packet";
 
+/**4
+ * @brief  Browse sync result action -> TODO: Move to the browser module
+ */
+static esp_err_t _mdns_sync_browse_action(mdns_action_type_t type, mdns_browse_sync_t *browse_sync)
+{
+    mdns_action_t *action = NULL;
+
+    action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t));
+    if (!action) {
+        HOOK_MALLOC_FAILED;
+        return ESP_ERR_NO_MEM;
+    }
+
+    action->type = type;
+    action->data.browse_sync.browse_sync = browse_sync;
+    if (!mdns_action_queue(action)) {
+        mdns_mem_free(action);
+        return ESP_ERR_NO_MEM;
+    }
+    return ESP_OK;
+}
+
+
 /**
  * @brief  Check if parsed name is discovery
  */
@@ -697,7 +720,7 @@ static int _mdns_check_aaaa_collision(esp_ip6_addr_t *ip, mdns_if_t tcpip_if)
 {
     struct esp_ip6_addr if_ip6;
     struct esp_ip6_addr other_ip6;
-    if (_ipv6_address_is_zero(*ip)) {
+    if (mdns_utils_ipv6_address_is_zero(*ip)) {
         return 1;//denial! they win
     }
     if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(tcpip_if), &if_ip6)) {
@@ -1110,8 +1133,9 @@ static mdns_result_t *_mdns_search_result_add_ptr(mdns_search_once_t *search, co
     return NULL;
 }
 
-
-
+/*
+ * Received Packet Handling
+ * */
 
 /**
  * @brief  main packet parser
@@ -1780,3 +1804,16 @@ void mdns_parse_packet(mdns_rx_packet_t *packet)
     mdns_mem_free(browse_result_proto);
     mdns_mem_free(out_sync_browse);
 }
+
+void mdns_receive_action(mdns_action_t *action, mdns_action_subtype_t type)
+{
+    if (action->type != ACTION_RX_HANDLE) {
+        abort();
+    }
+    if (type == ACTION_RUN) {
+        mdns_parse_packet(action->data.rx_handle.packet);
+        _mdns_packet_free(action->data.rx_handle.packet);
+    } else if (type == ACTION_CLEANUP) {
+        _mdns_packet_free(action->data.rx_handle.packet);
+    }
+}