Merge pull request #750 from david-cermak/bump/ws_client

[websocket]:  Bump 1.3.0 -> 1.4.0

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

@@ -13,16 +13,16 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0", "release-v5.1"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
         idf_target: ["esp32", "esp32s2"]
         example: ["asio_chat", "async_request", "socks4", "ssl_client_server", "tcp_echo_server", "udp_echo_server"]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
       TEST_DIR: components/asio/examples
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: recursive
       - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
@@ -43,7 +43,7 @@ jobs:
         run: |
           . ${IDF_PATH}/export.sh
           esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
           path: |
@@ -64,7 +64,7 @@ jobs:
     name: Target tests
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
         idf_target: ["esp32"]
         example: ["asio_chat", "tcp_echo_server", "udp_echo_server", "ssl_client_server"]
     needs: build_asio
@@ -76,8 +76,8 @@ jobs:
     steps:
       - name: Clear repository
         run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v3
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
         with:
           name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
           path: ${{ env.TEST_DIR }}/${{ matrix.example }}/build
@@ -93,7 +93,7 @@ jobs:
         working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}
         run: |
             python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}.xml --target=${{ matrix.idf_target }}
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}

.github/workflows/clang-tidy.yml

@@ -0,0 +1,56 @@
+name: Run clang-tidy
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Run clang-tidy
+    runs-on: ubuntu-20.04
+    container: espressif/idf:latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+      - name: Install esp-clang
+        run: |
+          ${IDF_PATH}/tools/idf_tools.py --non-interactive install esp-clang
+      - name: Install clang-tidy-sarif
+        run: |
+          curl -sSL https://github.com/psastras/sarif-rs/releases/download/clang-tidy-sarif-v0.3.3/clang-tidy-sarif-x86_64-unknown-linux-gnu -o clang-tidy-sarif
+          chmod +x clang-tidy-sarif
+          curl -sSL https://raw.githubusercontent.com/espressif/idf-extra-components/master/.github/filter_sarif.py -o filter_sarif.py
+      - name: Install pyclang
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install pyclang~=0.2.0
+      - name: Run code analysis
+        shell: bash
+        env:
+          IDF_TOOLCHAIN: clang
+          IDF_TARGET: esp32
+        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 --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@v4
+        with:
+          path: |
+            warnings.txt
+            results.sarif
+            results.sarif.raw
+      - name: Upload SARIF file
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: results.sarif
+          category: clang-tidy

.github/workflows/console_cmd_ifconfig__build.yml

@@ -13,20 +13,26 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
         idf_target: ["esp32"]
         test: [ { app: ifconfig-basic, path: "components/console_cmd_ifconfig/examples"}]
-    runs-on: ubuntu-20.04
+        include:
+          - idf_ver: "latest"
+            warning: "the choice symbol ETHERNET_PHY_LAN867X\nis deprecated: Please use smi_gpio instead"
+
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: recursive
       - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          EXPECTED_WARNING: ${{ matrix.warning }}
         shell: bash
         working-directory: ${{matrix.test.path}}
         run: |
-          ${IDF_PATH}/install.sh --enable-pytest
           . ${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/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/console_cmd_ping__build.yml

@@ -13,20 +13,20 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
         idf_target: ["esp32"]
         test: [ { app: ping-basic, path: "components/console_cmd_ping/examples" }]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        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}/install.sh --enable-pytest
           . ${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/console_cmd_wifi__build.yml

@@ -13,20 +13,20 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
         idf_target: ["esp32"]
         test: [ { app: wifi-basic, path: "components/console_cmd_wifi/examples" }]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        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}/install.sh --enable-pytest
           . ${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/console_simple_init__build.yml

@@ -13,20 +13,20 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
         idf_target: ["esp32"]
         test: [ { app: console_basic, path: "components/console_simple_init/examples" }]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        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}/install.sh --enable-pytest
           . ${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/eppp__build.yml

@@ -0,0 +1,28 @@
+name: "eppp_link: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_eppp:
+    if: contains(github.event.pull_request.labels.*.name, 'eppp') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+        test: [ { app: host, path: "examples/host" }, { app: slave, path: "examples/slave" }, { app: test_app, path: "test/test_app" }]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+      - 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/eppp_link/${{matrix.test.path}} -vv --preserve-all

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

@@ -13,13 +13,18 @@ jobs:
     name: Build examples
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.1"]
-    runs-on: ubuntu-20.04
+        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@v3
+        uses: actions/checkout@v4
       - name: Build with IDF-${{ matrix.idf_ver }}
+        env:
+          EXPECTED_WARNING: ${{ matrix.warning }}
         shell: bash
         run: |
           . ${IDF_PATH}/export.sh
@@ -33,11 +38,11 @@ jobs:
     strategy:
       matrix:
         idf_ver: ["latest"]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Build with IDF-${{ matrix.idf_ver }}
         shell: bash
         run: |

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

@@ -13,20 +13,20 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.2", "release-v5.3"]
         test: [ { app: example, path: "examples/query_advertise" }, { app: unit_test, path: "tests/unit_test" }, { app: test_app, path: "tests/test_apps" } ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }}
         shell: bash
         run: |
           . ${IDF_PATH}/export.sh
           python -m pip install idf-build-apps
           # Build default configs for all targets
-          python ./ci/build_apps.py components/mdns/${{ matrix.test.path }} -r default -m components/mdns/.build-test-rules.yml -d
+          python ./ci/build_apps.py components/mdns/${{ matrix.test.path }} -r default -d
           # Build specific configs for test targets
           python ./ci/build_apps.py components/mdns/${{ matrix.test.path }}
           cd components/mdns/${{ matrix.test.path }}
@@ -34,7 +34,7 @@ jobs:
           $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
           zip -qur artifacts.zip $dir
           done
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: mdns_bin_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: components/mdns/${{ matrix.test.path }}/artifacts.zip
@@ -58,8 +58,8 @@ jobs:
     steps:
       - name: Clear repository
         run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v3
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
         with:
           name: mdns_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: components/mdns/${{ matrix.test.path }}/ci/
@@ -77,7 +77,7 @@ jobs:
             mv $dir build
             python -m pytest --log-cli-level DEBUG --junit-xml=./results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=${{ matrix.idf_target }}
             done
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml

.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
-    runs-on: ubuntu-20.04
-    container: espressif/idf:release-v5.1
+    name: Host test build
+    runs-on: ubuntu-22.04
+    container: espressif/idf:release-v5.3
 
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@master
+        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'
@@ -40,11 +43,11 @@ jobs:
         idf_ver: ["latest"]
         idf_target: ["esp32"]
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@master
+        uses: actions/checkout@v4
         with:
           path: esp-protocols
       - name: Install Necessary Libs

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

@@ -13,25 +13,18 @@ jobs:
     name: Build examples
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v4.3", "release-v4.4", "release-v5.0"]
+        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.3"
-            example: modem_tcp_client
-          - idf_ver: "release-v4.4"
-            example: modem_tcp_client
         include:
-          - idf_ver: "release-v4.3"
-            skip_config: usb
           - idf_ver: "release-v5.0"
             example: "simple_cmux_client"
             warning: "Warning: The smallest app partition is nearly full"
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+      - name: Check out code
+        uses: actions/checkout@v4
         with:
           path: protocols
       - if: ${{ matrix.skip_config }}
@@ -51,14 +44,14 @@ jobs:
     name: Build tests
     strategy:
       matrix:
