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

[mdns]: Allow allocate memory with configured caps

.github/workflows/asio__build-target-test.yml

@@ -13,7 +13,7 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
         idf_target: ["esp32", "esp32s2"]
         example: ["asio_chat", "async_request", "socks4", "ssl_client_server", "tcp_echo_server", "udp_echo_server"]
     runs-on: ubuntu-22.04
@@ -64,7 +64,7 @@ jobs:
     name: Target tests
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0", "release-v5.2", "release-v5.3"]
+        idf_ver: ["latest", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
         idf_target: ["esp32"]
         example: ["asio_chat", "tcp_echo_server", "udp_echo_server", "ssl_client_server"]
     needs: build_asio

.github/workflows/mdns__host-tests.yml

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

.github/workflows/modem__target-test.yml

@@ -42,7 +42,7 @@ jobs:
           idf.py set-target ${{ matrix.idf_target }}
           idf.py build
           $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh ${GITHUB_WORKSPACE}/${TEST_DIR}/build
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/build
@@ -75,7 +75,7 @@ jobs:
         run: |
           sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
       - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/build

.github/workflows/mosq__build.yml

@@ -17,7 +17,8 @@ jobs:
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
-      TEST_DIR: components/mosquitto/examples/broker
+      TEST_DIR: components/mosquitto/examples
+      TARGET_TEST: broker
       TARGET_TEST_DIR: build_esp32_default
     steps:
       - name: Checkout esp-protocols
@@ -29,14 +30,15 @@ jobs:
         run: |
           . ${IDF_PATH}/export.sh
           pip install idf-component-manager idf-build-apps --upgrade
-          python ci/build_apps.py ${TEST_DIR}
-          cd ${TEST_DIR}
+          python ci/build_apps.py -c ${TEST_DIR} -m components/mosquitto/.build-test-rules.yml
+          # upload only the target test artifacts
+          cd ${TEST_DIR}/${TARGET_TEST}
           ${GITHUB_WORKSPACE}/ci/clean_build_artifacts.sh `pwd`/${TARGET_TEST_DIR}
           zip -qur artifacts.zip ${TARGET_TEST_DIR}
       - uses: actions/upload-artifact@v4
         with:
           name: mosq_target_esp32_${{ matrix.idf_ver }}
-          path: ${{ env.TEST_DIR }}/artifacts.zip
+          path: ${{ env.TEST_DIR }}/${{ env.TARGET_TEST }}/artifacts.zip
           if-no-files-found: error
 
   test_mosq:
@@ -71,3 +73,108 @@ jobs:
           mv $dir build
           python -m pytest --log-cli-level DEBUG --junit-xml=./results_esp32_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=esp32
           done
+
+  check_consistency:
+    if: contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push'
+    name: Checks that API docs and versions are consistent
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Checks API Docs and versions
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install doxygen
+          pip install esp-doxybook
+          cd components/mosquitto
+          cp api.md api_orig.md
+          ./generate_api_docs.sh
+          diff -wB api.md api_orig.md
+          # check version consistency
+          CONFIG_VERSION=$(grep -Po '(?<=#define VERSION ")[^"]*' port/priv_include/config.h)
+          CZ_VERSION=$(grep -Po '(?<=version: )[^"]*' .cz.yaml)
+          COMP_VERSION=$(grep -Po '(?<=version: ")[^"]*' idf_component.yml)
+          if [ "$CONFIG_VERSION" != "v$CZ_VERSION" ] || [ "$CONFIG_VERSION" != "v$COMP_VERSION" ]; then
+            echo "Version mismatch detected:"
+            echo "config.h: $CONFIG_VERSION"
+            echo ".cz.yaml: $CZ_VERSION"
+            echo "idf_component.yml: $COMP_VERSION"
+            exit 1
+          fi
+          echo "Versions are consistent: $CONFIG_VERSION"
+
+  build_idf_tests_with_mosq:
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push' )
+    name: Build IDF tests
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32"]
+        test: [ { app: publish, path: "tools/test_apps/protocols/mqtt/publish_connect_test" }]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TARGET_TEST_DIR: build_esp32_local_broker
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install idf-component-manager idf-build-apps --upgrade
+          export MOSQUITTO_PATH=`pwd`/components/mosquitto
+          # to use the actual version of mosquitto
+          sed -i '/espressif\/mosquitto:/a \ \ \ \ override_path: "${MOSQUITTO_PATH}"' ${IDF_PATH}/${{matrix.test.path}}/main/idf_component.yml
+          export PEDANTIC_FLAGS="-DIDF_CI_BUILD -Werror -Werror=deprecated-declarations -Werror=unused-variable -Werror=unused-but-set-variable -Werror=unused-function"
+          export EXTRA_CFLAGS="${PEDANTIC_FLAGS} -Wstrict-prototypes"
+          export EXTRA_CXXFLAGS="${PEDANTIC_FLAGS}"
+          cd ${IDF_PATH}/${{matrix.test.path}}
+          idf-build-apps find --config sdkconfig.ci.local_broker -vv --target ${{ matrix.idf_target }} --build-dir=${TARGET_TEST_DIR}
+          idf-build-apps build --config sdkconfig.ci.local_broker -vv --target ${{ matrix.idf_target }} --build-dir=${TARGET_TEST_DIR}
+          ${GITHUB_WORKSPACE}/ci/clean_build_artifacts.sh `pwd`/${TARGET_TEST_DIR}
+          # to replace mqtt test configs with specific mosquitto markers
+          python ${MOSQUITTO_PATH}/test/replace_decorators.py pytest_mqtt_publish_app.py ${TARGET_TEST_DIR}/pytest_mosquitto.py
+          zip -qur ${GITHUB_WORKSPACE}/artifacts.zip ${TARGET_TEST_DIR}
+      - uses: actions/upload-artifact@v4
+        with:
+          name: mosq_publish_esp32_${{ matrix.idf_ver }}
+          path: artifacts.zip
+          if-no-files-found: error
+
+  test_idf_ci_with_mosq:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push' )
+    name: Mosquitto IDF target tests
+    needs: build_idf_tests_with_mosq
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: examples
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: mosq_publish_esp32_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/ci/
+      - name: Run Test
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          python -m pip install pytest-embedded-serial-esp pytest-embedded-idf pytest-rerunfailures pytest-timeout pytest-ignore-test-results "paho-mqtt<2"
+          unzip ci/artifacts.zip -d ci
+          for dir in `ls -d ci/build_*`; do
+          rm -rf build sdkconfig.defaults
+          mv $dir build
+          mv build/*.py .
+          # Run only "test_mosquitto" marked tests
+          python -m pytest --log-cli-level DEBUG --junit-xml=./results_esp32_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=esp32 -m test_mosquitto
+          done

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "components/asio/asio"]
 	path = components/asio/asio
-	url = https://github.com/espressif/asio
+	url = https://github.com/chriskohlhoff/asio
 [submodule "components/mosquitto/mosquitto"]
 	path = components/mosquitto/mosquitto
 	url = https://github.com/eclipse/mosquitto

.pre-commit-config.yaml

@@ -51,7 +51,7 @@ repos:
     rev: v1.0.5
     hooks:
     -   id: astyle_py
-        args: ['--style=otbs', '--attach-namespaces', '--attach-classes', '--indent=spaces=4', '--convert-tabs', '--align-pointer=name', '--align-reference=name', '--keep-one-line-statements', '--pad-header', '--pad-oper', '--exclude-list=ci/ignore_astyle.txt']
+        args: ['--style=otbs', '--attach-namespaces', '--attach-classes', '--indent=spaces=4', '--convert-tabs', '--align-reference=name', '--keep-one-line-statements', '--pad-header', '--pad-oper', '--unpad-paren', '--max-continuation-indent=120', '--exclude-list=ci/ignore_astyle.txt']
   - repo: https://github.com/commitizen-tools/commitizen
     rev: v2.42.1
     hooks:

ci/check_copyright_ignore.txt

@@ -0,0 +1 @@
+components/mosquitto/examples/serverless_mqtt/components/libjuice/port/juice_random.c

common_components/linux_compat/freertos/freertos_linux.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
  */
@@ -64,7 +64,7 @@ static struct generic_queue_handle *create_generic_queue(queue_type_t type, uint
     return h;
 }
 
-QueueHandle_t xQueueCreate(uint32_t uxQueueLength, uint32_t uxItemSize )
+QueueHandle_t xQueueCreate(uint32_t uxQueueLength, uint32_t uxItemSize)
 {
     return (QueueHandle_t)create_generic_queue(QUEUE, uxQueueLength, uxItemSize);
 }
@@ -75,7 +75,7 @@ uint32_t xQueueSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t
     return osal_queue_send(h->q, (uint8_t *)pvItemToQueue, h->item_size) ? pdTRUE : pdFAIL;
 }
 
-uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait )
+uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
 {
     return xQueueSend(xQueue, pvItemToQueue, xTicksToWait);
 }
@@ -86,7 +86,7 @@ uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksTo
     return osal_queue_recv(h->q, (uint8_t *)pvBuffer, h->item_size, xTicksToWait) ? pdTRUE : pdFAIL;
 }
 
-BaseType_t xSemaphoreGive( QueueHandle_t xQueue)
+BaseType_t xSemaphoreGive(QueueHandle_t xQueue)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX) {
@@ -96,7 +96,7 @@ BaseType_t xSemaphoreGive( QueueHandle_t xQueue)
     return xQueueSend(xQueue, &s_semaphore_data, portMAX_DELAY);
 }
 
-BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue)
+BaseType_t xSemaphoreGiveRecursive(QueueHandle_t xQueue)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX_REC) {
@@ -106,7 +106,7 @@ BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue)
     return pdFALSE;
 }
 
-BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask )
+BaseType_t xSemaphoreTake(QueueHandle_t xQueue, TickType_t pvTask)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX) {
@@ -116,7 +116,7 @@ BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask )
     return xQueueReceive(xQueue, &s_semaphore_data, portMAX_DELAY);
 }
 
-BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask )
+BaseType_t xSemaphoreTakeRecursive(QueueHandle_t xQueue, TickType_t pvTask)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX_REC) {
@@ -126,7 +126,7 @@ BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask )
     return pdFALSE;
 }
 
-void vQueueDelete( QueueHandle_t xQueue )
+void vQueueDelete(QueueHandle_t xQueue)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->q) {
@@ -176,14 +176,14 @@ void vTaskSuspend(void *task)
     vTaskDelete(task);
 }
 
-TickType_t xTaskGetTickCount( void )
+TickType_t xTaskGetTickCount(void)
 {
     struct timespec spec;
     clock_gettime(CLOCK_REALTIME, &spec);
     return spec.tv_nsec / 1000000 + spec.tv_sec * 1000;
 }
 
-void vTaskDelay( const TickType_t xTicksToDelay )
+void vTaskDelay(const TickType_t xTicksToDelay)
 {
     usleep(xTicksToDelay * 1000);
 }
@@ -212,13 +212,27 @@ void *pthread_task(void *params)
     return NULL;
 }
 
-BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
-                                    const char *const pcName,
-                                    const uint32_t usStackDepth,
-                                    void *const pvParameters,
-                                    UBaseType_t uxPriority,
-                                    TaskHandle_t *const pvCreatedTask,
-                                    const BaseType_t xCoreID)
+TaskHandle_t xTaskCreateStaticPinnedToCore(TaskFunction_t pxTaskCode,
+                                           const char *const pcName,
+                                           const uint32_t ulStackDepth,
+                                           void *const pvParameters,
+                                           UBaseType_t uxPriority,
+                                           StackType_t *const puxStackBuffer,
+                                           StaticTask_t *const pxTaskBuffer,
+                                           const BaseType_t xCoreID)
+{
+    static TaskHandle_t pvCreatedTask;
+    xTaskCreate(pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, &pvCreatedTask);
+    return pvCreatedTask;
+}
+
+BaseType_t xTaskCreatePinnedToCore(TaskFunction_t pvTaskCode,
+                                   const char *const pcName,
+                                   const uint32_t usStackDepth,
+                                   void *const pvParameters,
+                                   UBaseType_t uxPriority,
+                                   TaskHandle_t *const pvCreatedTask,
+                                   const BaseType_t xCoreID)
 {
     xTaskCreate(pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask);
     return pdTRUE;
@@ -266,7 +280,7 @@ 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 )
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time)
 {
     return true;
 }
@@ -276,32 +290,32 @@ TaskHandle_t xTaskGetCurrentTaskHandle(void)
     return (TaskHandle_t)pthread_self();
 }
 
-EventGroupHandle_t xEventGroupCreate( void )
+EventGroupHandle_t xEventGroupCreate(void)
 {
     return osal_signal_create();
 }
 
-void vEventGroupDelete( EventGroupHandle_t xEventGroup )
+void vEventGroupDelete(EventGroupHandle_t xEventGroup)
 {
     osal_signal_delete(xEventGroup);
 }
 
-EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
+EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear)
 {
     return osal_signal_clear(xEventGroup, uxBitsToClear);
 }
 
-EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup)
+EventBits_t xEventGroupGetBits(EventGroupHandle_t xEventGroup)
 {
     return osal_signal_get(xEventGroup);
 }
 
-EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
+EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet)
 {
     return osal_signal_set(xEventGroup, uxBitsToSet);
 }
 
-EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
+EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait)
 {
     return osal_signal_wait(xEventGroup, uxBitsToWaitFor, xWaitForAllBits, xTicksToWait);
 }

common_components/linux_compat/freertos/include/freertos/task.h

@@ -1,11 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
 
 #include "freertos/FreeRTOS.h"
+#include "esp_heap_caps.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -15,7 +16,10 @@ extern "C" {
 #define TaskHandle_t TaskHandle_t
 #define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
 
-void vTaskDelay( const TickType_t xTicksToDelay );
+typedef void *StackType_t;
+typedef void *StaticTask_t;
+
+void vTaskDelay(const TickType_t xTicksToDelay);
 
 void xTaskNotifyGive(TaskHandle_t task);
 
@@ -23,39 +27,48 @@ void ulTaskNotifyTake(bool stuff, uint32_t timeout);
 
 TaskHandle_t xTaskGetCurrentTaskHandle(void);
 
-BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time );
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time);
 
-BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
-                                    const char *const pcName,
-                                    const uint32_t usStackDepth,
-                                    void *const pvParameters,
-                                    UBaseType_t uxPriority,
-                                    TaskHandle_t *const pvCreatedTask,
-                                    const BaseType_t xCoreID);
+TaskHandle_t xTaskCreateStaticPinnedToCore(TaskFunction_t pxTaskCode,
+                                           const char *const pcName,
+                                           const uint32_t ulStackDepth,
+                                           void *const pvParameters,
+                                           UBaseType_t uxPriority,
+                                           StackType_t *const puxStackBuffer,
+                                           StaticTask_t *const pxTaskBuffer,
+                                           const BaseType_t xCoreID);
+
+BaseType_t xTaskCreatePinnedToCore(TaskFunction_t pvTaskCode,
+                                   const char *const pcName,
+                                   const uint32_t usStackDepth,
+                                   void *const pvParameters,
+                                   UBaseType_t uxPriority,
+                                   TaskHandle_t *const pvCreatedTask,
+                                   const BaseType_t xCoreID);
 
 BaseType_t xTaskCreate(TaskFunction_t pvTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pvCreatedTask);
 
-TickType_t xTaskGetTickCount( void );
+TickType_t xTaskGetTickCount(void);
 
-void vQueueDelete( QueueHandle_t xQueue );
+void vQueueDelete(QueueHandle_t xQueue);
 
 QueueHandle_t xSemaphoreCreateBinary(void);
 
 QueueHandle_t xSemaphoreCreateMutex(void);
 QueueHandle_t xSemaphoreCreateRecursiveMutex(void);
 
-BaseType_t xSemaphoreGive( QueueHandle_t xQueue);
+BaseType_t xSemaphoreGive(QueueHandle_t xQueue);
 
-BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask );
+BaseType_t xSemaphoreTake(QueueHandle_t xQueue, TickType_t pvTask);
 
-BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue);
+BaseType_t xSemaphoreGiveRecursive(QueueHandle_t xQueue);
 
-BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask );
+BaseType_t xSemaphoreTakeRecursive(QueueHandle_t xQueue, TickType_t pvTask);
 
 void vTaskDelete(TaskHandle_t *task);
 
-QueueHandle_t xQueueCreate( uint32_t uxQueueLength,
-                            uint32_t uxItemSize );
+QueueHandle_t xQueueCreate(uint32_t uxQueueLength,
+                           uint32_t uxItemSize);
 
 uint32_t xQueueSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait);
 
@@ -63,23 +76,26 @@ uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksTo
 
 void vTaskSuspend(void *task);
 
-EventGroupHandle_t xEventGroupCreate( void );
-void vEventGroupDelete( EventGroupHandle_t xEventGroup );
-EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
-                                  const EventBits_t uxBitsToClear );
+EventGroupHandle_t xEventGroupCreate(void);
+void vEventGroupDelete(EventGroupHandle_t xEventGroup);
+EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,
+                                 const EventBits_t uxBitsToClear);
 
-EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
-                                 const EventBits_t uxBitsToWaitFor,
-                                 const BaseType_t xClearOnExit,
-                                 const BaseType_t xWaitForAllBits,
-                                 TickType_t xTicksToWait );
+EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup,
+                                const EventBits_t uxBitsToWaitFor,
+                                const BaseType_t xClearOnExit,
+                                const BaseType_t xWaitForAllBits,
+                                TickType_t xTicksToWait);
 
-EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup);
+EventBits_t xEventGroupGetBits(EventGroupHandle_t xEventGroup);
 
-EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
-                                const EventBits_t uxBitsToSet );
+EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup,
+                               const EventBits_t uxBitsToSet);
 
-uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait );
+uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait);
+
+void *heap_caps_malloc(size_t size, uint32_t caps);
+void heap_caps_free(void *ptr);
 
 #ifdef __cplusplus
 }

components/asio/.cz.yaml

@@ -1,7 +1,8 @@
+---
 commitizen:
   bump_message: 'bump(asio): $current_version -> $new_version'
   pre_bump_hooks: python ../../ci/changelog.py asio
   tag_format: asio-v$version
-  version: 1.28.0~0
+  version: 1.32.0
   version_files:
   - idf_component.yml

