diff --git a/components/mdns/CMakeLists.txt b/components/mdns/CMakeLists.txt index e0b2a4d9e..405e9f785 100644 --- a/components/mdns/CMakeLists.txt +++ b/components/mdns/CMakeLists.txt @@ -10,15 +10,17 @@ else() set(MDNS_CONSOLE "") endif() +set(MDNS_MEMORY "mdns_mem_caps.c") + idf_build_get_property(target IDF_TARGET) if(${target} STREQUAL "linux") set(dependencies esp_netif_linux esp_event) set(private_dependencies esp_timer console esp_system) - set(srcs "mdns.c" ${MDNS_NETWORKING} ${MDNS_CONSOLE}) + set(srcs "mdns.c" ${MDNS_MEMORY} ${MDNS_NETWORKING} ${MDNS_CONSOLE}) else() set(dependencies lwip console esp_netif) set(private_dependencies esp_timer esp_wifi) - set(srcs "mdns.c" ${MDNS_NETWORKING} ${MDNS_CONSOLE}) + set(srcs "mdns.c" ${MDNS_MEMORY} ${MDNS_NETWORKING} ${MDNS_CONSOLE}) endif() idf_component_register( diff --git a/components/mdns/Kconfig b/components/mdns/Kconfig index 79080e533..7aa4eb862 100644 --- a/components/mdns/Kconfig +++ b/components/mdns/Kconfig @@ -71,6 +71,18 @@ menu "mDNS" bool "mDNS task creates on the internal RAM" endchoice + choice MDNS_MEMORY_ALLOC_FROM + prompt "Select mDNS memory allocation type" + default MDNS_MEMORY_ALLOC_INTERNAL + + config MDNS_MEMORY_ALLOC_SPIRAM + bool "Allocate mDNS memory from SPIRAM" + depends on (SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) + + config MDNS_MEMORY_ALLOC_INTERNAL + bool "Allocate mDNS memory from internal RAM" + endchoice + config MDNS_SERVICE_ADD_TIMEOUT_MS int "mDNS adding service timeout (ms)" range 10 30000 diff --git a/components/mdns/mdns.c b/components/mdns/mdns.c index 8739aeee9..c771cc70a 100644 --- a/components/mdns/mdns.c +++ b/components/mdns/mdns.c @@ -16,6 +16,7 @@ #include "mdns.h" #include "mdns_private.h" #include "mdns_networking.h" +#include "mdns_mem_caps.h" static void _mdns_browse_item_free(mdns_browse_t *browse); static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t *browse); @@ -247,7 +248,7 @@ static char *_mdns_mangle_name(char *in) char *ret; if (p == NULL) { //need to add -2 to string - ret = malloc(strlen(in) + 3); + ret = mdns_mem_malloc(strlen(in) + 3); if (ret == NULL) { HOOK_MALLOC_FAILED; return NULL; @@ -255,7 +256,7 @@ static char *_mdns_mangle_name(char *in) sprintf(ret, "%s-2", in); } else { size_t in_len = strlen(in); - ret = malloc(in_len + 2); //one extra byte in case 9-10 or 99-100 etc + ret = mdns_mem_malloc(in_len + 2); //one extra byte in case 9-10 or 99-100 etc if (ret == NULL) { HOOK_MALLOC_FAILED; return NULL; @@ -354,7 +355,7 @@ esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet) { mdns_action_t *action = NULL; - action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; @@ -363,7 +364,7 @@ esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet) action->type = ACTION_RX_HANDLE; action->data.rx_handle.packet = packet; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(action); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -1564,18 +1565,18 @@ static void _mdns_free_tx_packet(mdns_tx_packet_t *packet) while (q) { mdns_out_question_t *next = q->next; if (q->own_dynamic_memory) { - free((char *)q->host); - free((char *)q->service); - free((char *)q->proto); - free((char *)q->domain); + mdns_mem_free((char *)q->host); + mdns_mem_free((char *)q->service); + mdns_mem_free((char *)q->proto); + mdns_mem_free((char *)q->domain); } - free(q); + mdns_mem_free(q); q = next; } queueFree(mdns_out_answer_t, packet->answers); queueFree(mdns_out_answer_t, packet->servers); queueFree(mdns_out_answer_t, packet->additional); - free(packet); + mdns_mem_free(packet); } /** @@ -1679,13 +1680,13 @@ static void _mdns_remove_scheduled_answer(mdns_if_t tcpip_if, mdns_ip_protocol_t if (a) { if (a->type == type && a->service == service->service) { q->answers = q->answers->next; - free(a); + mdns_mem_free(a); } else { while (a->next) { if (a->next->type == type && a->next->service == service->service) { mdns_out_answer_t *b = a->next; a->next = b->next; - free(b); + mdns_mem_free(b); break; } a = a->next; @@ -1712,14 +1713,14 @@ static void _mdns_dealloc_answer(mdns_out_answer_t **destination, uint16_t type, } if (d->type == type && d->service == service->service) { *destination = d->next; - free(d); + mdns_mem_free(d); return; } while (d->next) { mdns_out_answer_t *a = d->next; if (a->type == type && a->service == service->service) { d->next = a->next; - free(a); + mdns_mem_free(a); return; } d = d->next; @@ -1740,7 +1741,7 @@ static bool _mdns_alloc_answer(mdns_out_answer_t **destination, uint16_t type, m d = d->next; } - mdns_out_answer_t *a = (mdns_out_answer_t *)malloc(sizeof(mdns_out_answer_t)); + mdns_out_answer_t *a = (mdns_out_answer_t *)mdns_mem_malloc(sizeof(mdns_out_answer_t)); if (!a) { HOOK_MALLOC_FAILED; return false; @@ -1761,7 +1762,7 @@ static bool _mdns_alloc_answer(mdns_out_answer_t **destination, uint16_t type, m */ static mdns_tx_packet_t *_mdns_alloc_packet_default(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) { - mdns_tx_packet_t *packet = (mdns_tx_packet_t *)malloc(sizeof(mdns_tx_packet_t)); + mdns_tx_packet_t *packet = (mdns_tx_packet_t *)mdns_mem_malloc(sizeof(mdns_tx_packet_t)); if (!packet) { HOOK_MALLOC_FAILED; return NULL; @@ -1958,7 +1959,7 @@ static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_ || q->type == MDNS_TYPE_PTR #endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ )) { - mdns_out_question_t *out_question = malloc(sizeof(mdns_out_question_t)); + mdns_out_question_t *out_question = mdns_mem_malloc(sizeof(mdns_out_question_t)); if (out_question == NULL) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); @@ -2069,7 +2070,7 @@ static bool _mdns_append_host_list(mdns_out_answer_t **destination, bool flush, static bool _mdns_append_host_question(mdns_out_question_t **questions, const char *hostname, bool unicast) { - mdns_out_question_t *q = (mdns_out_question_t *)malloc(sizeof(mdns_out_question_t)); + mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t)); if (!q) { HOOK_MALLOC_FAILED; return false; @@ -2083,7 +2084,7 @@ static bool _mdns_append_host_question(mdns_out_question_t **questions, const ch q->domain = MDNS_DEFAULT_DOMAIN; q->own_dynamic_memory = false; if (_mdns_question_exists(q, *questions)) { - free(q); + mdns_mem_free(q); } else { queueToEnd(mdns_out_question_t, *questions, q); } @@ -2117,7 +2118,7 @@ static mdns_tx_packet_t *_mdns_create_probe_packet(mdns_if_t tcpip_if, mdns_ip_p size_t i; for (i = 0; i < len; i++) { - mdns_out_question_t *q = (mdns_out_question_t *)malloc(sizeof(mdns_out_question_t)); + mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t)); if (!q) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); @@ -2132,7 +2133,7 @@ static mdns_tx_packet_t *_mdns_create_probe_packet(mdns_if_t tcpip_if, mdns_ip_p q->domain = MDNS_DEFAULT_DOMAIN; q->own_dynamic_memory = false; if (!q->host || _mdns_question_exists(q, packet->questions)) { - free(q); + mdns_mem_free(q); continue; } else { queueToEnd(mdns_out_question_t, packet->questions, q); @@ -2266,7 +2267,7 @@ static void _mdns_init_pcb_probe_new_service(mdns_if_t tcpip_if, mdns_ip_protoco } mdns_srv_item_t **_services = NULL; if (services_final_len) { - _services = (mdns_srv_item_t **)malloc(sizeof(mdns_srv_item_t *) * services_final_len); + _services = (mdns_srv_item_t **)mdns_mem_malloc(sizeof(mdns_srv_item_t *) * services_final_len); if (!_services) { HOOK_MALLOC_FAILED; return; @@ -2280,7 +2281,7 @@ static void _mdns_init_pcb_probe_new_service(mdns_if_t tcpip_if, mdns_ip_protoco for (i = 0; i < pcb->probe_services_len; i++) { _services[len + i] = pcb->probe_services[i]; } - free(pcb->probe_services); + mdns_mem_free(pcb->probe_services); } } @@ -2293,7 +2294,7 @@ static void _mdns_init_pcb_probe_new_service(mdns_if_t tcpip_if, mdns_ip_protoco mdns_tx_packet_t *packet = _mdns_create_probe_packet(tcpip_if, ip_protocol, _services, services_final_len, true, probe_ip); if (!packet) { - free(_services); + mdns_mem_free(_services); return; } @@ -2498,7 +2499,7 @@ static void _mdns_probe_all_pcbs(mdns_srv_item_t **services, size_t len, bool pr if (mdns_is_netif_ready(i, j)) { mdns_pcb_t *_pcb = &_mdns_server->interfaces[i].pcbs[j]; if (clear_old_probe) { - free(_pcb->probe_services); + mdns_mem_free(_pcb->probe_services); _pcb->probe_services = NULL; _pcb->probe_services_len = 0; _pcb->probe_running = false; @@ -2645,20 +2646,20 @@ static mdns_txt_linked_item_t *_mdns_allocate_txt(size_t num_items, mdns_txt_ite size_t i = 0; if (num_items) { for (i = 0; i < num_items; i++) { - mdns_txt_linked_item_t *new_item = (mdns_txt_linked_item_t *)malloc(sizeof(mdns_txt_linked_item_t)); + mdns_txt_linked_item_t *new_item = (mdns_txt_linked_item_t *)mdns_mem_malloc(sizeof(mdns_txt_linked_item_t)); if (!new_item) { HOOK_MALLOC_FAILED; break; } - new_item->key = strdup(txt[i].key); + new_item->key = mdns_mem_strdup(txt[i].key); if (!new_item->key) { - free(new_item); + mdns_mem_free(new_item); break; } - new_item->value = strdup(txt[i].value); + new_item->value = mdns_mem_strdup(txt[i].value); if (!new_item->value) { - free((char *)new_item->key); - free(new_item); + mdns_mem_free((char *)new_item->key); + mdns_mem_free(new_item); break; } new_item->value_len = strlen(new_item->value); @@ -2679,9 +2680,9 @@ static void _mdns_free_linked_txt(mdns_txt_linked_item_t *txt) while (txt) { t = txt; txt = txt->next; - free((char *)t->value); - free((char *)t->key); - free(t); + mdns_mem_free((char *)t->value); + mdns_mem_free((char *)t->key); + mdns_mem_free(t); } } @@ -2701,7 +2702,7 @@ static mdns_service_t *_mdns_create_service(const char *service, const char *pro uint16_t port, const char *instance, size_t num_items, mdns_txt_item_t txt[]) { - mdns_service_t *s = (mdns_service_t *)calloc(1, sizeof(mdns_service_t)); + mdns_service_t *s = (mdns_service_t *)mdns_mem_calloc(1, sizeof(mdns_service_t)); if (!s) { HOOK_MALLOC_FAILED; return NULL; @@ -2714,13 +2715,13 @@ static mdns_service_t *_mdns_create_service(const char *service, const char *pro s->priority = 0; s->weight = 0; - s->instance = instance ? strndup(instance, MDNS_NAME_BUF_LEN - 1) : NULL; + s->instance = instance ? mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1) : NULL; s->txt = new_txt; s->port = port; s->subtype = NULL; if (hostname) { - s->hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); + s->hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!s->hostname) { goto fail; } @@ -2728,12 +2729,12 @@ static mdns_service_t *_mdns_create_service(const char *service, const char *pro s->hostname = NULL; } - s->service = strndup(service, MDNS_NAME_BUF_LEN - 1); + s->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1); if (!s->service) { goto fail; } - s->proto = strndup(proto, MDNS_NAME_BUF_LEN - 1); + s->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1); if (!s->proto) { goto fail; } @@ -2741,11 +2742,11 @@ static mdns_service_t *_mdns_create_service(const char *service, const char *pro fail: _mdns_free_linked_txt(s->txt); - free((char *)s->instance); - free((char *)s->service); - free((char *)s->proto); - free((char *)s->hostname); - free(s); + mdns_mem_free((char *)s->instance); + mdns_mem_free((char *)s->service); + mdns_mem_free((char *)s->proto); + mdns_mem_free((char *)s->hostname); + mdns_mem_free(s); return NULL; } @@ -2761,14 +2762,14 @@ static void _mdns_dealloc_scheduled_service_answers(mdns_out_answer_t **destinat } while (d && d->service == service) { *destination = d->next; - free(d); + mdns_mem_free(d); d = *destination; } while (d && d->next) { mdns_out_answer_t *a = d->next; if (a->service == service) { d->next = a->next; - free(a); + mdns_mem_free(a); } else { d = d->next; } @@ -2813,7 +2814,7 @@ static void _mdns_remove_scheduled_service_packets(mdns_service_t *service) _pcb->probe_services_len--; } else { _pcb->probe_services_len = 0; - free(_pcb->probe_services); + mdns_mem_free(_pcb->probe_services); _pcb->probe_services = NULL; if (!_pcb->probe_ip) { _pcb->probe_running = false; @@ -2828,14 +2829,14 @@ static void _mdns_remove_scheduled_service_packets(mdns_service_t *service) && qs->service && strcmp(qs->service, service->service) == 0 && qs->proto && strcmp(qs->proto, service->proto) == 0) { q->questions = q->questions->next; - free(qs); + mdns_mem_free(qs); } else while (qs->next) { qsn = qs->next; if (qsn->type == MDNS_TYPE_ANY && qsn->service && strcmp(qsn->service, service->service) == 0 && qsn->proto && strcmp(qsn->proto, service->proto) == 0) { qs->next = qsn->next; - free(qsn); + mdns_mem_free(qsn); break; } qs = qs->next; @@ -2863,8 +2864,8 @@ static void _mdns_free_subtype(mdns_subtype_t *subtype) { while (subtype) { mdns_subtype_t *next = subtype->next; - free((char *)subtype->subtype); - free(subtype); + mdns_mem_free((char *)subtype->subtype); + mdns_mem_free(subtype); subtype = next; } } @@ -2885,19 +2886,19 @@ static void _mdns_free_service(mdns_service_t *service) if (!service) { return; } - free((char *)service->instance); - free((char *)service->service); - free((char *)service->proto); - free((char *)service->hostname); + mdns_mem_free((char *)service->instance); + mdns_mem_free((char *)service->service); + mdns_mem_free((char *)service->proto); + mdns_mem_free((char *)service->hostname); while (service->txt) { mdns_txt_linked_item_t *s = service->txt; service->txt = service->txt->next; - free((char *)s->key); - free((char *)s->value); - free(s); + mdns_mem_free((char *)s->key); + mdns_mem_free((char *)s->value); + mdns_mem_free(s); } _mdns_free_service_subtype(service); - free(service); + mdns_mem_free(service); } @@ -3014,7 +3015,7 @@ static esp_err_t mdns_pcb_deinit_local(mdns_if_t tcpip_if, mdns_ip_protocol_t ip if (_pcb == NULL || err != ESP_OK) { return err; } - free(_pcb->probe_services); + mdns_mem_free(_pcb->probe_services); _pcb->state = PCB_OFF; _pcb->probe_ip = false; _pcb->probe_services = NULL; @@ -3147,7 +3148,7 @@ static bool _mdns_delegate_hostname_add(const char *hostname, mdns_ip_addr_t *ad return false; } - mdns_host_item_t *host = (mdns_host_item_t *)malloc(sizeof(mdns_host_item_t)); + mdns_host_item_t *host = (mdns_host_item_t *)mdns_mem_malloc(sizeof(mdns_host_item_t)); if (host == NULL) { return false; @@ -3163,7 +3164,7 @@ static void free_address_list(mdns_ip_addr_t *address_list) { while (address_list != NULL) { mdns_ip_addr_t *next = address_list->next; - free(address_list); + mdns_mem_free(address_list); address_list = next; } } @@ -3194,7 +3195,7 @@ static mdns_ip_addr_t *copy_address_list(const mdns_ip_addr_t *address_list) mdns_ip_addr_t *head = NULL; mdns_ip_addr_t *tail = NULL; while (address_list != NULL) { - mdns_ip_addr_t *addr = (mdns_ip_addr_t *)malloc(sizeof(mdns_ip_addr_t)); + mdns_ip_addr_t *addr = (mdns_ip_addr_t *)mdns_mem_malloc(sizeof(mdns_ip_addr_t)); if (addr == NULL) { free_address_list(head); return NULL; @@ -3218,10 +3219,10 @@ static void free_delegated_hostnames(void) mdns_host_item_t *host = _mdns_host_list; while (host != NULL) { free_address_list(host->address_list); - free((char *)host->hostname); + mdns_mem_free((char *)host->hostname); mdns_host_item_t *item = host; host = host->next; - free(item); + mdns_mem_free(item); } _mdns_host_list = NULL; } @@ -3243,7 +3244,7 @@ static bool _mdns_delegate_hostname_remove(const char *hostname) srv = srv->next; } _mdns_free_service(to_free->service); - free(to_free); + mdns_mem_free(to_free); } else { prev_srv = srv; srv = srv->next; @@ -3259,8 +3260,8 @@ static bool _mdns_delegate_hostname_remove(const char *hostname) prev_host->next = host->next; } free_address_list(host->address_list); - free((char *)host->hostname); - free(host); + mdns_mem_free((char *)host->hostname); + mdns_mem_free(host); break; } else { prev_host = host; @@ -3480,11 +3481,11 @@ static void _mdns_remove_parsed_question(mdns_parsed_packet_t *parsed_packet, ui if (_mdns_question_matches(q, type, service)) { parsed_packet->questions = q->next; - free(q->host); - free(q->service); - free(q->proto); - free(q->domain); - free(q); + mdns_mem_free(q->host); + mdns_mem_free(q->service); + mdns_mem_free(q->proto); + mdns_mem_free(q->domain); + mdns_mem_free(q); return; } @@ -3492,11 +3493,11 @@ static void _mdns_remove_parsed_question(mdns_parsed_packet_t *parsed_packet, ui mdns_parsed_question_t *p = q->next; if (_mdns_question_matches(p, type, service)) { q->next = p->next; - free(p->host); - free(p->service); - free(p->proto); - free(p->domain); - free(p); + mdns_mem_free(p->host); + mdns_mem_free(p->service); + mdns_mem_free(p->proto); + mdns_mem_free(p->domain); + mdns_mem_free(p); return; } q = q->next; @@ -3566,14 +3567,14 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it return; } - mdns_txt_item_t *txt = (mdns_txt_item_t *)malloc(sizeof(mdns_txt_item_t) * num_items); + mdns_txt_item_t *txt = (mdns_txt_item_t *)mdns_mem_malloc(sizeof(mdns_txt_item_t) * num_items); if (!txt) { HOOK_MALLOC_FAILED; return; } - uint8_t *txt_value_len = (uint8_t *)malloc(num_items); + uint8_t *txt_value_len = (uint8_t *)mdns_mem_malloc(num_items); if (!txt_value_len) { - free(txt); + mdns_mem_free(txt); HOOK_MALLOC_FAILED; return; } @@ -3596,7 +3597,7 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it i += partLen; continue; } - char *key = (char *)malloc(name_len + 1); + char *key = (char *)mdns_mem_malloc(name_len + 1); if (!key) { HOOK_MALLOC_FAILED; goto handle_error;//error @@ -3613,7 +3614,7 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it int new_value_len = partLen - name_len - 1; if (new_value_len > 0) { - char *value = (char *)malloc(new_value_len + 1); + char *value = (char *)mdns_mem_malloc(new_value_len + 1); if (!value) { HOOK_MALLOC_FAILED; goto handle_error;//error @@ -3634,11 +3635,11 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it handle_error : for (y = 0; y < txt_num; y++) { mdns_txt_item_t *t = &txt[y]; - free((char *)t->key); - free((char *)t->value); + mdns_mem_free((char *)t->key); + mdns_mem_free((char *)t->value); } - free(txt_value_len); - free(txt); + mdns_mem_free(txt_value_len); + mdns_mem_free(txt); } /** @@ -3647,7 +3648,7 @@ handle_error : static esp_err_t _mdns_strdup_check(char **out, char *in) { if (in && in[0]) { - *out = strdup(in); + *out = mdns_mem_strdup(in); if (!*out) { return ESP_FAIL; } @@ -3719,7 +3720,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) return; } - mdns_parsed_packet_t *parsed_packet = (mdns_parsed_packet_t *)malloc(sizeof(mdns_parsed_packet_t)); + mdns_parsed_packet_t *parsed_packet = (mdns_parsed_packet_t *)mdns_mem_malloc(sizeof(mdns_parsed_packet_t)); if (!parsed_packet) { HOOK_MALLOC_FAILED; return; @@ -3737,13 +3738,13 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET); if (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE && packet->src_port != MDNS_SERVICE_PORT) { - free(parsed_packet); + mdns_mem_free(parsed_packet); return; } //if we have not set the hostname, we can not answer questions if (header.questions && !header.answers && _str_null_or_empty(_mdns_server->hostname)) { - free(parsed_packet); + mdns_mem_free(parsed_packet); return; } @@ -3787,7 +3788,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) parsed_packet->discovery = true; mdns_srv_item_t *a = _mdns_server->services; while (a) { - mdns_parsed_question_t *question = (mdns_parsed_question_t *)calloc(1, sizeof(mdns_parsed_question_t)); + mdns_parsed_question_t *question = (mdns_parsed_question_t *)mdns_mem_calloc(1, sizeof(mdns_parsed_question_t)); if (!question) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3798,9 +3799,9 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) question->unicast = unicast; question->type = MDNS_TYPE_SDPTR; question->host = NULL; - question->service = strdup(a->service->service); - question->proto = strdup(a->service->proto); - question->domain = strdup(MDNS_DEFAULT_DOMAIN); + question->service = mdns_mem_strdup(a->service->service); + question->proto = mdns_mem_strdup(a->service->proto); + question->domain = mdns_mem_strdup(MDNS_DEFAULT_DOMAIN); if (!question->service || !question->proto || !question->domain) { goto clear_rx_packet; } @@ -3816,7 +3817,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) parsed_packet->probe = true; } - mdns_parsed_question_t *question = (mdns_parsed_question_t *)calloc(1, sizeof(mdns_parsed_question_t)); + mdns_parsed_question_t *question = (mdns_parsed_question_t *)mdns_mem_calloc(1, sizeof(mdns_parsed_question_t)); if (!question) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3897,7 +3898,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) if (browse_result) { if (!out_sync_browse) { // will be freed in function `_mdns_browse_sync` - out_sync_browse = (mdns_browse_sync_t *)malloc(sizeof(mdns_browse_sync_t)); + out_sync_browse = (mdns_browse_sync_t *)mdns_mem_malloc(sizeof(mdns_browse_sync_t)); if (!out_sync_browse) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3906,7 +3907,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) out_sync_browse->sync_result = NULL; } if (!browse_result_service) { - browse_result_service = (char *)malloc(MDNS_NAME_BUF_LEN); + browse_result_service = (char *)mdns_mem_malloc(MDNS_NAME_BUF_LEN); if (!browse_result_service) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3914,7 +3915,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) } memcpy(browse_result_service, browse_result->service, MDNS_NAME_BUF_LEN); if (!browse_result_proto) { - browse_result_proto = (char *)malloc(MDNS_NAME_BUF_LEN); + browse_result_proto = (char *)mdns_mem_malloc(MDNS_NAME_BUF_LEN); if (!browse_result_proto) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3923,7 +3924,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) memcpy(browse_result_proto, browse_result->proto, MDNS_NAME_BUF_LEN); if (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT) { if (!browse_result_instance) { - browse_result_instance = (char *)malloc(MDNS_NAME_BUF_LEN); + browse_result_instance = (char *)mdns_mem_malloc(MDNS_NAME_BUF_LEN); if (!browse_result_instance) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3958,7 +3959,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) } } if (service) { - mdns_parsed_record_t *record = malloc(sizeof(mdns_parsed_record_t)); + mdns_parsed_record_t *record = mdns_mem_malloc(sizeof(mdns_parsed_record_t)); if (!record) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3972,7 +3973,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) record->service = NULL; record->proto = NULL; if (name->host[0]) { - record->host = malloc(MDNS_NAME_BUF_LEN); + record->host = mdns_mem_malloc(MDNS_NAME_BUF_LEN); if (!record->host) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3980,7 +3981,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) memcpy(record->host, name->host, MDNS_NAME_BUF_LEN); } if (name->service[0]) { - record->service = malloc(MDNS_NAME_BUF_LEN); + record->service = mdns_mem_malloc(MDNS_NAME_BUF_LEN); if (!record->service) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -3988,7 +3989,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) memcpy(record->service, name->service, MDNS_NAME_BUF_LEN); } if (name->proto[0]) { - record->proto = malloc(MDNS_NAME_BUF_LEN); + record->proto = mdns_mem_malloc(MDNS_NAME_BUF_LEN); if (!record->proto) { HOOK_MALLOC_FAILED; goto clear_rx_packet; @@ -4036,7 +4037,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) if (search_result->type == MDNS_TYPE_PTR) { if (!result->hostname) { // assign host/port for this entry only if not previously set result->port = port; - result->hostname = strdup(name->host); + result->hostname = mdns_mem_strdup(name->host); } } else { _mdns_search_result_add_srv(search_result, name->host, port, packet->tcpip_if, packet->ip_protocol, ttl); @@ -4069,14 +4070,14 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) if (!_str_null_or_empty(service->service->instance)) { char *new_instance = _mdns_mangle_name((char *)service->service->instance); if (new_instance) { - free((char *)service->service->instance); + mdns_mem_free((char *)service->service->instance); service->service->instance = new_instance; } _mdns_probe_all_pcbs(&service, 1, false, false); } else if (!_str_null_or_empty(_mdns_server->instance)) { char *new_instance = _mdns_mangle_name((char *)_mdns_server->instance); if (new_instance) { - free((char *)_mdns_server->instance); + mdns_mem_free((char *)_mdns_server->instance); _mdns_server->instance = new_instance; } _mdns_restart_all_pcbs_no_instance(); @@ -4084,7 +4085,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) char *new_host = _mdns_mangle_name((char *)_mdns_server->hostname); if (new_host) { _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); - free((char *)_mdns_server->hostname); + mdns_mem_free((char *)_mdns_server->hostname); _mdns_server->hostname = new_host; _mdns_self_host.hostname = new_host; } @@ -4209,7 +4210,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) char *new_host = _mdns_mangle_name((char *)_mdns_server->hostname); if (new_host) { _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); - free((char *)_mdns_server->hostname); + mdns_mem_free((char *)_mdns_server->hostname); _mdns_server->hostname = new_host; _mdns_self_host.hostname = new_host; } @@ -4266,7 +4267,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) char *new_host = _mdns_mangle_name((char *)_mdns_server->hostname); if (new_host) { _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); - free((char *)_mdns_server->hostname); + mdns_mem_free((char *)_mdns_server->hostname); _mdns_server->hostname = new_host; _mdns_self_host.hostname = new_host; } @@ -4304,7 +4305,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet) #endif // MDNS_ENABLE_DEBUG _mdns_sync_browse_action(ACTION_BROWSE_SYNC, out_sync_browse); } else { - free(out_sync_browse); + mdns_mem_free(out_sync_browse); } out_sync_browse = NULL; } @@ -4314,39 +4315,39 @@ clear_rx_packet: mdns_parsed_question_t *question = parsed_packet->questions; parsed_packet->questions = parsed_packet->questions->next; if (question->host) { - free(question->host); + mdns_mem_free(question->host); } if (question->service) { - free(question->service); + mdns_mem_free(question->service); } if (question->proto) { - free(question->proto); + mdns_mem_free(question->proto); } if (question->domain) { - free(question->domain); + mdns_mem_free(question->domain); } - free(question); + mdns_mem_free(question); } while (parsed_packet->records) { mdns_parsed_record_t *record = parsed_packet->records; parsed_packet->records = parsed_packet->records->next; if (record->host) { - free(record->host); + mdns_mem_free(record->host); } if (record->service) { - free(record->service); + mdns_mem_free(record->service); } if (record->proto) { - free(record->proto); + mdns_mem_free(record->proto); } record->next = NULL; - free(record); + mdns_mem_free(record); } - free(parsed_packet); - free(browse_result_instance); - free(browse_result_service); - free(browse_result_proto); - free(out_sync_browse); + mdns_mem_free(parsed_packet); + mdns_mem_free(browse_result_instance); + mdns_mem_free(browse_result_service); + mdns_mem_free(browse_result_proto); + mdns_mem_free(out_sync_browse); } /** @@ -4439,7 +4440,7 @@ static void perform_event_action(mdns_if_t mdns_if, mdns_event_actions_t action) uint8_t *paddr = (uint8_t *)&addr6.addr; const char sub[] = "ip6"; const size_t query_name_size = 4 * sizeof(addr6.addr) /* (2 nibbles + 2 dots)/per byte of IP address */ + sizeof(sub); - char *reverse_query_name = malloc(query_name_size); + char *reverse_query_name = mdns_mem_malloc(query_name_size); if (reverse_query_name) { char *ptr = &reverse_query_name[query_name_size]; // point to the end memcpy(ptr - sizeof(sub), sub, sizeof(sub)); // copy the IP sub-domain @@ -4574,11 +4575,11 @@ void mdns_preset_if_handle_system_event(void *arg, esp_event_base_t event_base, */ static void _mdns_search_free(mdns_search_once_t *search) { - free(search->instance); - free(search->service); - free(search->proto); + mdns_mem_free(search->instance); + mdns_mem_free(search->service); + mdns_mem_free(search->proto); vSemaphoreDelete(search->done_semaphore); - free(search); + mdns_mem_free(search); } /** @@ -4587,7 +4588,7 @@ static void _mdns_search_free(mdns_search_once_t *search) static mdns_search_once_t *_mdns_search_init(const char *name, const char *service, const char *proto, uint16_t type, bool unicast, uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier) { - mdns_search_once_t *search = (mdns_search_once_t *)malloc(sizeof(mdns_search_once_t)); + mdns_search_once_t *search = (mdns_search_once_t *)mdns_mem_malloc(sizeof(mdns_search_once_t)); if (!search) { HOOK_MALLOC_FAILED; return NULL; @@ -4596,12 +4597,12 @@ static mdns_search_once_t *_mdns_search_init(const char *name, const char *servi search->done_semaphore = xSemaphoreCreateBinary(); if (!search->done_semaphore) { - free(search); + mdns_mem_free(search); return NULL; } if (!_str_null_or_empty(name)) { - search->instance = strndup(name, MDNS_NAME_BUF_LEN - 1); + search->instance = mdns_mem_strndup(name, MDNS_NAME_BUF_LEN - 1); if (!search->instance) { _mdns_search_free(search); return NULL; @@ -4609,7 +4610,7 @@ static mdns_search_once_t *_mdns_search_init(const char *name, const char *servi } if (!_str_null_or_empty(service)) { - search->service = strndup(service, MDNS_NAME_BUF_LEN - 1); + search->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1); if (!search->service) { _mdns_search_free(search); return NULL; @@ -4617,7 +4618,7 @@ static mdns_search_once_t *_mdns_search_init(const char *name, const char *servi } if (!_str_null_or_empty(proto)) { - search->proto = strndup(proto, MDNS_NAME_BUF_LEN - 1); + search->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1); if (!search->proto) { _mdns_search_free(search); return NULL; @@ -4682,7 +4683,7 @@ static void _mdns_search_finish_done(void) */ static mdns_ip_addr_t *_mdns_result_addr_create_ip(esp_ip_addr_t *ip) { - mdns_ip_addr_t *a = (mdns_ip_addr_t *)malloc(sizeof(mdns_ip_addr_t)); + mdns_ip_addr_t *a = (mdns_ip_addr_t *)mdns_mem_malloc(sizeof(mdns_ip_addr_t)); if (!a) { HOOK_MALLOC_FAILED; return NULL; @@ -4753,7 +4754,7 @@ static void _mdns_search_result_add_ip(mdns_search_once_t *search, const char *h r = r->next; } if (!search->max_results || search->num_results < search->max_results) { - r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; return; @@ -4763,11 +4764,11 @@ static void _mdns_search_result_add_ip(mdns_search_once_t *search, const char *h a = _mdns_result_addr_create_ip(ip); if (!a) { - free(r); + mdns_mem_free(r); return; } a->next = r->addr; - r->hostname = strdup(hostname); + r->hostname = mdns_mem_strdup(hostname); r->addr = a; r->esp_netif = _mdns_get_esp_netif(tcpip_if); r->ip_protocol = ip_protocol; @@ -4805,18 +4806,18 @@ static mdns_result_t *_mdns_search_result_add_ptr(mdns_search_once_t *search, co r = r->next; } if (!search->max_results || search->num_results < search->max_results) { - r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; return NULL; } memset(r, 0, sizeof(mdns_result_t)); - r->instance_name = strdup(instance); - r->service_type = strdup(service_type); - r->proto = strdup(proto); + r->instance_name = mdns_mem_strdup(instance); + r->service_type = mdns_mem_strdup(service_type); + r->proto = mdns_mem_strdup(proto); if (!r->instance_name) { - free(r); + mdns_mem_free(r); return NULL; } @@ -4846,23 +4847,23 @@ static void _mdns_search_result_add_srv(mdns_search_once_t *search, const char * r = r->next; } if (!search->max_results || search->num_results < search->max_results) { - r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + 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 = strdup(hostname); + r->hostname = mdns_mem_strdup(hostname); if (!r->hostname) { - free(r); + mdns_mem_free(r); return; } if (search->instance) { - r->instance_name = strdup(search->instance); + r->instance_name = mdns_mem_strdup(search->instance); } - r->service_type = strdup(search->service); - r->proto = strdup(search->proto); + r->service_type = mdns_mem_strdup(search->service); + r->proto = mdns_mem_strdup(search->proto); r->port = port; r->esp_netif = _mdns_get_esp_netif(tcpip_if); r->ip_protocol = ip_protocol; @@ -4895,7 +4896,7 @@ static void _mdns_search_result_add_txt(mdns_search_once_t *search, mdns_txt_ite r = r->next; } if (!search->max_results || search->num_results < search->max_results) { - r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); if (!r) { HOOK_MALLOC_FAILED; goto free_txt; @@ -4916,11 +4917,11 @@ static void _mdns_search_result_add_txt(mdns_search_once_t *search, mdns_txt_ite free_txt: for (size_t i = 0; i < txt_count; i++) { - free((char *)(txt[i].key)); - free((char *)(txt[i].value)); + mdns_mem_free((char *)(txt[i].key)); + mdns_mem_free((char *)(txt[i].value)); } - free(txt); - free(txt_value_len); + mdns_mem_free(txt); + mdns_mem_free(txt_value_len); } /** @@ -5001,7 +5002,7 @@ static mdns_tx_packet_t *_mdns_create_search_packet(mdns_search_once_t *search, return NULL; } - mdns_out_question_t *q = (mdns_out_question_t *)malloc(sizeof(mdns_out_question_t)); + mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t)); if (!q) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); @@ -5025,7 +5026,7 @@ static mdns_tx_packet_t *_mdns_create_search_packet(mdns_search_once_t *search, r = r->next; continue; } - mdns_out_answer_t *a = (mdns_out_answer_t *)malloc(sizeof(mdns_out_answer_t)); + mdns_out_answer_t *a = (mdns_out_answer_t *)mdns_mem_malloc(sizeof(mdns_out_answer_t)); if (!a) { HOOK_MALLOC_FAILED; _mdns_free_tx_packet(packet); @@ -5127,7 +5128,7 @@ static void _mdns_tx_handle_packet(mdns_tx_packet_t *p) pcb->probe_ip = false; pcb->probe_services_len = 0; pcb->failed_probes = 0; - free(pcb->probe_services); + mdns_mem_free(pcb->probe_services); pcb->probe_services = NULL; _mdns_free_tx_packet(p); p = a; @@ -5156,8 +5157,8 @@ static void _mdns_remap_self_service_hostname(const char *old_hostname, const ch while (service) { if (service->service->hostname && strcmp(service->service->hostname, old_hostname) == 0) { - free((char *)service->service->hostname); - service->service->hostname = strdup(new_hostname); + mdns_mem_free((char *)service->service->hostname); + service->service->hostname = mdns_mem_strdup(new_hostname); } service = service->next; } @@ -5170,9 +5171,9 @@ static void _mdns_sync_browse_result_link_free(mdns_browse_sync_t *browse_sync) while (current) { need_free = current; current = current->next; - free(need_free); + mdns_mem_free(need_free); } - free(browse_sync); + mdns_mem_free(browse_sync); } /** @@ -5182,10 +5183,10 @@ static void _mdns_free_action(mdns_action_t *action) { switch (action->type) { case ACTION_HOSTNAME_SET: - free(action->data.hostname_set.hostname); + mdns_mem_free(action->data.hostname_set.hostname); break; case ACTION_INSTANCE_SET: - free(action->data.instance); + mdns_mem_free(action->data.instance); break; case ACTION_SEARCH_ADD: //fallthrough @@ -5210,16 +5211,16 @@ static void _mdns_free_action(mdns_action_t *action) break; case ACTION_DELEGATE_HOSTNAME_SET_ADDR: case ACTION_DELEGATE_HOSTNAME_ADD: - free((char *)action->data.delegate_hostname.hostname); + mdns_mem_free((char *)action->data.delegate_hostname.hostname); free_address_list(action->data.delegate_hostname.address_list); break; case ACTION_DELEGATE_HOSTNAME_REMOVE: - free((char *)action->data.delegate_hostname.hostname); + mdns_mem_free((char *)action->data.delegate_hostname.hostname); break; default: break; } - free(action); + mdns_mem_free(action); } /** @@ -5234,7 +5235,7 @@ static void _mdns_execute_action(mdns_action_t *action) case ACTION_HOSTNAME_SET: _mdns_send_bye_all_pcbs_no_instance(true); _mdns_remap_self_service_hostname(_mdns_server->hostname, action->data.hostname_set.hostname); - free((char *)_mdns_server->hostname); + mdns_mem_free((char *)_mdns_server->hostname); _mdns_server->hostname = action->data.hostname_set.hostname; _mdns_self_host.hostname = action->data.hostname_set.hostname; _mdns_restart_all_pcbs(); @@ -5242,7 +5243,7 @@ static void _mdns_execute_action(mdns_action_t *action) break; case ACTION_INSTANCE_SET: _mdns_send_bye_all_pcbs_no_instance(false); - free((char *)_mdns_server->instance); + mdns_mem_free((char *)_mdns_server->instance); _mdns_server->instance = action->data.instance; _mdns_restart_all_pcbs_no_instance(); @@ -5287,7 +5288,7 @@ static void _mdns_execute_action(mdns_action_t *action) case ACTION_DELEGATE_HOSTNAME_ADD: if (!_mdns_delegate_hostname_add(action->data.delegate_hostname.hostname, action->data.delegate_hostname.address_list)) { - free((char *)action->data.delegate_hostname.hostname); + mdns_mem_free((char *)action->data.delegate_hostname.hostname); free_address_list(action->data.delegate_hostname.address_list); } xSemaphoreGive(_mdns_server->action_sema); @@ -5297,16 +5298,16 @@ static void _mdns_execute_action(mdns_action_t *action) action->data.delegate_hostname.address_list)) { free_address_list(action->data.delegate_hostname.address_list); } - free((char *)action->data.delegate_hostname.hostname); + mdns_mem_free((char *)action->data.delegate_hostname.hostname); break; case ACTION_DELEGATE_HOSTNAME_REMOVE: _mdns_delegate_hostname_remove(action->data.delegate_hostname.hostname); - free((char *)action->data.delegate_hostname.hostname); + mdns_mem_free((char *)action->data.delegate_hostname.hostname); break; default: break; } - free(action); + mdns_mem_free(action); } /** @@ -5316,7 +5317,7 @@ static esp_err_t _mdns_send_search_action(mdns_action_type_t type, mdns_search_o { mdns_action_t *action = NULL; - action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; @@ -5325,7 +5326,7 @@ static esp_err_t _mdns_send_search_action(mdns_action_type_t type, mdns_search_o action->type = type; action->data.search_add.search = search; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(action); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -5353,13 +5354,13 @@ static void _mdns_scheduler_run(void) return; } while (p && (int32_t)(p->send_at - (xTaskGetTickCount() * portTICK_PERIOD_MS)) < 0) { - action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (action) { action->type = ACTION_TX_HANDLE; action->data.tx_handle.packet = p; p->queued = true; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(action); + mdns_mem_free(action); p->queued = false; } } else { @@ -5555,7 +5556,7 @@ static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_ return ESP_ERR_INVALID_STATE; } - mdns_action_t *action = (mdns_action_t *)calloc(1, sizeof(mdns_action_t)); + 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; @@ -5565,7 +5566,7 @@ static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_ action->data.sys_event.interface = mdns_if; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(action); + mdns_mem_free(action); } return ESP_OK; } @@ -5664,7 +5665,7 @@ esp_err_t mdns_init(void) return err; } - _mdns_server = (mdns_server_t *)malloc(sizeof(mdns_server_t)); + _mdns_server = (mdns_server_t *)mdns_mem_malloc(sizeof(mdns_server_t)); if (!_mdns_server) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; @@ -5749,7 +5750,7 @@ free_event_handlers: free_queue: vQueueDelete(_mdns_server->action_queue); free_server: - free(_mdns_server); + mdns_mem_free(_mdns_server); _mdns_server = NULL; return err; } @@ -5774,8 +5775,8 @@ void mdns_free(void) mdns_pcb_deinit_local(i, j); } } - free((char *)_mdns_server->hostname); - free((char *)_mdns_server->instance); + mdns_mem_free((char *)_mdns_server->hostname); + mdns_mem_free((char *)_mdns_server->instance); if (_mdns_server->action_queue) { mdns_action_t *c; while (xQueueReceive(_mdns_server->action_queue, &c, 0) == pdTRUE) { @@ -5787,14 +5788,14 @@ void mdns_free(void) while (_mdns_server->search_once) { mdns_search_once_t *h = _mdns_server->search_once; _mdns_server->search_once = h->next; - free(h->instance); - free(h->service); - free(h->proto); + mdns_mem_free(h->instance); + mdns_mem_free(h->service); + mdns_mem_free(h->proto); vSemaphoreDelete(h->done_semaphore); if (h->result) { _mdns_query_results_free(h->result); } - free(h); + mdns_mem_free(h); } while (_mdns_server->browse) { mdns_browse_t *b = _mdns_server->browse; @@ -5803,7 +5804,7 @@ void mdns_free(void) } vSemaphoreDelete(_mdns_server->action_sema); - free(_mdns_server); + mdns_mem_free(_mdns_server); _mdns_server = NULL; } @@ -5815,22 +5816,22 @@ esp_err_t mdns_hostname_set(const char *hostname) if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } - char *new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } - mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; - free(new_hostname); + mdns_mem_free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_HOSTNAME_SET; action->data.hostname_set.hostname = new_hostname; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(new_hostname); - free(action); + mdns_mem_free(new_hostname); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } xSemaphoreTake(_mdns_server->action_sema, portMAX_DELAY); @@ -5863,23 +5864,23 @@ esp_err_t mdns_delegate_hostname_add(const char *hostname, const mdns_ip_addr_t if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } - char *new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } - mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; - free(new_hostname); + mdns_mem_free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_DELEGATE_HOSTNAME_ADD; action->data.delegate_hostname.hostname = new_hostname; action->data.delegate_hostname.address_list = copy_address_list(address_list); if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(new_hostname); - free(action); + mdns_mem_free(new_hostname); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } xSemaphoreTake(_mdns_server->action_sema, portMAX_DELAY); @@ -5894,22 +5895,22 @@ esp_err_t mdns_delegate_hostname_remove(const char *hostname) if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } - char *new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } - mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; - free(new_hostname); + mdns_mem_free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_DELEGATE_HOSTNAME_REMOVE; action->data.delegate_hostname.hostname = new_hostname; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(new_hostname); - free(action); + mdns_mem_free(new_hostname); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -5923,23 +5924,23 @@ esp_err_t mdns_delegate_hostname_set_address(const char *hostname, const mdns_ip if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } - char *new_hostname = strndup(hostname, MDNS_NAME_BUF_LEN - 1); + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); if (!new_hostname) { return ESP_ERR_NO_MEM; } - mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; - free(new_hostname); + mdns_mem_free(new_hostname); return ESP_ERR_NO_MEM; } action->type = ACTION_DELEGATE_HOSTNAME_SET_ADDR; action->data.delegate_hostname.hostname = new_hostname; action->data.delegate_hostname.address_list = copy_address_list(address_list); if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(new_hostname); - free(action); + mdns_mem_free(new_hostname); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -5962,22 +5963,22 @@ esp_err_t mdns_instance_name_set(const char *instance) if (_str_null_or_empty(instance) || _mdns_server->hostname == NULL || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) { return ESP_ERR_INVALID_ARG; } - char *new_instance = strndup(instance, MDNS_NAME_BUF_LEN - 1); + char *new_instance = mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1); if (!new_instance) { return ESP_ERR_NO_MEM; } - mdns_action_t *action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; - free(new_instance); + mdns_mem_free(new_instance); return ESP_ERR_NO_MEM; } action->type = ACTION_INSTANCE_SET; action->data.instance = new_instance; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(new_instance); - free(action); + mdns_mem_free(new_instance); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -6008,7 +6009,7 @@ esp_err_t mdns_service_add_for_host(const char *instance, const char *service, c s = _mdns_create_service(service, proto, hostname, port, instance, num_items, txt); ESP_GOTO_ON_FALSE(s, ESP_ERR_NO_MEM, err, TAG, "Cannot create service: Out of memory"); - item = (mdns_srv_item_t *)malloc(sizeof(mdns_srv_item_t)); + item = (mdns_srv_item_t *)mdns_mem_malloc(sizeof(mdns_srv_item_t)); ESP_GOTO_ON_FALSE(item, ESP_ERR_NO_MEM, err, TAG, "Cannot create service: Out of memory"); item->service = s; @@ -6069,8 +6070,8 @@ static mdns_txt_item_t *_copy_mdns_txt_items(mdns_txt_linked_item_t *items, uint *txt_value_len = NULL; return NULL; } - ret = (mdns_txt_item_t *)calloc(ret_index, sizeof(mdns_txt_item_t)); - *txt_value_len = (uint8_t *)calloc(ret_index, sizeof(uint8_t)); + ret = (mdns_txt_item_t *)mdns_mem_calloc(ret_index, sizeof(mdns_txt_item_t)); + *txt_value_len = (uint8_t *)mdns_mem_calloc(ret_index, sizeof(uint8_t)); if (!ret || !(*txt_value_len)) { HOOK_MALLOC_FAILED; goto handle_error; @@ -6078,7 +6079,7 @@ static mdns_txt_item_t *_copy_mdns_txt_items(mdns_txt_linked_item_t *items, uint ret_index = 0; for (mdns_txt_linked_item_t *tmp = items; tmp != NULL; tmp = tmp->next) { size_t key_len = strlen(tmp->key); - char *key = (char *)malloc(key_len + 1); + char *key = (char *)mdns_mem_malloc(key_len + 1); if (!key) { HOOK_MALLOC_FAILED; goto handle_error; @@ -6086,7 +6087,7 @@ static mdns_txt_item_t *_copy_mdns_txt_items(mdns_txt_linked_item_t *items, uint memcpy(key, tmp->key, key_len); key[key_len] = 0; ret[ret_index].key = key; - char *value = (char *)malloc(tmp->value_len + 1); + char *value = (char *)mdns_mem_malloc(tmp->value_len + 1); if (!value) { HOOK_MALLOC_FAILED; goto handle_error; @@ -6102,11 +6103,11 @@ static mdns_txt_item_t *_copy_mdns_txt_items(mdns_txt_linked_item_t *items, uint handle_error: for (size_t y = 0; y < ret_index + 1 && ret != NULL; y++) { mdns_txt_item_t *t = &ret[y]; - free((char *)t->key); - free((char *)t->value); + mdns_mem_free((char *)t->key); + mdns_mem_free((char *)t->value); } - free(*txt_value_len); - free(ret); + mdns_mem_free(*txt_value_len); + mdns_mem_free(ret); return NULL; } @@ -6141,7 +6142,7 @@ static mdns_result_t *_mdns_lookup_service(const char *instance, const char *ser if ((selfhost && is_service_selfhosted) || (!selfhost && is_service_delegated)) { if (!strcasecmp(srv->service, service) && !strcasecmp(srv->proto, proto) && (_str_null_or_empty(instance) || _mdns_instance_name_match(srv->instance, instance))) { - mdns_result_t *item = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + mdns_result_t *item = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); if (!item) { HOOK_MALLOC_FAILED; goto handle_error; @@ -6152,7 +6153,7 @@ static mdns_result_t *_mdns_lookup_service(const char *instance, const char *ser item->ttl = _str_null_or_empty(instance) ? MDNS_ANSWER_PTR_TTL : MDNS_ANSWER_SRV_TTL; item->ip_protocol = MDNS_IP_PROTOCOL_MAX; if (srv->instance) { - item->instance_name = strndup(srv->instance, MDNS_NAME_BUF_LEN - 1); + item->instance_name = mdns_mem_strndup(srv->instance, MDNS_NAME_BUF_LEN - 1); if (!item->instance_name) { HOOK_MALLOC_FAILED; goto handle_error; @@ -6160,17 +6161,17 @@ static mdns_result_t *_mdns_lookup_service(const char *instance, const char *ser } else { item->instance_name = NULL; } - item->service_type = strndup(srv->service, MDNS_NAME_BUF_LEN - 1); + item->service_type = mdns_mem_strndup(srv->service, MDNS_NAME_BUF_LEN - 1); if (!item->service_type) { HOOK_MALLOC_FAILED; goto handle_error; } - item->proto = strndup(srv->proto, MDNS_NAME_BUF_LEN - 1); + item->proto = mdns_mem_strndup(srv->proto, MDNS_NAME_BUF_LEN - 1); if (!item->proto) { HOOK_MALLOC_FAILED; goto handle_error; } - item->hostname = strndup(srv->hostname, MDNS_NAME_BUF_LEN - 1); + item->hostname = mdns_mem_strndup(srv->hostname, MDNS_NAME_BUF_LEN - 1); if (!item->hostname) { HOOK_MALLOC_FAILED; goto handle_error; @@ -6282,7 +6283,7 @@ esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char mdns_service_t *srv = s->service; if (value_len > 0) { - value = (char *) malloc(value_len); + value = (char *) mdns_mem_malloc(value_len); ESP_GOTO_ON_FALSE(value, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); memcpy(value, value_arg, value_len); } else { @@ -6291,7 +6292,7 @@ esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char mdns_txt_linked_item_t *txt = srv->txt; while (txt) { if (strcmp(txt->key, key) == 0) { - free((char *)txt->value); + mdns_mem_free((char *)txt->value); txt->value = value; txt->value_len = value_len; break; @@ -6299,9 +6300,9 @@ esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char txt = txt->next; } if (!txt) { - new_txt = (mdns_txt_linked_item_t *)malloc(sizeof(mdns_txt_linked_item_t)); + new_txt = (mdns_txt_linked_item_t *)mdns_mem_malloc(sizeof(mdns_txt_linked_item_t)); ESP_GOTO_ON_FALSE(new_txt, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); - new_txt->key = strdup(key); + new_txt->key = mdns_mem_strdup(key); ESP_GOTO_ON_FALSE(new_txt->key, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); new_txt->value = value; new_txt->value_len = value_len; @@ -6317,8 +6318,8 @@ err: out_of_mem: MDNS_SERVICE_UNLOCK(); HOOK_MALLOC_FAILED; - free(value); - free(new_txt); + mdns_mem_free(value); + mdns_mem_free(new_txt); return ret; } @@ -6367,17 +6368,17 @@ esp_err_t mdns_service_txt_item_remove_for_host(const char *instance, const char } if (strcmp(txt->key, key) == 0) { srv->txt = txt->next; - free((char *)txt->key); - free((char *)txt->value); - free(txt); + mdns_mem_free((char *)txt->key); + mdns_mem_free((char *)txt->value); + mdns_mem_free(txt); } else { while (txt->next) { if (strcmp(txt->next->key, key) == 0) { mdns_txt_linked_item_t *t = txt->next; txt->next = t->next; - free((char *)t->key); - free((char *)t->value); - free(t); + mdns_mem_free((char *)t->key); + mdns_mem_free((char *)t->value); + mdns_mem_free(t); break; } else { txt = txt->next; @@ -6417,8 +6418,8 @@ static esp_err_t _mdns_service_subtype_remove_for_host(mdns_srv_item_t *service, } else { pre->next = srv_subtype->next; } - free((char *)srv_subtype->subtype); - free(srv_subtype); + mdns_mem_free((char *)srv_subtype->subtype); + mdns_mem_free(srv_subtype); ret = ESP_OK; break; } @@ -6447,9 +6448,9 @@ esp_err_t mdns_service_subtype_remove_for_host(const char *instance_name, const ESP_GOTO_ON_ERROR(ret, err, TAG, "Failed to remove the subtype: %s", subtype); // Transmit a sendbye message for the removed subtype. - mdns_subtype_t *remove_subtypes = (mdns_subtype_t *)malloc(sizeof(mdns_subtype_t)); + mdns_subtype_t *remove_subtypes = (mdns_subtype_t *)mdns_mem_malloc(sizeof(mdns_subtype_t)); ESP_GOTO_ON_FALSE(remove_subtypes, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); - remove_subtypes->subtype = strdup(subtype); + remove_subtypes->subtype = mdns_mem_strdup(subtype); ESP_GOTO_ON_FALSE(remove_subtypes->subtype, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); remove_subtypes->next = NULL; @@ -6460,7 +6461,7 @@ err: return ret; out_of_mem: HOOK_MALLOC_FAILED; - free(remove_subtypes); + mdns_mem_free(remove_subtypes); MDNS_SERVICE_UNLOCK(); return ret; } @@ -6474,9 +6475,9 @@ static esp_err_t _mdns_service_subtype_add_for_host(mdns_srv_item_t *service, co srv_subtype = srv_subtype->next; } - mdns_subtype_t *subtype_item = (mdns_subtype_t *)malloc(sizeof(mdns_subtype_t)); + mdns_subtype_t *subtype_item = (mdns_subtype_t *)mdns_mem_malloc(sizeof(mdns_subtype_t)); ESP_GOTO_ON_FALSE(subtype_item, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); - subtype_item->subtype = strdup(subtype); + subtype_item->subtype = mdns_mem_strdup(subtype); ESP_GOTO_ON_FALSE(subtype_item->subtype, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); subtype_item->next = service->service->subtype; service->service->subtype = subtype_item; @@ -6485,7 +6486,7 @@ err: return ret; out_of_mem: HOOK_MALLOC_FAILED; - free(subtype_item); + mdns_mem_free(subtype_item); return ret; } @@ -6646,9 +6647,9 @@ esp_err_t mdns_service_instance_name_set_for_host(const char *instance_old, cons if (s->service->instance) { _mdns_send_bye(&s, 1, false); - free((char *)s->service->instance); + mdns_mem_free((char *)s->service->instance); } - s->service->instance = strndup(instance, MDNS_NAME_BUF_LEN - 1); + s->service->instance = mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1); ESP_GOTO_ON_FALSE(s->service->instance, ESP_ERR_NO_MEM, err, TAG, "Out of memory"); _mdns_probe_all_pcbs(&s, 1, false, false); @@ -6688,7 +6689,7 @@ esp_err_t mdns_service_remove_for_host(const char *instance, const char *service _mdns_send_bye(&a, 1, false); _mdns_remove_scheduled_service_packets(a->service); _mdns_free_service(a->service); - free(a); + mdns_mem_free(a); break; } b = a; @@ -6705,7 +6706,7 @@ esp_err_t mdns_service_remove_for_host(const char *instance, const char *service _mdns_send_bye(&a, 1, false); _mdns_remove_scheduled_service_packets(a->service); _mdns_free_service(a->service); - free(a); + mdns_mem_free(a); break; } b = a; @@ -6743,7 +6744,7 @@ esp_err_t mdns_service_remove_all(void) services = services->next; _mdns_remove_scheduled_service_packets(s->service); _mdns_free_service(s->service); - free(s); + mdns_mem_free(s); } done: @@ -6769,26 +6770,26 @@ static void _mdns_query_results_free(mdns_result_t *results) while (results) { r = results; - free((char *)(r->hostname)); - free((char *)(r->instance_name)); - free((char *)(r->service_type)); - free((char *)(r->proto)); + mdns_mem_free((char *)(r->hostname)); + mdns_mem_free((char *)(r->instance_name)); + mdns_mem_free((char *)(r->service_type)); + mdns_mem_free((char *)(r->proto)); for (size_t i = 0; i < r->txt_count; i++) { - free((char *)(r->txt[i].key)); - free((char *)(r->txt[i].value)); + mdns_mem_free((char *)(r->txt[i].key)); + mdns_mem_free((char *)(r->txt[i].value)); } - free(r->txt); - free(r->txt_value_len); + mdns_mem_free(r->txt); + mdns_mem_free(r->txt_value_len); while (r->addr) { a = r->addr; r->addr = r->addr->next; - free(a); + mdns_mem_free(a); } results = results->next; - free(r); + mdns_mem_free(r); } } @@ -7251,7 +7252,7 @@ static esp_err_t _mdns_sync_browse_action(mdns_action_type_t type, mdns_browse_s { mdns_action_t *action = NULL; - action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; return ESP_ERR_NO_MEM; @@ -7260,7 +7261,7 @@ static esp_err_t _mdns_sync_browse_action(mdns_action_type_t type, mdns_browse_s action->type = type; action->data.browse_sync.browse_sync = browse_sync; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(action); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -7273,7 +7274,7 @@ static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t { mdns_action_t *action = NULL; - action = (mdns_action_t *)malloc(sizeof(mdns_action_t)); + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); if (!action) { HOOK_MALLOC_FAILED; @@ -7283,7 +7284,7 @@ static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t action->type = type; action->data.browse_add.browse = browse; if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { - free(action); + mdns_mem_free(action); return ESP_ERR_NO_MEM; } return ESP_OK; @@ -7294,12 +7295,12 @@ static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t */ static void _mdns_browse_item_free(mdns_browse_t *browse) { - free(browse->service); - free(browse->proto); + mdns_mem_free(browse->service); + mdns_mem_free(browse->proto); if (browse->result) { _mdns_query_results_free(browse->result); } - free(browse); + mdns_mem_free(browse); } /** @@ -7307,7 +7308,7 @@ static void _mdns_browse_item_free(mdns_browse_t *browse) */ static mdns_browse_t *_mdns_browse_init(const char *service, const char *proto, mdns_browse_notify_t notifier) { - mdns_browse_t *browse = (mdns_browse_t *)malloc(sizeof(mdns_browse_t)); + mdns_browse_t *browse = (mdns_browse_t *)mdns_mem_malloc(sizeof(mdns_browse_t)); if (!browse) { HOOK_MALLOC_FAILED; @@ -7317,7 +7318,7 @@ static mdns_browse_t *_mdns_browse_init(const char *service, const char *proto, browse->state = BROWSE_INIT; if (!_str_null_or_empty(service)) { - browse->service = strndup(service, MDNS_NAME_BUF_LEN - 1); + browse->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1); if (!browse->service) { _mdns_browse_item_free(browse); return NULL; @@ -7325,7 +7326,7 @@ static mdns_browse_t *_mdns_browse_init(const char *service, const char *proto, } if (!_str_null_or_empty(proto)) { - browse->proto = strndup(proto, MDNS_NAME_BUF_LEN - 1); + browse->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1); if (!browse->proto) { _mdns_browse_item_free(browse); return NULL; @@ -7463,7 +7464,7 @@ static esp_err_t _mdns_add_browse_result(mdns_browse_sync_t *sync_browse, mdns_r } 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 *)malloc(sizeof(mdns_browse_result_sync_t)); + 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; @@ -7624,11 +7625,11 @@ static void _mdns_browse_result_add_txt(mdns_browse_t *browse, const char *insta } // If the result has a previous txt entry, we delete it and re-add. for (size_t i = 0; i < r->txt_count; i++) { - free((char *)(r->txt[i].key)); - free((char *)(r->txt[i].value)); + mdns_mem_free((char *)(r->txt[i].key)); + mdns_mem_free((char *)(r->txt[i].value)); } - free(r->txt); - free(r->txt_value_len); + mdns_mem_free(r->txt); + mdns_mem_free(r->txt_value_len); } r->txt = txt; r->txt_value_len = txt_value_len; @@ -7653,20 +7654,20 @@ static void _mdns_browse_result_add_txt(mdns_browse_t *browse, const char *insta } r = r->next; } - r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + 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 = strdup(instance); - r->service_type = strdup(service); - r->proto = strdup(proto); + 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) { - free(r->instance_name); - free(r->service_type); - free(r->proto); - free(r); + 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; @@ -7682,11 +7683,11 @@ static void _mdns_browse_result_add_txt(mdns_browse_t *browse, const char *insta free_txt: for (size_t i = 0; i < txt_count; i++) { - free((char *)(txt[i].key)); - free((char *)(txt[i].value)); + mdns_mem_free((char *)(txt[i].key)); + mdns_mem_free((char *)(txt[i].value)); } - free(txt); - free(txt_value_len); + mdns_mem_free(txt); + mdns_mem_free(txt_value_len); return; } @@ -7728,7 +7729,7 @@ static void _mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostn !_str_null_or_empty(r->service_type) && !strcasecmp(service, r->service_type) && !_str_null_or_empty(r->proto) && !strcasecmp(proto, r->proto)) { if (_str_null_or_empty(r->hostname) || strcasecmp(hostname, r->hostname)) { - r->hostname = strdup(hostname); + r->hostname = mdns_mem_strdup(hostname); r->port = port; if (!r->hostname) { HOOK_MALLOC_FAILED; @@ -7761,24 +7762,24 @@ static void _mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostn } r = r->next; } - r = (mdns_result_t *)malloc(sizeof(mdns_result_t)); + 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 = strdup(hostname); - r->instance_name = strdup(instance); - r->service_type = strdup(service); - r->proto = strdup(proto); + 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; - free(r->hostname); - free(r->instance_name); - free(r->service_type); - free(r->proto); - free(r); + 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; diff --git a/components/mdns/mdns_console.c b/components/mdns/mdns_console.c index 80f009a12..b3448ff92 100644 --- a/components/mdns/mdns_console.c +++ b/components/mdns/mdns_console.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -10,6 +10,7 @@ #include "mdns.h" #include "mdns_private.h" #include "inttypes.h" +#include "mdns_mem_caps.h" static const char *ip_protocol_str[] = {"V4", "V6", "MAX"}; @@ -110,7 +111,7 @@ static void register_mdns_query_a(void) .argtable = &mdns_query_a_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } #endif /* CONFIG_LWIP_IPV4 */ @@ -169,7 +170,7 @@ static void register_mdns_query_aaaa(void) .argtable = &mdns_query_a_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } #endif /* CONFIG_LWIP_IPV6 */ @@ -231,7 +232,7 @@ static void register_mdns_query_srv(void) .argtable = &mdns_query_srv_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } static struct { @@ -293,7 +294,7 @@ static void register_mdns_query_txt(void) .argtable = &mdns_query_txt_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } static struct { @@ -359,7 +360,7 @@ static void register_mdns_query_ptr(void) .argtable = &mdns_query_ptr_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } static struct { @@ -427,7 +428,7 @@ static void register_mdns_query_ip(void) .argtable = &mdns_query_ip_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } static struct { @@ -496,7 +497,7 @@ static void register_mdns_query_svc(void) .argtable = &mdns_query_svc_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } static struct { @@ -513,15 +514,15 @@ static int cmd_mdns_init(int argc, char **argv) return 1; } - ESP_ERROR_CHECK( mdns_init() ); + ESP_ERROR_CHECK(mdns_init()); if (mdns_init_args.hostname->sval[0]) { - ESP_ERROR_CHECK( mdns_hostname_set(mdns_init_args.hostname->sval[0]) ); + ESP_ERROR_CHECK(mdns_hostname_set(mdns_init_args.hostname->sval[0])); printf("MDNS: Hostname: %s\n", mdns_init_args.hostname->sval[0]); } if (mdns_init_args.instance->count) { - ESP_ERROR_CHECK( mdns_instance_name_set(mdns_init_args.instance->sval[0]) ); + ESP_ERROR_CHECK(mdns_instance_name_set(mdns_init_args.instance->sval[0])); printf("MDNS: Instance: %s\n", mdns_init_args.instance->sval[0]); } @@ -542,7 +543,7 @@ static void register_mdns_init(void) .argtable = &mdns_init_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); } static int cmd_mdns_free(int argc, char **argv) @@ -561,7 +562,7 @@ static void register_mdns_free(void) .argtable = NULL }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_free) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_free)); } static struct { @@ -582,7 +583,7 @@ static int cmd_mdns_set_hostname(int argc, char **argv) return 1; } - ESP_ERROR_CHECK( mdns_hostname_set(mdns_set_hostname_args.hostname->sval[0]) ); + ESP_ERROR_CHECK(mdns_hostname_set(mdns_set_hostname_args.hostname->sval[0])); return 0; } @@ -599,7 +600,7 @@ static void register_mdns_set_hostname(void) .argtable = &mdns_set_hostname_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_set_hostname) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_set_hostname)); } static struct { @@ -620,7 +621,7 @@ static int cmd_mdns_set_instance(int argc, char **argv) return 1; } - ESP_ERROR_CHECK( mdns_instance_name_set(mdns_set_instance_args.instance->sval[0]) ); + ESP_ERROR_CHECK(mdns_instance_name_set(mdns_set_instance_args.instance->sval[0])); return 0; } @@ -637,14 +638,14 @@ static void register_mdns_set_instance(void) .argtable = &mdns_set_instance_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_set_instance) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_set_instance)); } static mdns_txt_item_t *_convert_items(const char **values, int count) { int i = 0, e; const char *value = NULL; - mdns_txt_item_t *items = (mdns_txt_item_t *) malloc(sizeof(mdns_txt_item_t) * count); + mdns_txt_item_t *items = (mdns_txt_item_t *) mdns_mem_malloc(sizeof(mdns_txt_item_t) * count); if (!items) { printf("ERROR: No Memory!\n"); goto fail; @@ -661,15 +662,15 @@ static mdns_txt_item_t *_convert_items(const char **values, int count) } int var_len = esign - value; int val_len = strlen(value) - var_len - 1; - char *var = (char *)malloc(var_len + 1); + char *var = (char *)mdns_mem_malloc(var_len + 1); if (var == NULL) { printf("ERROR: No Memory!\n"); goto fail; } - char *val = (char *)malloc(val_len + 1); + char *val = (char *)mdns_mem_malloc(val_len + 1); if (val == NULL) { printf("ERROR: No Memory!\n"); - free(var); + mdns_mem_free(var); goto fail; } memcpy(var, value, var_len); @@ -685,10 +686,10 @@ static mdns_txt_item_t *_convert_items(const char **values, int count) fail: for (e = 0; e < i; e++) { - free((char *)items[e].key); - free((char *)items[e].value); + mdns_mem_free((char *)items[e].key); + mdns_mem_free((char *)items[e].value); } - free(items); + mdns_mem_free(items); return NULL; } @@ -734,9 +735,9 @@ static int cmd_mdns_service_add(int argc, char **argv) } } - ESP_ERROR_CHECK( mdns_service_add_for_host(instance, mdns_add_args.service->sval[0], mdns_add_args.proto->sval[0], - host, mdns_add_args.port->ival[0], items, mdns_add_args.txt->count) ); - free(items); + ESP_ERROR_CHECK(mdns_service_add_for_host(instance, mdns_add_args.service->sval[0], mdns_add_args.proto->sval[0], + host, mdns_add_args.port->ival[0], items, mdns_add_args.txt->count)); + mdns_mem_free(items); return 0; } @@ -758,7 +759,7 @@ static void register_mdns_service_add(void) .argtable = &mdns_add_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_add) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_add)); } static struct { @@ -791,7 +792,7 @@ static int cmd_mdns_service_remove(int argc, char **argv) host = mdns_remove_args.host->sval[0]; } - ESP_ERROR_CHECK( mdns_service_remove_for_host(instance, mdns_remove_args.service->sval[0], mdns_remove_args.proto->sval[0], host) ); + ESP_ERROR_CHECK(mdns_service_remove_for_host(instance, mdns_remove_args.service->sval[0], mdns_remove_args.proto->sval[0], host)); return 0; } @@ -811,7 +812,7 @@ static void register_mdns_service_remove(void) .argtable = &mdns_remove_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_remove) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_remove)); } static struct { @@ -869,7 +870,7 @@ static void register_mdns_service_instance_set(void) .argtable = &mdns_service_instance_set_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_add) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_add)); } static struct { @@ -927,7 +928,7 @@ static void register_mdns_service_port_set(void) .argtable = &mdns_service_port_set_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_add) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_add)); } static struct { @@ -970,8 +971,8 @@ static int cmd_mdns_service_txt_replace(int argc, char **argv) } } - ESP_ERROR_CHECK( mdns_service_txt_set_for_host(instance, mdns_txt_replace_args.service->sval[0], mdns_txt_replace_args.proto->sval[0], host, items, mdns_txt_replace_args.txt->count) ); - free(items); + ESP_ERROR_CHECK(mdns_service_txt_set_for_host(instance, mdns_txt_replace_args.service->sval[0], mdns_txt_replace_args.proto->sval[0], host, items, mdns_txt_replace_args.txt->count)); + mdns_mem_free(items); return 0; } @@ -992,7 +993,7 @@ static void register_mdns_service_txt_replace(void) .argtable = &mdns_txt_replace_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_txt_set) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_txt_set)); } static struct { @@ -1028,7 +1029,7 @@ static int cmd_mdns_service_txt_set(int argc, char **argv) printf("MDNS: Service for delegated host: %s\n", host); } - ESP_ERROR_CHECK( mdns_service_txt_item_set_for_host(instance, mdns_txt_set_args.service->sval[0], mdns_txt_set_args.proto->sval[0], host, mdns_txt_set_args.var->sval[0], mdns_txt_set_args.value->sval[0]) ); + ESP_ERROR_CHECK(mdns_service_txt_item_set_for_host(instance, mdns_txt_set_args.service->sval[0], mdns_txt_set_args.proto->sval[0], host, mdns_txt_set_args.var->sval[0], mdns_txt_set_args.value->sval[0])); return 0; } @@ -1050,7 +1051,7 @@ static void register_mdns_service_txt_set(void) .argtable = &mdns_txt_set_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_txt_set) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_txt_set)); } static struct { @@ -1082,7 +1083,7 @@ static int cmd_mdns_service_txt_remove(int argc, char **argv) if (mdns_txt_remove_args.host->count && mdns_txt_remove_args.host->sval[0]) { host = mdns_txt_remove_args.host->sval[0]; } - ESP_ERROR_CHECK( mdns_service_txt_item_remove_for_host(instance, mdns_txt_remove_args.service->sval[0], mdns_txt_remove_args.proto->sval[0], host, mdns_txt_remove_args.var->sval[0]) ); + ESP_ERROR_CHECK(mdns_service_txt_item_remove_for_host(instance, mdns_txt_remove_args.service->sval[0], mdns_txt_remove_args.proto->sval[0], host, mdns_txt_remove_args.var->sval[0])); return 0; } @@ -1103,7 +1104,7 @@ static void register_mdns_service_txt_remove(void) .argtable = &mdns_txt_remove_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_txt_remove) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_txt_remove)); } static int cmd_mdns_service_remove_all(int argc, char **argv) @@ -1122,7 +1123,7 @@ static void register_mdns_service_remove_all(void) .argtable = NULL }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_free) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_free)); } #define MDNS_MAX_LOOKUP_RESULTS CONFIG_MDNS_MAX_SERVICES @@ -1189,7 +1190,7 @@ static void register_mdns_lookup_service(void) .argtable = &mdns_lookup_service_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_lookup_service) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_lookup_service)); } static struct { @@ -1237,7 +1238,7 @@ static void register_mdns_delegate_host(void) .argtable = &mdns_delegate_host_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_delegate_host) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_delegate_host)); } static struct { @@ -1278,7 +1279,7 @@ static void register_mdns_undelegate_host(void) .argtable = &mdns_undelegate_host_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_undelegate_host) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_undelegate_host)); } static struct { @@ -1310,7 +1311,7 @@ static int cmd_mdns_service_subtype(int argc, char **argv) if (mdns_service_subtype_args.host->count && mdns_service_subtype_args.host->sval[0]) { host = mdns_service_subtype_args.host->sval[0]; } - ESP_ERROR_CHECK( mdns_service_subtype_add_for_host(instance, mdns_service_subtype_args.service->sval[0], mdns_service_subtype_args.proto->sval[0], host, mdns_service_subtype_args.sub->sval[0]) ); + ESP_ERROR_CHECK(mdns_service_subtype_add_for_host(instance, mdns_service_subtype_args.service->sval[0], mdns_service_subtype_args.proto->sval[0], host, mdns_service_subtype_args.sub->sval[0])); return 0; } @@ -1331,7 +1332,7 @@ static void register_mdns_service_subtype_set(void) .argtable = &mdns_service_subtype_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_service_sub) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_service_sub)); } static struct { @@ -1377,7 +1378,7 @@ static void register_mdns_browse(void) .argtable = &mdns_browse_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_browse) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_browse)); } static int cmd_mdns_browse_del(int argc, char **argv) @@ -1410,7 +1411,7 @@ static void register_mdns_browse_del(void) .argtable = &mdns_browse_args }; - ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_browse_del) ); + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_browse_del)); } void mdns_console_register(void) diff --git a/components/mdns/mdns_mem_caps.c b/components/mdns/mdns_mem_caps.c new file mode 100644 index 000000000..b7ad16c13 --- /dev/null +++ b/components/mdns/mdns_mem_caps.c @@ -0,0 +1,56 @@ +/* + * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include "mdns_private.h" +#include "mdns_mem_caps.h" +#include "esp_heap_caps.h" + +#ifndef MDNS_MEMORY_CAPS +#warning "No memory allocation method defined, using internal memory" +#define MDNS_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT) +#endif + +void *mdns_mem_malloc(size_t size) +{ + return heap_caps_malloc(size, MDNS_MEMORY_CAPS); +} + +void *mdns_mem_calloc(size_t num, size_t size) +{ + return heap_caps_calloc(num, size, MDNS_MEMORY_CAPS); +} + +void mdns_mem_free(void *ptr) +{ + heap_caps_free(ptr); +} + +char *mdns_mem_strdup(const char *s) +{ + if (!s) { + return NULL; + } + size_t len = strlen(s) + 1; + char *copy = (char *)heap_caps_malloc(len, MDNS_MEMORY_CAPS); + if (copy) { + memcpy(copy, s, len); + } + return copy; +} + +char *mdns_mem_strndup(const char *s, size_t n) +{ + if (!s) { + return NULL; + } + size_t len = strnlen(s, n); + char *copy = (char *)heap_caps_malloc(len + 1, MDNS_MEMORY_CAPS); + if (copy) { + memcpy(copy, s, len); + copy[len] = '\0'; + } + return copy; +} diff --git a/components/mdns/mdns_networking_lwip.c b/components/mdns/mdns_networking_lwip.c index 16604cdf1..a68672764 100644 --- a/components/mdns/mdns_networking_lwip.c +++ b/components/mdns/mdns_networking_lwip.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -20,6 +20,7 @@ #include "esp_event.h" #include "mdns_networking.h" #include "esp_netif_net_stack.h" +#include "mdns_mem_caps.h" /* * MDNS Server Networking @@ -143,7 +144,7 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip pb = pb->next; this_pb->next = NULL; - mdns_rx_packet_t *packet = (mdns_rx_packet_t *)malloc(sizeof(mdns_rx_packet_t)); + mdns_rx_packet_t *packet = (mdns_rx_packet_t *)mdns_mem_malloc(sizeof(mdns_rx_packet_t)); if (!packet) { HOOK_MALLOC_FAILED; //missed packet - no memory @@ -188,7 +189,7 @@ static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip bool found = false; for (i = 0; i < MDNS_MAX_INTERFACES; i++) { netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i)); - if (s_interfaces[i].proto && netif && netif == ip_current_input_netif ()) { + if (s_interfaces[i].proto && netif && netif == ip_current_input_netif()) { #if LWIP_IPV4 if (packet->src.type == IPADDR_TYPE_V4) { if ((packet->src.u_addr.ip4.addr & ip_2_ip4(&netif->netmask)->addr) != (ip_2_ip4(&netif->ip_addr)->addr & ip_2_ip4(&netif->netmask)->addr)) { @@ -205,7 +206,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) { pbuf_free(this_pb); - free(packet); + mdns_mem_free(packet); } } @@ -338,7 +339,7 @@ static err_t _mdns_udp_pcb_write_api(struct tcpip_api_call_data *api_call_msg) 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); + esp_err_t err = udp_sendto_if(_pcb_main, msg->pbt, msg->ip, msg->port, (struct netif *)nif); pbuf_free(msg->pbt); msg->err = err; return err; @@ -393,5 +394,5 @@ size_t _mdns_get_packet_len(mdns_rx_packet_t *packet) void _mdns_packet_free(mdns_rx_packet_t *packet) { pbuf_free(packet->pb); - free(packet); + mdns_mem_free(packet); } diff --git a/components/mdns/mdns_networking_socket.c b/components/mdns/mdns_networking_socket.c index a99a9cc2d..7bcafbb9c 100644 --- a/components/mdns/mdns_networking_socket.c +++ b/components/mdns/mdns_networking_socket.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -21,6 +21,7 @@ #include #include #include "esp_log.h" +#include "mdns_mem_caps.h" #if defined(CONFIG_IDF_TARGET_LINUX) #include @@ -87,9 +88,9 @@ size_t _mdns_get_packet_len(mdns_rx_packet_t *packet) void _mdns_packet_free(mdns_rx_packet_t *packet) { - free(packet->pb->payload); - free(packet->pb); - free(packet); + mdns_mem_free(packet->pb->payload); + mdns_mem_free(packet->pb); + mdns_mem_free(packet); } esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) @@ -297,13 +298,13 @@ void sock_recv_task(void *arg) inet_to_espaddr(&raddr, &addr, &port); // Allocate the packet structure and pass it to the mdns main engine - mdns_rx_packet_t *packet = (mdns_rx_packet_t *) calloc(1, sizeof(mdns_rx_packet_t)); - struct pbuf *packet_pbuf = calloc(1, sizeof(struct pbuf)); - uint8_t *buf = malloc(len); - if (packet == NULL || packet_pbuf == NULL || buf == NULL ) { - free(buf); - free(packet_pbuf); - free(packet); + mdns_rx_packet_t *packet = (mdns_rx_packet_t *) mdns_mem_calloc(1, sizeof(mdns_rx_packet_t)); + struct pbuf *packet_pbuf = mdns_mem_calloc(1, sizeof(struct pbuf)); + uint8_t *buf = mdns_mem_malloc(len); + if (packet == NULL || packet_pbuf == NULL || buf == NULL) { + mdns_mem_free(buf); + mdns_mem_free(packet_pbuf); + mdns_mem_free(packet); HOOK_MALLOC_FAILED; ESP_LOGE(TAG, "Failed to allocate the mdns packet"); continue; @@ -326,9 +327,9 @@ void sock_recv_task(void *arg) packet->src.type == ESP_IPADDR_TYPE_V4 ? MDNS_IP_PROTOCOL_V4 : MDNS_IP_PROTOCOL_V6; if (_mdns_send_rx_action(packet) != ESP_OK) { ESP_LOGE(TAG, "_mdns_send_rx_action failed!"); - free(packet->pb->payload); - free(packet->pb); - free(packet); + mdns_mem_free(packet->pb->payload); + mdns_mem_free(packet->pb); + mdns_mem_free(packet); } } } @@ -341,7 +342,7 @@ static void mdns_networking_init(void) { if (s_run_sock_recv_task == false) { s_run_sock_recv_task = true; - xTaskCreate( sock_recv_task, "mdns recv task", 3 * 1024, NULL, 5, NULL ); + xTaskCreate(sock_recv_task, "mdns recv task", 3 * 1024, NULL, 5, NULL); } } @@ -392,7 +393,7 @@ static int create_socket(esp_netif_t *netif) } int on = 1; - if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) < 0) { + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { ESP_LOGE(TAG, "Failed setsockopt() to set SO_REUSEADDR. errno=%d: %s\n", errno, strerror(errno)); } // Bind the socket to any address @@ -419,7 +420,7 @@ static int create_socket(esp_netif_t *netif) #endif // CONFIG_LWIP_IPV6 struct ifreq ifr; esp_netif_get_netif_impl_name(netif, ifr.ifr_name); - int ret = setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, (void *)&ifr, sizeof(struct ifreq)); + int ret = setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, (void *)&ifr, sizeof(struct ifreq)); if (ret < 0) { ESP_LOGE(TAG, "\"%s\" Unable to bind socket to specified interface. errno=%d: %s", esp_netif_get_desc(netif), errno, strerror(errno)); goto err; diff --git a/components/mdns/mem_prefix_script.py b/components/mdns/mem_prefix_script.py new file mode 100644 index 000000000..b9af09d32 --- /dev/null +++ b/components/mdns/mem_prefix_script.py @@ -0,0 +1,54 @@ +# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Apache-2.0 +import re +import sys + +# Configurable prefix for memory functions +MDNS_MEM_PREFIX = 'mdns_mem_' # Change this to modify the prefix + + +def add_prefix_to_mem_funcs(content): + # List of memory functions to prefix + mem_funcs = [ + 'malloc', + 'calloc', + 'free', + 'strdup', + 'strndup' + ] + + # Create regex pattern matching the memory functions but not already prefixed ones + pattern = fr'(?') + sys.exit(1) + + process_file(sys.argv[1]) diff --git a/components/mdns/private_include/mdns_mem_caps.h b/components/mdns/private_include/mdns_mem_caps.h new file mode 100644 index 000000000..d9c1c3feb --- /dev/null +++ b/components/mdns/private_include/mdns_mem_caps.h @@ -0,0 +1,52 @@ +/* + * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Allocate memory. + * @param size Number of bytes to allocate. + * @return Pointer to allocated memory, or NULL on failure. + */ +void *mdns_mem_malloc(size_t size); + +/** + * @brief Allocate and zero memory. + * @param num Number of elements. + * @param size Size of each element. + * @return Pointer to allocated memory, or NULL on failure. + */ +void *mdns_mem_calloc(size_t num, size_t size); + +/** + * @brief Free allocated memory. + * @param ptr Pointer to memory to free. + */ +void mdns_mem_free(void *ptr); + +/** + * @brief Duplicate a string. + * @param s String to duplicate. + * @return Pointer to duplicated string, or NULL on failure. + */ +char *mdns_mem_strdup(const char *s); + +/** + * @brief Duplicate a string with length limit. + * @param s String to duplicate. + * @param n Maximum number of characters to copy. + * @return Pointer to duplicated string, or NULL on failure. + */ +char *mdns_mem_strndup(const char *s, size_t n); + +#ifdef __cplusplus +} +#endif diff --git a/components/mdns/private_include/mdns_private.h b/components/mdns/private_include/mdns_private.h index 8976ed1e7..f1c38975b 100644 --- a/components/mdns/private_include/mdns_private.h +++ b/components/mdns/private_include/mdns_private.h @@ -36,6 +36,13 @@ #define MDNS_TASK_MEMORY_LOG "internal RAM" #endif +#if CONFIG_MDNS_MEMORY_ALLOC_SPIRAM +#define MDNS_MEMORY_CAPS (MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT) +#endif +#if CONFIG_MDNS_MEMORY_ALLOC_INTERNAL +#define MDNS_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT) +#endif + /** Number of predefined interfaces */ #ifndef CONFIG_MDNS_PREDEF_NETIF_STA #define CONFIG_MDNS_PREDEF_NETIF_STA 0 diff --git a/components/mdns/tests/test_afl_fuzz_host/esp32_mock.c b/components/mdns/tests/test_afl_fuzz_host/esp32_mock.c index 237e987cf..66e1cf00e 100644 --- a/components/mdns/tests/test_afl_fuzz_host/esp32_mock.c +++ b/components/mdns/tests/test_afl_fuzz_host/esp32_mock.c @@ -135,3 +135,28 @@ void heap_caps_free(void *ptr) { free(ptr); } + +void *mdns_mem_malloc(size_t size) +{ + return malloc(size); +} + +void *mdns_mem_calloc(size_t num, size_t size) +{ + return calloc(num, size); +} + +void mdns_mem_free(void *ptr) +{ + free(ptr); +} + +char *mdns_mem_strdup(const char *s) +{ + return strdup(s); +} + +char *mdns_mem_strndup(const char *s, size_t n) +{ + return strndup(s, n); +}