-        idf_ver: ["release-v5.0", "release-v5.1", "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-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: protocols
       - name: Build ${{ matrix.test }} with IDF-${{ matrix.idf_ver }}
@@ -76,10 +69,25 @@ jobs:
     if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
     uses: "./.github/workflows/run-host-tests.yml"
     with:
-        idf_version: "release-v4.3"
+        idf_version: "latest"
         app_name: "host_modem_test"
         app_path: "esp-protocols/components/esp_modem/test/host_test"
         component_path: "esp-protocols/components/esp_modem"
         upload_artifacts: true
+        run_executable: true
+        run_coverage: true
         pre_run_script: "esp-protocols/components/esp_modem/test/host_test/env.sh"
         publish_unit_test_result: true
+
+  build_linux_example:
+    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
+    uses: "./.github/workflows/run-host-tests.yml"
+    with:
+        idf_version: "latest"
+        app_name: "linux_modem"
+        app_path: "esp-protocols/components/esp_modem/examples/linux_modem"
+        component_path: "esp-protocols/components/esp_modem"
+        upload_artifacts: true
+        run_executable: false
+        run_coverage: false
+        pre_run_script: "esp-protocols/components/esp_modem/test/host_test/env.sh"

.github/workflows/modem__target-test.yml

@@ -15,18 +15,18 @@ 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"
             test: { app: usb_a7670_s2, path: examples/pppos_client }
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
       TEST_DIR: components/esp_modem/${{ matrix.test.path }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: recursive
       - name: Build esp-modem target tests with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
@@ -42,7 +42,7 @@ jobs:
           idf.py set-target ${{ matrix.idf_target }}
           idf.py build
           $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh ${GITHUB_WORKSPACE}/${TEST_DIR}/build
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/build
@@ -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,15 +69,23 @@ 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
+      - uses: actions/download-artifact@v4
         with:
           name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/build
       - name: Run Example Test on target
-        working-directory: ${{ env.TEST_DIR }}
+        env:
+          PIP_EXTRA_INDEX_URL: "https://dl.espressif.com/pypi/"
         run: |
+            python -m venv .venv
+            source .venv/bin/activate
+            pip install --prefer-binary cryptography pytest-embedded pytest-embedded-serial-esp pytest-embedded-idf pytest-custom_exit_code esptool
+            pip install -r $GITHUB_WORKSPACE/ci/requirements.txt
+            cd ${{ env.TEST_DIR }}
             python -m pytest --log-cli-level DEBUG --target=${{ matrix.idf_target }}

.github/workflows/mosq__build.yml

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

.github/workflows/mqtt_cxx__build.yml

@@ -13,20 +13,20 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
         idf_target: ["esp32"]
         test: [ { app: mqtt-basic, path: "components/esp_mqtt_cxx/examples" }]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        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}/install.sh --enable-pytest
           . ${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/pre_commit_check.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           ref: ${{ github.base_ref }}
           fetch-depth: 20
@@ -26,7 +26,7 @@ jobs:
       - name: Set up Python environment
         uses: actions/setup-python@master
         with:
-          python-version: v3.7
+          python-version: v3.8
       - name: Install python packages
         run: |
           pip install pre-commit

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

@@ -20,7 +20,7 @@ jobs:
     if: github.repository == 'espressif/esp-protocols'
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           persist-credentials: false
           fetch-depth: 0
@@ -92,10 +92,15 @@ jobs:
             components/esp_modem;
             components/esp_mqtt_cxx;
             components/esp_websocket_client;
+            components/eppp_link;
             components/mdns;
             components/console_simple_init;
             components/console_cmd_ping;
             components/console_cmd_ifconfig;
             components/console_cmd_wifi;
+            components/console_cmd_mqtt;
+            components/mbedtls_cxx;
+            components/mosquitto;
+            components/sock_utils;
           namespace: "espressif"
           api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}

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

@@ -18,6 +18,12 @@ on:
             upload_artifacts:
                 type: boolean
                 required: true
+            run_executable:
+                type: boolean
+                required: true
+            run_coverage:
+                type: boolean
+                required: true
             pre_run_script:
                 type: string
                 required: false
@@ -28,14 +34,14 @@ on:
 jobs:
   build:
       name: Build App
-      runs-on: ubuntu-20.04
+      runs-on: ubuntu-22.04
       permissions:
         checks: write
         contents: write
       container: espressif/idf:${{inputs.idf_version}}
       steps:
         - name: Checkout esp-protocols
-          uses: actions/checkout@v3
+          uses: actions/checkout@v4
           with:
             path: esp-protocols
         - name: Build ${{ inputs.app_name }} with IDF-${{ inputs.idf_version }}
@@ -51,7 +57,11 @@ jobs:
             # The sdkconfig.ci.linux specifies Linux as the build target with apropriate settings.
             cp sdkconfig.ci.linux sdkconfig.defaults
             idf.py build
-            ./build/${{inputs.app_name}}.elf -r junit -o junit.xml
+            if [ "${{ inputs.run_executable}}" == "false" ]; then
+                echo "Executeable wasn't run"
+                exit 0
+            fi
+            ./build/${{inputs.app_name}}.elf
         - name: Publish Unit Test Result
           uses: EnricoMi/publish-unit-test-result-action@v2
           if: ${{ inputs.publish_unit_test_result }}
@@ -59,6 +69,7 @@ jobs:
             files: ${{inputs.component_path}}/**/*junit.xml
         - name: Build with Coverage Enabled
           shell: bash
+          if: ${{ inputs.run_coverage }}
           run: |
             component=$(basename ${{ inputs.component_path }})
             if [ -f "${{ inputs.pre_run_script }}" ]; then
@@ -74,9 +85,12 @@ jobs:
             ./build/${{inputs.app_name}}.elf
         - name: Run Coverage
           shell: bash
+          if: ${{ inputs.run_coverage }}
           run: |
-            apt-get update && apt-get install -y python3-pip rsync
-            python -m pip install gcovr
+            apt-get update && apt-get install -y rsync
+            python3 -m venv .venv
+            source .venv/bin/activate
+            python3 -m pip install gcovr
             cd $GITHUB_WORKSPACE/${{inputs.component_path}}
             component=$(basename ${{ inputs.component_path }})
             gcov `find . -name "$component*gcda"`
@@ -86,6 +100,7 @@ jobs:
             cp index.html ${{inputs.app_name}}_coverage_report
             cp -rf ${{inputs.app_name}}_coverage_report ${{inputs.app_name}}_coverage.xml $GITHUB_WORKSPACE
         - name: Code Coverage Summary Report
+          if: ${{ inputs.run_coverage }}
           uses: irongut/CodeCoverageSummary@v1.3.0
           with:
             filename: esp-protocols/**/${{inputs.app_name}}_coverage.xml
@@ -99,9 +114,10 @@ jobs:
             thresholds: '60 80'
         - name: Write to Job Summary
           run: cat code-coverage-results.md >> $GITHUB_STEP_SUMMARY
+          if: ${{ inputs.run_coverage }}
         - name: Upload files to artifacts for run-target job
-          uses: actions/upload-artifact@v3
-          if: ${{inputs.upload_artifacts}}
+          uses: actions/upload-artifact@v4
+          if: ${{ inputs.run_coverage }}
           with:
             name: ${{inputs.app_name}}_coverage_report
             path: |

.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/tls_cxx__build.yml

@@ -0,0 +1,30 @@
+name: "mbedtls-cxx: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_tls_cxx:
+    if: contains(github.event.pull_request.labels.*.name, 'tls_cxx') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3", "release-v5.2", "release-v5.1"]
+        test: [ { app: client, path: "examples/tls_client" }, { app: udp, path: "examples/udp_mutual_auth" }, { app: test, path: "tests/uart_mutual_auth" } ]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - 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/mbedtls_cxx/${{ matrix.test.path }} -vv --preserve-all

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

@@ -17,4 +17,6 @@ jobs:
         app_name: "websocket"
         app_path: "esp-protocols/components/esp_websocket_client/examples/linux"
         component_path: "esp-protocols/components/esp_websocket_client"
+        run_executable: true
         upload_artifacts: true
+        run_coverage: true

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

@@ -13,15 +13,15 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["release-v5.0", "release-v5.1", "latest"]
+        idf_ver: ["release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "latest"]
         test: [ { app: example, path: "examples/target" }, { app: unit_test, path: "test" } ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
       TEST_DIR: components/esp_websocket_client/${{ matrix.test.path }}
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: recursive
       - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
@@ -35,7 +35,7 @@ jobs:
           $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
           zip -qur artifacts.zip $dir
           done
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: websocket_bin_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/artifacts.zip
@@ -51,7 +51,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        idf_ver: ["release-v5.0", "release-v5.1", "latest"]
+        idf_ver: ["release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "latest"]
         idf_target: ["esp32"]
         test: [ { app: example, path: "examples/target" }, { app: unit_test, path: "test" } ]
     runs-on:
@@ -60,8 +60,8 @@ jobs:
     env:
       TEST_DIR: components/esp_websocket_client/${{ matrix.test.path }}
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v3
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
         with:
           name: websocket_bin_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/ci/
@@ -79,7 +79,7 @@ jobs:
           mv $dir build
           python -m pytest --log-cli-level DEBUG --junit-xml=./results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=${{ matrix.idf_target }}
           done
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml

.gitmodules

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

.pre-commit-config.yaml

@@ -48,10 +48,10 @@ repos:
       - id: check-copyright
         args: ['--ignore', 'ci/check_copyright_ignore.txt', '--config', 'ci/check_copyright_config.yaml']
   - repo: https://github.com/igrr/astyle_py.git
-    rev: c0013808882a15a0c0c2c1a9b5c903866c53a653
+    rev: v1.0.5
     hooks:
     -   id: astyle_py
-        args: ['--style=otbs', '--attach-namespaces', '--attach-classes', '--indent=spaces=4', '--convert-tabs', '--align-pointer=name', '--align-reference=name', '--keep-one-line-statements', '--pad-header', '--pad-oper']
+        args: ['--style=otbs', '--attach-namespaces', '--attach-classes', '--indent=spaces=4', '--convert-tabs', '--align-pointer=name', '--align-reference=name', '--keep-one-line-statements', '--pad-header', '--pad-oper', '--exclude-list=ci/ignore_astyle.txt']
   - repo: https://github.com/commitizen-tools/commitizen
     rev: v2.42.1
     hooks:
@@ -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"
-        entry: '\A(?!(feat|fix|ci|bump|test|docs)\((mdns|modem|common|console|websocket|asio|mqtt_cxx|examples)\)\:)'
+        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

@@ -49,3 +49,20 @@ Please refer to instructions in [ESP-IDF](https://github.com/espressif/esp-idf)
 ### console_cmd_wifi
 
 * Brief introduction [README](components/console_cmd_wifi/README.md)
+
+### ESP PPP Link (eppp)
+
+* Brief introduction [README](components/eppp_link/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/changelog.py

@@ -83,13 +83,14 @@ def main():
             changelog += '\n### {}\n\n'.format(sections[section])
             for it in item:
                 changelog += '- {}\n'.format(it)
-    changelog += '\n'
     filename = os.path.join(root_path, 'components', component, 'CHANGELOG.md')
     # Check if the changelog file exists.
     if not os.path.exists(filename):
         # File does not exist, create it
         with open(filename, 'w') as file:
             file.write('# Changelog\n\n')
+    else:
+        changelog += '\n'
     # insert the actual changelog to the beginning of the file, just after the title (2nd line)
     with open(filename, 'r') as orig_changelog:
         changelog_title = orig_changelog.readline(

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/check_copyright_ignore.txt

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

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
 

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

@@ -0,0 +1,6 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#pragma once

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/asio/.cz.yaml

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

components/asio/CHANGELOG.md

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

components/asio/CMakeLists.txt

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

components/asio/Kconfig

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

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

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

components/asio/idf_component.yml

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

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

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

components/asio/port/include/esp_asio_config.h

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

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

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

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

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

components/asio/port/src/asio_stub.cpp

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

components/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/console_cmd_wifi/.cz.yaml

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

components/console_cmd_wifi/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.1.0](https://github.com/espressif/esp-protocols/commits/console_cmd_wifi-v1.1.0)
+
+### Features
+
+- Added support to join pre-configured network ([bdbf16c1](https://github.com/espressif/esp-protocols/commit/bdbf16c1))
+
 ## [1.0.1](https://github.com/espressif/esp-protocols/commits/console_cmd_wifi-v1.0.1)
 
 ### Features

components/console_cmd_wifi/CMakeLists.txt

@@ -1,4 +1,8 @@
 idf_component_register(SRCS "console_wifi.c"
-                    INCLUDE_DIRS "."
-                    PRIV_REQUIRES esp_netif console esp_wifi
-                    WHOLE_ARCHIVE)
+                    INCLUDE_DIRS "include"
+                    REQUIRES lwip
+                    PRIV_REQUIRES esp_netif console esp_wifi esp_timer)
+
+if(CONFIG_WIFI_CMD_AUTO_REGISTRATION)
+    target_link_libraries(${COMPONENT_LIB} "-u console_cmd_wifi_register")
+endif()

components/console_cmd_wifi/Kconfig.projbuild

@@ -0,0 +1,22 @@
+menu "Wifi command Configuration"
+
+    config WIFI_CMD_AUTO_REGISTRATION
+        bool "Enable Console command wifi Auto-registration"
+        default y
+        help
+            Enabling this allows for the autoregistration of the wifi command.
+
+    config WIFI_CMD_NETWORK_SSID
+        string "WiFi SSID"
+        default "myssid"
+        help
+            SSID (network name) to connect to.
+
+    config WIFI_CMD_NETWORK_PASSWORD
+        string "WiFi Password"
+        default "mypassword"
+        help
+            WiFi password (WPA or WPA2) to use.
+            Can be left blank if the network has no security set.
+
+endmenu

components/console_cmd_wifi/README.md

@@ -33,12 +33,16 @@ The component offers a console with a command that enables runtime wifi configur
     ESP_ERROR_CHECK(console_cmd_start());    // Start console
     ```
 
+Note: Auto-registration of a specific plugin command can be disabled from menuconfig.
+
 ## Suported command:
 
 ### wifi:
-* ```wifi help```: Prints the help text for all wifi commands
-* ```wifi show network```: Scans and displays upto 10 available wifi networks.
-* ```wifi show sta```: Shows the details of wifi station.
-* ```wifi sta join <network ssid> <password>```: Station joins the given wifi network.
-* ```wifi sta join <network ssid>```: Station joins the given unsecured wifi network.
-* ```wifi sta leave```: Station leaves the wifi network.
+```
+ wifi help: Prints the help text for all wifi commands
+ wifi show network/sta: Scans and displays all available wifi APs./ Shows the details of wifi station.
+ wifi sta join <network ssid> <password>: Station joins the given wifi network.
+ wifi sta join <network ssid>: Station joins the given unsecured wifi network.
+ wifi sta join: Station joins the pre-configured wifi network.
+ wifi sta leave: Station leaves the wifi network.
+ ```

components/console_cmd_wifi/console_wifi.c

@@ -21,6 +21,7 @@
 
 #define DEFAULT_SCAN_LIST_SIZE 10
 
+#if CONFIG_WIFI_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,6 +31,7 @@ static const console_cmd_plugin_desc_t __attribute__((section(".console_cmd_desc
     .name = "console_cmd_wifi",
     .plugin_regd_fn = &console_cmd_wifi_register
 };
+#endif
 
 typedef struct wifi_op_t {
     char *name;
@@ -55,8 +57,9 @@ static const int CONNECTED_BIT = BIT1;
 static wifi_op_t cmd_list[] = {
     {.name = "help", .operation = wifi_help_op, .arg_cnt = 2, .start_index = 1, .help = "wifi help: Prints the help text for all wifi commands"},
     {.name = "show", .operation = wifi_show_op, .arg_cnt = 3, .start_index = 1, .help = "wifi show network/sta: Scans and displays all available wifi APs./ Shows the details of wifi station."},
-    {.name = "join",  .operation = wifi_sta_join_op,  .arg_cnt = 4, .start_index = 2, .help = "wifi sta join <network ssid> <password>: Station joins the given wifi network."},
-    {.name = "join",  .operation = wifi_sta_join_op,  .arg_cnt = 5, .start_index = 2, .help = "wifi sta join <network ssid>: Station joins the given unsecured wifi network."},
+    {.name = "join",  .operation = wifi_sta_join_op,  .arg_cnt = 5, .start_index = 2, .help = "wifi sta join <network ssid> <password>: Station joins the given wifi network."},
+    {.name = "join",  .operation = wifi_sta_join_op,  .arg_cnt = 4, .start_index = 2, .help = "wifi sta join <network ssid>: Station joins the given unsecured wifi network."},
+    {.name = "join",  .operation = wifi_sta_join_op,  .arg_cnt = 3, .start_index = 2, .help = "wifi sta join: Station joins the pre-configured wifi network."},
     {.name = "leave", .operation = wifi_sta_leave_op,  .arg_cnt = 3, .start_index = 2, .help = "wifi sta leave: Station leaves the wifi network."},
 };
 
@@ -162,7 +165,6 @@ static esp_err_t wifi_show_op(wifi_op_t *self, int argc, char *argv[])
             ESP_LOGI(TAG, "Showing Joind AP details:");
             ESP_LOGI(TAG, "*************************");
             ESP_LOGI(TAG, "SSID: %s", wifi_config.sta.ssid);
-            ESP_LOGI(TAG, "Password: %s", wifi_config.sta.password);
             ESP_LOGI(TAG, "Channel: %d", wifi_config.sta.channel);
             ESP_LOGI(TAG, "bssid: %02x:%02x:%02x:%02x:%02x:%02x", wifi_config.sta.bssid[0],
                      wifi_config.sta.bssid[1], wifi_config.sta.bssid[2], wifi_config.sta.bssid[3],
@@ -184,7 +186,13 @@ static esp_err_t wifi_sta_join_op(wifi_op_t *self, int argc, char *argv[])
         return ESP_FAIL;
     }
 
-    strlcpy((char *) wifi_config.sta.ssid, argv[self->start_index + 1], sizeof(wifi_config.sta.ssid));
+    if (self->arg_cnt == 3) {
+        strlcpy((char *) wifi_config.sta.ssid, CONFIG_WIFI_CMD_NETWORK_SSID, sizeof(wifi_config.sta.ssid));
+        strlcpy((char *) wifi_config.sta.password, CONFIG_WIFI_CMD_NETWORK_PASSWORD, sizeof(wifi_config.sta.password));
+    } else {
+        strlcpy((char *) wifi_config.sta.ssid, argv[self->start_index + 1], sizeof(wifi_config.sta.ssid));
+    }
+
     if (self->arg_cnt == 5) {
         strlcpy((char *) wifi_config.sta.password, argv[self->start_index + 2], sizeof(wifi_config.sta.password));
     }
@@ -260,7 +268,7 @@ static esp_err_t do_cmd_wifi(int argc, char **argv)
  */
 esp_err_t console_cmd_wifi_register(void)
 {
-    esp_err_t ret;
+    esp_err_t ret = ESP_OK;
     esp_console_cmd_t command = {
         .command = "wifi",
         .help = "Command for wifi configuration and monitoring\n For more info run 'wifi help'",

components/console_cmd_wifi/idf_component.yml

@@ -1,4 +1,4 @@
-version: 1.0.1
+version: 1.1.0
 url: https://github.com/espressif/esp-protocols/tree/master/components/console_cmd_wifi
 description: The component offers a console that enables runtime wifi configuration and monitoring.
 dependencies:

components/eppp_link/.cz.yaml

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

components/eppp_link/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+## [0.2.0](https://github.com/espressif/esp-protocols/commits/eppp-v0.2.0)
+
+### Features
+
+- Add support for SDIO transport ([085dd790](https://github.com/espressif/esp-protocols/commit/085dd790))
+
+### Bug Fixes
+
+- Fixed strict prototype API decl issue in SDIO ([eb09e426](https://github.com/espressif/esp-protocols/commit/eb09e426))
+- Fix SIDO host to check/clear interrupts atomically ([402176c9](https://github.com/espressif/esp-protocols/commit/402176c9))
+
+## [0.1.1](https://github.com/espressif/esp-protocols/commits/eppp-v0.1.1)
+
+### Bug Fixes
+
+- Make some common netif options configurable ([7829e8f](https://github.com/espressif/esp-protocols/commit/7829e8f))
+
+## [0.1.0](https://github.com/espressif/esp-protocols/commits/eppp-v0.1.0)
+
+### Features
+
+- Added CI job to build examples and tests ([7eefcf0](https://github.com/espressif/esp-protocols/commit/7eefcf0))
+
+### Bug Fixes
+
+- Fixed to select PPP LWIP opts which are OFF by default ([16be2f9](https://github.com/espressif/esp-protocols/commit/16be2f9))
+- Example to use iperf component from the registry ([bd6b66d](https://github.com/espressif/esp-protocols/commit/bd6b66d))
+- Fixed defalt config designated init issue in C++ ([8bd4712](https://github.com/espressif/esp-protocols/commit/8bd4712))
+
+## [0.0.1](https://github.com/espressif/esp-protocols/commits/eppp-v0.0.1)
+
+### Features
+
+- Added CI job to build examples and tests ([8686977](https://github.com/espressif/esp-protocols/commit/8686977))
+- Added support for SPI transport ([18f8452](https://github.com/espressif/esp-protocols/commit/18f8452))
+- Added support for UART transport ([ad27414](https://github.com/espressif/esp-protocols/commit/ad27414))
+- Introduced ESP-PPP-Link component ([a761039](https://github.com/espressif/esp-protocols/commit/a761039))

components/eppp_link/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS eppp_link.c eppp_sdio_slave.c eppp_sdio_host.c
+                    INCLUDE_DIRS "include"
+                    PRIV_REQUIRES esp_netif esp_driver_spi esp_driver_gpio esp_timer driver)

components/eppp_link/Kconfig

@@ -0,0 +1,70 @@
+menu "eppp_link"
+
+    config EPPP_LINK_USES_LWIP
+        bool
+        default "y"
+        select LWIP_PPP_SUPPORT
+        select LWIP_PPP_SERVER_SUPPORT
+
+    choice EPPP_LINK_DEVICE
+        prompt "Choose PPP device"
+        default EPPP_LINK_DEVICE_UART
+        help
+            Select which peripheral to use for PPP link
+
+        config EPPP_LINK_DEVICE_UART
+            bool "UART"
+            help
+                Use UART.
+
+        config EPPP_LINK_DEVICE_SPI
+            bool "SPI"
+            help
+                Use SPI.
+
+        config EPPP_LINK_DEVICE_SDIO
+            bool "SDIO"
+            depends on SOC_SDMMC_HOST_SUPPORTED || SOC_SDIO_SLAVE_SUPPORTED
+            help
+                Use SDIO.
+
+    endchoice
+
+    config EPPP_LINK_CONN_MAX_RETRY
+        int "Maximum retry"
+        default 6
+        help
+            Set the Maximum retry to infinitely avoid reconnecting
+            This is used only with the simplified API (eppp_connect()
+            and eppp_listen())
+
+    config EPPP_LINK_PACKET_QUEUE_SIZE
+        int "Packet queue size"
+        default 64
+        depends on EPPP_LINK_DEVICE_SPI
+        help
+            Size of the Tx packet queue.
+            You can decrease the number for slower bit rates.
+
+    choice EPPP_LINK_SDIO_ROLE
+        prompt "Choose SDIO host or slave"
+        depends on EPPP_LINK_DEVICE_SDIO
+        default EPPP_LINK_DEVICE_SDIO_HOST if SOC_SDMMC_HOST_SUPPORTED
+        help
+            Select which either SDIO host or slave
+
+        config EPPP_LINK_DEVICE_SDIO_HOST
+            bool "Host"
+            depends on SOC_SDMMC_HOST_SUPPORTED
+            help
+                Use SDIO host.
+
+        config EPPP_LINK_DEVICE_SDIO_SLAVE
+            bool "SLAVE"
+            depends on SOC_SDIO_SLAVE_SUPPORTED
+            help
+                Use SDIO slave.
+
+    endchoice
+
+endmenu

components/eppp_link/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

components/eppp_link/README.md

@@ -0,0 +1,57 @@
+# ESP PPP Link component (eppp_link)
+
+The component provides a general purpose connectivity engine between two microcontrollers, one acting as PPP server (slave), the other one as PPP client (host).
+This component could be used for extending network using physical serial connection. Applications could vary from providing PRC engine for multiprocessor solutions to serial connection to POSIX machine. This uses a standard PPP protocol to negotiate IP addresses and networking, so standard PPP toolset could be used, e.g. a `pppd` service on linux. Typical application is a WiFi connectivity provider for chips that do not have WiFi
+
+## Typical application
+
+Using this component we can construct a WiFi connectivity gateway on PPP channel. The below diagram depicts an application where
+PPP server is running on a WiFi capable chip with NAPT module translating packets between WiFi and PPPoS interface.
+We usually call this node a SLAVE microcontroller. The "HOST" microcontroller runs PPP client and connects only to the serial line,
+brings in the WiFi connectivity from the "SLAVE" microcontroller.
+
+```
+             SLAVE micro                                  HOST micro
+    \|/  +----------------+                           +----------------+
+     |   |                |          serial line      |                |
+     +---+ WiFi NAT PPPoS |=== UART / SPI / SDIO =====| PPPoS client   |
+         |        (server)|                           |                |
+         +----------------+                           +----------------+
+```
+
+## API
+
+### Client
+
+* `eppp_connect()` -- Simplified API. Provides the initialization, starts the task and blocks until we're connected
+
+### Server
+
+* `eppp_listen()` -- Simplified API. Provides the initialization, starts the task and blocks until the client connects
+
+### Manual actions
+
+* `eppp_init()` -- Initializes one endpoint (client/server).
+* `eppp_deinit()` -- Destroys the endpoint
+* `eppp_netif_start()` -- Starts the network, could be called after startup or whenever a connection is lost
+* `eppp_netif_stop()` --  Stops the network
+* `eppp_perform()` -- Perform one iteration of the PPP task (need to be called regularly in task-less configuration)
+
+## Throughput
+
+Tested with WiFi-NAPT example
+
+### UART @ 3Mbauds
+
+* TCP - 2Mbits/s
+* UDP - 2Mbits/s
+
+### SPI @ 16MHz
+
+* TCP - 5Mbits/s
+* UDP - 8Mbits/s
+
+### SDIO
+
+* TCP - 9Mbits/s
+* UDP - 11Mbits/s

components/eppp_link/eppp_link.c

@@ -0,0 +1,887 @@
+/*
+ * SPDX-FileCopyrightText: 2019-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <string.h>
+#include <stdint.h>
+#include "sdkconfig.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "esp_check.h"
+#include "esp_event.h"
+#include "esp_netif_ppp.h"
+#include "eppp_link.h"
+#include "esp_serial_slave_link/essl_sdio.h"
+
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+#include "driver/spi_master.h"
+#include "driver/spi_slave.h"
+#include "driver/gpio.h"
+#include "esp_timer.h"
+#include "esp_rom_crc.h"
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+#include "driver/uart.h"
+#endif
+
+static const int GOT_IPV4 = BIT0;
+static const int CONNECTION_FAILED = BIT1;
+#define CONNECT_BITS (GOT_IPV4|CONNECTION_FAILED)
+
+static EventGroupHandle_t s_event_group = NULL;
+static const char *TAG = "eppp_link";
+static int s_retry_num = 0;
+static int s_eppp_netif_count = 0; // used as a suffix for the netif key
+
+
+struct packet {
+    size_t len;
+    uint8_t *data;
+};
+
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+#define MAX_PAYLOAD 1500
+#define MIN_TRIGGER_US 20
+#define SPI_HEADER_MAGIC 0x1234
+
+static void timer_callback(void *arg);
+
+struct header {
+    uint16_t magic;
+    uint16_t size;
+    uint16_t next_size;
+    uint16_t check;
+} __attribute__((packed));
+
+enum blocked_status {
+    NONE,
+    MASTER_BLOCKED,
+    MASTER_WANTS_READ,
+    SLAVE_BLOCKED,
+    SLAVE_WANTS_WRITE,
+};
+
+#endif // CONFIG_EPPP_LINK_DEVICE_SPI
+
+struct eppp_handle {
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    QueueHandle_t out_queue;
+    QueueHandle_t ready_semaphore;
+    spi_device_handle_t spi_device;
+    spi_host_device_t spi_host;
+    int gpio_intr;
+    uint16_t next_size;
+    uint16_t transaction_size;
+    struct packet outbound;
+    enum blocked_status blocked;
+    uint32_t slave_last_edge;
+    esp_timer_handle_t timer;
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+    QueueHandle_t uart_event_queue;
+    uart_port_t uart_port;
+#endif
+    esp_netif_t *netif;
+    eppp_type_t role;
+    bool stop;
+    bool exited;
+    bool netif_stop;
+};
+
+typedef esp_err_t (*transmit_t)(void *h, void *buffer, size_t len);
+
+#if CONFIG_EPPP_LINK_DEVICE_SDIO
+esp_err_t eppp_sdio_host_tx(void *h, void *buffer, size_t len);
+esp_err_t eppp_sdio_host_rx(esp_netif_t *netif);
+esp_err_t eppp_sdio_slave_rx(esp_netif_t *netif);
+esp_err_t eppp_sdio_slave_tx(void *h, void *buffer, size_t len);
+esp_err_t eppp_sdio_host_init(struct eppp_config_sdio_s *config);
+esp_err_t eppp_sdio_slave_init(void);
+void eppp_sdio_slave_deinit(void);
+void eppp_sdio_host_deinit(void);
+#else
+static esp_err_t transmit(void *h, void *buffer, size_t len)
+{
+    struct eppp_handle *handle = h;
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    struct packet buf = { };
+    uint8_t *current_buffer = buffer;
+    size_t remaining = len;
+    do {    // TODO(IDF-9194): Refactor this loop to allocate only once and perform
+        //       fragmentation after receiving from the queue (applicable only if MTU > MAX_PAYLOAD)
+        size_t batch = remaining > MAX_PAYLOAD ? MAX_PAYLOAD : remaining;
+        buf.data = malloc(batch);
+        if (buf.data == NULL) {
+            ESP_LOGE(TAG, "Failed to allocate packet");
+            return ESP_ERR_NO_MEM;
+        }
+        buf.len = batch;
+        remaining -= batch;
+        memcpy(buf.data, current_buffer, batch);
+        current_buffer += batch;
+        BaseType_t ret = xQueueSend(handle->out_queue, &buf, 0);
+        if (ret != pdTRUE) {
+            ESP_LOGE(TAG, "Failed to queue packet to slave!");
+            return ESP_ERR_NO_MEM;
+        }
+    } while (remaining > 0);
+
+    if (handle->role == EPPP_SERVER && handle->blocked == SLAVE_BLOCKED) {
+        uint32_t now = esp_timer_get_time();
+        uint32_t diff = now - handle->slave_last_edge;
+        if (diff < MIN_TRIGGER_US) {
+            esp_rom_delay_us(MIN_TRIGGER_US - diff);
+        }
+        gpio_set_level(handle->gpio_intr, 0);
+    }
+
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+    ESP_LOG_BUFFER_HEXDUMP("ppp_uart_send", buffer, len, ESP_LOG_VERBOSE);
+    uart_write_bytes(handle->uart_port, buffer, len);
+#endif // DEVICE UART or SPI
+    return ESP_OK;
+}
+#endif
+
+static void netif_deinit(esp_netif_t *netif)
+{
+    if (netif == NULL) {
+        return;
+    }
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    if (h == NULL) {
+        return;
+    }
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    struct packet buf = { };
+    while (xQueueReceive(h->out_queue, &buf, 0) == pdTRUE) {
+        if (buf.len > 0) {
+            free(buf.data);
+        }
+    }
+    vQueueDelete(h->out_queue);
+    if (h->role == EPPP_CLIENT) {
+        vSemaphoreDelete(h->ready_semaphore);
+    }
+#endif
+    free(h);
+    esp_netif_destroy(netif);
+    if (s_eppp_netif_count > 0) {
+        s_eppp_netif_count--;
+    }
+}
+
+static esp_netif_t *netif_init(eppp_type_t role, eppp_config_t *eppp_config)
+{
+    if (s_eppp_netif_count > 9) {   // Limit to max 10 netifs, since we use "EPPPx" as the unique key (where x is 0-9)
+        ESP_LOGE(TAG, "Cannot create more than 10 instances");
+        return NULL;
+    }
+
+    // Create the object first
+    struct eppp_handle *h = calloc(1, sizeof(struct eppp_handle));
+    if (!h) {
+        ESP_LOGE(TAG, "Failed to allocate eppp_handle");
+        return NULL;
+    }
+    h->role = role;
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    h->out_queue = xQueueCreate(CONFIG_EPPP_LINK_PACKET_QUEUE_SIZE, sizeof(struct packet));
+    if (!h->out_queue) {
+        ESP_LOGE(TAG, "Failed to create the packet queue");
+        free(h);
+        return NULL;
+    }
+    if (role == EPPP_CLIENT) {
+        h->ready_semaphore = xSemaphoreCreateBinary();
+        if (!h->ready_semaphore) {
+            ESP_LOGE(TAG, "Failed to create the packet queue");
+            vQueueDelete(h->out_queue);
+            free(h);
+            return NULL;
+        }
+    }
+    h->transaction_size = 0;
+    h->outbound.data = NULL;
+    h->outbound.len = 0;
+    if (role == EPPP_SERVER) {
+        esp_timer_create_args_t args = {
+            .callback = &timer_callback,
+            .arg = h,
+            .name = "timer"
+        };
+        if (esp_timer_create(&args, &h->timer) != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to create the packet queue");
+            vQueueDelete(h->out_queue);
+            vSemaphoreDelete(h->ready_semaphore);
+            free(h);
+            return NULL;
+        }
+    }
+
+#endif
+
+    esp_netif_driver_ifconfig_t driver_cfg = {
+        .handle = h,
+#if CONFIG_EPPP_LINK_DEVICE_SDIO
+        .transmit = role == EPPP_CLIENT ? eppp_sdio_host_tx : eppp_sdio_slave_tx,
+#else
+        .transmit = transmit,
+#endif
+    };
+    const esp_netif_driver_ifconfig_t *ppp_driver_cfg = &driver_cfg;
+
+    esp_netif_inherent_config_t base_netif_cfg = ESP_NETIF_INHERENT_DEFAULT_PPP();
+    char if_key[] = "EPPP0"; // netif key needs to be unique
+    if_key[sizeof(if_key) - 2 /* 2 = two chars before the terminator */ ] += s_eppp_netif_count++;
+    base_netif_cfg.if_key = if_key;
+    if (eppp_config->ppp.netif_description) {
+        base_netif_cfg.if_desc = eppp_config->ppp.netif_description;
+    } else {
+        base_netif_cfg.if_desc = role == EPPP_CLIENT ? "pppos_client" : "pppos_server";
+    }
+    if (eppp_config->ppp.netif_prio) {
+        base_netif_cfg.route_prio = eppp_config->ppp.netif_prio;
+    }
+    esp_netif_config_t netif_ppp_config = { .base = &base_netif_cfg,
+                                            .driver = ppp_driver_cfg,
+                                            .stack = ESP_NETIF_NETSTACK_DEFAULT_PPP
+                                          };
+
+    esp_netif_t *netif = esp_netif_new(&netif_ppp_config);
+    if (!netif) {
+        ESP_LOGE(TAG, "Failed to create esp_netif");
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+        vQueueDelete(h->out_queue);
+        if (h->ready_semaphore) {
+            vSemaphoreDelete(h->ready_semaphore);
+        }
+#endif
+        free(h);
+        return NULL;
+    }
+    return netif;
+
+}
+
+esp_err_t eppp_netif_stop(esp_netif_t *netif, int stop_timeout_ms)
+{
+    esp_netif_action_disconnected(netif, 0, 0, 0);
+    esp_netif_action_stop(netif, 0, 0, 0);
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    for (int wait = 0; wait < 100; wait++) {
+        vTaskDelay(pdMS_TO_TICKS(stop_timeout_ms) / 100);
+        if (h->netif_stop) {
+            break;
+        }
+    }
+    if (!h->netif_stop) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t eppp_netif_start(esp_netif_t *netif)
+{
+    esp_netif_action_start(netif, 0, 0, 0);
+    esp_netif_action_connected(netif, 0, 0, 0);
+    return ESP_OK;
+}
+
+static int get_netif_num(esp_netif_t *netif)
+{
+    if (netif == NULL) {
+        return -1;
+    }
+    const char *ifkey = esp_netif_get_ifkey(netif);
+    if (strstr(ifkey, "EPPP") == NULL) {
+        return -1; // not our netif
+    }
+    int netif_cnt = ifkey[4] - '0';
+    if (netif_cnt < 0 || netif_cnt > 9) {
+        ESP_LOGE(TAG, "Unexpected netif key %s", ifkey);
+        return -1;
+    }
+    return  netif_cnt;
+}
+
+static void on_ppp_event(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    esp_netif_t **netif = data;
+    ESP_LOGD(TAG, "PPP status event: %" PRId32, event_id);
+    if (base == NETIF_PPP_STATUS && event_id == NETIF_PPP_ERRORUSER) {
+        ESP_LOGI(TAG, "Disconnected %d", get_netif_num(*netif));
+        struct eppp_handle *h = esp_netif_get_io_driver(*netif);
+        h->netif_stop = true;
+    }
+}
+
+static void on_ip_event(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    ip_event_got_ip_t *event = (ip_event_got_ip_t *)data;
+    esp_netif_t *netif = event->esp_netif;
+    int netif_cnt = get_netif_num(netif);
+    if (netif_cnt < 0) {
+        return;
+    }
+    if (event_id == IP_EVENT_PPP_GOT_IP) {
+        ESP_LOGI(TAG, "Got IPv4 event: Interface \"%s(%s)\" address: " IPSTR, esp_netif_get_desc(netif),
+                 esp_netif_get_ifkey(netif), IP2STR(&event->ip_info.ip));
+        xEventGroupSetBits(s_event_group, GOT_IPV4 << (netif_cnt * 2));
+    } else if (event_id == IP_EVENT_PPP_LOST_IP) {
+        ESP_LOGI(TAG, "Disconnected");
+        s_retry_num++;
+        if (s_retry_num > CONFIG_EPPP_LINK_CONN_MAX_RETRY) {
+            ESP_LOGE(TAG, "PPP Connection failed %d times, stop reconnecting.", s_retry_num);
+            xEventGroupSetBits(s_event_group, CONNECTION_FAILED << (netif_cnt * 2));
+        } else {
+            ESP_LOGI(TAG, "PPP Connection failed %d times, try to reconnect.", s_retry_num);
+            eppp_netif_start(netif);
+        }
+    }
+}
+
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+
+#define SPI_ALIGN(size) (((size) + 3U) & ~(3U))
+#define TRANSFER_SIZE SPI_ALIGN((MAX_PAYLOAD + 6))
+#define NEXT_TRANSACTION_SIZE(a,b) (((a)>(b))?(a):(b)) /* next transaction: whichever is bigger */
+
+static void IRAM_ATTR timer_callback(void *arg)
+{
+    struct eppp_handle *h = arg;
+    if (h->blocked == SLAVE_WANTS_WRITE) {
+        gpio_set_level(h->gpio_intr, 0);
+    }
+}
+
+static void IRAM_ATTR gpio_isr_handler(void *arg)
+{
+    static uint32_t s_last_time;
+    uint32_t now = esp_timer_get_time();
+    uint32_t diff = now - s_last_time;
+    if (diff < MIN_TRIGGER_US) { // debounce
+        return;
+    }
+    s_last_time = now;
+    struct eppp_handle *h = arg;
+    BaseType_t yield = false;
+
+    // Positive edge means SPI slave prepared the data
+    if (gpio_get_level(h->gpio_intr) == 1) {
+        xSemaphoreGiveFromISR(h->ready_semaphore, &yield);
+        if (yield) {
+            portYIELD_FROM_ISR();
+        }
+        return;
+    }
+
+    // Negative edge (when master blocked) means that slave wants to transmit
+    if (h->blocked == MASTER_BLOCKED) {
+        struct packet buf = { .data = NULL, .len = -1 };
+        xQueueSendFromISR(h->out_queue, &buf, &yield);
+        if (yield) {
+            portYIELD_FROM_ISR();
+        }
+    }
+}
+
+static esp_err_t deinit_master(esp_netif_t *netif)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    ESP_RETURN_ON_ERROR(spi_bus_remove_device(h->spi_device), TAG, "Failed to remove SPI bus");
+    ESP_RETURN_ON_ERROR(spi_bus_free(h->spi_host), TAG, "Failed to free SPI bus");
+    return ESP_OK;
+}
+
+static esp_err_t init_master(struct eppp_config_spi_s *config, esp_netif_t *netif)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    h->spi_host = config->host;
+    h->gpio_intr = config->intr;
+    spi_bus_config_t bus_cfg = {};
+    bus_cfg.mosi_io_num = config->mosi;
+    bus_cfg.miso_io_num = config->miso;
+    bus_cfg.sclk_io_num = config->sclk;
+    bus_cfg.quadwp_io_num = -1;
+    bus_cfg.quadhd_io_num = -1;
+    bus_cfg.max_transfer_sz = TRANSFER_SIZE;
+    bus_cfg.flags = 0;
+    bus_cfg.intr_flags = 0;
+
+    // TODO: Init and deinit SPI bus separately (per Kconfig?)
+    if (spi_bus_initialize(config->host, &bus_cfg, SPI_DMA_CH_AUTO) != ESP_OK) {
+        return ESP_FAIL;
+    }
+
+    spi_device_interface_config_t dev_cfg = {};
+    dev_cfg.clock_speed_hz = config->freq;
+    dev_cfg.mode = 0;
+    dev_cfg.spics_io_num = config->cs;
+    dev_cfg.cs_ena_pretrans = config->cs_ena_pretrans;
+    dev_cfg.cs_ena_posttrans = config->cs_ena_posttrans;
+    dev_cfg.duty_cycle_pos = 128;
+    dev_cfg.input_delay_ns = config->input_delay_ns;
+    dev_cfg.pre_cb = NULL;
+    dev_cfg.post_cb = NULL;
+    dev_cfg.queue_size = 3;
+
+    if (spi_bus_add_device(config->host, &dev_cfg, &h->spi_device) != ESP_OK) {
+        return ESP_FAIL;
+    }
+
+    //GPIO config for the handshake line.
+    gpio_config_t io_conf = {
+        .intr_type = GPIO_INTR_ANYEDGE,
+        .mode = GPIO_MODE_INPUT,
+        .pull_up_en = 1,
+        .pin_bit_mask = BIT64(config->intr),
+    };
+
+    gpio_config(&io_conf);
+    gpio_install_isr_service(0);
+    gpio_set_intr_type(config->intr, GPIO_INTR_ANYEDGE);
+    gpio_isr_handler_add(config->intr, gpio_isr_handler, esp_netif_get_io_driver(netif));
+    return ESP_OK;
+}
+
+static void post_setup(spi_slave_transaction_t *trans)
+{
+    struct eppp_handle *h = trans->user;
+    h->slave_last_edge = esp_timer_get_time();
+    gpio_set_level(h->gpio_intr, 1);
+    if (h->transaction_size == 0) { // If no transaction planned:
+        if (h->outbound.len == 0) { // we're blocked if we don't have any data
+            h->blocked = SLAVE_BLOCKED;
+        } else {
+            h->blocked = SLAVE_WANTS_WRITE; // we notify the master that we want to write
+            esp_timer_start_once(h->timer, MIN_TRIGGER_US);
+        }
+    }
+}
+
+static void post_trans(spi_slave_transaction_t *trans)
+{
+    struct eppp_handle *h = trans->user;
+    h->blocked = NONE;
+    gpio_set_level(h->gpio_intr, 0);
+}
+
+static esp_err_t deinit_slave(esp_netif_t *netif)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    ESP_RETURN_ON_ERROR(spi_slave_free(h->spi_host), TAG, "Failed to free SPI slave host");
+    ESP_RETURN_ON_ERROR(spi_bus_remove_device(h->spi_device), TAG, "Failed to remove SPI device");
+    ESP_RETURN_ON_ERROR(spi_bus_free(h->spi_host), TAG, "Failed to free SPI bus");
+    return ESP_OK;
+}
+
+static esp_err_t init_slave(struct eppp_config_spi_s *config, esp_netif_t *netif)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    h->spi_host = config->host;
+    h->gpio_intr = config->intr;
+    spi_bus_config_t bus_cfg = {};
+    bus_cfg.mosi_io_num = config->mosi;
+    bus_cfg.miso_io_num = config->miso;
+    bus_cfg.sclk_io_num = config->sclk;
+    bus_cfg.quadwp_io_num = -1;
+    bus_cfg.quadhd_io_num = -1;
+    bus_cfg.flags = 0;
+    bus_cfg.intr_flags = 0;
+
+    //Configuration for the SPI slave interface
+    spi_slave_interface_config_t slvcfg = {
+        .mode = 0,
+        .spics_io_num = config->cs,
+        .queue_size = 3,
+        .flags = 0,
+        .post_setup_cb = post_setup,
+        .post_trans_cb = post_trans,
+    };
+
+    //Configuration for the handshake line
+    gpio_config_t io_conf = {
+        .intr_type = GPIO_INTR_DISABLE,
+        .mode = GPIO_MODE_OUTPUT,
+        .pin_bit_mask = BIT64(config->intr),
+    };
+
+    gpio_config(&io_conf);
+    gpio_set_pull_mode(config->mosi, GPIO_PULLUP_ONLY);
+    gpio_set_pull_mode(config->sclk, GPIO_PULLUP_ONLY);
+    gpio_set_pull_mode(config->cs, GPIO_PULLUP_ONLY);
+
+    //Initialize SPI slave interface
+    if (spi_slave_initialize(config->host, &bus_cfg, &slvcfg, SPI_DMA_CH_AUTO) != ESP_OK) {
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
+typedef esp_err_t (*perform_transaction_t)(struct eppp_handle *h, size_t len, const void *tx_buffer, void *rx_buffer);
+
+static esp_err_t perform_transaction_master(struct eppp_handle *h, size_t len, const void *tx_buffer, void *rx_buffer)
+{
+    spi_transaction_t t = {};
+    t.length = len * 8;
+    t.tx_buffer = tx_buffer;
+    t.rx_buffer = rx_buffer;
+    return spi_device_transmit(h->spi_device, &t);
+}
+
+static esp_err_t perform_transaction_slave(struct eppp_handle *h, size_t len, const void *tx_buffer, void *rx_buffer)
+{
+    spi_slave_transaction_t t = {};
+    t.user = h;
+    t.length = len * 8;
+    t.tx_buffer = tx_buffer;
+    t.rx_buffer = rx_buffer;
+    return spi_slave_transmit(h->spi_host, &t, portMAX_DELAY);
+}
+
+esp_err_t eppp_perform(esp_netif_t *netif)
+{
+    static WORD_ALIGNED_ATTR uint8_t out_buf[TRANSFER_SIZE] = {};
+    static WORD_ALIGNED_ATTR uint8_t in_buf[TRANSFER_SIZE] = {};
+
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+
+    // Perform transaction for master and slave
+    const perform_transaction_t perform_transaction = h->role == EPPP_CLIENT ? perform_transaction_master : perform_transaction_slave;
+
+    if (h->stop) {
+        return ESP_ERR_TIMEOUT;
+    }
+
+    BaseType_t tx_queue_stat;
+    bool allow_test_tx = false;
+    uint16_t next_tx_size = 0;
+    if (h->role == EPPP_CLIENT) {
+        // SPI MASTER only code
+        if (xSemaphoreTake(h->ready_semaphore, pdMS_TO_TICKS(1000)) != pdTRUE) {
+            // slave might not be ready, but maybe we just missed an interrupt
+            allow_test_tx = true;
+        }
+        if (h->outbound.len == 0 && h->transaction_size == 0 && h->blocked == NONE) {
+            h->blocked = MASTER_BLOCKED;
+            xQueueReceive(h->out_queue, &h->outbound, portMAX_DELAY);
+            h->blocked = NONE;
+            if (h->outbound.len == -1) {
+                h->outbound.len = 0;
+                h->blocked = MASTER_WANTS_READ;
+            }
+        } else if (h->blocked == MASTER_WANTS_READ) {
+            h->blocked = NONE;
+        }
+    }
+    struct header *head = (void *)out_buf;
+    if (h->outbound.len <= h->transaction_size && allow_test_tx == false) {
+        // sending outbound
+        head->size = h->outbound.len;
+        if (h->outbound.len > 0) {
+            memcpy(out_buf + sizeof(struct header), h->outbound.data, h->outbound.len);
+            free(h->outbound.data);
+            ESP_LOG_BUFFER_HEXDUMP(TAG, out_buf + sizeof(struct header), head->size, ESP_LOG_VERBOSE);
+            h->outbound.data = NULL;
+            h->outbound.len = 0;
+        }
+        do {
+            tx_queue_stat = xQueueReceive(h->out_queue, &h->outbound, 0);
+        } while (tx_queue_stat == pdTRUE && h->outbound.len == -1);
+        if (h->outbound.len == -1) { // used as a signal only, no actual data
+            h->outbound.len = 0;
+        }
+    } else {
+        // outbound is bigger, need to transmit in another transaction (keep this empty)
+        head->size = 0;
+    }
+    next_tx_size = head->next_size = h->outbound.len;
+    head->magic = SPI_HEADER_MAGIC;
+    head->check = esp_rom_crc16_le(0, out_buf, sizeof(struct header) - sizeof(uint16_t));
+    esp_err_t ret = perform_transaction(h, sizeof(struct header) + h->transaction_size, out_buf, in_buf);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "spi_device_transmit failed");
+        h->transaction_size = 0; // need to start with HEADER only transaction
+        return ESP_FAIL;
+    }
+    head = (void *)in_buf;
+    uint16_t check = esp_rom_crc16_le(0, in_buf, sizeof(struct header) - sizeof(uint16_t));
+    if (check != head->check || head->magic != SPI_HEADER_MAGIC) {
+        h->transaction_size = 0; // need to start with HEADER only transaction
+        if (allow_test_tx) {
+            return ESP_OK;
+        }
+        ESP_LOGE(TAG, "Wrong checksum or magic");
+        return ESP_FAIL;
+    }
+    if (head->size > 0) {
+        ESP_LOG_BUFFER_HEXDUMP(TAG, in_buf + sizeof(struct header), head->size, ESP_LOG_VERBOSE);
+        esp_netif_receive(netif, in_buf + sizeof(struct header), head->size, NULL);
+    }
+    h->transaction_size = NEXT_TRANSACTION_SIZE(next_tx_size, head->next_size);
+    return ESP_OK;
+}
+
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+#define BUF_SIZE (1024)
+
+static esp_err_t init_uart(struct eppp_handle *h, eppp_config_t *config)
+{
+    h->uart_port = config->uart.port;
+    uart_config_t uart_config = {};
+    uart_config.baud_rate = config->uart.baud;
+    uart_config.data_bits = UART_DATA_8_BITS;
+    uart_config.parity    = UART_PARITY_DISABLE;
+    uart_config.stop_bits = UART_STOP_BITS_1;
+    uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
+    uart_config.source_clk = UART_SCLK_DEFAULT;
+
+    ESP_RETURN_ON_ERROR(uart_driver_install(h->uart_port, config->uart.rx_buffer_size, 0, config->uart.queue_size, &h->uart_event_queue, 0), TAG, "Failed to install UART");
+    ESP_RETURN_ON_ERROR(uart_param_config(h->uart_port, &uart_config), TAG, "Failed to set params");
+    ESP_RETURN_ON_ERROR(uart_set_pin(h->uart_port, config->uart.tx_io, config->uart.rx_io, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE), TAG, "Failed to set UART pins");
+    ESP_RETURN_ON_ERROR(uart_set_rx_timeout(h->uart_port, 1), TAG, "Failed to set UART Rx timeout");
+    return ESP_OK;
+}
+
+static void deinit_uart(struct eppp_handle *h)
+{
+    uart_driver_delete(h->uart_port);
+}
+
+esp_err_t eppp_perform(esp_netif_t *netif)
+{
+    static uint8_t buffer[BUF_SIZE] = {};
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    uart_event_t event = {};
+    if (h->stop) {
+        return ESP_ERR_TIMEOUT;
+    }
+
+    if (xQueueReceive(h->uart_event_queue, &event, pdMS_TO_TICKS(100)) != pdTRUE) {
+        return ESP_OK;
+    }
+    if (event.type == UART_DATA) {
+        size_t len;
+        uart_get_buffered_data_len(h->uart_port, &len);
+        if (len) {
+            len = uart_read_bytes(h->uart_port, buffer, BUF_SIZE, 0);
+            ESP_LOG_BUFFER_HEXDUMP("ppp_uart_recv", buffer, len, ESP_LOG_VERBOSE);
+            esp_netif_receive(netif, buffer, len, NULL);
+        }
+    } else {
+        ESP_LOGW(TAG, "Received UART event: %d", event.type);
+    }
+    return ESP_OK;
+}
+#elif CONFIG_EPPP_LINK_DEVICE_SDIO
+
+esp_err_t eppp_perform(esp_netif_t *netif)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    if (h->stop) {
+        return ESP_ERR_TIMEOUT;
+    }
+    if (h->role == EPPP_SERVER) {
+        return eppp_sdio_slave_rx(netif);
+    } else {
+        return eppp_sdio_host_rx(netif);
+    }
+}
+
+#endif // CONFIG_EPPP_LINK_DEVICE_SPI / UART
+
+static void ppp_task(void *args)
+{
+    esp_netif_t *netif = args;
+    while (eppp_perform(netif) != ESP_ERR_TIMEOUT) {}
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    h->exited = true;
+    vTaskDelete(NULL);
+}
+
+static bool have_some_eppp_netif(esp_netif_t *netif, void *ctx)
+{
+    return get_netif_num(netif) > 0;
+}
+
+static void remove_handlers(void)
+{
+    esp_netif_t *netif = esp_netif_find_if(have_some_eppp_netif, NULL);
+    if (netif == NULL) {
+        // if EPPP netif in the system, we cleanup the statics
+        vEventGroupDelete(s_event_group);
+        s_event_group = NULL;
+        esp_event_handler_unregister(IP_EVENT, ESP_EVENT_ANY_ID, on_ip_event);
+        esp_event_handler_unregister(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, on_ppp_event);
+    }
+}
+
+void eppp_deinit(esp_netif_t *netif)
+{
+    if (netif == NULL) {
+        return;
+    }
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    if (h->role == EPPP_CLIENT) {
+        deinit_master(netif);
+    } else {
+        deinit_slave(netif);
+    }
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+    deinit_uart(esp_netif_get_io_driver(netif));
+#elif CONFIG_EPPP_LINK_DEVICE_SDIO
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    if (h->role == EPPP_CLIENT) {
+        eppp_sdio_host_deinit();
+    } else {
+        eppp_sdio_slave_deinit();
+    }
+#endif
+    netif_deinit(netif);
+}
+
+esp_netif_t *eppp_init(eppp_type_t role, eppp_config_t *config)
+{
+    if (config == NULL || (role != EPPP_SERVER && role != EPPP_CLIENT)) {
+        ESP_LOGE(TAG, "Invalid configuration or role");
+        return NULL;
+    }
+
+    esp_netif_t *netif = netif_init(role, config);
+    if (!netif) {
+        ESP_LOGE(TAG, "Failed to initialize PPP netif");
+        return NULL;
+    }
+    esp_netif_ppp_config_t netif_params;
+    ESP_ERROR_CHECK(esp_netif_ppp_get_params(netif, &netif_params));
+    netif_params.ppp_our_ip4_addr = config->ppp.our_ip4_addr;
+    netif_params.ppp_their_ip4_addr = config->ppp.their_ip4_addr;
+    netif_params.ppp_error_event_enabled = true;
+    ESP_ERROR_CHECK(esp_netif_ppp_set_params(netif, &netif_params));
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    if (role == EPPP_CLIENT) {
+        init_master(&config->spi, netif);
+    } else {
+        init_slave(&config->spi, netif);
+
+    }
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+    init_uart(esp_netif_get_io_driver(netif), config);
+#elif CONFIG_EPPP_LINK_DEVICE_SDIO
+    esp_err_t ret;
+    if (role == EPPP_SERVER) {
+        ret = eppp_sdio_slave_init();
+    } else {
+        ret = eppp_sdio_host_init(&config->sdio);
+    }
+
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to initialize SDIO %d", ret);
+        return NULL;
+    }
+#endif
+    return netif;
+}
+
+esp_netif_t *eppp_open(eppp_type_t role, eppp_config_t *config, int connect_timeout_ms)
+{
+    if (config == NULL || (role != EPPP_SERVER && role != EPPP_CLIENT)) {
+        ESP_LOGE(TAG, "Invalid configuration or role");
+        return NULL;
+    }
+#if CONFIG_EPPP_LINK_DEVICE_UART
+    if (config->transport != EPPP_TRANSPORT_UART) {
+        ESP_LOGE(TAG, "Invalid transport: UART device must be enabled in Kconfig");
+        return NULL;
+    }
+#endif
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    if (config->transport != EPPP_TRANSPORT_SPI) {
+        ESP_LOGE(TAG, "Invalid transport: SPI device must be enabled in Kconfig");
+        return NULL;
+    }
+#endif
+#if CONFIG_EPPP_LINK_DEVICE_SDIO
+    if (config->transport != EPPP_TRANSPORT_SDIO) {
+        ESP_LOGE(TAG, "Invalid transport: SDIO device must be enabled in Kconfig");
+        return NULL;
+    }
+#endif
+
+    if (config->task.run_task == false) {
+        ESP_LOGE(TAG, "task.run_task == false is invalid in this API. Please use eppp_init()");
+        return NULL;
+    }
+    if (s_event_group == NULL) {
+        s_event_group = xEventGroupCreate();
+        if (esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_ip_event, NULL) != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to register IP event handler");
+            remove_handlers();
+            return NULL;
+        }
+        if (esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, on_ppp_event, NULL) !=  ESP_OK) {
+            ESP_LOGE(TAG, "Failed to register PPP status handler");
+            remove_handlers();
+            return NULL;
+        }
+    }
+    esp_netif_t *netif = eppp_init(role, config);
+    if (!netif) {
+        remove_handlers();
+        return NULL;
+    }
+
+    eppp_netif_start(netif);
+
+    if (xTaskCreate(ppp_task, "ppp connect", config->task.stack_size, netif, config->task.priority, NULL) != pdTRUE) {
+        ESP_LOGE(TAG, "Failed to create a ppp connection task");
+        eppp_deinit(netif);
+        return NULL;
+    }
+    int netif_cnt = get_netif_num(netif);
+    if (netif_cnt < 0) {
+        eppp_close(netif);
+        return NULL;
+    }
+    ESP_LOGI(TAG, "Waiting for IP address %d", netif_cnt);
+    EventBits_t bits = xEventGroupWaitBits(s_event_group, CONNECT_BITS << (netif_cnt * 2), pdFALSE, pdFALSE, pdMS_TO_TICKS(connect_timeout_ms));
+    if (bits & (CONNECTION_FAILED << (netif_cnt * 2))) {
+        ESP_LOGE(TAG, "Connection failed!");
+        eppp_close(netif);
+        return NULL;
+    }
+    ESP_LOGI(TAG, "Connected! %d", netif_cnt);
+    return netif;
+}
+
+esp_netif_t *eppp_connect(eppp_config_t *config)
+{
+    return eppp_open(EPPP_CLIENT, config, portMAX_DELAY);
+}
+
+esp_netif_t *eppp_listen(eppp_config_t *config)
+{
+    return eppp_open(EPPP_SERVER, config, portMAX_DELAY);
+}
+
+void eppp_close(esp_netif_t *netif)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    if (eppp_netif_stop(netif, 60000) != ESP_OK) {
+        ESP_LOGE(TAG, "Network didn't exit cleanly");
+    }
+    h->stop = true;
+    for (int wait = 0; wait < 100; wait++) {
+        vTaskDelay(pdMS_TO_TICKS(10));
+        if (h->exited) {
+            break;
+        }
+    }
+    if (!h->exited) {
+        ESP_LOGE(TAG, "Cannot stop ppp_task");
+    }
+    eppp_deinit(netif);
+    remove_handlers();
+}

components/eppp_link/eppp_sdio.h

@@ -0,0 +1,19 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#define MAX_SDIO_PAYLOAD 1500
+#define SDIO_ALIGN(size) (((size) + 3U) & ~(3U))
+#define SDIO_PAYLOAD SDIO_ALIGN(MAX_SDIO_PAYLOAD)
+#define PPP_SOF 0x7E
+
+// Interrupts and registers
+#define SLAVE_INTR      0
+#define SLAVE_REG_REQ   0
+
+// Requests from host to slave
+#define REQ_RESET 1
+#define REQ_INIT  2

components/eppp_link/eppp_sdio_host.c

@@ -0,0 +1,200 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <string.h>
+#include <stdint.h>
+#include "sdkconfig.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "driver/sdio_slave.h"
+#include "esp_serial_slave_link/essl_sdio.h"
+#include "eppp_sdio.h"
+#include "driver/sdmmc_host.h"
+#include "sdmmc_cmd.h"
+#include "esp_check.h"
+#include "eppp_link.h"
+
+#if CONFIG_EPPP_LINK_DEVICE_SDIO_HOST
+
+// For blocking operations
+#define TIMEOUT_MAX   UINT32_MAX
+// Short timeout for sending/receiving ESSL packets
+#define PACKET_TIMEOUT_MS   50
+
+static const char *TAG = "eppp_sdio_host";
+static SemaphoreHandle_t s_essl_mutex = NULL;
+static essl_handle_t s_essl = NULL;
+static sdmmc_card_t *s_card = NULL;
+
+static DRAM_DMA_ALIGNED_ATTR uint8_t send_buffer[SDIO_PAYLOAD];
+static DMA_ATTR uint8_t rcv_buffer[SDIO_PAYLOAD];
+
+esp_err_t eppp_sdio_host_tx(void *h, void *buffer, size_t len)
+{
+    if (s_essl == NULL || s_essl_mutex == NULL) {
+        // silently skip the Tx if the SDIO not fully initialized
+        return ESP_OK;
+    }
+
+    memcpy(send_buffer, buffer, len);
+    size_t send_len = SDIO_ALIGN(len);
+    if (send_len > len) {
+        // pad with SOF's
+        memset(&send_buffer[len], PPP_SOF, send_len - len);
+    }
+    xSemaphoreTake(s_essl_mutex, portMAX_DELAY);
+    esp_err_t ret = essl_send_packet(s_essl, send_buffer, send_len, PACKET_TIMEOUT_MS);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Slave not ready to receive packet %x", ret);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        ret = ESP_ERR_NO_MEM; // to inform the upper layers
+    }
+    ESP_LOG_BUFFER_HEXDUMP(TAG, send_buffer, send_len, ESP_LOG_VERBOSE);
+    xSemaphoreGive(s_essl_mutex);
+    return ret;
+}
+
+static esp_err_t request_slave_reset(void)
+{
+    esp_err_t ret = ESP_OK;
+    ESP_LOGI(TAG, "send reset to slave...");
+    ESP_GOTO_ON_ERROR(essl_write_reg(s_essl, SLAVE_REG_REQ, REQ_RESET, NULL, TIMEOUT_MAX), err, TAG, "write-reg failed");
+    ESP_GOTO_ON_ERROR(essl_send_slave_intr(s_essl, BIT(SLAVE_INTR), TIMEOUT_MAX), err, TAG, "send-intr failed");
+    vTaskDelay(pdMS_TO_TICKS(PACKET_TIMEOUT_MS));
+    ESP_GOTO_ON_ERROR(essl_wait_for_ready(s_essl, TIMEOUT_MAX), err, TAG, "wait-for-ready failed");
+    ESP_LOGI(TAG, "slave io ready");
+err:
+    return ret;
+}
+
+esp_err_t eppp_sdio_host_init(struct eppp_config_sdio_s *eppp_config)
+{
+    esp_err_t ret = ESP_OK;
+
+    ESP_GOTO_ON_ERROR(sdmmc_host_init(), err, TAG, "sdmmc host init failed");
+
+    // configure SDIO interface and slot
+    sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
+    slot_config.width = eppp_config->width;
+#ifdef CONFIG_SOC_SDMMC_USE_GPIO_MATRIX
+    slot_config.clk = eppp_config->clk;
+    slot_config.cmd = eppp_config->cmd;
+    slot_config.d0  = eppp_config->d0;
+    slot_config.d1  = eppp_config->d1;
+    slot_config.d2  = eppp_config->d2;
+    slot_config.d3  = eppp_config->d3;
+#endif
+
+    ESP_GOTO_ON_ERROR(sdmmc_host_init_slot(SDMMC_HOST_SLOT_1, &slot_config), err, TAG, "init sdmmc host slot failed");
+
+    sdmmc_host_t config = SDMMC_HOST_DEFAULT();
+    config.flags = SDMMC_HOST_FLAG_4BIT;
+    config.flags |= SDMMC_HOST_FLAG_ALLOC_ALIGNED_BUF;
+    config.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
+
+    s_card = (sdmmc_card_t *)malloc(sizeof(sdmmc_card_t));
+    ESP_GOTO_ON_FALSE(s_card, ESP_ERR_NO_MEM, err, TAG, "card allocation failed");
+    ESP_GOTO_ON_ERROR(sdmmc_card_init(&config, s_card), err, TAG, "sdmmc card init failed");
+
+    essl_sdio_config_t ser_config = {
+        .card = s_card,
+        .recv_buffer_size = SDIO_PAYLOAD,
+    };
+    ESP_GOTO_ON_FALSE(essl_sdio_init_dev(&s_essl, &ser_config) == ESP_OK && s_essl, ESP_FAIL, err, TAG, "essl_sdio_init_dev failed");
+    ESP_GOTO_ON_ERROR(essl_init(s_essl, TIMEOUT_MAX), err, TAG, "essl-init failed");
+    ESP_GOTO_ON_ERROR(request_slave_reset(), err, TAG, "failed to reset the slave");
+    ESP_GOTO_ON_FALSE((s_essl_mutex = xSemaphoreCreateMutex()), ESP_ERR_NO_MEM, err, TAG, "failed to create semaphore");
+    return ret;
+
+err:
+    essl_sdio_deinit_dev(s_essl);
+    s_essl = NULL;
+    return ret;
+}
+
+static esp_err_t get_intr(uint32_t *out_raw)
+{
+    esp_err_t ret = ESP_OK;
+    ESP_GOTO_ON_ERROR(essl_get_intr(s_essl, out_raw, NULL, 0), err, TAG, "essl-get-int failed");
+    ESP_GOTO_ON_ERROR(essl_clear_intr(s_essl, *out_raw, 0), err, TAG, "essl-clear-int failed");
+    ESP_LOGD(TAG, "intr: %08"PRIX32, *out_raw);
+err:
+    return ret;
+}
+
+esp_err_t eppp_sdio_host_rx(esp_netif_t *netif)
+{
+    uint32_t intr;
+    esp_err_t err = essl_wait_int(s_essl, TIMEOUT_MAX);
+    if (err == ESP_ERR_TIMEOUT) {
+        return ESP_OK;
+    }
+    xSemaphoreTake(s_essl_mutex, portMAX_DELAY);
+    err = get_intr(&intr);
+    if (err == ESP_ERR_TIMEOUT) {
+        xSemaphoreGive(s_essl_mutex);
+        return ESP_OK;
+    }
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "failed to check for interrupts %d", err);
+        xSemaphoreGive(s_essl_mutex);
+        return ESP_FAIL;
+    }
+    if (intr & ESSL_SDIO_DEF_ESP32.new_packet_intr_mask) {
+        esp_err_t ret;
+        do {
+            size_t size_read = SDIO_PAYLOAD;
+            ret = essl_get_packet(s_essl, rcv_buffer, SDIO_PAYLOAD, &size_read, PACKET_TIMEOUT_MS);
+            if (ret == ESP_ERR_NOT_FOUND) {
+                ESP_LOGE(TAG, "interrupt but no data can be read");
+                break;
+            } else if (ret == ESP_OK) {
+                ESP_LOGD(TAG, "receive data, size: %d", size_read);
+                ESP_LOG_BUFFER_HEXDUMP(TAG, rcv_buffer, size_read, ESP_LOG_VERBOSE);
+                esp_netif_receive(netif, rcv_buffer, size_read, NULL);
+                break;
+            } else {
+                ESP_LOGE(TAG, "rx packet error: %08X", ret);
+                if (request_slave_reset() != ESP_OK) {
+                    ESP_LOGE(TAG, "Failed to request slave reset %x", ret);
+                    break;
+                }
+            }
+        } while (ret == ESP_ERR_NOT_FINISHED);
+    }
+    xSemaphoreGive(s_essl_mutex);
+    return ESP_OK;
+}
+
+void eppp_sdio_host_deinit(void)
+{
+    essl_sdio_deinit_dev(s_essl);
+    sdmmc_host_deinit();
+    free(s_card);
+    s_card = NULL;
+    s_essl = NULL;
+}
+
+#else // SDMMC_HOST NOT-SUPPORTED
+
+esp_err_t eppp_sdio_host_tx(void *handle, void *buffer, size_t len)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t eppp_sdio_host_rx(esp_netif_t *netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+void eppp_sdio_host_deinit(void)
+{
+}
+
+esp_err_t eppp_sdio_host_init(struct eppp_config_sdio_s *config)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+#endif // CONFIG_SOC_SDIO_SLAVE_SUPPORTED

components/eppp_link/eppp_sdio_slave.c

@@ -0,0 +1,174 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <string.h>
+#include <stdint.h>
+#include "sdkconfig.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "driver/sdio_slave.h"
+#include "eppp_sdio.h"
+#include "esp_check.h"
+
+#if CONFIG_EPPP_LINK_DEVICE_SDIO_SLAVE
+#define BUFFER_NUM 4
+#define BUFFER_SIZE SDIO_PAYLOAD
+static const char *TAG = "eppp_sdio_slave";
+static DMA_ATTR uint8_t sdio_slave_rx_buffer[BUFFER_NUM][BUFFER_SIZE];
+static DMA_ATTR uint8_t sdio_slave_tx_buffer[SDIO_PAYLOAD];
+static int s_slave_request = 0;
+
+esp_err_t eppp_sdio_slave_tx(void *h, void *buffer, size_t len)
+{
+    if (s_slave_request != REQ_INIT) {
+        // silently skip the Tx if the SDIO not fully initialized
+        return ESP_OK;
+    }
+    memcpy(sdio_slave_tx_buffer, buffer, len);
+    size_t send_len = SDIO_ALIGN(len);
+    if (send_len > len) {
+        // pad with SOF's if the size is not 4 bytes aligned
+        memset(&sdio_slave_tx_buffer[len], PPP_SOF, send_len - len);
+    }
+
+    ESP_LOG_BUFFER_HEXDUMP(TAG, sdio_slave_tx_buffer, send_len, ESP_LOG_VERBOSE);
+    esp_err_t ret = sdio_slave_transmit(sdio_slave_tx_buffer, send_len);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "sdio slave transmit error, ret : 0x%x", ret);
+        // to inform the upper layers
+        return ESP_ERR_NO_MEM;
+    }
+    return ESP_OK;
+}
+
+static esp_err_t slave_reset(void)
+{
+    esp_err_t ret = ESP_OK;
+    ESP_LOGI(TAG, "SDIO slave reset");
+    sdio_slave_stop();
+    ESP_GOTO_ON_ERROR(sdio_slave_reset(), err, TAG, "slave reset failed");
+    ESP_GOTO_ON_ERROR(sdio_slave_start(), err, TAG, "slave start failed");
+
+    while (1) {
+        sdio_slave_buf_handle_t handle;
+        ret = sdio_slave_send_get_finished(&handle, 0);
+        if (ret == ESP_ERR_TIMEOUT) {
+            break;
+        }
+        ESP_GOTO_ON_ERROR(ret, err, TAG, "slave-get-finished failed");
+        ESP_GOTO_ON_ERROR(sdio_slave_recv_load_buf(handle), err, TAG, "slave-load-buf failed");
+    }
+err:
+    return ret;
+}
+
+esp_err_t eppp_sdio_slave_rx(esp_netif_t *netif)
+{
+    if (s_slave_request == REQ_RESET) {
+        ESP_LOGD(TAG, "request: %x", s_slave_request);
+        slave_reset();
+        s_slave_request = REQ_INIT;
+    }
+    sdio_slave_buf_handle_t handle;
+    size_t length;
+    uint8_t *ptr;
+    esp_err_t ret = sdio_slave_recv_packet(&handle, pdMS_TO_TICKS(1000));
+    if (ret == ESP_ERR_TIMEOUT) {
+        return ESP_OK;
+    }
+    if (ret == ESP_ERR_NOT_FINISHED || ret == ESP_OK) {
+again:
+        ptr = sdio_slave_recv_get_buf(handle, &length);
+        esp_netif_receive(netif, ptr, length, NULL);
+        if (sdio_slave_recv_load_buf(handle) != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to recycle packet buffer");
+            return ESP_FAIL;
+        }
+        if (ret == ESP_ERR_NOT_FINISHED) {
+            ret = sdio_slave_recv_packet(&handle, 0);
+            if (ret == ESP_ERR_NOT_FINISHED || ret == ESP_OK) {
+                goto again;
+            }
+        }
+        ESP_LOG_BUFFER_HEXDUMP(TAG, ptr, length, ESP_LOG_VERBOSE);
+        return ESP_OK;
+    }
+    ESP_LOGE(TAG, "Error when receiving packet %d", ret);
+    return ESP_FAIL;
+}
+
+
+static void event_cb(uint8_t pos)
+{
+    ESP_EARLY_LOGI(TAG, "SDIO event: %d", pos);
+    if (pos == SLAVE_INTR) {
+        s_slave_request = sdio_slave_read_reg(SLAVE_REG_REQ);
+        sdio_slave_write_reg(SLAVE_REG_REQ, 0);
+    }
+}
+
+esp_err_t eppp_sdio_slave_init(void)
+{
+    sdio_slave_config_t config = {
+        .sending_mode       = SDIO_SLAVE_SEND_PACKET,
+        .send_queue_size    = BUFFER_NUM,
+        .recv_buffer_size   = BUFFER_SIZE,
+        .event_cb           = event_cb,
+    };
+    esp_err_t ret = sdio_slave_initialize(&config);
+    if (ret != ESP_OK) {
+        return ret;
+    }
+
+    for (int i = 0; i < BUFFER_NUM; i++) {
+        sdio_slave_buf_handle_t handle = sdio_slave_recv_register_buf(sdio_slave_rx_buffer[i]);
+        if (handle == NULL) {
+            sdio_slave_deinit();
+            return ESP_FAIL;
+        }
+        ret = sdio_slave_recv_load_buf(handle);
+        if (ret != ESP_OK) {
+            sdio_slave_deinit();
+            return ESP_FAIL;
+        }
+    }
+
+    sdio_slave_set_host_intena(SDIO_SLAVE_HOSTINT_SEND_NEW_PACKET); // only need one interrupt to notify of a new packet
+
+    ret = sdio_slave_start();
+    if (ret != ESP_OK) {
+        sdio_slave_deinit();
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
+void eppp_sdio_slave_deinit(void)
+{
+    sdio_slave_stop();
+    sdio_slave_deinit();
+}
+
+#else // SOC_SDIO_SLAVE NOT-SUPPORTED
+
+esp_err_t eppp_sdio_slave_tx(void *h, void *buffer, size_t len)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+esp_err_t eppp_sdio_slave_rx(esp_netif_t *netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+void eppp_sdio_slave_deinit(void)
+{
+}
+
+esp_err_t eppp_sdio_slave_init(void)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+#endif // CONFIG_SOC_SDIO_SLAVE_SUPPORTED

components/eppp_link/examples/host/CMakeLists.txt

@@ -0,0 +1,7 @@
+# The following four 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(pppos_host)

components/eppp_link/examples/host/README.md

@@ -0,0 +1,9 @@
+
+# Client side demo of ESP-PPP-Link
+
+This is a basic demo of using esp-mqtt library, but connects to the internet using a PPPoS client. To run this example, you would need a PPP server that provides connectivity to the MQTT broker used in this example (by default a public broker accessible on the internet).
+
+If configured, this example could also run a ping session and an iperf console.
+
+
+The PPP server could be a Linux computer with `pppd` service or an ESP32 acting like a connection gateway with PPPoS server (see the "slave" project).

components/eppp_link/examples/host/main/CMakeLists.txt

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

components/eppp_link/examples/host/main/Kconfig.projbuild

@@ -0,0 +1,53 @@
+menu "Example Configuration"
+
+    config EXAMPLE_GLOBAL_DNS
+        hex "Set global DNS server"
+        range 0 0xFFFFFFFF
+        default 0x08080808
+        help
+            Global DNS server address.
+
+    config EXAMPLE_MQTT
+        bool "Run mqtt example"
+        default y
+        help
+            Run MQTT client after startup.
+
+    config EXAMPLE_BROKER_URL
+        string "Broker URL"
+        depends on EXAMPLE_MQTT
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of the broker to connect to.
+
+    config EXAMPLE_IPERF
+        bool "Run iperf"
+        default y
+        help
+            Init and run iperf console.
+
+    config EXAMPLE_UART_TX_PIN
+        int "TXD Pin Number"
+        depends on EPPP_LINK_DEVICE_UART
+        default 10
+        range 0 31
+        help
+            Pin number of UART TX.
+
+    config EXAMPLE_UART_RX_PIN
+        int "RXD Pin Number"
+        depends on EPPP_LINK_DEVICE_UART
+        default 11
+        range 0 31
+        help
+            Pin number of UART RX.
+
+    config EXAMPLE_UART_BAUDRATE
+        int "Baudrate"
+        depends on EPPP_LINK_DEVICE_UART
+        default 2000000
+        range 0 4000000
+        help
+            Baudrate used by the PPP over UART
+
+endmenu

components/eppp_link/examples/host/main/app_main.c

@@ -0,0 +1,151 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include "esp_system.h"
+#include "nvs_flash.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+#include "eppp_link.h"
+#include "esp_log.h"
+#include "mqtt_client.h"
+#include "console_ping.h"
+
+void register_iperf(void);
+
+static const char *TAG = "eppp_host_example";
+
+#if CONFIG_EXAMPLE_MQTT
+static void mqtt_event_handler(void *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;
+    esp_mqtt_client_handle_t client = event->client;
+    int msg_id;
+    switch ((esp_mqtt_event_id_t)event_id) {
+    case MQTT_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+        msg_id = esp_mqtt_client_publish(client, "/topic/qos1", "data_3", 0, 1, 0);
+        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
+
+        msg_id = esp_mqtt_client_subscribe(client, "/topic/qos0", 0);
+        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+
+        msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 1);
+        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+
+        msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos1");
+        ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+        break;
+
+    case MQTT_EVENT_SUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
+        msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0);
+        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", 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");
+        printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
+        printf("DATA=%.*s\r\n", event->data_len, event->data);
+        break;
+    case MQTT_EVENT_ERROR:
+        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
+            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 void mqtt_app_start(void)
+{
+    esp_mqtt_client_config_t mqtt_cfg = {
+        .broker.address.uri = "mqtt://mqtt.eclipseprojects.io",
+    };
+
+    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
+    /* 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, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
+    esp_mqtt_client_start(client);
+}
+#endif // MQTT
+
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "[APP] Startup..");
+    ESP_LOGI(TAG, "[APP] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    ESP_ERROR_CHECK(nvs_flash_init());
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    /* Sets up the default EPPP-connection
+     */
+    eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
+#if CONFIG_EPPP_LINK_DEVICE_SPI
+    config.transport = EPPP_TRANSPORT_SPI;
+#elif CONFIG_EPPP_LINK_DEVICE_UART
+    config.transport = EPPP_TRANSPORT_UART;
+    config.uart.tx_io = CONFIG_EXAMPLE_UART_TX_PIN;
+    config.uart.rx_io = CONFIG_EXAMPLE_UART_RX_PIN;
+    config.uart.baud = CONFIG_EXAMPLE_UART_BAUDRATE;
+#else
+    config.transport = EPPP_TRANSPORT_SDIO;
+#endif
+    esp_netif_t *eppp_netif = eppp_connect(&config);
+    if (eppp_netif == NULL) {
+        ESP_LOGE(TAG, "Failed to connect");
+        return ;
+    }
+    // Setup global DNS
+    esp_netif_dns_info_t dns;
+    dns.ip.u_addr.ip4.addr = esp_netif_htonl(CONFIG_EXAMPLE_GLOBAL_DNS);
+    dns.ip.type = ESP_IPADDR_TYPE_V4;
+    ESP_ERROR_CHECK(esp_netif_set_dns_info(eppp_netif, ESP_NETIF_DNS_MAIN, &dns));
+
+    // Initialize console REPL
+    ESP_ERROR_CHECK(console_cmd_init());
+
+#if CONFIG_EXAMPLE_IPERF
+    register_iperf();
+
+    printf("\n =======================================================\n");
+    printf(" |       Steps to Test EPPP-host bandwidth             |\n");
+    printf(" |                                                     |\n");
+    printf(" |  1. Wait for the ESP32 to get an IP                 |\n");
+    printf(" |  2. Server: 'iperf -u -s -i 3' (on host)            |\n");
+    printf(" |  3. Client: 'iperf -u -c SERVER_IP -t 60 -i 3'      |\n");
+    printf(" |                                                     |\n");
+    printf(" =======================================================\n\n");
+
+#endif // CONFIG_EXAMPLE_IPERF
+
+    // Register the ping command
+    ESP_ERROR_CHECK(console_cmd_ping_register());
+    // start console REPL
+    ESP_ERROR_CHECK(console_cmd_start());
+
+#if CONFIG_EXAMPLE_MQTT
+    mqtt_app_start();
+#endif
+}