Merge pull request #502 from espressif-abhikroy/component/console_cmd_mqtt

feat(console): Added component with mqtt command

.github/workflows/clang-tidy.yml

@@ -35,14 +35,14 @@ jobs:
         working-directory: test_app
         run: |
           . ${IDF_PATH}/export.sh
-          idf.py clang-check --include-paths $GITHUB_WORKSPACE --exclude-paths $PWD --run-clang-tidy-py run-clang-tidy
+          idf.py clang-check --include-paths $GITHUB_WORKSPACE --exclude-paths $PWD --run-clang-tidy-py run-clang-tidy --run-clang-tidy-options "-checks=-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling"
           cp warnings.txt ../
       - name: Convert clang-tidy results into SARIF output
         run: |
           export PATH=$PWD:$PATH
           ./clang-tidy-sarif -o results.sarif.raw warnings.txt
           python3 filter_sarif.py -o results.sarif --include-prefix ${GITHUB_WORKSPACE}/ results.sarif.raw
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           path: |
             warnings.txt

.github/workflows/console_cmd_mqtt__build.yml

@@ -0,0 +1,32 @@
+name: "console_cmd_mqtt: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_console_cmd_mqtt:
+    if: contains(github.event.pull_request.labels.*.name, 'console') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
+        idf_target: ["esp32"]
+        test: [ { app: mqtt_ssl_auth_console, path: "components/console_cmd_mqtt/examples" }]
+    runs-on: ubuntu-22.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        shell: bash
+        working-directory: ${{matrix.test.path}}
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install idf-component-manager idf-build-apps --upgrade
+          python ../../../ci/build_apps.py ./${{ matrix.test.app }} --target ${{ matrix.idf_target }} -vv --preserve-all --pytest-app

.github/workflows/examples_build-host-test.yml

@@ -14,12 +14,17 @@ jobs:
     strategy:
       matrix:
         idf_ver: ["latest", "release-v5.1", "release-v5.2", "release-v5.3"]
+        include:
+          - idf_ver: "latest"
+            warning: "Warning: The smallest app partition is nearly full"
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
         uses: actions/checkout@v4
       - name: Build with IDF-${{ matrix.idf_ver }}
+        env:
+          EXPECTED_WARNING: ${{ matrix.warning }}
         shell: bash
         run: |
           . ${IDF_PATH}/export.sh

.github/workflows/mdns__host-tests.yml

@@ -10,27 +10,30 @@ on:
 jobs:
   host_test_mdns:
     if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
-    name: Host test
+    name: Host test build
     runs-on: ubuntu-22.04
-    container: espressif/idf:release-v5.1
+    container: espressif/idf:release-v5.3
 
     steps:
       - name: Checkout esp-protocols
         uses: actions/checkout@v4
         with:
-          path: esp-protocols
+          path: protocols
 
       - name: Build and Test
         shell: bash
         run: |
-          apt-get update && apt-get install -y dnsutils gcc g++
           . ${IDF_PATH}/export.sh
-          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/host_test
-          idf.py build
-          ./build/mdns_host.elf &
-          dig +short -p 5353 @224.0.0.251 myesp.local > ip.txt
-          cat ip.txt | xargs dig +short -p 5353 @224.0.0.251 -x
-          cat ip.txt
+          python -m pip install idf-build-apps dnspython pytest pytest-embedded pytest-embedded-serial-esp pytest-embedded-idf
+          cd $GITHUB_WORKSPACE/protocols
+          # Build host tests app (with all configs and targets supported)
+          python ./ci/build_apps.py components/mdns/tests/host_test/
+          cd components/mdns/tests/host_test
+          # First run the linux_app and send a quick A query and a reverse query
+          ./build_linux_app/mdns_host.elf &
+          python dnsfixture.py A myesp.local --ip_only | xargs python dnsfixture.py X
+          # Next we run the pytest (using the console app)
+          pytest
 
   build_afl_host_test_mdns:
     if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'

.github/workflows/modem__build-host-tests.yml

@@ -13,11 +13,8 @@ jobs:
     name: Build examples
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v4.4", "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"]
         example: ["pppos_client", "modem_console", "modem_tcp_client", "ap_to_pppos", "simple_cmux_client"]
-        exclude:
-          - idf_ver: "release-v4.4"
-            example: modem_tcp_client
         include:
           - idf_ver: "release-v5.0"
             example: "simple_cmux_client"
@@ -26,13 +23,7 @@ jobs:
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
-      - name: Check out code (v3) # @v4 failed due to Node 20's requirement, incompatible with older IDF versions
-        if: matrix.idf_ver != 'latest' && matrix.idf_ver < 'release-v5.0'
-        uses: actions/checkout@v3
-        with:
-          path: protocols
-      - name: Check out code (v4)
-        if: matrix.idf_ver == 'latest' || matrix.idf_ver >= 'release-v5.0'
+      - name: Check out code
         uses: actions/checkout@v4
         with:
           path: protocols
@@ -53,7 +44,7 @@ jobs:
     name: Build tests
     strategy:
       matrix:
