espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-29 18:27:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #764 from david-cermak/feat/mdns_malloc_caps

Browse Source 
[mdns]: Allow allocate memory with configured caps
This commit is contained in:
david-cermak
2025-02-18 13:23:41 +01:00
committed by GitHub
parent f1a72ec42c 384d1c23ba
commit dea5f1c431
16 changed files with 692 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
.github/workflows/mdns__host-tests.yml vendored
View File

@ -35,30 +35,36 @@ jobs:
# Next we run the pytest (using the console app)
pytest
build_afl_host_test_mdns:
host_compat_checks:
if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
name: Build AFL host test
name: Set of compatibility checks
strategy:
matrix:
idf_ver: ["latest"]
idf_target: ["esp32"]
runs-on: ubuntu-22.04
container: espressif/idf:${{ matrix.idf_ver }}
steps:
- name: Checkout esp-protocols
uses: actions/checkout@v4
with:
path: esp-protocols
- name: Install Necessary Libs
run: |
apt-get update -y
apt-get install -y libbsd-dev
- name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
env:
IDF_TARGET: ${{ matrix.idf_target }}
- name: Test AFL compat build
shell: bash
run: |
. ${IDF_PATH}/export.sh
cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/test_afl_fuzz_host/
cd components/mdns/tests/test_afl_fuzz_host/
make INSTR=off
- name: Test no malloc functions
shell: bash
run: |
cd components/mdns
for file in $(ls *.c); do
cp $file /tmp
echo -n "Checking that $file does not call any std allocations directly..."
python mem_prefix_script.py $file
diff -q $file /tmp/$file || exit 1
echo "OK"
done

2
components/mdns/.cz.yaml
View File

@ -3,6 +3,6 @@ commitizen:
bump_message: 'bump(mdns): $current_version -> $new_version'
pre_bump_hooks: python ../../ci/changelog.py mdns
tag_format: mdns-v$version
version: 1.6.0
version: 1.7.0
version_files:
- idf_component.yml

11
components/mdns/CHANGELOG.md
View File

