fix(modem): Fix other clang-tidy warnings

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

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

.github/workflows/clang-tidy.yml

@@ -4,17 +4,17 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - test_clang_tidy
 
 jobs:
   build:
     name: Run clang-tidy
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     container: espressif/idf:latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
-          submodules: recursive
+          submodules: 'true'
       - name: Install esp-clang
         run: |
           ${IDF_PATH}/tools/idf_tools.py --non-interactive install esp-clang
@@ -24,7 +24,6 @@ jobs:
           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
@@ -36,21 +35,21 @@ jobs:
         working-directory: test_app
         run: |
           . ${IDF_PATH}/export.sh
-          idf.py clang-check --include-paths $GITHUB_WORKSPACE --exclude-paths $PWD --run-clang-tidy-py run-clang-tidy --run-clang-tidy-options "-checks=-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling"
+          idf.py clang-check --include-paths $GITHUB_WORKSPACE --exclude-paths $PWD --run-clang-tidy-py run-clang-tidy
           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
+      - uses: actions/upload-artifact@v2
         with:
           path: |
             warnings.txt
             results.sarif
             results.sarif.raw
       - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@v3
+        uses: github/codeql-action/upload-sarif@v2
         with:
           sarif_file: results.sarif
           category: clang-tidy

.github/workflows/console_cmd_mqtt__build.yml

@@ -1,32 +0,0 @@
-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/eppp__build.yml

@@ -13,16 +13,14 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.5", "release-v5.4", "release-v5.3"]
+        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-22.04
+    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 }}
-        env:
-          EXPECTED_WARNING: "DeprecationWarning: 'MultiCommand' is deprecated and will be removed\nCryptographyDeprecationWarning: Parsed a serial number which wasn't positive"
         shell: bash
         run: |
           . ${IDF_PATH}/export.sh

.github/workflows/esp_dns__build.yml

@@ -1,38 +0,0 @@
-name: "esp_dns: build-tests"
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    types: [opened, synchronize, reopened, labeled]
-
-jobs:
-  build_esp_dns:
-    if: contains(github.event.pull_request.labels.*.name, 'dns') || github.event_name == 'push'
-    name: Build
-    strategy:
-      matrix:
-        idf_ver: ["latest", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
-        idf_target: ["esp32"]
-        test: [ { app: esp_dns_basic, path: "components/esp_dns/examples"}]
-        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@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}/export.sh
-          pip install idf-component-manager idf-build-apps --upgrade
-          python ../../../ci/build_apps.py ./${{ matrix.test.app }} --target ${{ matrix.idf_target }} -vv --preserve-all --pytest-app

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

@@ -13,37 +13,19 @@ jobs:
     name: Build examples
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
-        include:
-          - idf_ver: "latest"
-            warning: "Warning: The smallest app partition is nearly full"
+        idf_ver: ["latest", "release-v5.1", "release-v5.2", "release-v5.3"]
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
-    env:
-      TARGET_TEST: examples/esp_netif/slip_custom_netif/
-      TARGET_TEST_DIR: build_esp32c3_target
     steps:
       - name: Checkout esp-protocols
         uses: actions/checkout@v4
       - name: Build with IDF-${{ matrix.idf_ver }}
-        env:
-          EXPECTED_WARNING: ${{ matrix.warning }}
         shell: bash
         run: |
           . ${IDF_PATH}/export.sh
           python -m pip install idf-build-apps
           # Build default configs for all targets
           python ./ci/build_apps.py examples -m examples/.build-test-rules.yml -d -c