-        idf_ver: ["release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "latest"]
+        idf_ver: ["release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4", "latest"]
         test: ["target", "target_ota", "target_iperf"]
 
     runs-on: ubuntu-22.04

.github/workflows/modem__target-test.yml

@@ -15,7 +15,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
+        test: [ { app: pppd, path: test/target }, { app: pppd_chap_auth, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
         include:
           - idf_ver: "latest"
             idf_target: "esp32s2"
@@ -58,7 +58,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
+        test: [ { app: pppd, path: test/target }, { app: pppd_chap_auth, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
         include:
           - idf_ver: "latest"
             idf_target: "esp32s2"
@@ -69,9 +69,11 @@ jobs:
       - modem
     env:
       TEST_DIR: components/esp_modem/${{ matrix.test.path }}
+      ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
     steps:
       - name: Clear repository
-        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
+        run: |
+          sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
       - uses: actions/checkout@v3
       - uses: actions/download-artifact@v3
         with:

.github/workflows/mosq__build.yml

@@ -0,0 +1,73 @@
+name: "mosq: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_mosq:
+    if: contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push'
+    name: Mosquitto build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on: ubuntu-22.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/mosquitto/examples/broker
+      TARGET_TEST_DIR: build_esp32_default
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install idf-component-manager idf-build-apps --upgrade
+          python ci/build_apps.py ${TEST_DIR}
+          cd ${TEST_DIR}
+          ${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
+          if-no-files-found: error
+
+  test_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 target test
+    needs: build_mosq
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/mosquitto/examples/broker
+      TARGET_TEST_DIR: build_esp32_default
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: mosq_target_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
+          unzip ci/artifacts.zip -d ci
+          for dir in `ls -d ci/build_*`; do
+          rm -rf build sdkconfig.defaults
+          mv $dir build
+          python -m pytest --log-cli-level DEBUG --junit-xml=./results_esp32_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=esp32
+          done

.github/workflows/publish-docs-component.yml

@@ -98,7 +98,9 @@ jobs:
             components/console_cmd_ping;
             components/console_cmd_ifconfig;
             components/console_cmd_wifi;
-            components/esp_wifi_remote;
+            components/console_cmd_mqtt;
             components/mbedtls_cxx;
+            components/mosquitto;
+            components/sock_utils;
           namespace: "espressif"
           api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}

.github/workflows/sockutls_build.yml

@@ -0,0 +1,95 @@
+name: "sock_utils: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_sock_utils:
+    if: contains(github.event.pull_request.labels.*.name, 'sock_utils') || github.event_name == 'push'
+    name: Socket helpers build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on: ubuntu-22.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/sock_utils/examples/simple
+      TARGET_TEST_DIR: build_esp32_default
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install idf-component-manager idf-build-apps --upgrade
+          python ci/build_apps.py ${TEST_DIR}
+          cd ${TEST_DIR}
+          ${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: sock_utils_target_esp32_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/artifacts.zip
+          if-no-files-found: error
+  host_test_sock_utils:
+    if: contains(github.event.pull_request.labels.*.name, 'sock_utils') || github.event_name == 'push'
+    name: Socket helpers host test
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on: ubuntu-22.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/sock_utils/test/host
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install idf-component-manager idf-build-apps --upgrade
+          cd ${TEST_DIR}
+          idf.py build
+          ./build/sock_utils_host_test.elf
+
+  test_sock_utils:
+    # 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, 'sock_utils') || github.event_name == 'push' )
+    name: Socket helpers target test
+    needs: build_sock_utils
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/sock_utils/examples/simple
+      TARGET_TEST_DIR: build_esp32_default
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: sock_utils_target_esp32_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/ci/
+      - name: Run Test
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          unzip ci/artifacts.zip -d ci
+          for dir in `ls -d ci/build_*`; do
+          rm -rf build sdkconfig.defaults
+          mv $dir build
+          python -m pytest --log-cli-level DEBUG --junit-xml=./results_esp32_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=esp32
+          done

.github/workflows/wifi_remote__build.yml

@@ -1,77 +0,0 @@
-name: "esp_wifi_remote: build-tests"
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    types: [opened, synchronize, reopened, labeled]
-
-jobs:
-  wifi_remote_api_compat:
-    if: contains(github.event.pull_request.labels.*.name, 'wifi_remote') || github.event_name == 'push'
-    name: Check API compatibility of WiFi Remote
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-      - name: Check that headers are the same as generated
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          pip install idf-component-manager idf-build-apps --upgrade
-          cd ./components/esp_wifi_remote/scripts
-          python generate_and_check.py
-
-  build_wifi_remote:
-    if: contains(github.event.pull_request.labels.*.name, 'wifi_remote') || github.event_name == 'push'
-    name: Build WiFi Remote Test
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        test: [ { app: smoke_test, path: "test/smoke_test" }]
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2
-        with:
-            key: ${{ matrix.idf_ver }}
-      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          pip install idf-component-manager idf-build-apps --upgrade
-          python ./ci/build_apps.py ./components/esp_wifi_remote/${{matrix.test.path}} -vv --preserve-all
-
-  build_wifi_remote_example:
-    if: contains(github.event.pull_request.labels.*.name, 'wifi_remote') || github.event_name == 'push'
-    name: Build WiFi Remote Example
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        example: [ { app: host, path: "examples/mqtt" }, { app: slave, path: "examples/server" }]
-        include:
-          - idf_ver: "latest"
-            example: { app: slave, path: "examples/server" }
-            warning: "Warning: The smallest app partition is nearly full"
-
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-      - name: Build ${{ matrix.example.app }} with IDF-${{ matrix.idf_ver }}
-        env:
-          EXPECTED_WARNING: ${{ matrix.warning }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          pip install idf-component-manager idf-build-apps --upgrade
-          python ./ci/build_apps.py ./components/esp_wifi_remote/${{matrix.example.path}} -vv --preserve-all

.gitmodules

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

.pre-commit-config.yaml

@@ -61,8 +61,8 @@ repos:
   - repo: local
     hooks:
       - id: commit message scopes
-        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, console, common, eppp, wifi_remote, tls_cxx"
-        entry: '\A(?!(feat|fix|ci|bump|test|docs)\((mdns|modem|common|console|websocket|asio|mqtt_cxx|examples|eppp|wifi_remote|tls_cxx)\)\:)'
+        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, console, common, eppp, tls_cxx, mosq, sockutls"
+        entry: '\A(?!(feat|fix|ci|bump|test|docs|chore)\((mdns|modem|common|console|websocket|asio|mqtt_cxx|examples|eppp|tls_cxx|mosq|sockutls)\)\:)'
         language: pygrep
         args: [--multiline]
         stages: [commit-msg]

README.md

@@ -54,10 +54,15 @@ Please refer to instructions in [ESP-IDF](https://github.com/espressif/esp-idf)
 
 * Brief introduction [README](components/eppp_link/README.md)
 
-### esp_wifi_remote
-
-* Brief introduction [README](components/esp_wifi_remote/README.md)
-
 ### mbedtls_cxx
 
 * Brief introduction [README](components/mbedtls_cxx/README.md)
+
+### mosquitto
+
+* Brief introduction [README](components/mosquitto/README.md)
+* API documentation [api.md](components/mosquitto/api.md)
+
+### Socket helpers (sock-utils)
+
+* Brief introduction [README](components/sock_utils/README.md)

ci/build_apps.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 """
 This file is used in CI for esp-protocols build tests
@@ -10,8 +10,6 @@ import sys
 
 from idf_build_apps import build_apps, find_apps, setup_logging
 from idf_build_apps.constants import SUPPORTED_TARGETS
-from packaging import version
-from pkg_resources import get_distribution
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(
@@ -51,43 +49,24 @@ if __name__ == '__main__':
         SUPPORTED_TARGETS.append('linux')
         ignore_warning = 'warning: '  # Ignore all common warnings on linux builds
     setup_logging(2)
-    if version.parse(get_distribution('idf_build_apps').version) >= version.parse('2.0.0'):
-        apps = find_apps(
-            args.paths,
-            recursive=args.recursive,
-            target=args.target,
-            build_dir='build_@t_@w',
-            config_rules_str=args.rules,
-            build_log_filename='build_log.txt',
-            size_json_filename='size.json' if not args.linux else None,
-            check_warnings=True,
-            preserve=not args.delete,
-            manifest_files=args.manifests,
-            default_build_targets=SUPPORTED_TARGETS,
-            manifest_rootpath='.',
-        )
-    else:
-        apps = find_apps(
-            args.paths,
-            recursive=args.recursive,
-            target=args.target,
-            build_dir='build_@t_@w',
-            config_rules_str=args.rules,
-            build_log_path='build_log.txt',
-            size_json_path='size.json' if not args.linux else None,
-            check_warnings=True,
-            preserve=not args.delete,
-            manifest_files=args.manifests,
-            default_build_targets=SUPPORTED_TARGETS,
-            manifest_rootpath='.',
-        )
-
-    for app in apps:
-        print(app)
+    apps = find_apps(
+        args.paths,
+        recursive=args.recursive,
+        target=args.target,
+        build_dir='build_@t_@w',
+        config_rules_str=args.rules,
+        build_log_filename='build_log.txt',
+        size_json_filename='size.json' if not args.linux else None,
+        check_warnings=True,
+        manifest_files=args.manifests,
+        default_build_targets=SUPPORTED_TARGETS,
+        manifest_rootpath='.',
+    )
 
     sys.exit(
         build_apps(apps,
                    dry_run=False,
                    keep_going=False,
+                   no_preserve=args.delete,
                    ignore_warning_strs=ignore_warning)
     )

ci/check_copyright_config.yaml

@@ -47,6 +47,14 @@ asio_component:
     - Apache-2.0
     - BSL-1.0
 
+mosquitto_component:
+  include:
+    - 'components/mosquitto/port/**'
+  allowed_licenses:
+    - EPL-2.0
+    - Apache-2.0
+    - BSD-3-Clause
+
 slim_modem_examples:
   include:
     - 'examples/esp_netif/slip_custom_netif/**'

ci/detect_component_bump

@@ -22,7 +22,11 @@ if git log -1 -m --name-only --pretty="" | grep -q components/${comp}/idf_compon
     if [ $(git tag -l "$tag") ]; then
         echo "${comp}: version (${tag}) already exits"
     else
+        # skip components that do not have changelog
+        [ -f components/${comp}/CHANGELOG.md ] || continue
+
         echo "${comp}: Component version has been updated to ${version}"
+
         # creates release notes from the last entry (between first two "## sections")
         awk '/^## \[/{a++};{if(a==1){print}}' components/${comp}/CHANGELOG.md > release_notes.md
 

ci/ignore_astyle.txt

@@ -1,2 +0,0 @@
-# The below file is generated from esp_wifi_types_native.h in IDF, which doesn't follow atyle
-components/esp_wifi_remote/include/esp_wifi_types_native.h

common_components/linux_compat/esp_ringbuf/CMakeLists.txt

@@ -0,0 +1 @@
+idf_component_register()

common_components/linux_compat/freertos/freertos_linux.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -12,8 +12,24 @@
 #include <stdlib.h>
 #include <string.h>
 #include "osal/osal_api.h"
+#include <semaphore.h>
+
+typedef struct task_notifiers {
+    sem_t sem;
+    TaskHandle_t id;
+} task_notifiers_t;
+
+typedef struct pthread_params {
+    void *const param;
+    TaskFunction_t task;
+    bool started;
+    TaskHandle_t handle;
+} pthread_params_t;
 
 static uint64_t s_semaphore_data = 0;
+static task_notifiers_t *s_notifiers;
+static int s_threads = 0;
+pthread_mutex_t s_mutex;
 
 typedef enum queue_type_tag {
     MUTEX_REC,
@@ -89,6 +105,7 @@ BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue)
     }
     return pdFALSE;
 }
+
 BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask )
 {
     struct generic_queue_handle *h = xQueue;
@@ -99,7 +116,6 @@ 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 )
 {
     struct generic_queue_handle *h = xQueue;
@@ -110,9 +126,6 @@ BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask )
     return pdFALSE;
 }
 
-
-
-
 void vQueueDelete( QueueHandle_t xQueue )
 {
     struct generic_queue_handle *h = xQueue;
@@ -128,8 +141,7 @@ void vQueueDelete( QueueHandle_t xQueue )
 
 QueueHandle_t xSemaphoreCreateBinary(void)
 {
-    QueueHandle_t sempaphore =  xQueueCreate(1, 1);
-    return sempaphore;
+    return xQueueCreate(1, 1);
 }
 
 QueueHandle_t xSemaphoreCreateMutex(void)
@@ -145,6 +157,13 @@ QueueHandle_t xSemaphoreCreateRecursiveMutex(void)
 
 void vTaskDelete(TaskHandle_t *task)
 {
+    for (int i = 0; i < s_threads; ++i) {
+        if (task == s_notifiers[i].id) {
+            sem_destroy(&s_notifiers[i].sem);
+            s_notifiers[i].id = 0;
+        }
+    }
+
     if (task == NULL) {
         pthread_exit(0);
     }
@@ -171,14 +190,21 @@ void vTaskDelay( const TickType_t xTicksToDelay )
 
 void *pthread_task(void *params)
 {
-    struct {
-        void *const param;
-        TaskFunction_t task;
-        bool started;
-    } *pthread_params = params;
+    pthread_params_t *pthread_params = params;
 
     void *const param = pthread_params->param;
     TaskFunction_t task = pthread_params->task;
+
+    pthread_params->handle = xTaskGetCurrentTaskHandle();
+    if (s_threads == 0) {
+        pthread_mutex_init(&s_mutex, NULL);
+    }
+    pthread_mutex_lock(&s_mutex);
+    s_notifiers = realloc(s_notifiers, sizeof(struct task_notifiers) * (++s_threads));
+    assert(s_notifiers);
+    s_notifiers[s_threads - 1].id = pthread_params->handle;
+    sem_init(&s_notifiers[s_threads - 1].sem, 0, 0);
+    pthread_mutex_unlock(&s_mutex);
     pthread_params->started = true;
 
     task(param);
@@ -198,16 +224,12 @@ BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
     return pdTRUE;
 }
 
-
 BaseType_t xTaskCreate(TaskFunction_t pvTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pvCreatedTask)
 {
     pthread_t new_thread = (pthread_t)NULL;
     pthread_attr_t attr;
-    struct {
-        void *const param;
-        TaskFunction_t task;
-        bool started;
-    } pthread_params = { .param = pvParameters, .task = pvTaskCode};
+    pthread_params_t pthread_params = { .param = pvParameters, .task = pvTaskCode};
+
     int res = pthread_attr_init(&attr);
     assert(res == 0);
     res = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
@@ -215,20 +237,33 @@ BaseType_t xTaskCreate(TaskFunction_t pvTaskCode, const char *const pcName, cons
     res = pthread_create(&new_thread, &attr, pthread_task, &pthread_params);
     assert(res == 0);
 
-    if (pvCreatedTask) {
-        *pvCreatedTask = (void *)new_thread;
-    }
-
     // just wait till the task started so we can unwind params from the stack
     while (pthread_params.started == false) {
         usleep(1000);
     }
+    if (pvCreatedTask) {
+        *pvCreatedTask = pthread_params.handle;
+    }
+
     return pdTRUE;
 }
 
 void xTaskNotifyGive(TaskHandle_t task)
 {
-
+    int i = 0;
+    while (true) {
+        pthread_mutex_lock(&s_mutex);
+        if (task == s_notifiers[i].id) {
+            sem_post(&s_notifiers[i].sem);
+            pthread_mutex_unlock(&s_mutex);
+            return;
+        }
+        pthread_mutex_unlock(&s_mutex);
+        if (++i == s_threads) {
+            i = 0;
+        }
+        usleep(1000);
+    }
 }
 
 BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time )
@@ -238,7 +273,7 @@ BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear,
 
 TaskHandle_t xTaskGetCurrentTaskHandle(void)
 {
-    return NULL;
+    return (TaskHandle_t)pthread_self();
 }
 
 EventGroupHandle_t xEventGroupCreate( void )
@@ -270,3 +305,22 @@ EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits
 {
     return osal_signal_wait(xEventGroup, uxBitsToWaitFor, xWaitForAllBits, xTicksToWait);
 }
+
+void ulTaskNotifyTake(bool clear_on_exit, uint32_t xTicksToWait)
+{
+    TaskHandle_t task = xTaskGetCurrentTaskHandle();
+    int i = 0;
+    while (true) {
+        pthread_mutex_lock(&s_mutex);
+        if (task == s_notifiers[i].id) {
+            pthread_mutex_unlock(&s_mutex);
+            sem_wait(&s_notifiers[i].sem);
+            return;
+        }
+        pthread_mutex_unlock(&s_mutex);
+        if (++i == s_threads) {
+            i = 0;
+        }
+        usleep(1000);
+    }
+}

common_components/linux_compat/freertos/include/freertos/FreeRTOS.h

@@ -5,6 +5,7 @@
  */
 #pragma once
 
+#include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>

common_components/linux_compat/freertos/include/freertos/list.h

@@ -4,5 +4,3 @@
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
 #pragma once
-#include "esp_wifi.h"
-#include "esp_hosted_api.h"

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

@@ -11,6 +11,7 @@
 extern "C" {
 #endif
 
+#define tskNO_AFFINITY      ( ( BaseType_t ) 0x7FFFFFFF )
 #define TaskHandle_t TaskHandle_t
 #define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
 
@@ -18,6 +19,8 @@ void vTaskDelay( const TickType_t xTicksToDelay );
 
 void xTaskNotifyGive(TaskHandle_t task);
 
+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 );

components/console_cmd_mqtt/.cz.yaml

@@ -0,0 +1,8 @@
+---
+commitizen:
+  bump_message: 'bump(console): $current_version -> $new_version'
+  pre_bump_hooks: python ../../ci/changelog.py console_cmd_mqtt
+  tag_format: console_cmd_mqtt-v$version
+  version: 1.0.0
+  version_files:
+  - idf_component.yml

components/console_cmd_mqtt/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## [1.0.0](https://github.com/espressif/esp-protocols/commits/console_cmd_mqtt-v1.0.0)
+
+### Features
+
+- Added component with mqtt command ([1fcc5b1d](https://github.com/espressif/esp-protocols/commit/1fcc5b1d))

components/console_cmd_mqtt/CMakeLists.txt

@@ -0,0 +1,7 @@
+idf_component_register(SRCS "console_mqtt.c"
+                    INCLUDE_DIRS "."
+                    PRIV_REQUIRES esp_netif console mqtt)
+
+if(CONFIG_MQTT_CMD_AUTO_REGISTRATION)
+    target_link_libraries(${COMPONENT_LIB} PRIVATE "-u console_cmd_mqtt_register")
+endif()

components/console_cmd_mqtt/Kconfig.projbuild

@@ -0,0 +1,15 @@
+menu "MQTT Configuration"
+
+    config MQTT_CMD_AUTO_REGISTRATION
+        bool "Enable Console command mqtt Auto-registration"
+        default y
+        help
+            Enabling this allows for the autoregistration of the wifi command.
+
+    config MQTT_BROKER_URL
+        string "Broker URL or IP address"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL or IP address of the broker to connect to
+
+endmenu

components/console_cmd_mqtt/README.md

@@ -0,0 +1,87 @@
+# Console command mqtt
+The component provides a console where mqtt commands can be executed.
+
+
+## MQTT Configuration:
+1. Broker: Use menuconfig **"MQTT Configuration"** to configure the broker url.
+
+
+## API
+
+### Steps to enable console in an example code:
+1. Add this component to your project using ```idf.py add-dependency``` command.
+2. In the main file of the example, add the following line:
+    ```c
+    #include "console_mqtt.h"
+    ```
+3. Ensure esp-netif is initialized and default event loop is created in your app_main():
+    ```c
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+    ```
+4. In your app_main() function, add the following line as the last line:
+    ```c
+    ESP_ERROR_CHECK(console_cmd_init());     // Initialize console
+
+    // Register all plugin command added to your project
+    ESP_ERROR_CHECK(console_cmd_all_register());
+
+    // To register only mqtt command skip calling console_cmd_all_register()
+    ESP_ERROR_CHECK(console_cmd_mqtt_register());
+
+    ESP_ERROR_CHECK(console_cmd_start());    // Start console
+    ```
+
+Note: Auto-registration of a specific plugin command can be disabled from menuconfig.
+
+### Certificate Integration for Mutual Authentication
+To enhance security and enable secure communication over MQTT, three functions have been added to the API, allowing users to set client certificates, client keys, and broker certificates separately.
+
+Setting the client certificate:
+```c
+set_mqtt_client_cert(client_cert_pem_start, client_cert_pem_end);
+```
+Setting the client key:
+```c
+set_mqtt_client_key(client_key_pem_start, client_key_pem_end);
+```
+Setting the broker certificate:
+```c
+set_mqtt_broker_certs(broker_cert_pem_start, broker_cert_pem_end);
+```
+Each function takes pointers to the start and end of the respective PEM-encoded data, allowing users to specify the necessary certificate and key information independently. For a complete secure MQTT setup, users should call all three functions in their application code.
+
+To utilize these certificates, users need to include additional arguments when establishing MQTT connections using the library. Specifically, users should provide the `--cert`, `--key`, and `--cafile` options along with the MQTT connection command.
+
+### Adding a plugin command or component:
+To add a plugin command or any component from IDF component manager into your project, simply include an entry within the `idf_component.yml` file.
+
+For more details refer [IDF Component Manager](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/tools/idf-component-manager.html)
+
+## Suported command:
+
+### mqtt:
+```
+mqtt  [-CsD] [-h <host>] [-u <username>] [-P <password>] [--cert] [--key] [--cafile]
+  mqtt command
+  -C, --connect  Connect to a broker (flag, no argument)
+  -h, --host=<host>  Specify the host uri to connect to
+  -s, --status  Displays the status of the mqtt client (flag, no argument)
+  -u, --username=<username>  Provide a username to be used for authenticating with the broker
+  -P, --password=<password>  Provide a password to be used for authenticating with the broker
+      --cert  Define the PEM encoded certificate for this client, if required by the broker (flag, no argument)
+      --key  Define the PEM encoded private key for this client, if required by the broker (flag, no argument)
+      --cafile  Define the PEM encoded CA certificates that are trusted (flag, no argument)
+      --use-internal-bundle  Use the internal certificate bundle for TLS (flag, no argument)
+  -D, --disconnect  Disconnect from the broker (flag, no argument)
+
+mqtt_pub  [-t <topic>] [-m <message>]
+  mqtt publish command
+  -t, --topic=<topic>  Topic to Subscribe/Publish
+  -m, --message=<message>  Message to Publish
+
+mqtt_sub  [-U] [-t <topic>]
+  mqtt subscribe command
+  -t, --topic=<topic>  Topic to Subscribe/Publish
+  -U, --unsubscribe  Unsubscribe from a topic
+```

components/console_cmd_mqtt/console_mqtt.c

@@ -0,0 +1,475 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdio.h>
+#include <string.h>
+#include "sdkconfig.h"
+#include "esp_console.h"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "argtable3/argtable3.h"
+#include "console_mqtt.h"
+#include "mqtt_client.h"
+#if defined(CONFIG_MBEDTLS_CERTIFICATE_BUNDLE)
+#include "esp_crt_bundle.h"
+#endif
+
+static const char *TAG = "console_mqtt";
+
+#define CONNECT_HELP_MSG "mqtt -C -h <host uri> -u <username> -P <password> --cert --key --cafile\n"
+#define PUBLISH_HELP_MSG "Usage: mqtt -P -t <topic> -d <data>\n"
+#define SUBSCRIBE_HELP_MSG "Usage: mqtt -S -t <topic>\n"
+#define UNSUBSCRIBE_HELP_MSG "Usage: mqtt -U\n"
+#define DISCONNECT_HELP_MSG "Usage: mqtt -D\n"
+
+#if CONFIG_MQTT_CMD_AUTO_REGISTRATION
+/**
+ * Static registration of this plugin is achieved by defining the plugin description
+ * structure and placing it into .console_cmd_desc section.
+ * The name of the section and its placement is determined by linker.lf file in 'plugins' component.
+ */
+static const console_cmd_plugin_desc_t __attribute__((section(".console_cmd_desc"), used)) PLUGIN = {
+    .name = "console_cmd_mqtt",
+    .plugin_regd_fn = &console_cmd_mqtt_register
+};
+#endif
+
+static struct {
+    struct arg_lit *connect;
+    struct arg_str *uri;
+    struct arg_lit *status;
+    struct arg_str *username;
+    struct arg_str *password;
+    struct arg_lit *cert;
+    struct arg_lit *key;
+    struct arg_lit *cafile;
+#if defined(CONFIG_MBEDTLS_CERTIFICATE_BUNDLE)
+    struct arg_lit *use_internal_bundle;
+#endif
+    struct arg_lit *disconnect;
+
+    struct arg_end *end;
+} mqtt_args;
+
+static struct {
+    struct arg_str *topic;
+    struct arg_lit *unsubscribe;
+
+    struct arg_end *end;
+} mqtt_sub_args;
+
+static struct {
+    struct arg_str *topic;
+    struct arg_str *message;
+
+    struct arg_end *end;
+} mqtt_pub_args;
+
+typedef enum {
+    MQTT_STATE_INIT = 0,
+    MQTT_STATE_DISCONNECTED,
+    MQTT_STATE_CONNECTED,
+    MQTT_STATE_ERROR,
+    MQTT_STATE_STOPPED,
+} mqtt_client_state_t;
+
+mqtt_client_state_t client_status = MQTT_STATE_INIT;
+
+static esp_mqtt_client_handle_t client_handle = NULL;
+
+static const uint8_t *s_own_cert_pem_start = NULL;
+static const uint8_t *s_own_cert_pem_end = NULL;
+static const uint8_t *s_own_key_pem_start = NULL;
+static const uint8_t *s_own_key_pem_end = NULL;
+static const uint8_t *s_ca_cert_pem_start = NULL;
+static const uint8_t *s_ca_cert_pem_end = NULL;
+
+static void log_error_if_nonzero(const char *message, int error_code)
+{
+    if (error_code != 0) {
+        ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
+    }
+}
+
+/*
+ * @brief Event handler registered to receive MQTT events
+ *
+ *  This function is called by the MQTT client event loop.
+ *
+ * @param handler_args user data registered to the event.
+ * @param base Event base for the handler(always MQTT Base in this example).
+ * @param event_id The id for the received event.
+ * @param event_data The data for the event, esp_mqtt_event_handle_t.
+ */
+static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32, base, event_id);
+    esp_mqtt_event_handle_t event = event_data;
+    switch ((esp_mqtt_event_id_t)event_id) {
+    case MQTT_EVENT_BEFORE_CONNECT:
+        ESP_LOGI(TAG, "MQTT_EVENT_BEFORE_CONNECT");
+        break;
+    case MQTT_EVENT_CONNECTED:
+        client_status = MQTT_STATE_CONNECTED;
+        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        client_status = MQTT_STATE_DISCONNECTED;
+        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+        break;
+    case MQTT_EVENT_SUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
+        break;
+    case MQTT_EVENT_UNSUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
+        break;
+    case MQTT_EVENT_PUBLISHED:
+        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
+        break;
+    case MQTT_EVENT_DATA:
+        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
+        ESP_LOGI(TAG, "TOPIC=%.*s\r\n", event->topic_len, event->topic);
+        ESP_LOGI(TAG, "DATA=%.*s\r\n", event->data_len, event->data);
+        break;
+    case MQTT_EVENT_ERROR:
+        client_status = MQTT_STATE_ERROR;
+        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
+            log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
+            log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
+            log_error_if_nonzero("captured as transport's socket errno",  event->error_handle->esp_transport_sock_errno);
+            ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
+        }
+        break;
+    default:
+        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
+        break;
+    }
+}
+
+
+static const char *mqtt_state_to_string(mqtt_client_state_t state)
+{
+    switch (state) {
+    case MQTT_STATE_INIT:
+        return "Initializing";
+    case MQTT_STATE_DISCONNECTED:
+        return "Disconnected";
+    case MQTT_STATE_CONNECTED:
+        return "Connected";
+    case MQTT_STATE_ERROR:
+        return "Error";
+    case MQTT_STATE_STOPPED:
+        return "Disconnected and Stopped";
+    default:
+        return "Unknown State";
+    }
+}
+
+
+static int do_mqtt_cmd(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **)&mqtt_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, mqtt_args.end, argv[0]);
+        return 1;
+    }
+
+    if (mqtt_args.status->count > 0) {
+        ESP_LOGI(TAG, "MQTT Client Status: %s\n", mqtt_state_to_string(client_status));
+        return 0;
+    }
+
+    if (mqtt_args.connect->count > 0) {
+
+        if (client_handle != NULL) {
+            ESP_LOGW(TAG, "mqtt client already connected");
+            ESP_LOGI(TAG, "Try: %s", DISCONNECT_HELP_MSG);
+            return 0;
+        }
+
+        char *uri = CONFIG_MQTT_BROKER_URL;
+        if (mqtt_args.uri->count > 0) {
+            uri = (char *)mqtt_args.uri->sval[0];
+        }
+
+        esp_mqtt_client_config_t mqtt_cfg = {
+            .broker.address.uri = uri,
+        };
+
+        if ((mqtt_args.username->count > 0) && (mqtt_args.password->count > 0)) {
+            mqtt_cfg.credentials.username = mqtt_args.username->sval[0];
+            mqtt_cfg.credentials.authentication.password = mqtt_args.password->sval[0];
+        }
+
+        ESP_LOGI(TAG, "broker: %s", mqtt_cfg.broker.address.uri);
+
+#if defined(CONFIG_MBEDTLS_CERTIFICATE_BUNDLE)
+        /* Ensure --use_internal_bundle and --cafile are mutually exclusive */
+        if ((mqtt_args.use_internal_bundle->count > 0) && (mqtt_args.cafile->count > 0)) {
+            ESP_LOGE(TAG, "Error: Options can't be used together. Use either --use-internal-bundle or --cafile.  \n");
+            return 1;
+        }
+
+        if (mqtt_args.use_internal_bundle->count > 0) {
+            mqtt_cfg.broker.verification.crt_bundle_attach = esp_crt_bundle_attach;
+        }
+#endif
+
+        if (mqtt_args.cafile->count > 0) {
+            if (s_ca_cert_pem_start && s_ca_cert_pem_end) {
+                mqtt_cfg.broker.verification.certificate = (const char *)s_ca_cert_pem_start;
+            } else {
+                ESP_LOGW(TAG, "cafile not provided");
+            }
+        }
+
+        if (mqtt_args.cert->count > 0) {
+            if (s_own_cert_pem_start && s_own_cert_pem_end) {
+                mqtt_cfg.credentials.authentication.certificate = (const char *)s_own_cert_pem_start;
+            } else {
+                ESP_LOGW(TAG, "cert not provided");
+            }
+
+            if (mqtt_args.key->count > 0) {
+                if (s_own_key_pem_start && s_own_key_pem_end) {
+                    mqtt_cfg.credentials.authentication.key = (const char *)s_own_key_pem_start;
+                } else {
+                    ESP_LOGW(TAG, "key not provided");
+                }
+            } else {
+                mqtt_cfg.credentials.authentication.key = NULL;
+            }
+        }
+
+        client_handle = esp_mqtt_client_init(&mqtt_cfg);
+        if (client_handle == NULL) {
+            ESP_LOGE(TAG, "ERROR: Client init");
+            ESP_LOGI(TAG, "Try: %s", DISCONNECT_HELP_MSG);
+            ESP_LOGE(TAG, CONNECT_HELP_MSG);
+            return 1;
+        }
+
+        /* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */
+        esp_mqtt_client_register_event(client_handle, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
+        esp_mqtt_client_start(client_handle);
+
+    } else if (mqtt_args.disconnect->count > 0) {
+        ESP_LOGD(TAG, "Disconnect command received:");
+
+        if (client_handle == NULL) {
+            ESP_LOGE(TAG, "mqtt client not connected");
+            return 0;
+        }
+
+        if (esp_mqtt_client_stop(client_handle) != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to stop mqtt client task");
+            return 1;
+        }
+
+        client_handle = NULL;
+        client_status = MQTT_STATE_STOPPED;
+        ESP_LOGI(TAG, "mqtt client disconnected and stopped");
+    }
+
+    return 0;
+}
+
+
+esp_err_t set_mqtt_client_cert(const uint8_t *client_cert_pem_start_i, const uint8_t *client_cert_pem_end_i)
+{
+    if (!client_cert_pem_start_i || !client_cert_pem_end_i ||
+            (client_cert_pem_start_i > client_cert_pem_end_i)) {
+        ESP_LOGE(TAG, "Invalid mqtt Client certs(%d)\n", __LINE__);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    s_own_cert_pem_start = client_cert_pem_start_i;
+    s_own_cert_pem_end = client_cert_pem_end_i;
+
+    return ESP_OK;
+}
+
+
+esp_err_t set_mqtt_client_key(const uint8_t *client_key_pem_start_i, const uint8_t *client_key_pem_end_i)
+{
+    if (client_key_pem_start_i && client_key_pem_end_i &&
+            (client_key_pem_start_i >= client_key_pem_end_i)) {
+        ESP_LOGE(TAG, "Invalid mqtt Client key(%d)\n", __LINE__);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    s_own_key_pem_start = client_key_pem_start_i;
+    s_own_key_pem_end = client_key_pem_end_i;
+
+    return ESP_OK;
+}
+
+
+esp_err_t set_mqtt_broker_certs(const uint8_t *ca_cert_pem_start_i, const uint8_t *ca_cert_pem_end_i)
+{
+    if (!ca_cert_pem_start_i || !ca_cert_pem_end_i ||
+            (ca_cert_pem_start_i > ca_cert_pem_end_i)) {
+        ESP_LOGE(TAG, "Invalid mqtt ca cert(%d)\n", __LINE__);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    s_ca_cert_pem_start = ca_cert_pem_start_i;
+    s_ca_cert_pem_end = ca_cert_pem_end_i;
+
+    return ESP_OK;
+}
+
+
+static int do_mqtt_sub_cmd(int argc, char **argv)
+{
+    int msg_id;
+    int nerrors = arg_parse(argc, argv, (void **)&mqtt_sub_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, mqtt_sub_args.end, argv[0]);
+        return 1;
+    }
+
+    if (client_handle == NULL) {
+        ESP_LOGE(TAG, "mqtt client not connected");
+        return 0;
+    }
+
+    if (mqtt_sub_args.unsubscribe->count > 0) {
+        if (mqtt_sub_args.topic->count <= 0) {
+            ESP_LOGE(TAG, UNSUBSCRIBE_HELP_MSG);
+            return 0;
+        }
+        char *topic = (char *)mqtt_sub_args.topic->sval[0];
+
+        msg_id = esp_mqtt_client_unsubscribe(client_handle, mqtt_sub_args.topic->sval[0]);
+        ESP_LOGI(TAG, "Unsubscribe successful, msg_id=%d, topic=%s", msg_id, topic);
+
+    } else {
+        if (mqtt_sub_args.topic->count <= 0) {
+            ESP_LOGE(TAG, SUBSCRIBE_HELP_MSG);
+            return 0;
+        }
+        char *topic = (char *)mqtt_sub_args.topic->sval[0];
+
+        msg_id = esp_mqtt_client_subscribe(client_handle, topic, 0);
+        ESP_LOGI(TAG, "Subscribe successful, msg_id=%d, topic=%s", msg_id, topic);
+
+    }
+
+    return 0;
+}
+
+
+static int do_mqtt_pub_cmd(int argc, char **argv)
+{
+    int msg_id;
+    int nerrors = arg_parse(argc, argv, (void **)&mqtt_pub_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, mqtt_pub_args.end, argv[0]);
+        return 1;
+    }
+
+    if (client_handle == NULL) {
+        ESP_LOGE(TAG, "mqtt client not connected");
+        return 0;
+    }
+
+    if ((mqtt_pub_args.topic->count <= 0) || (mqtt_pub_args.message->count <= 0)) {
+        ESP_LOGE(TAG, PUBLISH_HELP_MSG);
+    }
+
+    msg_id = esp_mqtt_client_publish(client_handle,
+                                     mqtt_pub_args.topic->sval[0],
+                                     mqtt_pub_args.message->sval[0],
+                                     0, 1, 0);
+    if (msg_id == -1) {
+        ESP_LOGE(TAG, "mqtt client not connected");
+        return 0;
+    }
+    ESP_LOGI(TAG, "Publish successful, msg_id=%d, topic=%s, data=%s",
+             msg_id, mqtt_pub_args.topic->sval[0], mqtt_pub_args.message->sval[0]);
+
+    return 0;
+}
+
+/**
+ * @brief Registers the mqtt commands.
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_mqtt_register(void)
+{
+    esp_err_t ret = ESP_OK;
+
+    /* Register mqtt */
+    mqtt_args.connect = arg_lit0("C", "connect", "Connect to a broker (flag, no argument)");
+    mqtt_args.uri = arg_str0("h", "host", "<host>", "Specify the host uri to connect to");
+    mqtt_args.status = arg_lit0("s", "status", "Displays the status of the mqtt client (flag, no argument)");
+    mqtt_args.username = arg_str0("u", "username", "<username>", "Provide a username to be used for authenticating with the broker");
+    mqtt_args.password = arg_str0("P", "password", "<password>", "Provide a password to be used for authenticating with the broker");
+    mqtt_args.cert = arg_lit0(NULL, "cert", "Define the PEM encoded certificate for this client, if required by the broker (flag, no argument)");
+    mqtt_args.key = arg_lit0(NULL, "key", "Define the PEM encoded private key for this client, if required by the broker (flag, no argument)");
+    mqtt_args.cafile = arg_lit0(NULL, "cafile", "Define the PEM encoded CA certificates that are trusted (flag, no argument)");
+#if defined(CONFIG_MBEDTLS_CERTIFICATE_BUNDLE)
+    mqtt_args.use_internal_bundle = arg_lit0(NULL, "use-internal-bundle", "Use the internal certificate bundle for TLS (flag, no argument)");
+#endif
+    mqtt_args.disconnect = arg_lit0("D", "disconnect", "Disconnect from the broker (flag, no argument)");
+    mqtt_args.end = arg_end(1);
+
+    const esp_console_cmd_t mqtt_cmd = {
+        .command = "mqtt",
+        .help = "mqtt command",
+        .hint = NULL,
+        .func = &do_mqtt_cmd,
+        .argtable = &mqtt_args
+    };
+
+    ret = esp_console_cmd_register(&mqtt_cmd);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Unable to register mqtt");
+        return ret;
+    }
+
+    /* Register mqtt_pub */
+    mqtt_pub_args.topic = arg_str0("t", "topic", "<topic>", "Topic to Subscribe/Publish");
+    mqtt_pub_args.message = arg_str0("m", "message", "<message>", "Message to Publish");
+    mqtt_pub_args.end = arg_end(1);
+
+    const esp_console_cmd_t mqtt_pub_cmd = {
+        .command = "mqtt_pub",
+        .help = "mqtt publish command",
+        .hint = NULL,
+        .func = &do_mqtt_pub_cmd,
+        .argtable = &mqtt_pub_args
+    };
+
+    ret = esp_console_cmd_register(&mqtt_pub_cmd);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Unable to register mqtt_pub");
+        return ret;
+    }
+
+    /* Register mqtt_sub */
+    mqtt_sub_args.topic = arg_str0("t", "topic", "<topic>", "Topic to Subscribe/Publish");
+    mqtt_sub_args.unsubscribe = arg_lit0("U", "unsubscribe", "Unsubscribe from a topic");
+    mqtt_sub_args.end = arg_end(1);
+
+    const esp_console_cmd_t mqtt_sub_cmd = {
+        .command = "mqtt_sub",
+        .help = "mqtt subscribe command",
+        .hint = NULL,
+        .func = &do_mqtt_sub_cmd,
+        .argtable = &mqtt_sub_args
+    };
+
+    ret = esp_console_cmd_register(&mqtt_sub_cmd);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Unable to register mqtt_sub");
+    }
+
+    return ret;
+}

components/console_cmd_mqtt/console_mqtt.h

@@ -0,0 +1,73 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "console_simple_init.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Registers the mqtt command.
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_mqtt_register(void);
+
+
+/**
+ * @brief Set MQTT client certificate
+ *
+ *  This function sets the MQTT client certificate for secure communication.
+ *  The function takes the PEM(Privacy Enhanced Mail) encoded certificate arguments.
+ *
+ * @param client_cert_pem_start_i Pointer to the beginning of the client certificate PEM data.
+ * @param client_cert_pem_end_i Pointer to the end of the client certificate PEM data.
+ *
+ * @return
+ *      ESP_OK on success
+ *      ESP_ERR_INVALID_ARG on invalid arguments
+ */
+esp_err_t set_mqtt_client_cert(const uint8_t *client_cert_pem_start_i, const uint8_t *client_cert_pem_end_i);
+
+
+/**
+ * @brief Set MQTT client key
+ *
+ *  This function sets the MQTT client key for secure communication.
+ *  The function takes the PEM(Privacy Enhanced Mail) encoded key arguments.
+ *
+ * @param client_key_pem_start_i Pointer to the beginning of the client key PEM data.
+ * @param client_key_pem_end_i Pointer to the end of the client key PEM data.
+ *
+ * @return
+ *      ESP_OK on success
+ *      ESP_ERR_INVALID_ARG on invalid arguments
+ */
+esp_err_t set_mqtt_client_key(const uint8_t *client_key_pem_start_i, const uint8_t *client_key_pem_end_i);
+
+
+/**
+ * @brief Set MQTT broker certificate
+ *
+ *  This function sets the MQTT broker certificate for secure communication.
+ *  The function takes the PEM(Privacy Enhanced Mail) encoded broker certificate arguments.
+ *
+ * @param broker_cert_pem_start_i Pointer to the beginning of the broker certificate PEM data.
+ * @param broker_cert_pem_end_i Pointer to the end of the broker certificate PEM data.
+ *
+ * @return
+ *      ESP_OK on success
+ *      ESP_ERR_INVALID_ARG on invalid arguments
+ */
+esp_err_t set_mqtt_broker_certs(const uint8_t *broker_cert_pem_start_i, const uint8_t *broker_cert_pem_end_i);
+
+#ifdef __cplusplus
+}
+#endif

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/CMakeLists.txt

@@ -0,0 +1,11 @@
+# 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(mqtt_ssl_auth_console)
+
+# Certs for mqtts://test.mosquitto.org:8884
+target_add_binary_data(${CMAKE_PROJECT_NAME}.elf "certs/client.crt" TEXT)
+target_add_binary_data(${CMAKE_PROJECT_NAME}.elf "certs/client.key" TEXT)
+target_add_binary_data(${CMAKE_PROJECT_NAME}.elf "certs/mosquitto.org.pem" TEXT)

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/README.md

@@ -0,0 +1,174 @@
+| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C6 | ESP32-H2 | ESP32-P4 | ESP32-S2 | ESP32-S3 |
+| ----------------- | ----- | -------- | -------- | -------- | -------- | -------- | -------- | -------- |
+
+# ESP-MQTT SSL Authentication Console
+
+This example demonstrates the use of the MQTT command-line component to connect to both secured and unsecured MQTT brokers. It provides multiple modes of connection, including:
+
+* Unsecured transport: Connect to a broker without encryption.
+* SSL/TLS transport: Securely connect using SSL/TLS with options for:
+  * Validating the broker using a provided CA certificate.
+  * Validating the broker using the internal certificate bundle.
+  * Performing SSL mutual authentication using client and broker certificates.
+
+Additionally, the example allows subscribing to topics, unsubscribing from topics, and publishing messages to a specified topic through commands. Connections to the broker at test.mosquitto.org are used to demonstrate these features.
+(Please note that the public broker is maintained by the community so may not be always available, for details please visit http://test.mosquitto.org)
+
+It uses ESP-MQTT library which implements mqtt client to connect to mqtt broker.
+
+## How to use example
+
+### Hardware Required
+
+This example can be executed on any ESP32 board, the only required interface is WiFi and connection to internet.
+
+### Configure the project
+
+* Open the project configuration menu (`idf.py menuconfig`)
+* Configure Wi-Fi or Ethernet under "Example Connection Configuration" menu. See "Establishing Wi-Fi or Ethernet Connection" section in [examples/protocols/README.md](../../README.md) for more details.
+
+* Generate your client keys and certificate (specific to testing with Mosquitto broker)
+
+Note: The following steps are for testing with the Mosquitto broker. If you're using a different broker, you may need to adapt the steps to meet your broker's certificate and key requirements.
+
+#### Steps for SSL Mutual authentication:
+Navigate to the certs directory
+
+```
+cd certs
+```
+
+Generate a client key and a CSR. When you are generating the CSR, do not use the default values. At a minimum, the CSR must include the Country, Organisation and Common Name fields.
+
+```
+openssl genrsa -out client.key
+openssl req -out client.csr -key client.key -new
+```
+
+Paste the generated CSR in the [Mosquitto test certificate signer](https://test.mosquitto.org/ssl/index.php), click Submit and copy the downloaded `client.crt` in the `main` directory.
+
+Please note, that the supplied files `client.crt` and `client.key` in the `main` directory are only placeholders for your client certificate and key (i.e. the example "as is" would compile but would not connect to the broker)
+
+The broker certificate `mosquitto.org.pem` can be downloaded in pem format from [mosquitto.org.crt](https://test.mosquitto.org/ssl/mosquitto.org.crt). Convert it to `mosquitto.org.pem` simply by renaming it.
+
+Note: If your certificate and key file names differ, update the root `CMakeLists.txt` file and main/`mqtt_ssl_auth_console.c` accordingly.
+
+### Build and Flash
+
+Build the project and flash it to the board, then run monitor tool to view serial output:
+
+```
+idf.py -p PORT flash monitor
+```
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
+
+Warning: This example might need a bigger app partition size if you're compiling it for debug. To ensere this issue doesn't happen "optimize for size is enabled in menuconfig.
+
+### Command Usage:
+```
+esp> help
+help  [<string>]
+  Print the summary of all registered commands if no arguments are given,
+  otherwise print summary of given command.
+      <string>  Name of command
+
+mqtt  [-CsD] [-h <host>] [-u <username>] [-P <password>] [--cert] [--key] [--cafile]
+  mqtt command
+  -C, --connect  Connect to a broker (flag, no argument)
+  -h, --host=<host>  Specify the host uri to connect to
+  -s, --status  Displays the status of the mqtt client (flag, no argument)
+  -u, --username=<username>  Provide a username to be used for authenticating with the broker
+  -P, --password=<password>  Provide a password to be used for authenticating with the broker
+      --cert  Define the PEM encoded certificate for this client, if required by the broker (flag, no argument)
+      --key  Define the PEM encoded private key for this client, if required by the broker (flag, no argument)
+      --cafile  Define the PEM encoded CA certificates that are trusted (flag, no argument)
+      --use-internal-bundle  Use the internal certificate bundle for TLS (flag, no argument)
+  -D, --disconnect  Disconnect from the broker (flag, no argument)
+
+mqtt_pub  [-t <topic>] [-m <message>]
+  mqtt publish command
+  -t, --topic=<topic>  Topic to Subscribe/Publish
+  -m, --message=<message>  Message to Publish
+
+mqtt_sub  [-U] [-t <topic>]
+  mqtt subscribe command
+  -t, --topic=<topic>  Topic to Subscribe/Publish
+  -U, --unsubscribe  Unsubscribe from a topic
+```
+
+### Connection:
+
+#### Connect without Validating the Broker:
+This option connects to the broker without validating its certificate. It is not secure.
+```
+mqtt -h mqtts://test.mosquitto.org -C
+```
+or
+```
+mqtt -h mqtts://mqtt.eclipseprojects.io -C
+```
+
+#### Validate the Broker using the Internal Certificate Bundle:
+This option uses the ESP-IDF's built-in certificate bundle to verify the broker's identity.
+```
+mqtt -h mqtts://mqtt.eclipseprojects.io -C --use-internal-bundle
+```
+or
+```
+mqtt -h mqtts://test.mosquitto.org -C --use-internal-bundle
+```
+
+#### Validate the Broker using a Provided CA Certificate:
+This option requires you to provide the broker's CA certificate for validation.
+```
+mqtt -h mqtts://test.mosquitto.org -C --cafile
+```
+
+
+#### SSL Mutual Authentication(encrypted, client certificate required):
+This option performs client authentication in addition to broker validation. It requires the client certificate, private key, and broker CA certificate.
+```
+mqtt -h mqtts://test.mosquitto.org:8884 -C --cert --key --cafile
+```
+or
+```
+mqtt -h mqtts://test.mosquitto.org:8884 -C --cert --key --use-internal-bundle
+```
+
+Note: In this example, the broker's certificate is included in the certificate bundle (refer to sdkconfig.default).
+
+### Disconnect:
+```
+esp> mqtt -D
+I (1189949) console_mqtt: mqtt client disconnected
+```
+
+### Subscribe/Unsubscribe:
+```
+esp> mqtt_sub -t test0
+I (897289) console_mqtt: Subscribe successful, msg_id=57425, topic=test0
+esp> I (897799) console_mqtt: MQTT_EVENT_SUBSCRIBED, msg_id=57425
+esp>
+esp> mqtt_sub -U -t test0
+I (902009) console_mqtt: Unsubscribe successful, msg_id=27663, topic=test0
+esp> I (902509) console_mqtt: MQTT_EVENT_UNSUBSCRIBED, msg_id=27663
+```
+
+### Publish:
+```
+esp> mqtt_pub -t test0 -m "Hello, Testing 123"
+I (999469) console_mqtt: Publish successful, msg_id=55776, topic=test0, data=Hello, Testing 123
+I (1000009) console_mqtt: MQTT_EVENT_PUBLISHED, msg_id=55776
+esp>
+```
+
+### Receiving data event:
+```
+esp> I (999999) console_mqtt: MQTT_EVENT_DATA
+I (999999) console_mqtt: TOPIC=test0
+
+I (999999) console_mqtt: DATA=Hello, Testing 123
+```

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/certs/mosquitto.org.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEAzCCAuugAwIBAgIUBY1hlCGvdj4NhBXkZ/uLUZNILAwwDQYJKoZIhvcNAQEL
+BQAwgZAxCzAJBgNVBAYTAkdCMRcwFQYDVQQIDA5Vbml0ZWQgS2luZ2RvbTEOMAwG
+A1UEBwwFRGVyYnkxEjAQBgNVBAoMCU1vc3F1aXR0bzELMAkGA1UECwwCQ0ExFjAU
+BgNVBAMMDW1vc3F1aXR0by5vcmcxHzAdBgkqhkiG9w0BCQEWEHJvZ2VyQGF0Y2hv
+by5vcmcwHhcNMjAwNjA5MTEwNjM5WhcNMzAwNjA3MTEwNjM5WjCBkDELMAkGA1UE
+BhMCR0IxFzAVBgNVBAgMDlVuaXRlZCBLaW5nZG9tMQ4wDAYDVQQHDAVEZXJieTES
+MBAGA1UECgwJTW9zcXVpdHRvMQswCQYDVQQLDAJDQTEWMBQGA1UEAwwNbW9zcXVp
+dHRvLm9yZzEfMB0GCSqGSIb3DQEJARYQcm9nZXJAYXRjaG9vLm9yZzCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBAME0HKmIzfTOwkKLT3THHe+ObdizamPg
+UZmD64Tf3zJdNeYGYn4CEXbyP6fy3tWc8S2boW6dzrH8SdFf9uo320GJA9B7U1FW
+Te3xda/Lm3JFfaHjkWw7jBwcauQZjpGINHapHRlpiCZsquAthOgxW9SgDgYlGzEA
+s06pkEFiMw+qDfLo/sxFKB6vQlFekMeCymjLCbNwPJyqyhFmPWwio/PDMruBTzPH
+3cioBnrJWKXc3OjXdLGFJOfj7pP0j/dr2LH72eSvv3PQQFl90CZPFhrCUcRHSSxo
+E6yjGOdnz7f6PveLIB574kQORwt8ePn0yidrTC1ictikED3nHYhMUOUCAwEAAaNT
+MFEwHQYDVR0OBBYEFPVV6xBUFPiGKDyo5V3+Hbh4N9YSMB8GA1UdIwQYMBaAFPVV
+6xBUFPiGKDyo5V3+Hbh4N9YSMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAGa9kS21N70ThM6/Hj9D7mbVxKLBjVWe2TPsGfbl3rEDfZ+OKRZ2j6AC
+6r7jb4TZO3dzF2p6dgbrlU71Y/4K0TdzIjRj3cQ3KSm41JvUQ0hZ/c04iGDg/xWf
++pp58nfPAYwuerruPNWmlStWAXf0UTqRtg4hQDWBuUFDJTuWuuBvEXudz74eh/wK
+sMwfu1HFvjy5Z0iMDU8PUDepjVolOCue9ashlS4EB5IECdSR2TItnAIiIwimx839
+LdUdRudafMu5T5Xma182OC0/u/xRlEm+tvKGGmfFcN0piqVl8OrSPBgIlb+1IKJE
+m/XriWr/Cq4h/JfB7NTsezVslgkBaoU=
+-----END CERTIFICATE-----

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/main/CMakeLists.txt

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "mqtt_ssl_auth_console.c"
+                    INCLUDE_DIRS ".")

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/main/idf_component.yml

@@ -0,0 +1,8 @@
+dependencies:
+  idf:
+    version: ">=5.0"
+  protocol_examples_common:
+    path: ${IDF_PATH}/examples/common_components/protocol_examples_common
+  console_cmd_mqtt:
+    version: "*"
+    override_path: '../../../'

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/main/mqtt_ssl_auth_console.c

@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#include <stdio.h>
+#include "nvs_flash.h"
+#include "esp_netif.h"
+#include "esp_event.h"
+#include <netdb.h>
+#include "console_mqtt.h"
+#include "protocol_examples_common.h"
+
+// Certs for mqtts://test.mosquitto.org:8884
+extern const uint8_t g_client_cert_pem_start[] asm("_binary_client_crt_start");
+extern const uint8_t g_client_cert_pem_end[] asm("_binary_client_crt_end");
+extern const uint8_t g_client_key_pem_start[] asm("_binary_client_key_start");
+extern const uint8_t g_client_key_pem_end[] asm("_binary_client_key_end");
+extern const uint8_t g_broker_cert_pem_start[] asm("_binary_mosquitto_org_pem_start");
+extern const uint8_t g_broker_cert_pem_end[] asm("_binary_mosquitto_org_pem_end");
+
+
+void app_main(void)
+{
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+    esp_err_t ret = nvs_flash_init();   //Initialize NVS
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        ret = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK(ret);
+
+    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
+     * Read "Establishing Wi-Fi or Ethernet Connection" section in
+     * ${IDF_PATH}/examples/protocols/README.md for more information about this function.
+     */
+    ESP_ERROR_CHECK(example_connect());
+
+    // Initialize console REPL
+    ESP_ERROR_CHECK(console_cmd_init());
+    ESP_ERROR_CHECK(console_cmd_all_register());
+
+    set_mqtt_client_cert(g_client_cert_pem_start, g_client_cert_pem_end);
+    set_mqtt_client_key(g_client_key_pem_start, g_client_key_pem_end);
+    set_mqtt_broker_certs(g_broker_cert_pem_start, g_broker_cert_pem_end);
+
+    // start console REPL
+    ESP_ERROR_CHECK(console_cmd_start());
+
+}

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/pytest_mqtt_ssl_auth_console.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+
+# -*- coding: utf-8 -*-
+
+import pytest
+
+
+@pytest.mark.esp32
+def test_examples_ifconfig_command(dut):
+    dut.expect('esp>', timeout=30)
+    dut.write('help mqtt')
+    dut.expect(r'mqtt  \[-CsD\] \[-h <host>\] \[-u <username>\] \[-P <password>\] \[--cert\] \[--key\] \[--cafile\]', timeout=30)
+
+    dut.write('help mqtt_pub')
+    dut.expect(r'mqtt_pub  \[-t <topic>\] \[-m <message>\]', timeout=30)
+
+    dut.write('help mqtt_sub')
+    dut.expect(r'mqtt_sub  \[-U\] \[-t <topic>\]', timeout=30)

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/sdkconfig.defaults

@@ -0,0 +1,7 @@
+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) 5.5.0 Project Minimal Configuration
+#
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
+CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE=y
+CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE_PATH="certs/mosquitto.org.pem"

components/console_cmd_mqtt/idf_component.yml

@@ -0,0 +1,11 @@
+version: 1.0.0
+url: https://github.com/espressif/esp-protocols/tree/master/components/console_cmd_mqtt
+description: The component provides a console where the 'mqtt' command can be executed.
+license: Apache-2.0
+dependencies:
+  idf:
+    version: '>=5.0'
+  espressif/console_simple_init:
+    version: '>=1.1.0'
+    override_path: '../console_simple_init'
+    public: true

components/console_cmd_ping/.cz.yaml

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

components/console_cmd_ping/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.1.0](https://github.com/espressif/esp-protocols/commits/console_cmd_ping-v1.1.0)
+
+### Features
+
+- Added command getaddrinfo, set/get dnsserver to console_cmd_ping ([b80c19d7](https://github.com/espressif/esp-protocols/commit/b80c19d7))
+
 ## [1.0.0](https://github.com/espressif/esp-protocols/commits/console_cmd_ping-v1.0.0)
 
 ### Features

components/console_cmd_ping/CMakeLists.txt

@@ -1,4 +1,10 @@
-idf_component_register(SRCS "console_ping.c"
+idf_component_register(SRCS "console_ping.c" "console_getaddrinfo.c" "console_getsetdnsserver.c"
                     INCLUDE_DIRS "."
-                    PRIV_REQUIRES esp_netif console
-                    WHOLE_ARCHIVE)
+                    PRIV_REQUIRES esp_netif console)
+
+if(CONFIG_PING_CMD_AUTO_REGISTRATION)
+    target_link_libraries(${COMPONENT_LIB} "-u console_cmd_ping_register")
+    target_link_libraries(${COMPONENT_LIB} "-u console_cmd_getaddrinfo_register")
+    target_link_libraries(${COMPONENT_LIB} "-u console_cmd_setdnsserver_register")
+    target_link_libraries(${COMPONENT_LIB} "-u console_cmd_getdnsserver_register")
+endif()

components/console_cmd_ping/Kconfig.projbuild

@@ -0,0 +1,9 @@
+menu "Ping command Configuration"
+
+    config PING_CMD_AUTO_REGISTRATION
+        bool "Enable Console command ping/dns Auto-registration"
+        default y
+        help
+            Enabling this allows for the autoregistration of the ping and dns commands.
+
+endmenu

components/console_cmd_ping/README.md

@@ -1,5 +1,5 @@
-# Console command ping
-The component provides a console where the 'ping' command can be executed.
+# Console command ping and DNS server configuration
+The component provides a console where the 'ping' command, 'getaddrinfo', and DNS server configuration commands can be executed.
 
 ## API
 
@@ -27,8 +27,11 @@ The component provides a console where the 'ping' command can be executed.
     // Register all plugin command added to your project
     ESP_ERROR_CHECK(console_cmd_all_register());
 
-    // To register only ifconfig command skip calling console_cmd_all_register()
+    // To register only ping/dns command skip calling console_cmd_all_register()
     ESP_ERROR_CHECK(console_cmd_ping_register());
+    ESP_ERROR_CHECK(console_cmd_getaddrinfo_register());
+    ESP_ERROR_CHECK(console_cmd_setdnsserver_register());
+    ESP_ERROR_CHECK(console_cmd_getdnsserver_register());
 
     ESP_ERROR_CHECK(console_cmd_start());    // Start console
     ```
@@ -36,6 +39,8 @@ The component provides a console where the 'ping' command can be executed.
 ### Adding a plugin command or component:
 To add a plugin command or any component from IDF component manager into your project, simply include an entry within the `idf_component.yml` file.
 
+Note: **Auto-registration** of a specific plugin command can be disabled from menuconfig.
+
 For more details refer [IDF Component Manager](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/tools/idf-component-manager.html)
 
 
@@ -52,4 +57,72 @@ ping  [-W <t>] [-i <t>] [-s <n>] [-c <n>] [-Q <n>] [-T <n>] <host>
   -Q, --tos=<n>  Set Type of Service related bits in IP datagrams
   -T, --ttl=<n>  Set Time to Live related bits in IP datagrams
         <host>  Host address
+
+getaddrinfo  [-f <AF>] [-F <FLAGS>]... [-p <port>] <hostname>
+  Usage: getaddrinfo [options] <hostname> [service]
+  -f, --family=<AF>  Address family (AF_INET, AF_INET6, AF_UNSPEC).
+  -F, --flags=<FLAGS>  Special flags (AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST, AI_V4MAPPED, AI_ALL).
+  -p, --port=<port>  String containing a numeric port number.
+    <hostname>  Host address
+
+setdnsserver  <main> [backup] [fallback]
+  Usage: setdnsserver <main> [backup] [fallback]
+        <main>  The main DNS server IP address.
+        backup  The secondary DNS server IP address (optional).
+      fallback  The fallback DNS server IP address (optional).
+
+getdnsserver
+  Usage: getdnsserver
+```
+These commands allow you to configure and retrieve DNS server settings on your ESP32 device, in addition to the existing ping functionality.
+
+## Usage
+### Using the setdnsserver command:
+1. To set the main DNS server:
+```
+setdnsserver 8.8.8.8
+```
+
+2. To set the main and backup DNS servers:
+
+```
+setdnsserver 8.8.8.8 fe80::b0be:83ff:fe77:dd64
+```
+
+3. To set the main, backup, and fallback DNS servers:
+
+```
+setdnsserver 8.8.8.8 fe80::b0be:83ff:fe77:dd64 www.xyz.com
+```
+
+### Using the getdnsserver command:
+To get the current DNS server settings:
+```
+getdnsserver
+```
+
+### Using the getaddrinfo command:
+1. To get address information for a hostname:
+
+```
+getaddrinfo www.example.com
+```
+
+2. To specify additional options:
+
+```
+getaddrinfo -f AF_INET -F AI_PASSIVE www.example.com
+```
+
+### Using the ping command:
+1. To ping a host:
+
+```
+ping www.example.com
+```
+
+2. To specify additional options, such as timeout, interval, packet size, etc.:
+
+```
+ping -W 5 -i 1 -s 64 -c 4 -Q 0x10 -T 64 www.example.com
 ```

components/console_cmd_ping/console_getaddrinfo.c

@@ -0,0 +1,180 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdio.h>
+#include <string.h>
+#include "sdkconfig.h"
+#include "lwip/inet.h"
+#include "lwip/netdb.h"
+#include "lwip/sockets.h"
+#include "esp_console.h"
+#include "esp_log.h"
+#include "argtable3/argtable3.h"
+#include <netdb.h>
+#include "console_ping.h"
+
+
+static const char *TAG = "console_getaddrinfo";
+
+#if CONFIG_PING_CMD_AUTO_REGISTRATION
+/**
+ * @brief  Static registration of the getaddrinfo command plugin.
+ *
+ * This section registers the plugin description structure and places it into
+ * the .console_cmd_desc section, as determined by the linker.lf file in the
+ * 'plugins' component.
+ */
+static const console_cmd_plugin_desc_t __attribute__((section(".console_cmd_desc"), used)) PLUGIN = {
+    .name = "console_cmd_getddrinfo",
+    .plugin_regd_fn = &console_cmd_getaddrinfo_register
+};
+#endif
+
+/**
+ * @brief Structure to hold arguments for the getaddrinfo command.
+ */
+static struct {
+    struct arg_str *family;
+    struct arg_str *flags;
+    struct arg_str *port_nr;
+    struct arg_str *hostname;
+    struct arg_end *end;
+} getddrinfo_args;
+
+/**
+ * @brief Executes the getaddrinfo command.
+ *
+ * This function parses arguments, sets hints for address resolution, and calls
+ * getaddrinfo to resolve the hostname. It then prints the resolved IP addresses
+ * and associated information.
+ *
+ * @param argc Argument count
+ * @param argv Argument vector
+ *
+ * @return int Returns 0 on success, 1 on error.
+ */
+static int do_getddrinfo_cmd(int argc, char **argv)
+{
+    char ip_str[INET6_ADDRSTRLEN];
+    struct addrinfo hint = {0};
+    struct addrinfo *res = NULL, *res_tmp = NULL;
+    const char *port_nr_str = NULL;
+    int ret = 0;
+
+    int nerrors = arg_parse(argc, argv, (void **)&getddrinfo_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, getddrinfo_args.end, argv[0]);
+        return 1;
+    }
+
+    /* Set the address family */
+    if (getddrinfo_args.family->count > 0) {
+        if (strcmp(getddrinfo_args.family->sval[0], "AF_INET") == 0) {
+            hint.ai_family = AF_INET;
+        } else if (strcmp(getddrinfo_args.family->sval[0], "AF_INET6") == 0) {
+            hint.ai_family = AF_INET6;
+        } else if (strcmp(getddrinfo_args.family->sval[0], "AF_UNSPEC") == 0) {
+            hint.ai_family = AF_UNSPEC;
+        } else {
+            ESP_LOGE(TAG, "Unknown family");
+            return 1;
+        }
+    }
+
+    /* Set the flags */
+    if (getddrinfo_args.flags->count > 0) {
+        for (int i = 0; i < getddrinfo_args.flags->count; i++) {
+            if (strcmp(getddrinfo_args.flags->sval[i], "AI_PASSIVE") == 0) {
+                hint.ai_flags |= AI_PASSIVE;
+            } else if (strcmp(getddrinfo_args.flags->sval[i], "AI_CANONNAME") == 0) {
+                hint.ai_flags |= AI_CANONNAME;
+            } else if (strcmp(getddrinfo_args.flags->sval[i], "AI_NUMERICHOST") == 0) {
+                hint.ai_flags |= AI_NUMERICHOST;
+            } else if (strcmp(getddrinfo_args.flags->sval[i], "AI_V4MAPPED") == 0) {
+                hint.ai_flags |= AI_V4MAPPED;
+            } else if (strcmp(getddrinfo_args.flags->sval[i], "AI_ALL") == 0) {
+                hint.ai_flags |= AI_ALL;
+            } else {
+                ESP_LOGE(TAG, "Unknown flag: %s", getddrinfo_args.flags->sval[i]);
+                return 1;
+            }
+        }
+    }
+
+    if (getddrinfo_args.port_nr->count > 0) {
+        port_nr_str = getddrinfo_args.port_nr->sval[0];
+    }
+
+    /* Convert hostname to IP address */
+    if (!strcmp(getddrinfo_args.hostname->sval[0], "NULL")) {
+        ret = getaddrinfo(NULL, port_nr_str, &hint, &res);
+    } else {
+        ret = getaddrinfo(getddrinfo_args.hostname->sval[0], port_nr_str, &hint, &res);
+    }
+
+    if (ret != 0) {
+        printf("getddrinfo: Failure host:%s(ERROR: %d)\n", getddrinfo_args.hostname->sval[0], ret);
+        ESP_LOGE(TAG, "Failure host");
+        return 1;
+    }
+
+    /* Iterate through the results from getaddrinfo */
+    for (res_tmp = res; res_tmp != NULL; res_tmp = res_tmp->ai_next) {
+
+        if (res_tmp->ai_family == AF_INET) {
+            inet_ntop(AF_INET, &((struct sockaddr_in *)res_tmp->ai_addr)->sin_addr, ip_str, INET_ADDRSTRLEN);
+            printf("\tIP Address: %s\n", ip_str);
+            printf("\tAddress Family: AF_INET\n");
+        } else if (res_tmp->ai_family == AF_INET6) {
+            inet_ntop(AF_INET6, &((struct sockaddr_in6 *)res_tmp->ai_addr)->sin6_addr, ip_str, INET6_ADDRSTRLEN);
+            printf("\tIP Address: %s\n", ip_str);
+            printf("\tAddress Family: AF_INET6\n");
+        } else {
+            ESP_LOGE(TAG, "ai_family Unknown: %d\n", res_tmp->ai_family);
+        }
+
+        /* Print the protocol used */
+        printf("\tProtocol: %d\n", res_tmp->ai_protocol);
+
+        /* Print the canonical name if available */
+        if (res_tmp->ai_canonname) {
+            printf("\tCanonical Name: %s\n", res_tmp->ai_canonname);
+        }
+    }
+
+    freeaddrinfo(res);
+
+    return 0;
+}
+
+/**
+ * @brief Registers the getaddrinfo command.
+ *
+ * @return esp_err_t Returns ESP_OK on success, or an error code on failure.
+ */
+esp_err_t console_cmd_getaddrinfo_register(void)
+{
+    esp_err_t ret;
+
+    getddrinfo_args.family = arg_str0("f", "family", "<AF>", "Address family (AF_INET, AF_INET6, AF_UNSPEC).");
+    getddrinfo_args.flags = arg_strn("F", "flags", "<FLAGS>", 0, 5, "Special flags (AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST, AI_V4MAPPED, AI_ALL).");
+    getddrinfo_args.port_nr = arg_str0("p", "port", "<port>", "String containing a numeric port number.");
+    getddrinfo_args.hostname = arg_str1(NULL, NULL, "<hostname>", "Host address");
+    getddrinfo_args.end = arg_end(1);
+    const esp_console_cmd_t getddrinfo_cmd = {
+        .command = "getaddrinfo",
+        .help = "Usage: getaddrinfo [options] <hostname> [service]",
+        .hint = NULL,
+        .func = &do_getddrinfo_cmd,
+        .argtable = &getddrinfo_args
+    };
+
+    ret = esp_console_cmd_register(&getddrinfo_cmd);
+    if (ret) {
+        ESP_LOGE(TAG, "Unable to register getddrinfo");
+    }
+
+    return ret;
+}

components/console_cmd_ping/console_getsetdnsserver.c

@@ -0,0 +1,279 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdio.h>
+#include <string.h>
+#include "sdkconfig.h"
+#include "lwip/inet.h"
+#include "lwip/netdb.h"
+#include "lwip/sockets.h"
+#include "esp_console.h"
+#include "esp_netif.h"
+#include "lwip/netdb.h"
+#include "esp_log.h"
+#include "argtable3/argtable3.h"
+#include <netdb.h>
+#include "console_ping.h"
+
+
+static const char *TAG = "console_setdnsserver";
+
+#if CONFIG_PING_CMD_AUTO_REGISTRATION
+static esp_err_t console_cmd_dnscmd_register(void);
+
+/**
+ * @brief  Static registration of the getaddrinfo command plugin.
+ *
+ * This section registers the plugin description structure and places it into
+ * the .console_cmd_desc section, as determined by the linker.lf file in the
+ * 'plugins' component.
+ */
+static const console_cmd_plugin_desc_t __attribute__((section(".console_cmd_desc"), used)) PLUGIN = {
+    .name = "console_cmd_dnscmd",
+    .plugin_regd_fn = &console_cmd_dnscmd_register
+};
+
+
+/**
+ * @brief Registers the DNS commands (setdnsserver and getdnsserver) with the console.
+ *
+ * @return esp_err_t Returns ESP_OK.
+ */
+static esp_err_t console_cmd_dnscmd_register(void)
+{
+    console_cmd_setdnsserver_register();
+    console_cmd_getdnsserver_register();
+
+    return ESP_OK;
+}
+#endif
+
+/**
+ * @brief Structure to hold arguments for the setdnsserver command.
+ */
+static struct {
+    struct arg_str *main;
+    struct arg_str *backup;
+    struct arg_str *fallback;
+    struct arg_end *end;
+} setdnsserver_args;
+
+/**
+ * @brief Sets the DNS server address for all network interfaces.
+ *
+ * This function iterates over all network interfaces available on the ESP32 device
+ * and sets the DNS server address for the specified DNS type (main, backup, or fallback).
+ * The DNS address is only set if a valid address is provided (non-zero and not equal to IPADDR_NONE).
+ *
+ * @param server IP address of the DNS server.
+ * @param type Type of the DNS server (main, backup, fallback).
+ *
+ * @return esp_err_t Returns ESP_OK on success, or an error code on failure.
+ */
+static esp_err_t set_dns_server(const char *server, esp_netif_dns_type_t type)
+{
+    int ret = 0;
+    struct addrinfo hint = {0};
+    struct addrinfo *res = NULL, *res_tmp = NULL;
+    esp_netif_t *esp_netif = NULL;
+    esp_netif_dns_info_t dns;
+    int addr_cnt = 0;
+
+    ret = getaddrinfo(server, NULL, &hint, &res);
+    if (ret != 0) {
+        printf("setdnsserver: Failure host:%s(ERROR: %d)\n", server, ret);
+        ESP_LOGE(TAG, "Failure host");
+        return 1;
+    }
+
+    for (res_tmp = res; res_tmp != NULL; res_tmp = res_tmp->ai_next) {
+
+        if (addr_cnt == 0) {
+            if (res_tmp->ai_family == AF_INET) {
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 2, 0)
+                while ((esp_netif = esp_netif_next_unsafe(esp_netif)) != NULL) {
+#else
+                while ((esp_netif = esp_netif_next(esp_netif)) != NULL) {
+#endif
+                    struct sockaddr_in *ipv4 = (struct sockaddr_in *)res_tmp->ai_addr;
+                    dns.ip.u_addr.ip4.addr = ipv4->sin_addr.s_addr;
+                    dns.ip.type = IPADDR_TYPE_V4;
+                    ESP_ERROR_CHECK(esp_netif_set_dns_info(esp_netif, type, &dns));
+                }
+            } else if (res_tmp->ai_family == AF_INET6) {
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 2, 0)
+                while ((esp_netif = esp_netif_next_unsafe(esp_netif)) != NULL) {
+#else
+                while ((esp_netif = esp_netif_next(esp_netif)) != NULL) {
+#endif
+                    struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)res_tmp->ai_addr;
+                    memcpy(dns.ip.u_addr.ip6.addr, &ipv6->sin6_addr, sizeof(dns.ip.u_addr.ip6.addr));
+                    dns.ip.type = IPADDR_TYPE_V6;
+                    ESP_ERROR_CHECK(esp_netif_set_dns_info(esp_netif, type, &dns));
+                }
+            } else {
+                ESP_LOGE(TAG, "ai_family Unknown: %d\n", res_tmp->ai_family);
+            }
+        }
+        addr_cnt++;
+    }
+
+    freeaddrinfo(res);
+
+    return ESP_OK;
+}
+
+/**
+ * @brief Command handler for setting DNS server addresses.
+ *
+ * @param argc Argument count.
+ * @param argv Argument values.
+ *
+ * @return int: 0 on success, 1 on error.
+ */
+static int do_setdnsserver_cmd(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **)&setdnsserver_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, setdnsserver_args.end, argv[0]);
+        return 1;
+    }
+
+    set_dns_server(setdnsserver_args.main->sval[0], ESP_NETIF_DNS_MAIN);
+
+    if (setdnsserver_args.backup->count > 0) {
+        set_dns_server(setdnsserver_args.backup->sval[0], ESP_NETIF_DNS_BACKUP);
+    }
+
+    if (setdnsserver_args.fallback->count > 0) {
+        set_dns_server(setdnsserver_args.fallback->sval[0], ESP_NETIF_DNS_FALLBACK);
+    }
+
+    return 0;
+}
+
+
+/**
+ * @brief Registers the setdnsserver command.
+ *
+ * @return esp_err_t Returns ESP_OK on success, or an error code on failure.
+ */
+esp_err_t console_cmd_setdnsserver_register(void)
+{
+    esp_err_t ret;
+
+    setdnsserver_args.main = arg_str1(NULL, NULL, "<main>", "The main DNS server IP address.");
+    setdnsserver_args.backup = arg_str0(NULL, NULL, "backup", "The secondary DNS server IP address (optional).");
+    setdnsserver_args.fallback = arg_str0(NULL, NULL, "fallback", "The fallback DNS server IP address (optional).");
+    setdnsserver_args.end = arg_end(1);
+    const esp_console_cmd_t setdnsserver_cmd = {
+        .command = "setdnsserver",
+        .help = "Usage: setdnsserver <main> [backup] [fallback]",
+        .hint = NULL,
+        .func = &do_setdnsserver_cmd,
+        .argtable = &setdnsserver_args
+    };
+
+    ret = esp_console_cmd_register(&setdnsserver_cmd);
+    if (ret) {
+        ESP_LOGE(TAG, "Unable to register setdnsserver");
+    }
+
+    return ret;
+}
+
+
+/**
+ * @brief Structure to hold arguments for the getdnsserver command.
+ */
+static struct {
+    struct arg_end *end;
+} getdnsserver_args;
+
+/**
+ * @brief Command handler for getting DNS server addresses.
+ *
+ * @param argc Argument count.
+ * @param argv Argument values.
+ *
+ * @return int: 0 on success, 1 on error.
+ */
+static int do_getdnsserver_cmd(int argc, char **argv)
+{
+    esp_netif_t *esp_netif = NULL;
+    esp_netif_dns_info_t dns_info;
+    char interface[10];
+    esp_err_t ret = ESP_FAIL;
+
+    int nerrors = arg_parse(argc, argv, (void **)&getdnsserver_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, getdnsserver_args.end, argv[0]);
+        return 1;
+    }
+
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 2, 0)
+    while ((esp_netif = esp_netif_next_unsafe(esp_netif)) != NULL) {
+#else
+    while ((esp_netif = esp_netif_next(esp_netif)) != NULL) {
+#endif
+
+        /* Print Interface Name and Number */
+        ret = esp_netif_get_netif_impl_name(esp_netif, interface);
+        if ((ESP_FAIL == ret) || (NULL == esp_netif)) {
+            ESP_LOGE(TAG, "No interface available");
+            return 1;
+        }
+
+        printf("Interface Name: %s\n", interface);
+        ESP_ERROR_CHECK(esp_netif_get_dns_info(esp_netif, ESP_NETIF_DNS_MAIN, &dns_info));
+        if (dns_info.ip.type == ESP_IPADDR_TYPE_V4) {
+            printf("Main DNS server : " IPSTR "\n", IP2STR(&dns_info.ip.u_addr.ip4));
+        } else if (dns_info.ip.type == ESP_IPADDR_TYPE_V6) {
+            printf("Main DNS server : " IPV6STR "\n", IPV62STR(dns_info.ip.u_addr.ip6));
+        }
+
+        ESP_ERROR_CHECK(esp_netif_get_dns_info(esp_netif, ESP_NETIF_DNS_BACKUP, &dns_info));
+        if (dns_info.ip.type == ESP_IPADDR_TYPE_V4) {
+            printf("Backup DNS server : " IPSTR "\n", IP2STR(&dns_info.ip.u_addr.ip4));
+        } else if (dns_info.ip.type == ESP_IPADDR_TYPE_V6) {
+            printf("Backup DNS server : " IPV6STR "\n", IPV62STR(dns_info.ip.u_addr.ip6));
+        }
+
+        ESP_ERROR_CHECK(esp_netif_get_dns_info(esp_netif, ESP_NETIF_DNS_FALLBACK, &dns_info));
+        if (dns_info.ip.type == ESP_IPADDR_TYPE_V4) {
+            printf("Fallback DNS server : " IPSTR "\n", IP2STR(&dns_info.ip.u_addr.ip4));
+        } else if (dns_info.ip.type == ESP_IPADDR_TYPE_V6) {
+            printf("Fallback DNS server : " IPV6STR "\n", IPV62STR(dns_info.ip.u_addr.ip6));
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * @brief Registers the getdnsserver command.
+ *
+ * @return esp_err_t Returns ESP_OK on success, or an error code on failure.
+ */
+esp_err_t console_cmd_getdnsserver_register(void)
+{
+    esp_err_t ret;
+
+    getdnsserver_args.end = arg_end(1);
+    const esp_console_cmd_t getdnsserver_cmd = {
+        .command = "getdnsserver",
+        .help = "Usage: getdnsserver",
+        .hint = NULL,
+        .func = &do_getdnsserver_cmd,
+        .argtable = &getdnsserver_args
+    };
+
+    ret = esp_console_cmd_register(&getdnsserver_cmd);
+    if (ret) {
+        ESP_LOGE(TAG, "Unable to register getdnsserver");
+    }
+
+    return ret;
+}

components/console_cmd_ping/console_ping.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -20,7 +20,7 @@
 static const char *TAG = "console_ping";
 SemaphoreHandle_t sync_semaphore;
 
-
+#if CONFIG_PING_CMD_AUTO_REGISTRATION
 /**
  * Static registration of this plugin is achieved by defining the plugin description
  * structure and placing it into .console_cmd_desc section.
@@ -30,7 +30,7 @@ static const console_cmd_plugin_desc_t __attribute__((section(".console_cmd_desc
     .name = "console_cmd_ping",
     .plugin_regd_fn = &console_cmd_ping_register
 };
-
+#endif
 
 static void cmd_ping_on_ping_success(esp_ping_handle_t hdl, void *args)
 {
@@ -75,9 +75,13 @@ static void cmd_ping_on_ping_end(esp_ping_handle_t hdl, void *args)
         loss = 0;
     }
     if (IP_IS_V4(&target_addr)) {
+#if CONFIG_LWIP_IPV4
         printf("\n--- %s ping statistics ---\n", inet_ntoa(*ip_2_ip4(&target_addr)));
+#endif
     } else {
+#if CONFIG_LWIP_IPV6
         printf("\n--- %s ping statistics ---\n", inet6_ntoa(*ip_2_ip6(&target_addr)));
+#endif
     }
     printf("%" PRIu32 " packets transmitted, %" PRIu32 " received, %" PRIu32 "%% packet loss, time %" PRIu32 "ms\n",
            transmitted, received, loss, total_time_ms);
@@ -150,11 +154,15 @@ static int do_ping_cmd(int argc, char **argv)
             return 1;
         }
         if (res->ai_family == AF_INET) {
+#if CONFIG_LWIP_IPV4
             struct in_addr addr4 = ((struct sockaddr_in *) (res->ai_addr))->sin_addr;
             inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4);
+#endif
         } else {
+#if CONFIG_LWIP_IPV6
             struct in6_addr addr6 = ((struct sockaddr_in6 *) (res->ai_addr))->sin6_addr;
             inet6_addr_to_ip6addr(ip_2_ip6(&target_addr), &addr6);
+#endif
         }
         freeaddrinfo(res);
     }

components/console_cmd_ping/console_ping.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -20,6 +20,30 @@ extern "C" {
  */
 esp_err_t console_cmd_ping_register(void);
 
+/**
+ * @brief Registers the getddrinfo command.
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_getaddrinfo_register(void);
+
+/**
+ * @brief Registers the setdnsserver command.
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_setdnsserver_register(void);
+
+/**
+ * @brief Registers the setdnsserver command.
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_getdnsserver_register(void);
+
 #ifdef __cplusplus
 }
 #endif

components/console_cmd_ping/idf_component.yml

@@ -1,4 +1,4 @@
-version: 1.0.0
+version: 1.1.0
 url: https://github.com/espressif/esp-protocols/tree/master/components/console_cmd_ping
 description: The component provides a console where the 'ping' command can be executed.
 dependencies:

components/esp_modem/.cz.yaml

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

components/esp_modem/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [1.2.1](https://github.com/espressif/esp-protocols/commits/modem-v1.2.1)
+
+### Bug Fixes
+
+- Use higher GPIO range to support new chips ([428fdbbd](https://github.com/espressif/esp-protocols/commit/428fdbbd), [#558](https://github.com/espressif/esp-protocols/issues/558))
+- Remove tests and support for IDFv4.4, added IDFv5.4 ([433a033f](https://github.com/espressif/esp-protocols/commit/433a033f))
+- Fix typo GENETIC -> GENERIC in mode types ([090b1ff8](https://github.com/espressif/esp-protocols/commit/090b1ff8), [#667](https://github.com/espressif/esp-protocols/issues/667))
+- Add support for URC handler into C-API ([295d99df](https://github.com/espressif/esp-protocols/commit/295d99df), [#180](https://github.com/espressif/esp-protocols/issues/180))
+
+## [1.2.0](https://github.com/espressif/esp-protocols/commits/modem-v1.2.0)
+
+### Features
+
+- Add support for guessing mode ([52598e5f](https://github.com/espressif/esp-protocols/commit/52598e5f))
+- Delete CMUX internal implementation even if terminal exit fails ([0e0cbd6b](https://github.com/espressif/esp-protocols/commit/0e0cbd6b))
+- Add support for handling URC ([1b6a3b3b](https://github.com/espressif/esp-protocols/commit/1b6a3b3b), [#180](https://github.com/espressif/esp-protocols/issues/180))
+- add ability to change ESP_MODEM_C_API_STR_MAX from Kconfig ([17909892](https://github.com/espressif/esp-protocols/commit/17909892))
+- Added target test config with CHAP authentication ([f8ae7def](https://github.com/espressif/esp-protocols/commit/f8ae7def))
+- example add esp32p4 usb support ([adafeae5](https://github.com/espressif/esp-protocols/commit/adafeae5))
+- Publish mbedtls component ([0140455f](https://github.com/espressif/esp-protocols/commit/0140455f))
+- host test support of the latest ESP-IDF release ([3f74b4e8](https://github.com/espressif/esp-protocols/commit/3f74b4e8))
+
+### Bug Fixes
+
+- Fix console example to use urc/detect features ([1a9eaf3e](https://github.com/espressif/esp-protocols/commit/1a9eaf3e))
+- Update target test builds to use external Catch2 ([554f022c](https://github.com/espressif/esp-protocols/commit/554f022c))
+- Fix arguments names when spawn esp_modem_xxx declarations ([b6792c52](https://github.com/espressif/esp-protocols/commit/b6792c52))
+- Remove catch dependency ([c3480768](https://github.com/espressif/esp-protocols/commit/c3480768))
+- Examples: use local configs for MQTT topic/data ([f5c13b92](https://github.com/espressif/esp-protocols/commit/f5c13b92))
+- Fixed clang-tidy warnings ([70fa3af7](https://github.com/espressif/esp-protocols/commit/70fa3af7))
+- Fix CI build per IDFv5.3 ([d0c17ef0](https://github.com/espressif/esp-protocols/commit/d0c17ef0))
+- Fixed UART task to check for buffered data periodically ([4bdd90cc](https://github.com/espressif/esp-protocols/commit/4bdd90cc), [#536](https://github.com/espressif/esp-protocols/issues/536))
+- Cleanup unused configs from PPPoS example ([08a62ccc](https://github.com/espressif/esp-protocols/commit/08a62ccc))
+- Update CMUX example with SIM7070_gnss cleaned-up ([56fe5327](https://github.com/espressif/esp-protocols/commit/56fe5327))
+- Update console example with SIM7070_gnss format comments ([5baaf542](https://github.com/espressif/esp-protocols/commit/5baaf542))
+- Fix remaining print format warnings ([3b80181d](https://github.com/espressif/esp-protocols/commit/3b80181d))
+
+### Updated
+
+- docs(modem): Fix esp_modem_at_raw() description (C-API) ([492a6a00](https://github.com/espressif/esp-protocols/commit/492a6a00))
+- ci(common): updated github actions(checkout, upload, download) v3 to 4, Ubuntu 20.04 to v22.04 ([a23a0027](https://github.com/espressif/esp-protocols/commit/a23a0027))
+
 ## [1.1.0](https://github.com/espressif/esp-protocols/commits/modem-v1.1.0)
 
 ### Features

components/esp_modem/Kconfig

@@ -63,4 +63,17 @@ menu "esp-modem"
             dce_factory::Factory::create_unique_dce_from<CustomModule, DCE*>(dce_config, std::move(dte), netif)
             Please refer to the pppos_client example for more details.
 
+    config ESP_MODEM_C_API_STR_MAX
+        int "Size in bytes for response from AT commands returning textual values (C-API)"
+        default 128
+        help
+            Some AT commands returns textual values which C-API copy as c-string to user allocated space,
+            it also truncates the output data to this size. Increase this if some AT answers are truncated.
+
+    config ESP_MODEM_URC_HANDLER
+        bool "Enable support for adding URC handler"
+        default n
+        help
+            If enabled, APIs to add URC handler are available
+
 endmenu

components/esp_modem/examples/ap_to_pppos/README.md

@@ -15,7 +15,3 @@ By default, this example simply connects to the PPP server using a supported dev
 This example however, doesn't rely on sending specific AT commands, just the bare minimum to setup the cellular network.
 Thus, if the `EXAMPLE_USE_MINIMAL_DCE` option is enabled, we directly inherit from the `ModuleIf` and implement only the basic commands.
 Also, to demonstrate the dce_factory functionality, a new `NetDCE_Factory` is implemented for creating the network module and the DCE.
-
-### Supported IDF versions
-
-This example is only supported from `v4.2`, since is uses NAPT feature.

components/esp_modem/examples/linux_modem/README.md

@@ -17,7 +17,3 @@ over PPPoS, i.e. over the modem serial line.
 * Experiment with the network, after getting the IP from the modem device
     - directly in the code
     - in the system (need to set `tun` interface IP, dns servers, and routing the desired traffic over the tun interface)
-
-### Supported IDF versions
-
-This example (using the default CMake IDF build system) is only supported from `v4.4`, since is uses `idf.py`'s linux target.

components/esp_modem/examples/modem_console/README.md

@@ -25,9 +25,3 @@ USB example uses Quactel BG96 modem device. BG96 needs a positive pulse on its P
 This example supports USB modem hot-plugging and reconnection. There is one limitation coming from esp_console component:
 When esp_console REPL is being destroyed (after USB mode disconnection or after `exit` command), it will block on UART read.
 You must send a character to it (via idf.py monitor), so it unblocks and properly exits.
-
-### Supported IDF versions
-
-This example is only supported from `v4.2`, due to support of the console repl mode.
-
-USB example is supported from `v4.4`.

components/esp_modem/examples/modem_console/main/Kconfig.projbuild

@@ -108,28 +108,28 @@ menu "Example Configuration"
         config EXAMPLE_MODEM_UART_TX_PIN
             int "TXD Pin Number"
             default 25
-            range 0 31
+            range 0 56
             help
                 Pin number of UART TX.
 
         config EXAMPLE_MODEM_UART_RX_PIN
             int "RXD Pin Number"
             default 26
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RX.
 
         config EXAMPLE_MODEM_UART_RTS_PIN
             int "RTS Pin Number"
             default 27
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RTS.
 
         config EXAMPLE_MODEM_UART_CTS_PIN
             int "CTS Pin Number"
             default 23
-            range 0 31
+            range 0 56
             help
                 Pin number of UART CTS.
 
@@ -179,7 +179,7 @@ menu "Example Configuration"
     config EXAMPLE_MODEM_PWRKEY_PIN
         int "PWRKEY Pin Number"
         default 18
-        range 0 31
+        range 0 56
         help
             Pin number connected to modem's power key pin.
 endmenu

components/esp_modem/examples/modem_console/main/modem_console_main.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -89,7 +89,7 @@ void wakeup_modem(void)
     vTaskDelay(pdMS_TO_TICKS(2000));
 }
 
-#ifdef CONFIG_EXAMPLE_MODEM_DEVICE_SHINY
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
 command_result handle_urc(uint8_t *data, size_t len)
 {
     ESP_LOG_BUFFER_HEXDUMP("on_read", data, len, ESP_LOG_INFO);
@@ -238,7 +238,9 @@ extern "C" void app_main(void)
         if (c->get_count_of(&SetModeArgs::mode)) {
             auto mode = c->get_string_of(&SetModeArgs::mode);
             modem_mode dev_mode;
-            if (mode == "UNDEF") {
+            if (mode == "AUTO") {
+                dev_mode = esp_modem::modem_mode::AUTODETECT;
+            } else if (mode == "UNDEF") {
                 dev_mode = esp_modem::modem_mode::UNDEF;
             } else if (mode == "CMUX1") {
                 dev_mode = esp_modem::modem_mode::CMUX_MANUAL_MODE;
@@ -370,15 +372,15 @@ extern "C" void app_main(void)
         ESP_LOGI(TAG, "Resetting the module...");
         CHECK_ERR(dce->reset(), ESP_LOGI(TAG, "OK"));
     });
-#ifdef CONFIG_EXAMPLE_MODEM_DEVICE_SHINY
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
     const ConsoleCommand HandleURC("urc", "toggle urc handling", no_args, [&](ConsoleCommand * c) {
         static int cnt = 0;
         if (++cnt % 2) {
             ESP_LOGI(TAG, "Adding URC handler");
-            dce->set_on_read(handle_urc);
+            dce->set_urc(handle_urc);
         } else {
             ESP_LOGI(TAG, "URC removed");
-            dce->set_on_read(nullptr);
+            dce->set_urc(nullptr);
         }
         return 0;
     });

components/esp_modem/examples/modem_psm/main/Kconfig.projbuild

@@ -20,14 +20,14 @@ menu "Example Configuration"
         config EXAMPLE_MODEM_UART_TX_PIN
             int "TXD Pin Number"
             default 4
-            range 0 31
+            range 0 56
             help
                 Pin number of UART TX.
 
         config EXAMPLE_MODEM_UART_RX_PIN
             int "RXD Pin Number"
             default 5
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RX.
 
@@ -70,14 +70,14 @@ menu "Example Configuration"
     config EXAMPLE_MODEM_PWRKEY_PIN
         int "PWRKEY Pin Number"
         default 18
-        range 0 31
+        range 0 56
         help
             Pin number connected to modem's power key pin.
 
     config EXAMPLE_MODEM_STATUS_PIN
         int "STATUS Pin Number"
         default 19
-        range 0 31
+        range 0 56
         help
             Pin number connected to modem's status pin.
 

components/esp_modem/examples/modem_tcp_client/README.md

@@ -22,7 +22,3 @@ To enable this mode, please set `EXAMPLE_CUSTOM_TCP_TRANSPORT=y`
 This configuration could be used with any network library, which is connecting to a localhost endpoint instead of remote one. This example creates a localhost listener which basically mimics the remote endpoint by forwarding the traffic between the library and the TCP/socket layer of the modem (which is already secure if the TLS is used in the network library)
 
 ![with localhost listener](at_client_localhost.png)
-
-### Supported IDF versions
-
-This example is supported from IDF `v5.0`.

components/esp_modem/examples/modem_tcp_client/main/Kconfig.projbuild

@@ -30,28 +30,28 @@ menu "Example Configuration"
         config EXAMPLE_MODEM_UART_TX_PIN
             int "TXD Pin Number"
             default 25
-            range 0 31
+            range 0 56
             help
                 Pin number of UART TX.
 
         config EXAMPLE_MODEM_UART_RX_PIN
             int "RXD Pin Number"
             default 26
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RX.
 
         config EXAMPLE_MODEM_UART_RTS_PIN
             int "RTS Pin Number"
             default 27
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RTS.
 
         config EXAMPLE_MODEM_UART_CTS_PIN
             int "CTS Pin Number"
             default 23
-            range 0 31
+            range 0 56
             help
                 Pin number of UART CTS.
 

components/esp_modem/examples/pppos_client/README.md

@@ -18,9 +18,3 @@ For USB enabled targets (ESP32-S2, ESP32-S3, or ESP32-P4), it is possible to con
 USB example uses Quactel BG96 modem device. BG96 needs a positive pulse on its PWK pin to boot-up.
 
 This example supports USB modem hot-plugging and reconnection.
-
-### Supported IDF versions
-
-This example is only supported from `v4.1`, as this is the default dependency of `esp-modem` component.
-
-USB example is supported from `v4.4`.

components/esp_modem/examples/pppos_client/main/Kconfig.projbuild

@@ -100,28 +100,28 @@ menu "Example Configuration"
         config EXAMPLE_MODEM_UART_TX_PIN
             int "TXD Pin Number"
             default 25
-            range 0 31
+            range 0 56
             help
                 Pin number of UART TX.
 
         config EXAMPLE_MODEM_UART_RX_PIN
             int "RXD Pin Number"
             default 26
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RX.
 
         config EXAMPLE_MODEM_UART_RTS_PIN
             int "RTS Pin Number"
             default 27
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RTS.
 
         config EXAMPLE_MODEM_UART_CTS_PIN
             int "CTS Pin Number"
             default 23
-            range 0 31
+            range 0 56
             help
                 Pin number of UART CTS.
 

components/esp_modem/examples/pppos_client/main/custom_module.hpp

@@ -56,7 +56,7 @@ DCE *esp_modem_create_custom_dce(const esp_modem_dce_config_t *dce_config, std::
 /**
  * @brief This API is only needed for extending standard C-API, since we added get_time() method to our CustomModule
  *
- * @note This header is included from esp_modem_c_api.cpp, so it could use ESP_MODEM_C_API_STR_MAX macro
+ * @note This header is included from esp_modem_c_api.cpp, so it could use CONFIG_ESP_MODEM_C_API_STR_MAX macro
  * indicating maximum C-API string size
  *
  * @note In order to access the newly added API get_time(), we have to static_cast<> the GenericModule from DCE
@@ -70,10 +70,10 @@ extern "C" esp_err_t esp_modem_get_time(esp_modem_dce_t *dce_wrap, char *p_time)
     if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
         return ESP_ERR_INVALID_ARG;
     }
-    std::string time{ESP_MODEM_C_API_STR_MAX};
+    std::string time{CONFIG_ESP_MODEM_C_API_STR_MAX};
     auto ret = command_response_to_esp_err(static_cast<SIM7600_WITH_TIME *>(dce_wrap->dce->get_module())->get_time(time));
     if (ret == ESP_OK && !time.empty()) {
-        strlcpy(p_time, time.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_time, time.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }

components/esp_modem/examples/simple_cmux_client/README.md

@@ -11,11 +11,3 @@ The example uses the following configuration options to demonstrate basic esp-mo
 * `EXAMPLE_NEED_SIM_PIN`: To unlock the SIM card with a PIN code if needed
 * `EXAMPLE_PERFORM_OTA`: To start simple OTA at the end of the example to exercise basic CMUX/modem networking. Please note that the option `CONFIG_UART_ISR_IN_IRAM` is not enabled automatically, so that buffer overflows are expected and CMUX/PPP and networking should recover.
 * `EXAMPLE_USE_VFS_TERM`: To demonstrate using an abstract file descriptor to talk to the device (instead of the UART driver directly). This option could be used when implementing a custom VFS driver.
-
-## About the esp_modem
-
-Please check the component [README](../../README.md)
-
-### Supported IDF versions
-
-This example is only supported from `v4.3`, since is uses an experimental `esp_event_cxx` component.

components/esp_modem/examples/simple_cmux_client/main/Kconfig.projbuild

@@ -69,28 +69,28 @@ menu "Example Configuration"
         config EXAMPLE_MODEM_UART_TX_PIN
             int "TXD Pin Number"
             default 25
-            range 0 31
+            range 0 56
             help
                 Pin number of UART TX.
 
         config EXAMPLE_MODEM_UART_RX_PIN
             int "RXD Pin Number"
             default 26
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RX.
 
         config EXAMPLE_MODEM_UART_RTS_PIN
             int "RTS Pin Number"
             default 27
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RTS.
 
         config EXAMPLE_MODEM_UART_CTS_PIN
             int "CTS Pin Number"
             default 23
-            range 0 31
+            range 0 56
             help
                 Pin number of UART CTS.
     endmenu
@@ -129,4 +129,16 @@ menu "Example Configuration"
         help
             URL of an mqtt broker which this example connects to.
 
+    config EXAMPLE_MQTT_TEST_TOPIC
+        string "MQTT topic to publish/subscribe"
+        default "/topic/esp-pppos"
+        help
+            MQTT topic, which we subscribe on and publish to.
+
+    config EXAMPLE_MQTT_TEST_DATA
+        string "MQTT data to publish/receive"
+        default "esp32-pppos"
+        help
+            MQTT data message, which we publish and expect to receive.
+
 endmenu

components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp

@@ -234,8 +234,8 @@ extern "C" void app_main(void)
         }
         std::cout << "Connected" << std::endl;
 
-        mqtt.subscribe("/topic/esp-modem");
-        mqtt.publish("/topic/esp-modem", "Hello modem");
+        mqtt.subscribe(CONFIG_EXAMPLE_MQTT_TEST_TOPIC);
+        mqtt.publish(CONFIG_EXAMPLE_MQTT_TEST_TOPIC, CONFIG_EXAMPLE_MQTT_TEST_DATA);
         if (!handler.wait_for(StatusHandler::MQTT_Data, 60000)) {
             ESP_LOGE(TAG, "Didn't receive published data within specified timeout... exiting");
             return;

components/esp_modem/examples/simple_cmux_client/pytest_cmux.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
 from __future__ import print_function, unicode_literals
 
@@ -10,8 +10,17 @@ def test_cmux_connection(dut):
       2. checks we get an IP
       3. checks for the MQTT events
     """
+    # Get topic and data from Kconfig
+    topic = ''
+    data = ''
+    try:
+        topic = dut.app.sdkconfig.get('EXAMPLE_MQTT_TEST_TOPIC')
+        data = dut.app.sdkconfig.get('EXAMPLE_MQTT_TEST_DATA')
+    except Exception:
+        print('ENV_TEST_FAILURE: Cannot find broker url in sdkconfig')
+        raise
     # Check the sequence of connecting, publishing, disconnecting
     dut.expect('Modem has correctly entered multiplexed')
     # Check for MQTT connection and the data event
-    dut.expect('TOPIC: /topic/esp-modem')
-    dut.expect('DATA: Hello modem')
+    dut.expect(f'TOPIC: {topic}')
+    dut.expect(f'DATA: {data}')

components/esp_modem/examples/simple_cmux_client/sdkconfig.ci.sim800_cmux

@@ -15,3 +15,4 @@ CONFIG_ESP32_PANIC_PRINT_HALT=y
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
 CONFIG_EXAMPLE_CLOSE_CMUX_AT_END=y
+CONFIG_EXAMPLE_MQTT_TEST_TOPIC="/ci/esp-modem/pppos-client"

components/esp_modem/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.1.0"
+version: "1.2.1"
 description: Library for communicating with cellular modems in command and data modes
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_modem
 issues: https://github.com/espressif/esp-protocols/issues

components/esp_modem/include/cxx_include/esp_modem_dce.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -30,9 +30,11 @@ public:
     ~DCE_Mode() = default;
     bool set(DTE *dte, ModuleIf *module, Netif &netif, modem_mode m);
     modem_mode get();
+    modem_mode guess(DTE *dte, bool with_cmux = false);
 
 private:
     bool set_unsafe(DTE *dte, ModuleIf *module, Netif &netif, modem_mode m);
+    modem_mode guess_unsafe(DTE *dte, bool with_cmux);
     modem_mode mode;
 
 };
@@ -79,6 +81,11 @@ public:
         return dte->command(command, std::move(got_line), time_ms);
     }
 
+    modem_mode guess_mode(bool with_cmux = false)
+    {
+        return mode.guess(dte.get(), with_cmux);
+    }
+
     bool set_mode(modem_mode m)
     {
         return mode.set(dte.get(), device.get(), netif, m);
@@ -89,6 +96,13 @@ public:
         return dte->recover();
     }
 
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+    void set_urc(got_line_cb on_read_cb)
+    {
+        dte->set_urc_cb(on_read_cb);
+    }
+#endif
+
 protected:
     std::shared_ptr<DTE> dte;
     std::shared_ptr<SpecificModule> device;

components/esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -65,6 +65,18 @@ public:
 
     int write(DTE_Command command);
 
+    /**
+     * @brief send data to the selected terminal, by default (without term_id argument)
+     * this API works the same as write: sends data to the secondary terminal, which is
+     * typically used as data terminal (for networking).
+     *
+     * @param data Data pointer to write
+     * @param len Data len to write
+     * @param term_id Terminal id: Primary if id==0, Secondary if id==1
+     * @return number of bytes written
+     */
+    int send(uint8_t *data, size_t len, int term_id = 1);
+
     /**
      * @brief Reading from the underlying terminal
      * @param d Returning the data pointer of the received payload
@@ -94,6 +106,17 @@ public:
      */
     void set_error_cb(std::function<void(terminal_error err)> f);
 
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+    /**
+     * @brief Allow setting a line callback for all incoming data
+     * @param line_cb
+     */
+    void set_urc_cb(got_line_cb line_cb)
+    {
+        command_cb.urc_handler = std::move(line_cb);
+    }
+#endif
+
     /**
      * @brief Sets the DTE to desired mode (Command/Data/Cmux)
      * @param m Desired operation mode
@@ -191,6 +214,9 @@ private:
      * @brief This abstracts command callback processing and implements its locking, signaling of completion and timeouts.
      */
     struct command_cb {
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+        got_line_cb urc_handler {};                             /*!< URC callback if enabled */
+#endif
         static const size_t GOT_LINE = SignalGroup::bit0;       /*!< Bit indicating response available */
         got_line_cb got_line;                                   /*!< Supplied command callback */
         Lock line_lock{};                                       /*!< Command callback locking mechanism */

components/esp_modem/include/cxx_include/esp_modem_types.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -37,6 +37,17 @@ enum class modem_mode {
     CMUX_MANUAL_DATA,    /*!< Sets the primary terminal to DATA mode in manual CMUX */
     CMUX_MANUAL_COMMAND, /*!< Sets the primary terminal to COMMAND mode in manual CMUX */
     CMUX_MANUAL_SWAP,    /*!< Swaps virtual terminals in manual CMUX mode (primary <-> secondary) */
+    RESUME_DATA_MODE,    /*!< This is used when the device is already in DATA mode and we need the modem lib to
+                          * enter the mode without switching. On success, we would end up in DATA-mode, UNDEF otherwise */
+    RESUME_COMMAND_MODE, /*!< This is used when the device is already in COMMAND mode and we want to resume it
+                          * On success, we would end up in DATA-mode, UNDEF otherwise */
+    RESUME_CMUX_MANUAL_MODE, /*!< This is used when the device is already in CMUX mode and we need the modem lib to
+                              * enter it without switching. On success, we would end up in CMUX_MANUAL-mode, UNDEF otherwise */
+    RESUME_CMUX_MANUAL_DATA, /*!< This is used when the device is already in CMUX-DATA mode and we need the modem lib to
+                              * enter it without switching. On success, we would end up in CMUX_MANUAL-DATA mode, UNDEF otherwise */
+    AUTODETECT,              /*!< Auto-detection command: It tries to send a few packets in order to recognize which mode the
+                              * the device currently is and update the modem library mode. On success the modem is updated,
+                              * otherwise it's set to UNDEF */
 };
 
 /**

components/esp_modem/include/esp_modem_c_api_types.h

@@ -13,6 +13,10 @@
 extern "C" {
 #endif
 
+/*  Compatibility macro to be removed in v2.0
+ */
+#define ESP_MODEM_DCE_GENETIC ESP_MODEM_DCE_GENERIC
+
 typedef struct esp_modem_dce_wrap esp_modem_dce_t;
 
 typedef struct esp_modem_PdpContext_t {
@@ -47,7 +51,7 @@ typedef enum esp_modem_dce_mode {
  * @brief DCE devices: Enum list of supported devices
  */
 typedef enum esp_modem_dce_device {
-    ESP_MODEM_DCE_GENETIC,  /**< The most generic device */
+    ESP_MODEM_DCE_GENERIC,  /**< The most generic device */
     ESP_MODEM_DCE_SIM7600,
     ESP_MODEM_DCE_SIM7070,
     ESP_MODEM_DCE_SIM7000,
@@ -141,6 +145,21 @@ esp_err_t esp_modem_command(esp_modem_dce_t *dce, const char *command, esp_err_t
  */
 esp_err_t esp_modem_set_apn(esp_modem_dce_t *dce, const char *apn);
 
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+/**
+ * @brief Sets a handler for unsolicited result codes (URCs) from the modem
+ *
+ * This function registers a callback that is triggered whenever an unsolicited
+ * result code (URC) is received from the modem. URCs are typically sent by the
+ * modem without a prior command to notify the host about certain events or status changes.
+ *
+ * @param dce Modem DCE handle
+ * @param got_line_cb Callback function which is called whenever a URC line is received
+ * @return ESP_OK on success, ESP_FAIL on failure
+ */
+esp_err_t esp_modem_set_urc(esp_modem_dce_t *dce, esp_err_t(*got_line_cb)(uint8_t *data, size_t len));
+#endif
+
 /**
  * @}
  */

components/esp_modem/include/esp_private/c_api_wrapper.hpp

@@ -44,7 +44,7 @@ inline dce_factory::ModemType convert_modem_enum(esp_modem_dce_device_t module)
     case ESP_MODEM_DCE_SIM800:
         return esp_modem::dce_factory::ModemType::SIM800;
     default:
-    case ESP_MODEM_DCE_GENETIC:
+    case ESP_MODEM_DCE_GENERIC:
         return esp_modem::dce_factory::ModemType::GenericModule;
     }
 }

components/esp_modem/include/generate/esp_modem_command_declare.inc

@@ -50,7 +50,6 @@ ESP_MODEM_DECLARE_DCE_COMMAND(set_pin, command_result, 1, STRING_IN(p1, pin)) \
  * @param[out] out Raw output from DTE
  * @param[in] pass Pattern in response for the API to return OK
  * @param[in] fail Pattern in response for the API to return FAIL
- * @param[in] cmd String command that's send to DTE
  * @param[in] timeout AT command timeout in milliseconds
  * @return OK, FAIL or TIMEOUT
  */\

components/esp_modem/include/generate/esp_modem_command_declare_helper.inc

@@ -3,9 +3,9 @@
 // Parameters
 // * handle different parameters for C++ and C API
 // * make parameter unique names, so they could be easily referenced and forwarded
-#define _ARG(param, name) param
 #define INT_IN(param, name) int  _ARG(param, name)
 #ifdef __cplusplus
+#define _ARG(param, name) param
 #include <string>
 #define STRING_IN(param, name) const std::string& _ARG(param, name)
 #define STRING_OUT(param, name) std::string& _ARG(param, name)
@@ -16,6 +16,7 @@
 
 #define STRUCT_OUT(struct_name, p1)  struct_name& p1
 #else
+#define _ARG(param, name) name
 #define STRING_IN(param, name) const char* _ARG(param, name)
 #define STRING_OUT(param, name) char* _ARG(param, name)
 #define BOOL_IN(param, name) const bool _ARG(param, name)

components/esp_modem/src/esp_modem_c_api.cpp

@@ -16,10 +16,6 @@
 #include "exception_stub.hpp"
 #include "esp_private/c_api_wrapper.hpp"
 
-#ifndef ESP_MODEM_C_API_STR_MAX
-#define ESP_MODEM_C_API_STR_MAX 128
-#endif
-
 #ifndef HAVE_STRLCPY
 size_t strlcpy(char *dest, const char *src, size_t len);
 #endif
@@ -64,7 +60,7 @@ extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, con
 
 extern "C" esp_modem_dce_t *esp_modem_new(const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
 {
-    return esp_modem_new_dev(ESP_MODEM_DCE_GENETIC, dte_config, dce_config, netif);
+    return esp_modem_new_dev(ESP_MODEM_DCE_GENERIC, dte_config, dce_config, netif);
 }
 
 extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
@@ -180,7 +176,7 @@ extern "C" esp_err_t esp_modem_at(esp_modem_dce_t *dce_wrap, const char *at, cha
     std::string at_str(at);
     auto ret = command_response_to_esp_err(dce_wrap->dce->at(at_str, out, timeout));
     if ((p_out != NULL) && (!out.empty())) {
-        strlcpy(p_out, out.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_out, out.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -201,7 +197,7 @@ extern "C" esp_err_t esp_modem_get_imsi(esp_modem_dce_t *dce_wrap, char *p_imsi)
     std::string imsi;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_imsi(imsi));
     if (ret == ESP_OK && !imsi.empty()) {
-        strlcpy(p_imsi, imsi.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_imsi, imsi.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -214,7 +210,7 @@ extern "C" esp_err_t esp_modem_at_raw(esp_modem_dce_t *dce_wrap, const char *cmd
     std::string out;
     auto ret = command_response_to_esp_err(dce_wrap->dce->at_raw(cmd, out, pass, fail, timeout));
     if ((p_out != NULL) && (!out.empty())) {
-        strlcpy(p_out, out.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_out, out.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -244,7 +240,7 @@ extern "C" esp_err_t esp_modem_get_imei(esp_modem_dce_t *dce_wrap, char *p_imei)
     std::string imei;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_imei(imei));
     if (ret == ESP_OK && !imei.empty()) {
-        strlcpy(p_imei, imei.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_imei, imei.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -258,7 +254,7 @@ extern "C" esp_err_t esp_modem_get_operator_name(esp_modem_dce_t *dce_wrap, char
     int act;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_operator_name(name, act));
     if (ret == ESP_OK && !name.empty()) {
-        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_name, name.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
         *p_act = act;
     }
     return ret;
@@ -272,7 +268,7 @@ extern "C" esp_err_t esp_modem_get_module_name(esp_modem_dce_t *dce_wrap, char *
     std::string name;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_module_name(name));
     if (ret == ESP_OK && !name.empty()) {
-        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_name, name.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -455,3 +451,27 @@ extern "C" esp_err_t esp_modem_set_apn(esp_modem_dce_t *dce_wrap, const char *ap
     dce_wrap->dce->get_module()->configure_pdp_context(std::move(new_pdp));
     return ESP_OK;
 }
+
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+extern "C" esp_err_t esp_modem_set_urc(esp_modem_dce_t *dce_wrap, esp_err_t(*got_line_fn)(uint8_t *data, size_t len))
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (got_line_fn == nullptr) {
+        dce_wrap->dce->set_urc(nullptr);
+        return ESP_OK;
+    }
+    dce_wrap->dce->set_urc([got_line_fn](uint8_t *data, size_t len) {
+        switch (got_line_fn(data, len)) {
+        case ESP_OK:
+            return command_result::OK;
+        case ESP_FAIL:
+            return command_result::FAIL;
+        default:
+            return command_result::TIMEOUT;
+        }
+    });
+    return ESP_OK;
+}
+#endif

components/esp_modem/src/esp_modem_dce.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -103,6 +103,51 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
         return true;
     case modem_mode::DUAL_MODE: // Only DTE can be in Dual mode
         break;
+    case modem_mode::AUTODETECT: {
+        auto guessed = guess_unsafe(dte, true);
+        if (guessed == modem_mode::UNDEF) {
+            return false;
+        }
+        // prepare the undefined mode before to allow all possible transitions
+        if (!dte->set_mode(modem_mode::UNDEF)) {
+            return false;
+        }
+        mode = modem_mode::UNDEF;
+        ESP_LOGD("DCE mode", "Detected mode: %d", static_cast<int>(guessed));
+        if (guessed == modem_mode::DATA_MODE) {
+            return set_unsafe(dte, device, netif, esp_modem::modem_mode::RESUME_DATA_MODE);
+        } else if (guessed == esp_modem::modem_mode::COMMAND_MODE) {
+            return set_unsafe(dte, device, netif, esp_modem::modem_mode::RESUME_COMMAND_MODE);
+        } else if (guessed == esp_modem::modem_mode::CMUX_MODE) {
+            if (!set_unsafe(dte, device, netif, esp_modem::modem_mode::RESUME_CMUX_MANUAL_MODE)) {
+                return false;
+            }
+            // now we guess the mode for each terminal
+            guessed = guess_unsafe(dte, false);
+            ESP_LOGD("DCE mode", "Detected mode on primary term: %d", static_cast<int>(guessed));
+            // now we need to access the second terminal, so we could simply send a SWAP command
+            // (switching to data mode does the swapping internally, so we only swap if we're in CMD mode)
+            if (guessed == modem_mode::DATA_MODE) {
+                // switch to DATA on the primary terminal and swap terminals
+                if (!set_unsafe(dte, device, netif, esp_modem::modem_mode::RESUME_CMUX_MANUAL_DATA)) {
+                    return false;
+                }
+            } else {
+                // swap terminals
+                if (!set_unsafe(dte, device, netif, esp_modem::modem_mode::CMUX_MANUAL_SWAP)) {
+                    return false;
+                }
+            }
+            guessed = guess_unsafe(dte, false);
+            ESP_LOGD("DCE mode", "Detected mode on secondary term: %d", static_cast<int>(guessed));
+            if (guessed == modem_mode::DATA_MODE) {
+                if (!set_unsafe(dte, device, netif, esp_modem::modem_mode::RESUME_CMUX_MANUAL_DATA)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     case modem_mode::COMMAND_MODE:
         if (mode == modem_mode::COMMAND_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
             return false;
@@ -122,6 +167,32 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
         }
         mode = m;
         return true;
+    case modem_mode::RESUME_DATA_MODE:
+        if (!dte->set_mode(modem_mode::DATA_MODE)) {
+            return false;
+        }
+        netif.start();
+        mode = modem_mode::DATA_MODE;
+        return true;
+    case modem_mode::RESUME_COMMAND_MODE:
+        if (!dte->set_mode(modem_mode::COMMAND_MODE)) {
+            return false;
+        }
+        mode = modem_mode::COMMAND_MODE;
+        return true;
+    case modem_mode::RESUME_CMUX_MANUAL_MODE:
+        if (!dte->set_mode(modem_mode::CMUX_MANUAL_MODE)) {
+            return false;
+        }
+        mode = modem_mode::CMUX_MANUAL_MODE;
+        return true;
+    case modem_mode::RESUME_CMUX_MANUAL_DATA:
+        if (!dte->set_mode(modem_mode::CMUX_MANUAL_SWAP)) {
+            return false;
+        }
+        netif.start();
+        mode = modem_mode::CMUX_MANUAL_MODE;
+        return true;
     case modem_mode::DATA_MODE:
         if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
             return false;
@@ -191,4 +262,114 @@ modem_mode DCE_Mode::get()
     return mode;
 }
 
+modem_mode DCE_Mode::guess(DTE *dte, bool with_cmux)
+{
+    Scoped<DTE> lock(*dte);
+    return guess_unsafe(dte, with_cmux);
+}
+
+/**
+ * This namespace contains probe packets and expected replies on 3 different protocols,
+ * the modem device could use (as well as timeouts and mode ids for synchronisation)
+ */
+namespace probe {
+
+namespace ppp {
+// Test that we're in the PPP mode by sending an LCP protocol echo request and expecting LCP echo reply
+constexpr std::array<uint8_t, 16> lcp_echo_request = {0x7e, 0xff, 0x03, 0xc0, 0x21, 0x09, 0x01, 0x00, 0x08, 0x99, 0xd1, 0x35, 0xc1, 0x8e, 0x2c, 0x7e };
+constexpr std::array<uint8_t, 5> lcp_echo_reply_head = {0x7e, 0xff, 0x7d, 0x23, 0xc0};
+const size_t mode = 1 << 0;
+const int timeout = 200;
+}
+
+namespace cmd {
+// For command mode, we just send a simple AT command
+const char at[] = "\r\nAT\r\n";
+const size_t max_at_reply = 16; // account for some whitespaces and/or CMUX encapsulation
+const char reply[] = { 'O', 'K' };
+const int mode = 1 << 1;
+const int timeout = 500;
+}
+
+namespace cmux {
+// For CMUX mode, we send an SABM on control terminal (0)
+const uint8_t sabm0_reqest[] = {0xf9, 0x03, 0x3f, 0x01, 0x1c, 0xf9};
+const uint8_t sabm0_reply[] = {0xf9, 0x03, 0x73, 0x01};
+const int mode = 1 << 0;
+const int timeout = 200;
+}
+};
+
+modem_mode DCE_Mode::guess_unsafe(DTE *dte, bool with_cmux)
+{
+    // placeholder for reply and its size, since it could come in pieces, and we have to cache
+    // this is captured by the lambda by reference.
+    // must make sure the lambda is cleared before exiting this function (done by dte->on_read(nullptr))
+    uint8_t reply[std::max(probe::cmd::max_at_reply, std::max(sizeof(probe::ppp::lcp_echo_request), sizeof(probe::cmux::sabm0_reply)))];
+    size_t reply_pos = 0;
+    auto signal = std::make_shared<SignalGroup>();
+    std::weak_ptr<SignalGroup> weak_signal = signal;
+    dte->on_read([weak_signal, with_cmux, &reply, &reply_pos](uint8_t *data, size_t len) {
+        // storing the response in the `reply` array and de-fragmenting
+        if (reply_pos >= sizeof(reply)) {
+            return command_result::TIMEOUT;
+        }
+        auto reply_size = std::min((size_t)sizeof(reply) - reply_pos, len);
+        ::memcpy(reply + reply_pos, data, reply_size);
+        reply_pos += reply_size;
+        ESP_LOG_BUFFER_HEXDUMP("esp-modem: guess mode data:", reply, reply_pos, ESP_LOG_DEBUG);
+
+        // Check whether the response resembles the "golden" reply (for these 3 protocols)
+        if (reply_pos >= sizeof(probe::ppp::lcp_echo_reply_head)) {
+            // check for initial 2 bytes
+            auto *ptr = static_cast<uint8_t *>(memmem(reply, reply_pos, probe::ppp::lcp_echo_reply_head.data(), 2));
+            // and check the other two bytes for protocol ID: LCP
+            if (ptr && ptr[3] == probe::ppp::lcp_echo_reply_head[3] && ptr[4] == probe::ppp::lcp_echo_reply_head[4]) {
+                if (auto signal = weak_signal.lock()) {
+                    signal->set(probe::ppp::mode);
+                }
+            }
+        }
+        if (reply_pos >= 4 && memmem(reply, reply_pos, probe::cmd::reply, sizeof(probe::cmd::reply))) {
+            if (reply[0] != 0xf9) {   // double check that the reply is not wrapped in CMUX headers
+                if (auto signal = weak_signal.lock()) {
+                    signal->set(probe::cmd::mode);
+                }
+            }
+        }
+        if (with_cmux && reply_pos >= sizeof(probe::cmux::sabm0_reply)) {
+            // checking the initial 3 bytes
+            auto *ptr = static_cast<uint8_t *>(memmem(reply, reply_pos, probe::cmux::sabm0_reply, 3));
+            // and checking that DLCI is 0 (control frame)
+            if (ptr && (ptr[3] >> 2) == 0) {
+                if (auto signal = weak_signal.lock()) {
+                    signal->set(probe::cmux::mode);
+                }
+            }
+        }
+        return command_result::TIMEOUT;
+    });
+    auto guessed = modem_mode::UNDEF;
+    // Check the PPP mode fist by sending LCP echo request
+    dte->send((uint8_t *)probe::ppp::lcp_echo_request.data(), sizeof(probe::ppp::lcp_echo_request), 0);
+    if (signal->wait(probe::ppp::mode, probe::ppp::timeout)) {
+        guessed = modem_mode::DATA_MODE;
+    } else {    // LCP echo timeout
+        // now check for AT mode
+        reply_pos = 0;
+        dte->send((uint8_t *)probe::cmd::at, sizeof(probe::cmd::at), 0);
+        if (signal->wait(probe::cmd::mode, probe::cmd::timeout)) {
+            guessed = modem_mode::COMMAND_MODE;
+        } else if (with_cmux) {     // no AT reply, check for CMUX mode (if requested)
+            reply_pos = 0;
+            dte->send((uint8_t *) probe::cmux::sabm0_reqest, sizeof(probe::cmux::sabm0_reqest), 0);
+            if (signal->wait(probe::cmux::mode, probe::cmux::timeout)) {
+                guessed = modem_mode::CMUX_MODE;
+            }
+        }
+    }
+    dte->on_read(nullptr);
+    return guessed;
+}
+
 } // esp_modem

components/esp_modem/src/esp_modem_dte.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -50,9 +50,11 @@ void DTE::set_command_callbacks()
 {
     primary_term->set_read_cb([this](uint8_t *data, size_t len) {
         Scoped<Lock> l(command_cb.line_lock);
-        if (command_cb.got_line == nullptr) {
-            return false;
+#ifndef CONFIG_ESP_MODEM_URC_HANDLER
+        if (command_cb.got_line == nullptr || command_cb.result != command_result::TIMEOUT) {
+            return false;   // this line has been processed already (got OK or FAIL previously)
         }
+#endif
         if (data) {
             // For terminals which post data directly with the callback (CMUX)
             // we cannot defragment unless we allocate, but
@@ -154,12 +156,10 @@ bool DTE::exit_cmux()
     if (!cmux_term) {
         return false;
     }
-    if (!cmux_term->deinit()) {
-        return false;
-    }
+    const bool success = cmux_term->deinit();
     exit_cmux_internal();
     cmux_term.reset();
-    return true;
+    return success;
 }
 
 void DTE::exit_cmux_internal()
@@ -223,13 +223,13 @@ bool DTE::set_mode(modem_mode m)
         }
     }
     // transitions (COMMAND|DUAL|CMUX|UNDEF) -> DATA
-    if (m == modem_mode::DATA_MODE) {
+    if (m == modem_mode::DATA_MODE || m == modem_mode::RESUME_DATA_MODE) {
         if (mode == modem_mode::CMUX_MODE || mode == modem_mode::CMUX_MANUAL_MODE || mode == modem_mode::DUAL_MODE) {
             // mode stays the same, but need to swap terminals (as command has been switched)
             secondary_term.swap(primary_term);
             set_command_callbacks();
         } else {
-            mode = m;
+            mode = modem_mode::DATA_MODE;
         }
         return true;
     }
@@ -316,6 +316,12 @@ int DTE::write(uint8_t *data, size_t len)
     return secondary_term->write(data, len);
 }
 
+int DTE::send(uint8_t *data, size_t len, int term_id)
+{
+    Terminal *term = term_id == 0 ? primary_term.get() : secondary_term.get();
+    return term->write(data, len);
+}
+
 int DTE::write(DTE_Command command)
 {
     return primary_term->write(command.data, command.len);
@@ -347,9 +353,14 @@ void DTE::on_read(got_line_cb on_read_cb)
 
 bool DTE::command_cb::process_line(uint8_t *data, size_t consumed, size_t len)
 {
-    if (result != command_result::TIMEOUT) {
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+    if (urc_handler) {
+        urc_handler(data, consumed + len);
+    }
+    if (result != command_result::TIMEOUT || got_line == nullptr) {
         return false;   // this line has been processed already (got OK or FAIL previously)
     }
+#endif
     if (memchr(data + consumed, separator, len)) {
         result = got_line(data, consumed + len);
         if (result == command_result::OK || result == command_result::FAIL) {

components/esp_modem/src/esp_modem_netif.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -87,8 +87,10 @@ void Netif::start()
         receive(data, len);
         return true;
     });
-    signal.set(PPP_STARTED);
-    esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
+    if (!signal.is_any(PPP_STARTED)) {
+        signal.set(PPP_STARTED);
+        esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
+    }
 }
 
 void Netif::stop()

components/esp_modem/src/esp_modem_uart.cpp

@@ -72,6 +72,7 @@ private:
     {
         auto t = static_cast<UartTerminal *>(task_param);
         t->task();
+        t->task_handle.task_handle = nullptr;
         vTaskDelete(nullptr);
     }
 

components/esp_modem/test/target/main/CMakeLists.txt

@@ -1,7 +1,6 @@
 idf_component_register(SRCS "pppd_test.cpp"
                             "NetworkDCE.cpp"
-        INCLUDE_DIRS "$ENV{IDF_PATH}/tools/catch"
-        REQUIRES esp_modem)
+                       REQUIRES esp_modem catch2)
 
 set_target_properties(${COMPONENT_LIB} PROPERTIES
     CXX_STANDARD 17

components/esp_modem/test/target/main/Kconfig.projbuild

@@ -16,23 +16,34 @@ menu "Test App Configuration"
     config TEST_APP_UART_TX_PIN
         int "TXD Pin Number"
         default 6
-        range 0 31
+        range 0 56
         help
             Pin number of UART TX.
 
     config TEST_APP_UART_RX_PIN
         int "RXD Pin Number"
         default 7
-        range 0 31
+        range 0 56
         help
             Pin number of UART RX.
 
-    config TEST_APP_TCP_PORT
-        int "Port of test"
-        range 0 65535
-        default 2222
+    config TEST_APP_AUTH
+        bool "Use PPP authentication"
+        select LWIP_PPP_CHAP_SUPPORT
+        default n
         help
-            The remote port to which the client will connects to
-            once the PPP connection established
+            Set to true for the PPP client to use authentication
+
+    config TEST_APP_AUTH_USERNAME
+        string "Set username for authentication"
+        default "myclient"
+        help
+            Username to authenticate the PPP connection.
+
+    config TEST_APP_AUTH_PASSWORD
+        string "Set password for authentication"
+        default "mypassword"
+        help
+            Password to authenticate the PPP connection.
 
 endmenu

components/esp_modem/test/target/main/idf_component.yml

@@ -0,0 +1,4 @@
+dependencies:
+  espressif/catch2: "*"
+  idf:
+    version: ">=4.4"

components/esp_modem/test/target/main/pppd_test.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -18,7 +18,8 @@
 #include "freertos/event_groups.h"
 
 #define CATCH_CONFIG_MAIN
-#include "catch.hpp"
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/catch_session.hpp"
 
 static const char *TAG = "pppd_test";
 static EventGroupHandle_t event_group = NULL;
@@ -94,6 +95,10 @@ extern "C" void app_main(void)
     ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_modem_event, nullptr));
     ESP_ERROR_CHECK(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, nullptr));
 
+#if CONFIG_TEST_APP_AUTH
+    esp_netif_ppp_set_auth(ppp_netif, NETIF_PPP_AUTHTYPE_CHAP, CONFIG_TEST_APP_AUTH_USERNAME, CONFIG_TEST_APP_AUTH_PASSWORD);
+#endif
+
     modem_start_network();
     Catch::Session session;
     int numFailed = session.run();

components/esp_modem/test/target/pytest_pppd.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
 from __future__ import print_function, unicode_literals
 
@@ -9,14 +9,20 @@ from threading import Event, Thread
 import netifaces
 
 
-def run_server(server_stop, port, server_ip, client_ip):
+def run_server(server_stop, port, server_ip, client_ip, auth, auth_user, auth_password):
     print('Starting PPP server on port: {}'.format(port))
     try:
         arg_list = [
             'sudo', 'pppd', port, '115200',
-            '{}:{}'.format(server_ip, client_ip), 'modem', 'local', 'noauth',
+            '{}:{}'.format(server_ip, client_ip), 'modem', 'local',
             'debug', 'nocrtscts', 'nodetach', '+ipv6'
         ]
+        if auth:
+            arg_list.extend(['auth', '+chap'])
+            subprocess.run(['sudo', 'rm', '/etc/ppp/chap-secrets'])
+            subprocess.run(f"echo '{auth_user} * {auth_password} *' | sudo tee -a /etc/ppp/chap-secrets", shell=True)
+        else:
+            arg_list.append('noauth')
         p = subprocess.Popen(arg_list, stdout=subprocess.PIPE, bufsize=1)
         while not server_stop.is_set():
             if p.poll() is not None:
@@ -51,6 +57,9 @@ def test_examples_protocol_pppos_connect(dut):
     try:
         server_ip = dut.app.sdkconfig.get('TEST_APP_PPP_SERVER_IP')
         client_ip = dut.app.sdkconfig.get('TEST_APP_PPP_CLIENT_IP')
+        auth = dut.app.sdkconfig.get('TEST_APP_AUTH')
+        auth_user = dut.app.sdkconfig.get('TEST_APP_AUTH_USERNAME')
+        auth_password = dut.app.sdkconfig.get('TEST_APP_AUTH_PASSWORD')
     except Exception:
         print(
             'ENV_TEST_FAILURE: Some mandatory configuration not found in sdkconfig'
@@ -63,7 +72,7 @@ def test_examples_protocol_pppos_connect(dut):
     # Start the PPP server
     server_stop = Event()
     t = Thread(target=run_server,
-               args=(server_stop, port, server_ip, client_ip))
+               args=(server_stop, port, server_ip, client_ip, auth, auth_user, auth_password))
     t.start()
     try:
         ppp_server_timeout = time.time() + 30

components/esp_modem/test/target/sdkconfig.ci.pppd_chap_auth

@@ -0,0 +1,5 @@
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
+CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y
+CONFIG_TEST_APP_AUTH=y

components/esp_modem/test/target/sdkconfig.defaults

@@ -1,4 +1,4 @@
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
-CONFIG_CXX_EXCEPTIONS=y
-CONFIG_PPP_SUPPORT=y
-CONFIG_ESP_MAIN_TASK_STACK_SIZE=4096
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
+CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y

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.2.3
+  version: 1.3.0
   version_files:
   - idf_component.yml

components/esp_websocket_client/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.3.0](https://github.com/espressif/esp-protocols/commits/websocket-v1.3.0)
+
+### Features
+
+- add events for begin/end thread ([d7fa24bc](https://github.com/espressif/esp-protocols/commit/d7fa24bc))
+- Make example to use certificate bundle ([aecf6f80](https://github.com/espressif/esp-protocols/commit/aecf6f80))
+- propagate esp_tls stack error and cert verify flags ([234f579b](https://github.com/espressif/esp-protocols/commit/234f579b))
+- Add option to set and use cert_common_name in Websocket client ([3a6720de](https://github.com/espressif/esp-protocols/commit/3a6720de))
+- adding support for `if_name` when using WSS transport ([333a6893](https://github.com/espressif/esp-protocols/commit/333a6893))
+- allow updating reconnect timeout for retry backoffs ([bd9f0627](https://github.com/espressif/esp-protocols/commit/bd9f0627))
+- allow using external tcp transport handle ([83ea2876](https://github.com/espressif/esp-protocols/commit/83ea2876))
+- adding support for `keep_alive_enable` when using WSS transport ([c728eae5](https://github.com/espressif/esp-protocols/commit/c728eae5))
+
+### Bug Fixes
+
+- Prevent crash on network disconnect during send ([a453ca1f](https://github.com/espressif/esp-protocols/commit/a453ca1f))
+- use proper interface to delete semaphore ([991ac40d](https://github.com/espressif/esp-protocols/commit/991ac40d))
+- Move client to different state when disconnecting ([0d8f2a6d](https://github.com/espressif/esp-protocols/commit/0d8f2a6d))
+- fix of websocket host example ([5ccc018a](https://github.com/espressif/esp-protocols/commit/5ccc018a))
+- don't get transport from the list if external transport is used ([9d4d5d2d](https://github.com/espressif/esp-protocols/commit/9d4d5d2d))
+- Fix locking issues of `esp_websocket_client_send_with_exact_opcode` API ([6393fcd7](https://github.com/espressif/esp-protocols/commit/6393fcd7))
+
 ## [1.2.3](https://github.com/espressif/esp-protocols/commits/websocket-v1.2.3)
 
 ### Features

components/esp_websocket_client/esp_websocket_client.c

@@ -95,7 +95,9 @@ typedef struct {
     size_t                      client_key_len;
     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_transport_handle_t      ext_transport;
 } websocket_config_storage_t;
 
 typedef enum {
@@ -204,6 +206,8 @@ static esp_err_t esp_websocket_client_dispatch_event(esp_websocket_client_handle
         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);
+        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);
     }
     event_data.error_handle.error_type = client->error_handle.error_type;
@@ -225,13 +229,15 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
     ESP_WS_CLIENT_STATE_CHECK(TAG, client, return ESP_FAIL);
     esp_transport_close(client->transport);
 
-    if (client->config->auto_reconnect) {
+    if (!client->config->auto_reconnect) {
+        client->run = false;
+        client->state = WEBSOCKET_STATE_UNKNOW;
+    } 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;
-    client->state = WEBSOCKET_STATE_WAIT_TIMEOUT;
     esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_DISCONNECTED, NULL, 0);
     return ESP_OK;
 }
@@ -430,7 +436,7 @@ static void destroy_and_free_resources(esp_websocket_client_handle_t client)
     if (client->transport_list) {
         esp_transport_list_destroy(client->transport_list);
     }
-    vQueueDelete(client->lock);
+    vSemaphoreDelete(client->lock);
     free(client->tx_buffer);
     free(client->rx_buffer);
     free(client->errormsg_buffer);
@@ -500,6 +506,10 @@ static esp_err_t esp_websocket_client_create_transport(esp_websocket_client_hand
         if (client->keep_alive_cfg.keep_alive_enable) {
             esp_transport_ssl_set_keep_alive(ssl, &client->keep_alive_cfg);
         }
+        if (client->if_name) {
+            esp_transport_ssl_set_interface_name(ssl, client->if_name);
+        }
+
         if (client->config->use_global_ca_store == true) {
             esp_transport_ssl_enable_global_ca_store(ssl);
         } else if (client->config->cert) {
@@ -533,6 +543,13 @@ static esp_err_t esp_websocket_client_create_transport(esp_websocket_client_hand
         if (client->config->skip_cert_common_name_check) {
             esp_transport_ssl_skip_common_name_check(ssl);
         }
+        if (client->config->cert_common_name) {
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
+            esp_transport_ssl_set_common_name(ssl, client->config->cert_common_name);
+#else
+            ESP_LOGE(TAG, "cert_common_name requires ESP-IDF 5.1.0 or later");
+#endif
+        }
 
         esp_transport_handle_t wss = esp_transport_ws_init(ssl);
         ESP_WS_CLIENT_MEM_CHECK(TAG, wss, return ESP_ERR_NO_MEM);
@@ -668,6 +685,11 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
     }
 
     // configure ssl related parameters
+    if (config->cert_common_name != NULL && config->skip_cert_common_name_check) {
+        ESP_LOGE(TAG, "Both cert_common_name and skip_cert_common_name_check are set, only one of them can be set");
+        goto _websocket_init_fail;
+    }
+
     client->config->use_global_ca_store = config->use_global_ca_store;
     client->config->cert = config->cert_pem;
     client->config->cert_len = config->cert_len;
@@ -676,7 +698,9 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
     client->config->client_key = config->client_key;
     client->config->client_key_len = config->client_key_len;
     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;
+    client->config->ext_transport = config->ext_transport;
 
     if (config->uri) {
         if (esp_websocket_client_set_uri(client, config->uri) != ESP_OK) {
@@ -935,7 +959,9 @@ static void esp_websocket_client_task(void *pv)
     client->run = true;
 
     //get transport by scheme
-    client->transport = esp_transport_list_get_transport(client->transport_list, client->config->scheme);
+    if (client->transport == NULL && client->config->ext_transport == NULL) {
+        client->transport = esp_transport_list_get_transport(client->transport_list, client->config->scheme);
+    }
 
     if (client->transport == NULL) {
         ESP_LOGE(TAG, "There are no transports valid, stop websocket client");
@@ -948,6 +974,7 @@ static void esp_websocket_client_task(void *pv)
 
     client->state = WEBSOCKET_STATE_INIT;
     xEventGroupClearBits(client->status_bits, STOPPED_BIT | CLOSE_FRAME_SENT_BIT);
+    esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_BEGIN, NULL, 0);
     int read_select = 0;
     while (client->run) {
         if (xSemaphoreTakeRecursive(client->lock, lock_timeout) != pdPASS) {
@@ -1026,10 +1053,6 @@ static void esp_websocket_client_task(void *pv)
             break;
         case WEBSOCKET_STATE_WAIT_TIMEOUT:
 
-            if (!client->config->auto_reconnect) {
-                client->run = false;
-                break;
-            }
             if (_tick_get_ms() - client->reconnect_tick_ms > client->wait_timeout_ms) {
                 client->state = WEBSOCKET_STATE_INIT;
                 client->reconnect_tick_ms = _tick_get_ms();
@@ -1060,7 +1083,9 @@ static void esp_websocket_client_task(void *pv)
                 } else {
                     esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
                 }
+                xSemaphoreTakeRecursive(client->lock, lock_timeout);
                 esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
+                xSemaphoreGiveRecursive(client->lock);
             }
         } else if (WEBSOCKET_STATE_WAIT_TIMEOUT == client->state) {
             // waiting for reconnecting...
@@ -1082,6 +1107,7 @@ static void esp_websocket_client_task(void *pv)
         }
     }
 
+    esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_FINISH, NULL, 0);
     esp_transport_close(client->transport);
     xEventGroupSetBits(client->status_bits, STOPPED_BIT);
     client->state = WEBSOCKET_STATE_UNKNOW;
@@ -1100,9 +1126,13 @@ esp_err_t esp_websocket_client_start(esp_websocket_client_handle_t client)
         ESP_LOGE(TAG, "The client has started");
         return ESP_FAIL;
     }
-    if (esp_websocket_client_create_transport(client) != ESP_OK) {
-        ESP_LOGE(TAG, "Failed to create websocket transport");
-        return ESP_FAIL;
+
+    client->transport = client->config->ext_transport;
+    if (!client->transport) {
+        if (esp_websocket_client_create_transport(client) != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to create websocket transport");
+            return ESP_FAIL;
+        }
     }
 
     if (xTaskCreate(esp_websocket_client_task, client->config->task_name ? client->config->task_name : "websocket_task",
@@ -1111,6 +1141,7 @@ esp_err_t esp_websocket_client_start(esp_websocket_client_handle_t client)
         return ESP_FAIL;
     }
     xEventGroupClearBits(client->status_bits, STOPPED_BIT | CLOSE_FRAME_SENT_BIT);
+    ESP_LOGI(TAG, "Started");
     return ESP_OK;
 }
 
@@ -1278,6 +1309,43 @@ esp_err_t esp_websocket_client_set_ping_interval_sec(esp_websocket_client_handle
     return ESP_OK;
 }
 
+int esp_websocket_client_get_reconnect_timeout(esp_websocket_client_handle_t client)
+{
+    if (client == NULL) {
+        ESP_LOGW(TAG, "Client was not initialized");
+        return -1;
+    }
+
+    if (!client->config->auto_reconnect) {
+        ESP_LOGW(TAG, "Automatic reconnect is disabled");
+        return -1;
+    }
+
+    return client->wait_timeout_ms;
+}
+
+esp_err_t esp_websocket_client_set_reconnect_timeout(esp_websocket_client_handle_t client, int reconnect_timeout_ms)
+{
+    if (client == NULL) {
+        ESP_LOGW(TAG, "Client was not initialized");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (reconnect_timeout_ms <= 0) {
+        ESP_LOGW(TAG, "Invalid reconnect timeout");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!client->config->auto_reconnect) {
+        ESP_LOGW(TAG, "Automatic reconnect is disabled");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    client->wait_timeout_ms = reconnect_timeout_ms;
+
+    return ESP_OK;
+}
+
 esp_err_t esp_websocket_register_events(esp_websocket_client_handle_t client,
                                         esp_websocket_event_id_t event,
                                         esp_event_handler_t event_handler,

components/esp_websocket_client/examples/linux/CMakeLists.txt

@@ -6,7 +6,6 @@ set(common_component_dir ../../../../common_components)
 set(EXTRA_COMPONENT_DIRS
    ../..
   "${common_component_dir}/linux_compat/esp_timer"
-  "${common_component_dir}/linux_compat"
   "${common_component_dir}/linux_compat/freertos"
    $ENV{IDF_PATH}/examples/protocols/linux_stubs/esp_stubs
    $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)

components/esp_websocket_client/examples/linux/main/CMakeLists.txt

@@ -1,6 +1,4 @@
-idf_component_register(SRCS "main.c"
-                    INCLUDE_DIRS
-                    "."
+idf_component_register(SRCS "websocket_linux.c"
                     REQUIRES esp_websocket_client protocol_examples_common)
 
 if(CONFIG_GCOV_ENABLED)

components/esp_websocket_client/examples/linux/main/websocket_linux.c

@@ -3,20 +3,13 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-#include <stdio.h>
-#include "esp_log.h"
+#include <esp_log.h>
 #include "nvs_flash.h"
 #include "protocol_examples_common.h"
 
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/semphr.h"
-#include "freertos/event_groups.h"
-
 #include "esp_websocket_client.h"
 #include "esp_system.h"
 #include "esp_event.h"
-#include "esp_log.h"
 #include "esp_netif.h"
 
 static const char *TAG = "websocket";
@@ -32,6 +25,9 @@ static void websocket_event_handler(void *handler_args, esp_event_base_t base, i
 {
     esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
     switch (event_id) {
+    case WEBSOCKET_EVENT_BEGIN:
+        ESP_LOGI(TAG, "WEBSOCKET_EVENT_BEGIN");
+        break;
     case WEBSOCKET_EVENT_CONNECTED:
         ESP_LOGI(TAG, "WEBSOCKET_EVENT_CONNECTED");
         break;
@@ -66,6 +62,9 @@ static void websocket_event_handler(void *handler_args, esp_event_base_t base, i
             log_error_if_nonzero("captured as transport's socket errno",  data->error_handle.esp_transport_sock_errno);
         }
         break;
+    case WEBSOCKET_EVENT_FINISH:
+        ESP_LOGI(TAG, "WEBSOCKET_EVENT_FINISH");
+        break;
     }
 }
 

components/esp_websocket_client/examples/target/main/CMakeLists.txt

@@ -10,12 +10,6 @@ set(EMBED_FILES "") # Initialize an empty list for files to embed
         "certs/client_key.pem")
 #endif()
 
-# For testing purpose we are using CA of wss://echo.websocket.events
-#if(CONFIG_WS_OVER_TLS_SERVER_AUTH)
-    list(APPEND EMBED_FILES
-        "certs/ca_certificate_public_domain.pem")
-#endif()
-
 # Register the component with source files, include dirs, and any conditionally added embedded files
 idf_component_register(SRCS "${SRC_FILES}"
                        INCLUDE_DIRS "${INCLUDE_DIRS}"

components/esp_websocket_client/examples/target/main/certs/ca_certificate_public_domain.pem

@@ -1,30 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw
-TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
-cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw
-WhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg
-RW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
-AoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP
-R5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx
-sxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm
-NHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg
-Z3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG
-/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC
-AYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB
-Af8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA
-FHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw
-AoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw
-Oi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB
-gt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W
-PTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl
-ikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz
-CkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm
-lJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4
-avAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2
-yJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O
-yK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids
-hCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+
-HlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv
-MldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX
-nLRbwHOoq7hHwg==
------END CERTIFICATE-----

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

@@ -19,6 +19,7 @@
 #include "nvs_flash.h"
 #include "esp_event.h"
 #include "protocol_examples_common.h"
+#include "esp_crt_bundle.h"
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
@@ -73,6 +74,9 @@ static void websocket_event_handler(void *handler_args, esp_event_base_t base, i
 {
     esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
     switch (event_id) {
+    case WEBSOCKET_EVENT_BEGIN:
+        ESP_LOGI(TAG, "WEBSOCKET_EVENT_BEGIN");
+        break;
     case WEBSOCKET_EVENT_CONNECTED:
         ESP_LOGI(TAG, "WEBSOCKET_EVENT_CONNECTED");
         break;
@@ -121,6 +125,9 @@ static void websocket_event_handler(void *handler_args, esp_event_base_t base, i
             log_error_if_nonzero("captured as transport's socket errno",  data->error_handle.esp_transport_sock_errno);
         }
         break;
+    case WEBSOCKET_EVENT_FINISH:
+        ESP_LOGI(TAG, "WEBSOCKET_EVENT_FINISH");
+        break;
     }
 }
 
@@ -159,8 +166,12 @@ static void websocket_app_start(void)
     websocket_cfg.client_key = key_start;
     websocket_cfg.client_key_len = key_end - key_start;
 #elif CONFIG_WS_OVER_TLS_SERVER_AUTH
-    extern const char cacert_start[] asm("_binary_ca_certificate_public_domain_pem_start"); // CA cert of wss://echo.websocket.event, modify it if using another server
-    websocket_cfg.cert_pem = cacert_start;
+    // Using certificate bundle as default server certificate source
+    websocket_cfg.crt_bundle_attach = esp_crt_bundle_attach;
+    // If using a custom certificate it could be added to certificate bundle, added to the build similar to client certificates in this examples,
+    // or read from NVS.
+    /* extern const char cacert_start[] asm("ADDED_CERTIFICATE"); */
+    /* websocket_cfg.cert_pem = cacert_start; */
 #endif
 
 #if CONFIG_WS_OVER_TLS_SKIP_COMMON_NAME_CHECK
@@ -211,6 +222,7 @@ static void websocket_app_start(void)
     char *long_data = malloc(size);
     memset(long_data, 'a', size);
     esp_websocket_client_send_text(client, long_data, size, portMAX_DELAY);
+    free(long_data);
 
     xSemaphoreTake(shutdown_sema, portMAX_DELAY);
     esp_websocket_client_close(client, portMAX_DELAY);