components/asio/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [1.32.0](https://github.com/espressif/esp-protocols/commits/asio-v1.32.0)
+
+### Features
+
+- Upgrade asio to 1.32 ([9bdd429c](https://github.com/espressif/esp-protocols/commit/9bdd429c))
+- Drop esp/asio patches in favor of sock-utils ([27435b7f](https://github.com/espressif/esp-protocols/commit/27435b7f))
+
+### Bug Fixes
+
+- Fix chat example to print only the message body ([76aaea08](https://github.com/espressif/esp-protocols/commit/76aaea08))
+- Make asio enable if_nametoindex to fix linking ([5db32cce](https://github.com/espressif/esp-protocols/commit/5db32cce))
+- Re-applie refs to common comps idf_component.yml ([9fe44a45](https://github.com/espressif/esp-protocols/commit/9fe44a45))
+- Reference common component from IDF ([74fc228c](https://github.com/espressif/esp-protocols/commit/74fc228c))
+- Revert referencing protocol_examples_common from IDF ([f9e0281a](https://github.com/espressif/esp-protocols/commit/f9e0281a))
+- reference protocol_examples_common from IDF ([09abb18b](https://github.com/espressif/esp-protocols/commit/09abb18b))
+- specify override_path in example manifest files ([1d8923cf](https://github.com/espressif/esp-protocols/commit/1d8923cf))
+
+### Updated
+
+- docs(asio): Updates asio docs ([ce9337d3](https://github.com/espressif/esp-protocols/commit/ce9337d3))
+
 ## [1.28.2~0](https://github.com/espressif/esp-protocols/commits/asio-1.28.2_0)
 
 ### Bug Fixes

components/asio/CMakeLists.txt

@@ -6,8 +6,8 @@ if(NOT CONFIG_LWIP_IPV6 AND NOT CMAKE_BUILD_EARLY_EXPANSION)
     return()
 endif()
 
-set(asio_sources "asio/asio/src/asio.cpp")
-set(asio_requires lwip)
+set(asio_sources "asio/asio/src/asio.cpp" "port/src/asio_stub.cpp")
+set(asio_requires lwip sock_utils)
 
 if(CONFIG_ASIO_SSL_SUPPORT)
     list(APPEND asio_sources
@@ -18,7 +18,7 @@ if(CONFIG_ASIO_SSL_SUPPORT)
 endif()
 
 idf_component_register(SRCS ${asio_sources}
-                    INCLUDE_DIRS "asio/asio/include" "port/include"
+                    INCLUDE_DIRS "port/include" "asio/asio/include"
                     PRIV_INCLUDE_DIRS ${asio_priv_includes}
                     PRIV_REQUIRES ${asio_requires})
 
@@ -30,6 +30,7 @@ target_compile_definitions(${COMPONENT_LIB} PUBLIC SA_RESTART=0x01
                                                    ASIO_STANDALONE
                                                    ASIO_HAS_PTHREADS
                                                    OPENSSL_NO_ENGINE
+                                                   ASIO_DETAIL_IMPL_POSIX_EVENT_IPP  # this replaces asio's posix_event constructor
 )
 
 if(NOT CONFIG_COMPILER_CXX_EXCEPTIONS)

components/asio/Kconfig

@@ -1,6 +1,15 @@
 menu "ESP-ASIO"
     visible if LWIP_IPV6
 
+    config ASIO_IS_ENABLED
+        # Invisible option that is enabled if ASIO is added to the IDF components.
+        # This is used to "select" LWIP_NETIF_API option
+        # which enables if_indextoname() and if_nametoindex() functions
+        # (these are optionally used in asio)
+        bool
+        default "y"
+        select LWIP_NETIF_API
+
     config ASIO_SSL_SUPPORT
         bool "Enable SSL/TLS support of ASIO"
         default n

components/asio/examples/asio_chat/main/server.hpp

@@ -120,7 +120,7 @@ private:
                          asio::buffer(read_msg_.body(), read_msg_.body_length()),
         [this, self](std::error_code ec, std::size_t /*length*/) {
             if (!ec) {
-                ESP_LOGD("asio-chat:", "%s", read_msg_.body());
+                ESP_LOGD("asio-chat", "%.*s", read_msg_.body_length(), read_msg_.body());
                 room_.deliver(read_msg_);
                 do_read_header();
             } else {

components/asio/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.28.2~0"
+version: "1.32.0"
 description: Cross-platform C++ library for network and I/O programming
 url: https://github.com/espressif/esp-protocols/tree/master/components/asio
 issues: https://github.com/espressif/esp-protocols/issues
@@ -7,3 +7,5 @@ repository: https://github.com/espressif/esp-protocols.git
 dependencies:
   idf:
     version: ">=5.0"
+  espressif/sock_utils:
+    version: "^0.1"

components/asio/port/include/asio/detail/config.hpp

@@ -0,0 +1,11 @@
+//
+// SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+//
+// SPDX-License-Identifier: BSL-1.0
+//
+#pragma once
+
+#include "sys/socket.h"
+#include "socketpair.h"
+
+#include_next "asio/detail/config.hpp"

components/asio/port/include/esp_asio_config.h

@@ -1,12 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2018-2023 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#ifndef _ESP_ASIO_CONFIG_H_
-#define _ESP_ASIO_CONFIG_H_
-
-#define ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
-#include "openssl_stub.hpp"
-
-#endif // _ESP_ASIO_CONFIG_H_

components/asio/port/mbedtls/src/mbedtls_context.cpp

@@ -8,7 +8,7 @@
 //
 
 #include "asio/detail/config.hpp"
-#include "openssl_stub.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
 #include <cstring>
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"

components/asio/port/mbedtls/src/mbedtls_engine.cpp

@@ -7,7 +7,7 @@
 //
 
 #include "asio/detail/config.hpp"
-#include "openssl_stub.hpp"
+#include "asio/ssl/detail/openssl_types.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
 #include "asio/ssl/detail/engine.hpp"

components/asio/port/src/asio_stub.cpp

@@ -0,0 +1,36 @@
+//
+// SPDX-FileCopyrightText: 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// SPDX-License-Identifier: BSL-1.0
+//
+// SPDX-FileContributor: 2024 Espressif Systems (Shanghai) CO LTD
+//
+#include "asio/detail/posix_event.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/detail/push_options.hpp"
+#include <unistd.h>
+#include <climits>
+
+namespace asio::detail {
+// This replaces asio's posix_event constructor
+// since the default POSIX version uses pthread_condattr_t operations (init, setclock, destroy),
+// which are not available on all IDF versions (some are defined in compilers' headers, others in
+// pthread library, but they typically return `ENOSYS` which causes trouble in the event wrapper)
+// IMPORTANT: Check implementation of posix_event() when upgrading upstream asio in order not to
+// miss any initialization step.
+posix_event::posix_event()
+    : state_(0)
+{
+    int error = ::pthread_cond_init(&cond_, nullptr);
+    asio::error_code ec(error, asio::error::get_system_category());
+    asio::detail::throw_error(ec, "event");
+}
+} // namespace asio::detail
+
+extern "C" int pause (void)
+{
+    while (true) {
+        ::sleep(UINT_MAX);
+    }
+}

components/esp_websocket_client/.cz.yaml

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

components/esp_websocket_client/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [1.4.0](https://github.com/espressif/esp-protocols/commits/websocket-v1.4.0)
+
+### Features
+
+- Support DS peripheral for mutual TLS ([55385ec3](https://github.com/espressif/esp-protocols/commit/55385ec3))
+
+### Bug Fixes
+
+- wait for task on destroy ([42674b49](https://github.com/espressif/esp-protocols/commit/42674b49))
+- Fix pytest to verify client correctly ([9046af8f](https://github.com/espressif/esp-protocols/commit/9046af8f))
+- propagate error type ([eeeb9006](https://github.com/espressif/esp-protocols/commit/eeeb9006))
+- fix example buffer leak ([5219c39d](https://github.com/espressif/esp-protocols/commit/5219c39d))
+
+### Updated
+
+- chore(websocket): align structure members ([beb6e57e](https://github.com/espressif/esp-protocols/commit/beb6e57e))
+- chore(websocket): remove unused client variable ([15d3a01e](https://github.com/espressif/esp-protocols/commit/15d3a01e))
+
 ## [1.3.0](https://github.com/espressif/esp-protocols/commits/websocket-v1.3.0)
 
 ### Features

components/esp_websocket_client/esp_websocket_client.c

@@ -93,10 +93,13 @@ typedef struct {
     size_t                      client_cert_len;
     const char                  *client_key;
     size_t                      client_key_len;
+#if CONFIG_ESP_TLS_USE_DS_PERIPHERAL
+    void                        *client_ds_data;
+#endif
     bool                        use_global_ca_store;
     bool                        skip_cert_common_name_check;
     const char                  *cert_common_name;
-    esp_err_t                   (*crt_bundle_attach)(void *conf);
+    esp_err_t (*crt_bundle_attach)(void *conf);
     esp_transport_handle_t      ext_transport;
 } websocket_config_storage_t;
 
@@ -122,12 +125,11 @@ struct esp_websocket_client {
     uint64_t                    ping_tick_ms;
     uint64_t                    pingpong_tick_ms;
     int                         wait_timeout_ms;
-    int                         auto_reconnect;
     bool                        run;
     bool                        wait_for_pong_resp;
     bool                        selected_for_destroying;
     EventGroupHandle_t          status_bits;
-    SemaphoreHandle_t            lock;
+    SemaphoreHandle_t           lock;
     size_t                      errormsg_size;
     char                        *errormsg_buffer;
     char                        *rx_buffer;
@@ -186,9 +188,9 @@ static void esp_websocket_free_buf(esp_websocket_client_handle_t client, bool is
 }
 
 static esp_err_t esp_websocket_client_dispatch_event(esp_websocket_client_handle_t client,
-        esp_websocket_event_id_t event,
-        const char *data,
-        int data_len)
+                                                     esp_websocket_event_id_t event,
+                                                     const char *data,
+                                                     int data_len)
 {
     esp_err_t err;
     esp_websocket_event_data_t event_data;
@@ -204,8 +206,8 @@ static esp_err_t esp_websocket_client_dispatch_event(esp_websocket_client_handle
 
     if (client->error_handle.error_type == WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT) {
         event_data.error_handle.esp_tls_last_esp_err = esp_tls_get_and_clear_last_error(esp_transport_get_error_handle(client->transport),
-                &client->error_handle.esp_tls_stack_err,
-                &client->error_handle.esp_tls_cert_verify_flags);
+                                                                                        &client->error_handle.esp_tls_stack_err,
+                                                                                        &client->error_handle.esp_tls_cert_verify_flags);
         event_data.error_handle.esp_tls_stack_err = client->error_handle.esp_tls_stack_err;
         event_data.error_handle.esp_tls_cert_verify_flags = client->error_handle.esp_tls_cert_verify_flags;
         event_data.error_handle.esp_transport_sock_errno = esp_transport_get_errno(client->transport);
@@ -235,14 +237,14 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
     } else {
         client->reconnect_tick_ms = _tick_get_ms();
         ESP_LOGI(TAG, "Reconnect after %d ms", client->wait_timeout_ms);
-        client->error_handle.error_type = error_type;
         client->state = WEBSOCKET_STATE_WAIT_TIMEOUT;
     }
+    client->error_handle.error_type = error_type;
     esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_DISCONNECTED, NULL, 0);
     return ESP_OK;
 }
 
-static esp_err_t esp_websocket_client_error(esp_websocket_client_handle_t client, const char *format, ...) __attribute__ ((format (printf, 2, 3)));
+static esp_err_t esp_websocket_client_error(esp_websocket_client_handle_t client, const char *format, ...) __attribute__((format(printf, 2, 3)));
 static esp_err_t esp_websocket_client_error(esp_websocket_client_handle_t client, const char *format, ...)
 {
     va_list myargs;
@@ -447,6 +449,21 @@ static void destroy_and_free_resources(esp_websocket_client_handle_t client)
     client = NULL;
 }
 
+static esp_err_t stop_wait_task(esp_websocket_client_handle_t client)
+{
+    /* A running client cannot be stopped from the websocket task/event handler */
+    TaskHandle_t running_task = xTaskGetCurrentTaskHandle();
+    if (running_task == client->task_handle) {
+        ESP_LOGE(TAG, "Client cannot be stopped from websocket task");
+        return ESP_FAIL;
+    }
+
+    client->run = false;
+    xEventGroupWaitBits(client->status_bits, STOPPED_BIT, false, true, portMAX_DELAY);
+    client->state = WEBSOCKET_STATE_UNKNOW;
+    return ESP_OK;
+}
+
 static esp_err_t set_websocket_transport_optional_settings(esp_websocket_client_handle_t client, const char *scheme)
 {
     esp_transport_handle_t trans = esp_transport_list_get_transport(client->transport_list, scheme);
@@ -532,6 +549,10 @@ static esp_err_t esp_websocket_client_create_transport(esp_websocket_client_hand
             } else {
                 esp_transport_ssl_set_client_key_data_der(ssl, client->config->client_key, client->config->client_key_len);
             }
+#if CONFIG_ESP_TLS_USE_DS_PERIPHERAL
+        } else if (client->config->client_ds_data) {
+            esp_transport_ssl_set_ds_data(ssl, client->config->client_ds_data);
+#endif
         }
         if (client->config->crt_bundle_attach) {
 #ifdef CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
@@ -654,7 +675,7 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
         client->keep_alive_cfg.keep_alive_enable = true;
         client->keep_alive_cfg.keep_alive_idle = (config->keep_alive_idle == 0) ? WEBSOCKET_KEEP_ALIVE_IDLE : config->keep_alive_idle;
         client->keep_alive_cfg.keep_alive_interval = (config->keep_alive_interval == 0) ? WEBSOCKET_KEEP_ALIVE_INTERVAL : config->keep_alive_interval;
-        client->keep_alive_cfg.keep_alive_count =  (config->keep_alive_count == 0) ? WEBSOCKET_KEEP_ALIVE_COUNT : config->keep_alive_count;
+        client->keep_alive_cfg.keep_alive_count = (config->keep_alive_count == 0) ? WEBSOCKET_KEEP_ALIVE_COUNT : config->keep_alive_count;
     }
 
     if (config->if_name) {
@@ -697,6 +718,9 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
     client->config->client_cert_len = config->client_cert_len;
     client->config->client_key = config->client_key;
     client->config->client_key_len = config->client_key_len;
+#if CONFIG_ESP_TLS_USE_DS_PERIPHERAL
+    client->config->client_ds_data = config->client_ds_data;
+#endif
     client->config->skip_cert_common_name_check = config->skip_cert_common_name_check;
     client->config->cert_common_name = config->cert_common_name;
     client->config->crt_bundle_attach = config->crt_bundle_attach;
@@ -745,6 +769,7 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
     ESP_WS_CLIENT_MEM_CHECK(TAG, client->status_bits, {
         goto _websocket_init_fail;
     });
+    xEventGroupSetBits(client->status_bits, STOPPED_BIT);
 
     client->buffer_size = buffer_size;
     return client;
@@ -759,9 +784,11 @@ esp_err_t esp_websocket_client_destroy(esp_websocket_client_handle_t client)
     if (client == NULL) {
         return ESP_ERR_INVALID_ARG;
     }
-    if (client->run) {
-        esp_websocket_client_stop(client);
+
+    if (client->status_bits && (STOPPED_BIT & xEventGroupGetBits(client->status_bits)) == 0) {
+        stop_wait_task(client);
     }
+
     destroy_and_free_resources(client);
     return ESP_OK;
 }
@@ -923,7 +950,7 @@ static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client)
         client->last_fin = esp_transport_ws_get_fin_flag(client->transport);
         client->last_opcode = esp_transport_ws_get_read_opcode(client->transport);
 
-        if (rlen == 0 && client->last_opcode == WS_TRANSPORT_OPCODES_NONE ) {
+        if (rlen == 0 && client->last_opcode == WS_TRANSPORT_OPCODES_NONE) {
             ESP_LOGV(TAG, "esp_transport_read timeouts");
             esp_websocket_free_buf(client, false);
             return ESP_OK;
@@ -1029,7 +1056,7 @@ static void esp_websocket_client_task(void *pv)
                     }
                 }
 
-                if ( _tick_get_ms() - client->pingpong_tick_ms > client->config->pingpong_timeout_sec * 1000 ) {
+                if (_tick_get_ms() - client->pingpong_tick_ms > client->config->pingpong_timeout_sec * 1000) {
                     if (client->wait_for_pong_resp) {
                         esp_websocket_client_error(client, "Error, no PONG received for more than %d seconds after PING", client->config->pingpong_timeout_sec);
                         esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_PONG_TIMEOUT);
@@ -1150,23 +1177,13 @@ esp_err_t esp_websocket_client_stop(esp_websocket_client_handle_t client)
     if (client == NULL) {
         return ESP_ERR_INVALID_ARG;
     }
-    if (!client->run) {
+
+    if (xEventGroupGetBits(client->status_bits) & STOPPED_BIT) {
         ESP_LOGW(TAG, "Client was not started");
         return ESP_FAIL;
     }
 
-    /* A running client cannot be stopped from the websocket task/event handler */
-    TaskHandle_t running_task = xTaskGetCurrentTaskHandle();
-    if (running_task == client->task_handle) {
-        ESP_LOGE(TAG, "Client cannot be stopped from websocket task");
-        return ESP_FAIL;
-    }
-
-
-    client->run = false;
-    xEventGroupWaitBits(client->status_bits, STOPPED_BIT, false, true, portMAX_DELAY);
-    client->state = WEBSOCKET_STATE_UNKNOW;
-    return ESP_OK;
+    return stop_wait_task(client);
 }
 
 static int esp_websocket_client_send_close(esp_websocket_client_handle_t client, int code, const char *additional_data, int total_len, TickType_t timeout)
@@ -1356,3 +1373,13 @@ esp_err_t esp_websocket_register_events(esp_websocket_client_handle_t client,
     }
     return esp_event_handler_register_with(client->event_handle, WEBSOCKET_EVENTS, event, event_handler, event_handler_arg);
 }
+
+esp_err_t esp_websocket_unregister_events(esp_websocket_client_handle_t client,
+                                          esp_websocket_event_id_t event,
+                                          esp_event_handler_t event_handler)
+{
+    if (client == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return esp_event_handler_unregister_with(client->event_handle, WEBSOCKET_EVENTS, event, event_handler);
+}

components/esp_websocket_client/examples/target/main/websocket_example.c

@@ -227,6 +227,7 @@ static void websocket_app_start(void)
     xSemaphoreTake(shutdown_sema, portMAX_DELAY);
     esp_websocket_client_close(client, portMAX_DELAY);
     ESP_LOGI(TAG, "Websocket Stopped");
+    esp_websocket_unregister_events(client, WEBSOCKET_EVENT_ANY, websocket_event_handler);
     esp_websocket_client_destroy(client);
 }
 

components/esp_websocket_client/examples/target/pytest_websocket.py

@@ -55,7 +55,7 @@ class Websocket(object):
             ssl_context.load_cert_chain(certfile='main/certs/server/server_cert.pem', keyfile='main/certs/server/server_key.pem')
             if self.client_verify is True:
                 ssl_context.load_verify_locations(cafile='main/certs/ca_cert.pem')
-                ssl_context.verify = ssl.CERT_REQUIRED
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
             ssl_context.check_hostname = False
             self.server = SimpleSSLWebSocketServer('', self.port, WebsocketTestEcho, ssl_context=ssl_context)
         else:

components/esp_websocket_client/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.3.0"
+version: "1.4.0"
 description: WebSocket protocol client for ESP-IDF
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_websocket_client
 dependencies:

components/esp_websocket_client/include/esp_websocket_client.h

@@ -108,10 +108,13 @@ typedef struct {
     int                         buffer_size;                /*!< Websocket buffer size */
     const char                  *cert_pem;                  /*!< Pointer to certificate data in PEM or DER format for server verify (with SSL), default is NULL, not required to verify the server. PEM-format must have a terminating NULL-character. DER-format requires the length to be passed in cert_len. */
     size_t                      cert_len;                   /*!< Length of the buffer pointed to by cert_pem. May be 0 for null-terminated pem */
-    const char                  *client_cert;               /*!< Pointer to certificate data in PEM or DER format for SSL mutual authentication, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_key` has to be provided. PEM-format must have a terminating NULL-character. DER-format requires the length to be passed in client_cert_len. */
+    const char                  *client_cert;               /*!< Pointer to certificate data in PEM or DER format for SSL mutual authentication, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_key` or `client_ds_data` (if supported) has to be provided. PEM-format must have a terminating NULL-character. DER-format requires the length to be passed in client_cert_len. */
     size_t                      client_cert_len;            /*!< Length of the buffer pointed to by client_cert. May be 0 for null-terminated pem */
-    const char                  *client_key;                /*!< Pointer to private key data in PEM or DER format for SSL mutual authentication, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_cert` has to be provided. PEM-format must have a terminating NULL-character. DER-format requires the length to be passed in client_key_len */
+    const char                  *client_key;                /*!< Pointer to private key data in PEM or DER format for SSL mutual authentication, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_cert` has to be provided and `client_ds_data` (if supported) gets ignored. PEM-format must have a terminating NULL-character. DER-format requires the length to be passed in client_key_len */
     size_t                      client_key_len;             /*!< Length of the buffer pointed to by client_key_pem. May be 0 for null-terminated pem */
+#if CONFIG_ESP_TLS_USE_DS_PERIPHERAL
+    void                        *client_ds_data;            /*!< Pointer to the encrypted private key data for SSL mutual authentication using the DS peripheral, default is NULL, not required if mutual authentication is not needed. If it is not NULL, also `client_cert` has to be provided. It is ignored if `client_key` is provided */
+#endif
     esp_websocket_transport_t   transport;                  /*!< Websocket transport type, see `esp_websocket_transport_t */
     const char                  *subprotocol;               /*!< Websocket subprotocol */
     const char                  *user_agent;                /*!< Websocket user-agent */
@@ -457,6 +460,18 @@ esp_err_t esp_websocket_register_events(esp_websocket_client_handle_t client,
                                         esp_event_handler_t event_handler,
                                         void *event_handler_arg);
 
+/**
+ * @brief Unegister the Websocket Events
+ *
+ * @param client            The client handle
+ * @param event             The event id
+ * @param event_handler     The callback function
+ * @return esp_err_t
+ */
+esp_err_t esp_websocket_unregister_events(esp_websocket_client_handle_t client,
+                                          esp_websocket_event_id_t event,
+                                          esp_event_handler_t event_handler);
+
 #ifdef __cplusplus
 }
 #endif

components/mdns/.cz.yaml

@@ -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.4.2
+  version: 1.7.0
   version_files:
   - idf_component.yml

components/mdns/CHANGELOG.md

@@ -1,5 +1,76 @@
 # 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
+
+- support allocating mDNS task from SPIRAM ([8fcad10c](https://github.com/espressif/esp-protocols/commit/8fcad10c))
+
+### Bug Fixes
+
+- Use correct task delete function ([eb4ab524](https://github.com/espressif/esp-protocols/commit/eb4ab524))
+
+### Updated
+
+- ci(mdns): Fix mdns host test layers with static task creation ([0690eba3](https://github.com/espressif/esp-protocols/commit/0690eba3))
+
+## [1.5.3](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.3)
+
+### Bug Fixes
+
+- Fix responder to ignore only invalid queries ([cd07228f](https://github.com/espressif/esp-protocols/commit/cd07228f), [#754](https://github.com/espressif/esp-protocols/issues/754))
+
+## [1.5.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.2)
+
+### Bug Fixes
+
+- Fix potential NULL deref when sending sub-buy ([e7273c46](https://github.com/espressif/esp-protocols/commit/e7273c46))
+- Fix _mdns_append_fqdn excessive stack usage ([bd23c233](https://github.com/espressif/esp-protocols/commit/bd23c233))
+
+## [1.5.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.1)
+
+### Bug Fixes
+
+- Fix incorrect memory free for mdns browse ([4451a8c5](https://github.com/espressif/esp-protocols/commit/4451a8c5))
+
+## [1.5.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.0)
+
+### Features
+
+- supported removal of subtype when updating service ([4ad88e29](https://github.com/espressif/esp-protocols/commit/4ad88e29))
+
+### Bug Fixes
+
+- Fix zero-sized VLA clang-tidy warnings ([196198ec](https://github.com/espressif/esp-protocols/commit/196198ec))
+- Remove dead store to arg variable shared ([e838bf03](https://github.com/espressif/esp-protocols/commit/e838bf03))
+- Fix name mangling not to use strcpy() ([99b54ac3](https://github.com/espressif/esp-protocols/commit/99b54ac3))
+- Fix potential null derefernce in _mdns_execute_action() ([f5be2f41](https://github.com/espressif/esp-protocols/commit/f5be2f41))
+- Fix AFL test mock per espressif/esp-idf@a5bc08fb55c ([3d8835cf](https://github.com/espressif/esp-protocols/commit/3d8835cf))
+- Fixed potential out-of-bound interface error ([24f55ce9](https://github.com/espressif/esp-protocols/commit/24f55ce9))
+- Fixed incorrect error conversion ([8f8516cc](https://github.com/espressif/esp-protocols/commit/8f8516cc))
+- Fixed potential overflow when allocating txt data ([75a8e864](https://github.com/espressif/esp-protocols/commit/75a8e864))
+- Move MDNS_NAME_BUF_LEN to public headers ([907087c0](https://github.com/espressif/esp-protocols/commit/907087c0), [#724](https://github.com/espressif/esp-protocols/issues/724))
+- Cleanup includes in mdns.c ([68a9e148](https://github.com/espressif/esp-protocols/commit/68a9e148), [#725](https://github.com/espressif/esp-protocols/issues/725))
+- Allow advertizing service with port==0 ([827ea65f](https://github.com/espressif/esp-protocols/commit/827ea65f))
+- Fixed complier warning if MDNS_MAX_SERVICES==0 ([95377216](https://github.com/espressif/esp-protocols/commit/95377216), [#611](https://github.com/espressif/esp-protocols/issues/611))
+
+## [1.4.3](https://github.com/espressif/esp-protocols/commits/mdns-v1.4.3)
+
+### Features
+
+- support zero item when update subtype ([5bd82c01](https://github.com/espressif/esp-protocols/commit/5bd82c01))
+
 ## [1.4.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.4.2)
 
 ### Features

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(

components/mdns/Kconfig

@@ -61,6 +61,48 @@ menu "mDNS"
         default 0x0 if MDNS_TASK_AFFINITY_CPU0
         default 0x1 if MDNS_TASK_AFFINITY_CPU1
 
+    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)"
         range 10 30000

components/mdns/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.4.2"
+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"

components/mdns/include/mdns.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -10,6 +10,7 @@
 extern "C" {
 #endif
 
+#include "sdkconfig.h"
 #include <esp_netif.h>
 
 #define MDNS_TYPE_A                 0x0001
@@ -21,6 +22,13 @@ extern "C" {
 #define MDNS_TYPE_NSEC              0x002F
 #define MDNS_TYPE_ANY               0x00FF
 
+#if defined(CONFIG_LWIP_IPV6) && defined(CONFIG_MDNS_RESPOND_REVERSE_QUERIES)
+#define MDNS_NAME_MAX_LEN           (64+4)                  // Need to account for IPv6 reverse queries (64 char address  + ".ip6" )
+#else
+#define MDNS_NAME_MAX_LEN           64                      // Maximum string length of hostname, instance, service and proto
+#endif
+#define MDNS_NAME_BUF_LEN           (MDNS_NAME_MAX_LEN+1)   // Maximum char buffer size to hold hostname, instance, service or proto
+
 /**
  * @brief   Asynchronous query handle
  */
@@ -615,6 +623,8 @@ esp_err_t mdns_service_subtype_add_multiple_items_for_host(const char *instance_
  * @param  subtype          the pointer of subtype array to add.
  * @param  num_items        number of items in subtype array
  *
+ * @note  If `num_items` is 0, then remove all subtypes.
+ *
  * @return
  *     - ESP_OK success
  *     - ESP_ERR_INVALID_ARG Parameter error

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)

components/mdns/mdns_mem_caps.c

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

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);
         }
     }
 
@@ -288,7 +289,7 @@ typedef struct {
 static err_t _mdns_pcb_init_api(struct tcpip_api_call_data *api_call_msg)
 {
     mdns_api_call_t *msg = (mdns_api_call_t *)api_call_msg;
-    msg->err = _udp_pcb_init(msg->tcpip_if, msg->ip_protocol);
+    msg->err = _udp_pcb_init(msg->tcpip_if, msg->ip_protocol) == ESP_OK ? ERR_OK : ERR_IF;
     return msg->err;
 }
 
@@ -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);
 }

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 <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;

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'(?<!{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])

components/mdns/private_include/mdns_mem_caps.h

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

components/mdns/private_include/mdns_private.h

@@ -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
  */
@@ -103,12 +103,6 @@
 #define MDNS_PACKET_QUEUE_LEN       16                      // Maximum packets that can be queued for parsing
 #define MDNS_ACTION_QUEUE_LEN       CONFIG_MDNS_ACTION_QUEUE_LEN  // Maximum actions pending to the server
 #define MDNS_TXT_MAX_LEN            1024                    // Maximum string length of text data in TXT record
-#if defined(CONFIG_LWIP_IPV6) && defined(CONFIG_MDNS_RESPOND_REVERSE_QUERIES)
-#define MDNS_NAME_MAX_LEN           (64+4)                  // Need to account for IPv6 reverse queries (64 char address  + ".ip6" )
-#else
-#define MDNS_NAME_MAX_LEN           64                      // Maximum string length of hostname, instance, service and proto
-#endif
-#define MDNS_NAME_BUF_LEN           (MDNS_NAME_MAX_LEN+1)   // Maximum char buffer size to hold hostname, instance, service or proto
 #define MDNS_MAX_PACKET_SIZE        1460                    // Maximum size of mDNS  outgoing packet
 
 #define MDNS_HEAD_LEN               12

components/mdns/tests/test_afl_fuzz_host/esp32_mock.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -59,7 +59,7 @@ uint32_t xTaskGetTickCount(void)
 }
 
 /// Queue mock
-QueueHandle_t xQueueCreate( uint32_t uxQueueLength, uint32_t uxItemSize )
+QueueHandle_t xQueueCreate(uint32_t uxQueueLength, uint32_t uxItemSize)
 {
     g_size = uxItemSize;
     g_queue = malloc((uxQueueLength) * (uxItemSize));
@@ -67,7 +67,7 @@ QueueHandle_t xQueueCreate( uint32_t uxQueueLength, uint32_t uxItemSize )
 }
 
 
-void vQueueDelete( QueueHandle_t xQueue )
+void vQueueDelete(QueueHandle_t xQueue)
 {
     free(xQueue);
 }
@@ -117,7 +117,46 @@ void esp_log_write(esp_log_level_t level, const char *tag, const char *format, .
 {
 }
 
+void esp_log(esp_log_config_t config, const char *tag, const char *format, ...)
+{
+}
+
 uint32_t esp_log_timestamp(void)
 {
     return 0;
 }
+
+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);
+}
+
+void *mdns_mem_task_malloc(size_t size)
+{
+    return malloc(size);
+}
+
+void mdns_mem_task_free(void *ptr)
+{
+    free(ptr);
+}

components/mdns/tests/test_afl_fuzz_host/esp32_mock.h

@@ -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
  */
@@ -38,6 +38,10 @@
 #define ESP_ERR_INVALID_RESPONSE    0x108
 #define ESP_ERR_INVALID_CRC         0x109
 
+#define MDNS_TASK_MEMORY_LOG        "internal RAM"
+#define MALLOC_CAP_8BIT             (1<<2)
+#define MALLOC_CAP_INTERNAL         (1<<11)
+
 #define pdTRUE                      true
 #define pdFALSE                     false
 #define pdPASS          ( pdTRUE )
@@ -62,6 +66,7 @@
 #define vSemaphoreDelete(s)         free(s)
 #define queueQUEUE_TYPE_MUTEX       ( ( uint8_t ) 1U
 #define xTaskCreatePinnedToCore(a,b,c,d,e,f,g)     *(f) = malloc(1)
+#define xTaskCreateStaticPinnedToCore(a,b,c,d,e,f,g,h)     true
 #define vTaskDelay(m)               usleep((m)*0)
 #define esp_random()                (rand()%UINT32_MAX)
 
@@ -79,7 +84,8 @@ typedef void *QueueHandle_t;
 typedef void *TaskHandle_t;
 typedef int    BaseType_t;
 typedef uint32_t TickType_t;
-
+typedef void *StackType_t;
+typedef void *StaticTask_t;
 
 struct udp_pcb {
     uint8_t dummy;
@@ -111,10 +117,10 @@ uint32_t xTaskGetTickCount(void);
 typedef void (*esp_timer_cb_t)(void *arg);
 
 // Queue mock
-QueueHandle_t xQueueCreate( uint32_t uxQueueLength,
-                            uint32_t uxItemSize );
+QueueHandle_t xQueueCreate(uint32_t uxQueueLength,
+                           uint32_t uxItemSize);
 
-void vQueueDelete( QueueHandle_t xQueue );
+void vQueueDelete(QueueHandle_t xQueue);
 
 uint32_t xQueueSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait);
 
@@ -131,6 +137,6 @@ 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 );
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time);
 
 #endif //_ESP32_COMPAT_H_

components/mosquitto/.build-test-rules.yml

@@ -0,0 +1,3 @@
+components/mosquitto/examples/serverless_mqtt:
+  disable:
+    - if: IDF_TARGET not in ["esp32", "esp32s3", "esp32c3"]

components/mosquitto/.cz.yaml

@@ -3,6 +3,6 @@ commitizen:
   bump_message: 'bump(mosq): $current_version -> $new_version'
   pre_bump_hooks: python ../../ci/changelog.py mosquitto
   tag_format: mosq-v$version
-  version: 2.0.28~0
+  version: 2.0.20~1
   version_files:
   - idf_component.yml

components/mosquitto/CHANGELOG.md

@@ -1,5 +1,30 @@
+# Changelog
+
+## [2.0.20~1](https://github.com/espressif/esp-protocols/commits/mosq-v2.0.20_1)
+
+### Bug Fixes
+
+- Use sock_utils instead of func stubs ([3cd0ed37](https://github.com/espressif/esp-protocols/commit/3cd0ed37))
+- Update API docs adding on-message callback ([5dcc3330](https://github.com/espressif/esp-protocols/commit/5dcc3330))
+
+## [2.0.20](https://github.com/espressif/esp-protocols/commits/mosq-v2.0.20)
+
+### Features
+
+- Upgrade to mosquitto v2.0.20 ([3b2c614d](https://github.com/espressif/esp-protocols/commit/3b2c614d))
+- Add support for on-message callback ([cdeab8f5](https://github.com/espressif/esp-protocols/commit/cdeab8f5))
+- Add example with two brokers synced on P2P ([d57b8c5b](https://github.com/espressif/esp-protocols/commit/d57b8c5b))
+
+### Bug Fixes
+
+- Fix dependency issues moving esp-tls to public deps ([6cce87e4](https://github.com/espressif/esp-protocols/commit/6cce87e4))
+
 ## [2.0.28~0](https://github.com/espressif/esp-protocols/commits/mosq-v2.0.28_0)
 
+### Warning
+
+Incorrect version number! This version published under `2.0.28~0` is based on upstream v2.0.18
+
 ### Features
 
 - Added support for TLS transport using ESP-TLS ([1af4bbe1](https://github.com/espressif/esp-protocols/commit/1af4bbe1))

components/mosquitto/CMakeLists.txt

@@ -74,15 +74,15 @@ idf_component_register(SRCS ${m_srcs}
                             port/callbacks.c
                             port/config.c
                             port/signals.c
-                            port/ifaddrs.c
                             port/broker.c
                             port/files.c
                             port/net__esp_tls.c
+                            port/sysconf.c
                     PRIV_INCLUDE_DIRS port/priv_include port/priv_include/sys ${m_dir} ${m_src_dir}
                                       ${m_incl_dir} ${m_lib_dir} ${m_deps_dir}
                     INCLUDE_DIRS ${m_incl_dir} port/include
-                    PRIV_REQUIRES newlib esp-tls
-        )
+                    REQUIRES esp-tls
+                    PRIV_REQUIRES newlib sock_utils)
 
 target_compile_definitions(${COMPONENT_LIB} PRIVATE "WITH_BROKER")
 target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/mosquitto/README.md

@@ -20,7 +20,7 @@ mosq_broker_run(&config);
 
 ## Memory Footprint Considerations
 
-The broker primarily uses the heap for internal data, with minimal use of static/BSS memory. It consumes approximately 60 kB of program memory.
+The broker primarily uses the heap for internal data, with minimal use of static/BSS memory. It consumes approximately 60 kB of program memory and minimum 5kB of stack size.
 
 - **Initial Memory Usage**: ~2 kB of heap on startup
 - **Per Client Memory Usage**: ~4 kB of heap for each connected client

components/mosquitto/api.md

@@ -15,6 +15,7 @@
 | Type | Name |
 | ---: | :--- |
 | struct | [**mosq\_broker\_config**](#struct-mosq_broker_config) <br>_Mosquitto configuration structure._ |
+| typedef void(\* | [**mosq\_message\_cb\_t**](#typedef-mosq_message_cb_t)  <br> |
 
 ## Functions
 
@@ -34,12 +35,20 @@ ESP port of mosquittto supports only the options in this configuration structure
 
 Variables:
 
+-  void(\* handle_message_cb  <br>On message callback. If configured, user function is called whenever mosquitto processes a message.
+
 -  char \* host  <br>Address on which the broker is listening for connections
 
 -  int port  <br>Port number of the broker to listen to
 
 -  esp\_tls\_cfg\_server\_t \* tls_cfg  <br>ESP-TLS configuration (if TLS transport used) Please refer to the ESP-TLS official documentation for more details on configuring the TLS options. You can open the respective docs with this idf.py command: `idf.py docs -sp api-reference/protocols/esp_tls.html`
 
+### typedef `mosq_message_cb_t`
+
+```c
+typedef void(* mosq_message_cb_t) (char *client, char *topic, char *data, int len, int qos, int retain);
+```
+
 
 ## Functions Documentation
 

components/mosquitto/examples/serverless_mqtt/CMakeLists.txt

@@ -0,0 +1,6 @@
+# The following five lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(serverless_mqtt)

components/mosquitto/examples/serverless_mqtt/README.md

@@ -0,0 +1,53 @@
+# Brokerless MQTT Example
+
+MQTT served by (two) mosquitto's running on two ESP chips.
+
+* Leverages MQTT connectivity between two private networks without cloud premisses.
+* Creates two local MQTT servers (on ESP32x's) which are being synchronized over peer to peer connection (established via ICE protocol, by [libjuice](https://github.com/paullouisageneau/libjuice)).
+
+## How it works
+
+This example needs two ESP32 chipsets, that will create two separate Wi-Fi networks (IoT networks) used for IoT devices.
+Each IoT network is served by an MQTT server (using mosquitto component).
+This example will also synchronize these two MQTT brokers, as if there was only one IoT network with one broker.
+This example creates a peer to peer connection between two chipsets to keep them synchronize. This connection utilizes libjuice (which implements a simplified ICE-UDP) to traverse NATs, which enabling direct connection between two private networks behind NATs.
+
+* Diagram
+
+![demo](serverless.png)
+
+Here's a step-by-step procedure of establishing this remote connection:
+1) Initialize and start Wi-Fi AP (for IoT networks) and Wi-Fi station (for internet connection)
+2) Start mosquitto broker on IoT network
+3) Start libjuice to gather connection candidates
+4) Synchronize using a public MQTT broker and exchange ICE descriptors
+5) Establish ICE UDP connection between the two ESP32 chipsets
+6) Start forwarding mqtt messages
+   - Each remote datagram (received from ICE-UDP channel) is re-published to the local MQTT server
+   - Each local MQTT message (received from mosquitto on_message callback) is sent in ICE-UDP datagram
+
+## How to use this example
+
+You need two ESP32 devices that support Wi-Fi station and Wi-Fi software access point.
+
+* Configure Wi-Fi credentials for both devices on both interfaces
+  * These devices would be deployed in distinct Wi-Fi environments, so the Wi-Fi station credentials would likely be different.
+  * They also create their own IoT network (on the soft-AP interface) Wi-Fi, so the AP credentials would likely be the same, suggesting the IoT networks will be keep synchronized (even though these are two distict Wi-Fi networks).
+* Choose `CONFIG_EXAMPLE_SERVERLESS_ROLE_PEER1` for one device and `CONFIG_EXAMPLE_SERVERLESS_ROLE_PEER2` for another. It's not important which device is PEER1, since the code is symmetric, but these two devices need to have different role.
+* Optionally: You can use `idf.py` `-D` and `-B` flag to keep separate build directories and sdkconfigs for these two roles
+```
+idf.py -B build1 -DSDKCONFIG=build1/sdkconfig menuconfig build flash monitor
+```
+* Flash and run the two devices and wait for them to connect and synchronize.
+* Now you can test MQTT connectivity, for example:
+  * Join PEER1 device's AP and connect to the MQTT broker with one or more clients, subscribing to one or more topics.
+  * Join PEER2 device's AP and connect to the MQTT broker with one or more clients, subscribing to one or more topics.
+  * Whenever you publish to a topic, all subscribed clients should receive the message, no matter which Wi-Fi network they're connected to.
+
+## Warning
+
+This example uses libjuice as a dependency:
+
+* libjuice (UDP Interactive Connectivity Establishment): https://github.com/paullouisageneau/libjuice
+
+which is distributed under Mozilla Public License v2.0.

components/mosquitto/examples/serverless_mqtt/components/libjuice/CMakeLists.txt

@@ -0,0 +1,44 @@
+set(LIBJUICE_VERSION "73785387eafe15c02b6a210edb10f722474e8e14")
+set(LIBJUICE_URL "https://github.com/paullouisageneau/libjuice/archive/${LIBJUICE_VERSION}.zip")
+
+set(libjuice_dir ${CMAKE_BINARY_DIR}/libjuice/libjuice-${LIBJUICE_VERSION})
+
+# Fetch the library
+if(NOT EXISTS ${libjuice_dir})
+        message(STATUS "Downloading libjuice ${LIBJUICE_VERSION}...")
+        file(DOWNLOAD ${LIBJUICE_URL} ${CMAKE_BINARY_DIR}/libjuice.zip SHOW_PROGRESS)
+        execute_process(COMMAND unzip -o ${CMAKE_BINARY_DIR}/libjuice.zip -d ${CMAKE_BINARY_DIR}/libjuice
+                WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+endif()
+
+set(JUICE_SOURCES   ${libjuice_dir}/src/addr.c
+                    ${libjuice_dir}/src/agent.c
+                    ${libjuice_dir}/src/base64.c
+                    ${libjuice_dir}/src/conn.c
+                    ${libjuice_dir}/src/conn_mux.c
+                    ${libjuice_dir}/src/conn_poll.c
+                    ${libjuice_dir}/src/conn_thread.c
+                    ${libjuice_dir}/src/const_time.c
+                    ${libjuice_dir}/src/crc32.c
+                    ${libjuice_dir}/src/hash.c
+                    ${libjuice_dir}/src/ice.c
+                    ${libjuice_dir}/src/juice.c
+                    ${libjuice_dir}/src/log.c
+                    ${libjuice_dir}/src/server.c
+                    ${libjuice_dir}/src/stun.c
+                    ${libjuice_dir}/src/timestamp.c
+                    ${libjuice_dir}/src/turn.c
+                    ${libjuice_dir}/src/udp.c
+# Use hmac from mbedtls and random numbers from esp_random:
+#                    ${libjuice_dir}/src/hmac.c
+#                    ${libjuice_dir}/src/random.c
+        )
+
+idf_component_register(SRCS     port/juice_random.c
+                                ${JUICE_SOURCES}
+                       INCLUDE_DIRS "include"  "${libjuice_dir}/include" "${libjuice_dir}/include/juice"
+                       REQUIRES esp_netif
+                       PRIV_REQUIRES sock_utils)
+
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
+set_source_files_properties(${libjuice_dir}/src/udp.c PROPERTIES COMPILE_FLAGS -Wno-unused-variable)

components/mosquitto/examples/serverless_mqtt/components/libjuice/include/ifaddrs.h

@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#pragma once
+
+// Purpose of this header is to replace udp_sendto() to avoid name conflict with lwip
+// added here since ifaddrs.h is included from juice_udp sources
+#define udp_sendto juice_udp_sendto
+
+// other than that, let's just include the ifaddrs (from sock_utils)
+#include_next "ifaddrs.h"

components/mosquitto/examples/serverless_mqtt/components/libjuice/port/juice_random.c

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+#include "esp_random.h"
+
+void juice_random(void *buf, size_t size)
+{
+    esp_fill_random(buf, size);
+}
+
+void juice_random_str64(char *buf, size_t size)
+{
+    static const char chars64[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    size_t i = 0;
+    for (i = 0; i + 1 < size; ++i) {
+        uint8_t byte = 0;
+        juice_random(&byte, 1);
+        buf[i] = chars64[byte & 0x3F];
+    }
+    buf[i] = '\0';
+}
+
+uint32_t juice_rand32(void)
+{
+    uint32_t r = 0;
+    juice_random(&r, sizeof(r));
+    return r;
+}
+
+uint64_t juice_rand64(void)
+{
+    uint64_t r = 0;
+    juice_random(&r, sizeof(r));
+    return r;
+}

components/mosquitto/examples/serverless_mqtt/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(SRCS "serverless_mqtt.c"
+                            "wifi_connect.c"
+                    INCLUDE_DIRS "."
+                    REQUIRES libjuice nvs_flash mqtt json esp_wifi)

components/mosquitto/examples/serverless_mqtt/main/Kconfig.projbuild

@@ -0,0 +1,85 @@
+menu "Example Configuration"
+
+    menu "AP Configuration"
+        comment "AP Configuration"
+
+        config EXAMPLE_AP_SSID
+            string "Wi-Fi SSID"
+            default "myssid"
+            help
+                Set the SSID of Wi-Fi ap interface.
+
+        config EXAMPLE_AP_PASSWORD
+            string "Wi-Fi Password"
+            default "12345678"
+            help
+                Set the password of Wi-Fi ap interface.
+
+    endmenu
+
+    menu "STA Configuration"
+        comment "STA Configuration"
+
+        config EXAMPLE_STA_SSID
+            string "WiFi Station SSID"
+            default "mystationssid"
+            help
+                SSID for the example's sta to connect to.
+
+        config EXAMPLE_STA_PASSWORD
+            string "WiFi Station Password"
+            default "mystationpassword"
+            help
+                WiFi station password for the example to use.
+    endmenu
+
+    config EXAMPLE_MQTT_BROKER_URI
+        string "MQTT Broker URL"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of the mqtt broker use for synchronisation and exchanging
+            ICE connect info (description and candidates).
+
+    config EXAMPLE_MQTT_SYNC_TOPIC
+        string "MQTT topic for synchronisation"
+        default "/topic/serverless_mqtt"
+        help
+            MQTT topic used fo synchronisation.
+
+    config EXAMPLE_STUN_SERVER
+        string "Hostname of STUN server"
+        default "stun.l.google.com"
+        help
+            STUN server hostname.
+
+    config EXAMPLE_MQTT_CLIENT_STACK_SIZE
+        int "Stack size for mqtt client"
+        default 16384
+        help
+            Set stack size for the mqtt client.
+            Need more stack, since calling juice API from the handler.
+
+    config EXAMPLE_MQTT_BROKER_PORT
+        int "port for the mosquitto to listen to"
+        default 1883
+        help
+            This is a port which the local mosquitto uses.
+
+    choice EXAMPLE_SERVERLESS_ROLE
+        prompt "Choose your role"
+        default EXAMPLE_SERVERLESS_ROLE_PEER1
+        help
+            Choose either peer1 or peer2.
+            It's not very important which device is peer1
+            (peer-1 sends sync messages, peer2 listens for them)
+            It is important that we have two peers,
+            one with peer1 config, another one with peer2 config
+
+        config EXAMPLE_SERVERLESS_ROLE_PEER1
+            bool "peer1"
+
+        config EXAMPLE_SERVERLESS_ROLE_PEER2
+            bool "peer2"
+    endchoice
+
+endmenu

components/mosquitto/examples/serverless_mqtt/main/idf_component.yml

@@ -0,0 +1,5 @@
+## IDF Component Manager Manifest File
+dependencies:
+  espressif/mosquitto:
+    override_path: ../../..
+  espressif/sock_utils: "*"

components/mosquitto/examples/serverless_mqtt/main/serverless_mqtt.c

@@ -0,0 +1,374 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#include <stdio.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "mqtt_client.h"
+#include "esp_wifi.h"
+#include "esp_log.h"
+#include "esp_random.h"
+#include "esp_check.h"
+#include "esp_sleep.h"
+#include "mosq_broker.h"
+#include "juice/juice.h"
+#include "cJSON.h"
+
+#if defined(CONFIG_EXAMPLE_SERVERLESS_ROLE_PEER1)
+#define OUR_PEER "1"
+#define THEIR_PEER "2"
+#elif defined(CONFIG_EXAMPLE_SERVERLESS_ROLE_PEER2)
+#define OUR_PEER "2"
+#define THEIR_PEER "1"
+#endif
+
+#define PEER_SYNC0 BIT(0)
+#define PEER_SYNC1 BIT(1)
+#define PEER_SYNC2 BIT(2)
+#define PEER_FAIL  BIT(3)
+#define PEER_GATHER_DONE  BIT(4)
+#define PEER_DESC_PUBLISHED  BIT(5)
+#define PEER_CONNECTED  BIT(6)
+
+#define SYNC_BITS (PEER_SYNC1 | PEER_SYNC2 | PEER_FAIL)
+
+#define PUBLISH_SYNC_TOPIC CONFIG_EXAMPLE_MQTT_SYNC_TOPIC OUR_PEER
+#define SUBSCRIBE_SYNC_TOPIC CONFIG_EXAMPLE_MQTT_SYNC_TOPIC THEIR_PEER
+#define MAX_BUFFER_SIZE JUICE_MAX_SDP_STRING_LEN
+
+typedef struct message_wrap {
+    uint16_t topic_len;
+    uint16_t data_len;
+    char data[];
+} __attribute__((packed)) message_wrap_t;
+
+static const char *TAG = "serverless_mqtt" OUR_PEER;
+static char s_buffer[MAX_BUFFER_SIZE];
+static EventGroupHandle_t s_state = NULL;
+static juice_agent_t *s_agent = NULL;
+static cJSON *s_peer_desc_json = NULL;
+static char *s_peer_desc = NULL;
+static esp_mqtt_client_handle_t s_local_mqtt = NULL;
+
+char *wifi_get_ipv4(wifi_interface_t interface);
+esp_err_t wifi_connect(void);
+static esp_err_t sync_peers(void);
+static esp_err_t create_candidates(void);
+static esp_err_t create_local_client(void);
+static esp_err_t create_local_broker(void);
+
+void app_main(void)
+{
+    __attribute__((__unused__)) esp_err_t ret;
+    ESP_GOTO_ON_ERROR(wifi_connect(), err, TAG, "Failed to initialize WiFi");
+    ESP_GOTO_ON_ERROR(create_local_broker(), err, TAG, "Failed to create local broker");
+    ESP_GOTO_ON_ERROR(create_candidates(), err, TAG, "Failed to create juice candidates");
+    ESP_GOTO_ON_ERROR(sync_peers(), err, TAG, "Failed to sync with the other peer");
+    EventBits_t bits = xEventGroupWaitBits(s_state, PEER_FAIL | PEER_CONNECTED, pdFALSE, pdFALSE, pdMS_TO_TICKS(90000));
+    if (bits & PEER_CONNECTED) {
+        ESP_LOGI(TAG, "Peer is connected!");
+        ESP_GOTO_ON_ERROR(create_local_client(), err, TAG, "Failed to create forwarding mqtt client");
+        ESP_LOGI(TAG, "Everything is ready, exiting main task");
+        return;
+    }
+err:
+    ESP_LOGE(TAG, "Non recoverable error, going to sleep for some time (random, max 20s)");
+    esp_deep_sleep(1000000LL * (esp_random() % 20));
+}
+
+static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    esp_mqtt_event_handle_t event = event_data;
+    esp_mqtt_client_handle_t client = event->client;
+    switch ((esp_mqtt_event_id_t)event_id) {
+    case MQTT_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+        if (esp_mqtt_client_subscribe(client, SUBSCRIBE_SYNC_TOPIC, 1) < 0) {
+            ESP_LOGE(TAG, "Failed to subscribe to the sync topic");
+        }
+        xEventGroupSetBits(s_state, PEER_SYNC0);
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+        xEventGroupSetBits(s_state, PEER_FAIL);
+        break;
+
+    case MQTT_EVENT_DATA:
+        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
+        printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
+        printf("DATA=%.*s\r\n", event->data_len, event->data);
+        if (s_state == NULL || memcmp(event->topic, SUBSCRIBE_SYNC_TOPIC, event->topic_len) != 0) {
+            break;
+        }
+        EventBits_t bits = xEventGroupGetBits(s_state);
+        if (event->data_len > 1 && s_agent) {
+            cJSON *root = cJSON_Parse(event->data);
+            if (root == NULL) {
+                break;
+            }
+            cJSON *desc = cJSON_GetObjectItem(root, "desc");
+            if (desc == NULL) {
+                cJSON_Delete(root);
+                break;
+            }
+            printf("desc->valuestring:%s\n", desc->valuestring);
+            juice_set_remote_description(s_agent, desc->valuestring);
+            char cand_name[] = "cand0";
+            while (true) {
+                cJSON *cand = cJSON_GetObjectItem(root, cand_name);
+                if (cand == NULL) {
+                    break;
+                }
+                printf("%s: cand->valuestring:%s\n", cand_name, cand->valuestring);
+                juice_add_remote_candidate(s_agent, cand->valuestring);
+                cand_name[4]++;
+            }
+            cJSON_Delete(root);
+            xEventGroupSetBits(s_state, PEER_DESC_PUBLISHED); // this will complete the sync process
+            // and destroy the mqtt client
+        }
+#ifdef CONFIG_EXAMPLE_SERVERLESS_ROLE_PEER1
+        if (event->data_len == 1 && event->data[0] == '1' && (bits & PEER_SYNC2) == 0) {
+            if (esp_mqtt_client_publish(client, PUBLISH_SYNC_TOPIC, "2", 1, 1, 0) >= 0) {
+                xEventGroupSetBits(s_state, PEER_SYNC2);
+            } else {
+                xEventGroupSetBits(s_state, PEER_FAIL);
+            }
+        }
+#else
+        if (event->data_len == 1 && event->data[0] == '0' && (bits & PEER_SYNC1) == 0) {
+            if (esp_mqtt_client_publish(client, PUBLISH_SYNC_TOPIC, "1", 1, 1, 0) >= 0) {
+                xEventGroupSetBits(s_state, PEER_SYNC1);
+            }  else {
+                xEventGroupSetBits(s_state, PEER_FAIL);
+            }
+        } else if (event->data_len == 1 && event->data[0] == '2' && (bits & PEER_SYNC2) == 0) {
+            xEventGroupSetBits(s_state, PEER_SYNC2);
+        }
+#endif
+        break;
+    case MQTT_EVENT_ERROR:
+        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+        xEventGroupSetBits(s_state, PEER_FAIL);
+        break;
+    default:
+        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
+        break;
+    }
+}
+
+static esp_err_t sync_peers(void)
+{
+    esp_err_t ret = ESP_OK;
+    esp_mqtt_client_config_t mqtt_cfg = {
+        .broker.address.uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
+        .task.stack_size = CONFIG_EXAMPLE_MQTT_CLIENT_STACK_SIZE,
+    };
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
+    ESP_GOTO_ON_FALSE(client, ESP_ERR_NO_MEM, err, TAG, "Failed to create mqtt client");
+    ESP_GOTO_ON_ERROR(esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL),
+                      err, TAG, "Failed to register mqtt event handler");
+    ESP_GOTO_ON_ERROR(esp_mqtt_client_start(client), err, TAG, "Failed to start mqtt client");
+    ESP_GOTO_ON_FALSE(xEventGroupWaitBits(s_state, PEER_SYNC0, pdTRUE, pdTRUE, pdMS_TO_TICKS(10000)),
+                      ESP_FAIL, err, TAG, "Failed to connect to the sync broker");
+    ESP_LOGI(TAG, "Waiting for the other peer...");
+    const int max_sync_retry = 60;
+    int retry = 0;
+    while (true) {
+        EventBits_t bits = xEventGroupWaitBits(s_state, SYNC_BITS, pdTRUE, pdFALSE, pdMS_TO_TICKS(1000));
+        if (bits & PEER_SYNC2) {
+            break;
+        }
+        if (bits & PEER_SYNC1) {
+            continue;
+        }
+        ESP_GOTO_ON_FALSE((bits & PEER_FAIL) == 0, ESP_FAIL, err, TAG, "Failed to sync with the other peer");
+        ESP_GOTO_ON_FALSE(retry++ < max_sync_retry, ESP_FAIL, err, TAG, "Failed to sync after %d seconds", retry);
+#ifdef CONFIG_EXAMPLE_SERVERLESS_ROLE_PEER1
+        ESP_RETURN_ON_FALSE(esp_mqtt_client_publish(client, PUBLISH_SYNC_TOPIC, "0", 1, 1, 0) >= 0,
+                            ESP_FAIL, TAG, "Failed to publish mqtt message");
+#endif
+    }
+    ESP_LOGI(TAG, "Sync done");
+    ESP_RETURN_ON_FALSE(esp_mqtt_client_publish(client, PUBLISH_SYNC_TOPIC, s_peer_desc, 0, 1, 0) >= 0,
+                        ESP_FAIL, TAG, "Failed to publish peer's description");
+    ESP_LOGI(TAG, "Waiting for the other peer description and candidates...");
+    ESP_GOTO_ON_FALSE(xEventGroupWaitBits(s_state, PEER_DESC_PUBLISHED, pdTRUE, pdTRUE, pdMS_TO_TICKS(10000)),
+                      ESP_FAIL, err, TAG, "Timeout in waiting for the other peer candidates");
+err:
+    free(s_peer_desc);
+    esp_mqtt_client_destroy(client);
+    return ret;
+}
+
+static void juice_state(juice_agent_t *agent, juice_state_t state, void *user_ptr)
+{
+    ESP_LOGI(TAG, "JUICE state change: %s", juice_state_to_string(state));
+    if (state == JUICE_STATE_CONNECTED) {
+        xEventGroupSetBits(s_state, PEER_CONNECTED);
+    } else if (state == JUICE_STATE_FAILED || state == JUICE_STATE_DISCONNECTED) {
+        esp_restart();
+    }
+}
+
+static void juice_candidate(juice_agent_t *agent, const char *sdp, void *user_ptr)
+{
+    static uint8_t cand_nr = 0;
+    if (s_peer_desc_json && cand_nr < 10) { // supporting only 10 candidates
+        char cand_name[] = "cand0";
+        cand_name[4] += cand_nr++;
+        cJSON_AddStringToObject(s_peer_desc_json, cand_name, sdp);
+    }
+}
+
+static void juice_gathering_done(juice_agent_t *agent, void *user_ptr)
+{
+    ESP_LOGI(TAG, "Gathering done");
+    if (s_state) {
+        xEventGroupSetBits(s_state, PEER_GATHER_DONE);
+    }
+}
+
+#define ALIGN(size) (((size) + 3U) & ~(3U))
+
+static void juice_recv(juice_agent_t *agent, const char *data, size_t size, void *user_ptr)
+{
+    if (s_local_mqtt) {
+        message_wrap_t *message = (message_wrap_t *)data;
+        int topic_len = message->topic_len;
+        int payload_len = message->data_len;
+        int topic_len_aligned = ALIGN(topic_len);
+        char *topic = message->data;
+        char *payload = message->data + topic_len_aligned;
+        if (topic_len + topic_len_aligned + 4 > size) {
+            ESP_LOGE(TAG, "Received invalid message");
+            return;
+        }
+        ESP_LOGI(TAG, "forwarding remote message: topic:%s", topic);
+        ESP_LOGI(TAG, "forwarding remote message: payload:%.*s", payload_len, payload);
+        esp_mqtt_client_publish(s_local_mqtt, topic, payload, payload_len, 0, 0);
+    }
+}
+
+static esp_err_t create_candidates(void)
+{
+    ESP_RETURN_ON_FALSE(s_state = xEventGroupCreate(), ESP_ERR_NO_MEM, TAG, "Failed to create state event group");
+    s_peer_desc_json = cJSON_CreateObject();
+    esp_err_t ret = ESP_OK;
+    juice_set_log_level(JUICE_LOG_LEVEL_INFO);
+    juice_config_t config = { .stun_server_host = CONFIG_EXAMPLE_STUN_SERVER,
+                              .bind_address = wifi_get_ipv4(WIFI_IF_STA),
+                              .stun_server_port = 19302,
+                              .cb_state_changed = juice_state,
+                              .cb_candidate = juice_candidate,
+                              .cb_gathering_done = juice_gathering_done,
+                              .cb_recv = juice_recv,
+                            };
+
+    s_agent = juice_create(&config);
+    ESP_RETURN_ON_FALSE(s_agent, ESP_FAIL, TAG, "Failed to create juice agent");
+    ESP_GOTO_ON_FALSE(juice_get_local_description(s_agent, s_buffer, MAX_BUFFER_SIZE) == JUICE_ERR_SUCCESS,
+                      ESP_FAIL, err, TAG, "Failed to get local description");
+    ESP_LOGI(TAG, "desc: %s", s_buffer);
+    cJSON_AddStringToObject(s_peer_desc_json, "desc", s_buffer);
+
+    ESP_GOTO_ON_FALSE(juice_gather_candidates(s_agent) == JUICE_ERR_SUCCESS,
+                      ESP_FAIL, err, TAG, "Failed to start gathering candidates");
+    ESP_GOTO_ON_FALSE(xEventGroupWaitBits(s_state, PEER_GATHER_DONE, pdTRUE, pdTRUE, pdMS_TO_TICKS(30000)),
+                      ESP_FAIL, err, TAG, "Failed to connect to the sync broker");
+    s_peer_desc = cJSON_Print(s_peer_desc_json);
+    ESP_LOGI(TAG, "desc: %s", s_peer_desc);
+    cJSON_Delete(s_peer_desc_json);
+    return ESP_OK;
+
+err:
+    juice_destroy(s_agent);
+    s_agent = NULL;
+    cJSON_Delete(s_peer_desc_json);
+    s_peer_desc_json = NULL;
+    return ret;
+}
+
+static void local_handler(void *args, esp_event_base_t base, int32_t id, void *data)
+{
+    switch (id) {
+    case MQTT_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "local client connected");
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        ESP_LOGI(TAG, "local client disconnected");
+        break;
+
+    case MQTT_EVENT_ERROR:
+        ESP_LOGI(TAG, "local client error");
+        break;
+    default:
+        ESP_LOGI(TAG, "local client event id:%d", (int)id);
+        break;
+    }
+}
+
+static esp_err_t create_local_client(void)
+{
+    esp_err_t ret = ESP_OK;
+    esp_mqtt_client_config_t mqtt_cfg = {
+        .broker.address.transport = MQTT_TRANSPORT_OVER_TCP,
+        .broker.address.hostname = wifi_get_ipv4(WIFI_IF_AP),
+        .broker.address.port = CONFIG_EXAMPLE_MQTT_BROKER_PORT,
+        .task.stack_size = CONFIG_EXAMPLE_MQTT_CLIENT_STACK_SIZE,
+        .credentials.client_id = "local_mqtt"
+    };
+    s_local_mqtt = esp_mqtt_client_init(&mqtt_cfg);
+    ESP_GOTO_ON_FALSE(s_local_mqtt, ESP_ERR_NO_MEM, err, TAG, "Failed to create mqtt client");
+    ESP_GOTO_ON_ERROR(esp_mqtt_client_register_event(s_local_mqtt, ESP_EVENT_ANY_ID, local_handler, NULL),
+                      err, TAG, "Failed to register mqtt event handler");
+    ESP_GOTO_ON_ERROR(esp_mqtt_client_start(s_local_mqtt), err, TAG, "Failed to start mqtt client");
+
+    return ESP_OK;
+err:
+    esp_mqtt_client_destroy(s_local_mqtt);
+    s_local_mqtt = NULL;
+    return ret;
+}
+
+static void handle_message(char *client, char *topic, char *payload, int len, int qos, int retain)
+{
+    if (client && strcmp(client, "local_mqtt") == 0 ) {
+        // This is our little local client -- do not forward
+        return;
+    }
+    ESP_LOGI(TAG, "handle_message topic:%s", topic);
+    ESP_LOGI(TAG, "handle_message data:%.*s", len, payload);
+    ESP_LOGI(TAG, "handle_message qos=%d, retain=%d", qos, retain);
+    if (s_local_mqtt && s_agent) {
+        int topic_len = strlen(topic) + 1; // null term
+        int topic_len_aligned = ALIGN(topic_len);
+        int total_msg_len = 2 + 2 /* msg_wrap header */ + topic_len_aligned + len;
+        if (total_msg_len > MAX_BUFFER_SIZE) {
+            ESP_LOGE(TAG, "Fail to forward, message too long");
+            return;
+        }
+        message_wrap_t *message = (message_wrap_t *)s_buffer;
+        message->topic_len = topic_len;
+        message->data_len = len;
+
+        memcpy(s_buffer + 4, topic, topic_len);
+        memcpy(s_buffer + 4 + topic_len_aligned, payload, len);
+        juice_send(s_agent, s_buffer, total_msg_len);
+    }
+}
+
+static void broker_task(void *ctx)
+{
+    struct mosq_broker_config config = { .host = wifi_get_ipv4(WIFI_IF_AP), .port = CONFIG_EXAMPLE_MQTT_BROKER_PORT, .handle_message_cb = handle_message };
+    mosq_broker_run(&config);
+    vTaskDelete(NULL);
+}
+
+static esp_err_t create_local_broker(void)
+{
+    return xTaskCreate(broker_task, "mqtt_broker_task", 1024 * 32, NULL, 5, NULL) == pdTRUE ?
+           ESP_OK : ESP_FAIL;
+}

components/mosquitto/examples/serverless_mqtt/main/wifi_connect.c

@@ -0,0 +1,122 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#include "nvs_flash.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+#include "esp_check.h"
+#include "esp_wifi.h"
+#include "esp_mac.h"
+
+#define WIFI_CONNECTED_BIT BIT0
+#define WIFI_FAIL_BIT      BIT1
+
+static const char *TAG = "serverless_wifi";
+static EventGroupHandle_t s_wifi_events;
+static int s_retry_num = 0;
+static const int s_max_retry = 30;
+
+static void wifi_event_handler(void *arg, esp_event_base_t event_base,
+                               int32_t event_id, void *event_data)
+{
+    if (event_id == WIFI_EVENT_AP_STACONNECTED) {
+        wifi_event_ap_staconnected_t *event = (wifi_event_ap_staconnected_t *) event_data;
+        ESP_LOGI(TAG, "station "MACSTR" join, AID=%d",
+                 MAC2STR(event->mac), event->aid);
+    } else if (event_id == WIFI_EVENT_AP_STADISCONNECTED) {
+        wifi_event_ap_stadisconnected_t *event = (wifi_event_ap_stadisconnected_t *) event_data;
+        ESP_LOGI(TAG, "station "MACSTR" leave, AID=%d",
+                 MAC2STR(event->mac), event->aid);
+    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
+        esp_wifi_connect();
+    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
+        if (s_retry_num < s_max_retry) {
+            esp_wifi_connect();
+            s_retry_num++;
+            ESP_LOGI(TAG, "retry to connect to the AP");
+        } else {
+            xEventGroupSetBits(s_wifi_events, WIFI_FAIL_BIT);
+        }
+        ESP_LOGI(TAG, "Connect to the AP fail");
+    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
+        ip_event_got_ip_t *event = (ip_event_got_ip_t *) event_data;
+        ESP_LOGI(TAG, "Got ip:" IPSTR, IP2STR(&event->ip_info.ip));
+        s_retry_num = 0;
+        xEventGroupSetBits(s_wifi_events, WIFI_CONNECTED_BIT);
+    }
+}
+
+esp_err_t wifi_connect(void)
+{
+    esp_err_t ret = ESP_OK;
+    ESP_GOTO_ON_FALSE(s_wifi_events = xEventGroupCreate(), ESP_ERR_NO_MEM, err, TAG, "Failed to create wifi_events");
+    ESP_GOTO_ON_ERROR(nvs_flash_init(), err, TAG, "Failed to init nvs flash");
+    ESP_GOTO_ON_ERROR(esp_netif_init(), err, TAG, "Failed to init esp_netif");
+    ESP_GOTO_ON_ERROR(esp_event_loop_create_default(), err, TAG, "Failed to create default event loop");
+    ESP_GOTO_ON_ERROR(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event_handler, NULL),
+                      err, TAG, "Failed to register WiFi event handler");
+    ESP_GOTO_ON_ERROR(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL),
+                      err, TAG, "Failed to register IP event handler");
+
+    // Initialize WiFi
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_GOTO_ON_ERROR(esp_wifi_init(&cfg), err, TAG, "Failed to initialize WiFi");
+    ESP_GOTO_ON_ERROR(esp_wifi_set_mode(WIFI_MODE_APSTA), err, TAG, "Failed to set STA+AP mode");
+
+    // Initialize AP
+    esp_netif_t *ap = esp_netif_create_default_wifi_ap();
+    ESP_GOTO_ON_FALSE(ap, ESP_FAIL, err, TAG, "Failed to create AP network interface");
+    wifi_config_t wifi_ap_config = {
+        .ap = {
+            .ssid = CONFIG_EXAMPLE_AP_SSID,
+            .password = CONFIG_EXAMPLE_AP_PASSWORD,
+            .authmode = WIFI_AUTH_WPA2_PSK,
+            .max_connection = 4,
+        },
+    };
+    ESP_GOTO_ON_ERROR(esp_wifi_set_config(WIFI_IF_AP, &wifi_ap_config), err, TAG, "Failed to set AP config");
+
+
+    // Initialize STA
+    esp_netif_t *sta = esp_netif_create_default_wifi_sta();
+    ESP_GOTO_ON_FALSE(sta, ESP_FAIL, err, TAG, "Failed to create WiFi station network interface");
+    wifi_config_t wifi_sta_config = {
+        .sta = {
+            .ssid = CONFIG_EXAMPLE_STA_SSID,
+            .password = CONFIG_EXAMPLE_STA_PASSWORD,
+        },
+    };
+    ESP_GOTO_ON_ERROR(esp_wifi_set_config(WIFI_IF_STA, &wifi_sta_config), err, TAG, "Failed to set STA config");
+
+    // Start WiFi
+    ESP_GOTO_ON_ERROR(esp_wifi_start(), err, TAG, "Failed to start WiFi");
+
+    // Wait for connection
+    EventBits_t bits = xEventGroupWaitBits(s_wifi_events, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
+                                           pdFALSE, pdFALSE, pdMS_TO_TICKS(30000));
+    ESP_GOTO_ON_FALSE((bits & WIFI_CONNECTED_BIT) == WIFI_CONNECTED_BIT, ESP_FAIL, err,
+                      TAG, "Failed to obtain IP address from WiFi station");
+    return ESP_OK;
+err:
+    esp_wifi_stop();
+    esp_wifi_deinit();
+    nvs_flash_deinit();
+    esp_netif_deinit();
+    esp_event_loop_delete_default();
+    return ret;
+
+}
+
+_Thread_local char s_ipv4_addr[4 * 4]; // 4 octets + '.'/term
+
+char *wifi_get_ipv4(wifi_interface_t interface)
+{
+    esp_netif_t *netif = esp_netif_get_handle_from_ifkey(interface == WIFI_IF_AP ? "WIFI_AP_DEF" : "WIFI_STA_DEF");
+    ESP_RETURN_ON_FALSE(netif, NULL, TAG, "Failed to find default Wi-Fi netif");
+    esp_netif_ip_info_t ip_info;
+    ESP_RETURN_ON_FALSE(esp_netif_get_ip_info(netif, &ip_info) == ESP_OK, NULL, TAG, "Failed to get IP from netif");
+    ESP_RETURN_ON_FALSE(esp_ip4addr_ntoa(&ip_info.ip, s_ipv4_addr, sizeof(s_ipv4_addr)) != NULL, NULL, TAG, "Failed to convert IP");
+    return s_ipv4_addr;
+}

components/mosquitto/examples/serverless_mqtt/sdkconfig.defaults

@@ -0,0 +1,3 @@
+CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=16384
+CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=32768

components/mosquitto/idf_component.yml

@@ -1,5 +1,7 @@
-version: "2.0.28~0"
+version: "2.0.20~1"
 url: https://github.com/espressif/esp-protocols/tree/master/components/mosquitto
 description: The component provides a simple ESP32 port of mosquitto broker
 dependencies:
   idf: '>=5.1'
+  espressif/sock_utils:
+    version: '^0.2'

components/mosquitto/port/broker.c

@@ -101,6 +101,8 @@ void mosq_broker_stop(void)
     run = 0;
 }
 
+extern mosq_message_cb_t g_mosq_message_callback;
+
 int mosq_broker_run(struct mosq_broker_config *broker_config)
 {
 
@@ -125,6 +127,9 @@ int mosq_broker_run(struct mosq_broker_config *broker_config)
     if (broker_config->tls_cfg) {
         net__set_tls_config(broker_config->tls_cfg);
     }
+    if (broker_config->handle_message_cb) {
+        g_mosq_message_callback = broker_config->handle_message_cb;
+    }
 
     db.config = &config;
 

components/mosquitto/port/callbacks.c

@@ -13,7 +13,9 @@
 #include "util_mosq.h"
 #include "utlist.h"
 #include "lib_load.h"
+#include "mosq_broker.h"
 
+mosq_message_cb_t g_mosq_message_callback = NULL;
 
 int mosquitto_callback_register(
     mosquitto_plugin_id_t *identifier,
@@ -44,5 +46,8 @@ void plugin__handle_disconnect(struct mosquitto *context, int reason)
 
 int plugin__handle_message(struct mosquitto *context, struct mosquitto_msg_store *stored)
 {
+    if (g_mosq_message_callback) {
+        g_mosq_message_callback(context->id, stored->topic, stored->payload, stored->payloadlen, stored->qos, stored->retain);
+    }
     return MOSQ_ERR_SUCCESS;
 }

components/mosquitto/port/ifaddrs.c

@@ -1,20 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Roger Light <roger@atchoo.org>
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- * SPDX-FileContributor: 2024 Espressif Systems (Shanghai) CO LTD
- */
-#include "ifaddrs.h"
-
-// Dummy implementation of getifaddrs()
-// TODO: Implement this if we need to use bind_interface option of listener's config
-int getifaddrs(struct ifaddrs **ifap)
-{
-    return -1;
-}
-
-void freeifaddrs(struct ifaddrs *ifa)
-{
-
-}

components/mosquitto/port/include/mosq_broker.h

@@ -9,6 +9,7 @@
 
 struct mosquitto__config;
 
+typedef void (*mosq_message_cb_t)(char *client, char *topic, char *data, int len, int qos, int retain);
 /**
  * @brief Mosquitto configuration structure
  *
@@ -24,6 +25,10 @@ struct mosq_broker_config {
                                      * You can open the respective docs with this idf.py command:
                                      * `idf.py docs -sp api-reference/protocols/esp_tls.html`
                                      */
+    void (*handle_message_cb)(char *client, char *topic, char *data, int len, int qos, int retain); /*!<
+                                     * On message callback. If configured, user function is called
+                                     * whenever mosquitto processes a message.
+                                     */
 };
 
 /**

components/mosquitto/port/priv_include/config.h

@@ -5,20 +5,11 @@
  */
 #pragma once
 #include <ctype.h>
+#include "net/if.h"
 
 #undef  isspace
 #define isspace(__c) (__ctype_lookup((int)__c)&_S)
 
 #include_next "config.h"
-#define VERSION "v2.0.18~0"
 
-#define _SC_OPEN_MAX_OVERRIDE                 4
-
-// used to override syscall for obtaining max open fds
-static inline long sysconf(int arg)
-{
-    if (arg == _SC_OPEN_MAX_OVERRIDE) {
-        return 64;
-    }
-    return -1;
-}
+#define VERSION "v2.0.20~1"

components/mosquitto/port/priv_include/ifaddrs.h

@@ -1,17 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-
-#define gai_strerror(x) "gai_strerror() not supported"
-
-struct ifaddrs {
-    struct ifaddrs  *ifa_next;    /* Next item in list */
-    char            *ifa_name;    /* Name of interface */
-    struct sockaddr *ifa_addr;    /* Address of interface */
-};
-
-int getifaddrs(struct ifaddrs **ifap);
-void freeifaddrs(struct ifaddrs *ifa);

components/mosquitto/port/priv_include/poll.h

@@ -1,8 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-
-#include_next "sys/poll.h"

components/mosquitto/port/sysconf.c

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <ctype.h>
+#include <unistd.h>
+
+#define _SC_OPEN_MAX_OVERRIDE                 4
+
+// used to override syscall for obtaining max open fds
+long sysconf(int arg)
+{
+    if (arg == _SC_OPEN_MAX_OVERRIDE) {
+        return 64;
+    }
+    return -1;
+}

components/mosquitto/test/README.md

@@ -0,0 +1,5 @@
+# ESP32 mosquitto tests
+
+Mosquitto component doesn't have any tests yet, but we upcycle IDF mqtt tests and run them with the current version of mosquitto.
+For that we need to update the IDF test project's `idf_component.yml` file to reference this actual version of mosquitto.
+We also need to update some pytest decorators to run only relevant test cases. See the [replacement](./replace_decorators.py) script.

components/mosquitto/test/replace_decorators.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+
+# This script replaces the `@pytest` decorators in the test files
+# based on the value of the `config` parameter in the `@pytest` decorator.
+# to reuse mqtt test cases for mosquitto broker.
+
+import re
+import sys
+
+
+def replace_decorators(in_file: str, out_file: str) -> None:
+    with open(in_file, 'r') as file:
+        content = file.read()
+
+    # we replace config decorators to differentiate between local mosquitto based tests
+    pattern = r"@pytest\.mark\.parametrize\(\s*'config'\s*,\s*\[\s*'(.*?)'\s*\]\s*,.*\)"
+
+    def replacement(match):
+        config_value = match.group(1)
+        if config_value == 'local_broker':
+            return '@pytest.mark.test_mosquitto'
+        else:
+            return '@pytest.mark.test_mqtt'
+
+    # Replace occurrences
+    updated_content = re.sub(pattern, replacement, content)
+
+    with open(out_file, 'w') as file:
+        file.write(updated_content)
+
+
+# Main function to handle arguments
+if __name__ == '__main__':
+    if len(sys.argv) != 3:
+        print('Usage: python replace_decorators.py <in_file> <out_file>')
+        sys.exit(1)
+
+    in_file = sys.argv[1]
+    out_file = sys.argv[2]
+    replace_decorators(in_file, out_file)
+    print(f'Replacements completed')

components/sock_utils/.cz.yaml

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

components/sock_utils/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.2.2](https://github.com/espressif/esp-protocols/commits/sock_utils-v0.2.2)
+
+### Bug Fixes
+
+- Fix gai_strerror() impl to return const string ([f12a2056](https://github.com/espressif/esp-protocols/commit/f12a2056))
+
+## [0.2.1](https://github.com/espressif/esp-protocols/commits/sock_utils-v0.2.1)
+
+### Bug Fixes
+
+- Fix potential macro colission including standard headers ([ade9448c](https://github.com/espressif/esp-protocols/commit/ade9448c))
+
+## [0.2.0](https://github.com/espressif/esp-protocols/commits/sock_utils-v0.2.0)
+
+### Features
+
+- Declare socketpair and gai_strerror via standard headers ([b090a3cb](https://github.com/espressif/esp-protocols/commit/b090a3cb))
+- Add support for gethostname() ([f7c0b756](https://github.com/espressif/esp-protocols/commit/f7c0b756))
+
 ## [0.1.0](https://github.com/espressif/esp-protocols/commits/sock_utils-v0.1.0)
 
 ### Features

components/sock_utils/CMakeLists.txt

@@ -2,5 +2,15 @@ idf_component_register(SRCS "src/getnameinfo.c"
                             "src/ifaddrs.c"
                             "src/gai_strerror.c"
                             "src/socketpair.c"
+                            "src/gethostname.c"
                        INCLUDE_DIRS "include"
                        PRIV_REQUIRES lwip esp_netif)
+
+# To support declarations from standard headers in lwip component
+# - socket pair from lwip/sockets.h
+# - gai_strerror from lwip/netdb.h
+# also need to make lwip depend on the sock_utils lib
+idf_component_get_property(lwip lwip COMPONENT_LIB)
+target_compile_definitions(${lwip} PUBLIC LWIP_SOCKET_HAS_SOCKETPAIR=1)
+target_compile_definitions(${lwip} PUBLIC LWIP_NETDB_HAS_GAI_STRERROR=1)
+target_link_libraries(${lwip} PUBLIC ${COMPONENT_LIB})

components/sock_utils/README.md

@@ -6,12 +6,17 @@ This component provides simplified implementations of common socket-related util
 ## Supported Functions
 
 
-| API              | Description                                                 | Limitations                                                       |
-|------------------|-------------------------------------------------------------|-------------------------------------------------------------------|
-| `ifaddrs()`      | Retrieves interface addresses using `esp_netif`             | IPv4 addresses only                                               |
-| `socketpair()`   | Creates a pair of connected sockets using `lwIP` loopback stream sockets | IPv4 sockets only                                    |
-| `pipe()`         | Wraps `socketpair()` to provide unidirectional pipe-like functionality | Uses bidirectional sockets in place of true pipes  |
-| `getnameinfo()`  | Converts IP addresses to human-readable form using `lwIP`'s `inet_ntop()` | IPv4 only; supports `NI_NUMERICHOST` and `NI_NUMERICSERV` flags only |
-| `gai_strerror()` | Returns error code as a string                              | Simple numeric string representation only                         |
+| API                | Description                                                 | Limitations                                                       | Declared in                            |
+|--------------------|-------------------------------------------------------------|-------------------------------------------------------------------|----------------------------------------|
+| `ifaddrs()`        | Retrieves interface addresses using `esp_netif`             | IPv4 addresses only                                               | `ifaddrs.h`                            |
+| `socketpair()` *)  | Creates a pair of connected sockets using `lwIP` loopback stream sockets | IPv4 sockets only                                    | `socketpair.h`, `sys/socket.h` **)     |
+| `pipe()`       *) | Wraps `socketpair()` to provide unidirectional pipe-like functionality | Uses bidirectional sockets in place of true pipes  | `socketpair.h`, `unistd.h` ***)        |
+| `getnameinfo()`    | Converts IP addresses to human-readable form using `lwIP`'s `inet_ntop()` | IPv4 only; supports `NI_NUMERICHOST` and `NI_NUMERICSERV` flags only | `getnameinfo.h`, `netdb.h` in ESP-IDF  |
+| `gai_strerror()`   | Returns error code as a string                              | Simple numeric string representation only                         | `gai_strerror.h`, `netdb.h` **)        |
+| `gethostname()`    | Returns lwip netif hostname                                 | Not a system-wide hostname, but interface specific hostname       | `gethostname.h`, `unistd.h` in ESP-IDF |
 
-**Note**: `socketpair()` and `pipe()` are built on top of `lwIP` TCP sockets, inheriting the same characteristics. For instance, the maximum transmit buffer size is based on the `TCP_SND_BUF` setting.
+**Notes**:
+
+- **`*)`** `socketpair()` and `pipe()` are built on top of `lwIP` TCP sockets, inheriting the same characteristics. For instance, the maximum transmit buffer size is based on the `TCP_SND_BUF` setting.
+- **`**)`** `socketpair()` and `gai_strerror()` are declared in sock_utils header files, the declaration is propagated to ESP-IDF from v5.5 to the official header files. If you're using older IDF version, you need to manually pre-include related header files from the sock_utils public include directory.
+- **`***)`** `pipe()` is declared in compiler's `sys/unistd.h`.

components/sock_utils/idf_component.yml

@@ -1,4 +1,4 @@
-version: 0.1.0
+version: 0.2.2
 description: The component provides helper implementation of common system/socket utilities
 url: https://github.com/espressif/esp-protocols/tree/master/components/sock_utils
 dependencies:

components/sock_utils/include/gai_strerror.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -18,13 +18,14 @@ extern "C" {
 #endif
 
 /**
-* @brief Returns a numeric string representing of `getaddrinfo()` error code.
+* @brief Returns a string representing of `getaddrinfo()` error code.
 *
-* @param[in] ecode Error code returned by `getaddrinfo()`.
+* @param[in] errcode Error code returned by `getaddrinfo()`.
 *
-* @return A pointer to a string describing the error.
+* @return A pointer to a string containing the error code, for example "EAI_NONAME"
+* for EAI_NONAME error type.
 */
-const char *gai_strerror(int ecode);
+const char *gai_strerror(int errcode);
 
 #ifdef __cplusplus
 }

components/sock_utils/include/gethostname.h

@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <unistd.h>
+#include "sdkconfig.h"
+
+#ifdef CONFIG_IDF_TARGET_LINUX
+// namespace with esp_ on linux to avoid conflict of symbols
+#define gethostname esp_gethostname
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Retrieves the hostname of the device.
+ *
+ * This function provides the hostname associated with the network interface.
+ * Unlike the standard behavior where the hostname represents a system-wide name,
+ * this implementation returns lwip netif hostname (used as a hostname in DHCP packets)
+ *
+ * @param[out] name A pointer to a buffer where the hostname will be stored.
+ *                  The buffer must be allocated by the caller.
+ * @param[in] len   The size of the buffer pointed to by @p name. The hostname,
+ *                  including the null-terminator, must fit within this size.
+ *
+ * @return
+ *   - 0 on success
+ *   - -1 on error, with `errno` set to indicate the error:
+ *     - `EINVAL`: Invalid argument, name is NULL, or hostname is too long
+ *
+ * @note This implementation retrieves the hostname associated with the network
+ * interface using the `esp_netif_get_hostname()` function, which in turn
+ * returns lwip netif hostname used in DHCP packets if LWIP_NETIF_HOSTNAME=1 (hardcoded)
+ * in ESP-IDF lwip port.
+ * As there could be multiple network interfaces in the system, the logic tries
+ * to find the default (active) netif first, then it looks for any (inactive) netif
+ * with highest route priority. If none of the above found or esp_netif_get_hostname() fails
+ * for the selected interface, this API returns the default value of `CONFIG_LWIP_LOCAL_HOSTNAME`,
+ * the local hostname from lwip component configuration menu.
+ */
+int gethostname(char *name, size_t len);
+
+#ifdef __cplusplus
+}
+#endif

components/sock_utils/include/netdb_macros.h

@@ -5,6 +5,17 @@
  */
 #pragma once
 
+#include "sdkconfig.h"
+#ifndef CONFIG_IDF_TARGET_LINUX
+#include <netinet/in.h>   // For network-related definitions
+#include <sys/socket.h>   // For socket-related definitions
+#include <net/if.h>       // For interface flags (e.g., IFF_UP)
+#include <netdb.h>        // For NI_NUMERICHOST, NI_NUMERICSERV, etc.
+#include <errno.h>        // For EAI_BADFLAGS
+#include <sys/un.h>       // For AF_UNIX
+#include <sys/types.h>    // For PF_LOCAL
+#endif
+
 #ifndef NI_NUMERICHOST
 #define NI_NUMERICHOST  0x1
 #endif
@@ -32,3 +43,10 @@
 #ifndef AF_UNIX
 #define AF_UNIX         1
 #endif
+
+#ifndef PF_LOCAL
+/*
+ * In POSIX, AF_UNIX and PF_LOCAL are essentially synonymous.
+ */
+#define PF_LOCAL        AF_UNIX
+#endif

components/sock_utils/src/gai_strerror.c

@@ -1,17 +1,36 @@
 /*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 #include <stdio.h>
 #include "gai_strerror.h"
+#include "lwip/netdb.h"
 
-_Thread_local char gai_strerror_string[32];
+#define HANDLE_GAI_ERROR(code) \
+    case code: return #code;
 
-const char *gai_strerror(int ecode)
+const char *gai_strerror(int errcode)
 {
-    if (snprintf(gai_strerror_string, sizeof(gai_strerror_string), "EAI error:%d", ecode) < 0) {
-        return "gai_strerror() failed";
+    switch (errcode) {
+        /* lwip defined DNS codes */
+        HANDLE_GAI_ERROR(EAI_BADFLAGS)
+        HANDLE_GAI_ERROR(EAI_FAIL)
+        HANDLE_GAI_ERROR(EAI_FAMILY)
+        HANDLE_GAI_ERROR(EAI_MEMORY)
+        HANDLE_GAI_ERROR(EAI_NONAME)
+        HANDLE_GAI_ERROR(EAI_SERVICE)
+        /* other error codes optionally defined in platform/newlib or toolchain */
+#ifdef EAI_AGAIN
+        HANDLE_GAI_ERROR(EAI_AGAIN)
+#endif
+#ifdef EAI_SOCKTYPE
+        HANDLE_GAI_ERROR(EAI_SOCKTYPE)
+#endif
+#ifdef EAI_SYSTEM
+        HANDLE_GAI_ERROR(EAI_SYSTEM)
+#endif
+    default:
+        return "Unknown error";
     }
-    return gai_strerror_string;
 }

components/sock_utils/src/gethostname.c

@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <string.h>
+#include "gethostname.h"
+#include "esp_netif.h"
+#include "errno.h"
+#include "esp_log.h"
+
+
+static bool highest_prio_netif(esp_netif_t *netif, void *ctx)
+{
+    esp_netif_t **highest_so_far = ctx;
+    if (esp_netif_get_route_prio(netif) > esp_netif_get_route_prio(*highest_so_far)) {
+        *highest_so_far = netif;
+    }
+    return false;   // go over the entire list to find the netif with the highest route-prio
+}
+
+int gethostname(char *name, size_t len)
+{
+    if (name == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+    const char *netif_hostname = CONFIG_LWIP_LOCAL_HOSTNAME;    // default value from Kconfig
+
+    // Find the default netif
+    esp_netif_t *default_netif = esp_netif_get_default_netif();
+    if (default_netif == NULL) {    // if no netif is active/up -> find the highest prio netif
+        esp_netif_find_if(highest_prio_netif, &default_netif);
+    }
+    // now the `default_netif` could be NULL and/or the esp_netif_get_hostname() could fail
+    // but we ignore the return code, as if it fails, the `netif_hostname` still holds the default value
+    esp_netif_get_hostname(default_netif, &netif_hostname);
+
+    size_t hostname_len;
+    if (netif_hostname == NULL || len < (hostname_len = strlen(netif_hostname) + 1)) { // including the NULL terminator
+        errno = EINVAL;
+        return -1;
+    }
+    memcpy(name, netif_hostname, hostname_len);
+    return 0;
+}

components/sock_utils/test/host/main/test_sock_utils.cpp

@@ -3,6 +3,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+#include "gethostname.h"
 #include "ifaddrs.h"
 #include "esp_netif.h"
 #include "esp_event.h"
@@ -148,6 +149,30 @@ TEST_CASE("gai_strerror()", "[sock_utils]")
     CHECK(str_error != NULL);
 }
 
+TEST_CASE("gethostname()", "[sock_utils]")
+{
+    const char *test_netif_name = "station";
+    char hostname[32];
+    int ret;
+
+    // expect failure
+    ret = gethostname(hostname, strlen(CONFIG_LWIP_LOCAL_HOSTNAME) - 1);
+    CHECK(ret == -1);
+
+    // happy flow with the default name
+    ret = gethostname(hostname, sizeof(hostname));
+    CHECK(ret == 0);
+    CHECK(strcmp(hostname, CONFIG_LWIP_LOCAL_HOSTNAME) == 0);
+
+    // happy flow with the netif name
+    esp_netif_t *esp_netif = create_test_netif(test_netif_name, 1);
+    REQUIRE(esp_netif != NULL);
+    CHECK(esp_netif_set_hostname(esp_netif, test_netif_name) == ESP_OK);
+    ret = gethostname(hostname, sizeof(hostname));
+    CHECK(ret == 0);
+    CHECK(strcmp(hostname, test_netif_name) == 0);
+    esp_netif_destroy(esp_netif);
+}
 
 extern "C" void app_main(void)
 {

docs/esp_websocket_client/en/index.rst

@@ -66,13 +66,43 @@ Configuration:
 .. note:: If you want to verify the server, then you need to provide a certificate in PEM format, and provide to ``cert_pem`` in :cpp:type:`websocket_client_config_t`. If no certficate is provided then the TLS connection will default to not requiring verification.
 
 PEM certificate for this example could be extracted from an openssl `s_client` command connecting to websocket.org.
-In case a host operating system has `openssl` and `sed` packages installed, one could execute the following command to download and save the root or intermediate root certificate to a file (Note for Windows users: Both Linux like environment or Windows native packages may be used).
-```
-echo "" | openssl s_client -showcerts -connect websocket.org:443 | sed -n "1,/Root/d; /BEGIN/,/END/p" | openssl x509 -outform PEM >websocket_org.pem
-```
+In case a host operating system has `openssl` and `sed` packages installed, one could execute the following command to download and save the root or intermediate root certificate to a file (Note for Windows users: Both Linux like environment or Windows native packages may be used). ::
+
+    echo "" | openssl s_client -showcerts -connect websocket.org:443 \
+        | sed -n "1,/Root/d; /BEGIN/,/END/p" \
+        | openssl x509 -outform PEM \
+        > websocket_org.pem
 
 This command will extract the second certificate in the chain and save it as a pem-file.
 
+Mutual TLS with DS Peripheral
+"""""""""""""""""""""""""""""
+
+To leverage the Digital Signature (DS) peripheral on supported targets, use `esp_secure_cert_mgr <https://github.com/espressif/esp_secure_cert_mgr/>`_ to flash an encrypted client certificate. In your project, add the dependency: ::
+
+    idf.py add-dependency esp_secure_cert_mgr
+
+Set ``client_cert`` and ``client_ds_data`` in the config struct:
+
+.. code:: c
+
+    char *client_cert = NULL;
+    uint32_t client_cert_len = 0;
+    esp_err_t err = esp_secure_cert_get_device_cert(&client_cert, &client_cert_len);
+    assert(err == ESP_OK);
+
+    esp_ds_data_ctx_t *ds_data = esp_secure_cert_get_ds_ctx();
+    assert(ds_data != NULL);
+
+    esp_websocket_client_config_t config = {
+        .uri = "wss://echo.websocket.org",
+        .cert_pem = (const char *)websocket_org_pem_start,
+        .client_cert = client_cert,
+        .client_ds_data = ds_data,
+    };
+
+.. note:: ``client_cert`` provided by `esp_secure_cert_mgr` is a null-terminated PEM; so ``client_cert_len`` (DER format) should not be set.
+
 Subprotocol
 ^^^^^^^^^^^
 
@@ -91,14 +121,14 @@ For more options on :cpp:type:`esp_websocket_client_config_t`, please refer to A
 
 Events
 ------
-* `WEBSOCKET_EVENT_BEGIN': The client thread is running.
+* `WEBSOCKET_EVENT_BEGIN`: The client thread is running.
 * `WEBSOCKET_EVENT_BEFORE_CONNECT`: The client is about to connect.
 * `WEBSOCKET_EVENT_CONNECTED`: The client has successfully established a connection to the server. The client is now ready to send and receive data. Contains no event data.
 * `WEBSOCKET_EVENT_DATA`: The client has successfully received and parsed a WebSocket frame. The event data contains a pointer to the payload data, the length of the payload data as well as the opcode of the received frame. A message may be fragmented into multiple events if the length exceeds the buffer size. This event will also be posted for non-payload frames, e.g. pong or connection close frames.
 * `WEBSOCKET_EVENT_ERROR`: The client has experienced an error. Examples include transport write or read failures.
 * `WEBSOCKET_EVENT_DISCONNECTED`: The client has aborted the connection due to the transport layer failing to read data, e.g. because the server is unavailable. Contains no event data.
 * `WEBSOCKET_EVENT_CLOSED`: The connection has been closed cleanly.
-* `WEBSOCKET_EVENT_FINISH': The client thread is about to exit.
+* `WEBSOCKET_EVENT_FINISH`: The client thread is about to exit.
 
 If the client handle is needed in the event handler it can be accessed through the pointer passed to the event handler:
 

docs/requirements.txt

@@ -1,8 +1 @@
-sphinxcontrib-applehelp==1.0.4
-sphinxcontrib_devhelp==1.0.2
-sphinxcontrib-htmlhelp==2.0.1
-sphinxcontrib-serializinghtml==1.1.5
-sphinxcontrib-qthelp==1.0.3
-breathe==4.35
-recommonmark==0.7.1
-esp-docs==1.7.1
+esp-docs>=2.0.0