Merge pull request #713 from david-cermak/feat/sock_utiis_0.2

[sock-utils]: Bump 0.1 -> 0.2

.github/workflows/clang-tidy.yml

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

.github/workflows/console_cmd_mqtt__build.yml

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

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

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

.github/workflows/modem__target-test.yml

@@ -15,7 +15,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
+        test: [ { app: pppd, path: test/target }, { app: pppd_chap_auth, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
         include:
           - idf_ver: "latest"
             idf_target: "esp32s2"
@@ -58,7 +58,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
+        test: [ { app: pppd, path: test/target }, { app: pppd_chap_auth, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
         include:
           - idf_ver: "latest"
             idf_target: "esp32s2"
@@ -80,7 +80,12 @@ jobs:
           name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
           path: ${{ env.TEST_DIR }}/build
       - name: Run Example Test on target
-        working-directory: ${{ env.TEST_DIR }}
+        env:
+          PIP_EXTRA_INDEX_URL: "https://dl.espressif.com/pypi/"
         run: |
-            python -m pip install -r $GITHUB_WORKSPACE/ci/requirements.txt
+            python -m venv .venv
+            source .venv/bin/activate
+            pip install --prefer-binary cryptography pytest-embedded pytest-embedded-serial-esp pytest-embedded-idf pytest-custom_exit_code esptool
+            pip install -r $GITHUB_WORKSPACE/ci/requirements.txt
+            cd ${{ env.TEST_DIR }}
             python -m pytest --log-cli-level DEBUG --target=${{ matrix.idf_target }}

.github/workflows/mosq__build.yml

@@ -0,0 +1,73 @@
+name: "mosq: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_mosq:
+    if: contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push'
+    name: Mosquitto build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on: ubuntu-22.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/mosquitto/examples/broker
+      TARGET_TEST_DIR: build_esp32_default
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Build with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install idf-component-manager idf-build-apps --upgrade
+          python ci/build_apps.py ${TEST_DIR}
+          cd ${TEST_DIR}
+          ${GITHUB_WORKSPACE}/ci/clean_build_artifacts.sh `pwd`/${TARGET_TEST_DIR}
+          zip -qur artifacts.zip ${TARGET_TEST_DIR}
+      - uses: actions/upload-artifact@v4
+        with:
+          name: mosq_target_esp32_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/artifacts.zip
+          if-no-files-found: error
+
+  test_mosq:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'mosquitto') || github.event_name == 'push' )
+    name: Mosquitto target test
+    needs: build_mosq
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.3"]
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/mosquitto/examples/broker
+      TARGET_TEST_DIR: build_esp32_default
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: mosq_target_esp32_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/ci/
+      - name: Run Test
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          python -m pip install pytest-embedded-serial-esp pytest-embedded-idf pytest-rerunfailures pytest-timeout pytest-ignore-test-results
+          unzip ci/artifacts.zip -d ci
+          for dir in `ls -d ci/build_*`; do
+          rm -rf build sdkconfig.defaults
+          mv $dir build
+          python -m pytest --log-cli-level DEBUG --junit-xml=./results_esp32_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=esp32
+          done

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

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

.github/workflows/sockutls_build.yml

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

.github/workflows/wifi_remote__build.yml

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

.gitmodules

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

.pre-commit-config.yaml

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

README.md

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

ci/build_apps.py

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

ci/check_copyright_config.yaml

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

ci/detect_component_bump

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

ci/ignore_astyle.txt

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

components/console_cmd_mqtt/.cz.yaml

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

components/console_cmd_mqtt/CHANGELOG.md

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

components/console_cmd_mqtt/CMakeLists.txt

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

components/console_cmd_mqtt/Kconfig.projbuild

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

components/console_cmd_mqtt/README.md

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

components/console_cmd_mqtt/console_mqtt.c

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

components/console_cmd_mqtt/console_mqtt.h

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

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/CMakeLists.txt

@@ -0,0 +1,11 @@
+# The following five lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(mqtt_ssl_auth_console)
+
+# Certs for mqtts://test.mosquitto.org:8884
+target_add_binary_data(${CMAKE_PROJECT_NAME}.elf "certs/client.crt" TEXT)
+target_add_binary_data(${CMAKE_PROJECT_NAME}.elf "certs/client.key" TEXT)
+target_add_binary_data(${CMAKE_PROJECT_NAME}.elf "certs/mosquitto.org.pem" TEXT)

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/README.md

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

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

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

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

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

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

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

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

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

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/pytest_mqtt_ssl_auth_console.py

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

components/console_cmd_mqtt/examples/mqtt_ssl_auth_console/sdkconfig.defaults

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

components/console_cmd_mqtt/idf_component.yml

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

components/esp_modem/.cz.yaml

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

components/esp_modem/CHANGELOG.md

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

components/esp_modem/Kconfig

@@ -63,4 +63,33 @@ menu "esp-modem"
             dce_factory::Factory::create_unique_dce_from<CustomModule, DCE*>(dce_config, std::move(dte), netif)
             Please refer to the pppos_client example for more details.
 
+    config ESP_MODEM_C_API_STR_MAX
+        int "Size in bytes for response from AT commands returning textual values (C-API)"
+        default 128
+        help
+            Some AT commands returns textual values which C-API copy as c-string to user allocated space,
+            it also truncates the output data to this size. Increase this if some AT answers are truncated.
+
+    config ESP_MODEM_URC_HANDLER
+        bool "Enable support for adding URC handler"
+        default n
+        help
+            If enabled, APIs to add URC handler are available
+
+    config ESP_MODEM_PPP_ESCAPE_BEFORE_EXIT
+        bool "Send escape sequence when switching PPP -> CMD"
+        default n
+        help
+            If enabled, the library sends a PPP escape ("+++" command)
+            to switch to command mode. This make switching from PPP to CMD
+            mode more robust for some devices (e.g. Quectel), but might cause
+            trouble for other devices (e.g. SIMCOM).
+
+    config ESP_MODEM_ADD_DEBUG_LOGS
+        bool "Add UART Tx/Rx logs"
+        default n
+        help
+            If enabled, the library dumps all transmitted and received data.
+            This option is only used for debugging.
+
 endmenu

components/esp_modem/examples/ap_to_pppos/README.md

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

components/esp_modem/examples/linux_modem/README.md

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

components/esp_modem/examples/modem_console/README.md

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

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

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

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

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

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

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

components/esp_modem/examples/modem_tcp_client/README.md

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

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

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

components/esp_modem/examples/pppos_client/README.md

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

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

@@ -100,28 +100,28 @@ menu "Example Configuration"
         config EXAMPLE_MODEM_UART_TX_PIN
             int "TXD Pin Number"
             default 25
-            range 0 31
+            range 0 56
             help
                 Pin number of UART TX.
 
         config EXAMPLE_MODEM_UART_RX_PIN
             int "RXD Pin Number"
             default 26
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RX.
 
         config EXAMPLE_MODEM_UART_RTS_PIN
             int "RTS Pin Number"
             default 27
-            range 0 31
+            range 0 56
             help
                 Pin number of UART RTS.
 
         config EXAMPLE_MODEM_UART_CTS_PIN
             int "CTS Pin Number"
             default 23
-            range 0 31
+            range 0 56
             help
                 Pin number of UART CTS.
 
@@ -201,4 +201,23 @@ menu "Example Configuration"
         help
             MQTT data message, which we publish and expect to receive.
 
+    config EXAMPLE_PAUSE_NETIF_TO_CHECK_SIGNAL
+        bool "Demonstrate netif pause"
+        default n
+        help
+            Set this to true to demonstrate network pausing.
+            If enabled, the example waits for an MQTT data, then temporarily
+            drops network to check signal quality, resumes networking and
+            publishes another MQTT message.
+            Connection to the MQTT broker should be kept.
+
+    config EXAMPLE_DETECT_MODE_BEFORE_CONNECT
+        bool "Detect mode before connect"
+        default n
+        help
+            Set this to true to demonstrate mode auto-detection.
+            If enabled, the example tries to recognize the actual mode.
+            If mode is detected correctly and it is not a command mode,
+            then the example switches to command mode.
+
 endmenu

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

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

components/esp_modem/examples/pppos_client/main/pppos_client_main.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -34,6 +34,7 @@
 static const char *TAG = "pppos_example";
 static EventGroupHandle_t event_group = NULL;
 static const int CONNECT_BIT = BIT0;
+static const int DISCONNECT_BIT = BIT1;
 static const int GOT_DATA_BIT = BIT2;
 static const int USB_DISCONNECTED_BIT = BIT3; // Used only with USB DTE but we define it unconditionally, to avoid too many #ifdefs in the code
 
@@ -55,6 +56,7 @@ static void usb_terminal_error_handler(esp_modem_terminal_error_t err)
 }
 #define CHECK_USB_DISCONNECTION(event_group) \
 if ((xEventGroupGetBits(event_group) & USB_DISCONNECTED_BIT) == USB_DISCONNECTED_BIT) { \
+    ESP_LOGE(TAG, "USB_DISCONNECTED_BIT destroying modem dce");                                            \
     esp_modem_destroy(dce); \
     continue; \
 }
@@ -140,6 +142,7 @@ static void on_ip_event(void *arg, esp_event_base_t event_base,
         ESP_LOGI(TAG, "GOT ip event!!!");
     } else if (event_id == IP_EVENT_PPP_LOST_IP) {
         ESP_LOGI(TAG, "Modem Disconnect from PPP Server");
+        xEventGroupSetBits(event_group, DISCONNECT_BIT);
     } else if (event_id == IP_EVENT_GOT_IP6) {
         ESP_LOGI(TAG, "GOT IPv6 event!");
 
@@ -158,6 +161,7 @@ void app_main(void)
     ESP_ERROR_CHECK(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, &on_ppp_changed, NULL));
 
     /* Configure the PPP netif */
+    esp_err_t err;
     esp_modem_dce_config_t dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG(CONFIG_EXAMPLE_MODEM_PPP_APN);
     esp_netif_config_t netif_ppp_config = ESP_NETIF_DEFAULT_PPP();
     esp_netif_t *esp_netif = esp_netif_new(&netif_ppp_config);
@@ -205,7 +209,7 @@ void app_main(void)
 #endif
     assert(dce);
     if (dte_config.uart_config.flow_control == ESP_MODEM_FLOW_CONTROL_HW) {
-        esp_err_t err = esp_modem_set_flow_control(dce, 2, 2);  //2/2 means HW Flow Control.
+        err = esp_modem_set_flow_control(dce, 2, 2);  //2/2 means HW Flow Control.
         if (err != ESP_OK) {
             ESP_LOGE(TAG, "Failed to set the set_flow_control mode");
             return;
@@ -246,7 +250,27 @@ void app_main(void)
 #error Invalid serial connection to modem.
 #endif
 
-    xEventGroupClearBits(event_group, CONNECT_BIT | GOT_DATA_BIT | USB_DISCONNECTED_BIT);
+#if CONFIG_EXAMPLE_DETECT_MODE_BEFORE_CONNECT
+    xEventGroupClearBits(event_group, CONNECT_BIT | GOT_DATA_BIT | USB_DISCONNECTED_BIT | DISCONNECT_BIT);
+
+    err = esp_modem_set_mode(dce, ESP_MODEM_MODE_DETECT);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "esp_modem_set_mode(ESP_MODEM_MODE_DETECT) failed with %d", err);
+        return;
+    }
+    esp_modem_dce_mode_t mode = esp_modem_get_mode(dce);
+    ESP_LOGI(TAG, "Mode detection completed: current mode is: %d", mode);
+    if (mode == ESP_MODEM_MODE_DATA) {  // set back to command mode
+        err = esp_modem_set_mode(dce, ESP_MODEM_MODE_COMMAND);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "esp_modem_set_mode(ESP_MODEM_MODE_COMMAND) failed with %d", err);
+            return;
+        }
+        ESP_LOGI(TAG, "Command mode restored");
+    }
+#endif // CONFIG_EXAMPLE_DETECT_MODE_BEFORE_CONNECT
+
+    xEventGroupClearBits(event_group, CONNECT_BIT | GOT_DATA_BIT | USB_DISCONNECTED_BIT | DISCONNECT_BIT);
 
     /* Run the modem demo app */
 #if CONFIG_EXAMPLE_NEED_SIM_PIN == 1
@@ -262,7 +286,7 @@ void app_main(void)
 #endif
 
     int rssi, ber;
-    esp_err_t err = esp_modem_get_signal_quality(dce, &rssi, &ber);
+    err = esp_modem_get_signal_quality(dce, &rssi, &ber);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "esp_modem_get_signal_quality failed with %d %s", err, esp_err_to_name(err));
         return;
@@ -301,22 +325,41 @@ void app_main(void)
     }
     /* Wait for IP address */
     ESP_LOGI(TAG, "Waiting for IP address");
-    xEventGroupWaitBits(event_group, CONNECT_BIT | USB_DISCONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
+    xEventGroupWaitBits(event_group, CONNECT_BIT | USB_DISCONNECTED_BIT | DISCONNECT_BIT, pdFALSE, pdFALSE,
+                        pdMS_TO_TICKS(60000));
     CHECK_USB_DISCONNECTION(event_group);
+    if ((xEventGroupGetBits(event_group) & CONNECT_BIT) != CONNECT_BIT) {
+        ESP_LOGW(TAG, "Modem not connected, switching back to the command mode");
+        err = esp_modem_set_mode(dce, ESP_MODEM_MODE_COMMAND);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "esp_modem_set_mode(ESP_MODEM_MODE_COMMAND) failed with %d", err);
+            return;
+        }
+        ESP_LOGI(TAG, "Command mode restored");
+        return;
+    }
 
     /* Config MQTT */
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
     esp_mqtt_client_config_t mqtt_config = {
         .broker.address.uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
     };
-#else
-    esp_mqtt_client_config_t mqtt_config = {
-        .uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
-    };
-#endif
     esp_mqtt_client_handle_t mqtt_client = esp_mqtt_client_init(&mqtt_config);
     esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
     esp_mqtt_client_start(mqtt_client);
+
+#if CONFIG_EXAMPLE_PAUSE_NETIF_TO_CHECK_SIGNAL
+    xEventGroupWaitBits(event_group, GOT_DATA_BIT, pdTRUE, pdFALSE, portMAX_DELAY);
+    esp_modem_pause_net(dce, true);
+    err = esp_modem_get_signal_quality(dce, &rssi, &ber);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "esp_modem_get_signal_quality failed with %d", err);
+        return;
+    }
+    ESP_LOGI(TAG, "Signal quality: rssi=%d, ber=%d", rssi, ber);
+    esp_modem_pause_net(dce, false);
+    esp_mqtt_client_publish(mqtt_client, CONFIG_EXAMPLE_MQTT_TEST_TOPIC, CONFIG_EXAMPLE_MQTT_TEST_DATA, 0, 0, 0);
+#endif // CONFIG_EXAMPLE_PAUSE_NETIF_TO_CHECK_SIGNAL
+
     ESP_LOGI(TAG, "Waiting for MQTT data");
     xEventGroupWaitBits(event_group, GOT_DATA_BIT | USB_DISCONNECTED_BIT, pdFALSE, pdFALSE, portMAX_DELAY);
     CHECK_USB_DISCONNECTION(event_group);

components/esp_modem/examples/pppos_client/pytest_pppos_client.py