@ -1,5 +1,16 @@
# Changelog
## [1.7.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.7.0)
### Features
- Support user defined allocators ([88162d1f](https://github.com/espressif/esp-protocols/commit/88162d1f))
- Allow allocate memory with configured caps ([7d29b476](https://github.com/espressif/esp-protocols/commit/7d29b476))
### Bug Fixes
- Adjust some formatting per indent-cont=120 ([5b2077e3](https://github.com/espressif/esp-protocols/commit/5b2077e3))
## [1.6.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.6.0)
### Features

6
components/mdns/CMakeLists.txt
View File

@ -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(

50
components/mdns/Kconfig
View File

@ -61,15 +61,47 @@ menu "mDNS"
default 0x0 if MDNS_TASK_AFFINITY_CPU0
default 0x1 if MDNS_TASK_AFFINITY_CPU1
choice MDNS_TASK_MEMORY_ALLOC_FROM
prompt "Select mDNS task create on which type of memory"
default MDNS_TASK_CREATE_FROM_INTERNAL
config MDNS_TASK_CREATE_FROM_SPIRAM
bool "mDNS task creates on the SPIRAM"
depends on (SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC)
config MDNS_TASK_CREATE_FROM_INTERNAL
bool "mDNS task creates on the internal RAM"
endchoice
menu "MDNS Memory Configuration"
choice MDNS_TASK_MEMORY_ALLOC_FROM
prompt "Select mDNS task create on which type of memory"
default MDNS_TASK_CREATE_FROM_INTERNAL
config MDNS_TASK_CREATE_FROM_SPIRAM
bool "mDNS task creates on the SPIRAM (READ HELP)"
depends on (SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC)
help
mDNS task creates on the SPIRAM.
This option requires FreeRTOS component to allow creating
tasks on the external memory.
Please read the documentation about FREERTOS_TASK_CREATE_ALLOW_EXT_MEM
config MDNS_TASK_CREATE_FROM_INTERNAL
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_MEMORY_CUSTOM_IMPL
bool "Implement custom memory functions"
default n
help
Enable to implement custom memory functions for mDNS library.
This option is useful when the application wants to use custom
memory allocation functions for mDNS library.
endmenu # MDNS Memory Configuration
config MDNS_SERVICE_ADD_TIMEOUT_MS
int "mDNS adding service timeout (ms)"

2
components/mdns/idf_component.yml
View File

@ -1,4 +1,4 @@
version: "1.6.0"
version: "1.7.0"
description: "Multicast UDP service used to provide local network service and host discovery."
url: "https://github.com/espressif/esp-protocols/tree/master/components/mdns"
issues: "https://github.com/espressif/esp-protocols/issues"

609
components/mdns/mdns.c
View File

File diff suppressed because it is too large Load Diff

95
components/mdns/mdns_console.c
View File

@ -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)

96
components/mdns/mdns_mem_caps.c Normal file
View File

@ -0,0 +1,96 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#include "sdkconfig.h"
#include "mdns_private.h"
#include "mdns_mem_caps.h"
#include "esp_heap_caps.h"
#include "esp_log.h"
#if CONFIG_MDNS_MEMORY_CUSTOM_IMPL
#define ALLOW_WEAK __attribute__((weak))
#else
#define ALLOW_WEAK
#endif
#if CONFIG_MDNS_TASK_CREATE_FROM_SPIRAM
#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT)
#define MDNS_TASK_MEMORY_LOG "SPIRAM"
#endif
#if CONFIG_MDNS_TASK_CREATE_FROM_INTERNAL
#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
#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
// Allocate memory from internal heap as default.
#ifndef MDNS_MEMORY_CAPS
#warning "No memory allocation method defined, using internal memory"
#define MDNS_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
#endif
#ifndef MDNS_TASK_MEMORY_CAPS
#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
#define MDNS_TASK_MEMORY_LOG "internal RAM"
#endif
void ALLOW_WEAK *mdns_mem_malloc(size_t size)
{
return heap_caps_malloc(size, MDNS_MEMORY_CAPS);
}
void ALLOW_WEAK *mdns_mem_calloc(size_t num, size_t size)
{
return heap_caps_calloc(num, size, MDNS_MEMORY_CAPS);
}
void ALLOW_WEAK mdns_mem_free(void *ptr)
{
heap_caps_free(ptr);
}
char ALLOW_WEAK *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 ALLOW_WEAK *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;
}
void ALLOW_WEAK *mdns_mem_task_malloc(size_t size)
{
ESP_LOGI("mdns_mem", "mDNS task will be created from %s", MDNS_TASK_MEMORY_LOG);
return heap_caps_malloc(size, MDNS_TASK_MEMORY_CAPS);
}
void ALLOW_WEAK mdns_mem_task_free(void *ptr)
{
heap_caps_free(ptr);
}

13
components/mdns/mdns_networking_lwip.c
View File

@ -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);
}

35
components/mdns/mdns_networking_socket.c
View File

@ -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 <unistd.h>
#include <sys/param.h>
#include "esp_log.h"
#include "mdns_mem_caps.h"
#if defined(CONFIG_IDF_TARGET_LINUX)
#include <sys/ioctl.h>
@ -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;

54
components/mdns/mem_prefix_script.py Normal file
View File

@ -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'(?<!{MDNS_MEM_PREFIX})(?<![\w])(' + '|'.join(mem_funcs) + r')(?=\s*\()'
# Replace all occurrences with configured prefix
modified = re.sub(pattern, fr'{MDNS_MEM_PREFIX}\1', content)
return modified
def process_file(filename):
try:
# Read the file
with open(filename, 'r') as f:
content = f.read()
# Add prefixes
modified = add_prefix_to_mem_funcs(content)
# Write back to file
with open(filename, 'w') as f:
f.write(modified)
print(f'Successfully processed {filename}')
except Exception as e:
print(f'Error processing {filename}: {str(e)}')
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) != 2:
print('Usage: python script.py <filename>')
sys.exit(1)
process_file(sys.argv[1])

65
components/mdns/private_include/mdns_mem_caps.h Normal file
View File

@ -0,0 +1,65 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <stddef.h>
#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);
/**
* @brief Allocate memory for mDNS task.
* @param size Number of bytes to allocate.
* @return Pointer to allocated memory, or NULL on failure.
*/
void *mdns_mem_task_malloc(size_t size);
/**
* @brief Free allocated memory for mDNS task.
* @param ptr Pointer to memory to free.
*/
void mdns_mem_task_free(void *ptr);
#ifdef __cplusplus
}
#endif

15
components/mdns/private_include/mdns_private.h
View File

@ -21,21 +21,6 @@
#define _mdns_dbg_printf(...) printf(__VA_ARGS__)
#endif
#if CONFIG_MDNS_TASK_CREATE_FROM_SPIRAM
#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT)
#define MDNS_TASK_MEMORY_LOG "SPIRAM"
#endif
#if CONFIG_MDNS_TASK_CREATE_FROM_INTERNAL
#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
#define MDNS_TASK_MEMORY_LOG "internal RAM"
#endif
// Allocate memory from internal heap as default.
#ifndef MDNS_TASK_MEMORY_CAPS
#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
#define MDNS_TASK_MEMORY_LOG "internal RAM"
#endif
/** Number of predefined interfaces */
#ifndef CONFIG_MDNS_PREDEF_NETIF_STA
#define CONFIG_MDNS_PREDEF_NETIF_STA 0

29
components/mdns/tests/test_afl_fuzz_host/esp32_mock.c
View File

@ -126,12 +126,37 @@ uint32_t esp_log_timestamp(void)
return 0;
}
void *heap_caps_malloc(size_t size, uint32_t caps)
void *mdns_mem_malloc(size_t size)
{
return malloc(size);
}
void heap_caps_free(void *ptr)
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);
}
void *mdns_mem_task_malloc(size_t size)
{
return malloc(size);
}
void mdns_mem_task_free(void *ptr)
{
free(ptr);
}

2
components/mdns/tests/test_afl_fuzz_host/esp32_mock.h
View File

@ -138,7 +138,5 @@ esp_err_t esp_event_handler_unregister(const char *event_base, int32_t event_id,
TaskHandle_t xTaskGetCurrentTaskHandle(void);
void xTaskNotifyGive(TaskHandle_t task);
BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time);
void *heap_caps_malloc(size_t size, uint32_t caps);
void heap_caps_free(void *ptr);
#endif //_ESP32_COMPAT_H_