Merge pull request #529 from zwx1995esp/fix/add_lock_for_mdns_common_api

gabsuren · web-flow · commit 4e844936b7e9 · 2024-03-15T11:14:16.000+04:00
fix(mdns): add lock for some common apis (IDFGH-12338)
diff --git a/components/mdns/mdns.c b/components/mdns/mdns.c
@@ -72,6 +72,7 @@ static bool _mdns_append_host_list(mdns_out_answer_t **destination, bool flush,
 static void _mdns_remap_self_service_hostname(const char *old_hostname, const char *new_hostname);
 static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_actions_t event_action);
 
+static void _mdns_query_results_free(mdns_result_t *results);
 typedef enum {
     MDNS_IF_STA = 0,
     MDNS_IF_AP = 1,
@@ -5600,7 +5601,7 @@ void mdns_free(void)
         free(h->proto);
         vSemaphoreDelete(h->done_semaphore);
         if (h->result) {
-            mdns_query_results_free(h->result);
+            _mdns_query_results_free(h->result);
         }
         free(h);
     }
@@ -5748,7 +5749,11 @@ esp_err_t mdns_delegate_hostname_set_address(const char *hostname, const mdns_ip
 
 bool mdns_hostname_exists(const char *hostname)
 {
-    return _hostname_is_ours(hostname);
+    bool ret = false;
+    MDNS_SERVICE_LOCK();
+    ret = _hostname_is_ours(hostname);
+    MDNS_SERVICE_UNLOCK();
+    return ret;
 }
 
 esp_err_t mdns_instance_name_set(const char *instance)
@@ -5791,11 +5796,14 @@ esp_err_t mdns_service_add_for_host(const char *instance, const char *service, c
         return ESP_ERR_INVALID_ARG;
     }
 
+    MDNS_SERVICE_LOCK();
     if (!_mdns_can_add_more_services()) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_NO_MEM;
     }
 
     mdns_srv_item_t *item = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (item) {
         return ESP_ERR_INVALID_ARG;
     }