@@ -12,7 +12,7 @@ def test_pppos_connect(dut):
       4. checks that the client cleanly disconnects
     """
     # Check the sequence of connecting, publishing, disconnecting
-    dut.expect('Modem Connect to PPP Server')
+    dut.expect('Modem Connect to PPP Server', timeout=90)
     # Check for MQTT connection and the data event
     dut.expect('MQTT_EVENT_CONNECTED')
     dut.expect('MQTT_EVENT_DATA')

components/esp_modem/examples/pppos_client/sdkconfig.ci.sim800_c3

@@ -11,5 +11,7 @@ CONFIG_EXAMPLE_MODEM_DEVICE_SIM800=y
 CONFIG_EXAMPLE_MODEM_DEVICE_BG96=n
 CONFIG_EXAMPLE_MODEM_PPP_APN="lpwa.vodafone.com"
 CONFIG_EXAMPLE_MQTT_TEST_TOPIC="/ci/esp-modem/pppos-client"
+CONFIG_EXAMPLE_PAUSE_NETIF_TO_CHECK_SIGNAL=y
 CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
 CONFIG_ESP32_PANIC_PRINT_HALT=y
+CONFIG_EXAMPLE_DETECT_MODE_BEFORE_CONNECT=y

components/esp_modem/examples/simple_cmux_client/README.md

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

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

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

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

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

components/esp_modem/examples/simple_cmux_client/pytest_cmux.py

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

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

@@ -15,3 +15,5 @@ CONFIG_ESP32_PANIC_PRINT_HALT=y
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
 CONFIG_EXAMPLE_CLOSE_CMUX_AT_END=y
+CONFIG_EXAMPLE_MQTT_TEST_TOPIC="/ci/esp-modem/pppos-client"
+CONFIG_BROKER_URI="mqtt://mqtt.eclipseprojects.io"

components/esp_modem/idf_component.yml

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

components/esp_modem/include/cxx_include/esp_modem_dce.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -30,9 +30,11 @@ public:
     ~DCE_Mode() = default;
     bool set(DTE *dte, ModuleIf *module, Netif &netif, modem_mode m);
     modem_mode get();
+    modem_mode guess(DTE *dte, bool with_cmux = false);
 
 private:
     bool set_unsafe(DTE *dte, ModuleIf *module, Netif &netif, modem_mode m);
+    modem_mode guess_unsafe(DTE *dte, bool with_cmux);
     modem_mode mode;
 
 };
@@ -79,16 +81,56 @@ public:
         return dte->command(command, std::move(got_line), time_ms);
     }
 
+    modem_mode guess_mode(bool with_cmux = false)
+    {
+        return mode.guess(dte.get(), with_cmux);
+    }
+
     bool set_mode(modem_mode m)
     {
         return mode.set(dte.get(), device.get(), netif, m);
     }
 
+    modem_mode get_mode()
+    {
+        return mode.get();
+    }
+
     bool recover()
     {
         return dte->recover();
     }
 
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+    void set_urc(got_line_cb on_read_cb)
+    {
+        dte->set_urc_cb(on_read_cb);
+    }
+#endif
+
+    /**
+     * @brief Pauses/Unpauses network temporarily
+     * @param do_pause true to pause, false to unpause
+     * @param force true to ignore command failures and continue
+     * @return command_result of the underlying commands
+     */
+    command_result pause_netif(bool do_pause, bool force = false, int delay = 1000)
+    {
+        command_result result;
+        if (do_pause) {
+            netif.pause();
+            Task::Delay(delay); // Mandatory 1s pause before
+            dte->set_command_callbacks();
+            result = device->set_command_mode();
+        } else {
+            result = device->resume_data_mode();
+            if (result == command_result::OK || force) {
+                netif.resume();
+            }
+        }
+        return result;
+    }
+
 protected:
     std::shared_ptr<DTE> dte;
     std::shared_ptr<SpecificModule> device;

components/esp_modem/include/cxx_include/esp_modem_dce_module.hpp

@@ -77,7 +77,9 @@ public:
                 if (set_command_mode() == command_result::OK) {
                     return true;
                 }
-                Task::Delay(1000); // Mandatory 1s pause after escape
+                // send a newline to delimit the escape from the upcoming sync command
+                uint8_t delim = '\n';
+                dte->write(&delim, 1);
                 if (sync() == command_result::OK) {
                     return true;
                 }

components/esp_modem/include/cxx_include/esp_modem_dte.hpp

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

components/esp_modem/include/cxx_include/esp_modem_netif.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -54,6 +54,16 @@ public:
      */
     void stop();
 
+    /**
+     * @brief Pause the network interface
+     */
+    void pause();
+
+    /**
+     * @brief Resume the network interface
+     */
+    void resume();
+
     void receive(uint8_t *data, size_t len);
 
 private:

components/esp_modem/include/cxx_include/esp_modem_types.hpp

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

components/esp_modem/include/esp_modem_c_api_types.h

@@ -13,6 +13,10 @@
 extern "C" {
 #endif
 
+/*  Compatibility macro to be removed in v2.0
+ */
+#define ESP_MODEM_DCE_GENETIC ESP_MODEM_DCE_GENERIC
+
 typedef struct esp_modem_dce_wrap esp_modem_dce_t;
 
 typedef struct esp_modem_PdpContext_t {
@@ -41,13 +45,15 @@ typedef enum esp_modem_dce_mode {
     ESP_MODEM_MODE_CMUX_MANUAL_SWAP,    /**< Swap terminals in CMUX manual mode */
     ESP_MODEM_MODE_CMUX_MANUAL_DATA,    /**< Set DATA mode in CMUX manual mode */
     ESP_MODEM_MODE_CMUX_MANUAL_COMMAND, /**< Set COMMAND mode in CMUX manual mode */
+    ESP_MODEM_MODE_DETECT,              /**< Detect the mode and resume it (if sucessfully detected) */
+    ESP_MODEM_MODE_UNDEF,
 } esp_modem_dce_mode_t;
 
 /**
  * @brief DCE devices: Enum list of supported devices
  */
 typedef enum esp_modem_dce_device {
-    ESP_MODEM_DCE_GENETIC,  /**< The most generic device */
+    ESP_MODEM_DCE_GENERIC,  /**< The most generic device */
     ESP_MODEM_DCE_SIM7600,
     ESP_MODEM_DCE_SIM7070,
     ESP_MODEM_DCE_SIM7000,
@@ -141,6 +147,33 @@ esp_err_t esp_modem_command(esp_modem_dce_t *dce, const char *command, esp_err_t
  */
 esp_err_t esp_modem_set_apn(esp_modem_dce_t *dce, const char *apn);
 
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+/**
+ * @brief Sets a handler for unsolicited result codes (URCs) from the modem
+ *
+ * This function registers a callback that is triggered whenever an unsolicited
+ * result code (URC) is received from the modem. URCs are typically sent by the
+ * modem without a prior command to notify the host about certain events or status changes.
+ *
+ * @param dce Modem DCE handle
+ * @param got_line_cb Callback function which is called whenever a URC line is received
+ * @return ESP_OK on success, ESP_FAIL on failure
+ */
+esp_err_t esp_modem_set_urc(esp_modem_dce_t *dce, esp_err_t(*got_line_cb)(uint8_t *data, size_t len));
+#endif
+
+/**
+ * @brief This API provides support for temporarily pausing networking in order
+ * to send/receive AT commands and resume networking afterwards.
+ * @note This function does not switch modes, the modem is still in data mode.
+ *
+ * @param dce Modem DCE handle
+ * @param pause true to pause the network interface, false to resume networking
+ * @return ESP_OK on success
+ */
+esp_err_t esp_modem_pause_net(esp_modem_dce_t *dce, bool pause);
+
+esp_modem_dce_mode_t esp_modem_get_mode(esp_modem_dce_t *dce);
 /**
  * @}
  */

components/esp_modem/include/esp_private/c_api_wrapper.hpp

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

components/esp_modem/include/generate/esp_modem_command_declare.inc

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

components/esp_modem/include/generate/esp_modem_command_declare_helper.inc

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

components/esp_modem/src/esp_modem_c_api.cpp

@@ -16,10 +16,6 @@
 #include "exception_stub.hpp"
 #include "esp_private/c_api_wrapper.hpp"
 
-#ifndef ESP_MODEM_C_API_STR_MAX
-#define ESP_MODEM_C_API_STR_MAX 128
-#endif
-
 #ifndef HAVE_STRLCPY
 size_t strlcpy(char *dest, const char *src, size_t len);
 #endif
@@ -64,7 +60,7 @@ extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, con
 
 extern "C" esp_modem_dce_t *esp_modem_new(const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
 {
-    return esp_modem_new_dev(ESP_MODEM_DCE_GENETIC, dte_config, dce_config, netif);
+    return esp_modem_new_dev(ESP_MODEM_DCE_GENERIC, dte_config, dce_config, netif);
 }
 
 extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
@@ -99,12 +95,43 @@ extern "C" esp_err_t esp_modem_sync(esp_modem_dce_t *dce_wrap)
     return command_response_to_esp_err(dce_wrap->dce->sync());
 }
 
+extern "C" esp_modem_dce_mode_t esp_modem_get_mode(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_MODEM_MODE_UNDEF;
+    }
+    auto mode = dce_wrap->dce->get_mode();
+    switch (mode) {
+    default:
+    case modem_mode::UNDEF:
+        return ESP_MODEM_MODE_UNDEF;
+    case modem_mode::COMMAND_MODE:
+        return ESP_MODEM_MODE_COMMAND;
+    case modem_mode::DATA_MODE:
+        return ESP_MODEM_MODE_DATA;
+    case modem_mode::CMUX_MODE:
+        return ESP_MODEM_MODE_CMUX;
+    case modem_mode::CMUX_MANUAL_MODE:
+        return ESP_MODEM_MODE_CMUX_MANUAL;
+    case modem_mode::CMUX_MANUAL_EXIT:
+        return ESP_MODEM_MODE_CMUX_MANUAL_EXIT;
+    case modem_mode::CMUX_MANUAL_DATA:
+        return ESP_MODEM_MODE_CMUX_MANUAL_DATA;
+    case modem_mode::CMUX_MANUAL_COMMAND:
+        return ESP_MODEM_MODE_CMUX_MANUAL_COMMAND;
+    case modem_mode::CMUX_MANUAL_SWAP:
+        return ESP_MODEM_MODE_CMUX_MANUAL_SWAP;
+    }
+}
+
 extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t *dce_wrap, esp_modem_dce_mode_t mode)
 {
     if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
         return ESP_ERR_INVALID_ARG;
     }
     switch (mode) {
+    case ESP_MODEM_MODE_UNDEF:
+        return dce_wrap->dce->set_mode(modem_mode::UNDEF) ? ESP_OK : ESP_FAIL;
     case ESP_MODEM_MODE_DATA:
         return dce_wrap->dce->set_mode(modem_mode::DATA_MODE) ? ESP_OK : ESP_FAIL;
     case ESP_MODEM_MODE_COMMAND:
@@ -121,6 +148,8 @@ extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t *dce_wrap, esp_modem_dce
         return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_DATA) ? ESP_OK : ESP_FAIL;
     case ESP_MODEM_MODE_CMUX_MANUAL_COMMAND:
         return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_COMMAND) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_DETECT:
+        return dce_wrap->dce->set_mode(modem_mode::AUTODETECT) ? ESP_OK : ESP_FAIL;
     }
     return ESP_ERR_NOT_SUPPORTED;
 }
@@ -180,7 +209,7 @@ extern "C" esp_err_t esp_modem_at(esp_modem_dce_t *dce_wrap, const char *at, cha
     std::string at_str(at);
     auto ret = command_response_to_esp_err(dce_wrap->dce->at(at_str, out, timeout));
     if ((p_out != NULL) && (!out.empty())) {
-        strlcpy(p_out, out.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_out, out.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -201,7 +230,7 @@ extern "C" esp_err_t esp_modem_get_imsi(esp_modem_dce_t *dce_wrap, char *p_imsi)
     std::string imsi;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_imsi(imsi));
     if (ret == ESP_OK && !imsi.empty()) {
-        strlcpy(p_imsi, imsi.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_imsi, imsi.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -214,7 +243,7 @@ extern "C" esp_err_t esp_modem_at_raw(esp_modem_dce_t *dce_wrap, const char *cmd
     std::string out;
     auto ret = command_response_to_esp_err(dce_wrap->dce->at_raw(cmd, out, pass, fail, timeout));
     if ((p_out != NULL) && (!out.empty())) {
-        strlcpy(p_out, out.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_out, out.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -244,7 +273,7 @@ extern "C" esp_err_t esp_modem_get_imei(esp_modem_dce_t *dce_wrap, char *p_imei)
     std::string imei;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_imei(imei));
     if (ret == ESP_OK && !imei.empty()) {
-        strlcpy(p_imei, imei.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_imei, imei.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -258,7 +287,7 @@ extern "C" esp_err_t esp_modem_get_operator_name(esp_modem_dce_t *dce_wrap, char
     int act;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_operator_name(name, act));
     if (ret == ESP_OK && !name.empty()) {
-        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_name, name.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
         *p_act = act;
     }
     return ret;
@@ -272,7 +301,7 @@ extern "C" esp_err_t esp_modem_get_module_name(esp_modem_dce_t *dce_wrap, char *
     std::string name;
     auto ret = command_response_to_esp_err(dce_wrap->dce->get_module_name(name));
     if (ret == ESP_OK && !name.empty()) {
-        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
+        strlcpy(p_name, name.c_str(), CONFIG_ESP_MODEM_C_API_STR_MAX);
     }
     return ret;
 }
@@ -455,3 +484,43 @@ extern "C" esp_err_t esp_modem_set_apn(esp_modem_dce_t *dce_wrap, const char *ap
     dce_wrap->dce->get_module()->configure_pdp_context(std::move(new_pdp));
     return ESP_OK;
 }
+
+#ifdef CONFIG_ESP_MODEM_URC_HANDLER
+extern "C" esp_err_t esp_modem_set_urc(esp_modem_dce_t *dce_wrap, esp_err_t(*got_line_fn)(uint8_t *data, size_t len))
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (got_line_fn == nullptr) {
+        dce_wrap->dce->set_urc(nullptr);
+        return ESP_OK;
+    }
+    dce_wrap->dce->set_urc([got_line_fn](uint8_t *data, size_t len) {
+        switch (got_line_fn(data, len)) {
+        case ESP_OK:
+            return command_result::OK;
+        case ESP_FAIL:
+            return command_result::FAIL;
+        default:
+            return command_result::TIMEOUT;
+        }
+    });
+    return ESP_OK;
+}
+#endif
+
+extern "C" esp_err_t esp_modem_pause_net(esp_modem_dce_t *dce_wrap, bool pause)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->pause_netif(pause));
+}
+
+extern "C" esp_err_t esp_modem_hang_up(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->hang_up());
+}

components/esp_modem/src/esp_modem_cmux.cpp

@@ -123,7 +123,12 @@ bool CMux::data_available(uint8_t *data, size_t len)
 {
     if (data && (type & FT_UIH) == FT_UIH && len > 0 && dlci > 0) { // valid payload on a virtual term
         int virtual_term = dlci - 1;
-        if (virtual_term < MAX_TERMINALS_NUM && read_cb[virtual_term]) {
+        if (virtual_term < MAX_TERMINALS_NUM) {
+            if (read_cb[virtual_term] == nullptr) {
+                // ignore all virtual terminal's data before we completely establish CMUX
+                ESP_LOG_BUFFER_HEXDUMP("CMUX Rx before init", data, len, ESP_LOG_DEBUG);
+                return true;
+            }
             // Post partial data (or defragment to post on CMUX footer)
 #ifdef DEFRAGMENT_CMUX_PAYLOAD
             if (payload_start == nullptr) {
@@ -142,7 +147,11 @@ bool CMux::data_available(uint8_t *data, size_t len)
         sabm_ack = dlci;
     } else if (data == nullptr && dlci > 0) {
         int virtual_term = dlci - 1;
-        if (virtual_term < MAX_TERMINALS_NUM && read_cb[virtual_term]) {
+        if (virtual_term < MAX_TERMINALS_NUM) {
+            if (read_cb[virtual_term] == nullptr) {
+                // silently ignore this CMUX frame (not finished entering CMUX, yet)
+                return true;
+            }
 #ifdef DEFRAGMENT_CMUX_PAYLOAD
             read_cb[virtual_term](payload_start, total_payload_size);
 #endif

components/esp_modem/src/esp_modem_dce.cpp

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

components/esp_modem/src/esp_modem_dte.cpp

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

components/esp_modem/src/esp_modem_netif.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -87,8 +87,10 @@ void Netif::start()
         receive(data, len);
         return true;
     });
-    signal.set(PPP_STARTED);
-    esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
+    if (!signal.is_any(PPP_STARTED)) {
+        signal.set(PPP_STARTED);
+        esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
+    }
 }
 
 void Netif::stop()
@@ -97,6 +99,20 @@ void Netif::stop()
     signal.clear(PPP_STARTED);
 }
 
+void Netif::resume()
+{
+    ppp_dte->set_read_cb([this](uint8_t *data, size_t len) -> bool {
+        receive(data, len);
+        return true;
+    });
+    signal.set(PPP_STARTED);
+}
+
+void Netif::pause()
+{
+    signal.clear(PPP_STARTED);
+}
+
 Netif::~Netif()
 {
     if (signal.is_any(PPP_STARTED)) {

components/esp_modem/src/esp_modem_netif_linux.cpp

@@ -52,7 +52,6 @@ void Netif::start()
 
 void Netif::stop()
 {
-    ppp_dte->set_read_cb(nullptr);
     signal.clear(PPP_STARTED);
 }
 

components/esp_modem/src/esp_modem_uart.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -72,6 +72,7 @@ private:
     {
         auto t = static_cast<UartTerminal *>(task_param);
         t->task();
+        t->task_handle.task_handle = nullptr;
         vTaskDelete(nullptr);
     }
 
@@ -175,13 +176,20 @@ int UartTerminal::read(uint8_t *data, size_t len)
     uart_get_buffered_data_len(uart.port, &length);
     length = std::min(len, length);
     if (length > 0) {
-        return uart_read_bytes(uart.port, data, length, portMAX_DELAY);
+        int read_len = uart_read_bytes(uart.port, data, length, portMAX_DELAY);
+#if CONFIG_ESP_MODEM_ADD_DEBUG_LOGS
+        ESP_LOG_BUFFER_HEXDUMP("uart-rx", data, read_len, ESP_LOG_DEBUG);
+#endif
+        return read_len;
     }
     return 0;
 }
 
 int UartTerminal::write(uint8_t *data, size_t len)
 {
+#if CONFIG_ESP_MODEM_ADD_DEBUG_LOGS
+    ESP_LOG_BUFFER_HEXDUMP("uart-tx", data, len, ESP_LOG_DEBUG);
+#endif
     return uart_write_bytes_compat(uart.port, data, len);
 }
 

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

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

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

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

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

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

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

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

components/esp_modem/test/target/pytest_pppd.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
 from __future__ import print_function, unicode_literals
 
@@ -9,14 +9,34 @@ from threading import Event, Thread
 import netifaces
 
 
-def run_server(server_stop, port, server_ip, client_ip):
+def is_esp32(port):
+    """
+    Check if the given port is connected to an ESP32 using esptool.
+    """
+    try:
+        result = subprocess.run(
+            ['esptool.py', '--port', port, 'chip_id'],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True, text=True
+        )
+        return 'ESP32' in result.stdout
+    except subprocess.CalledProcessError:
+        return False
+
+
+def run_server(server_stop, port, server_ip, client_ip, auth, auth_user, auth_password):
     print('Starting PPP server on port: {}'.format(port))
     try:
         arg_list = [
             'sudo', 'pppd', port, '115200',
-            '{}:{}'.format(server_ip, client_ip), 'modem', 'local', 'noauth',
+            '{}:{}'.format(server_ip, client_ip), 'modem', 'local',
             'debug', 'nocrtscts', 'nodetach', '+ipv6'
         ]
+        if auth:
+            arg_list.extend(['auth', '+chap'])
+            subprocess.run(['sudo', 'rm', '/etc/ppp/chap-secrets'])
+            subprocess.run(f"echo '{auth_user} * {auth_password} *' | sudo tee -a /etc/ppp/chap-secrets", shell=True)
+        else:
+            arg_list.append('noauth')
         p = subprocess.Popen(arg_list, stdout=subprocess.PIPE, bufsize=1)
         while not server_stop.is_set():
             if p.poll() is not None:
@@ -51,19 +71,36 @@ def test_examples_protocol_pppos_connect(dut):
     try:
         server_ip = dut.app.sdkconfig.get('TEST_APP_PPP_SERVER_IP')
         client_ip = dut.app.sdkconfig.get('TEST_APP_PPP_CLIENT_IP')
+        auth = dut.app.sdkconfig.get('TEST_APP_AUTH')
+        auth_user = dut.app.sdkconfig.get('TEST_APP_AUTH_USERNAME')
+        auth_password = dut.app.sdkconfig.get('TEST_APP_AUTH_PASSWORD')
     except Exception:
         print(
             'ENV_TEST_FAILURE: Some mandatory configuration not found in sdkconfig'
         )
         raise
 
-    # the PPP test env uses two ttyUSB's: one for ESP32 board, another one for ppp server
-    # use the other port for PPP server than the DUT/ESP
-    port = '/dev/ttyUSB0' if dut.serial.port == '/dev/ttyUSB1' else '/dev/ttyUSB1'
+    # the PPP test env uses three ttyUSB's: two for ESP32 board and another one for the ppp server
+    # we need to detect the server_port (for PPPD)
+    server_port = None
+    for i in ['/dev/ttyUSB0', '/dev/ttyUSB1', '/dev/ttyUSB2']:
+        if i == dut.serial.port:
+            print(f'DUT port: {i}')
+        elif is_esp32(i):
+            print(f'Some other ESP32: {i}')
+        else:
+            print(f'Port for PPPD: {i}')
+            server_port = i
+    if server_port is None:
+        print(
+            'ENV_TEST_FAILURE: Cannot locate PPPD port'
+        )
+        raise
+
     # Start the PPP server
     server_stop = Event()
     t = Thread(target=run_server,
-               args=(server_stop, port, server_ip, client_ip))
+               args=(server_stop, server_port, server_ip, client_ip, auth, auth_user, auth_password))
     t.start()
     try:
         ppp_server_timeout = time.time() + 30

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

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

components/esp_modem/test/target/sdkconfig.defaults

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

components/esp_websocket_client/.cz.yaml

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

components/esp_websocket_client/CHANGELOG.md

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

components/esp_websocket_client/esp_websocket_client.c

@@ -122,12 +122,11 @@ struct esp_websocket_client {
     uint64_t                    ping_tick_ms;
     uint64_t                    pingpong_tick_ms;
     int                         wait_timeout_ms;
-    int                         auto_reconnect;
     bool                        run;
     bool                        wait_for_pong_resp;
     bool                        selected_for_destroying;
     EventGroupHandle_t          status_bits;
-    SemaphoreHandle_t            lock;
+    SemaphoreHandle_t           lock;
     size_t                      errormsg_size;
     char                        *errormsg_buffer;
     char                        *rx_buffer;
@@ -229,13 +228,15 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
     ESP_WS_CLIENT_STATE_CHECK(TAG, client, return ESP_FAIL);
     esp_transport_close(client->transport);
 
-    if (client->config->auto_reconnect) {
+    if (!client->config->auto_reconnect) {
+        client->run = false;
+        client->state = WEBSOCKET_STATE_UNKNOW;
+    } else {
         client->reconnect_tick_ms = _tick_get_ms();
         ESP_LOGI(TAG, "Reconnect after %d ms", client->wait_timeout_ms);
+        client->error_handle.error_type = error_type;
+        client->state = WEBSOCKET_STATE_WAIT_TIMEOUT;
     }
-
-    client->error_handle.error_type = error_type;
-    client->state = WEBSOCKET_STATE_WAIT_TIMEOUT;
     esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_DISCONNECTED, NULL, 0);
     return ESP_OK;
 }
@@ -434,7 +435,7 @@ static void destroy_and_free_resources(esp_websocket_client_handle_t client)
     if (client->transport_list) {
         esp_transport_list_destroy(client->transport_list);
     }
-    vQueueDelete(client->lock);
+    vSemaphoreDelete(client->lock);
     free(client->tx_buffer);
     free(client->rx_buffer);
     free(client->errormsg_buffer);
@@ -1051,10 +1052,6 @@ static void esp_websocket_client_task(void *pv)
             break;
         case WEBSOCKET_STATE_WAIT_TIMEOUT:
 
-            if (!client->config->auto_reconnect) {
-                client->run = false;
-                break;
-            }
             if (_tick_get_ms() - client->reconnect_tick_ms > client->wait_timeout_ms) {
                 client->state = WEBSOCKET_STATE_INIT;
                 client->reconnect_tick_ms = _tick_get_ms();
@@ -1085,7 +1082,9 @@ static void esp_websocket_client_task(void *pv)
                 } else {
                     esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
                 }
+                xSemaphoreTakeRecursive(client->lock, lock_timeout);
                 esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
+                xSemaphoreGiveRecursive(client->lock);
             }
         } else if (WEBSOCKET_STATE_WAIT_TIMEOUT == client->state) {
             // waiting for reconnecting...

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

@@ -222,6 +222,7 @@ static void websocket_app_start(void)
     char *long_data = malloc(size);
     memset(long_data, 'a', size);
     esp_websocket_client_send_text(client, long_data, size, portMAX_DELAY);
+    free(long_data);
 
     xSemaphoreTake(shutdown_sema, portMAX_DELAY);
     esp_websocket_client_close(client, portMAX_DELAY);

components/esp_websocket_client/idf_component.yml

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

components/esp_wifi_remote/.cz.yaml

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

components/esp_wifi_remote/CHANGELOG.md

@@ -1,47 +0,0 @@
-# Changelog
-
-## [0.3.0](https://github.com/espressif/esp-protocols/commits/wifi_remote-v0.3.0)
-
-### Features
-
-- add esp_wifi_internal_tx_by_ref ([ba35d14e](https://github.com/espressif/esp-protocols/commit/ba35d14e))
-- Make wifi_remote depend on esp_hosted ([ac9972aa](https://github.com/espressif/esp-protocols/commit/ac9972aa))
-
-## [0.2.3](https://github.com/espressif/esp-protocols/commits/wifi_remote-v0.2.3)
-
-### Bug Fixes
-
-- Fix server event/command race condtion using eventfd ([732b1d5](https://github.com/espressif/esp-protocols/commit/732b1d5))
-- Lock server before marshalling events ([9e13870](https://github.com/espressif/esp-protocols/commit/9e13870))
-
-## [0.2.2](https://github.com/espressif/esp-protocols/commits/wifi_remote-v0.2.2)
-
-### Bug Fixes
-
-- Added more netif options for eppp connection ([24ce867](https://github.com/espressif/esp-protocols/commit/24ce867))
-- Do not restrict EPPP config to RSA keys only ([f05c765](https://github.com/espressif/esp-protocols/commit/f05c765), [#570](https://github.com/espressif/esp-protocols/issues/570))
-
-## [0.2.1](https://github.com/espressif/esp-protocols/commits/wifi_remote-v0.2.1)
-
-### Bug Fixes
-
-- Added misc wifi API in eppp impl ([93256d1](https://github.com/espressif/esp-protocols/commit/93256d1))
-- Updated eppp dependency not to use fixed version ([3a48c06](https://github.com/espressif/esp-protocols/commit/3a48c06))
-
-## [0.2.0](https://github.com/espressif/esp-protocols/commits/wifi_remote-v0.2.0)
-
-### Features
-
-- Add support for simple eppp based RPC ([fd168d8](https://github.com/espressif/esp-protocols/commit/fd168d8))
-
-### Bug Fixes
-
-- Make services restartable, code cleanup ([6c82ce2](https://github.com/espressif/esp-protocols/commit/6c82ce2))
-- Add examples to CI ([d2b7c55](https://github.com/espressif/esp-protocols/commit/d2b7c55))
-
-## [0.1.12](https://github.com/espressif/esp-protocols/commits/wifi_remote-v0.1.12)
-
-### Features
-
-- Added generation step for wifi_remote based on IDF ([dfb00358](https://github.com/espressif/esp-protocols/commit/dfb00358))
-- Move to esp-protocols ([edc3c2d](https://github.com/espressif/esp-protocols/commit/edc3c2d))

components/esp_wifi_remote/CMakeLists.txt

@@ -1,20 +0,0 @@
-if(NOT CONFIG_ESP_WIFI_ENABLED)
-    set(src_wifi_is_remote esp_wifi_remote.c esp_wifi_with_remote.c esp_wifi_remote_net.c)
-endif()
-
-if(CONFIG_ESP_WIFI_REMOTE_LIBRARY_EPPP)
-    set(src_wifi_remote_eppp eppp/wifi_remote_rpc_client.cpp eppp/wifi_remote_rpc_server.cpp eppp/eppp_init.c)
-else()
-    set(src_wifi_remote_weak esp_wifi_remote_weak.c)
-endif()
-
-idf_component_register(INCLUDE_DIRS include
-                    SRCS ${src_wifi_remote_weak}
-                         ${src_wifi_remote_eppp}
-                         ${src_wifi_is_remote}
-                    PRIV_INCLUDE_DIRS eppp
-                    REQUIRES esp_event esp_netif
-                    PRIV_REQUIRES esp_wifi esp-tls vfs)
-
-idf_component_get_property(wifi esp_wifi COMPONENT_LIB)
-target_link_libraries(${wifi} PUBLIC ${COMPONENT_LIB})

components/esp_wifi_remote/Kconfig

@@ -1,678 +0,0 @@
-# This file is auto-generated
-menu "Wi-Fi Remote"
-    config ESP_WIFI_REMOTE_ENABLED
-        bool
-        default y
-
-    orsource "./Kconfig.soc_wifi_caps.in"
-    orsource "./Kconfig.rpc.in"
-
-        config ESP_WIFI_STATIC_RX_BUFFER_NUM
-            int "Max number of WiFi static RX buffers"
-            range 2 25 if !SLAVE_SOC_WIFI_HE_SUPPORT
-            range 2 128 if SLAVE_SOC_WIFI_HE_SUPPORT
-            default 10 if !SPIRAM_TRY_ALLOCATE_WIFI_LWIP
-            default 16 if SPIRAM_TRY_ALLOCATE_WIFI_LWIP
-            help
-                Set the number of WiFi static RX buffers. Each buffer takes approximately 1.6KB of RAM.
-                The static rx buffers are allocated when esp_wifi_init is called, they are not freed
-                until esp_wifi_deinit is called.
-
-                WiFi hardware use these buffers to receive all 802.11 frames.
-                A higher number may allow higher throughput but increases memory use. If ESP_WIFI_AMPDU_RX_ENABLED
-                is enabled, this value is recommended to set equal or bigger than ESP_WIFI_RX_BA_WIN in order to
-                achieve better throughput and compatibility with both stations and APs.
-
-        config ESP_WIFI_DYNAMIC_RX_BUFFER_NUM
-            int "Max number of WiFi dynamic RX buffers"
-            range 0 128 if !LWIP_WND_SCALE
-            range 0 1024 if LWIP_WND_SCALE
-            default 32
-            help
-                Set the number of WiFi dynamic RX buffers, 0 means unlimited RX buffers will be allocated
-                (provided sufficient free RAM). The size of each dynamic RX buffer depends on the size of
-                the received data frame.
-
-                For each received data frame, the WiFi driver makes a copy to an RX buffer and then delivers
-                it to the high layer TCP/IP stack. The dynamic RX buffer is freed after the higher layer has
-                successfully received the data frame.
-
-                For some applications, WiFi data frames may be received faster than the application can
-                process them. In these cases we may run out of memory if RX buffer number is unlimited (0).
-
-                If a dynamic RX buffer limit is set, it should be at least the number of static RX buffers.
-
-        choice ESP_WIFI_TX_BUFFER
-            prompt "Type of WiFi TX buffers"
-            default ESP_WIFI_DYNAMIC_TX_BUFFER
-            help
-                Select type of WiFi TX buffers:
-
-                If "Static" is selected, WiFi TX buffers are allocated when WiFi is initialized and released
-                when WiFi is de-initialized. The size of each static TX buffer is fixed to about 1.6KB.
-
-                If "Dynamic" is selected, each WiFi TX buffer is allocated as needed when a data frame is
-                delivered to the Wifi driver from the TCP/IP stack. The buffer is freed after the data frame
-                has been sent by the WiFi driver. The size of each dynamic TX buffer depends on the length
-                of each data frame sent by the TCP/IP layer.
-
-                If PSRAM is enabled, "Static" should be selected to guarantee enough WiFi TX buffers.
-                If PSRAM is disabled, "Dynamic" should be selected to improve the utilization of RAM.
-
-            config ESP_WIFI_STATIC_TX_BUFFER
-                bool "Static"
-            config ESP_WIFI_DYNAMIC_TX_BUFFER
-                bool "Dynamic"
-                depends on !SPIRAM_USE_MALLOC
-        endchoice
-
-        config ESP_WIFI_TX_BUFFER_TYPE
-            int
-            default 0 if ESP_WIFI_STATIC_TX_BUFFER
-            default 1 if ESP_WIFI_DYNAMIC_TX_BUFFER
-
-        config ESP_WIFI_STATIC_TX_BUFFER_NUM
-            int "Max number of WiFi static TX buffers"
-            depends on ESP_WIFI_STATIC_TX_BUFFER
-            range 1 64
-            default 16
-            help
-                Set the number of WiFi static TX buffers. Each buffer takes approximately 1.6KB of RAM.
-                The static RX buffers are allocated when esp_wifi_init() is called, they are not released
-                until esp_wifi_deinit() is called.
-
-                For each transmitted data frame from the higher layer TCP/IP stack, the WiFi driver makes a
-                copy of it in a TX buffer.  For some applications especially UDP applications, the upper
-                layer can deliver frames faster than WiFi layer can transmit. In these cases, we may run out
-                of TX buffers.
-
-        config ESP_WIFI_CACHE_TX_BUFFER_NUM
-            int "Max number of WiFi cache TX buffers"
-            depends on SPIRAM
-            range 16 128
-            default 32
-            help
-                Set the number of WiFi cache TX buffer number.
-
-                For each TX packet from uplayer, such as LWIP etc, WiFi driver needs to allocate a static TX
-                buffer and makes a copy of uplayer packet. If WiFi driver fails to allocate the static TX buffer,
-                it caches the uplayer packets to a dedicated buffer queue, this option is used to configure the
-                size of the cached TX queue.
-
-        config ESP_WIFI_DYNAMIC_TX_BUFFER_NUM
-            int "Max number of WiFi dynamic TX buffers"
-            depends on ESP_WIFI_DYNAMIC_TX_BUFFER
-            range 1 128
-            default 32
-            help
-                Set the number of WiFi dynamic TX buffers. The size of each dynamic TX buffer is not fixed,
-                it depends on the size of each transmitted data frame.
-
-                For each transmitted frame from the higher layer TCP/IP stack, the WiFi driver makes a copy
-                of it in a TX buffer. For some applications, especially UDP applications, the upper layer
-                can deliver frames faster than WiFi layer can transmit. In these cases, we may run out of TX
-                buffers.
-
-        choice ESP_WIFI_MGMT_RX_BUFFER
-            prompt "Type of WiFi RX MGMT buffers"
-            default ESP_WIFI_STATIC_RX_MGMT_BUFFER
-            help
-                Select type of WiFi RX MGMT buffers:
-
-                If "Static" is selected, WiFi RX MGMT buffers are allocated when WiFi is initialized and released
-                when WiFi is de-initialized. The size of each static RX MGMT buffer is fixed to about 500 Bytes.
-
-                If "Dynamic" is selected, each WiFi RX MGMT buffer is allocated as needed when a MGMT data frame is
-                received. The MGMT buffer is freed after the MGMT data frame has been processed by the WiFi driver.
-
-
-            config ESP_WIFI_STATIC_RX_MGMT_BUFFER
-                bool "Static"
-            config ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER
-                bool "Dynamic"
-        endchoice
-
-        config ESP_WIFI_DYNAMIC_RX_MGMT_BUF
-            int
-            default 0 if ESP_WIFI_STATIC_RX_MGMT_BUFFER
-            default 1 if ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER
-
-        config ESP_WIFI_RX_MGMT_BUF_NUM_DEF
-            int "Max number of WiFi RX MGMT buffers"
-            range 1 10
-            default 5
-            help
-                Set the number of WiFi RX_MGMT buffers.
-
-                For Management buffers, the number of dynamic and static management buffers is the same.
-                In order to prevent memory fragmentation, the management buffer type should be set to static first.
-
-        config ESP_WIFI_CSI_ENABLED
-            bool "WiFi CSI(Channel State Information)"
-            depends on SLAVE_SOC_WIFI_CSI_SUPPORT
-            default n
-            help
-                Select this option to enable CSI(Channel State Information) feature. CSI takes about
-                CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM KB of RAM. If CSI is not used, it is better to disable
-                this feature in order to save memory.
-
-        config ESP_WIFI_AMPDU_TX_ENABLED
-            bool "WiFi AMPDU TX"
-            default y
-            help
-                Select this option to enable AMPDU TX feature
-
-
-        config ESP_WIFI_TX_BA_WIN
-            int "WiFi AMPDU TX BA window size"
-            depends on ESP_WIFI_AMPDU_TX_ENABLED
-            range 2 32 if !SLAVE_SOC_WIFI_HE_SUPPORT
-            range 2 64 if SLAVE_SOC_WIFI_HE_SUPPORT
-            default 6
-            help
-                Set the size of WiFi Block Ack TX window. Generally a bigger value means higher throughput but
-                more memory. Most of time we should NOT change the default value unless special reason, e.g.
-                test the maximum UDP TX throughput with iperf etc. For iperf test in shieldbox, the recommended
-                value is 9~12.
-
-        config ESP_WIFI_AMPDU_RX_ENABLED
-            bool "WiFi AMPDU RX"
-            default y
-            help
-                Select this option to enable AMPDU RX feature
-
-        config ESP_WIFI_RX_BA_WIN
-            int "WiFi AMPDU RX BA window size"
-            depends on ESP_WIFI_AMPDU_RX_ENABLED
-            range 2 32 if !SLAVE_SOC_WIFI_HE_SUPPORT
-            range 2 64 if SLAVE_SOC_WIFI_HE_SUPPORT
-            default 6 if !SPIRAM_TRY_ALLOCATE_WIFI_LWIP
-            default 16 if SPIRAM_TRY_ALLOCATE_WIFI_LWIP
-            help
-                Set the size of WiFi Block Ack RX window. Generally a bigger value means higher throughput and better
-                compatibility but more memory. Most of time we should NOT change the default value unless special
-                reason, e.g. test the maximum UDP RX throughput with iperf etc. For iperf test in shieldbox, the
-                recommended value is 9~12. If PSRAM is used and WiFi memory is preferred to allocate in PSRAM first,
-                the default and minimum value should be 16 to achieve better throughput and compatibility with both
-                stations and APs.
-
-        config ESP_WIFI_AMSDU_TX_ENABLED
-            bool "WiFi AMSDU TX"
-            depends on SPIRAM
-            default n
-            help
-                Select this option to enable AMSDU TX feature
-
-        config ESP_WIFI_NVS_ENABLED
-            bool "WiFi NVS flash"
-            default y
-            help
-                Select this option to enable WiFi NVS flash
-
-        choice ESP_WIFI_TASK_CORE_ID
-            depends on !FREERTOS_UNICORE
-            prompt "WiFi Task Core ID"
-            default ESP_WIFI_TASK_PINNED_TO_CORE_0
-            help
-                Pinned WiFi task to core 0 or core 1.
-
-            config ESP_WIFI_TASK_PINNED_TO_CORE_0
-                bool "Core 0"
-            config ESP_WIFI_TASK_PINNED_TO_CORE_1
-                bool "Core 1"
-        endchoice
-
-        config ESP_WIFI_SOFTAP_BEACON_MAX_LEN
-            int "Max length of WiFi SoftAP Beacon"
-            range 752 1256
-            default 752
-            help
-                ESP-MESH utilizes beacon frames to detect and resolve root node conflicts (see documentation). However
-                the default length of a beacon frame can simultaneously hold only five root node identifier structures,
-                meaning that a root node conflict of up to five nodes can be detected at one time. In the occurrence of
-                more root nodes conflict involving more than five root nodes, the conflict resolution process will
-                detect five of the root nodes, resolve the conflict, and re-detect more root nodes. This process will
-                repeat until all root node conflicts are resolved. However this process can generally take a very long
-                time.
-
-                To counter this situation, the beacon frame length can be increased such that more root nodes can be
-                detected simultaneously. Each additional root node will require 36 bytes and should be added on top of
-                the default beacon frame length of
-                752 bytes. For example, if you want to detect 10 root nodes simultaneously, you need to set the beacon
-                frame length as
-                932 (752+36*5).
-
-                Setting a longer beacon length also assists with debugging as the conflicting root nodes can be
-                identified more quickly.
-
-        config ESP_WIFI_MGMT_SBUF_NUM
-            int "WiFi mgmt short buffer number"
-            range 6 32
-            default 32
-            help
-                Set the number of WiFi management short buffer.
-
-        config ESP_WIFI_IRAM_OPT
-            bool "WiFi IRAM speed optimization"
-            default n if (BT_ENABLED && SPIRAM && SLAVE_IDF_TARGET_ESP32)
-            default y
-            help
-                Select this option to place frequently called Wi-Fi library functions in IRAM.
-                When this option is disabled, more than 10Kbytes of IRAM memory will be saved
-                but Wi-Fi throughput will be reduced.
-
-        config ESP_WIFI_EXTRA_IRAM_OPT
-            bool "WiFi EXTRA IRAM speed optimization"
-            default y if SLAVE_IDF_TARGET_ESP32C6
-            default n
-            help
-                Select this option to place additional frequently called Wi-Fi library functions
-                in IRAM. When this option is disabled, more than 5Kbytes of IRAM memory will be saved
-                but Wi-Fi throughput will be reduced.
-
-        config ESP_WIFI_RX_IRAM_OPT
-            bool "WiFi RX IRAM speed optimization"
-            default n if (BT_ENABLED && SPIRAM && SLAVE_IDF_TARGET_ESP32)
-            default y
-            help
-                Select this option to place frequently called Wi-Fi library RX functions in IRAM.
-                When this option is disabled, more than 17Kbytes of IRAM memory will be saved
-                but Wi-Fi performance will be reduced.
-
-        config ESP_WIFI_ENABLE_WPA3_SAE
-            bool "Enable WPA3-Personal"
-            default y
-            select ESP_WIFI_MBEDTLS_CRYPTO
-            help
-                Select this option to allow the device to establish a WPA3-Personal connection with eligible AP's.
-                PMF (Protected Management Frames) is a prerequisite feature for a WPA3 connection, it needs to be
-                explicitly configured before attempting connection. Please refer to the Wi-Fi Driver API Guide
-                for details.
-
-        config ESP_WIFI_ENABLE_SAE_PK
-            bool "Enable SAE-PK"
-            default y
-            depends on ESP_WIFI_ENABLE_WPA3_SAE
-            help
-                Select this option to enable SAE-PK
-
-        config ESP_WIFI_SOFTAP_SAE_SUPPORT
-            bool "Enable WPA3 Personal(SAE) SoftAP"
-            default y
-            depends on ESP_WIFI_ENABLE_WPA3_SAE
-            depends on ESP_WIFI_SOFTAP_SUPPORT
-            help
-                Select this option to enable SAE support in softAP mode.
-
-        config ESP_WIFI_ENABLE_WPA3_OWE_STA
-            bool "Enable OWE STA"
-            default y
-            select ESP_WIFI_MBEDTLS_CRYPTO
-            help
-                Select this option to allow the device to establish OWE connection with eligible AP's.
-                PMF (Protected Management Frames) is a prerequisite feature for a WPA3 connection, it needs to be
-                explicitly configured before attempting connection. Please refer to the Wi-Fi Driver API Guide
-                for details.
-
-        config ESP_WIFI_SLP_IRAM_OPT
-            bool "WiFi SLP IRAM speed optimization"
-            select PM_SLP_DEFAULT_PARAMS_OPT
-            select PERIPH_CTRL_FUNC_IN_IRAM
-            help
-                Select this option to place called Wi-Fi library TBTT process and receive beacon functions in IRAM.
-                Some functions can be put in IRAM either by ESP_WIFI_IRAM_OPT and ESP_WIFI_RX_IRAM_OPT, or this one.
-                If already enabled ESP_WIFI_IRAM_OPT, the other 7.3KB IRAM memory would be taken by this option.
-                If already enabled ESP_WIFI_RX_IRAM_OPT, the other 1.3KB IRAM memory would be taken by this option.
-                If neither of them are enabled, the other 7.4KB IRAM memory would be taken by this option.
-                Wi-Fi power-save mode average current would be reduced if this option is enabled.
-
-        config ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME
-            int "Minimum active time"
-            range 8 60
-            default 50
-            depends on ESP_WIFI_SLP_IRAM_OPT
-            help
-                The minimum timeout for waiting to receive data, unit: milliseconds.
-
-        config ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME
-            int "Maximum keep alive time"
-            range 10 60
-            default 10
-            depends on ESP_WIFI_SLP_IRAM_OPT
-            help
-                The maximum time that wifi keep alive, unit: seconds.
-
-        config ESP_WIFI_FTM_ENABLE
-            bool "WiFi FTM"
-            default n
-            depends on SLAVE_SOC_WIFI_FTM_SUPPORT
-            help
-                Enable feature Fine Timing Measurement for calculating WiFi Round-Trip-Time (RTT).
-
-        config ESP_WIFI_FTM_INITIATOR_SUPPORT
-            bool "FTM Initiator support"
-            default y
-            depends on ESP_WIFI_FTM_ENABLE
-
-        config ESP_WIFI_FTM_RESPONDER_SUPPORT
-            bool "FTM Responder support"
-            default y
-            depends on ESP_WIFI_FTM_ENABLE
-
-        config ESP_WIFI_STA_DISCONNECTED_PM_ENABLE
-            bool "Power Management for station at disconnected"
-            default y
-            help
-                Select this option to enable power_management for station when disconnected.
-                Chip will do modem-sleep when rf module is not in use any more.
-
-        config ESP_WIFI_GCMP_SUPPORT
-            bool "WiFi GCMP Support(GCMP128 and GCMP256)"
-            default n
-            depends on SLAVE_SOC_WIFI_GCMP_SUPPORT
-            help
-                Select this option to enable GCMP support. GCMP support is compulsory for WiFi Suite-B support.
-
-        config ESP_WIFI_GMAC_SUPPORT
-            bool "WiFi GMAC Support(GMAC128 and GMAC256)"
-            default n
-            help
-                Select this option to enable GMAC support. GMAC support is compulsory for WiFi 192 bit certification.
-
-        config ESP_WIFI_SOFTAP_SUPPORT
-            bool "WiFi SoftAP Support"
-            default y
-            help
-                WiFi module can be compiled without SoftAP to save code size.
-
-        config ESP_WIFI_ENHANCED_LIGHT_SLEEP
-            bool "WiFi modem automatically receives the beacon"
-            default n
-            depends on ESP_PHY_MAC_BB_PD && SOC_PM_SUPPORT_BEACON_WAKEUP
-            help
-                The wifi modem automatically receives the beacon frame during light sleep.
-
-        config ESP_WIFI_SLP_BEACON_LOST_OPT
-            bool "Wifi sleep optimize when beacon lost"
-            help
-                Enable wifi sleep optimization when beacon loss occurs and immediately enter
-                sleep mode when the WiFi module detects beacon loss.
-
-        config ESP_WIFI_SLP_BEACON_LOST_TIMEOUT
-            int "Beacon loss timeout"
-            range 5 100
-            default 10
-            depends on ESP_WIFI_SLP_BEACON_LOST_OPT
-            help
-                Timeout time for close rf phy when beacon loss occurs, Unit: 1024 microsecond.
-
-        config ESP_WIFI_SLP_BEACON_LOST_THRESHOLD
-            int "Maximum number of consecutive lost beacons allowed"
-            range 0 8
-            default 3
-            depends on ESP_WIFI_SLP_BEACON_LOST_OPT
-            help
-                Maximum number of consecutive lost beacons allowed, WiFi keeps Rx state when
-                the number of consecutive beacons lost is greater than the given threshold.
-
-        config ESP_WIFI_SLP_PHY_ON_DELTA_EARLY_TIME
-            int "Delta early time for RF PHY on"
-            range 0 100
-            default 2
-            depends on ESP_WIFI_SLP_BEACON_LOST_OPT && SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-            help
-                Delta early time for rf phy on, When the beacon is lost, the next rf phy on will
-                be earlier the time specified by the configuration item, Unit: 32 microsecond.
-
-        config ESP_WIFI_SLP_PHY_OFF_DELTA_TIMEOUT_TIME
-            int "Delta timeout time for RF PHY off"
-            range 0 8
-            default 2
-            depends on ESP_WIFI_SLP_BEACON_LOST_OPT && SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-            help
-                Delta timeout time for rf phy off, When the beacon is lost, the next rf phy off will
-                be delayed for the time specified by the configuration item. Unit: 1024 microsecond.
-
-        config ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM
-            int "Maximum espnow encrypt peers number"
-            range 0 4 if SLAVE_IDF_TARGET_ESP32C2
-            range 0 17 if (!SLAVE_IDF_TARGET_ESP32C2)
-            default 2 if SLAVE_IDF_TARGET_ESP32C2
-            default 7 if (!SLAVE_IDF_TARGET_ESP32C2)
-            help
-                Maximum number of encrypted peers supported by espnow.
-                The number of hardware keys for encryption is fixed. And the espnow and SoftAP share the same
-                hardware keys. So this configuration will affect the maximum connection number of SoftAP.
-                Maximum espnow encrypted peers number + maximum number of connections of SoftAP = Max hardware
-                keys number. When using ESP mesh, this value should be set to a maximum of 6.
-
-        config ESP_WIFI_NAN_ENABLE
-            bool "WiFi Aware"
-            default n
-            depends on SLAVE_SOC_WIFI_NAN_SUPPORT
-            help
-                Enable WiFi Aware (NAN) feature.
-
-        config ESP_WIFI_ENABLE_WIFI_TX_STATS
-            bool "Enable Wi-Fi transmission statistics"
-            depends on SLAVE_SOC_WIFI_HE_SUPPORT
-            default "y"
-            help
-                Enable Wi-Fi transmission statistics. Total support 4 access category. Each access category
-                will use 346 bytes memory.
-
-        config ESP_WIFI_MBEDTLS_CRYPTO
-            bool "Use MbedTLS crypto APIs"
-            default y
-            select MBEDTLS_AES_C
-            select MBEDTLS_ECP_C
-            select MBEDTLS_ECDH_C
-            select MBEDTLS_ECDSA_C
-            select MBEDTLS_CMAC_C
-            select MBEDTLS_ECP_DP_SECP256R1_ENABLED
-            help
-                Select this option to enable the use of MbedTLS crypto APIs.
-                The internal crypto support within the supplicant is limited
-                and may not suffice for all new security features, including WPA3.
-
-                It is recommended to always keep this option enabled. Additionally,
-                note that MbedTLS can leverage hardware acceleration if available,
-                resulting in significantly faster cryptographic operations.
-
-        if ESP_WIFI_MBEDTLS_CRYPTO
-            config ESP_WIFI_MBEDTLS_TLS_CLIENT
-                bool "Use MbedTLS TLS client for WiFi Enterprise connection"
-                depends on ESP_WIFI_ENTERPRISE_SUPPORT
-                default y
-                select MBEDTLS_TLS_ENABLED
-                help
-                    Select this option to use MbedTLS TLS client for WPA2 enterprise connection.
-                    Please note that from MbedTLS-3.0 onwards, MbedTLS does not support SSL-3.0
-                    TLS-v1.0, TLS-v1.1 versions. In case your server is using one of these version,
-                    it is advisable to update your server.
-                    Please disable this option for compatibility with older TLS versions.
-
-            config ESP_WIFI_EAP_TLS1_3
-                bool "Enable EAP-TLS v1.3 Support for WiFi Enterprise connection"
-                default n
-                select MBEDTLS_SSL_PROTO_TLS1_3
-                depends on ESP_WIFI_MBEDTLS_TLS_CLIENT && IDF_EXPERIMENTAL_FEATURES
-                help
-                    Select this option to support EAP with TLS v1.3.
-                    This configuration still supports compatibility with EAP-TLS v1.2.
-                    Please note that enabling this configuration will cause every application which
-                    uses TLS go for TLS1.3 if server supports that. TLS1.3 is still in development in mbedtls
-                    and there may be interoperability issues with this. Please modify your application to set
-                    max version as TLS1.2 if you want to enable TLS1.3 only for WiFi connection.
-
-        endif
-
-        config ESP_WIFI_WAPI_PSK
-            bool "Enable WAPI PSK support"
-            depends on SLAVE_SOC_WIFI_WAPI_SUPPORT
-            default n
-            help
-                Select this option to enable WAPI-PSK
-                which is a Chinese National Standard Encryption for Wireless LANs (GB 15629.11-2003).
-
-        config ESP_WIFI_SUITE_B_192
-            bool "Enable NSA suite B support with 192 bit key"
-            default n
-            depends on SLAVE_SOC_WIFI_GCMP_SUPPORT
-            select ESP_WIFI_GCMP_SUPPORT
-            select ESP_WIFI_GMAC_SUPPORT
-            help
-                Select this option to enable 192 bit NSA suite-B.
-                This is necessary to support WPA3 192 bit security.
-
-        config ESP_WIFI_11KV_SUPPORT
-            bool "Enable 802.11k, 802.11v APIs Support"
-            default n
-            help
-                Select this option to enable 802.11k 802.11v APIs(RRM and BTM support).
-                Only APIs which are helpful for network assisted roaming
-                are supported for now.
-                Enable this option with BTM and RRM enabled in sta config
-                to make device ready for network assisted roaming.
-                BTM: BSS transition management enables an AP to request a station to transition
-                to a specific AP, or to indicate to a station a set of preferred APs.
-                RRM: Radio measurements enable STAs to understand the radio environment,
-                it enables STAs to observe and gather data on radio link performance
-                and on the radio environment. Current implementation adds beacon report,
-                link measurement, neighbor report.
-
-        config ESP_WIFI_SCAN_CACHE
-            bool "Keep scan results in cache"
-            depends on ESP_WIFI_11KV_SUPPORT
-            default n
-            help
-                Keep scan results in cache, if not enabled, those
-                will be flushed immediately.
-
-        config ESP_WIFI_MBO_SUPPORT
-            bool "Enable Multi Band Operation Certification Support"
-            default n
-            select ESP_WIFI_11KV_SUPPORT
-            select ESP_WIFI_SCAN_CACHE
-            help
-                Select this option to enable WiFi Multiband operation certification support.
-
-        config ESP_WIFI_ENABLE_ROAMING_APP
-            bool "Advanced support for Wi-Fi Roaming (Experimental)"
-            depends on IDF_EXPERIMENTAL_FEATURES
-            default n
-            select ESP_WIFI_SCAN_CACHE
-            help
-                Enable Espressif's roaming app to allow for efficient Wi-Fi roaming.
-                This includes configurable periodic environment scans, maintaining a cache of the
-                best APs, handling low rssi events etc.
-
-                Risk Warning
-                Please note that this feature is still experimental and enabling this potentially can
-                lead to unpredictable scanning, connection and roaming attempts.
-                We are still working on tuning and optimising this feature to ensure reliable and stable use.
-
-        menu "Configure roaming App"
-            depends on ESP_WIFI_ENABLE_ROAMING_APP
-            rsource "wifi_apps/roaming_app/src/Kconfig.roaming"
-        endmenu
-
-        config ESP_WIFI_DPP_SUPPORT
-            bool "Enable DPP support"
-            default n
-            select ESP_WIFI_MBEDTLS_CRYPTO
-            help
-                Select this option to enable WiFi Easy Connect Support.
-
-        config ESP_WIFI_11R_SUPPORT
-            bool "Enable 802.11R (Fast Transition) Support"
-            default n
-            help
-                Select this option to enable WiFi Fast Transition Support.
-
-        config ESP_WIFI_WPS_SOFTAP_REGISTRAR
-            bool "Add WPS Registrar support in SoftAP mode"
-            depends on ESP_WIFI_SOFTAP_SUPPORT
-            default n
-            help
-                Select this option to enable WPS registrar support in softAP mode.
-
-        config ESP_WIFI_ENABLE_WIFI_RX_STATS
-            bool "Enable Wi-Fi reception statistics"
-            depends on SLAVE_SOC_WIFI_HE_SUPPORT
-            default "y"
-            help
-                Enable Wi-Fi reception statistics. Total support 2 access category. Each access category
-                will use 190 bytes memory.
-
-        config ESP_WIFI_ENABLE_WIFI_RX_MU_STATS
-            bool "Enable Wi-Fi DL MU-MIMO and DL OFDMA reception statistics"
-            depends on ESP_WIFI_ENABLE_WIFI_RX_STATS
-            default "y"
-            help
-                Enable Wi-Fi DL MU-MIMO and DL OFDMA reception statistics. Will use 10932 bytes memory.
-
-        menu "WPS Configuration Options"
-            config ESP_WIFI_WPS_STRICT
-                bool "Strictly validate all WPS attributes"
-                default n
-                help
-                    Select this option to enable validate each WPS attribute
-                    rigorously. Disabling this add the workarounds with various APs.
-                    Enabling this may cause inter operability issues with some APs.
-
-            config ESP_WIFI_WPS_PASSPHRASE
-                bool "Get WPA2 passphrase in WPS config"
-                default n
-                help
-                    Select this option to get passphrase during WPS configuration.
-                    This option fakes the virtual display capabilities to get the
-                    configuration in passphrase mode.
-                    Not recommended to be used since WPS credentials should not
-                    be shared to other devices, making it in readable format increases
-                    that risk, also passphrase requires pbkdf2 to convert in psk.
-
-        endmenu # "WPS Configuration Options"
-
-
-        config ESP_WIFI_DEBUG_PRINT
-            bool "Print debug messages from WPA Supplicant"
-            default n
-            help
-                Select this option to print logging information from WPA supplicant,
-                this includes handshake information and key hex dumps depending
-                on the project logging level.
-
-                Enabling this could increase the build size ~60kb
-                depending on the project logging level.
-
-        config ESP_WIFI_TESTING_OPTIONS
-            bool "Add DPP testing code"
-            default n
-            help
-                Select this to enable unity test for DPP.
-
-        config ESP_WIFI_ENTERPRISE_SUPPORT
-            bool "Enable enterprise option"
-            default y
-            help
-                Select this to enable/disable enterprise connection support.
-
-                disabling this will reduce binary size.
-                disabling this will disable the use of any esp_wifi_sta_wpa2_ent_* (as APIs will be meaningless)
-
-                Note that when using bigger certificates on low-power chips without crypto
-                hardware acceleration, it is recommended to adjust the task watchdog timer (TWDT)
-                if it is enabled. For precise information on timing requirements, you can check
-                performance numbers at https://github.com/espressif/mbedtls/wiki/Performance-Numbers.
-
-        config ESP_WIFI_ENT_FREE_DYNAMIC_BUFFER
-            bool "Free dynamic buffers during WiFi enterprise connection"
-            depends on ESP_WIFI_ENTERPRISE_SUPPORT
-            default y if SLAVE_IDF_TARGET_ESP32C2
-            default n if !SLAVE_IDF_TARGET_ESP32C2
-            help
-                Select this configuration to free dynamic buffers during WiFi enterprise connection.
-                This will enable chip to reduce heap consumption during WiFi enterprise connection.
-
-endmenu # Wi-Fi Remote

components/esp_wifi_remote/Kconfig.rpc.in

@@ -1,74 +0,0 @@
-choice ESP_WIFI_REMOTE_LIBRARY
-    prompt "Choose WiFi-remote implementation"
-    default ESP_WIFI_REMOTE_LIBRARY_EPPP
-    help
-        Select type of WiFi Remote implementation
-
-        ESP-HOSTED is the default and most versatile option.
-        It's also possible to use EPPP, which uses PPPoS link between micros and NAPT, so it's slower
-        and less universal.
-
-    config ESP_WIFI_REMOTE_LIBRARY_HOSTED
-        bool "ESP-HOSTED"
-    config ESP_WIFI_REMOTE_LIBRARY_EPPP
-        bool "EPPP"
-endchoice
-
-    if ESP_WIFI_REMOTE_LIBRARY_EPPP
-
-        config ESP_WIFI_REMOTE_EPPP_UART_TX_PIN
-            int "TXD Pin Number"
-            default 10
-            range 0 31
-            help
-                Pin number of UART TX.
-
-        config ESP_WIFI_REMOTE_EPPP_UART_RX_PIN
-            int "RXD Pin Number"
-            default 11
-            range 0 31
-            help
-                Pin number of UART RX.
-
-        config ESP_WIFI_REMOTE_EPPP_NETIF_PRIORITY
-            int "Routing priority of eppp netif"
-            default 100
-            range 0 256
-            help
-                Set the priority of the wifi-remote netif.
-                The bigger the number the higher the priority.
-                The interface which is up and with the highest priority will act as a default GW.
-
-        config ESP_WIFI_REMOTE_EPPP_NETIF_DESCRIPTION
-            string "eppp network interface description"
-            default "example_netif_sta"
-            help
-                Textual description of the wifi remote network interface.
-                By default it is set to "example_netif_sta" to be used in IDF protocol example
-                as default wifi station substitution.
-
-        config ESP_WIFI_REMOTE_EPPP_SERVER_CA
-            string "Servers CA certificate"
-            default "--- Please copy content of the CA certificate ---"
-
-        config ESP_WIFI_REMOTE_EPPP_CLIENT_CRT
-            string "Client certificate"
-            default "--- Please copy content of the Client certificate ---"
-
-        config ESP_WIFI_REMOTE_EPPP_CLIENT_KEY
-            string "Client key"
-            default "--- Please copy content of the Client key ---"
-
-        config ESP_WIFI_REMOTE_EPPP_CLIENT_CA
-            string "Clients CA certificate"
-            default "--- Please copy content of the CA certificate ---"
-
-        config ESP_WIFI_REMOTE_EPPP_SERVER_CRT
-            string "Server certificate"
-            default "--- Please copy content of the Client certificate ---"
-
-        config ESP_WIFI_REMOTE_EPPP_SERVER_KEY
-            string "Server key"
-            default "--- Please copy content of the Client key ---"
-
-    endif

components/esp_wifi_remote/Kconfig.soc_wifi_caps.in

@@ -1,237 +0,0 @@
-# This file is auto-generated
-
-if SLAVE_IDF_TARGET_ESP32
-
-    config SLAVE_SOC_WIFI_SUPPORTED
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_WAPI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_CSI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_MESH_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_NAN_SUPPORT
-        bool
-        default y
-
-endif # ESP32
-
-if SLAVE_IDF_TARGET_ESP32S2
-
-    config SLAVE_SOC_WIFI_SUPPORTED
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH
-        int
-        default 12
-
-    config SLAVE_SOC_WIFI_HW_TSF
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_FTM_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_WAPI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_CSI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_MESH_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_NAN_SUPPORT
-        bool
-        default y
-
-endif # ESP32S2
-
-if SLAVE_IDF_TARGET_ESP32C3
-
-    config SLAVE_SOC_WIFI_SUPPORTED
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH
-        int
-        default 12
-
-    config SLAVE_SOC_WIFI_HW_TSF
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_FTM_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_GCMP_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_WAPI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_CSI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_MESH_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND
-        bool
-        default y
-
-endif # ESP32C3
-
-if SLAVE_IDF_TARGET_ESP32S3
-
-    config SLAVE_SOC_WIFI_SUPPORTED
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH
-        int
-        default 12
-
-    config SLAVE_SOC_WIFI_HW_TSF
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_FTM_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_GCMP_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_WAPI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_CSI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_MESH_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND
-        bool
-        default y
-
-endif # ESP32S3
-
-if SLAVE_IDF_TARGET_ESP32C2
-
-    config SLAVE_SOC_WIFI_SUPPORTED
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH
-        int
-        default 12
-
-    config SLAVE_SOC_WIFI_HW_TSF
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_FTM_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND
-        bool
-        default y
-
-endif # ESP32C2
-
-if SLAVE_IDF_TARGET_ESP32C6
-
-    config SLAVE_SOC_WIFI_SUPPORTED
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH
-        int
-        default 12
-
-    config SLAVE_SOC_WIFI_HW_TSF
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_FTM_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_GCMP_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_WAPI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_CSI_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_MESH_SUPPORT
-        bool
-        default y
-
-    config SLAVE_SOC_WIFI_HE_SUPPORT
-        bool
-        default y
-
-endif # ESP32C6
-
-if SLAVE_IDF_TARGET_ESP32H2
-
-endif # ESP32H2
-
-if SLAVE_IDF_TARGET_ESP32P4
-
-    config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH
-        int
-        default 12
-
-endif # ESP32P4

components/esp_wifi_remote/README.md

@@ -1,26 +0,0 @@
-# esp_wifi_remote
-
-[![Component Registry](https://components.espressif.com/components/espressif/esp_wifi_remote/badge.svg)](https://components.espressif.com/components/espressif/esp_wifi_remote)
-
-The `esp_wifi_remote` component is designed to extend WiFi functionality to ESP chipsets that lack native WiFi support. By simply adding a dependency to this component from your project, you gain access to WiFi capabilities via the WiFi-remote menuconfig and standard `esp_wifi` interface.
-
-Moreover, `esp_wifi_remote` can be utilized on ESP chipsets that do support native WiFi, providing an additional WiFi interface through the `esp_wifi_remote` API.
-
-To employ this component, a slave device -- capable of WiFi connectivity -- must be connected to your target device in a specified manner, as defined by the transport layer of [`esp_hosted`](https://github.com/espressif/esp-hosted).
-
-Functionally, `esp_wifi_remote` wraps the public API of `esp_wifi`, offering a set of function call namespaces prefixed with esp_wifi_remote. These calls are translated into Remote Procedure Calls (RPC) to another target device (referred to as the "slave" device), which then executes the appropriate `esp_wifi` APIs.
-
-Notably, `esp_wifi_remote` heavily relies on a specific version of the `esp_wifi` component. Consequently, the majority of its headers, sources, and configuration files are pre-generated based on the actual version of `esp_wifi`.
-
-It's important to highlight that `esp_wifi_remote` does not directly implement the RPC calls; rather, it relies on dependencies for this functionality. Presently, only esp_hosted is supported to provide the RPC functionality required by esp_wifi_remote.
-
-
-## Dependencies on `esp_wifi`
-
-Public API needs to correspond exactly to the `esp_wifi` API. Some of the internal types depend on the actual wifi target, as well as some default configuration values. Therefore it's easier to maintain consistency between this component and the exact version of `esp_wifi` automatically in CI:
-
-* We extract function prototypes from `esp_wifi.h` and use them to generate `esp_wifi_remote` function declarations.
-* We process the local `esp_wifi_types_native.h` and replace `CONFIG_IDF_TARGET` to `CONFIG_SLAVE_IDF_TARGET` and `CONFIG_SOC_WIFI_...` to `CONFIG_SLAVE_....`
-* Similarly we process `esp_wifi`'s Kconfig, so the dependencies are on the slave target and slave SOC capabilities.
-
-Please check the [README.md](./scripts/README.md) for more details on the generation step and testing consistency.

components/esp_wifi_remote/eppp/eppp_init.c

@@ -1,22 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include "esp_log.h"
-#include "esp_wifi.h"
-#include "eppp_link.h"
-
-__attribute__((weak)) esp_netif_t *wifi_remote_eppp_init(eppp_type_t role)
-{
-    uint32_t our_ip = role == EPPP_SERVER ? EPPP_DEFAULT_SERVER_IP() : EPPP_DEFAULT_CLIENT_IP();
-    uint32_t their_ip = role == EPPP_SERVER ? EPPP_DEFAULT_CLIENT_IP() : EPPP_DEFAULT_SERVER_IP();
-    eppp_config_t config = EPPP_DEFAULT_CONFIG(our_ip, their_ip);
-    // We currently support only UART transport
-    config.transport = EPPP_TRANSPORT_UART;
-    config.uart.tx_io = CONFIG_ESP_WIFI_REMOTE_EPPP_UART_TX_PIN;
-    config.uart.rx_io = CONFIG_ESP_WIFI_REMOTE_EPPP_UART_RX_PIN;
-    config.ppp.netif_description = CONFIG_ESP_WIFI_REMOTE_EPPP_NETIF_DESCRIPTION;
-    config.ppp.netif_prio = CONFIG_ESP_WIFI_REMOTE_EPPP_NETIF_PRIORITY;
-    return eppp_open(role, &config, portMAX_DELAY);
-}

components/esp_wifi_remote/eppp/wifi_remote_rpc_client.cpp

@@ -1,318 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include <netdb.h>
-#include <memory>
-#include <cinttypes>
-#include "esp_log.h"
-#include "esp_tls.h"
-#include "esp_wifi.h"
-#include "esp_check.h"
-#include "wifi_remote_rpc_impl.hpp"
-#include "eppp_link.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/event_groups.h"
-#include "wifi_remote_rpc_params.h"
-
-extern "C" esp_netif_t *wifi_remote_eppp_init(eppp_type_t role);
-
-namespace eppp_rpc {
-
-namespace client {
-const char *TAG = "rpc_client";
-
-const unsigned char ca_crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_CA "\n-----END CERTIFICATE-----";
-const unsigned char crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_CRT "\n-----END CERTIFICATE-----";
-const unsigned char key[] = "-----BEGIN PRIVATE KEY-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_KEY "\n-----END PRIVATE KEY-----";
-// TODO: Add option to supply keys and certs via a global symbol (file)
-
-}
-
-using namespace client;
-
-class Sync {
-    friend class RpcInstance;
-public:
-    void lock()
-    {
-        xSemaphoreTake(mutex, portMAX_DELAY);
-    }
-    void unlock()
-    {
-        xSemaphoreGive(mutex);
-    }
-    esp_err_t init()
-    {
-        mutex = xSemaphoreCreateMutex();
-        events = xEventGroupCreate();
-        return mutex == nullptr || events == nullptr ? ESP_ERR_NO_MEM : ESP_OK;
-    }
-    esp_err_t wait_for(EventBits_t bits, uint32_t timeout = portMAX_DELAY)
-    {
-        return (xEventGroupWaitBits(events, bits, pdTRUE, pdTRUE, timeout) & bits) == bits ? ESP_OK : ESP_FAIL;
-    }
-    esp_err_t notify(EventBits_t bits)
-    {
-        xEventGroupSetBits(events, bits);
-        return ESP_OK;
-    }
-    ~Sync()
-    {
-        if (mutex) {
-            vSemaphoreDelete(mutex);
-        }
-        if (events) {
-            vEventGroupDelete(events);
-        }
-    }
-
-
-private:
-    SemaphoreHandle_t mutex{nullptr};
-    EventGroupHandle_t events{nullptr};
-
-    const int request = 1;
-    const int resp_header = 2;
-    const int resp_payload = 4;
-    const int restart = 8;
-};
-
-class RpcInstance {
-    friend class Sync;
-public:
-
-    template<typename T>
-    esp_err_t send(api_id id, T *t)
-    {
-        pending_resp = id;
-        ESP_RETURN_ON_ERROR(sync.notify(sync.request), TAG, "failed to notify req");
-        ESP_RETURN_ON_ERROR(rpc.send<T>(id, t), TAG, "Failed to send request");
-        return ESP_OK;
-    }
-
-    // overload of the templated method (used for functions with no arguments)
-    esp_err_t send(api_id id)
-    {
-        pending_resp = id;
-        ESP_RETURN_ON_ERROR(sync.notify(sync.request), TAG, "failed to notify req");
-        ESP_RETURN_ON_ERROR(rpc.send(id), TAG, "Failed to send request");
-        return ESP_OK;
-    }
-
-    template<typename T>
-    T get_resp(api_id id)
-    {
-        sync.wait_for(sync.resp_header);
-        auto ret = rpc.template get_payload<T>(id, pending_header);
-        sync.notify(sync.resp_payload);
-        return ret;
-    }
-    esp_err_t init()
-    {
-        ESP_RETURN_ON_FALSE(netif = wifi_remote_eppp_init(EPPP_CLIENT), ESP_FAIL, TAG, "Failed to connect to EPPP server");
-        ESP_RETURN_ON_ERROR(esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_GOT_IP, got_ip, this), TAG, "Failed to register event");
-        ESP_RETURN_ON_ERROR(sync.init(), TAG, "Failed to init sync primitives");
-        ESP_RETURN_ON_ERROR(rpc.init(), TAG, "Failed to init RPC engine");
-        return xTaskCreate(task, "client", 8192, this, 5, nullptr) == pdTRUE ? ESP_OK : ESP_FAIL;
-    }
-    RpcEngine rpc{eppp_rpc::role::CLIENT};
-    Sync sync;
-private:
-    api_id pending_resp{api_id::UNDEF};
-    RpcHeader pending_header{};
-    esp_err_t process_ip_event(RpcHeader &header)
-    {
-        auto event = rpc.get_payload<esp_wifi_remote_eppp_ip_event>(api_id::IP_EVENT, header);
-        // Now bypass network layers with EPPP interface
-        ESP_RETURN_ON_ERROR(esp_netif_set_dns_info(netif, ESP_NETIF_DNS_MAIN, &event.dns), TAG, "Failed to set DNS info");
-        ESP_RETURN_ON_ERROR(esp_netif_set_default_netif(netif), TAG, "Failed to set default netif to EPPP");
-        ip_event_got_ip_t evt = {
-            .esp_netif = netif,
-            .ip_info = {},
-            .ip_changed = true,
-        };
-        esp_netif_get_ip_info(netif, &evt.ip_info);
-        ESP_RETURN_ON_ERROR(esp_event_post(IP_EVENT, IP_EVENT_STA_GOT_IP, &evt, sizeof(evt), 0), TAG, "Failed to post IP event");
-        ESP_LOGI(TAG, "Main DNS:" IPSTR, IP2STR(&event.dns.ip.u_addr.ip4));
-        ESP_LOGI(TAG, "EPPP IP:" IPSTR, IP2STR(&event.ppp_ip.ip));
-        ESP_LOGI(TAG, "WIFI IP:" IPSTR, IP2STR(&event.wifi_ip.ip));
-        ESP_LOGI(TAG, "WIFI GW:" IPSTR, IP2STR(&event.wifi_ip.gw));
-        ESP_LOGI(TAG, "WIFI mask:" IPSTR, IP2STR(&event.wifi_ip.netmask));
-        return ESP_OK;
-    }
-    esp_err_t process_wifi_event(RpcHeader &header)
-    {
-        auto event_id = rpc.get_payload<int32_t>(api_id::WIFI_EVENT, header);
-        ESP_RETURN_ON_ERROR(esp_event_post(WIFI_EVENT, event_id, nullptr, 0, 0), TAG, "Failed to post WiFi event");
-        return ESP_OK;
-    }
-    esp_err_t perform()
-    {
-        auto header = rpc.get_header();
-        if (api_id(header.id) == api_id::ERROR) {   // network error
-            return ESP_FAIL;
-        }
-        if (api_id(header.id) == api_id::UNDEF) {   // network timeout
-            return ESP_OK;
-        }
-
-        if (api_id(header.id) == api_id::IP_EVENT) {
-            return process_ip_event(header);
-        }
-        if (api_id(header.id) == api_id::WIFI_EVENT) {
-            return process_wifi_event(header);
-        }
-        if (sync.wait_for(sync.request, 0) == ESP_OK && api_id(header.id) == pending_resp) {
-            pending_header = header;
-            pending_resp = api_id::UNDEF;
-            sync.notify(sync.resp_header);
-            sync.wait_for(sync.resp_payload);
-            return ESP_OK;
-        }
-        ESP_LOGE(TAG, "Unexpected header %" PRIi32, static_cast<uint32_t>(header.id));
-        return ESP_FAIL;
-
-    }
-    static void task(void *ctx)
-    {
-        auto instance = static_cast<RpcInstance *>(ctx);
-        do {
-            while (instance->perform() == ESP_OK) {}
-        } while (instance->restart() == ESP_OK);
-        vTaskDelete(nullptr);
-    }
-    esp_err_t restart()
-    {
-        rpc.deinit();
-        ESP_RETURN_ON_ERROR(sync.wait_for(sync.restart, pdMS_TO_TICKS(10000)), TAG, "Didn't receive EPPP address in time");
-        return rpc.init();
-    }
-    static void got_ip(void *ctx, esp_event_base_t base, int32_t id, void *data)
-    {
-        auto instance = static_cast<RpcInstance *>(ctx);
-        instance->sync.notify(instance->sync.restart);
-    }
-    esp_netif_t *netif{nullptr};
-};
-
-
-namespace client {
-constinit RpcInstance instance;
-}   // namespace client
-
-RpcInstance *RpcEngine::init_client()
-{
-    char host[4 * 4 + 1] = {}; // IPv4: 4 x (3 numbers + '.') + \0
-    esp_ip4_addr_t ip = { .addr = EPPP_DEFAULT_SERVER_IP() };
-    if (esp_ip4addr_ntoa(&ip, host, sizeof(host)) == nullptr) {
-        return nullptr;
-    }
-
-    esp_tls_cfg_t cfg = {};
-    cfg.cacert_buf = client::ca_crt;
-    cfg.cacert_bytes = sizeof(client::ca_crt);
-    cfg.clientcert_buf = client::crt;
-    cfg.clientcert_bytes = sizeof(client::crt);
-    cfg.clientkey_buf = client::key;
-    cfg.clientkey_bytes = sizeof(client::key);
-    cfg.common_name = "espressif.local";
-
-    ESP_RETURN_ON_FALSE(tls_ = esp_tls_init(), nullptr, TAG, "Failed to create ESP-TLS instance");
-    int retries = 0;
-    while (esp_tls_conn_new_sync(host, strlen(host), rpc_port, &cfg, tls_) <= 0) {
-        esp_tls_conn_destroy(tls_);
-        tls_ = nullptr;
-        ESP_RETURN_ON_FALSE(retries++ < 3, nullptr, TAG, "Failed to open connection to %s", host);
-        ESP_LOGW(TAG, "Connection to RPC server failed! Will retry in %d second(s)", retries);
-        vTaskDelay(pdMS_TO_TICKS(1000 * retries));
-        ESP_RETURN_ON_FALSE(tls_ = esp_tls_init(), nullptr, TAG, "Failed to create ESP-TLS instance");
-    }
-    return &client::instance;
-}
-}   // namespace eppp_rpc
-
-//
-//  esp_wifi_remote API implementation
-//
-using namespace eppp_rpc;
-using namespace client;
-
-extern "C" esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config)
-{
-    // Here we initialize this client's RPC
-    ESP_RETURN_ON_ERROR(instance.init(), TAG, "Failed to initialize eppp-rpc");
-
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::INIT, config), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::INIT);
-}
-
-extern "C" esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf)
-{
-    esp_wifi_remote_config params = { .interface = interface, .conf = {} };
-    memcpy(&params.conf, conf, sizeof(wifi_config_t));
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::SET_CONFIG, &params), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::SET_CONFIG);
-}
-
-extern "C" esp_err_t esp_wifi_remote_start(void)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::START), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::START);
-}
-
-extern "C" esp_err_t esp_wifi_remote_stop(void)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::STOP), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::STOP);
-}
-
-extern "C" esp_err_t esp_wifi_remote_connect(void)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::CONNECT), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::CONNECT);
-}
-
-extern "C" esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6])
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::GET_MAC, &ifx), TAG, "Failed to send request");
-    auto ret = instance.get_resp<esp_wifi_remote_mac_t>(api_id::GET_MAC);
-    ESP_LOG_BUFFER_HEXDUMP("MAC", ret.mac, 6, ESP_LOG_DEBUG);
-    memcpy(mac, ret.mac, 6);
-    return ret.err;
-}
-
-extern "C" esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::SET_MODE, &mode), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::SET_MODE);
-}
-
-extern "C" esp_err_t esp_wifi_remote_deinit(void)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::DEINIT), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::DEINIT);
-}
-
-extern "C" esp_err_t esp_wifi_remote_disconnect(void)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::DISCONNECT), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::DISCONNECT);
-}
-
-extern "C" esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage)
-{
-    std::lock_guard<Sync> lock(instance.sync);
-    ESP_RETURN_ON_ERROR(instance.send(api_id::SET_STORAGE, &storage), TAG, "Failed to send request");
-    return instance.get_resp<esp_err_t>(api_id::SET_STORAGE);
-}

components/esp_wifi_remote/eppp/wifi_remote_rpc_impl.hpp

@@ -1,179 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-#include <cstring>
-#include <cerrno>
-
-namespace eppp_rpc {
-
-static constexpr int rpc_port = 3333;
-
-/**
- * @brief Currently supported RPC commands/events
- */
-enum class api_id : uint32_t {
-    ERROR,
-    UNDEF,
-    INIT,
-    DEINIT,
-    SET_MODE,
-    SET_CONFIG,
-    START,
-    STOP,
-    CONNECT,
-    DISCONNECT,
-    GET_MAC,
-    SET_STORAGE,
-    WIFI_EVENT,
-    IP_EVENT,
-};
-
-enum class role {
-    SERVER,
-    CLIENT,
-};
-
-struct RpcHeader {
-    api_id id;
-    uint32_t size;
-} __attribute((__packed__));
-
-/**
- * @brief Structure holding the outgoing or incoming parameter
- */
-template<typename T>
-struct RpcData {
-    RpcHeader head;
-    T value_{};
-    explicit RpcData(api_id id) : head{id, sizeof(T)} {}
-
-    uint8_t *value()
-    {
-        return (uint8_t *) &value_;
-    }
-
-    uint8_t *marshall(T *t, size_t &size)
-    {
-        size = head.size + sizeof(RpcHeader);
-        memcpy(value(), t, sizeof(T));
-        return (uint8_t *) this;
-    }
-} __attribute((__packed__));
-
-/**
- * @brief Singleton holding the static data for either the client or server side
- */
-class RpcInstance;
-
-/**
- * @brief Engine that implements a simple RPC mechanism
- */
-class RpcEngine {
-public:
-    constexpr explicit RpcEngine(role r) : tls_(nullptr), role_(r) {}
-
-    esp_err_t init()
-    {
-        if (tls_ != nullptr) {
-            return ESP_OK;
-        }
-        if (role_ == role::CLIENT) {
-            instance = init_client();
-        }
-        if (role_ == role::SERVER) {
-            instance = init_server();
-        }
-        return instance == nullptr ? ESP_FAIL : ESP_OK;
-    }
-
-    void deinit()
-    {
-        if (tls_ == nullptr) {
-            return;
-        }
-        if (role_ == role::CLIENT) {
-            esp_tls_conn_destroy(tls_);
-        } else if (role_ == role::SERVER) {
-            esp_tls_server_session_delete(tls_);
-        }
-        tls_ = nullptr;
-    }
-
-    template<typename T>
-    esp_err_t send(api_id id, T *t)
-    {
-        RpcData<T> req(id);
-        size_t size;
-        auto buf = req.marshall(t, size);
-        ESP_LOGD("rpc", "Sending API id:%d", (int) id);
-        ESP_LOG_BUFFER_HEXDUMP("rpc", buf, size, ESP_LOG_VERBOSE);
-        int len = esp_tls_conn_write(tls_, buf, size);
-        if (len <= 0) {
-            ESP_LOGE("rpc", "Failed to write data to the connection");
-            return ESP_FAIL;
-        }
-        return ESP_OK;
-    }
-
-    esp_err_t send(api_id id) // overload for (void)
-    {
-        RpcHeader head = {.id = id, .size = 0};
-        int len = esp_tls_conn_write(tls_, &head, sizeof(head));
-        if (len <= 0) {
-            ESP_LOGE("rpc", "Failed to write data to the connection");
-            return ESP_FAIL;
-        }
-        return ESP_OK;
-    }
-
-    int get_socket_fd()
-    {
-        int sock;
-        if (esp_tls_get_conn_sockfd(tls_, &sock) != ESP_OK) {
-            return -1;
-        }
-        return sock;
-    }
-
-    RpcHeader get_header()
-    {
-        RpcHeader header{};
-        int len = esp_tls_conn_read(tls_, (char *) &header, sizeof(header));
-        if (len <= 0) {
-            if (len < 0 && errno != EAGAIN) {
-                ESP_LOGE("rpc", "Failed to read header data from the connection %d %s", errno, strerror(errno));
-                return {.id = api_id::ERROR, .size = 0};
-            }
-            return {.id = api_id::UNDEF, .size = 0};
-        }
-        return header;
-    }
-
-    template<typename T>
-    T get_payload(api_id id, RpcHeader &head)
-    {
-        RpcData<T> resp(id);
-        if (head.id != id || head.size != resp.head.size) {
-            ESP_LOGE("rpc", "unexpected header %d %d or sizes %" PRIu32 " %" PRIu32, (int)head.id, (int)id, head.size, resp.head.size);
-            return {};
-        }
-        int len = esp_tls_conn_read(tls_, (char *) resp.value(), resp.head.size);
-        if (len <= 0) {
-            ESP_LOGE("rpc", "Failed to read data from the connection");
-            return {};
-        }
-        return resp.value_;
-    }
-
-private:
-    RpcInstance *init_server();
-    RpcInstance *init_client();
-    esp_tls_t *tls_;
-    role role_;
-    RpcInstance *instance{nullptr};
-};
-
-};

components/esp_wifi_remote/eppp/wifi_remote_rpc_params.h

@@ -1,23 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-
-struct esp_wifi_remote_config {
-    wifi_interface_t interface;
-    wifi_config_t conf;
-};
-
-struct esp_wifi_remote_mac_t {
-    esp_err_t err;
-    uint8_t mac[6];
-};
-
-struct esp_wifi_remote_eppp_ip_event {
-    int32_t id;
-    esp_netif_ip_info_t wifi_ip;
-    esp_netif_ip_info_t ppp_ip;
-    esp_netif_dns_info_t dns;
-};

components/esp_wifi_remote/eppp/wifi_remote_rpc_server.cpp

@@ -1,383 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include <netdb.h>
-#include <memory>
-#include <cerrno>
-#include <sys/socket.h>
-#include "esp_log.h"
-#include "esp_check.h"
-#include "esp_tls.h"
-#include "esp_wifi.h"
-#include "wifi_remote_rpc_impl.hpp"
-#include "eppp_link.h"
-#include "wifi_remote_rpc_params.h"
-#include "lwip/apps/snmp.h"
-#include "esp_vfs.h"
-#include "esp_vfs_eventfd.h"
-
-extern "C" esp_netif_t *wifi_remote_eppp_init(eppp_type_t role);
-
-namespace eppp_rpc {
-
-namespace server {
-const char *TAG = "rpc_server";
-
-const unsigned char ca_crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_CA "\n-----END CERTIFICATE-----";
-const unsigned char crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_CRT "\n-----END CERTIFICATE-----";
-const unsigned char key[] = "-----BEGIN PRIVATE KEY-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_KEY "\n-----END PRIVATE KEY-----";
-// TODO: Add option to supply keys and certs via a global symbol (file)
-
-}
-
-using namespace server;
-
-struct Events {
-    api_id type;
-    int32_t id;
-    esp_wifi_remote_eppp_ip_event *ip_data{nullptr};
-    bool clean_ip_data{true};
-    esp_err_t create_ip_data()
-    {
-        ip_data = new (std::nothrow) esp_wifi_remote_eppp_ip_event;
-        return ip_data ? ESP_OK : ESP_ERR_NO_MEM;
-    }
-    ~Events()
-    {
-        if (clean_ip_data) {
-            delete ip_data;
-        }
-    }
-};
-
-class Sync {
-    friend class RpcInstance;
-public:
-    esp_err_t put(Events &ev)
-    {
-        ESP_RETURN_ON_FALSE(xQueueSend(queue, &ev, pdMS_TO_TICKS(queue_timeout)), ESP_FAIL, TAG, "Failed to queue event %" PRIi32, ev.id);
-        ev.clean_ip_data = false; // IP data were successfully sent to the queue, will free manually after receiving from it
-        uint64_t event_queued = 1;
-        write(fd, &event_queued, sizeof(event_queued));     // trigger the wait loop that
-        return ESP_OK;
-    }
-    Events get()
-    {
-        Events ev{};
-        if (!xQueueReceive(queue, &ev, 0)) {
-            ev.type = api_id::ERROR;
-        }
-        return ev;
-    }
-    esp_err_t init()
-    {
-        queue = xQueueCreate(max_items, sizeof(Events));
-        esp_vfs_eventfd_config_t config = ESP_VFS_EVENTD_CONFIG_DEFAULT();
-        esp_vfs_eventfd_register(&config);
-        fd = eventfd(0, EFD_SUPPORT_ISR);
-        return queue == nullptr || fd < 0 ? ESP_ERR_NO_MEM : ESP_OK;
-    }
-    ~Sync()
-    {
-        if (queue) {
-            vQueueDelete(queue);
-        }
-        if (fd >= 0) {
-            close(fd);
-        }
-    }
-    int fd{-1};
-    // Used to trigger task by either an internal event or rpc command
-    static const int NONE = 0;
-    static const int ERROR = 1;
-    static const int EVENT = 2;
-    static const int RPC   = 4;
-private:
-    QueueHandle_t  queue{nullptr};
-    const int max_items = 15;
-    const int queue_timeout = 200;
-};
-
-class RpcInstance {
-    friend class Sync;
-public:
-    RpcEngine rpc{role::SERVER};
-    int sock{-1};
-
-    esp_err_t init()
-    {
-        ESP_RETURN_ON_FALSE(netif = wifi_remote_eppp_init(EPPP_SERVER), ESP_FAIL, TAG, "Failed to init EPPP connection");
-        ESP_RETURN_ON_ERROR(start_server(), TAG, "Failed to start RPC server");
-        ESP_RETURN_ON_ERROR(rpc.init(), TAG, "Failed to init RPC engine");
-        ESP_RETURN_ON_ERROR(esp_netif_napt_enable(netif), TAG, "Failed to enable NAPT");
-        ESP_RETURN_ON_ERROR(sync.init(), TAG, "Failed to init event queue");
-        ESP_RETURN_ON_ERROR(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, handler, this), TAG, "Failed to register event");
-        ESP_RETURN_ON_ERROR(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, handler, this), TAG, "Failed to register event");
-        return xTaskCreate(task, "server", 8192, this, 5, nullptr) == pdTRUE ? ESP_OK : ESP_FAIL;
-    }
-    Sync sync;
-private:
-    esp_netif_t *netif{nullptr};
-    static void task(void *ctx)
-    {
-        auto instance = static_cast<RpcInstance *>(ctx);
-        while (instance->perform() == ESP_OK) {}
-        esp_restart();
-    }
-    esp_err_t start_server()
-    {
-        struct sockaddr_in dest_addr = {};
-        int ret;
-        int opt = 1;
-        dest_addr.sin_addr.s_addr = htonl(INADDR_ANY);
-        dest_addr.sin_family = AF_INET;
-        dest_addr.sin_port = htons(rpc_port);
-        int listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
-        ESP_RETURN_ON_FALSE(listen_sock >= 0, ESP_FAIL, TAG, "Failed to create listening socket");
-        setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-        ret = bind(listen_sock, (struct sockaddr *) &dest_addr, sizeof(dest_addr));
-        ESP_RETURN_ON_FALSE(ret == 0, ESP_FAIL, TAG, "Failed to bind the listening socket");
-        ret = listen(listen_sock, 1);
-        ESP_RETURN_ON_FALSE(ret == 0, ESP_FAIL, TAG, "Failed to start listening");
-        struct sockaddr_storage source_addr {};
-        socklen_t addr_len = sizeof(source_addr);
-        sock = accept(listen_sock, (struct sockaddr *) &source_addr, &addr_len);
-        ESP_RETURN_ON_FALSE(sock >= 0, ESP_FAIL, TAG, "Failed to accept connections: errno %d", errno);
-        ESP_LOGI(TAG, "Socket accepted on: %s", inet_ntoa(((struct sockaddr_in *) &source_addr)->sin_addr));
-        return ESP_OK;
-    }
-    esp_err_t wifi_event(int32_t id)
-    {
-        ESP_LOGI(TAG, "Received WIFI event %" PRIi32, id);
-        Events ev{api_id::WIFI_EVENT, id, nullptr};
-        ESP_RETURN_ON_ERROR(sync.put(ev), TAG, "Failed to queue WiFi event");
-        return ESP_OK;
-    }
-    esp_err_t ip_event(int32_t id, ip_event_got_ip_t *ip_data)
-    {
-        ESP_LOGI(TAG, "Received IP event %" PRIi32, id);
-        Events ev{api_id::IP_EVENT, id, nullptr};
-        if (ip_data->esp_netif) {
-            ESP_RETURN_ON_ERROR(ev.create_ip_data(), TAG, "Failed to allocate event data");
-            ev.ip_data->id = id;
-            ESP_RETURN_ON_ERROR(esp_netif_get_dns_info(ip_data->esp_netif, ESP_NETIF_DNS_MAIN, &ev.ip_data->dns), TAG, "Failed to get DNS info");
-            ESP_LOGI(TAG, "Main DNS:" IPSTR, IP2STR(&ev.ip_data->dns.ip.u_addr.ip4));
-            memcpy(&ev.ip_data->wifi_ip, &ip_data->ip_info, sizeof(ev.ip_data->wifi_ip));
-            ESP_RETURN_ON_ERROR(esp_netif_get_ip_info(netif, &ev.ip_data->ppp_ip), TAG, "Failed to get IP info");
-            ESP_LOGI(TAG, "IP address:" IPSTR, IP2STR(&ip_data->ip_info.ip));
-        }
-        ESP_RETURN_ON_ERROR(sync.put(ev), TAG, "Failed to queue IP event");
-        return ESP_OK;
-    }
-    static void handler(void *ctx, esp_event_base_t base, int32_t id, void *data)
-    {
-        auto instance = static_cast<RpcInstance *>(ctx);
-        if (base == WIFI_EVENT) {
-            instance->wifi_event(id);
-        } else if (base == IP_EVENT) {
-            auto *ip_data = (ip_event_got_ip_t *)data;
-            instance->ip_event(id, ip_data);
-        }
-    }
-    int select()
-    {
-        struct timeval timeout = { .tv_sec = 1, .tv_usec = 0};
-        int rpc_sock = rpc.get_socket_fd();
-
-        ESP_RETURN_ON_FALSE(rpc_sock != -1, Sync::ERROR, TAG, "failed ot get rpc socket");
-        fd_set readset;
-        fd_set errset;
-        FD_ZERO(&readset);
-        FD_ZERO(&errset);
-        FD_SET(rpc_sock, &readset);
-        FD_SET(sync.fd, &readset);
-        FD_SET(rpc_sock, &errset);
-        int ret = ::select(std::max(rpc_sock, 5) + 1, &readset, nullptr, &errset, &timeout);
-        if (ret == 0) {
-            ESP_LOGV(TAG, "poll_read: select - Timeout before any socket was ready!");
-            return Sync::NONE;
-        }
-        if (ret < 0) {
-            ESP_LOGE(TAG, "select error: %d", errno);
-            return Sync::ERROR;
-        }
-        if (FD_ISSET(rpc_sock, &errset)) {
-            int sock_errno = 0;
-            uint32_t optlen = sizeof(sock_errno);
-            getsockopt(rpc_sock, SOL_SOCKET, SO_ERROR, &sock_errno, &optlen);
-            ESP_LOGE(TAG, "select failed, socket errno = %d", sock_errno);
-            return Sync::ERROR;
-        }
-        int result = Sync::NONE;
-        if (FD_ISSET(rpc_sock, &readset)) {
-            result |= Sync::RPC;
-        }
-        if (FD_ISSET(sync.fd, &readset)) {
-            result |= Sync::EVENT;
-        }
-        return result;
-    }
-    esp_err_t marshall_events()
-    {
-        api_id type;
-        do {
-            Events ev = sync.get();
-            type = ev.type;
-            if (ev.type == api_id::WIFI_EVENT) {
-                ESP_RETURN_ON_ERROR(rpc.send(api_id::WIFI_EVENT, &ev.id), TAG, "Failed to marshall WiFi event");
-            } else if (ev.type == api_id::IP_EVENT && ev.ip_data) {
-                ESP_RETURN_ON_ERROR(rpc.send(api_id::IP_EVENT, ev.ip_data), TAG, "Failed to marshal IP event");
-            }
-        } while (type != api_id::ERROR);
-        return ESP_OK;
-    }
-    esp_err_t perform()
-    {
-        auto res = select();
-        if (res == Sync::ERROR) {
-            return ESP_FAIL;
-        }
-        if (res & Sync::EVENT) {
-            uint64_t data;
-            read(sync.fd, &data, sizeof(data));
-            if (marshall_events() != ESP_OK) {
-                return ESP_FAIL;
-            }
-        }
-        if (res & Sync::RPC) {
-            if (handle_commands() != ESP_OK) {
-                return ESP_FAIL;
-            }
-        }
-        return ESP_OK;
-    }
-
-    esp_err_t handle_commands()
-    {
-        auto header = rpc.get_header();
-        ESP_LOGI(TAG, "Received header id %d", (int) header.id);
-        switch (header.id) {
-        case api_id::SET_MODE: {
-            auto req = rpc.get_payload<wifi_mode_t>(api_id::SET_MODE, header);
-            auto ret = esp_wifi_set_mode(req);
-            if (rpc.send(api_id::SET_MODE, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::INIT: {
-            auto req = rpc.get_payload<wifi_init_config_t>(api_id::INIT, header);
-            req.osi_funcs = &g_wifi_osi_funcs;
-            req.wpa_crypto_funcs = g_wifi_default_wpa_crypto_funcs;
-            auto ret = esp_wifi_init(&req);
-            if (rpc.send(api_id::INIT, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::SET_CONFIG: {
-            auto req = rpc.get_payload<esp_wifi_remote_config>(api_id::SET_CONFIG, header);
-            auto ret = esp_wifi_set_config(req.interface, &req.conf);
-            if (rpc.send(api_id::SET_CONFIG, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::START: {
-            if (header.size != 0) {
-                return ESP_FAIL;
-            }
-
-            auto ret = esp_wifi_start();
-            if (rpc.send(api_id::START, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::CONNECT: {
-            if (header.size != 0) {
-                return ESP_FAIL;
-            }
-
-            auto ret = esp_wifi_connect();
-            if (rpc.send(api_id::CONNECT, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::DISCONNECT: {
-            if (header.size != 0) {
-                return ESP_FAIL;
-            }
-
-            auto ret = esp_wifi_disconnect();
-            if (rpc.send(api_id::DISCONNECT, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::DEINIT: {
-            if (header.size != 0) {
-                return ESP_FAIL;
-            }
-
-            auto ret = esp_wifi_deinit();
-            if (rpc.send(api_id::DEINIT, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::SET_STORAGE: {
-            auto req = rpc.get_payload<wifi_storage_t>(api_id::SET_STORAGE, header);
-            auto ret = esp_wifi_set_storage(req);
-            if (rpc.send(api_id::SET_STORAGE, &ret) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        case api_id::GET_MAC: {
-            auto req = rpc.get_payload<wifi_interface_t>(api_id::GET_MAC, header);
-            esp_wifi_remote_mac_t resp = {};
-            resp.err = esp_wifi_get_mac(req, resp.mac);
-            if (rpc.send(api_id::GET_MAC, &resp) != ESP_OK) {
-                return ESP_FAIL;
-            }
-            break;
-        }
-        default:
-            return ESP_FAIL;
-        }
-        return ESP_OK;
-    }
-};
-
-
-namespace server {
-constinit RpcInstance instance;
-}
-
-RpcInstance *RpcEngine::init_server()
-{
-    esp_tls_cfg_server_t cfg = {};
-    cfg.cacert_buf = server::ca_crt;
-    cfg.cacert_bytes = sizeof(server::ca_crt);
-    cfg.servercert_buf = server::crt;
-    cfg.servercert_bytes = sizeof(server::crt);
-    cfg.serverkey_buf = server::key;
-    cfg.serverkey_bytes = sizeof(server::key);
-
-    ESP_RETURN_ON_FALSE(tls_ = esp_tls_init(), nullptr, TAG, "Failed to create ESP-TLS instance");
-    ESP_RETURN_ON_FALSE(esp_tls_server_session_create(&cfg, server::instance.sock, tls_) == ESP_OK, nullptr, TAG, "Failed to create TLS session");
-    return &server::instance;
-}
-
-}   // namespace eppp_rpc
-
-using namespace eppp_rpc;
-
-extern "C" esp_err_t server_init(void)
-{
-    return server::instance.init();
-}

components/esp_wifi_remote/esp_wifi_remote.c

@@ -1,34 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include "esp_wifi.h"
-#include "esp_log.h"
-#include "esp_wifi_remote.h"
-
-#define WEAK __attribute__((weak))
-
-WEAK ESP_EVENT_DEFINE_BASE(WIFI_EVENT);
-
-#if !CONFIG_SOC_WIFI_SUPPORTED
-struct wifi_osi_funcs_t { };
-#endif
-
-WEAK wifi_osi_funcs_t g_wifi_osi_funcs;
-WEAK const wpa_crypto_funcs_t g_wifi_default_wpa_crypto_funcs;
-WEAK uint64_t g_wifi_feature_caps =
-#if CONFIG_ESP_WIFI_ENABLE_WPA3_SAE
-    CONFIG_FEATURE_WPA3_SAE_BIT |
-#endif
-#if CONFIG_SPIRAM
-    CONFIG_FEATURE_CACHE_TX_BUF_BIT |
-#endif
-#if CONFIG_ESP_WIFI_FTM_INITIATOR_SUPPORT
-    CONFIG_FEATURE_FTM_INITIATOR_BIT |
-#endif
-#if CONFIG_ESP_WIFI_FTM_RESPONDER_SUPPORT
-    CONFIG_FEATURE_FTM_RESPONDER_BIT |
-#endif
-    0;

components/esp_wifi_remote/esp_wifi_remote_net.c

@@ -1,94 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include <esp_private/wifi.h>
-#include "esp_err.h"
-#include "esp_wifi_remote.h"
-#include "esp_log.h"
-
-#define CHANNELS 2
-#define WEAK __attribute__((weak))
-
-static esp_remote_channel_tx_fn_t s_tx_cb[CHANNELS];
-static esp_remote_channel_t s_channel[CHANNELS];
-static wifi_rxcb_t s_rx_fn[CHANNELS];
-
-WEAK esp_err_t esp_wifi_remote_channel_rx(void *h, void *buffer, void *buff_to_free, size_t len)
-{
-    assert(h);
-    if (h == s_channel[0] && s_rx_fn[0]) {
-        return s_rx_fn[0](buffer, len, buff_to_free);
-    }
-    if (h == s_channel[1] && s_rx_fn[1]) {
-        return s_rx_fn[1](buffer, len, buff_to_free);
-    }
-    return ESP_FAIL;
-}
-
-WEAK esp_err_t esp_wifi_remote_channel_set(wifi_interface_t ifx, void *h, esp_remote_channel_tx_fn_t tx_cb)
-{
-    if (ifx == WIFI_IF_STA) {
-        s_channel[0] = h;
-        s_tx_cb[0] = tx_cb;
-        return ESP_OK;
-    }
-    if (ifx == WIFI_IF_AP) {
-        s_channel[1] = h;
-        s_tx_cb[1] = tx_cb;
-        return ESP_OK;
-    }
-    return ESP_FAIL;
-}
-
-WEAK esp_err_t esp_wifi_internal_set_sta_ip(void)
-{
-    // TODO: Pass this information to the slave target
-    // Note that this function is called from the default event loop, so we shouldn't block here
-    return ESP_OK;
-}
-
-WEAK esp_err_t esp_wifi_internal_reg_netstack_buf_cb(wifi_netstack_buf_ref_cb_t ref, wifi_netstack_buf_free_cb_t free)
-{
-    return ESP_OK;
-}
-
-WEAK void esp_wifi_internal_free_rx_buffer(void *buffer)
-{
-    free(buffer);
-}
-
-WEAK esp_err_t esp_wifi_internal_tx_by_ref(wifi_interface_t ifx, void *buffer, size_t len, void *netstack_buf)
-{
-    return esp_wifi_internal_tx(ifx, buffer, (uint16_t)len);
-}
-
-WEAK int esp_wifi_internal_tx(wifi_interface_t ifx, void *buffer, uint16_t len)
-{
-    if (ifx == WIFI_IF_STA && s_tx_cb[0]) {
-
-        /* TODO: If not needed, remove arg3 */
-        return s_tx_cb[0](s_channel[0], buffer, len);
-    }
-    if (ifx == WIFI_IF_AP && s_tx_cb[1]) {
-        return s_tx_cb[1](s_channel[1], buffer, len);
-    }
-
-    return -1;
-}
-
-WEAK esp_err_t esp_wifi_internal_reg_rxcb(wifi_interface_t ifx, wifi_rxcb_t fn)
-{
-    if (ifx == WIFI_IF_STA) {
-        ESP_LOGI("esp_wifi_remote", "%s: sta: %p", __func__, fn);
-        s_rx_fn[0] = fn;
-        return ESP_OK;
-    }
-    if (ifx == WIFI_IF_AP) {
-        s_rx_fn[1] = fn;
-        return ESP_OK;
-    }
-
-    return ESP_FAIL;
-}

components/esp_wifi_remote/esp_wifi_remote_weak.c

@@ -1,377 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-// This file is auto-generated
-#include "esp_wifi_remote.h"
-#include "esp_log.h"
-
-#define WEAK __attribute__((weak))
-#define LOG_UNSUPPORTED_AND_RETURN(ret) ESP_LOGW("esp_wifi_remote_weak", "%s unsupported", __func__); \
-         return ret;
-
-WEAK esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_deinit(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_mode(wifi_mode_t *mode)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_start(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_stop(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_restore(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_connect(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_disconnect(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_clear_fast_connect(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, _Bool block)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_scan_stop(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_clear_ap_list(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_country(wifi_country_t *country)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_mac(wifi_interface_t ifx, const uint8_t mac[6])
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6])
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_promiscuous(_Bool en)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_promiscuous(_Bool *en)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_promiscuous_filter(wifi_promiscuous_filter_t *filter)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_event_mask(uint32_t mask)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_event_mask(uint32_t *mask)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_csi_config(const wifi_csi_config_t *config)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_csi(_Bool en)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK int64_t esp_wifi_remote_get_tsf_time(wifi_interface_t interface)
-{
-    LOG_UNSUPPORTED_AND_RETURN(-1);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_statis_dump(uint32_t modules)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_rssi_threshold(int32_t rssi)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_ftm_end_session(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_ftm_resp_set_offset(int16_t offset_cm)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_config_11b_rate(wifi_interface_t ifx, _Bool disable)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_connectionless_module_set_wake_interval(uint16_t wake_interval)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_force_wakeup_acquire(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_force_wakeup_release(void)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_country_code(const char *country, _Bool ieee80211d_enabled)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_get_country_code(char *country)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_set_dynamic_cs(_Bool enabled)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}
-
-WEAK esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi)
-{
-    LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED);
-}

components/esp_wifi_remote/esp_wifi_with_remote.c

@@ -1,373 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-// This file is auto-generated
-#include "esp_wifi.h"
-#include "esp_wifi_remote.h"
-
-esp_err_t esp_wifi_init(const wifi_init_config_t *config)
-{
-    return esp_wifi_remote_init(config);
-}
-
-esp_err_t esp_wifi_deinit(void)
-{
-    return esp_wifi_remote_deinit();
-}
-
-esp_err_t esp_wifi_set_mode(wifi_mode_t mode)
-{
-    return esp_wifi_remote_set_mode(mode);
-}
-
-esp_err_t esp_wifi_get_mode(wifi_mode_t *mode)
-{
-    return esp_wifi_remote_get_mode(mode);
-}
-
-esp_err_t esp_wifi_start(void)
-{
-    return esp_wifi_remote_start();
-}
-
-esp_err_t esp_wifi_stop(void)
-{
-    return esp_wifi_remote_stop();
-}
-
-esp_err_t esp_wifi_restore(void)
-{
-    return esp_wifi_remote_restore();
-}
-
-esp_err_t esp_wifi_connect(void)
-{
-    return esp_wifi_remote_connect();
-}
-
-esp_err_t esp_wifi_disconnect(void)
-{
-    return esp_wifi_remote_disconnect();
-}
-
-esp_err_t esp_wifi_clear_fast_connect(void)
-{
-    return esp_wifi_remote_clear_fast_connect();
-}
-
-esp_err_t esp_wifi_deauth_sta(uint16_t aid)
-{
-    return esp_wifi_remote_deauth_sta(aid);
-}
-
-esp_err_t esp_wifi_scan_start(const wifi_scan_config_t *config, _Bool block)
-{
-    return esp_wifi_remote_scan_start(config, block);
-}
-
-esp_err_t esp_wifi_scan_stop(void)
-{
-    return esp_wifi_remote_scan_stop();
-}
-
-esp_err_t esp_wifi_scan_get_ap_num(uint16_t *number)
-{
-    return esp_wifi_remote_scan_get_ap_num(number);
-}
-
-esp_err_t esp_wifi_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records)
-{
-    return esp_wifi_remote_scan_get_ap_records(number, ap_records);
-}
-
-esp_err_t esp_wifi_scan_get_ap_record(wifi_ap_record_t *ap_record)
-{
-    return esp_wifi_remote_scan_get_ap_record(ap_record);
-}
-
-esp_err_t esp_wifi_clear_ap_list(void)
-{
-    return esp_wifi_remote_clear_ap_list();
-}
-
-esp_err_t esp_wifi_sta_get_ap_info(wifi_ap_record_t *ap_info)
-{
-    return esp_wifi_remote_sta_get_ap_info(ap_info);
-}
-
-esp_err_t esp_wifi_set_ps(wifi_ps_type_t type)
-{
-    return esp_wifi_remote_set_ps(type);
-}
-
-esp_err_t esp_wifi_get_ps(wifi_ps_type_t *type)
-{
-    return esp_wifi_remote_get_ps(type);
-}
-
-esp_err_t esp_wifi_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap)
-{
-    return esp_wifi_remote_set_protocol(ifx, protocol_bitmap);
-}
-
-esp_err_t esp_wifi_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap)
-{
-    return esp_wifi_remote_get_protocol(ifx, protocol_bitmap);
-}
-
-esp_err_t esp_wifi_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw)
-{
-    return esp_wifi_remote_set_bandwidth(ifx, bw);
-}
-
-esp_err_t esp_wifi_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw)
-{
-    return esp_wifi_remote_get_bandwidth(ifx, bw);
-}
-
-esp_err_t esp_wifi_set_channel(uint8_t primary, wifi_second_chan_t second)
-{
-    return esp_wifi_remote_set_channel(primary, second);
-}
-
-esp_err_t esp_wifi_get_channel(uint8_t *primary, wifi_second_chan_t *second)
-{
-    return esp_wifi_remote_get_channel(primary, second);
-}
-
-esp_err_t esp_wifi_set_country(const wifi_country_t *country)
-{
-    return esp_wifi_remote_set_country(country);
-}
-
-esp_err_t esp_wifi_get_country(wifi_country_t *country)
-{
-    return esp_wifi_remote_get_country(country);
-}
-
-esp_err_t esp_wifi_set_mac(wifi_interface_t ifx, const uint8_t mac[6])
-{
-    return esp_wifi_remote_set_mac(ifx, mac);
-}
-
-esp_err_t esp_wifi_get_mac(wifi_interface_t ifx, uint8_t mac[6])
-{
-    return esp_wifi_remote_get_mac(ifx, mac);
-}
-
-esp_err_t esp_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb)
-{
-    return esp_wifi_remote_set_promiscuous_rx_cb(cb);
-}
-
-esp_err_t esp_wifi_set_promiscuous(_Bool en)
-{
-    return esp_wifi_remote_set_promiscuous(en);
-}
-
-esp_err_t esp_wifi_get_promiscuous(_Bool *en)
-{
-    return esp_wifi_remote_get_promiscuous(en);
-}
-
-esp_err_t esp_wifi_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter)
-{
-    return esp_wifi_remote_set_promiscuous_filter(filter);
-}
-
-esp_err_t esp_wifi_get_promiscuous_filter(wifi_promiscuous_filter_t *filter)
-{
-    return esp_wifi_remote_get_promiscuous_filter(filter);
-}
-
-esp_err_t esp_wifi_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter)
-{
-    return esp_wifi_remote_set_promiscuous_ctrl_filter(filter);
-}
-
-esp_err_t esp_wifi_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter)
-{
-    return esp_wifi_remote_get_promiscuous_ctrl_filter(filter);
-}
-
-esp_err_t esp_wifi_set_config(wifi_interface_t interface, wifi_config_t *conf)
-{
-    return esp_wifi_remote_set_config(interface, conf);
-}
-
-esp_err_t esp_wifi_get_config(wifi_interface_t interface, wifi_config_t *conf)
-{
-    return esp_wifi_remote_get_config(interface, conf);
-}
-
-esp_err_t esp_wifi_ap_get_sta_list(wifi_sta_list_t *sta)
-{
-    return esp_wifi_remote_ap_get_sta_list(sta);
-}
-
-esp_err_t esp_wifi_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid)
-{
-    return esp_wifi_remote_ap_get_sta_aid(mac, aid);
-}
-
-esp_err_t esp_wifi_set_storage(wifi_storage_t storage)
-{
-    return esp_wifi_remote_set_storage(storage);
-}
-
-esp_err_t esp_wifi_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie)
-{
-    return esp_wifi_remote_set_vendor_ie(enable, type, idx, vnd_ie);
-}
-
-esp_err_t esp_wifi_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx)
-{
-    return esp_wifi_remote_set_vendor_ie_cb(cb, ctx);
-}
-
-esp_err_t esp_wifi_set_max_tx_power(int8_t power)
-{
-    return esp_wifi_remote_set_max_tx_power(power);
-}
-
-esp_err_t esp_wifi_get_max_tx_power(int8_t *power)
-{
-    return esp_wifi_remote_get_max_tx_power(power);
-}
-
-esp_err_t esp_wifi_set_event_mask(uint32_t mask)
-{
-    return esp_wifi_remote_set_event_mask(mask);
-}
-
-esp_err_t esp_wifi_get_event_mask(uint32_t *mask)
-{
-    return esp_wifi_remote_get_event_mask(mask);
-}
-
-esp_err_t esp_wifi_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq)
-{
-    return esp_wifi_remote_80211_tx(ifx, buffer, len, en_sys_seq);
-}
-
-esp_err_t esp_wifi_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx)
-{
-    return esp_wifi_remote_set_csi_rx_cb(cb, ctx);
-}
-
-esp_err_t esp_wifi_set_csi_config(const wifi_csi_config_t *config)
-{
-    return esp_wifi_remote_set_csi_config(config);
-}
-
-esp_err_t esp_wifi_set_csi(_Bool en)
-{
-    return esp_wifi_remote_set_csi(en);
-}
-
-int64_t esp_wifi_get_tsf_time(wifi_interface_t interface)
-{
-    return esp_wifi_remote_get_tsf_time(interface);
-}
-
-esp_err_t esp_wifi_set_inactive_time(wifi_interface_t ifx, uint16_t sec)
-{
-    return esp_wifi_remote_set_inactive_time(ifx, sec);
-}
-
-esp_err_t esp_wifi_get_inactive_time(wifi_interface_t ifx, uint16_t *sec)
-{
-    return esp_wifi_remote_get_inactive_time(ifx, sec);
-}
-
-esp_err_t esp_wifi_statis_dump(uint32_t modules)
-{
-    return esp_wifi_remote_statis_dump(modules);
-}
-
-esp_err_t esp_wifi_set_rssi_threshold(int32_t rssi)
-{
-    return esp_wifi_remote_set_rssi_threshold(rssi);
-}
-
-esp_err_t esp_wifi_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg)
-{
-    return esp_wifi_remote_ftm_initiate_session(cfg);
-}
-
-esp_err_t esp_wifi_ftm_end_session(void)
-{
-    return esp_wifi_remote_ftm_end_session();
-}
-
-esp_err_t esp_wifi_ftm_resp_set_offset(int16_t offset_cm)
-{
-    return esp_wifi_remote_ftm_resp_set_offset(offset_cm);
-}
-
-esp_err_t esp_wifi_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries)
-{
-    return esp_wifi_remote_ftm_get_report(report, num_entries);
-}
-
-esp_err_t esp_wifi_config_11b_rate(wifi_interface_t ifx, _Bool disable)
-{
-    return esp_wifi_remote_config_11b_rate(ifx, disable);
-}
-
-esp_err_t esp_wifi_connectionless_module_set_wake_interval(uint16_t wake_interval)
-{
-    return esp_wifi_remote_connectionless_module_set_wake_interval(wake_interval);
-}
-
-esp_err_t esp_wifi_force_wakeup_acquire(void)
-{
-    return esp_wifi_remote_force_wakeup_acquire();
-}
-
-esp_err_t esp_wifi_force_wakeup_release(void)
-{
-    return esp_wifi_remote_force_wakeup_release();
-}
-
-esp_err_t esp_wifi_set_country_code(const char *country, _Bool ieee80211d_enabled)
-{
-    return esp_wifi_remote_set_country_code(country, ieee80211d_enabled);
-}
-
-esp_err_t esp_wifi_get_country_code(char *country)
-{
-    return esp_wifi_remote_get_country_code(country);
-}
-
-esp_err_t esp_wifi_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate)
-{
-    return esp_wifi_remote_config_80211_tx_rate(ifx, rate);
-}
-
-esp_err_t esp_wifi_disable_pmf_config(wifi_interface_t ifx)
-{
-    return esp_wifi_remote_disable_pmf_config(ifx);
-}
-
-esp_err_t esp_wifi_sta_get_aid(uint16_t *aid)
-{
-    return esp_wifi_remote_sta_get_aid(aid);
-}
-
-esp_err_t esp_wifi_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode)
-{
-    return esp_wifi_remote_sta_get_negotiated_phymode(phymode);
-}
-
-esp_err_t esp_wifi_set_dynamic_cs(_Bool enabled)
-{
-    return esp_wifi_remote_set_dynamic_cs(enabled);
-}
-
-esp_err_t esp_wifi_sta_get_rssi(int *rssi)
-{
-    return esp_wifi_remote_sta_get_rssi(rssi);
-}