-          # Build target tests
-          python ./ci/build_apps.py ${TARGET_TEST} -r sdkconfig.ci=target
-          cd ${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: slip_target_${{ matrix.idf_ver }}
-          path: ${{ env.TARGET_TEST }}/artifacts.zip
-          if-no-files-found: error
 
   build_and_run_on_host:
     if: contains(github.event.pull_request.labels.*.name, 'examples') || github.event_name == 'push'
@@ -64,38 +46,3 @@ jobs:
           python ./ci/build_apps.py examples/mqtt -l -t linux
           timeout 5 ./examples/mqtt/build_linux_default/esp_mqtt_demo.elf | tee test.log  || true
           grep 'MQTT_EVENT_DATA' test.log
-
-  run_on_target:
-    # 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, 'examples') || github.event_name == 'push' )
-    name: Slip example target test
-    needs: build_all_examples
-    strategy:
-      matrix:
-        idf_ver: ["release-v5.4", "latest"]
-    runs-on:
-      - self-hosted
-      - modem
-    env:
-      TARGET_TEST: examples/esp_netif/slip_custom_netif/
-      TARGET_TEST_DIR: build_esp32c3_target
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          name: slip_target_${{ matrix.idf_ver }}
-          path: ${{ env.TARGET_TEST }}/ci/
-      - name: Run Test
-        working-directory: ${{ env.TARGET_TEST }}
-        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 netifaces
-          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 --target=esp32c3
-          done

.github/workflows/lws_build.yml

@@ -1,86 +0,0 @@
-name: "lws: build-tests"
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    types: [opened, synchronize, reopened, labeled]
-
-jobs:
-  build_lws:
-    if: contains(github.event.pull_request.labels.*.name, 'lws') || github.event_name == 'push'
-    name: Libwebsockets build
-    strategy:
-      matrix:
-        idf_ver: ["latest", "release-v5.3", "release-v5.4"]
-        test: [ { app: example, path: "examples/client" }]
-    runs-on: ubuntu-22.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    env:
-      TEST_DIR: components/libwebsockets/${{ matrix.test.path }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          python -m pip install idf-build-apps
-          python ./ci/build_apps.py ${TEST_DIR}
-          cd ${TEST_DIR}
-          for dir in `ls -d build_esp32_*`; do
-          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
-          zip -qur artifacts.zip $dir
-          done
-      - uses: actions/upload-artifact@v4
-        with:
-          name: lws_target_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
-          path: ${{ env.TEST_DIR }}/artifacts.zip
-          if-no-files-found: error
-
-  run-target-lws:
-    # 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, 'lws') || github.event_name == 'push' )
-    name: Target test
-    needs: build_lws
-    strategy:
-      fail-fast: false
-      matrix:
-        idf_ver: ["latest", "release-v5.3", "release-v5.4"]
-        idf_target: ["esp32"]
-        test: [ { app: example, path: "examples/client" }]
-    runs-on:
-      - self-hosted
-      - ESP32-ETHERNET-KIT
-    env:
-      TEST_DIR: components/libwebsockets/${{ matrix.test.path }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          name: lws_target_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
-          path: ${{ env.TEST_DIR }}/ci/
-      - name: Install Python packages
-        env:
-          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
-        run: |
-          pip install --only-binary cryptography --extra-index-url https://dl.espressif.com/pypi/ -r $GITHUB_WORKSPACE/ci/requirements.txt
-      - name: Run Example Test on target
-        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_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=${{ matrix.idf_target }}
-          done
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml
-          path: components/libwebsockets/${{ matrix.test.path }}/*.xml

.github/workflows/mdns__host-tests.yml

@@ -10,61 +10,52 @@ on:
 jobs:
   host_test_mdns:
     if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
-    name: Host test build
+    name: Host test
     runs-on: ubuntu-22.04
-    container: espressif/idf:release-v5.3
+    container: espressif/idf:release-v5.1
 
     steps:
       - name: Checkout esp-protocols
         uses: actions/checkout@v4
         with:
-          path: protocols
+          path: esp-protocols
 
       - name: Build and Test
         shell: bash
         run: |
+          apt-get update && apt-get install -y dnsutils gcc g++
           . ${IDF_PATH}/export.sh
-          python -m pip install idf-build-apps==2.10.0 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
+          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
 
-  host_compat_checks:
+  build_afl_host_test_mdns:
     if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
-    name: Set of compatibility checks
+    name: Build AFL host test
     strategy:
       matrix:
         idf_ver: ["latest"]
+        idf_target: ["esp32"]
 
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols
         uses: actions/checkout@v4
+        with:
+          path: esp-protocols
       - name: Install Necessary Libs
         run: |
           apt-get update -y
           apt-get install -y libbsd-dev
-      - name: Test AFL compat build
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
         shell: bash
         run: |
           . ${IDF_PATH}/export.sh
-          cd components/mdns/tests/test_afl_fuzz_host/
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/test_afl_fuzz_host/
           make INSTR=off
-      - name: Test no malloc functions
-        shell: bash
-        run: |
-          cd components/mdns
-          for file in $(ls *.c); do
-            cp $file /tmp
-            echo -n "Checking that $file does not call any std allocations directly..."
-            python mem_prefix_script.py $file
-            diff -q $file /tmp/$file || exit 1
-            echo "OK"
-          done

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

@@ -13,8 +13,11 @@ jobs:
     name: Build examples
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
+        idf_ver: ["latest", "release-v4.4", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3"]
         example: ["pppos_client", "modem_console", "modem_tcp_client", "ap_to_pppos", "simple_cmux_client"]
+        exclude:
+          - idf_ver: "release-v4.4"
+            example: modem_tcp_client
         include:
           - idf_ver: "release-v5.0"
             example: "simple_cmux_client"
@@ -23,7 +26,13 @@ jobs:
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
-      - name: Check out code
+      - name: Check out code (v3) # @v4 failed due to Node 20's requirement, incompatible with older IDF versions
+        if: matrix.idf_ver != 'latest' && matrix.idf_ver < 'release-v5.0'
+        uses: actions/checkout@v3
+        with:
+          path: protocols
+      - name: Check out code (v4)
+        if: matrix.idf_ver == 'latest' || matrix.idf_ver >= 'release-v5.0'
         uses: actions/checkout@v4
         with:
           path: protocols
@@ -44,8 +53,8 @@ jobs:
     name: Build tests
     strategy:
       matrix:
-        idf_ver: ["release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4", "latest"]
-        test: ["target", "target_ota", "target_iperf", "target_urc"]
+        idf_ver: ["release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "latest"]
+        test: ["target", "target_ota", "target_iperf"]
 
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
@@ -91,21 +100,3 @@ jobs:
         run_executable: false
         run_coverage: false
         pre_run_script: "esp-protocols/components/esp_modem/test/host_test/env.sh"
-
-  esp_modem_generated_commands:
-    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
-    name: Generated commands compatibility
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v4
-      - name: Compat check
-        shell: bash
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y astyle
-          cd components/esp_modem
-          find examples/ -type f -regex '.*/generate/.*\.\(hpp\|cpp\)' -exec ./scripts/generate.sh {} \;
-          ./scripts/generate.sh
-          git diff --name-only
-          git diff --quiet

.github/workflows/modem__target-test.yml

@@ -15,7 +15,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: pppd_chap_auth, 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: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
         include:
           - idf_ver: "latest"
             idf_target: "esp32s2"
@@ -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@v4
+      - uses: actions/upload-artifact@v3
         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: pppd_chap_auth, 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: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
         include:
           - idf_ver: "latest"
             idf_target: "esp32s2"
@@ -69,23 +69,16 @@ 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@v4
+      - uses: actions/download-artifact@v3
         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
-        env:
-          PIP_EXTRA_INDEX_URL: "https://dl.espressif.com/pypi/"
+        working-directory: ${{ env.TEST_DIR }}
         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 pip install -r $GITHUB_WORKSPACE/ci/requirements.txt
             python -m pytest --log-cli-level DEBUG --target=${{ matrix.idf_target }}

.github/workflows/modem_sim__build.yml

@@ -1,28 +0,0 @@
-name: "modem_sim: build-tests"
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    types: [opened, synchronize, reopened, labeled]
-
-jobs:
-  build_modem_sim:
-    if: contains(github.event.pull_request.labels.*.name, 'modem_sim') || github.event_name == 'push'
-    name: Build
-    strategy:
-      matrix:
-        idf_ver: ["release-v5.4"]
-    runs-on: ubuntu-22.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-      - name: Build ESP-AT with IDF-${{ matrix.idf_ver }}
-        shell: bash
-        run: |
-          cd common_components/modem_sim
-          ./install.sh
-          source export.sh
-          idf.py build

.github/workflows/mosq__build.yml

@@ -1,188 +0,0 @@
-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.5", "release-v5.4", "release-v5.3", "release-v5.2", "release-v5.1"]
-        example: ["broker", "serverless_mqtt"]
-        exclude:
-          - idf_ver: "release-v5.1"
-            example: "serverless_mqtt"  # serverless_mqtt is not supported due to esp-peer
-
-    runs-on: ubuntu-22.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    env:
-      TEST_DIR: components/mosquitto/examples/${{ matrix.example }}
-      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
-          if [ "${{ matrix.example }}" == "${TARGET_TEST}" ]; then
-            # upload only the target test artifacts
-            cd ${TEST_DIR}
-            ${GITHUB_WORKSPACE}/ci/clean_build_artifacts.sh `pwd`/${TARGET_TEST_DIR}
-            zip -qur artifacts.zip ${TARGET_TEST_DIR}
-          fi
-      - uses: actions/upload-artifact@v4
-        if: ${{ matrix.example == 'broker' }}
-        with:
-          name: mosq_target_esp32_${{ matrix.idf_ver }}
-          path: ${{ env.TEST_DIR }}/artifacts.zip
-          if-no-files-found: error
-
-  test_mosq:
-    # Skip running on forks since it won't have access to secrets
-    if: |
-      github.repository == 'espressif/esp-protocols' &&
-      ( contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push' )
-    name: Mosquitto target test
-    needs: build_mosq
-    strategy:
-      matrix:
-        idf_ver: ["latest", "release-v5.3"]
-    runs-on:
-      - self-hosted
-      - ESP32-ETHERNET-KIT
-    env:
-      TEST_DIR: components/mosquitto/examples/broker
-      TARGET_TEST_DIR: build_esp32_default
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          name: mosq_target_esp32_${{ matrix.idf_ver }}
-          path: ${{ env.TEST_DIR }}/ci/
-      - name: Run Test
-        working-directory: ${{ env.TEST_DIR }}
-        run: |
-          python -m pip install pytest-embedded-serial-esp pytest-embedded-idf pytest-rerunfailures pytest-timeout pytest-ignore-test-results
-          unzip ci/artifacts.zip -d ci
-          for dir in `ls -d ci/build_*`; do
-          rm -rf build sdkconfig.defaults
-          mv $dir build
-          python -m pytest --log-cli-level DEBUG --junit-xml=./results_esp32_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=esp32
-          done
-
-  check_consistency:
-    if: contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push'
-    name: Checks that API docs and versions are consistent
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Checks API Docs and versions
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install doxygen
-          pip install esp-doxybook
-          cd components/mosquitto
-          cp api.md api_orig.md
-          ./generate_api_docs.sh
-          diff -wB api.md api_orig.md
-          # check version consistency
-          CONFIG_VERSION=$(grep -Po '(?<=#define VERSION ")[^"]*' port/priv_include/config.h)
-          CZ_VERSION=$(grep -Po '(?<=version: )[^"]*' .cz.yaml)
-          COMP_VERSION=$(grep -Po '(?<=version: ")[^"]*' idf_component.yml)
-          if [ "$CONFIG_VERSION" != "v$CZ_VERSION" ] || [ "$CONFIG_VERSION" != "v$COMP_VERSION" ]; then
-            echo "Version mismatch detected:"
-            echo "config.h: $CONFIG_VERSION"
-            echo ".cz.yaml: $CZ_VERSION"
-            echo "idf_component.yml: $COMP_VERSION"
-            exit 1
-          fi
-          echo "Versions are consistent: $CONFIG_VERSION"
-
-  build_idf_tests_with_mosq:
-    if: |
-      github.repository == 'espressif/esp-protocols' &&
-      ( contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push' )
-    name: Build IDF tests
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-        test: [ { app: publish, path: "tools/test_apps/protocols/mqtt/publish_connect_test" }]
-    runs-on: ubuntu-22.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"  --upgrade
-          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/pre_commit_check.yml

@@ -26,7 +26,7 @@ jobs:
       - name: Set up Python environment
         uses: actions/setup-python@master
         with:
-          python-version: v3.8
+          python-version: v3.7
       - name: Install python packages
         run: |
           pip install pre-commit

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

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

.github/workflows/sockutls_build.yml

@@ -1,95 +0,0 @@
-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

@@ -15,7 +15,7 @@ jobs:
       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-22.04
+    runs-on: ubuntu-20.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
       - name: Checkout esp-protocols

.github/workflows/wifi_remote__build.yml

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

.gitignore

@@ -94,9 +94,3 @@ docs/html
 
 # esp-idf managed components
 **/managed_components/**
-
-# modem simulator uses esp-at clone
-common_components/modem_sim/modem_sim_esp32/
-
-# repository release tools
-release_notes.txt

.gitmodules

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

.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: v1.0.5
+    rev: c0013808882a15a0c0c2c1a9b5c903866c53a653
     hooks:
     -   id: astyle_py
-        args: ['--style=otbs', '--attach-namespaces', '--attach-classes', '--indent=spaces=4', '--convert-tabs', '--align-reference=name', '--keep-one-line-statements', '--pad-header', '--pad-oper', '--unpad-paren', '--max-continuation-indent=120', '--exclude-list=ci/ignore_astyle.txt']
+        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, dns, modem, websocket, asio, mqtt_cxx, console, common, eppp, tls_cxx, mosq, sockutls, lws, modem_sim"
-        entry: '\A(?!(feat|fix|ci|bump|test|docs|chore)\((mdns|dns|modem|common|console|websocket|asio|mqtt_cxx|examples|eppp|tls_cxx|mosq|sockutls|lws|modem_sim)\)\:)'
+        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, console, common, eppp, wifi_remote, tls_cxx"
+        entry: '\A(?!(feat|fix|ci|bump|test|docs)\((mdns|modem|common|console|websocket|asio|mqtt_cxx|examples|eppp|wifi_remote|tls_cxx)\)\:)'
         language: pygrep
         args: [--multiline]
         stages: [commit-msg]

README.md

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

ci/build_apps.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Apache-2.0
 """
 This file is used in CI for esp-protocols build tests
@@ -10,6 +10,8 @@ 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(
@@ -49,24 +51,43 @@ if __name__ == '__main__':
         SUPPORTED_TARGETS.append('linux')
         ignore_warning = 'warning: '  # Ignore all common warnings on linux builds
     setup_logging(2)
-    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='.',
-    )
+    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)
 
     sys.exit(
         build_apps(apps,
                    dry_run=False,
                    keep_going=False,
-                   no_preserve=args.delete,
                    ignore_warning_strs=ignore_warning)
     )

ci/check_copyright_config.yaml

@@ -47,14 +47,6 @@ 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

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

ci/detect_component_bump

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

ci/ignore_astyle.txt

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

common_components/linux_compat/esp_ringbuf/CMakeLists.txt

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

common_components/linux_compat/freertos/freertos_linux.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -12,24 +12,8 @@
 #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,
@@ -64,7 +48,7 @@ static struct generic_queue_handle *create_generic_queue(queue_type_t type, uint
     return h;
 }
 
-QueueHandle_t xQueueCreate(uint32_t uxQueueLength, uint32_t uxItemSize)
+QueueHandle_t xQueueCreate(uint32_t uxQueueLength, uint32_t uxItemSize )
 {
     return (QueueHandle_t)create_generic_queue(QUEUE, uxQueueLength, uxItemSize);
 }
@@ -75,7 +59,7 @@ uint32_t xQueueSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t
     return osal_queue_send(h->q, (uint8_t *)pvItemToQueue, h->item_size) ? pdTRUE : pdFAIL;
 }
 
-uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
+uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait )
 {
     return xQueueSend(xQueue, pvItemToQueue, xTicksToWait);
 }
@@ -86,7 +70,7 @@ uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksTo
     return osal_queue_recv(h->q, (uint8_t *)pvBuffer, h->item_size, xTicksToWait) ? pdTRUE : pdFAIL;
 }
 
-BaseType_t xSemaphoreGive(QueueHandle_t xQueue)
+BaseType_t xSemaphoreGive( QueueHandle_t xQueue)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX) {
@@ -96,7 +80,7 @@ BaseType_t xSemaphoreGive(QueueHandle_t xQueue)
     return xQueueSend(xQueue, &s_semaphore_data, portMAX_DELAY);
 }
 
-BaseType_t xSemaphoreGiveRecursive(QueueHandle_t xQueue)
+BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue)
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX_REC) {
@@ -105,8 +89,7 @@ BaseType_t xSemaphoreGiveRecursive(QueueHandle_t xQueue)
     }
     return pdFALSE;
 }
-
-BaseType_t xSemaphoreTake(QueueHandle_t xQueue, TickType_t pvTask)
+BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask )
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX) {
@@ -116,7 +99,8 @@ BaseType_t xSemaphoreTake(QueueHandle_t xQueue, TickType_t pvTask)
     return xQueueReceive(xQueue, &s_semaphore_data, portMAX_DELAY);
 }
 
-BaseType_t xSemaphoreTakeRecursive(QueueHandle_t xQueue, TickType_t pvTask)
+
+BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask )
 {
     struct generic_queue_handle *h = xQueue;
     if (h->type == MUTEX_REC) {
@@ -126,7 +110,10 @@ BaseType_t xSemaphoreTakeRecursive(QueueHandle_t xQueue, TickType_t pvTask)
     return pdFALSE;
 }
 
-void vQueueDelete(QueueHandle_t xQueue)
+
+
+
+void vQueueDelete( QueueHandle_t xQueue )
 {
     struct generic_queue_handle *h = xQueue;
     if (h->q) {
@@ -141,7 +128,8 @@ void vQueueDelete(QueueHandle_t xQueue)
 
 QueueHandle_t xSemaphoreCreateBinary(void)
 {
-    return xQueueCreate(1, 1);
+    QueueHandle_t sempaphore =  xQueueCreate(1, 1);
+    return sempaphore;
 }
 
 QueueHandle_t xSemaphoreCreateMutex(void)
@@ -157,17 +145,8 @@ 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);
-    } else {
-        pthread_cancel((pthread_t)task);
     }
     void *thread_rval = NULL;
     pthread_join((pthread_t)task, &thread_rval);
@@ -178,35 +157,28 @@ void vTaskSuspend(void *task)
     vTaskDelete(task);
 }
 
-TickType_t xTaskGetTickCount(void)
+TickType_t xTaskGetTickCount( void )
 {
     struct timespec spec;
     clock_gettime(CLOCK_REALTIME, &spec);
     return spec.tv_nsec / 1000000 + spec.tv_sec * 1000;
 }
 
-void vTaskDelay(const TickType_t xTicksToDelay)
+void vTaskDelay( const TickType_t xTicksToDelay )
 {
     usleep(xTicksToDelay * 1000);
 }
 
 void *pthread_task(void *params)
 {
-    pthread_params_t *pthread_params = params;
+    struct {
+        void *const param;
+        TaskFunction_t task;
+        bool started;
+    } *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);
@@ -214,38 +186,28 @@ void *pthread_task(void *params)
     return NULL;
 }
 
-TaskHandle_t xTaskCreateStaticPinnedToCore(TaskFunction_t pxTaskCode,
-                                           const char *const pcName,
-                                           const uint32_t ulStackDepth,
-                                           void *const pvParameters,
-                                           UBaseType_t uxPriority,
-                                           StackType_t *const puxStackBuffer,
-                                           StaticTask_t *const pxTaskBuffer,
-                                           const BaseType_t xCoreID)
-{
-    static TaskHandle_t pvCreatedTask;
-    xTaskCreate(pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, &pvCreatedTask);
-    return pvCreatedTask;
-}
-
-BaseType_t xTaskCreatePinnedToCore(TaskFunction_t pvTaskCode,
-                                   const char *const pcName,
-                                   const uint32_t usStackDepth,
-                                   void *const pvParameters,
-                                   UBaseType_t uxPriority,
-                                   TaskHandle_t *const pvCreatedTask,
-                                   const BaseType_t xCoreID)
+BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
+                                    const char *const pcName,
+                                    const uint32_t usStackDepth,
+                                    void *const pvParameters,
+                                    UBaseType_t uxPriority,
+                                    TaskHandle_t *const pvCreatedTask,
+                                    const BaseType_t xCoreID)
 {
     xTaskCreate(pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask);
     return pdTRUE;
 }
 
+
 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;
-    pthread_params_t pthread_params = { .param = pvParameters, .task = pvTaskCode};
-
+    struct {
+        void *const param;
+        TaskFunction_t task;
+        bool started;
+    } pthread_params = { .param = pvParameters, .task = pvTaskCode};
     int res = pthread_attr_init(&attr);
     assert(res == 0);
     res = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
@@ -253,90 +215,58 @@ 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)
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time )
 {
     return true;
 }
 
 TaskHandle_t xTaskGetCurrentTaskHandle(void)
 {
-    return (TaskHandle_t)pthread_self();
+    return NULL;
 }
 
-EventGroupHandle_t xEventGroupCreate(void)
+EventGroupHandle_t xEventGroupCreate( void )
 {
     return osal_signal_create();
 }
 
-void vEventGroupDelete(EventGroupHandle_t xEventGroup)
+void vEventGroupDelete( EventGroupHandle_t xEventGroup )
 {
     osal_signal_delete(xEventGroup);
 }
 
-EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear)
+EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
 {
     return osal_signal_clear(xEventGroup, uxBitsToClear);
 }
 
-EventBits_t xEventGroupGetBits(EventGroupHandle_t xEventGroup)
+EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup)
 {
     return osal_signal_get(xEventGroup);
 }
 
-EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet)
+EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
 {
     return osal_signal_set(xEventGroup, uxBitsToSet);
 }
 
-EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait)
+EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
 {
     return osal_signal_wait(xEventGroup, uxBitsToWaitFor, xWaitForAllBits, xTicksToWait);
 }
-
-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,7 +5,6 @@
  */
 #pragma once
 
-#include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>

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

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

common_components/modem_sim/export.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-
-source $IDF_PATH/export.sh
-
-export AT_CUSTOM_COMPONENTS="`pwd`/pppd_cmd"
-
-cd modem_sim_esp32/esp-at
-
-python -m pip install -r requirements.txt
-
-python build.py reconfigure

common_components/modem_sim/install.sh

@@ -1,64 +0,0 @@
-#!/bin/bash
-set -e
-
-# Create directory "modem_sim_esp32", go inside it
-# Usage: ./install.sh [platform] [module]
-
-SCRIPT_DIR=$(pwd)
-mkdir -p modem_sim_esp32
-cd modem_sim_esp32
-
-if [ -z "$IDF_PATH" ]; then
-    echo "Error: IDF_PATH environment variable is not set"
-    exit 1
-fi
-
-# Default ESP_AT_VERSION uses this specific commit from master to support new chips and features
-ESP_AT_VERSION="aa9d7e0e9b741744f7bf5bec3bbf887cff033d5f"
-
-# Shallow clone of esp-at.git at $ESP_AT_VERSION
-if [ ! -d "esp-at" ]; then
-    # cannot shallow clone from a specific commit, so we init, shallow fetch, and checkout
-    mkdir -p esp-at && cd esp-at && git init && git remote add origin https://github.com/espressif/esp-at.git
-    git fetch --depth 1 origin $ESP_AT_VERSION && git checkout $ESP_AT_VERSION
-else
-    echo "esp-at directory already exists, skipping clone."
-    cd esp-at
-fi
-
-# Add esp-idf directory which is a symlink to the $IDF_PATH
-if [ ! -L "esp-idf" ]; then
-    ln -sf "$IDF_PATH" esp-idf
-else
-    echo "esp-idf symlink already exists, skipping."
-fi
-
-# Create "build" directory
-mkdir -p build
-
-# Default values for platform and module
-platform="PLATFORM_ESP32"
-module="WROOM-32"
-
-# Override defaults if parameters are provided
-if [ ! -z "$1" ]; then
-    platform="$1"
-fi
-if [ ! -z "$2" ]; then
-    module="$2"
-fi
-
-# Create file "build/module_info.json" with content
-cat > build/module_info.json << EOF
-{
-    "platform": "$platform",
-    "module": "$module",
-    "description": "4MB, Wi-Fi + BLE, OTA, TX:17 RX:16",
-    "silence": 0
-}
-EOF
-
-cp "$SCRIPT_DIR/sdkconfig.defaults" "module_config/module_esp32_default/sdkconfig.defaults"
-
-echo "Installation completed successfully!"
-echo "Created modem_sim_esp32 directory with esp-at repository and configuration"

common_components/modem_sim/pppd_cmd/CMakeLists.txt

@@ -1,6 +0,0 @@
-idf_component_register(
-    SRCS additional_commands.c
-    INCLUDE_DIRS include
-    REQUIRES at freertos nvs_flash)
-
-idf_component_set_property(${COMPONENT_NAME} WHOLE_ARCHIVE TRUE)

common_components/modem_sim/pppd_cmd/additional_commands.c

@@ -1,411 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include <stdio.h>
-#include <string.h>
-#include <stdbool.h>
-#include "esp_at.h"
-#include "driver/gpio.h"
-#include "driver/uart.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/event_groups.h"
-#include "freertos/semphr.h"
-#include "freertos/queue.h"
-#include "esp_netif.h"
-#include "esp_netif_ppp.h"
-#include "esp_check.h"
-#include "esp_http_server.h"
-#include "esp_timer.h"
-
-static uint8_t at_test_cmd_test(uint8_t *cmd_name)
-{
-    uint8_t buffer[64] = {0};
-    snprintf((char *)buffer, 64, "test command: <AT%s=?> is executed\r\n", cmd_name);
-    esp_at_port_write_data(buffer, strlen((char *)buffer));
-
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_query_cmd_test(uint8_t *cmd_name)
-{
-    uint8_t buffer[64] = {0};
-    snprintf((char *)buffer, 64, "query command: <AT%s?> is executed\r\n", cmd_name);
-    esp_at_port_write_data(buffer, strlen((char *)buffer));
-
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_setup_cmd_test(uint8_t para_num)
-{
-    uint8_t index = 0;
-    printf("setup command: <AT%s=%d> is executed\r\n", esp_at_get_current_cmd_name(), para_num);
-
-    // get first parameter, and parse it into a digit
-    int32_t digit = 0;
-    if (esp_at_get_para_as_digit(index++, &digit) != ESP_AT_PARA_PARSE_RESULT_OK) {
-        return ESP_AT_RESULT_CODE_ERROR;
-    }
-    printf("digit: %d\r\n", digit);
-
-    // get second parameter, and parse it into a string
-    uint8_t *str = NULL;
-    if (esp_at_get_para_as_str(index++, &str) != ESP_AT_PARA_PARSE_RESULT_OK) {
-        return ESP_AT_RESULT_CODE_ERROR;
-    }
-    printf("string: %s\r\n", str);
-
-    // allocate a buffer and construct the data, then send the data to mcu via interface (uart/spi/sdio/socket)
-    uint8_t *buffer = (uint8_t *)malloc(512);
-    if (!buffer) {
-        return ESP_AT_RESULT_CODE_ERROR;
-    }
-    int len = snprintf((char *)buffer, 512, "setup command: <AT%s=%d,\"%s\"> is executed\r\n",
-                       esp_at_get_current_cmd_name(), digit, str);
-    esp_at_port_write_data(buffer, len);
-
-    // remember to free the buffer
-    free(buffer);
-
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-#define TAG "at_custom_cmd"
-static esp_netif_t *s_netif = NULL;
-static httpd_handle_t http_server = NULL;
-
-static void on_ppp_event(void *arg, esp_event_base_t base, int32_t event_id, void *data)
-{
-    esp_netif_t **netif = data;
-    if (base == NETIF_PPP_STATUS && event_id == NETIF_PPP_ERRORUSER) {
-        printf("Disconnected!");
-    }
-}
-
-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;
-    if (event_id == IP_EVENT_PPP_GOT_IP) {
-        printf("Got IPv4 event: Interface \"%s(%s)\" address: " IPSTR, esp_netif_get_desc(netif),
-               esp_netif_get_ifkey(netif), IP2STR(&event->ip_info.ip));
-        ESP_ERROR_CHECK(esp_netif_napt_enable(s_netif));
-
-    } else if (event_id == IP_EVENT_PPP_LOST_IP) {
-        ESP_LOGI(TAG, "Disconnected");
-    }
-}
-
-static SemaphoreHandle_t at_sync_sema = NULL;
-static void wait_data_callback(void)
-{
-    static uint8_t buffer[1500] = {0};
-    int len = esp_at_port_read_data(buffer, sizeof(buffer) - 1);
-
-    // Check for the escape sequence "+++" in the received data
-    const uint8_t escape_seq[] = "+++";
-    uint8_t *escape_ptr = memmem(buffer, len, escape_seq, 3);
-
-    if (escape_ptr != NULL) {
-        printf("Found +++ sequence, signal to the command processing thread\n");
-
-        int data_before_escape = escape_ptr - buffer;
-        if (data_before_escape > 0) {
-            esp_netif_receive(s_netif, buffer, data_before_escape, NULL);
-        }
-
-        if (at_sync_sema) {
-            xSemaphoreGive(at_sync_sema);
-        }
-        return;
-    }
-    esp_netif_receive(s_netif, buffer, len, NULL);
-}
-
-static esp_err_t transmit(void *h, void *buffer, size_t len)
-{
-    printf("transmit: %d bytes\n", len);
-    esp_at_port_write_data(buffer, len);
-    return ESP_OK;
-}
-
-static uint8_t at_exe_cmd_test(uint8_t *cmd_name)
-{
-    uint8_t buffer[64] = {0};
-    snprintf((char *)buffer, 64, "execute command: <AT%s> is executed\r\n", cmd_name);
-    esp_at_port_write_data(buffer, strlen((char *)buffer));
-    printf("Command <AT%s> executed successfully\r\n", cmd_name);
-    if (!at_sync_sema) {
-        at_sync_sema = xSemaphoreCreateBinary();
-        assert(at_sync_sema != NULL);
-        esp_netif_driver_ifconfig_t driver_cfg = {
-            .handle = (void *)1,
-            .transmit = transmit,
-        };
-        const esp_netif_driver_ifconfig_t *ppp_driver_cfg = &driver_cfg;
-
-        esp_netif_inherent_config_t base_netif_cfg = ESP_NETIF_INHERENT_DEFAULT_PPP();
-        esp_netif_config_t netif_ppp_config = { .base = &base_netif_cfg,
-                                                .driver = ppp_driver_cfg,
-                                                .stack = ESP_NETIF_NETSTACK_DEFAULT_PPP
-                                              };
-
-        s_netif = esp_netif_new(&netif_ppp_config);
-        esp_netif_ppp_config_t netif_params;
-        ESP_ERROR_CHECK(esp_netif_ppp_get_params(s_netif, &netif_params));
-        netif_params.ppp_our_ip4_addr.addr = ESP_IP4TOADDR(192, 168, 11, 1);
-        netif_params.ppp_their_ip4_addr.addr = ESP_IP4TOADDR(192, 168, 11, 2);
-        netif_params.ppp_error_event_enabled = true;
-        ESP_ERROR_CHECK(esp_netif_ppp_set_params(s_netif, &netif_params));
-        if (esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_ip_event, NULL) != ESP_OK) {
-            printf("Failed to register IP event handler");
-        }
-        if (esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, on_ppp_event, NULL) !=  ESP_OK) {
-            printf("Failed to register NETIF_PPP_STATUS event handler");
-        }
-
-
-    }
-    esp_at_port_write_data((uint8_t *)"CONNECT\r\n", strlen("CONNECT\r\n"));
-
-    // set the callback function which will be called by AT port after receiving the input data
-    esp_at_port_enter_specific(wait_data_callback);
-    esp_netif_action_start(s_netif, 0, 0, 0);
-    esp_netif_action_connected(s_netif, 0, 0, 0);
-
-    while (xSemaphoreTake(at_sync_sema, pdMS_TO_TICKS(1000)) == pdFALSE) {
-        printf(".");
-    }
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_test_cereg(uint8_t *cmd_name)
-{
-    printf("%s: AT command <AT%s> is executed\r\n", __func__, cmd_name);
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_query_cereg(uint8_t *cmd_name)
-{
-    printf("%s: AT command <AT%s> is executed\r\n", __func__, cmd_name);
-    static uint8_t buffer[] = "+CEREG: 7,8\r\n";
-    esp_at_port_write_data(buffer, sizeof(buffer));
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_setup_cereg(uint8_t num)
-{
-    printf("%s: AT command <AT%d> is executed\r\n", __func__, num);
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_exe_cereg(uint8_t *cmd_name)
-{
-    printf("%s: AT command <AT%s> is executed\r\n", __func__, cmd_name);
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static esp_err_t hello_get_handler(httpd_req_t *req)
-{
-    const char* resp_str = "Hello from ESP-AT HTTP Server!";
-    httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
-    return ESP_OK;
-}
-
-static esp_err_t root_get_handler(httpd_req_t *req)
-{
-    const char* resp_str = "ESP-AT HTTP Server is running";
-    httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
-    return ESP_OK;
-}
-
-static esp_err_t test_get_handler(httpd_req_t *req)
-{
-    const char* resp_str = "{\"status\":\"success\",\"message\":\"Test endpoint working\",\"timestamp\":12345}";
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
-    return ESP_OK;
-}
-
-static esp_err_t async_get_handler(httpd_req_t *req)
-{
-    printf("Starting async chunked response handler\r\n");
-
-    // Set content type for plain text response
-    httpd_resp_set_type(req, "text/plain");
-
-    // Static counter to track requests
-    static uint8_t req_count = 0;
-    req_count++;
-
-    // Send initial response with request count
-    char buffer[256];
-    snprintf(buffer, sizeof(buffer), "=== Async Response #%d ===\r\n", req_count);
-    httpd_resp_sendstr_chunk(req, buffer);
-
-    // Long message broken into chunks
-    const char* chunks[] = {
-        "This is a simulated slow server response.\r\n",
-        "Chunk 1: The ESP-AT HTTP server is demonstrating...\r\n",
-        "Chunk 2: ...asynchronous chunked transfer encoding...\r\n",
-        "Chunk 3: ...with artificial delays between chunks...\r\n",
-        "Chunk 4: ...to simulate real-world network conditions.\r\n",
-        "Chunk 5: Processing data... please wait...\r\n",
-        "Chunk 6: Still processing... almost done...\r\n",
-        "Chunk 7: Final chunk - transfer complete!\r\n",
-        "=== END OF RESPONSE ===\r\n"
-    };
-
-    int num_chunks = sizeof(chunks) / sizeof(chunks[0]);
-
-    // Send each chunk with delays
-    for (int i = 0; i < num_chunks; i++) {
-        // Add a delay to simulate slow processing
-        vTaskDelay(pdMS_TO_TICKS(1500)); // 1.5 second delay between chunks
-
-        // Add chunk number and timestamp
-        snprintf(buffer, sizeof(buffer), "[%d/%d] [%d ms] %s",
-                 i + 1, num_chunks, (int)(esp_timer_get_time() / 1000), chunks[i]);
-
-        printf("Sending chunk %d: %s", i + 1, chunks[i]);
-        httpd_resp_sendstr_chunk(req, buffer);
-    }
-
-    // Add final summary
-    vTaskDelay(pdMS_TO_TICKS(500));
-    snprintf(buffer, sizeof(buffer), "\r\nTransfer completed in %d chunks with delays.\r\n", num_chunks);
-    httpd_resp_sendstr_chunk(req, buffer);
-
-    // Send NULL to signal end of chunked transfer
-    httpd_resp_sendstr_chunk(req, NULL);
-
-    printf("Async chunked response completed\r\n");
-    return ESP_OK;
-}
-
-static const httpd_uri_t hello = {
-    .uri       = "/hello",
-    .method    = HTTP_GET,
-    .handler   = hello_get_handler,
-    .user_ctx  = NULL
-};
-
-static const httpd_uri_t root = {
-    .uri       = "/",
-    .method    = HTTP_GET,
-    .handler   = root_get_handler,
-    .user_ctx  = NULL
-};
-
-static const httpd_uri_t test = {
-    .uri       = "/test",
-    .method    = HTTP_GET,
-    .handler   = test_get_handler,
-    .user_ctx  = NULL
-};
-
-static const httpd_uri_t async_uri = {
-    .uri       = "/async",
-    .method    = HTTP_GET,
-    .handler   = async_get_handler,
-    .user_ctx  = NULL
-};
-
-static esp_err_t start_http_server(void)
-{
-    if (http_server != NULL) {
-        printf("HTTP server already running\r\n");
-        return ESP_OK;
-    }
-
-    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
-    config.server_port = 8080;
-    config.lru_purge_enable = true;
-
-    printf("Starting HTTP server on port: %d\r\n", config.server_port);
-    if (httpd_start(&http_server, &config) == ESP_OK) {
-        printf("Registering URI handlers\r\n");
-        httpd_register_uri_handler(http_server, &hello);
-        httpd_register_uri_handler(http_server, &root);
-        httpd_register_uri_handler(http_server, &test);
-        httpd_register_uri_handler(http_server, &async_uri);
-        return ESP_OK;
-    }
-
-    printf("Error starting HTTP server!\r\n");
-    return ESP_FAIL;
-}
-
-static esp_err_t stop_http_server(void)
-{
-    if (http_server != NULL) {
-        httpd_stop(http_server);
-        http_server = NULL;
-        printf("HTTP server stopped\r\n");
-        return ESP_OK;
-    }
-    return ESP_OK;
-}
-
-/* HTTP Server AT Commands */
-static uint8_t at_test_httpd(uint8_t *cmd_name)
-{
-    uint8_t buffer[64] = {0};
-    snprintf((char *)buffer, 64, "AT%s=<0/1> - Start/Stop HTTP server\r\n", cmd_name);
-    esp_at_port_write_data(buffer, strlen((char *)buffer));
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_query_httpd(uint8_t *cmd_name)
-{
-    uint8_t buffer[64] = {0};
-    snprintf((char *)buffer, 64, "+HTTPD:%d\r\n", http_server != NULL ? 1 : 0);
-    esp_at_port_write_data(buffer, strlen((char *)buffer));
-    return ESP_AT_RESULT_CODE_OK;
-}
-
-static uint8_t at_setup_httpd(uint8_t para_num)
-{
-    int32_t action = 0;
-    if (esp_at_get_para_as_digit(0, &action) != ESP_AT_PARA_PARSE_RESULT_OK) {
-        return ESP_AT_RESULT_CODE_ERROR;
-    }
-
-    if (action == 1) {
-        if (start_http_server() == ESP_OK) {
-            printf("HTTP server started successfully\r\n");
-            return ESP_AT_RESULT_CODE_OK;
-        }
-    } else if (action == 0) {
-        if (stop_http_server() == ESP_OK) {
-            return ESP_AT_RESULT_CODE_OK;
-        }
-    }
-
-    return ESP_AT_RESULT_CODE_ERROR;
-}
-
-static uint8_t at_exe_httpd(uint8_t *cmd_name)
-{
-    // Default action: start server
-    if (start_http_server() == ESP_OK) {
-        printf("HTTP server started via execute command\r\n");
-        return ESP_AT_RESULT_CODE_OK;
-    }
-    return ESP_AT_RESULT_CODE_ERROR;
-}
-
-
-static const esp_at_cmd_struct at_custom_cmd[] = {
-    {"+PPPD", at_test_cmd_test, at_query_cmd_test, at_setup_cmd_test, at_exe_cmd_test},
-    {"+CEREG", at_test_cereg, at_query_cereg, at_setup_cereg, at_exe_cereg},
-    {"+HTTPD", at_test_httpd, at_query_httpd, at_setup_httpd, at_exe_httpd},
-};
-
-bool esp_at_custom_cmd_register(void)
-{
-    return esp_at_custom_cmd_array_regist(at_custom_cmd, sizeof(at_custom_cmd) / sizeof(esp_at_cmd_struct));
-}
-
-ESP_AT_CMD_SET_INIT_FN(esp_at_custom_cmd_register, 1);

common_components/modem_sim/pppd_cmd/include/at_custom_cmd.h

@@ -1,12 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-#include "esp_at_core.h"
-#include "esp_at.h"
-
-/**
- * @brief You can include more header files here for your own AT commands.
- */

common_components/modem_sim/sdkconfig.defaults

@@ -1,77 +0,0 @@
-# This file was generated using idf.py save-defconfig. It can be edited manually.
-# Espressif IoT Development Framework (ESP-IDF) 5.4.1 Project Minimal Configuration
-#
-CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y
-CONFIG_APP_PROJECT_VER_FROM_CONFIG=y
-CONFIG_APP_PROJECT_VER="v4.1.0.0-dev"
-CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
-CONFIG_PARTITION_TABLE_CUSTOM=y
-CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="module_config/module_esp32_default/partitions_at.csv"
-CONFIG_PARTITION_TABLE_MD5=n
-CONFIG_AT_CUSTOMIZED_PARTITION_TABLE_FILE="module_config/module_esp32_default/at_customize.csv"
-CONFIG_BT_ENABLED=y
-CONFIG_BT_BTU_TASK_STACK_SIZE=5120
-CONFIG_BT_BLE_BLUFI_ENABLE=y
-CONFIG_BT_STACK_NO_LOG=y
-CONFIG_BT_BLE_DYNAMIC_ENV_MEMORY=y
-CONFIG_BTDM_CTRL_MODE_BTDM=y
-CONFIG_BTDM_CTRL_LPCLK_SEL_EXT_32K_XTAL=y
-CONFIG_BTDM_SCAN_DUPL_CACHE_SIZE=200
-CONFIG_ESP_TLS_PSK_VERIFICATION=y
-CONFIG_ESP_TLS_INSECURE=y
-CONFIG_ESP_TLS_SKIP_SERVER_CERT_VERIFY=y
-CONFIG_ESP_ERR_TO_NAME_LOOKUP=n
-CONFIG_GPIO_ESP32_SUPPORT_SWITCH_SLP_PULL=y
-CONFIG_ETH_DMA_RX_BUFFER_NUM=3
-CONFIG_ETH_DMA_TX_BUFFER_NUM=3
-CONFIG_HTTPD_MAX_REQ_HDR_LEN=1024
-CONFIG_HTTPD_MAX_URI_LEN=1024
-CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP=y
-CONFIG_RTC_CLK_SRC_EXT_CRYS=y
-CONFIG_RTC_EXT_CRYST_ADDIT_CURRENT=y
-CONFIG_RTC_CLK_CAL_CYCLES=1024
-CONFIG_PM_ENABLE=y
-CONFIG_PM_SLP_DISABLE_GPIO=y
-CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_80=y
-CONFIG_ESP_TASK_WDT_PANIC=y
-CONFIG_ESP_TASK_WDT_TIMEOUT_S=60
-CONFIG_ESP_DEBUG_OCDAWARE=n
-CONFIG_ESP_WIFI_IRAM_OPT=n
-CONFIG_ESP_WIFI_RX_IRAM_OPT=n
-CONFIG_ESP_WIFI_SLP_IRAM_OPT=y
-CONFIG_ESP_WIFI_SLP_BEACON_LOST_OPT=y
-CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM=0
-CONFIG_FATFS_LFN_HEAP=y
-CONFIG_FREERTOS_UNICORE=y
-CONFIG_FREERTOS_HZ=1000
-CONFIG_FREERTOS_USE_TICKLESS_IDLE=y
-CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=n
-CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y
-CONFIG_HEAP_PLACE_FUNCTION_INTO_FLASH=y
-CONFIG_LOG_DEFAULT_LEVEL_ERROR=y
-CONFIG_LWIP_MAX_SOCKETS=16
-CONFIG_LWIP_SO_LINGER=y
-CONFIG_LWIP_SO_RCVBUF=y
-CONFIG_LWIP_IP4_REASSEMBLY=y
-CONFIG_LWIP_IP6_REASSEMBLY=y
-CONFIG_LWIP_IPV6_AUTOCONFIG=y
-CONFIG_LWIP_TCP_MAXRTX=6
-CONFIG_LWIP_TCP_SYNMAXRTX=3
-CONFIG_LWIP_PPP_SUPPORT=y
-CONFIG_LWIP_PPP_SERVER_SUPPORT=y
-CONFIG_LWIP_SNTP_MAX_SERVERS=3
-CONFIG_LWIP_SNTP_STARTUP_DELAY=n
-CONFIG_MBEDTLS_DYNAMIC_BUFFER=y
-CONFIG_MBEDTLS_DYNAMIC_FREE_CONFIG_DATA=y
-CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE=n
-CONFIG_MBEDTLS_HAVE_TIME_DATE=y
-CONFIG_MBEDTLS_DHM_C=y
-CONFIG_NEWLIB_NANO_FORMAT=y
-CONFIG_VFS_SUPPORT_TERMIOS=n
-CONFIG_WL_SECTOR_SIZE_512=y
-CONFIG_AT_PROCESS_TASK_STACK_SIZE=6144
-CONFIG_AT_MQTT_COMMAND_SUPPORT=y
-CONFIG_AT_HTTP_COMMAND_SUPPORT=y
-CONFIG_AT_BLE_COMMAND_SUPPORT=n
-CONFIG_AT_BLE_HID_COMMAND_SUPPORT=n
-CONFIG_AT_BLUFI_COMMAND_SUPPORT=n

components/asio/.cz.yaml

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

components/asio/CHANGELOG.md

@@ -1,26 +1,5 @@
 # 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" "port/src/asio_stub.cpp")
-set(asio_requires lwip sock_utils)
+set(asio_sources "asio/asio/src/asio.cpp")
+set(asio_requires lwip)
 
 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 "port/include" "asio/asio/include"
+                    INCLUDE_DIRS "asio/asio/include" "port/include"
                     PRIV_INCLUDE_DIRS ${asio_priv_includes}
                     PRIV_REQUIRES ${asio_requires})
 
@@ -30,7 +30,6 @@ 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,15 +1,6 @@
 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_length(), read_msg_.body());
+                ESP_LOGD("asio-chat:", "%s", read_msg_.body());
                 room_.deliver(read_msg_);
                 do_read_header();
             } else {

components/asio/examples/ssl_client_server/main/asio_ssl_main.cpp

@@ -17,8 +17,6 @@
 #include "asio/ssl.hpp"
 #include "asio/buffer.hpp"
 #include "esp_pthread.h"
-// allows for direct access to mbedtls specifics
-#include "asio/ssl/mbedtls_specific.hpp"
 
 extern const unsigned char server_pem_start[] asm("_binary_srv_crt_start");
 extern const unsigned char server_pem_end[]   asm("_binary_srv_crt_end");
@@ -219,7 +217,6 @@ void ssl_server_thread()
     io_context.run();
 }
 
-
 void ssl_client_thread()
 {
     asio::io_context io_context;
@@ -232,11 +229,6 @@ void ssl_client_thread()
     asio::ssl::context ctx(asio::ssl::context::tls_client);
 #if CONFIG_EXAMPLE_CLIENT_VERIFY_PEER
     ctx.add_certificate_authority(cert_chain);
-    // mbedtls (from 3.6.3) requires hostname to be set when performing TLS handshake with verify-peer option
-    // asio::ssl allows for name verification using verification callback, i.e. socket_.set_verify_callback(asio::ssl::host_name_verification()),
-    // - which is not supported in Espressif ASIO port yet.
-    // Therefore we provide a way to directly use mbedtls API and here we just configure the expected hostname to verify
-    asio::ssl::mbedtls::set_hostname(ctx.native_handle(), server_ip);
 #endif // CONFIG_EXAMPLE_CLIENT_VERIFY_PEER
 
     Client c(io_context, ctx, endpoints);

components/asio/examples/ssl_client_server/main/ca.crt

@@ -1,22 +1,22 @@
 -----BEGIN CERTIFICATE-----
-MIIDkzCCAnugAwIBAgIUb25LYOLubieEbKPQDiM+8T5p4yUwDQYJKoZIhvcNAQEL
+MIIDkzCCAnugAwIBAgIUNI5wldYysh6rtCzYmda6H414aRswDQYJKoZIhvcNAQEL
 BQAwWTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
 GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDESMBAGA1UEAwwJRXNwcmVzc2lmMB4X
-DTI1MDQwNzA5NDkzOFoXDTQ1MDQwMjA5NDkzOFowWTELMAkGA1UEBhMCQVUxEzAR
+DTIwMDEyMTA5MDk0NloXDTI1MDEyMDA5MDk0NlowWTELMAkGA1UEBhMCQVUxEzAR
 BgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5
 IEx0ZDESMBAGA1UEAwwJRXNwcmVzc2lmMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
-MIIBCgKCAQEArJsjwSNjPOBpTCRW+pIag9gJgRaNIjscea/ilRYRwAnqWKLNssNw
-Kye79KmQ5TxnOEvBIYjesArst1l7MghPLaELscCKo96jzCkSmgPLbxPs+5/E4daO
-9ItxOSH2mjOgG5yFQLEb8xOvsvWWrJAUBj6RBjhzgSYLYRbesWKAyVi9fxSuzfZm
-ROV0B2NsO1PlUDzweo9RYSuvpyNR3kddNnc6lJLXtZhf6IHczjFDFd5/PQuzLIO/
-Dbg+5AMpQykbMFhcQI/Y49GlMMXFDIaWjP+XfE/yUJ4GyYd2EzpDFDFMisnkuR9d
-LQgSXZNwygO8SIfYnnm1pwcGuG/fCQZYpQIDAQABo1MwUTAdBgNVHQ4EFgQUMTUG
-OZ7ujyz7oXSuhDgbpoPRo1cwHwYDVR0jBBgwFoAUMTUGOZ7ujyz7oXSuhDgbpoPR
-o1cwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAD5JwzRVEvnTK
-R2bfMNy60FmFNTOEEYP+XYoNGBiXVY3MRrWlfbY5Pbs4Nq7sCfzEWMj2UsjFmjZE
-DU6FdsaL6rhnps03MR5yiuE5w2aPiH/ijgzVfZtdLe6nKcnrv1YInjEKk+Y3qGu6
-2ZC+MEINPBfRiuN6gCAdxGiK81J4FPLlZImLO/g/0fSrIXCzBUzjoYRYjsy5AP60
-0kbaoGA/SshP0aeNvWB0wUab40idGXBFJ3vnEfMbLIMdc/uCqnzRpqK0m1DacwrI
-nTUMl0bI302Oa/gym+Ma0nJ1nVADcLKoZ1syWjyzIcl6zr+ITY5S+pbeO/geQgKh
-NSUkahX6MQ==
+MIIBCgKCAQEAyadSpRnIQBVbEAsbpkrKrOMlBOMIUmA8AfNyOYPLfv0Oa5lBiMAV
+3OQDu5tYyFYKwkCUqq65iAm50fPbSH71w1tkja6nZ1yAIM+TvpMlM/WiFGrhY+Tc
+kAcLcKUJyPxrv/glzoVslbqUgIhuhCSKA8uk1+ILcn3nWzPcbcowLx31+AHeZj8h
+bIAdj6vjqxMCFStp4IcA+ikmCk75LCN4vkkifdkebb/ZDNYCZZhpCBnCHyFAjPc4
+7C+FDVGT3/UUeeTy+Mtn+MqUAhB+W0sPDm1n2h59D4Z/MFm0hl6GQCAKeMJPzssU
+BBsRm6zoyPQ4VTqG0uwfNNbORyIfKONMUwIDAQABo1MwUTAdBgNVHQ4EFgQUGYLV
+EkgWzxjpltE6texha7zZVxowHwYDVR0jBBgwFoAUGYLVEkgWzxjpltE6texha7zZ
+VxowDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAb2EF4Zg2XWNb
+eZHnzupCDd9jAhwPqkt7F1OXvxJa/RFUSB9+2izGvikGGhuKY4f0iLuqF+bhExD9
+sapDcdFO2Suh4J3onbwEvmKvsv56K3xhapYg8WwPofpkVirnkwFjpQXGzrYxPujg
+BPmSy3psQrhvOr/WH7SefJv2qr4ikaugfE+3enY4PL+C1dSQAuNo1QGgWsZIu0c8
+TZybNZ13vNVMA+tgj2CM8FR3Etaabwtu3TTcAnO7aoBTix/bLBTuZoczhN8/MhG3
+GylmDzFI8a6aKxQL3Fi4PsM82hRKWu3gfs39sR1Ci4V22v8uO5EWBPK0QZvDSc1a
+KwwxI4zA0w==
 -----END CERTIFICATE-----

components/asio/examples/ssl_client_server/main/regenerate_test_certs.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-# This script generates self-signed certificates for testing purposes only.
-# DO NOT use these certificates in production environments.
-# These certificates are meant for development and testing of SSL/TLS functionality.
-
-# 1. Generate CA private key
-openssl genrsa -out ca.key 2048
-
-# 2. Generate CA certificate (validity: 20 years, CN=Espressif)
-openssl req -x509 -new -nodes -key ca.key -sha256 -days 7300 -out ca.crt -subj "/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd/CN=Espressif"
-
-# 3. Generate server private key
-openssl genrsa -out server.key 2048
-
-# 4. Generate server Certificate Signing Request (CSR)
-openssl req -new -key server.key -out server.csr -subj "/CN=localhost"
-
-# 5. Generate server certificate signed by CA (validity: 20 years)
-openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out srv.crt -days 7300 -sha256
-
-# 6. Clean up intermediate files
-rm server.csr ca.srl

components/asio/examples/ssl_client_server/main/server.key

@@ -1,27 +1,27 @@
 -----BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEA1zQFgwUxyIteLl5SiciuRBZbn/3KWRmsVpyo5JiYCK9NM3Q8
-dDur/dyQ4y2Mq0RVuM7uZL7VraRA4F9+Tm8D2BJ8q4Ai3nRDiGQkFEfbvX0Wic6P
-P6q7lKm65fnYMvbWHqhMOglr8e4b7dMOFpZdNLRZVcoP4/43+/9dOgOj7TXczTFs
-jnlLJBijOnwABf/xlTpTR7ZbQ3uOlckc0TK/Lqxex+NUq4dXQKa96a/wpA6smW38
-0XU5hvVBmhA9YNK86CIpAVOny9gNM1Wxv+aAdVZigNNi6Hht75neC0DhFqGbfpMi
-nLhW8qGwVtY3T1pM8HrpdAu5plkdvmcDm8tUAwIDAQABAoIBADHwOHc29V58ONa5
-vJ2MnCPgrFJsKlCSzJMst2SUpHMfeuK9zmmKj1bRoC2XnFUB/oJsQpXOUveAbi2i
-+0RoLpQtdhC2I2FLyYAU/OpX4n4OUPSZolQ74luVJ3HGkI0DCp0CoO220f3KK2D8
-4QAM1IQudayavyVBEOzBTXjw71FUCXmg0viBtd7JRSug9FR69PPLWP14uzo1viBA
-dtRsLePDyTatW+bfKkPwDG8hhJoummw+fYRPZbM05aWLmVvTiZ/eQtRq1jkwUNSH
-zXsJiCQbHLqwoXISiEsdagQM8hNW2bw5B+ijCQhWNj2ZZBZPJIRtI75sXiXGy2eC
-kDaP0cECgYEA8GpoGOyVZ+KMm7PVNcNbdLJrjpoNhdVXdGwR+yd3u6EoQ3MMD5tr
-4F7pFtN3IxwLoCSM/dnobysNFdKdQRnOB+o3uLADiPn9REM7ebuGUwUP3BWwkb7S
-orDVPUMA82A1p0T4Dwi+OAPpS5bUoI7S/6ZwheWTdoGZYjCrtsqkeEUCgYEA5Sc5
-sgLFWIqvYUQF/+aLAwjHR/bBD9NkvHgdW8GmgXdnEd0DIKHDpJ2yEK3BbQxVp/Kk
-O2KG1NGyJ9UqA9QQ3q5UgpZNHQBWxz2GUl0jHsy8enhgsZr4K2+wvuw5F5bCdXPe
-m/dyFIGnUJ7ic+DtvDGjXdcwAR8Cgc97m5Pg06cCgYEAgyjqBb78e6KDJ2biyOP9
-fxrfxvqQqhUMEz3qSWTs03ZGaxXW3KTkI5JkA8n2Uzc3uHR4Xv2E6zFHgEJY/G1B
-k9vZ7m5IX3BTFezAA9eknqJCVsWWgMzkSVHD5Bor6JryaoEb+8e/TvwDSPPOqJGC
-12pMNSBcZOirb4AyDhVbySkCgYB3Lu2dHj/SC1+oMR8Ft7y5eUlcroQ/XO1Z8Qck
-ABY/5ABhlBfaUwhUiAhjEFw4AWBTl6m/kUEbU21btkzB7PxRNU6TFOVKnjCENAW2
-tOZdUJL/B7kS5s0ImnDM/EO9dxXwzLENYaed7sk870ZMisJbTV3wosk+7Af7yBQ8
-GK+opQKBgQCdZy3KX2FT8S/K2SjDuRM8uDzJ+IcaqScDhgbJFMlrbWmTSML69oRD
-Ic6xVe5hWkkPIs521gwrQSD5E3dbb2dFmjhUZpZkHdv0u/AUupFN0EaCFb/I2A0P
-fRebd9oKoZjlUrEPeID0kjzbmnPGbtG+gFZYmkRb5iLdcCVAn0O1AQ==
+MIIEogIBAAKCAQEAlUCywNhVv4RO2y9h/XGKZ1azzk3jzHpSBzIGO9LoiA8trC/p
+1ykGaUfYPJllYK4HMhC4fUyE3J7tVL2Eskzl26LNPLbEoaBWZM9NhV3iA1/1EtOu
+p6umLx+y3sDfvK35YAOUbjdAlBfhnJ4r8h7oTsxl3J5jZ18zgjJnJi2NEFq/yTpO
+MiwHLWPjy25fDFixfV9UzSvbgt1JaGPmC7c4QkhHzjyp0+ikuvRIw0p9BBNeqBV2
+da3qBMB5FtodUJTAz6o6OKWbTalLjQi6C1H6z9TnY7IrJBUOy/FWkQH/sEsLdscD
+hHa1Dz2oT203QjhzyOSfnNF95D/1MdNcMt6l0wIDAQABAoIBAC1JJTOoMFRc48RT
+myrYQYNbZlEphv3q+2qdfhC2zMFDwbrmCtCy7PQSzYSNkpoEE8DYG/JAvmtmeWJl
+4pZrCK9ctWM/nWfhC3WpBL97nfEiM20T94F+bn0L5Cz8XqaULv839th+QUTt/hGU
+WIctY5VNJXcMQ+MAmtNdUbjex1d3iuxiKHUo4nDoZ8digKFNdtdP5B5nlMq5chCL
+mxNRcsGsx2dDAxbGUapdTVPWHPJKpLOBoSkluDsfd2KZADFU2R1SJpAX9+RYh3HM
+5FTUdHTUaISxbKkgeDKlEM0lqk2TtGUwCyEj098ewi7Wzsu9w60IplPPUJx5FRG6
+jp3wzLkCgYEAxKp5T20rf/7ysX7x053I7VCjDXUxAaWOEj1uS3AhOkl0NaZg7Di+
+y53fWNkcHdkt2n2LqMt/43UgMYq3TVVcq2eunPNF11e1bJw8CjDafwDs4omwwyVn
+lYhPuB4dK2OAib+vU5Zqpp0kZMoxk2MZVgon8z+s8DW/zmB6aFqAWeUCgYEAwkhC
+OgmXKMdjOCVy5t2f5UbY8Y9rV3w8eUATuJ47MMwLr4pGYnKoEn9JB4ltWrHv/u5S
+fOv3tIrrCEvnCoCbOILwCsY5LqTNXgqova8FB6RpMUQCzhDd8LHuvdHv0WMnMzX1
+3PKuqwh8JS55m4WqZRhzr5BFKG4fHPVs4IcaJVcCgYAzzCaJSdqUKqTnJOUydDNQ
+ddWMHNqccWs62J0tF0pZHLGT089hSAzQejMyJnSmU+Ykzr4y5e44DUg+ZCelIZ93
+saYmxlgVwI8THQ8fLADQRIEfpV4996MRmkZM2vmZzOo03Zyi6lIKsga82Rg3lnk8
+1Q3ynknBNpbfF0AGLhfyFQKBgBYlxJ73HutAJ5hr9HhLBYJOnEaVUehMOlycKGNg
+bmD2sdJWEgYBChXpurqIORYguLo4EuE4ySkkuPxeIr14wbkkfBbOWBBwKxUwY+IT
+xKAFZxR9q1AwbgyVTCEJgKw/AGX/HcMNS0omEnjunmBTUYRq0C1QZgHg490aQUor
+PJjLAoGAevzdTpFlVeuKeYh1oDubGO1LinyXpBv7fPFjl+zu4AVbjojcU6yC4OO6
+QvqopE6SyAECKy8kAOFcESPsGc9Lta2XUvI203z7pIVlNVEcJ0+90mQh3Mn1U46l
+sZ49PdRvNwNb5wvkh1UqNsMlGFbRlzMbIk45ou4311kCobowZek=
 -----END RSA PRIVATE KEY-----

components/asio/examples/ssl_client_server/main/srv.crt

@@ -1,18 +1,18 @@
 -----BEGIN CERTIFICATE-----
-MIIC9DCCAdwCFHNjaiCN2RT7W7NHXho8HlgxdAygMA0GCSqGSIb3DQEBCwUAMFkx
+MIIC9DCCAdwCFA1lSIcHwYKdB2UqOrZxZnVgPObTMA0GCSqGSIb3DQEBCwUAMFkx
 CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
-cm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMMCUVzcHJlc3NpZjAeFw0yNTA0
-MDcwOTQ5MzhaFw00NTA0MDIwOTQ5MzhaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCC
-ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANc0BYMFMciLXi5eUonIrkQW
-W5/9ylkZrFacqOSYmAivTTN0PHQ7q/3ckOMtjKtEVbjO7mS+1a2kQOBffk5vA9gS
-fKuAIt50Q4hkJBRH2719FonOjz+qu5SpuuX52DL21h6oTDoJa/HuG+3TDhaWXTS0
-WVXKD+P+N/v/XToDo+013M0xbI55SyQYozp8AAX/8ZU6U0e2W0N7jpXJHNEyvy6s
-XsfjVKuHV0Cmvemv8KQOrJlt/NF1OYb1QZoQPWDSvOgiKQFTp8vYDTNVsb/mgHVW
-YoDTYuh4be+Z3gtA4Rahm36TIpy4VvKhsFbWN09aTPB66XQLuaZZHb5nA5vLVAMC
-AwEAATANBgkqhkiG9w0BAQsFAAOCAQEAoiuycWVVjmS9IMS1n9ll8UlIqq8dl7vs
-Y5ckGMrdSGR8BPgloTrB6ual4vRPgbn2rGBGAvGusdcmhc1vkVbYsI3JRpTTDDoE
-PvQqHWXwV2RDRU5kG6ZOsU+o01Ir4b3w3qfP2LT20FCuuAMIMh23PsSmoc7ziFZ8
-76+ox6FjhJMPMF2aftiDmP44/fFg16C1t2PFH/Bk4sm4qRdpXVcWeiaHaSF9JkHa
-XwW3TuDSxJwlFFU7ffTRgYYkQ61q8B0LjWV4FF1dBBqflAiXEhWcVhljqfsWn7rq
-NBJ/QzZ3GhgQO9GOCokh/ckcp/ZMOm9tv9lV2huGz8Akk8/UYhMUEg==
+cm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMMCUVzcHJlc3NpZjAeFw0yMDA2
+MTIwNjA0MTNaFw0yMjA2MDIwNjA0MTNaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJVAssDYVb+ETtsvYf1ximdW
+s85N48x6UgcyBjvS6IgPLawv6dcpBmlH2DyZZWCuBzIQuH1MhNye7VS9hLJM5dui
+zTy2xKGgVmTPTYVd4gNf9RLTrqerpi8fst7A37yt+WADlG43QJQX4ZyeK/Ie6E7M
+ZdyeY2dfM4IyZyYtjRBav8k6TjIsBy1j48tuXwxYsX1fVM0r24LdSWhj5gu3OEJI
+R848qdPopLr0SMNKfQQTXqgVdnWt6gTAeRbaHVCUwM+qOjilm02pS40IugtR+s/U
+52OyKyQVDsvxVpEB/7BLC3bHA4R2tQ89qE9tN0I4c8jkn5zRfeQ/9THTXDLepdMC
+AwEAATANBgkqhkiG9w0BAQsFAAOCAQEAnMYGW+idt37bEE4WPgrRorKWuplR+zHD
+wJFz53DQzyIZJHmJ2hR5U0jNcHy/nMq7tbdz9LZPrVF4lZJ3TJhnmkOKjMFPCQE8
+YcmsP3il6eXgtGqg53InOi/uJqEQ9TfM54cbpp6xKbnmpwk4uprISBRQt7u2ZLk2
+40ED6zgjFPDTYmSjSpb2AN6KUB6PflgVs+4p9ViHNq4U3AlYV/BM0+3G4aMX2wNl
+ZIpQfOyuaYD5MU50mY+O+gDiiypkpYf6a6S4YJ1sMbavDsP7bW5UMnP0jKYR549q
+5hF1fdkXq52DfJ9ya2kl3mANFkKssQV+1KCBMxGoeqfakmJfa03xXA==
 -----END CERTIFICATE-----

components/asio/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.32.0"
+version: "1.28.2~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,5 +7,3 @@ 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

@@ -1,11 +0,0 @@
-//
-// 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/asio/ssl/mbedtls_specific.hpp

@@ -1,29 +0,0 @@
-//
-// SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
-//
-// SPDX-License-Identifier: BSL-1.0
-//
-
-#pragma once
-
-#include "asio/ssl/context_base.hpp"
-#include "asio/ssl/context.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-namespace asio {
-namespace ssl {
-namespace mbedtls {
-
-/**
- * @brief Configures specific hostname to be used in peer verification
- *
- * @param handle asio::ssl context handle type
- * @param name hostname to be verified (std::string ownership will be moved to ssl::context)
- *
- * @return true on success
- */
-bool set_hostname(asio::ssl::context::native_handle_type handle, std::string name);
-
-};
-};
-} // namespace asio::ssl::mbedtls

components/asio/port/include/esp_asio_config.h

@@ -0,0 +1,12 @@
+/*
+ * 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/include/mbedtls_context.hpp

@@ -1,5 +1,5 @@
 //
-// SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
+// SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
 //
 // SPDX-License-Identifier: BSL-1.0
 //
@@ -52,12 +52,6 @@ public:
         return nullptr;
     }
 
-    bool set_hostname(std::string hostname)
-    {
-        hostname_ = std::move(hostname);
-        return true;
-    }
-
     std::size_t size(container c) const
     {
         switch (c) {
@@ -76,7 +70,6 @@ public:
     const_buffer cert_chain_;
     const_buffer private_key_;
     const_buffer ca_cert_;
-    std::string hostname_;
 };
 
 /**

components/asio/port/mbedtls/include/mbedtls_engine.hpp

@@ -1,5 +1,5 @@
 //
-// SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
+// SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
 //
 // SPDX-License-Identifier: BSL-1.0
 //
@@ -16,11 +16,6 @@ namespace asio {
 namespace ssl {
 namespace mbedtls {
 
-bool set_hostname(asio::ssl::context::native_handle_type handle, std::string name)
-{
-    return handle->get()->set_hostname(std::move(name));
-}
-
 const char *error_message(int error_code)
 {
     static char error_buf[100];
@@ -30,7 +25,7 @@ const char *error_message(int error_code)
 
 void throw_alloc_failure(const char *location)
 {
-    asio::error_code ec(MBEDTLS_ERR_SSL_ALLOC_FAILED, asio::error::get_mbedtls_category());
+    asio::error_code ec( MBEDTLS_ERR_SSL_ALLOC_FAILED, asio::error::get_mbedtls_category());
     asio::detail::throw_error(ec, location);
 }
 
@@ -274,16 +269,6 @@ private:
             } else {
                 mbedtls_ssl_conf_ca_chain(&conf_, nullptr, nullptr);
             }
-
-            // Configure hostname before handshake if users pre-configured any
-            // use NULL if not set (to preserve the default behaviour of mbedtls < v3.6.3)
-            const char* hostname = !ctx->hostname_.empty() ? ctx->hostname_.c_str() : NULL;
-            ret = mbedtls_ssl_set_hostname(&ssl_, hostname);
-            if (ret < 0) {
-                print_error("mbedtls_ssl_set_hostname", ret);
-                return false;
-            }
-
             ret = mbedtls_ssl_setup(&ssl_, &conf_);
             if (ret) {
                 print_error("mbedtls_ssl_setup", ret);

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

@@ -8,7 +8,7 @@
 //
 
 #include "asio/detail/config.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
+#include "openssl_stub.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 "asio/ssl/detail/openssl_types.hpp"
+#include "openssl_stub.hpp"
 #include "asio/detail/throw_error.hpp"
 #include "asio/error.hpp"
 #include "asio/ssl/detail/engine.hpp"

components/asio/port/src/asio_stub.cpp

@@ -1,36 +0,0 @@
-//
-// 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

@@ -1,8 +0,0 @@
----
-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

@@ -1,7 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,87 +0,0 @@
-# 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

@@ -1,475 +0,0 @@
-/*
- * 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

@@ -1,73 +0,0 @@
-/*
- * 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

@@ -1,11 +0,0 @@
-# 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

@@ -1,174 +0,0 @@
-| 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

@@ -1,24 +0,0 @@
------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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,51 +0,0 @@
-/*
- * 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-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.1.0
+  version: 1.0.0
   version_files:
   - idf_component.yml

components/console_cmd_ping/CHANGELOG.md

@@ -1,11 +1,5 @@
 # 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,10 +1,4 @@
-idf_component_register(SRCS "console_ping.c" "console_getaddrinfo.c" "console_getsetdnsserver.c"
+idf_component_register(SRCS "console_ping.c"
                     INCLUDE_DIRS "."
-                    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()
+                    PRIV_REQUIRES esp_netif console
+                    WHOLE_ARCHIVE)

components/console_cmd_ping/Kconfig.projbuild

@@ -1,9 +0,0 @@
-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 and DNS server configuration
-The component provides a console where the 'ping' command, 'getaddrinfo', and DNS server configuration commands can be executed.
+# Console command ping
+The component provides a console where the 'ping' command can be executed.
 
 ## API
 
@@ -27,11 +27,8 @@ The component provides a console where the 'ping' command, 'getaddrinfo', and DN
     // Register all plugin command added to your project
     ESP_ERROR_CHECK(console_cmd_all_register());
 
-    // To register only ping/dns command skip calling console_cmd_all_register()
+    // To register only ifconfig 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
     ```
@@ -39,8 +36,6 @@ The component provides a console where the 'ping' command, 'getaddrinfo', and DN
 ### 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)
 
 
@@ -57,72 +52,4 @@ 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

@@ -1,180 +0,0 @@
-/*
- * 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

@@ -1,279 +0,0 @@
-/*
- * 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-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2023 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,13 +75,9 @@ 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);
@@ -154,15 +150,11 @@ 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-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -20,30 +20,6 @@ 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.1.0
+version: 1.0.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.1.0
+  version: 1.0.1
   version_files:
   - idf_component.yml

components/console_cmd_wifi/CHANGELOG.md

@@ -1,11 +1,5 @@
 # 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,8 +1,4 @@
 idf_component_register(SRCS "console_wifi.c"
-                    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()
+                    INCLUDE_DIRS "."
+                    PRIV_REQUIRES esp_netif console esp_wifi
+                    WHOLE_ARCHIVE)

components/console_cmd_wifi/Kconfig.projbuild

@@ -1,22 +0,0 @@
-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,16 +33,12 @@ 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/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.
- ```
+* ```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.

components/console_cmd_wifi/console_wifi.c

@@ -21,7 +21,6 @@
 
 #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.
@@ -31,7 +30,6 @@ 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;
@@ -57,9 +55,8 @@ 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 = 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 = "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 = "leave", .operation = wifi_sta_leave_op,  .arg_cnt = 3, .start_index = 2, .help = "wifi sta leave: Station leaves the wifi network."},
 };
 
@@ -165,6 +162,7 @@ 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],
@@ -186,13 +184,7 @@ static esp_err_t wifi_sta_join_op(wifi_op_t *self, int argc, char *argv[])
         return ESP_FAIL;
     }
 
-    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));
-    }
-
+    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));
     }
@@ -268,7 +260,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_OK;
+    esp_err_t ret;
     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.1.0
+version: 1.0.1
 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

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

components/eppp_link/CHANGELOG.md

@@ -1,35 +1,5 @@
 # Changelog
 
-## [1.0.0](https://github.com/espressif/esp-protocols/commits/eppp-v1.0.0)
-
-### Features
-
-- Add support for custom channels ([4ee9360f](https://github.com/espressif/esp-protocols/commit/4ee9360f))
-
-## [0.3.1](https://github.com/espressif/esp-protocols/commits/eppp-v0.3.1)
-
-### Bug Fixes
-
-- Fix NETIF_PPP_STATUS link issue if PPP disabled in lwip ([077ea0bb](https://github.com/espressif/esp-protocols/commit/077ea0bb))
-
-## [0.3.0](https://github.com/espressif/esp-protocols/commits/eppp-v0.3.0)
-
-### Features
-
-- Add support for TUN interface ([2ff150c3](https://github.com/espressif/esp-protocols/commit/2ff150c3))
-- Add support for transport via Ethernet link ([a21ce883](https://github.com/espressif/esp-protocols/commit/a21ce883))
-
-## [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

components/eppp_link/CMakeLists.txt

@@ -1,33 +1,3 @@
-if("${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}" VERSION_GREATER "5.3")
-    set(driver_deps esp_driver_gpio esp_driver_spi)
-else()
-    set(driver_deps driver)
-endif()
-
-if(CONFIG_EPPP_LINK_DEVICE_ETH)
-    set(transport_src eppp_eth.c)
-endif()
-
-if(CONFIG_EPPP_LINK_DEVICE_SPI)
-    set(transport_src eppp_spi.c)
-endif()
-
-if(CONFIG_EPPP_LINK_DEVICE_UART)
-    set(transport_src eppp_uart.c)
-endif()
-
-if(CONFIG_EPPP_LINK_DEVICE_SDIO)
-    set(transport_src eppp_sdio.c eppp_sdio_slave.c eppp_sdio_host.c)
-endif()
-
-if(NOT CONFIG_EPPP_LINK_USES_PPP)
-    set(netif_src eppp_netif_tun.c)
-endif()
-
-idf_component_register(SRCS eppp_link.c ${transport_src} ${netif_src}
+idf_component_register(SRCS "eppp_link.c"
                     INCLUDE_DIRS "include"
-                    PRIV_REQUIRES esp_netif esp_timer esp_eth ${driver_deps})
-
-if(CONFIG_EPPP_LINK_DEVICE_ETH)
-    idf_component_optional_requires(PRIVATE ethernet_init espressif__ethernet_init)
-endif()
+                    PRIV_REQUIRES esp_netif esp_driver_spi esp_driver_gpio esp_timer driver)

components/eppp_link/Kconfig

@@ -1,16 +1,10 @@
 menu "eppp_link"
 
-    config EPPP_LINK_USES_PPP
-        bool "Use PPP network interface"
-        default "n"
+    config EPPP_LINK_USES_LWIP
+        bool
+        default "y"
         select LWIP_PPP_SUPPORT
         select LWIP_PPP_SERVER_SUPPORT
-        help
-            Enable this option to use PPP network interface.
-            This is useful when pairing with another PPP device,
-            e.g. pppd service on Linux.
-            By default EPPP_LINK uses plain TUN interface,
-            relying on transports to split on packet boundaries.
 
     choice EPPP_LINK_DEVICE
         prompt "Choose PPP device"
@@ -27,23 +21,6 @@ menu "eppp_link"
             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.
-
-        config EPPP_LINK_DEVICE_ETH
-            bool "Ethernet"
-            depends on SOC_EMAC_SUPPORTED
-            help
-                Use Ethernet.
-                This transport could employ a full fledged Ethernet connection
-                between two EPPP nodes via standard Ethernet cable.
-                It could be also effectively connected directly on PCB, EMAC to EMAC,
-                without any Ethernet PHY chips (using eth_dummy_phy driver).
-
     endchoice
 
     config EPPP_LINK_CONN_MAX_RETRY
@@ -57,57 +34,8 @@ menu "eppp_link"
     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
-
-    config EPPP_LINK_ETHERNET_OUR_ADDRESS
-        string "MAC address our local node"
-        default "06:00:00:00:00:01"
-        depends on EPPP_LINK_DEVICE_ETH
-
-    config EPPP_LINK_ETHERNET_THEIR_ADDRESS
-        string "MAC address the remote node"
-        default "06:00:00:00:00:02"
-        depends on EPPP_LINK_DEVICE_ETH
-
-    config EPPP_LINK_CHANNELS_SUPPORT
-        bool "Enable channel support (multiple logical channels)"
-        default n
-        depends on !EPPP_LINK_DEVICE_ETH
-        help
-            Enable support for multiple logical channels in the EPPP link layer.
-            When enabled, you can configure the number of channels used for communication.
-
-    config EPPP_LINK_NR_OF_CHANNELS
-        int "Number of logical channels"
-        depends on EPPP_LINK_CHANNELS_SUPPORT && !EPPP_LINK_DEVICE_ETH
-        range 1 8
-        default 2
-        help
-            Set the number of logical channels for EPPP link communication.
-            Each channel can be used for independent data streams.
-
 endmenu

components/eppp_link/README.md

@@ -1,74 +1,24 @@
 # ESP PPP Link component (eppp_link)
 
-The component provides a general purpose connectivity engine between two microcontrollers, one acting as PPP server, the other one as PPP client.
-This component could be used for extending network using physical serial connection. Applications could vary from providing RPC engine for multiprocessor solutions to serial connection to POSIX machine. This uses a standard PPP protocol (if enabled) 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.
-Uses simplified TUN network interface by default to enable faster data transfer on non-UART transports.
+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 communication coprocessor, or a "SLAVE" microcontroller.
-The main microcontroller (sometimes also called the "HOST") runs PPP client and connects only to the serial line,
-brings in the WiFi connectivity from the communication coprocessor.
+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.
 
 ```
-        Communication coprocessor                        Main microcontroller
-    \|/  +----------------+                               +----------------+
-     |   |                |       (serial) line           |                |
-     +---+ WiFi NAT PPPoS |=== UART / SPI / SDIO / ETH ===| PPPoS client   |
-         |        (server)|                               |                |
-         +----------------+                               +----------------+
+             SLAVE micro                                  HOST micro
+    \|/  +----------------+                           +----------------+
+     |   |                |          serial line      |                |
+     +---+ WiFi NAT PPPoS |======== UART / SPI =======| PPPoS client   |
+         |        (server)|                           |                |
+         +----------------+                           +----------------+
 ```
 
-## Features
-
-### Network Interface Modes
-
-Standard PPP Mode (where PPP protocols is preferred) or simple tunnel using TUN Mode.
-
-### Transport layer
-
-UART, SPI, SDIO, Ethernet
-
-### Support for logical channels
-
-Allows channeling custom data (e.g. 802.11 frames)
-
-## (Other) usecases
-
-Besides the communication coprocessor example mentioned above, this component could be used to:
-* Bring Wi-Fi connectivity to a computer using ESP32 chip.
-* Connect your microcontroller to the internet via a pppd server (running on a raspberry)
-* Bridging two networks with two microcontrollers
-
-## Configuration
-
-### Choose the transport layer
-
-Use `idf.py menuconfig` to select the transport layer:
-
-* `CONFIG_EPPP_LINK_UART` -- Use UART transport layer
-* `CONFIG_EPPP_LINK_SPI` -- Use SPI transport layer
-* `CONFIG_EPPP_LINK_SDIO` -- Use SDIO transport layer
-* `CONFIG_EPPP_LINK_ETHERNET` -- Use Ethernet transport
-  - Note: Ethernet creates it's own task, so calling `eppp_perform()` would not work
-  - Note: Add dependency to ethernet_init component to use other Ethernet drivers
-  - Note: You can override functions `eppp_transport_ethernet_deinit()` and `eppp_transport_ethernet_init()` to use your own Ethernet driver
-
-### Choose the network interface
-
-Use PPP netif for UART; Keep the default (TUN) for others
-
-### Channel support (multiple logical channels)
-
-* `CONFIG_EPPP_LINK_CHANNELS_SUPPORT` -- Enable support for multiple logical channels (default: disabled)
-* `CONFIG_EPPP_LINK_NR_OF_CHANNELS` -- Number of logical channels (default: 2, range: 1-8, only visible if channel support is enabled)
-
-When channel support is enabled, the EPPP link can multiplex multiple logical data streams over the same transport. The number of channels is configurable. Channel support is not available for Ethernet transport.
-
-To use channels in your application, use the `eppp_add_channels()` API and provide your own channel transmit/receive callbacks. These APIs and related types are only available when channel support is enabled in Kconfig.
-
 ## API
 
 ### Client
@@ -86,31 +36,17 @@ To use channels in your application, use the `eppp_add_channels()` API and provi
 * `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)
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-* `eppp_add_channels()` -- Register channel transmit/receive callbacks (only available if channel support is enabled)
-#endif
 
 ## Throughput
 
-Tested with WiFi-NAPT example
+Tested with WiFi-NAPT example, no IRAM optimizations
 
 ### UART @ 3Mbauds
 
 * TCP - 2Mbits/s
 * UDP - 2Mbits/s
 
-### SPI @ 16MHz
+### SPI @ 20MHz
 
-* TCP - 5Mbits/s
-* UDP - 8Mbits/s
-
-### SDIO
-
-* TCP - 9Mbits/s
-* UDP - 11Mbits/s
-
-### Ethernet
-
-- Internal EMAC with real PHY chip
-    * TCP - 5Mbits/s
-    * UDP - 8Mbits/s
+* TCP - 6Mbits/s
+* UDP - 10Mbits/s

components/eppp_link/detailed_description.md

@@ -1,370 +0,0 @@
-# ESP PPP Link Component (eppp_link) - Detailed Documentation
-
-## Overview
-
-The ESP PPP Link component provides a versatile communication bridge between two ESP32 microcontrollers, enabling network connectivity over various physical transport layers. One device acts as a server (typically providing connectivity), while the other acts as a client (consuming connectivity).
-
-## Network Interface Modes
-
-### PPP Mode vs TUN Mode
-
-The component supports two distinct network interface modes:
-
-#### PPP Mode (`CONFIG_EPPP_LINK_USES_PPP=y`)
-- **Standard PPP Protocol**: Uses the Point-to-Point Protocol (RFC 1661) with full LCP negotiation
-- **Compatibility**: Compatible with standard PPP implementations like Linux `pppd`
-- **Features**:
-  - Automatic IP address negotiation
-  - Link Control Protocol (LCP) for connection establishment
-  - Authentication support (if configured)
-  - Standard PPP framing with escape sequences
-- **Use Case**: When interfacing with standard PPP-capable systems or when full PPP compatibility is required
-- **Transport Limitation**: Primarily designed for UART transport due to PPP's serial nature
-
-#### TUN Mode (`CONFIG_EPPP_LINK_USES_PPP=n`, default)
-- **Simplified Packet Interface**: Uses a custom packet-based protocol without PPP negotiation
-- **Performance**: Faster data transfer due to reduced protocol overhead
-- **Features**:
-  - Direct IP packet transmission
-  - Custom framing for packet boundaries
-  - No negotiation overhead
-  - Static IP address configuration
-- **Use Case**: Default mode for ESP-to-ESP communication, optimal for non-UART transports
-- **Transport Support**: Works efficiently with all transport types (UART, SPI, SDIO, Ethernet)
-
-**Mode Selection**: Configure via `idf.py menuconfig` → `Component config` → `eppp_link` → `Use PPP network interface`
-
-## Transport Layer Options
-
-### UART Transport
-- **Configuration**: `CONFIG_EPPP_LINK_DEVICE_UART=y`
-- **Features**:
-  - Simple serial communication
-  - Configurable baud rate (up to 3Mbps tested)
-  - Hardware flow control support
-  - Custom framing for packet boundaries in TUN mode
-- **Performance**: ~2 Mbps (TCP/UDP) @ 3 Mbaud
-- **Use Case**: Basic connectivity, long-distance communication, debugging
-- **Pins**: TX, RX configurable
-
-```c
-eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-config.transport = EPPP_TRANSPORT_UART;
-config.uart.tx_io = 25;
-config.uart.rx_io = 26;
-config.uart.baud = 921600;
-```
-
-### SPI Transport
-- **Configuration**: `CONFIG_EPPP_LINK_DEVICE_SPI=y`
-- **Features**:
-  - Master/slave configuration
-  - GPIO interrupt signaling for flow control
-  - Configurable clock frequency
-  - Full-duplex communication
-  - Packet queue for transmission
-- **Performance**: ~5 Mbps (TCP), ~8 Mbps (UDP) @ 16MHz
-- **Use Case**: High-speed local communication, PCB-level connections
-- **Pins**: MOSI, MISO, SCLK, CS, interrupt GPIO
-
-```c
-eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-config.transport = EPPP_TRANSPORT_SPI;
-config.spi.is_master = true;
-config.spi.freq = 16000000;
-config.spi.mosi = 11;
-config.spi.miso = 13;
-config.spi.sclk = 12;
-config.spi.cs = 10;
-config.spi.intr = 2;
-```
-
-### SDIO Transport
-- **Configuration**: `CONFIG_EPPP_LINK_DEVICE_SDIO=y`
-- **Features**:
-  - Host/slave configuration
-  - High-speed data transfer
-  - 1-bit or 4-bit bus width
-  - Hardware flow control
-- **Performance**: ~9 Mbps (TCP), ~11 Mbps (UDP)
-- **Use Case**: Highest throughput applications, module-to-module communication
-- **Pins**: CLK, CMD, D0-D3 (configurable width)
-
-```c
-eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-config.transport = EPPP_TRANSPORT_SDIO;
-config.sdio.is_host = true;
-config.sdio.width = 4;
-config.sdio.clk = 18;
-config.sdio.cmd = 19;
-config.sdio.d0 = 14;
-// ... additional data pins
-```
-
-### Ethernet Transport
-- **Configuration**: `CONFIG_EPPP_LINK_DEVICE_ETH=y`
-- **Features**:
-  - Direct MAC-to-MAC communication
-  - Can work with or without PHY chips
-  - Standard Ethernet framing
-  - Automatic task management (no `eppp_perform()` needed)
-- **Performance**: ~5 Mbps (TCP), ~8 Mbps (UDP) with internal EMAC
-- **Use Case**: Board-to-board communication, integration with existing Ethernet infrastructure
-- **Pins**: MDC, MDIO, plus PHY-specific pins
-
-```c
-eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-config.transport = EPPP_TRANSPORT_ETHERNET;
-config.ethernet.mdc_io = 23;
-config.ethernet.mdio_io = 18;
-config.ethernet.phy_addr = 1;
-config.ethernet.rst_io = 5;
-```
-
-## Channel Support (Multiple Logical Channels)
-
-### Overview
-Channel support allows multiplexing multiple independent data streams over a single transport connection. This enables applications to separate different types of data (e.g., network traffic, control commands, sensor data) into distinct logical channels.
-
-### Configuration
-- **Enable**: `CONFIG_EPPP_LINK_CHANNELS_SUPPORT=y`
-- **Count**: `CONFIG_EPPP_LINK_NR_OF_CHANNELS` (1-8 channels, default 2)
-- **Limitation**: Not available for Ethernet transport
-
-### Channel Usage
-```c
-// Channel callback function type
-typedef esp_err_t (*eppp_channel_fn_t)(esp_netif_t *netif, int nr, void *buffer, size_t len);
-
-// Register channel callbacks
-esp_err_t eppp_add_channels(esp_netif_t *netif,
-                           eppp_channel_fn_t *tx,     // Transmit function pointer (output)
-                           const eppp_channel_fn_t rx, // Receive callback (input)
-                           void* context);             // User context
-
-// Get user context
-void* eppp_get_context(esp_netif_t *netif);
-```
-
-### Channel Example
-```c
-// Channel 0: Default network traffic (handled automatically)
-// Channel 1: Control/chat messages
-// Channel 2: WiFi data forwarding
-
-static esp_err_t channel_receive(esp_netif_t *netif, int channel, void *buffer, size_t len)
-{
-    switch(channel) {
-        case 1: // Control channel
-            process_control_message(buffer, len);
-            break;
-        case 2: // WiFi channel
-            forward_to_wifi(buffer, len);
-            break;
-        default:
-            ESP_LOGE(TAG, "Unknown channel %d", channel);
-            return ESP_FAIL;
-    }
-    return ESP_OK;
-}
-
-// Register channels
-eppp_channel_fn_t tx_func;
-eppp_add_channels(netif, &tx_func, channel_receive, user_context);
-
-// Transmit on specific channel
-tx_func(netif, 1, "Hello", 5);  // Send to channel 1
-```
-
-## API Reference
-
-### Simple API (Recommended for most use cases)
-
-#### Client Side
-```c
-esp_netif_t *eppp_connect(eppp_config_t *config);
-```
-- **Purpose**: Simplified client connection
-- **Behavior**: Blocks until connection is established
-- **Returns**: Configured network interface or NULL on failure
-- **Use Case**: Simple applications that don't need fine-grained control
-
-#### Server Side
-```c
-esp_netif_t *eppp_listen(eppp_config_t *config);
-```
-- **Purpose**: Simplified server listening
-- **Behavior**: Blocks until client connects
-- **Returns**: Configured network interface or NULL on failure
-- **Use Case**: Simple applications that don't need fine-grained control
-
-#### Connection Management
-```c
-void eppp_close(esp_netif_t *netif);
-```
-- **Purpose**: Close connection and cleanup resources
-- **Behavior**: Stops tasks, closes transport, destroys network interface
-
-### Advanced API (Manual Control)
-
-#### Initialization
-```c
-esp_netif_t *eppp_init(eppp_type_t role, eppp_config_t *config);
-```
-- **Purpose**: Initialize endpoint without starting communication
-- **Parameters**:
-  - `role`: `EPPP_SERVER` or `EPPP_CLIENT`
-  - `config`: Transport and network configuration
-- **Returns**: Network interface handle
-- **Use Case**: Applications needing manual control over connection lifecycle
-
-#### Connection Control
-```c
-esp_err_t eppp_netif_start(esp_netif_t *netif);
-esp_err_t eppp_netif_stop(esp_netif_t *netif, int stop_timeout_ms);
-```
-- **Purpose**: Manual network interface start/stop
-- **Use Case**: Dynamic connection management, error recovery
-
-#### Task Management
-```c
-esp_err_t eppp_perform(esp_netif_t *netif);
-```
-- **Purpose**: Single iteration of communication task
-- **Returns**:
-  - `ESP_OK`: Continue operation
-  - `ESP_FAIL`: Operation failed but should continue
-  - `ESP_ERR_TIMEOUT`: Stop operation requested
-- **Use Case**: Task-less operation, integration with custom task schedulers
-- **Note**: Not needed for Ethernet transport (has its own task)
-
-#### Resource Management
-```c
-void eppp_deinit(esp_netif_t *netif);
-```
-- **Purpose**: Clean up resources without stopping tasks
-- **Use Case**: Manual resource management
-
-## Configuration Examples
-
-### Basic Client-Server Setup
-
-**Client (Host) Configuration:**
-```c
-void app_main(void)
-{
-    ESP_ERROR_CHECK(esp_netif_init());
-    ESP_ERROR_CHECK(esp_event_loop_create_default());
-
-    eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-    config.transport = EPPP_TRANSPORT_UART;
-    config.uart.tx_io = 25;
-    config.uart.rx_io = 26;
-    config.uart.baud = 921600;
-
-    esp_netif_t *netif = eppp_connect(&config);
-    if (netif == NULL) {
-        ESP_LOGE(TAG, "Failed to connect");
-        return;
-    }
-
-    ESP_LOGI(TAG, "Connected successfully");
-    // Use network interface for communication
-}
-```
-
-**Server (Slave) Configuration:**
-```c
-void app_main(void)
-{
-    ESP_ERROR_CHECK(esp_netif_init());
-    ESP_ERROR_CHECK(esp_event_loop_create_default());
-
-    // Initialize WiFi or other network interface
-    init_wifi();
-
-    eppp_config_t config = EPPP_DEFAULT_SERVER_CONFIG();
-    config.transport = EPPP_TRANSPORT_UART;
-    config.uart.tx_io = 26;  // Crossed with client
-    config.uart.rx_io = 25;  // Crossed with client
-    config.uart.baud = 921600;
-
-    esp_netif_t *netif = eppp_listen(&config);
-    if (netif == NULL) {
-        ESP_LOGE(TAG, "Failed to setup server");
-        return;
-    }
-
-    // Enable NAT to share WiFi connection
-    ESP_ERROR_CHECK(esp_netif_napt_enable(netif));
-    ESP_LOGI(TAG, "Server ready");
-}
-```
-
-### Advanced Manual Control
-```c
-void app_main(void)
-{
-    ESP_ERROR_CHECK(esp_netif_init());
-    ESP_ERROR_CHECK(esp_event_loop_create_default());
-
-    eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-    config.task.run_task = false;  // Disable automatic task
-
-    esp_netif_t *netif = eppp_init(EPPP_CLIENT, &config);
-    if (netif == NULL) {
-        ESP_LOGE(TAG, "Failed to initialize");
-        return;
-    }
-
-    // Start network interface
-    ESP_ERROR_CHECK(eppp_netif_start(netif));
-
-    // Custom task loop
-    while (true) {
-        esp_err_t ret = eppp_perform(netif);
-        if (ret == ESP_ERR_TIMEOUT) {
-            ESP_LOGI(TAG, "Operation stopped");
-            break;
-        } else if (ret != ESP_OK) {
-            ESP_LOGE(TAG, "Operation failed: %s", esp_err_to_name(ret));
-        }
-
-        // Add custom processing here
-        vTaskDelay(pdMS_TO_TICKS(1));
-    }
-
-    eppp_deinit(netif);
-}
-```
-
-### Multi-Channel Configuration
-```c
-typedef struct {
-    eppp_channel_fn_t tx_func;
-    esp_netif_t *netif;
-} channel_context_t;
-
-static esp_err_t channel_rx(esp_netif_t *netif, int channel, void *buffer, size_t len)
-{
-    ESP_LOGI(TAG, "Channel %d received %d bytes", channel, len);
-    // Process channel data based on channel number
-    return ESP_OK;
-}
-
-void setup_channels(void)
-{
-    eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
-    esp_netif_t *netif = eppp_connect(&config);
-
-    channel_context_t *ctx = calloc(1, sizeof(channel_context_t));
-    ctx->netif = netif;
-
-    // Register channel callbacks
-    ESP_ERROR_CHECK(eppp_add_channels(netif, &ctx->tx_func, channel_rx, ctx));
-
-    // Send data on channel 1
-    const char *msg = "Hello on channel 1";
-    ctx->tx_func(netif, 1, (void*)msg, strlen(msg));
-}
-```

components/eppp_link/eppp_eth.c

@@ -1,210 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include "esp_log.h"
-#include "esp_netif.h"
-#include "esp_check.h"
-#include "esp_event.h"
-#include "esp_mac.h"
-#include "esp_idf_version.h"
-#include "eppp_link.h"
-#include "eppp_transport.h"
-#include "esp_eth_driver.h"
-#include "esp_eth_spec.h"
-#include "eppp_transport_eth.h"
-// Use Ethernet Init component if available
-// (otherwise use just simple init/deinit with generic MAC/PHY)
-#if __has_include("ethernet_init.h")
-#define USE_ETHERNET_INIT_COMPONENT
-#include "ethernet_init.h"
-#endif
-
-typedef struct header {
-    uint8_t dst[ETH_ADDR_LEN];
-    uint8_t src[ETH_ADDR_LEN];
-    uint16_t len;
-} __attribute__((packed)) header_t;
-
-static const char *TAG = "eppp_ethernet";
-static bool s_is_connected = false;
-static esp_eth_handle_t *s_eth_handles = NULL;
-static uint8_t s_their_mac[ETH_ADDR_LEN];
-static uint8_t s_our_mac[ETH_ADDR_LEN];
-
-#ifndef USE_ETHERNET_INIT_COMPONENT
-static esp_eth_handle_t s_handles[1] = { NULL };
-static esp_eth_mac_t *s_mac = NULL;
-static esp_eth_phy_t *s_phy = NULL;
-
-static void simple_deinit(esp_eth_handle_t *handle_array[])
-{
-    if (s_handles[0] != NULL) {
-        esp_eth_driver_uninstall(s_handles[0]);
-        s_handles[0] = NULL;
-    }
-    if (s_mac != NULL) {
-        s_mac->del(s_mac);
-        s_mac = NULL;
-    }
-    if (s_phy != NULL) {
-        s_phy->del(s_phy);
-        s_phy = NULL;
-    }
-}
-
-static esp_err_t simple_init(struct eppp_config_ethernet_s *config, esp_eth_handle_t *handle_array[])
-{
-    esp_err_t ret = ESP_OK;
-    eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
-    eth_esp32_emac_config_t esp32_emac_config = ETH_ESP32_EMAC_DEFAULT_CONFIG();
-    esp32_emac_config.smi_gpio.mdc_num = config->mdc_io;
-    esp32_emac_config.smi_gpio.mdio_num = config->mdio_io;
-    s_mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
-    eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
-    phy_config.phy_addr = config->phy_addr;
-    phy_config.reset_gpio_num = config->rst_io;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 0)
-    s_phy = esp_eth_phy_new_generic(&phy_config);
-#else
-    s_phy = esp_eth_phy_new_ip101(&phy_config);
-#endif
-    esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(s_mac, s_phy);
-    ESP_GOTO_ON_ERROR(esp_eth_driver_install(&eth_config, &s_handles[0]), err, TAG, "Ethernet driver install failed");
-    *handle_array = s_handles;
-    return ESP_OK;
-err:
-    simple_deinit(handle_array);
-    return ret;
-}
-
-#endif // USE_ETHERNET_INIT_COMPONENT
-
-static void event_handler(void *arg, esp_event_base_t event_base,
-                          int32_t event_id, void *event_data)
-{
-    switch (event_id) {
-    case ETHERNET_EVENT_CONNECTED:
-        ESP_LOGI(TAG, "Ethernet Link Up");
-        s_is_connected = true;
-        break;
-    case ETHERNET_EVENT_DISCONNECTED:
-        ESP_LOGI(TAG, "Ethernet Link Down");
-        s_is_connected = false;
-        break;
-    case ETHERNET_EVENT_START:
-        ESP_LOGI(TAG, "Ethernet Started");
-        break;
-    case ETHERNET_EVENT_STOP:
-        ESP_LOGI(TAG, "Ethernet Stopped");
-        break;
-    default:
-        break;
-    }
-}
-
-static esp_err_t receive(esp_eth_handle_t h, uint8_t *buffer, uint32_t len, void *netif)
-{
-    header_t *head = (header_t *)buffer;
-    size_t packet_len = head->len;
-    if (len >= packet_len) {
-        esp_err_t ret = esp_netif_receive(netif, buffer + ETH_HEADER_LEN, packet_len, NULL);
-        free(buffer);
-        return ret;
-    }
-    return ESP_FAIL;
-}
-
-__attribute__((weak)) esp_err_t eppp_transport_ethernet_init(struct eppp_config_ethernet_s *config, esp_eth_handle_t *handle_array[])
-{
-#ifdef USE_ETHERNET_INIT_COMPONENT
-    uint8_t eth_port_cnt = 0;
-    ESP_RETURN_ON_ERROR(ethernet_init_all(handle_array, &eth_port_cnt), TAG, "Failed to init common eth drivers");
-    ESP_RETURN_ON_FALSE(eth_port_cnt == 1, ESP_ERR_INVALID_ARG, TAG, "multiple Ethernet devices detected, please init only one");
-    return ESP_OK;
-#else
-    return simple_init(config, handle_array);
-#endif
-}
-
-__attribute__((weak)) void eppp_transport_ethernet_deinit(esp_eth_handle_t *handle_array[])
-{
-#ifdef USE_ETHERNET_INIT_COMPONENT
-    ethernet_deinit_all(s_eth_handles);
-#else
-    simple_deinit(handle_array);
-#endif
-}
-
-esp_err_t eppp_transport_tx(void *h, void *buffer, size_t len)
-{
-    static uint8_t out_buffer[ETH_HEADER_LEN];
-    if (!s_is_connected) {
-        return ESP_FAIL;
-    }
-    // setup Ethernet header
-    header_t *head = (header_t *)out_buffer;
-    memcpy(head->dst, s_their_mac, ETH_ADDR_LEN);
-    memcpy(head->src, s_our_mac, ETH_ADDR_LEN);
-    head->len = len;
-    // support only payloads with len <=  ETH_MAX_PAYLOAD_LEN
-    if (len > ETH_MAX_PAYLOAD_LEN) {
-        return ESP_FAIL;
-    }
-    return esp_eth_transmit_vargs(s_eth_handles[0], 2, out_buffer, ETH_HEADER_LEN, buffer, len);
-}
-
-static esp_err_t start_driver(esp_netif_t *esp_netif)
-{
-    ESP_RETURN_ON_ERROR(esp_eth_update_input_path(s_eth_handles[0], receive, esp_netif), TAG, "Failed to set Ethernet Rx callback");
-    sscanf(CONFIG_EPPP_LINK_ETHERNET_OUR_ADDRESS, "%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8,
-           &s_our_mac[0], &s_our_mac[1], &s_our_mac[2], &s_our_mac[3], &s_our_mac[4], &s_our_mac[5]);
-
-    sscanf(CONFIG_EPPP_LINK_ETHERNET_THEIR_ADDRESS, "%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8 ":%2" PRIx8,
-           &s_their_mac[0], &s_their_mac[1], &s_their_mac[2], &s_their_mac[3], &s_their_mac[4], &s_their_mac[5]);
-    esp_eth_ioctl(s_eth_handles[0], ETH_CMD_S_MAC_ADDR, s_our_mac);
-    ESP_RETURN_ON_ERROR(esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, event_handler, NULL), TAG, "Failed to register Ethernet handlers");
-    ESP_RETURN_ON_ERROR(esp_eth_start(s_eth_handles[0]), TAG, "Failed to start Ethernet driver");
-    return ESP_OK;
-}
-
-static esp_err_t post_attach(esp_netif_t *esp_netif, void *args)
-{
-    eppp_transport_handle_t h = (eppp_transport_handle_t)args;
-    ESP_RETURN_ON_FALSE(h, ESP_ERR_INVALID_ARG, TAG, "Transport handle cannot be null");
-    h->base.netif = esp_netif;
-
-    esp_netif_driver_ifconfig_t driver_ifconfig = {
-        .handle =  h,
-        .transmit = eppp_transport_tx,
-    };
-
-    ESP_RETURN_ON_ERROR(esp_netif_set_driver_config(esp_netif, &driver_ifconfig), TAG, "Failed to set driver config");
-    ESP_LOGI(TAG, "EPPP Ethernet transport attached to EPPP netif %s", esp_netif_get_desc(esp_netif));
-    ESP_RETURN_ON_ERROR(start_driver(esp_netif), TAG, "Failed to start EPPP ethernet driver");
-    ESP_LOGI(TAG, "EPPP Ethernet driver started");
-    return ESP_OK;
-}
-
-eppp_transport_handle_t eppp_eth_init(struct eppp_config_ethernet_s *config)
-{
-    __attribute__((unused)) esp_err_t ret = ESP_OK;
-    ESP_RETURN_ON_FALSE(config, NULL, TAG, "Config cannot be null");
-    eppp_transport_handle_t h = calloc(1, sizeof(struct eppp_handle));
-    ESP_RETURN_ON_FALSE(h, NULL, TAG, "Failed to allocate eppp_handle");
-    ESP_GOTO_ON_ERROR(eppp_transport_ethernet_init(config, &s_eth_handles), err, TAG, "Failed to init Ethernet transport");
-    h->base.post_attach = post_attach;
-    return h;
-err:
-    return NULL;
-}
-
-void eppp_eth_deinit(eppp_transport_handle_t h)
-{
-    esp_eth_stop(s_eth_handles[0]);
-    eppp_transport_ethernet_deinit(&s_eth_handles);
-}

components/eppp_link/eppp_link.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2019-2025 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2019-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -12,17 +12,15 @@
 #include "esp_event.h"
 #include "esp_netif_ppp.h"
 #include "eppp_link.h"
-#include "eppp_transport_eth.h"
-#include "eppp_transport_spi.h"
-#include "eppp_transport_uart.h"
-#include "eppp_transport_sdio.h"
-#include "eppp_transport.h"
 
-
-#if CONFIG_EPPP_LINK_DEVICE_ETH
-#define EPPP_NEEDS_TASK 0
-#else
-#define EPPP_NEEDS_TASK 1
+#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;
@@ -34,54 +32,188 @@ 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
 
-void eppp_netif_deinit(esp_netif_t *netif)
+
+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;
+};
+
+
+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
+    return ESP_OK;
+}
+
+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--;
     }
 }
 
-#ifdef CONFIG_EPPP_LINK_USES_PPP
-#define NETSTACK_CONFIG() ESP_NETIF_NETSTACK_DEFAULT_PPP
-#else
-#define NETSTACK_CONFIG() g_eppp_netif_config_tun
-extern esp_netif_netstack_config_t *g_eppp_netif_config_tun;
-#define ESP_NETIF_INHERENT_DEFAULT_SLIP() \
-    {   \
-        ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(mac) \
-        ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(ip_info) \
-        .flags = ESP_NETIF_FLAG_EVENT_IP_MODIFIED,              \
-        .get_ip_event = IP_EVENT_PPP_GOT_IP,    \
-        .lost_ip_event = IP_EVENT_PPP_LOST_IP,   \
-        .if_key = "EPPP_TUN",  \
-        .if_desc = "eppp",    \
-        .route_prio = 1,     \
-        .bridge_info = NULL \
-};
-#endif // CONFIG_EPPP_LINK_USES_PPP
-
-esp_netif_t *eppp_netif_init(eppp_type_t role, eppp_transport_handle_t h, eppp_config_t *eppp_config)
+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;
-#ifdef CONFIG_EPPP_LINK_USES_PPP
-    esp_netif_inherent_config_t base_netif_cfg = ESP_NETIF_INHERENT_DEFAULT_PPP();
-#else
-    esp_netif_inherent_config_t base_netif_cfg = ESP_NETIF_INHERENT_DEFAULT_SLIP();
-    esp_netif_ip_info_t slip_ip4 = {};
-    slip_ip4.ip.addr = eppp_config->ppp.our_ip4_addr.addr;
-    slip_ip4.gw.addr = eppp_config->ppp.their_ip4_addr.addr;
-    slip_ip4.netmask.addr = ESP_IP4TOADDR(255, 255, 255, 0);
-    base_netif_cfg.ip_info = &slip_ip4;
+#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,
+        .transmit = transmit,
+    };
+    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;
@@ -93,27 +225,25 @@ esp_netif_t *eppp_netif_init(eppp_type_t role, eppp_transport_handle_t h, eppp_c
     if (eppp_config->ppp.netif_prio) {
         base_netif_cfg.route_prio = eppp_config->ppp.netif_prio;
     }
-    esp_netif_config_t netif_config = { .base = &base_netif_cfg,
-                                        .driver = NULL,
-                                        .stack = NETSTACK_CONFIG(),
-                                      };
+    esp_netif_config_t netif_ppp_config = { .base = &base_netif_cfg,
+                                            .driver = ppp_driver_cfg,
+                                            .stack = ESP_NETIF_NETSTACK_DEFAULT_PPP
+                                          };
 
-#ifdef CONFIG_EPPP_LINK_USES_PPP
-    __attribute__((unused)) esp_err_t ret = ESP_OK;
-    esp_netif_t *netif = esp_netif_new(&netif_config);
-    esp_netif_ppp_config_t netif_params;
-    ESP_GOTO_ON_ERROR(esp_netif_ppp_get_params(netif, &netif_params), err, TAG, "Failed to get PPP params");
-    netif_params.ppp_our_ip4_addr = eppp_config->ppp.our_ip4_addr;
-    netif_params.ppp_their_ip4_addr = eppp_config->ppp.their_ip4_addr;
-    netif_params.ppp_error_event_enabled = true;
-    ESP_GOTO_ON_ERROR(esp_netif_ppp_set_params(netif, &netif_params), err, TAG, "Failed to set PPP params");
+    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;
-err:
-    esp_netif_destroy(netif);
-    return NULL;
-#else
-    return esp_netif_new(&netif_config);
-#endif // CONFIG_EPPP_LINK_USES_PPP
+
 }
 
 esp_err_t eppp_netif_stop(esp_netif_t *netif, int stop_timeout_ms)
@@ -138,12 +268,7 @@ 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);
-#ifndef CONFIG_EPPP_LINK_USES_PPP
-    // PPP provides address negotiation, if not PPP, we need to check connection manually
-    return eppp_check_connection(netif);
-#else
     return ESP_OK;
-#endif
 }
 
 static int get_netif_num(esp_netif_t *netif)
@@ -163,17 +288,16 @@ static int get_netif_num(esp_netif_t *netif)
     return  netif_cnt;
 }
 
-#ifdef CONFIG_EPPP_LINK_USES_PPP
 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;
     }
 }
-#endif // CONFIG_EPPP_LINK_USES_PPP
 
 static void on_ip_event(void *arg, esp_event_base_t base, int32_t event_id, void *data)
 {
@@ -200,7 +324,342 @@ static void on_ip_event(void *arg, esp_event_base_t base, int32_t event_id, void
     }
 }
 
-#if EPPP_NEEDS_TASK
+#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;
+}
+
+#endif // CONFIG_EPPP_LINK_DEVICE_SPI / UART
+
 static void ppp_task(void *args)
 {
     esp_netif_t *netif = args;
@@ -209,7 +668,6 @@ static void ppp_task(void *args)
     h->exited = true;
     vTaskDelete(NULL);
 }
-#endif
 
 static bool have_some_eppp_netif(esp_netif_t *netif, void *ctx)
 {
@@ -220,13 +678,11 @@ 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 clean up the statics
+        // 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);
-#ifdef CONFIG_EPPP_LINK_USES_PPP
         esp_event_handler_unregister(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, on_ppp_event);
-#endif
     }
 }
 
@@ -235,33 +691,49 @@ 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);
-    EPPP_TRANSPORT_DEINIT(h);
-    eppp_netif_deinit(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));
+#endif
+    netif_deinit(netif);
 }
 
 esp_netif_t *eppp_init(eppp_type_t role, eppp_config_t *config)
 {
-    __attribute__((unused)) esp_err_t ret = ESP_OK;
-    esp_netif_t *netif = NULL;
     if (config == NULL || (role != EPPP_SERVER && role != EPPP_CLIENT)) {
         ESP_LOGE(TAG, "Invalid configuration or role");
         return NULL;
     }
 
-    eppp_transport_handle_t h = EPPP_TRANSPORT_INIT(config);
-    ESP_GOTO_ON_FALSE(h, ESP_ERR_NO_MEM, err, TAG, "Failed to init EPPP transport");
-    ESP_GOTO_ON_FALSE(netif = eppp_netif_init(role, h, config), ESP_ERR_NO_MEM, err, TAG, "Failed to init EPPP netif");
-    ESP_GOTO_ON_ERROR(esp_netif_attach(netif, h), err, TAG, "Failed to attach netif to EPPP transport");
+    esp_netif_t *netif = netif_init(role, config);
+    if (!netif) {
+        ESP_LOGE(TAG, "Failed to initialize PPP netif");
+        remove_handlers();
+        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);
+#endif
     return netif;
-err:
-    if (h) {
-        EPPP_TRANSPORT_DEINIT(h);
-    }
-    if (netif) {
-        eppp_netif_deinit(netif);
-    }
-    return NULL;
 }
 
 esp_netif_t *eppp_open(eppp_type_t role, eppp_config_t *config, int connect_timeout_ms)
@@ -282,12 +754,6 @@ esp_netif_t *eppp_open(eppp_type_t role, eppp_config_t *config, int connect_time
         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()");
@@ -300,13 +766,11 @@ esp_netif_t *eppp_open(eppp_type_t role, eppp_config_t *config, int connect_time
             remove_handlers();
             return NULL;
         }
-#ifdef CONFIG_EPPP_LINK_USES_PPP
         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;
         }
-#endif // CONFIG_EPPP_LINK_USES_PPP
     }
     esp_netif_t *netif = eppp_init(role, config);
     if (!netif) {
@@ -315,13 +779,12 @@ esp_netif_t *eppp_open(eppp_type_t role, eppp_config_t *config, int connect_time
     }
 
     eppp_netif_start(netif);
-#if EPPP_NEEDS_TASK
+
     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;
     }
-#endif
     int netif_cnt = get_netif_num(netif);
     if (netif_cnt < 0) {
         eppp_close(netif);
@@ -367,24 +830,3 @@ void eppp_close(esp_netif_t *netif)
     eppp_deinit(netif);
     remove_handlers();
 }
-
-#ifdef CONFIG_EPPP_LINK_CHANNELS_SUPPORT
-esp_err_t eppp_add_channels(esp_netif_t *netif, eppp_channel_fn_t *tx, const eppp_channel_fn_t rx, void* context)
-{
-    ESP_RETURN_ON_FALSE(netif != NULL && tx != NULL && rx != NULL, ESP_ERR_INVALID_ARG, TAG, "Invalid arguments");
-    struct eppp_handle *h = esp_netif_get_io_driver(netif);
-    ESP_RETURN_ON_FALSE(h != NULL && h->channel_tx != NULL, ESP_ERR_INVALID_STATE, TAG, "Transport not initialized");
-    *tx = h->channel_tx;
-    h->channel_rx = rx;
-    h->context = context;
-    return ESP_OK;
-}
-
-void* eppp_get_context(esp_netif_t *netif)
-{
-    ESP_RETURN_ON_FALSE(netif != NULL, NULL, TAG, "Invalid netif");
-    struct eppp_handle *h = esp_netif_get_io_driver(netif);
-    ESP_RETURN_ON_FALSE(h != NULL, NULL, TAG, "EPPP Not initialized");
-    return h->context;
-}
-#endif