@@ -5833,12 +5841,18 @@ esp_err_t mdns_service_add_for_host(const char *instance, const char *service, c
 
     size_t start = xTaskGetTickCount();
     size_t timeout_ticks = pdMS_TO_TICKS(MDNS_SERVICE_ADD_TIMEOUT_MS);
-    while (_mdns_get_service_item_instance(instance, service, proto, hostname) == NULL) {
+    MDNS_SERVICE_LOCK();
+    mdns_srv_item_t *target = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
+    while (target == NULL) {
         uint32_t expired = xTaskGetTickCount() - start;
         if (expired >= timeout_ticks) {
             return ESP_FAIL; // Timeout
         }
         vTaskDelay(MIN(10 / portTICK_PERIOD_MS, timeout_ticks - expired));
+        MDNS_SERVICE_LOCK();
+        target = _mdns_get_service_item_instance(instance, service, proto, hostname);
+        MDNS_SERVICE_UNLOCK();
     }
 
     return ESP_OK;
@@ -5855,13 +5869,21 @@ esp_err_t mdns_service_add(const char *instance, const char *service, const char
 
 bool mdns_service_exists(const char *service_type, const char *proto, const char *hostname)
 {
-    return _mdns_get_service_item(service_type, proto, hostname) != NULL;
+    bool ret = false;
+    MDNS_SERVICE_LOCK();
+    ret = _mdns_get_service_item(service_type, proto, hostname) != NULL;
+    MDNS_SERVICE_UNLOCK();
+    return ret;
 }
 
 bool mdns_service_exists_with_instance(const char *instance, const char *service_type, const char *proto,
                                        const char *hostname)
 {
-    return _mdns_get_service_item_instance(instance, service_type, proto, hostname) != NULL;
+    bool ret = false;
+    MDNS_SERVICE_LOCK();
+    ret = _mdns_get_service_item_instance(instance, service_type, proto, hostname) != NULL;
+    MDNS_SERVICE_UNLOCK();
+    return ret;
 }
 
 static mdns_txt_item_t *_copy_mdns_txt_items(mdns_txt_linked_item_t *items, uint8_t **txt_value_len, size_t *txt_count)
@@ -6001,16 +6023,19 @@ static mdns_result_t *_mdns_lookup_service(const char *instance, const char *ser
     }
     return results;
 handle_error:
-    mdns_query_results_free(results);
+    _mdns_query_results_free(results);
     return NULL;
 }
 
 esp_err_t mdns_service_port_set_for_host(const char *instance, const char *service, const char *proto, const char *hostname, uint16_t port)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || !port) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6041,10 +6066,13 @@ esp_err_t mdns_service_port_set(const char *service, const char *proto, uint16_t
 esp_err_t mdns_service_txt_set_for_host(const char *instance, const char *service, const char *proto, const char *hostname,
                                         mdns_txt_item_t txt[], uint8_t num_items)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || (num_items && txt == NULL)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6087,11 +6115,14 @@ esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char
         const char *hostname, const char *key,
         const char *value, uint8_t value_len)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) ||
             _str_null_or_empty(key) || (!value && value_len)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6160,10 +6191,13 @@ esp_err_t mdns_service_txt_item_set_with_explicit_value_len(const char *service,
 esp_err_t mdns_service_txt_item_remove_for_host(const char *instance, const char *service, const char *proto, const char *hostname,
         const char *key)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) || _str_null_or_empty(key)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6199,11 +6233,14 @@ esp_err_t mdns_service_txt_item_remove(const char *service, const char *proto, c
 esp_err_t mdns_service_subtype_add_for_host(const char *instance_name, const char *service, const char *proto,
         const char *hostname, const char *subtype)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto) ||
             _str_null_or_empty(subtype)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_name, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6232,13 +6269,17 @@ esp_err_t mdns_service_subtype_add_for_host(const char *instance_name, const cha
 esp_err_t mdns_service_instance_name_set_for_host(const char *instance_old, const char *service, const char *proto, const char *hostname,
         const char *instance)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     if (_str_null_or_empty(instance) || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_old, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6274,10 +6315,13 @@ esp_err_t mdns_service_instance_name_set(const char *service, const char *proto,
 
 esp_err_t mdns_service_remove_for_host(const char *instance, const char *service, const char *proto, const char *hostname)
 {
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server || !_mdns_server->services || _str_null_or_empty(service) || _str_null_or_empty(proto)) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_ERR_INVALID_ARG;
     }
     mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);
+    MDNS_SERVICE_UNLOCK();
     if (!s) {
         return ESP_ERR_NOT_FOUND;
     }
@@ -6309,9 +6353,12 @@ esp_err_t mdns_service_remove_all(void)
     if (!_mdns_server) {
         return ESP_ERR_INVALID_ARG;
     }
+    MDNS_SERVICE_LOCK();
     if (!_mdns_server->services) {
+        MDNS_SERVICE_UNLOCK();
         return ESP_OK;
     }
+    MDNS_SERVICE_UNLOCK();
 
     mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t));
     if (!action) {
@@ -6329,8 +6376,14 @@ esp_err_t mdns_service_remove_all(void)
 /*
  * MDNS QUERY
  * */
-
 void mdns_query_results_free(mdns_result_t *results)
+{
+    MDNS_SERVICE_LOCK();
+    _mdns_query_results_free(results);
+    MDNS_SERVICE_UNLOCK();
+}
+
+static void _mdns_query_results_free(mdns_result_t *results)
 {
     mdns_result_t *r;
     mdns_ip_addr_t *a;

Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,7 @@ static bool _mdns_append_host_list(mdns_out_answer_t **destination, bool flush,`
`72`	`72`	`static void _mdns_remap_self_service_hostname(const char old_hostname, const char new_hostname);`
`73`	`73`	`static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_actions_t event_action);`
`74`	`74`
	`75`	`+static void _mdns_query_results_free(mdns_result_t *results);`
`75`	`76`	`typedef enum {`
`76`	`77`	`MDNS_IF_STA = 0,`
`77`	`78`	`MDNS_IF_AP = 1,`
`@@ -5600,7 +5601,7 @@ void mdns_free(void)`
`5600`	`5601`	`free(h->proto);`
`5601`	`5602`	`vSemaphoreDelete(h->done_semaphore);`
`5602`	`5603`	`if (h->result) {`
`5603`		`- mdns_query_results_free(h->result);`
	`5604`	`+ _mdns_query_results_free(h->result);`
`5604`	`5605`	`}`
`5605`	`5606`	`free(h);`
`5606`	`5607`	`}`
`@@ -5748,7 +5749,11 @@ esp_err_t mdns_delegate_hostname_set_address(const char *hostname, const mdns_ip`
`5748`	`5749`
`5749`	`5750`	`bool mdns_hostname_exists(const char *hostname)`
`5750`	`5751`	`{`
`5751`		`- return _hostname_is_ours(hostname);`
	`5752`	`+ bool ret = false;`
	`5753`	`+ MDNS_SERVICE_LOCK();`
	`5754`	`+ ret = _hostname_is_ours(hostname);`
	`5755`	`+ MDNS_SERVICE_UNLOCK();`
	`5756`	`+ return ret;`
`5752`	`5757`	`}`
`5753`	`5758`
`5754`	`5759`	`esp_err_t mdns_instance_name_set(const char *instance)`
`@@ -5791,11 +5796,14 @@ esp_err_t mdns_service_add_for_host(const char instance, const char service, c`
`5791`	`5796`	`return ESP_ERR_INVALID_ARG;`
`5792`	`5797`	`}`
`5793`	`5798`
	`5799`	`+ MDNS_SERVICE_LOCK();`
`5794`	`5800`	`if (!_mdns_can_add_more_services()) {`
	`5801`	`+ MDNS_SERVICE_UNLOCK();`
`5795`	`5802`	`return ESP_ERR_NO_MEM;`
`5796`	`5803`	`}`
`5797`	`5804`
`5798`	`5805`	`mdns_srv_item_t *item = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`5806`	`+ MDNS_SERVICE_UNLOCK();`
`5799`	`5807`	`if (item) {`
`5800`	`5808`	`return ESP_ERR_INVALID_ARG;`
`5801`	`5809`	`}`
`@@ -5833,12 +5841,18 @@ esp_err_t mdns_service_add_for_host(const char instance, const char service, c`
`5833`	`5841`
`5834`	`5842`	`size_t start = xTaskGetTickCount();`
`5835`	`5843`	`size_t timeout_ticks = pdMS_TO_TICKS(MDNS_SERVICE_ADD_TIMEOUT_MS);`
`5836`		`- while (_mdns_get_service_item_instance(instance, service, proto, hostname) == NULL) {`
	`5844`	`+ MDNS_SERVICE_LOCK();`
	`5845`	`+ mdns_srv_item_t *target = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`5846`	`+ MDNS_SERVICE_UNLOCK();`
	`5847`	`+ while (target == NULL) {`
`5837`	`5848`	`uint32_t expired = xTaskGetTickCount() - start;`
`5838`	`5849`	`if (expired >= timeout_ticks) {`
`5839`	`5850`	`return ESP_FAIL; // Timeout`
`5840`	`5851`	`}`
`5841`	`5852`	`vTaskDelay(MIN(10 / portTICK_PERIOD_MS, timeout_ticks - expired));`
	`5853`	`+ MDNS_SERVICE_LOCK();`
	`5854`	`+ target = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`5855`	`+ MDNS_SERVICE_UNLOCK();`
`5842`	`5856`	`}`
`5843`	`5857`
`5844`	`5858`	`return ESP_OK;`
`@@ -5855,13 +5869,21 @@ esp_err_t mdns_service_add(const char instance, const char service, const char`
`5855`	`5869`
`5856`	`5870`	`bool mdns_service_exists(const char service_type, const char proto, const char *hostname)`
`5857`	`5871`	`{`
`5858`		`- return _mdns_get_service_item(service_type, proto, hostname) != NULL;`
	`5872`	`+ bool ret = false;`
	`5873`	`+ MDNS_SERVICE_LOCK();`
	`5874`	`+ ret = _mdns_get_service_item(service_type, proto, hostname) != NULL;`
	`5875`	`+ MDNS_SERVICE_UNLOCK();`
	`5876`	`+ return ret;`
`5859`	`5877`	`}`
`5860`	`5878`
`5861`	`5879`	`bool mdns_service_exists_with_instance(const char instance, const char service_type, const char *proto,`
`5862`	`5880`	`const char *hostname)`
`5863`	`5881`	`{`
`5864`		`- return _mdns_get_service_item_instance(instance, service_type, proto, hostname) != NULL;`
	`5882`	`+ bool ret = false;`
	`5883`	`+ MDNS_SERVICE_LOCK();`
	`5884`	`+ ret = _mdns_get_service_item_instance(instance, service_type, proto, hostname) != NULL;`
	`5885`	`+ MDNS_SERVICE_UNLOCK();`
	`5886`	`+ return ret;`
`5865`	`5887`	`}`
`5866`	`5888`
`5867`	`5889`	`static mdns_txt_item_t _copy_mdns_txt_items(mdns_txt_linked_item_t items, uint8_t *txt_value_len, size_t txt_count)`
`@@ -6001,16 +6023,19 @@ static mdns_result_t _mdns_lookup_service(const char instance, const char *ser`
`6001`	`6023`	`}`
`6002`	`6024`	`return results;`
`6003`	`6025`	`handle_error:`
`6004`		`- mdns_query_results_free(results);`
	`6026`	`+ _mdns_query_results_free(results);`
`6005`	`6027`	`return NULL;`
`6006`	`6028`	`}`
`6007`	`6029`
`6008`	`6030`	`esp_err_t mdns_service_port_set_for_host(const char instance, const char service, const char proto, const char hostname, uint16_t port)`
`6009`	`6031`	`{`
	`6032`	`+ MDNS_SERVICE_LOCK();`
`6010`	`6033`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto) \|\| !port) {`
	`6034`	`+ MDNS_SERVICE_UNLOCK();`
`6011`	`6035`	`return ESP_ERR_INVALID_ARG;`
`6012`	`6036`	`}`
`6013`	`6037`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`6038`	`+ MDNS_SERVICE_UNLOCK();`
`6014`	`6039`	`if (!s) {`
`6015`	`6040`	`return ESP_ERR_NOT_FOUND;`
`6016`	`6041`	`}`
`@@ -6041,10 +6066,13 @@ esp_err_t mdns_service_port_set(const char service, const char proto, uint16_t`
`6041`	`6066`	`esp_err_t mdns_service_txt_set_for_host(const char instance, const char service, const char proto, const char hostname,`
`6042`	`6067`	`mdns_txt_item_t txt[], uint8_t num_items)`
`6043`	`6068`	`{`
	`6069`	`+ MDNS_SERVICE_LOCK();`
`6044`	`6070`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto) \|\| (num_items && txt == NULL)) {`
	`6071`	`+ MDNS_SERVICE_UNLOCK();`
`6045`	`6072`	`return ESP_ERR_INVALID_ARG;`
`6046`	`6073`	`}`
`6047`	`6074`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`6075`	`+ MDNS_SERVICE_UNLOCK();`
`6048`	`6076`	`if (!s) {`
`6049`	`6077`	`return ESP_ERR_NOT_FOUND;`
`6050`	`6078`	`}`
`@@ -6087,11 +6115,14 @@ esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char`
`6087`	`6115`	`const char hostname, const char key,`
`6088`	`6116`	`const char *value, uint8_t value_len)`
`6089`	`6117`	`{`
	`6118`	`+ MDNS_SERVICE_LOCK();`
`6090`	`6119`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto) \|\|`
`6091`	`6120`	`_str_null_or_empty(key) \|\| (!value && value_len)) {`
	`6121`	`+ MDNS_SERVICE_UNLOCK();`
`6092`	`6122`	`return ESP_ERR_INVALID_ARG;`
`6093`	`6123`	`}`
`6094`	`6124`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`6125`	`+ MDNS_SERVICE_UNLOCK();`
`6095`	`6126`	`if (!s) {`
`6096`	`6127`	`return ESP_ERR_NOT_FOUND;`
`6097`	`6128`	`}`
`@@ -6160,10 +6191,13 @@ esp_err_t mdns_service_txt_item_set_with_explicit_value_len(const char *service,`
`6160`	`6191`	`esp_err_t mdns_service_txt_item_remove_for_host(const char instance, const char service, const char proto, const char hostname,`
`6161`	`6192`	`const char *key)`
`6162`	`6193`	`{`
	`6194`	`+ MDNS_SERVICE_LOCK();`
`6163`	`6195`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto) \|\| _str_null_or_empty(key)) {`
	`6196`	`+ MDNS_SERVICE_UNLOCK();`
`6164`	`6197`	`return ESP_ERR_INVALID_ARG;`
`6165`	`6198`	`}`
`6166`	`6199`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`6200`	`+ MDNS_SERVICE_UNLOCK();`
`6167`	`6201`	`if (!s) {`
`6168`	`6202`	`return ESP_ERR_NOT_FOUND;`
`6169`	`6203`	`}`
`@@ -6199,11 +6233,14 @@ esp_err_t mdns_service_txt_item_remove(const char service, const char proto, c`
`6199`	`6233`	`esp_err_t mdns_service_subtype_add_for_host(const char instance_name, const char service, const char *proto,`
`6200`	`6234`	`const char hostname, const char subtype)`
`6201`	`6235`	`{`
	`6236`	`+ MDNS_SERVICE_LOCK();`
`6202`	`6237`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto) \|\|`
`6203`	`6238`	`_str_null_or_empty(subtype)) {`
	`6239`	`+ MDNS_SERVICE_UNLOCK();`
`6204`	`6240`	`return ESP_ERR_INVALID_ARG;`
`6205`	`6241`	`}`
`6206`	`6242`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_name, service, proto, hostname);`
	`6243`	`+ MDNS_SERVICE_UNLOCK();`
`6207`	`6244`	`if (!s) {`
`6208`	`6245`	`return ESP_ERR_NOT_FOUND;`
`6209`	`6246`	`}`
`@@ -6232,13 +6269,17 @@ esp_err_t mdns_service_subtype_add_for_host(const char *instance_name, const cha`
`6232`	`6269`	`esp_err_t mdns_service_instance_name_set_for_host(const char instance_old, const char service, const char proto, const char hostname,`
`6233`	`6270`	`const char *instance)`
`6234`	`6271`	`{`
	`6272`	`+ MDNS_SERVICE_LOCK();`
`6235`	`6273`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto)) {`
	`6274`	`+ MDNS_SERVICE_UNLOCK();`
`6236`	`6275`	`return ESP_ERR_INVALID_ARG;`
`6237`	`6276`	`}`
`6238`	`6277`	`if (_str_null_or_empty(instance) \|\| strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) {`
	`6278`	`+ MDNS_SERVICE_UNLOCK();`
`6239`	`6279`	`return ESP_ERR_INVALID_ARG;`
`6240`	`6280`	`}`
`6241`	`6281`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_old, service, proto, hostname);`
	`6282`	`+ MDNS_SERVICE_UNLOCK();`
`6242`	`6283`	`if (!s) {`
`6243`	`6284`	`return ESP_ERR_NOT_FOUND;`
`6244`	`6285`	`}`
`@@ -6274,10 +6315,13 @@ esp_err_t mdns_service_instance_name_set(const char service, const char proto,`
`6274`	`6315`
`6275`	`6316`	`esp_err_t mdns_service_remove_for_host(const char instance, const char service, const char proto, const char hostname)`
`6276`	`6317`	`{`
	`6318`	`+ MDNS_SERVICE_LOCK();`
`6277`	`6319`	`if (!_mdns_server \|\| !_mdns_server->services \|\| _str_null_or_empty(service) \|\| _str_null_or_empty(proto)) {`
	`6320`	`+ MDNS_SERVICE_UNLOCK();`
`6278`	`6321`	`return ESP_ERR_INVALID_ARG;`
`6279`	`6322`	`}`
`6280`	`6323`	`mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname);`
	`6324`	`+ MDNS_SERVICE_UNLOCK();`
`6281`	`6325`	`if (!s) {`
`6282`	`6326`	`return ESP_ERR_NOT_FOUND;`
`6283`	`6327`	`}`
`@@ -6309,9 +6353,12 @@ esp_err_t mdns_service_remove_all(void)`
`6309`	`6353`	`if (!_mdns_server) {`
`6310`	`6354`	`return ESP_ERR_INVALID_ARG;`
`6311`	`6355`	`}`
	`6356`	`+ MDNS_SERVICE_LOCK();`
`6312`	`6357`	`if (!_mdns_server->services) {`
	`6358`	`+ MDNS_SERVICE_UNLOCK();`
`6313`	`6359`	`return ESP_OK;`
`6314`	`6360`	`}`
	`6361`	`+ MDNS_SERVICE_UNLOCK();`
`6315`	`6362`
`6316`	`6363`	`mdns_action_t action = (mdns_action_t )malloc(sizeof(mdns_action_t));`
`6317`	`6364`	`if (!action) {`
`@@ -6329,8 +6376,14 @@ esp_err_t mdns_service_remove_all(void)`
`6329`	`6376`	`/*`
`6330`	`6377`	`* MDNS QUERY`
`6331`	`6378`	`* */`
`6332`		`-`
`6333`	`6379`	`void mdns_query_results_free(mdns_result_t *results)`
	`6380`	`+{`
	`6381`	`+ MDNS_SERVICE_LOCK();`
	`6382`	`+ _mdns_query_results_free(results);`
	`6383`	`+ MDNS_SERVICE_UNLOCK();`
	`6384`	`+}`
	`6385`	`+`
	`6386`	`+static void _mdns_query_results_free(mdns_result_t *results)`
`6334`	`6387`	`{`
`6335`	`6388`	`mdns_result_t *r;`
`6336`	`6389`	`mdns_ip_addr_t *a;`