fix(mdns): Cleanup querier and pcb

Author: david-cermak

components/mdns/mdns_browser.c

@@ -90,7 +90,7 @@ static void browse_send(mdns_browse_t *browse, mdns_if_t interface)
     search.next = NULL;
 
     for (uint8_t protocol_idx = 0; protocol_idx < MDNS_IP_PROTOCOL_MAX; protocol_idx++) {
-        _mdns_search_send_pcb(&search, interface, (mdns_ip_protocol_t)protocol_idx);
+        mdns_priv_query_send(&search, interface, (mdns_ip_protocol_t) protocol_idx);
     }
 }
 

components/mdns/mdns_networking_lwip.c

@@ -38,13 +38,13 @@ typedef struct interfaces {
 
 static interfaces_t s_interfaces[MDNS_MAX_INTERFACES];
 
-static struct udp_pcb *_pcb_main = NULL;
+static struct udp_pcb *s_pcb_main = NULL;
 
 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 void receive(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)
+static esp_err_t send_rx_action(mdns_rx_packet_t *packet)
 {
     mdns_action_t *action = NULL;
 
@@ -66,44 +66,44 @@ static esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet)
 /**
  * @brief  Low level UDP PCB Initialize
  */
-static esp_err_t _udp_pcb_main_init(void)
+static esp_err_t pcb_init(void)
 {
-    if (_pcb_main) {
+    if (s_pcb_main) {
         return ESP_OK;
     }
-    _pcb_main = udp_new();
-    if (!_pcb_main) {
+    s_pcb_main = udp_new();
+    if (!s_pcb_main) {
         return ESP_ERR_NO_MEM;
     }
-    if (udp_bind(_pcb_main, IP_ANY_TYPE, MDNS_SERVICE_PORT) != 0) {
-        udp_remove(_pcb_main);
-        _pcb_main = NULL;
+    if (udp_bind(s_pcb_main, IP_ANY_TYPE, MDNS_SERVICE_PORT) != 0) {
+        udp_remove(s_pcb_main);
+        s_pcb_main = NULL;
         return ESP_ERR_INVALID_STATE;
     }
-    _pcb_main->mcast_ttl = 255;
-    _pcb_main->remote_port = MDNS_SERVICE_PORT;
-    ip_addr_copy(_pcb_main->remote_ip, *(IP_ANY_TYPE));
-    udp_recv(_pcb_main, &_udp_recv, NULL);
+    s_pcb_main->mcast_ttl = 255;
+    s_pcb_main->remote_port = MDNS_SERVICE_PORT;
+    ip_addr_copy(s_pcb_main->remote_ip, *(IP_ANY_TYPE));
+    udp_recv(s_pcb_main, receive, NULL);
     return ESP_OK;
 }
 
 /**
  * @brief  Low level UDP PCB Free
  */
-static void _udp_pcb_main_deinit(void)
+static void pcb_deinit(void)
 {
-    if (_pcb_main) {
-        udp_recv(_pcb_main, NULL, NULL);
-        udp_disconnect(_pcb_main);
-        udp_remove(_pcb_main);
-        _pcb_main = NULL;
+    if (s_pcb_main) {
+        udp_recv(s_pcb_main, NULL, NULL);
+        udp_disconnect(s_pcb_main);
+        udp_remove(s_pcb_main);
+        s_pcb_main = NULL;
     }
 }
 
 /**
  * @brief  Low level UDP Multicast membership control
  */
-static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protocol, bool join)
+static esp_err_t join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protocol, bool join)
 {
     struct netif *netif = NULL;
     esp_netif_t *tcpip_if = mdns_priv_get_esp_netif(if_inx);
@@ -154,7 +154,7 @@ static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protoco
  * @brief  the receive callback of the raw udp api. Packets are received here
  *
  */
-static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip_addr_t *raddr, uint16_t rport)
+static void receive(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip_addr_t *raddr, uint16_t rport)
 {
 
     uint8_t i;
@@ -223,7 +223,7 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip
             }
         }
 
-        if (!found || _mdns_send_rx_action(packet) != ESP_OK) {
+        if (!found || send_rx_action(packet) != ESP_OK) {
             pbuf_free(this_pb);
             mdns_mem_free(packet);
         }
@@ -240,7 +240,7 @@ bool mdns_priv_if_ready(mdns_if_t netif, mdns_ip_protocol_t ip_proto)
 /**
  * @brief  Check if any of the interfaces is up
  */
-static bool _udp_pcb_is_in_use(void)
+static bool is_any_pcb_in_use(void)
 {
     int i, p;
     for (i = 0; i < MDNS_MAX_INTERFACES; i++) {
@@ -256,33 +256,33 @@ static bool _udp_pcb_is_in_use(void)
 /**
  * @brief  Stop PCB Main code
  */
-static void _udp_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+static void pcb_if_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
 {
     s_interfaces[tcpip_if].proto &= ~(ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6);
     if (s_interfaces[tcpip_if].proto == 0) {
         s_interfaces[tcpip_if].ready = false;
-        _udp_join_group(tcpip_if, ip_protocol, false);
-        if (!_udp_pcb_is_in_use()) {
-            _udp_pcb_main_deinit();
+        join_group(tcpip_if, ip_protocol, false);
+        if (!is_any_pcb_in_use()) {
+            pcb_deinit();
         }
     }
 }
 
 /**
  * @brief  Start PCB Main code
  */
-static esp_err_t _udp_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+static esp_err_t pcb_if_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
 {
     if (mdns_priv_if_ready(tcpip_if, ip_protocol)) {
         return ESP_ERR_INVALID_STATE;
     }
 
-    esp_err_t err = _udp_join_group(tcpip_if, ip_protocol, true);
+    esp_err_t err = join_group(tcpip_if, ip_protocol, true);
     if (err) {
         return err;
     }
 
-    err = _udp_pcb_main_init();
+    err = pcb_init();
     if (err) {
         return err;
     }
@@ -305,20 +305,20 @@ typedef struct {
 /**
  * @brief  Start PCB from LwIP thread
  */
-static err_t mdns_priv_if_init_api(struct tcpip_api_call_data *api_call_msg)
+static err_t pcb_if_init_lwip(struct tcpip_api_call_data *api_call_msg)
 {
     mdns_api_call_t *msg = (mdns_api_call_t *)api_call_msg;
-    msg->err = _udp_pcb_init(msg->tcpip_if, msg->ip_protocol) == ESP_OK ? ERR_OK : ERR_IF;
-    return msg->err;
+    msg->err = pcb_if_init(msg->tcpip_if, msg->ip_protocol);
+    return msg->err == ESP_OK ? ERR_OK : ERR_IF;
 }
 
 /**
  * @brief  Stop PCB from LwIP thread
  */
-static err_t mdns_priv_if_deinit_api(struct tcpip_api_call_data *api_call_msg)
+static err_t pcb_if_deinit_lwip(struct tcpip_api_call_data *api_call_msg)
 {
     mdns_api_call_t *msg = (mdns_api_call_t *)api_call_msg;
-    _udp_pcb_deinit(msg->tcpip_if, msg->ip_protocol);
+    pcb_if_deinit(msg->tcpip_if, msg->ip_protocol);
     msg->err = ESP_OK;
     return ESP_OK;
 }
@@ -334,7 +334,7 @@ esp_err_t mdns_priv_if_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
         .tcpip_if = tcpip_if,
         .ip_protocol = ip_protocol
     };
-    tcpip_api_call(mdns_priv_if_init_api, &msg.call);
+    tcpip_api_call(pcb_if_init_lwip, &msg.call);
     return msg.err;
 }
 
@@ -344,23 +344,23 @@ esp_err_t mdns_priv_if_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol
         .tcpip_if = tcpip_if,
         .ip_protocol = ip_protocol
     };
-    tcpip_api_call(mdns_priv_if_deinit_api, &msg.call);
+    tcpip_api_call(pcb_if_deinit_lwip, &msg.call);
     return msg.err;
 }
 
-static err_t mdns_priv_if_write_api(struct tcpip_api_call_data *api_call_msg)
+static err_t write_if_lwip(struct tcpip_api_call_data *api_call_msg)
 {
     void *nif = NULL;
     mdns_api_call_t *msg = (mdns_api_call_t *)api_call_msg;
     nif = esp_netif_get_netif_impl(mdns_priv_get_esp_netif(msg->tcpip_if));
-    if (!nif || !mdns_priv_if_ready(msg->tcpip_if, msg->ip_protocol) || _pcb_main == NULL) {
+    if (!nif || !mdns_priv_if_ready(msg->tcpip_if, msg->ip_protocol) || s_pcb_main == NULL) {
         pbuf_free(msg->pbt);
         msg->err = ERR_IF;
         return ERR_IF;
     }
-    esp_err_t err = udp_sendto_if(_pcb_main, msg->pbt, msg->ip, msg->port, (struct netif *)nif);
+    err_t err = udp_sendto_if(s_pcb_main, msg->pbt, msg->ip, msg->port, (struct netif *)nif);
     pbuf_free(msg->pbt);
-    msg->err = err;
+    msg->err = err == ERR_OK ? ESP_OK : ESP_FAIL;
     return err;
 }
 
@@ -392,7 +392,7 @@ size_t mdns_priv_if_write(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, co
         .ip = &ip_add_copy,
         .port = port
     };
-    tcpip_api_call(mdns_priv_if_write_api, &msg.call);
+    tcpip_api_call(write_if_lwip, &msg.call);
 
     if (msg.err) {
         return 0;