Adds esp_mqtt_cxx component

- Component moved from esp-idf - Files moved to adjust to esp-protocol structure
build system: re-add -Wno-format as private flag for some example components
2023-02-16 09:59:46 +01:00 · 2023-02-15 10:26:19 +01:00 · 2023-02-15 10:26:19 +01:00 · 2023-02-15 10:26:19 +01:00 · 2023-02-15 10:26:19 +01:00 · 2023-02-15 10:26:19 +01:00
119 changed files with 3665 additions and 930 deletions
--- a/.github/workflows/gcov_analyzer.yml
+++ b/.github/workflows/gcov_analyzer.yml
@ -0,0 +1,92 @@
+name: Code Coverage Analyzer
+
+on: [push, pull_request]
+
+jobs:
+  gcovr_analyzer_esp_modem:
+    name: Run gcovr on esp modem host test
+    runs-on: ubuntu-22.04
+    container: espressif/idf:release-v4.3
+    env:
+      lwip: lwip-2.1.2
+      lwip_contrib: contrib-2.1.0
+      lwip_uri: http://download.savannah.nongnu.org/releases/lwip
+      COMP_DIR: esp-protocols/components/esp_modem
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          path: esp-protocols
+          persist-credentials: false
+      - name: Build and Test
+        shell: bash
+        run: |
+          apt-get update
+          apt-get update && apt-get install -y gcc-8 g++-8 python3-pip
+          apt-get install -y rsync
+          update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800 --slave /usr/bin/g++ g++ /usr/bin/g++-8
+          export DEBIAN_FRONTEND=noninteractive
+          export LWIP_PATH=`pwd`/${{ env.lwip }}
+          export LWIP_CONTRIB_PATH=`pwd`/${{ env.lwip_contrib }}
+          . ${IDF_PATH}/export.sh
+          ${{ env.COMP_DIR }}/test/host_test/env.sh $lwip $lwip_uri $lwip_contrib
+          cd $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/test/host_test
+          cat sdkconfig.ci.coverage >> sdkconfig.defaults
+          idf.py build
+          ./build/host_modem_test.elf
+      - name: Run gcovr
+        shell: bash
+        run: |
+          python -m pip install gcovr
+          cd $GITHUB_WORKSPACE/${{ env.COMP_DIR }}
+          gcov-8 `find . -name "esp_modem*gcda" -printf '%h\n' | head -n 1`/*
+          gcovr --gcov-ignore-parse-errors -g -k -r . --html index.html  -x esp_modem_coverage.xml
+          mkdir docs_gcovr
+          cp $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/index.html docs_gcovr
+          touch docs_gcovr/.nojekyll
+
+      - name: Code Coverage Summary Report
+        uses: irongut/CodeCoverageSummary@v1.3.0
+        with:
+          filename: esp-protocols/**/esp_modem_coverage.xml
+          badge: true
+          fail_below_min: false
+          format: markdown
+          hide_branch_rate: false
+          hide_complexity: false
+          indicators: true
+          output: both
+          thresholds: '60 80'
+
+      - name: Write to Job Summary
+        run: cat code-coverage-results.md >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: docs_gcovr
+          path: |
+            ${{ env.COMP_DIR }}/docs_gcovr
+          if-no-files-found: error
+
+#  show_report_data:
+#    name: Publish-Results
+#    if: github.ref == 'refs/heads/master' || github.repository != 'espressif/esp-protocols'
+#    runs-on: ubuntu-22.04
+#    needs: gcovr_analyzer_esp_modem
+#    steps:
+#      - name: Checkout 🛎️
+#        uses: actions/checkout@v3
+#        with:
+#          persist-credentials: false
+#      - name: Download Artifacts
+#        uses: actions/download-artifact@v1
+#        with:
+#          name: docs_gcovr
+#
+#      - name: Deploy generated docs
+#        uses: JamesIves/github-pages-deploy-action@v4
+#        with:
+#          branch: gh-pages
+#          folder: 'docs_gcovr'
--- a/.github/workflows/host-test.yml
+++ b/.github/workflows/host-test.yml
@ -3,16 +3,15 @@ name: Host test
 on: [push, pull_request]

 jobs:
-  host_test:
-    name: Build and Test on Host
+  host_test_esp_modem:
+    name: esp-modem Build and Test on Host
    runs-on: ubuntu-20.04
    container: espressif/idf:release-v4.3
    env:
      lwip: lwip-2.1.2
      lwip_contrib: contrib-2.1.0
      lwip_uri: http://download.savannah.nongnu.org/releases/lwip
-
-
+      COMP_DIR: esp-protocols/components/esp_modem
    steps:
      - name: Checkout esp-protocols
        uses: actions/checkout@master
@ -26,11 +25,8 @@ jobs:
          update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800 --slave /usr/bin/g++ g++ /usr/bin/g++-8
          export LWIP_PATH=`pwd`/${{ env.lwip }}
          export LWIP_CONTRIB_PATH=`pwd`/${{ env.lwip_contrib }}
-          wget --no-verbose ${lwip_uri}/${lwip}.zip
-          unzip -oq ${lwip}.zip
-          wget --no-verbose ${lwip_uri}/${lwip_contrib}.zip
-          unzip -oq ${lwip_contrib}.zip
          . ${IDF_PATH}/export.sh
+          $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/test/host_test/env.sh $lwip $lwip_uri $lwip_contrib
          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/examples/linux_modem
          idf.py build
          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/test/host_test
@ -42,3 +38,26 @@ jobs:
        if: always()
        with:
          files: esp-protocols/components/esp_modem/test/host_test/junit.xml
+
+  host_test_mdns:
+    name: mdns Build and Test on Host
+    runs-on: ubuntu-20.04
+    container: espressif/idf:latest
+
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@master
+        with:
+          path: esp-protocols
+
+      - name: Build and Test
+        shell: bash
+        run: |
+          apt-get update && apt-get install -y dnsutils gcc g++
+          . ${IDF_PATH}/export.sh
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/host_test
+          idf.py build
+          ./build/mdns_host.elf &
+          dig +short -p 5353 @224.0.0.251 myesp.local > ip.txt
+          cat ip.txt | xargs dig +short -p 5353 @224.0.0.251 -x
+          cat ip.txt
--- a/.github/workflows/target-test.yml
+++ b/.github/workflows/target-test.yml
@ -6,7 +6,7 @@ jobs:
  build_esp_modem:
    strategy:
      matrix:
-        idf_ver: ["latest", "release-v4.1", "release-v4.2", "release-v4.3", "release-v4.4"]
+        idf_ver: ["latest", "release-v4.1", "release-v4.2", "release-v4.3", "release-v4.4", "release-v5.0"]
        example: ["pppos_client", "modem_console", "ap_to_pppos", "simple_cmux_client"]
        idf_target: ["esp32"]
        exclude:
@ -62,7 +62,7 @@ jobs:
      matrix:
        idf_ver: ["latest"]
        idf_target: ["esp32", "esp32s2", "esp32c3"]
-        config: ["eth_custom_netif", "eth_def", "eth_no_ipv6", "eth_socket"]
+        test: [ { app: example, path: "components/mdns/examples" }, { app: unit_test, path: "components/mdns/tests/unit_test" } ]
    runs-on: ubuntu-20.04
    container: espressif/idf:${{ matrix.idf_ver }}
    steps:
@ -70,40 +70,22 @@ jobs:
        uses: actions/checkout@v3
        with:
          submodules: recursive
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }} for ${{ matrix.config }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
+      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
        shell: bash
-        working-directory: components/mdns/examples/
+        working-directory: ${{ matrix.test.path }}
        run: |
+          ${IDF_PATH}/install.sh --enable-pytest
          . ${IDF_PATH}/export.sh
-          rm -rf sdkconfig sdkconfig.defaults build build_${{ matrix.config }}
-          cat sdkconfig.ci.${{ matrix.config }} >> sdkconfig.defaults
-          idf.py set-target ${{ matrix.idf_target }}
-          idf.py build
-          mv build build_${{ matrix.config }}
-      - name: Merge binaries with IDF-${{ matrix.idf_ver }} for ${{ matrix.config }}
-        working-directory: components/mdns/examples
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          cd build_${{ matrix.config }}
-          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-          cd ../
-          cat build_${{ matrix.config }}/config/sdkconfig.json
-      - uses: actions/upload-artifact@v2
+          python $IDF_PATH/tools/ci/ci_build_apps.py . --target ${{ matrix.idf_target }} -vv --preserve-all --pytest-app
+          for dir in `ls -d build_*`; do
+          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
+          zip -qur artifacts.zip $dir
+          done
+      - uses: actions/upload-artifact@v3
+        if: ${{ matrix.idf_target }} == "esp32"
        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}
-          path: |
-            components/mdns/examples/build_${{ matrix.config }}/bootloader/bootloader.bin
-            components/mdns/examples/build_${{ matrix.config }}/partition_table/partition-table.bin
-            components/mdns/examples/build_${{ matrix.config }}/*.bin
-            components/mdns/examples/build_${{ matrix.config }}/*.elf
-            components/mdns/examples/build_${{ matrix.config }}/flasher_args.json
-            components/mdns/examples/build_${{ matrix.config }}/config/sdkconfig.h
-            components/mdns/examples/build_${{ matrix.config }}/config/sdkconfig.json
+          name: mdns_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ matrix.test.path }}/artifacts.zip
          if-no-files-found: error

  build_asio:
@ -114,13 +96,15 @@ jobs:
        example: ["asio_chat", "async_request", "socks4", "ssl_client_server", "tcp_echo_server", "udp_echo_server"]
    runs-on: ubuntu-20.04
    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/asio/examples
    steps:
      - name: Checkout esp-protocols
        uses: actions/checkout@v3
        with:
          submodules: recursive
      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        working-directory: components/asio/examples/${{ matrix.example }}
+        working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}
        env:
          IDF_TARGET: ${{ matrix.idf_target }}
        shell: bash
@ -130,7 +114,7 @@ jobs:
          idf.py set-target ${{ matrix.idf_target }}
          idf.py build
      - name: Merge binaries with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }} for ${{ matrix.example }}
-        working-directory: components/asio/examples/${{ matrix.example }}/build
+        working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}/build
        env:
          IDF_TARGET: ${{ matrix.idf_target }}
        shell: bash
@ -141,13 +125,13 @@ jobs:
        with:
          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
          path: |
-            components/asio/examples/${{ matrix.example }}/build/bootloader/bootloader.bin
-            components/asio/examples/${{ matrix.example }}/build//partition_table/partition-table.bin
-            components/asio/examples/${{ matrix.example }}/build/*.bin
-            components/asio/examples/${{ matrix.example }}/build/*.elf
-            components/asio/examples/${{ matrix.example }}/build/flasher_args.json
-            components/asio/examples/${{ matrix.example }}/build/config/sdkconfig.h
-            components/asio/examples/${{ matrix.example }}/build/config/sdkconfig.json
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/bootloader/bootloader.bin
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build//partition_table/partition-table.bin
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/*.bin
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/*.elf
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/flasher_args.json
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/config/sdkconfig.h
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/config/sdkconfig.json
          if-no-files-found: error


@ -158,6 +142,8 @@ jobs:
        idf_target: ["esp32"]
    runs-on: ubuntu-20.04
    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/esp_websocket_client/examples
    steps:
      - name: Checkout esp-protocols
        uses: actions/checkout@v3
@ -167,32 +153,53 @@ jobs:
        env:
          IDF_TARGET: ${{ matrix.idf_target }}
        shell: bash
-        working-directory: components/esp_websocket_client/examples/
+        working-directory: ${{ env.TEST_DIR }}
        run: |
          . ${IDF_PATH}/export.sh
          cat sdkconfig.ci >> sdkconfig.defaults
          idf.py build
      - name: Merge binaries
-        working-directory: components/esp_websocket_client/examples/build
+        working-directory: ${{ env.TEST_DIR }}/build
        env:
          IDF_TARGET: ${{ matrix.idf_target }}
        shell: bash
        run: |
          . ${IDF_PATH}/export.sh
          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
        with:
          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
          path: |
-            components/esp_websocket_client/examples/build/bootloader/bootloader.bin
-            components/esp_websocket_client/examples/build/partition_table/partition-table.bin
-            components/esp_websocket_client/examples/build/*.bin
-            components/esp_websocket_client/examples/build/*.elf
-            components/esp_websocket_client/examples/build/flasher_args.json
-            components/esp_websocket_client/examples/build/config/sdkconfig.h
-            components/esp_websocket_client/examples/build/config/sdkconfig.json
+            ${{ env.TEST_DIR }}/build/bootloader/bootloader.bin
+            ${{ env.TEST_DIR }}/build/partition_table/partition-table.bin
+            ${{ env.TEST_DIR }}/build/*.bin
+            ${{ env.TEST_DIR }}/build/*.elf
+            ${{ env.TEST_DIR }}/build/flasher_args.json
+            ${{ env.TEST_DIR }}/build/config/sdkconfig.h
+            ${{ env.TEST_DIR }}/build/config/sdkconfig.json
          if-no-files-found: error

+  build_esp_mqtt_cxx:
+      strategy:
+        matrix:
+          idf_ver: ["latest", "release-v5.0"]
+          idf_target: ["esp32"]
+          test: [ { app: example, path: "components/esp_mqtt_cxx/examples" }]
+      runs-on: ubuntu-20.04
+      container: espressif/idf:${{ matrix.idf_ver }}
+      steps:
+        - name: Checkout esp-protocols
+          uses: actions/checkout@v3
+          with:
+            submodules: recursive
+        - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+          shell: bash
+          working-directory: ${{matrix.test.path}}
+          run: |
+            ${IDF_PATH}/install.sh --enable-pytest
+            . ${IDF_PATH}/export.sh
+            python $IDF_PATH/tools/ci/ci_build_apps.py . --target ${{ matrix.idf_target }} -vv --preserve-all --pytest-app
+
  run-target-websocket:
    name: Run Websocket Example Test on target
    needs: build_websocket
@ -204,14 +211,16 @@ jobs:
    runs-on:
      - self-hosted
      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/esp_websocket_client/examples
    # Skip running on forks since it won't have access to secrets
    if: github.repository == 'espressif/esp-protocols'
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
        with:
          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: components/esp_websocket_client/examples/build/
+          path: ${{ env.TEST_DIR }}/build/
      - name: Install Python packages
        env:
          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
@ -220,22 +229,22 @@ jobs:
      - name: Download Example Test to target
        run: python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/esp_websocket_client/examples/build/flash_image.bin
      - name: Run Example Test on target
-        working-directory: components/esp_websocket_client/examples
+        working-directory: ${{ env.TEST_DIR }}
        run: |
          python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml --target=${{ matrix.idf_target }}
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
        if: always()
        with:
          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: components/esp_websocket_client/examples/*.xml
+          path: ${{ env.TEST_DIR }}/*.xml

  run-target-mdns:
    strategy:
      matrix:
        idf_ver: ["latest"]
        idf_target: ["esp32"]
-        config: ["eth_custom_netif", "eth_def", "eth_no_ipv6", "eth_socket"]
-    name: Run mDNS Example Test on target
+        test: [ { app: example, path: "components/mdns/examples" }, { app: unit_test, path: "components/mdns/tests/unit_test" } ]
+    name: Run mDNS target tests
    needs: build_mdns
    runs-on:
      - self-hosted
@ -246,31 +255,29 @@ jobs:
      - name: Clear repository
        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}
-          path: components/mdns/examples/build_${{ matrix.config }}
+          name: mdns_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ matrix.test.path }}/ci/
      - name: Install Python packages
        env:
          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
        run: |
            sudo apt-get install -y dnsutils
-      - name: Download Example Test to target ${{ matrix.config }}
+      - name: Run ${{ matrix.test.app }} application on ${{ matrix.idf_target }}
+        working-directory: ${{ matrix.test.path }}
        run: |
-            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/mdns/examples/build_${{ matrix.config }}/flash_image.bin
-      - name: Run Example Test on target ${{ matrix.config }}
-        working-directory: components/mdns/examples
-        run: |
-            rm -rf build
-            mv build_${{ matrix.config }} build
-            cat sdkconfig.ci.${{ matrix.config }} >> sdkconfig.defaults
-            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}.xml --target=${{ matrix.idf_target }}
+            unzip ci/artifacts.zip -d ci
+            for dir in `ls -d ci/build_*`; do
            rm -rf build sdkconfig.defaults
-      - uses: actions/upload-artifact@v2
+            mv $dir build
+            python -m pytest --log-cli-level DEBUG --junit-xml=./results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=${{ matrix.idf_target }}
+            done
+      - uses: actions/upload-artifact@v3
        if: always()
        with:
-          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}
-          path: components/mdns/examples/*.xml
+          name: results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml
+          path: ${{ matrix.test.path }}/*.xml

  run-target-asio:
    strategy:
@ -283,16 +290,18 @@ jobs:
    runs-on:
      - self-hosted
      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/asio/examples
    # Skip running on forks since it won't have access to secrets
    if: github.repository == 'espressif/esp-protocols'
    steps:
      - name: Clear repository
        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
        with:
          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
-          path: components/asio/examples/${{ matrix.example }}/build
+          path: ${{ env.TEST_DIR }}/${{ matrix.example }}/build
      - name: Install Python packages
        env:
          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
@ -300,13 +309,75 @@ jobs:
            sudo apt-get install -y dnsutils
      - name: Download Example Test to target ${{ matrix.config }}
        run: |
-            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/asio/examples/${{ matrix.example }}/build/flash_image.bin
+            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 ${{ env.TEST_DIR }}/${{ matrix.example }}/build/flash_image.bin
      - name: Run Example Test ${{ matrix.example }} on target
-        working-directory: components/asio/examples/${{ matrix.example }}
+        working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}
        run: |
            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}.xml --target=${{ matrix.idf_target }}
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
        if: always()
        with:
          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
-          path: components/asio/examples/${{ matrix.example }}/*.xml
+          path: ${{ env.TEST_DIR }}/${{ matrix.example }}/*.xml
+
+  build_esp_modem_tests:
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32c3"]
+        test: [ { app: pppd, path: test/target }, { app: sim800, path: examples/pppos_client } ]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/esp_modem/${{ matrix.test.path }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build esp-modem target tests with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+          SDKCONFIG: sdkconfig.ci.${{ matrix.test.app }}
+        shell: bash
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          . ${IDF_PATH}/export.sh
+          rm -rf sdkconfig build
+          [ -f ${SDKCONFIG} ] && cp ${SDKCONFIG} sdkconfig.defaults
+          idf.py set-target ${{ matrix.idf_target }}
+          idf.py build
+          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh ${GITHUB_WORKSPACE}/${TEST_DIR}/build
+      - uses: actions/upload-artifact@v3
+        with:
+          name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ env.TEST_DIR }}/build
+          if-no-files-found: error
+
+  run_esp_modem_tests:
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32c3"]
+        test: [ { app: pppd, path: test/target }, { app: sim800, path: examples/pppos_client } ]
+    name: Run esp_modem Test on target
+    needs: build_esp_modem_tests
+    runs-on:
+      - self-hosted
+      - BrnoRPI-GH006
+    env:
+      TEST_DIR: components/esp_modem/${{ matrix.test.path }}
+    # Skip running on forks since it won't have access to secrets
+    if: github.repository == 'espressif/esp-protocols'
+    steps:
+      - name: Clear repository
+        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ env.TEST_DIR }}/build
+      - name: Run Example Test on target
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+            python -m pytest --log-cli-level DEBUG --target=${{ matrix.idf_target }}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -12,7 +12,7 @@ repos:
      - id: trailing-whitespace
      - id: mixed-line-ending
      - id: debug-statements
-  - repo: https://gitlab.com/pycqa/flake8
+  - repo: https://github.com/pycqa/flake8
    rev: 5.0.4
    hooks:
      - id: flake8
--- a/ci/clean_build_artifacts.sh
+++ b/ci/clean_build_artifacts.sh
@ -0,0 +1,7 @@
+# Remove everything, but
+# - elf/bin files in the build dir
+# - partition-table and bootloader binaries
+# - flasher args
+# - sdkconfigs (header and json)
+# (Ignoring the command failure as it refuses to delete nonempty dirs)
+find $1 ! -regex ".*/build[^/]*/[^/]+.\(bin\|elf\)" -a ! -regex ".*\(bootloader\|partition-table\).bin" -a ! -name "flasher_args.json" -a ! -regex ".*/build[^/]*/config/sdkconfig.\(h\|json\)" -delete || true
--- a/ci/requirements.txt
+++ b/ci/requirements.txt
@ -5,3 +5,4 @@ SimpleWebSocketServer
 dpkt
 pytest
 idf_build_apps
+netifaces
--- a/components/asio/README.md
+++ b/components/asio/README.md
@ -1,5 +1,7 @@
 # ASIO port

+[![Component Registry](https://components.espressif.com/components/espressif/asio/badge.svg)](https://components.espressif.com/components/espressif/asio)
+
 Asio is a cross-platform C++ library, see https://think-async.com/Asio/. It provides a consistent asynchronous model using a modern C++ approach.

 ## Examples
--- a/components/asio/examples/asio_chat/sdkconfig.defaults
+++ b/components/asio/examples/asio_chat/sdkconfig.defaults
@ -1,2 +1,8 @@
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
+
+#
+# Partition Table
+#
+# Leave some room for larger apps without needing to reduce other features
+CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y
--- a/components/esp_modem/CMakeLists.txt
+++ b/components/esp_modem/CMakeLists.txt
@ -47,3 +47,15 @@ if(${target} STREQUAL "linux")
    # This is needed for ESP_LOGx() macros, as integer formats differ on ESP32(..) and x64
    set_target_properties(${COMPONENT_LIB} PROPERTIES COMPILE_FLAGS -Wno-format)
 endif()
+
+if(CONFIG_GCOV_ENABLED)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+
+
+    MARK_AS_ADVANCED(
+        CMAKE_CXX_FLAGS_COVERAGE
+        CMAKE_C_FLAGS_COVERAGE
+        CMAKE_EXE_LINKER_FLAGS_COVERAGE
+        CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+endif()
--- a/components/esp_modem/README.md
+++ b/components/esp_modem/README.md
@ -1,5 +1,7 @@
 # ESP MODEM

+[![Component Registry](https://components.espressif.com/components/espressif/esp_modem/badge.svg)](https://components.espressif.com/components/espressif/esp_modem)
+
 The `esp-modem` component is a managed component for `esp-idf` that is used for communication with GSM/LTE modems
 that support AT commands and PPP protocol as a network interface.

--- a/components/esp_modem/examples/modem_console/main/modem_console_main.cpp
+++ b/components/esp_modem/examples/modem_console/main/modem_console_main.cpp
@ -210,7 +210,17 @@ 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 == "CMD") {
+            if (mode == "CMUX1") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_MODE;
+            } else if (mode == "CMUX2") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_EXIT;
+            } else if (mode == "CMUX3") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_SWAP;
+            } else if (mode == "CMUX4") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_DATA;
+            } else if (mode == "CMUX5") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_COMMAND;
+            } else if (mode == "CMD") {
                dev_mode = esp_modem::modem_mode::COMMAND_MODE;
            } else if (mode == "PPP") {
                dev_mode = esp_modem::modem_mode::DATA_MODE;
--- a/components/esp_modem/examples/modem_psm/CMakeLists.txt
+++ b/components/esp_modem/examples/modem_psm/CMakeLists.txt
@ -0,0 +1,10 @@
+# For more information about build system see
+# https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
+# 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)
+
+set(EXTRA_COMPONENT_DIRS "../..")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(modem_psm)
--- a/components/esp_modem/examples/modem_psm/README.md
+++ b/components/esp_modem/examples/modem_psm/README.md
@ -0,0 +1,32 @@
+# Modem Power Saving Mode, sleep modes example
+
+
+## Overview
+
+This example demonstrates Power Saving Mode(PSM) in Sim70XX modems along with Deep sleep and Light Sleep modes in esp32.
+This example enables Power saving mode in Sim70XX modem and tries to synchronise the sleep cycle of the modem with esp32.
+When the modem wakes up from PSM sleep it wakes up the esp32. While the modem is awake esp32 goes to light sleep.
+
+This example is tested on a SIM7080 modem.
+
+## Supported devices
+
+This example is supported only on ESP32, ESP32-S2 and ESP32-S3.
+
+## Configuration
+
+* EXAMPLE_MODEM_UART_TX_PIN: Connect this pin to the UART Tx pin of the modem.
+* EXAMPLE_MODEM_UART_RX_PIN: Connect this pin to the UART Rx pin of the modem.
+* EXAMPLE_MODEM_PWRKEY_PIN: Connect this pin to the PWRKEY pin of the modem.
+* EXAMPLE_MODEM_STATUS_PIN: Connect this pin to the Status pin of the modem.
+
+    The status pin might not be exposed on a modem. It needs to tapped out from the LED indicator marked as STS.
+
+* EXAMPLE_MODEM_LIGHT_SLEEP_DURATION: Duration for which the esp32 will go into light sleep, while the modem is awake.
+
+    If the esp32 goes into deep sleep while the modem is awake, esp32 will be awaken by the STATUS pin. So it's recommended to go to light sleep while the modem is awake.
+
+* EXAMPLE_MODEM_T3412_PERIODIC_TAU: T3412 timer is the duration of one awake and sleep cycle of the modem in PSM.
+* EXAMPLE_MODEM_T3324_ACTIVE_TIME: T3324 timer is the duration for which the modem stays PSM.
+
+    The timeout information is coded in bit format for T3412 and T3324 timer.
--- a/components/esp_modem/examples/modem_psm/main/CMakeLists.txt
+++ b/components/esp_modem/examples/modem_psm/main/CMakeLists.txt
@ -0,0 +1,3 @@
+
+idf_component_register(SRCS "modem_psm.c"
+                    INCLUDE_DIRS ".")
--- a/components/esp_modem/examples/modem_psm/main/Kconfig.projbuild
+++ b/components/esp_modem/examples/modem_psm/main/Kconfig.projbuild
@ -0,0 +1,109 @@
+
+menu "Example Configuration"
+
+    choice EXAMPLE_MODEM_DEVICE
+        prompt "Choose supported modem device (DCE)"
+        default EXAMPLE_MODEM_DEVICE_SIM7080
+        help
+            Select modem device connected to the ESP DTE.
+        config EXAMPLE_MODEM_DEVICE_SIM7070
+            bool "SIM7070"
+            help
+                SIM7070 is Multi-Band CAT M and NB IoT module.
+        config EXAMPLE_MODEM_DEVICE_SIM7080
+            bool "SIM7080"
+            help
+                SIM7080 is Multi-Band CAT M and NB IoT module.
+    endchoice
+
+    menu "UART Configuration"
+        config EXAMPLE_MODEM_UART_TX_PIN
+            int "TXD Pin Number"
+            default 4
+            range 0 31
+            help
+                Pin number of UART TX.
+
+        config EXAMPLE_MODEM_UART_RX_PIN
+            int "RXD Pin Number"
+            default 5
+            range 0 31
+            help
+                Pin number of UART RX.
+
+        config EXAMPLE_MODEM_UART_EVENT_TASK_STACK_SIZE
+            int "UART Event Task Stack Size"
+            range 2000 6000
+            default 4096
+            help
+                Stack size of UART event task.
+
+        config EXAMPLE_MODEM_UART_EVENT_TASK_PRIORITY
+            int "UART Event Task Priority"
+            range 3 22
+            default 5
+            help
+                Priority of UART event task.
+
+        config EXAMPLE_MODEM_UART_EVENT_QUEUE_SIZE
+            int "UART Event Queue Size"
+            range 10 40
+            default 30
+            help
+                Length of UART event queue.
+
+        config EXAMPLE_MODEM_UART_TX_BUFFER_SIZE
+            int "UART TX Buffer Size"
+            range 256 2048
+            default 512
+            help
+                Buffer size of UART TX buffer.
+
+        config EXAMPLE_MODEM_UART_RX_BUFFER_SIZE
+            int "UART RX Buffer Size"
+            range 256 2048
+            default 1024
+            help
+                Buffer size of UART RX buffer.
+    endmenu
+
+    config EXAMPLE_MODEM_PWRKEY_PIN
+        int "PWRKEY Pin Number"
+        default 18
+        range 0 31
+        help
+            Pin number connected to modem's power key pin.
+
+    config EXAMPLE_MODEM_STATUS_PIN
+        int "STATUS Pin Number"
+        default 19
+        range 0 31
+        help
+            Pin number connected to modem's status pin.
+
+    config EXAMPLE_MODEM_LIGHT_SLEEP_DURATION
+        int "Light Sleep Duration"
+        default 10
+        range 0 15000
+        help
+            Duration in seconds, of which the esp32 goes into light sleep while the modem is awake.
+
+    config EXAMPLE_MODEM_PPP_APN
+        string "Set MODEM APN"
+        default "internet"
+        help
+            Set APN (Access Point Name), a logical name to choose data network
+
+    config EXAMPLE_MODEM_T3412_PERIODIC_TAU
+        string "T3412 Requester Periodic TAU"
+        default "00000100"
+        help
+            T3412 timer, i.e the duration of one awake and sleep cycle of the modem in PSM.
+
+    config EXAMPLE_MODEM_T3324_ACTIVE_TIME
+        string "T3324 Requester Active Time"
+        default "00000001"
+        help
+            T3324 timer, i.e the duration for which the modem stays PSM.
+
+endmenu
--- a/components/esp_modem/examples/modem_psm/main/modem_psm.c
+++ b/components/esp_modem/examples/modem_psm/main/modem_psm.c
@ -0,0 +1,202 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+/*
+ * Power Saving Mode(PSM) in Sim70XX modems along with
+ * Deep sleep and Light Sleep modes in esp32.
+*/
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "driver/uart.h"
+#include "string.h"
+#include "driver/gpio.h"
+#include "esp_sleep.h"
+#include "driver/rtc_io.h"
+#include "esp_modem_api.h"
+#include "esp_event.h"
+#include "sdkconfig.h"
+
+
+#define BUF_SIZE 1024
+
+#define TXD_PIN             ((gpio_num_t)CONFIG_EXAMPLE_MODEM_UART_TX_PIN)
+#define RXD_PIN             ((gpio_num_t)CONFIG_EXAMPLE_MODEM_UART_RX_PIN)
+#define GPIO_INPUT_STATUS   ((gpio_num_t)CONFIG_EXAMPLE_MODEM_STATUS_PIN)
+#define GPIO_OUTPUT_PWRKEY  ((gpio_num_t)CONFIG_EXAMPLE_MODEM_PWRKEY_PIN)
+#define GPIO_OUTPUT_PIN_SEL (1ULL<<GPIO_OUTPUT_PWRKEY)
+
+#define CHECK_ERR(cmd, success_action)  do {    \
+        esp_err_t ret = cmd;                    \
+        if (ret == ESP_OK) {                    \
+            success_action;                     \
+        } else {                                \
+            ESP_LOGE(TAG, "Failed with %s", ret == ESP_ERR_TIMEOUT ? "TIMEOUT":"ERROR");  \
+        } } while (0)
+
+
+const char *TAG = "modem_psm";
+RTC_DATA_ATTR static int boot_count = 0;
+
+
+void dce_init(esp_modem_dce_t **dce, esp_netif_t **esp_netif)
+{
+    esp_modem_dce_config_t dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG(CONFIG_EXAMPLE_MODEM_PPP_APN);
+    esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+    esp_netif_config_t netif_ppp_config = ESP_NETIF_DEFAULT_PPP();
+    *esp_netif = esp_netif_new(&netif_ppp_config);
+    assert(*esp_netif);
+
+    /* setup UART specific configuration based on kconfig options */
+    dte_config.uart_config.tx_io_num = CONFIG_EXAMPLE_MODEM_UART_TX_PIN;
+    dte_config.uart_config.rx_io_num = CONFIG_EXAMPLE_MODEM_UART_RX_PIN;
+    dte_config.uart_config.rx_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE;
+    dte_config.uart_config.tx_buffer_size = CONFIG_EXAMPLE_MODEM_UART_TX_BUFFER_SIZE;
+    dte_config.uart_config.event_queue_size = CONFIG_EXAMPLE_MODEM_UART_EVENT_QUEUE_SIZE;
+    dte_config.task_stack_size = CONFIG_EXAMPLE_MODEM_UART_EVENT_TASK_STACK_SIZE;
+    dte_config.task_priority = CONFIG_EXAMPLE_MODEM_UART_EVENT_TASK_PRIORITY;
+    dte_config.dte_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE / 2;
+
+    ESP_LOGI(TAG, "Initializing esp_modem for a generic module...");
+    *dce = esp_modem_new(&dte_config, &dce_config, *esp_netif);
+    assert(*dce);
+}
+
+void config_pwrkey_gpio(void)
+{
+    gpio_config_t io_conf = {};                     //zero-initialize the config structure.
+
+    io_conf.intr_type = GPIO_INTR_DISABLE;          //disable interrupt
+    io_conf.mode = GPIO_MODE_OUTPUT;                //set as output mode
+    io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;     //bit mask of the pins that you want to set,e.g.GPIO18/19
+    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;   //disable pull-down mode
+    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;       //disable pull-up mode
+
+    gpio_config(&io_conf);                          //configure GPIO with the given settings
+}
+
+void power_on_modem(esp_modem_dce_t *dce)
+{
+    rtc_gpio_hold_dis(GPIO_OUTPUT_PWRKEY);
+
+    /* Power on the modem */
+    ESP_LOGI(TAG, "Power on the modem");
+    gpio_set_level(GPIO_OUTPUT_PWRKEY, 1);
+    vTaskDelay(pdMS_TO_TICKS(500));
+    gpio_set_level(GPIO_OUTPUT_PWRKEY, 0);
+
+    rtc_gpio_hold_en(GPIO_OUTPUT_PWRKEY);
+    vTaskDelay(pdMS_TO_TICKS(2000));
+
+    CHECK_ERR(esp_modem_sync(dce), ESP_LOGI(TAG, "OK"));
+}
+
+void power_down_modem(esp_modem_dce_t *dce)
+{
+    char data[BUF_SIZE];
+
+    ESP_LOGI(TAG, "Power down the modem");
+
+    /* Power down the modem by AT command */
+    CHECK_ERR(esp_modem_at(dce, "AT+CPOWD=1", data, 500), ESP_LOGI(TAG, "OK. %s", data));
+}
+
+void run_at(esp_modem_dce_t *dce, uint8_t count)
+{
+    for (int i = 0; i < count; i++) {
+        CHECK_ERR(esp_modem_sync(dce), ESP_LOGI(TAG, "OK"));
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
+
+void run_at_ping(esp_modem_dce_t *dce)
+{
+    char data[BUF_SIZE];
+    int rssi, ber;
+    CHECK_ERR(esp_modem_get_signal_quality(dce, &rssi, &ber), ESP_LOGI(TAG, "OK. rssi=%d, ber=%d", rssi, ber));
+    vTaskDelay(pdMS_TO_TICKS(1000));
+
+    CHECK_ERR(esp_modem_at(dce, "AT+CPSMS?", data, 500), ESP_LOGI(TAG, "OK. %s", data));
+    vTaskDelay(pdMS_TO_TICKS(1000));
+
+    CHECK_ERR(esp_modem_at(dce, "AT+CPSI?", data, 500), ESP_LOGI(TAG, "OK. %s", data));             // Inquiring UE system information
+    CHECK_ERR(esp_modem_at(dce, "AT+CNACT=0,1", data, 500), ESP_LOGI(TAG, "OK. %s", data));         // Activate the APP network
+    CHECK_ERR(esp_modem_at(dce, "AT+SNPDPID=0", data, 500), ESP_LOGI(TAG, "OK. %s", data));         // Select PDP index for PING
+    CHECK_ERR(esp_modem_at(dce, "AT+SNPING4=\"8.8.8.8\",3,16,1000", data, 500), ESP_LOGI(TAG, "OK. %s", data));     // Send IPv4 PING
+    CHECK_ERR(esp_modem_at(dce, "AT+CNACT=0,0", data, 500), ESP_LOGI(TAG, "OK. %s", data));         // Deactivate the APP network
+}
+
+
+void app_main(void)
+{
+    char *cmd;
+    char data[BUF_SIZE];
+    esp_modem_dce_t *dce = NULL;
+    esp_netif_t *esp_netif = NULL;
+    esp_sleep_wakeup_cause_t wakeup_cause = esp_sleep_get_wakeup_cause();
+    ESP_LOGI(TAG, "Deep sleep Wake Up Cause: %d\n", wakeup_cause);
+
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    dce_init(&dce, &esp_netif);
+
+    switch (wakeup_cause) {
+    case ESP_SLEEP_WAKEUP_UNDEFINED:
+        /* Power on the modem */
+        config_pwrkey_gpio();
+        power_on_modem(dce);
+
+        run_at(dce, 3);
+
+        /* Configure Power Saving Mode in the modem */
+        asprintf(&cmd, "AT+CPSMS=1,,,\"%s\",\"%s\"\r\n", CONFIG_EXAMPLE_MODEM_T3412_PERIODIC_TAU,
+                 CONFIG_EXAMPLE_MODEM_T3324_ACTIVE_TIME);
+        CHECK_ERR(esp_modem_at(dce, cmd, data, 500), ESP_LOGI(TAG, "OK. %s", data));
+        free(cmd);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+
+        /* Perform Communication tasks */
+        run_at_ping(dce);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        break;
+
+    case ESP_SLEEP_WAKEUP_EXT0:
+        run_at(dce, 3);
+
+        /* Perform Communication tasks */
+        run_at_ping(dce);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        break;
+
+    default:
+        ESP_LOGI(TAG, "Not a deep sleep reset: %d\n", wakeup_cause);
+    }
+
+    ESP_LOGI(TAG, "Light sleep before going to Deep sleep\n\n");
+
+    /* Enter light sleep mode as long as the modem is awake */
+    esp_sleep_enable_timer_wakeup(CONFIG_EXAMPLE_MODEM_LIGHT_SLEEP_DURATION * 1000000);
+    esp_light_sleep_start();
+    esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);    // Disabling timer before going to deep sleep.
+    wakeup_cause = esp_sleep_get_wakeup_cause();
+    ESP_LOGI(TAG, "Light sleep wakeup cause: %d\n", wakeup_cause);
+
+    /* DCE and netif clean-up */
+    /* In Deep-sleep mode, the CPUs, most of the RAM, and all digital peripherals are powered off.
+     * So dce and netif would be lost anyway if they are not explicitly destroyed.
+     * But since dce is also linked with UART communication with the modem it's better to exit gracefully before going to deep sleep.
+     */
+    esp_modem_destroy(dce);
+    esp_netif_destroy(esp_netif);
+
+    /* Enable wakeup if status pin is high */
+    esp_sleep_enable_ext0_wakeup(GPIO_INPUT_STATUS, 1);
+
+    ESP_LOGI(TAG, "Entering deep sleep: %d\n", boot_count++);
+    esp_deep_sleep_start();
+}
--- a/components/esp_modem/examples/modem_psm/sdkconfig.defaults
+++ b/components/esp_modem/examples/modem_psm/sdkconfig.defaults
@ -0,0 +1,4 @@
+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_LWIP_PPP_SUPPORT=y
--- a/components/esp_modem/examples/pppos_client/main/Kconfig.projbuild
+++ b/components/esp_modem/examples/pppos_client/main/Kconfig.projbuild
@ -184,4 +184,22 @@ menu "Example Configuration"

    endmenu

+    config EXAMPLE_MQTT_BROKER_URI
+        string "MQTT Broker URL"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of the 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
--- a/components/esp_modem/examples/pppos_client/main/pppos_client_main.c
+++ b/components/esp_modem/examples/pppos_client/main/pppos_client_main.c
@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
@ -30,7 +30,6 @@
 #define EXAMPLE_FLOW_CONTROL ESP_MODEM_FLOW_CONTROL_HW
 #endif

-#define BROKER_URL "mqtt://mqtt.eclipseprojects.io"

 static const char *TAG = "pppos_example";
 static EventGroupHandle_t event_group = NULL;
@ -68,7 +67,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
-        msg_id = esp_mqtt_client_subscribe(client, "/topic/esp-pppos", 0);
+        msg_id = esp_mqtt_client_subscribe(client, CONFIG_EXAMPLE_MQTT_TEST_TOPIC, 0);
        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_DISCONNECTED:
@ -76,7 +75,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
        break;
    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
-        msg_id = esp_mqtt_client_publish(client, "/topic/esp-pppos", "esp32-pppos", 0, 0, 0);
+        msg_id = esp_mqtt_client_publish(client, CONFIG_EXAMPLE_MQTT_TEST_TOPIC, CONFIG_EXAMPLE_MQTT_TEST_DATA, 0, 0, 0);
        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
@ -271,11 +270,11 @@ void app_main(void)
    /* Config MQTT */
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
    esp_mqtt_client_config_t mqtt_config = {
-        .broker.address.uri = BROKER_URL,
+        .broker.address.uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
    };
 #else
    esp_mqtt_client_config_t mqtt_config = {
-        .uri = BROKER_URL,
+        .uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
    };
 #endif
    esp_mqtt_client_handle_t mqtt_client = esp_mqtt_client_init(&mqtt_config);
--- a/components/esp_modem/examples/pppos_client/pytest_pppos_client.py
+++ b/components/esp_modem/examples/pppos_client/pytest_pppos_client.py
@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+from __future__ import print_function, unicode_literals
+
+
+def test_pppos_connect(dut):
+    """
+    steps:
+      1. initializes connection with SIM800
+      2. checks we get an IP
+      3. checks for the MQTT events
+      4. checks that the client cleanly disconnects
+    """
+    # Check the sequence of connecting, publishing, disconnecting
+    dut.expect('Modem Connect to PPP Server')
+    # Check for MQTT connection and the data event
+    dut.expect('MQTT_EVENT_CONNECTED')
+    dut.expect('MQTT_EVENT_DATA')
+    dut.expect('TOPIC=/ci/esp-modem/pppos-client')
+    dut.expect('DATA=esp32-pppos')
+    # Check that we have disconnected
+    dut.expect('User interrupted event')
+    # And can use commands again
+    dut.expect('IMSI=[0-9]+')
--- a/components/esp_modem/examples/pppos_client/sdkconfig.ci.sim800
+++ b/components/esp_modem/examples/pppos_client/sdkconfig.ci.sim800
@ -0,0 +1,14 @@
+# Override some defaults to enable PPP
+CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_LWIP_PPP_NOTIFY_PHASE_SUPPORT=y
+CONFIG_LWIP_PPP_PAP_SUPPORT=y
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=4096
+CONFIG_LWIP_PPP_ENABLE_IPV6=n
+CONFIG_EXAMPLE_MODEM_UART_TX_PIN=4
+CONFIG_EXAMPLE_MODEM_UART_RX_PIN=5
+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_ESP_SYSTEM_PANIC_PRINT_HALT=y
+CONFIG_ESP32_PANIC_PRINT_HALT=y
--- a/components/esp_modem/examples/simple_cmux_client/CMakeLists.txt
+++ b/components/esp_modem/examples/simple_cmux_client/CMakeLists.txt
@ -2,7 +2,7 @@
 # in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.5)

-set(EXTRA_COMPONENT_DIRS "../.." $ENV{IDF_PATH}/examples/cxx/experimental/experimental_cpp_component)
+set(EXTRA_COMPONENT_DIRS "../..")

 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(simple_cmux_client)
--- a/components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp
+++ b/components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp
@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
@ -17,10 +17,10 @@
 #include "freertos/event_groups.h"
 #include "esp_netif.h"
 #include "esp_log.h"
+#include "esp_event.h"
 #include "cxx_include/esp_modem_dte.hpp"
 #include "esp_modem_config.h"
 #include "cxx_include/esp_modem_api.hpp"
-#include "esp_event_cxx.hpp"
 #include "simple_mqtt_client.hpp"
 #include "esp_vfs_dev.h"        // For optional VFS support
 #include "esp_https_ota.h"      // For potential OTA configuration
@ -39,16 +39,87 @@


 using namespace esp_modem;
-using namespace idf::event;
-

 static const char *TAG = "cmux_example";

+class StatusHandler {
+public:
+    static constexpr auto IP_Event      = SignalGroup::bit0;
+    static constexpr auto MQTT_Connect  = SignalGroup::bit1;
+    static constexpr auto MQTT_Data     = SignalGroup::bit2;
+
+    StatusHandler()
+    {
+        ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_event, this));
+    }
+
+    ~StatusHandler()
+    {
+        esp_event_handler_unregister(IP_EVENT, ESP_EVENT_ANY_ID, on_event);
+    }
+
+    void handle_mqtt(MqttClient *client)
+    {
+        mqtt_client = client;
+        client->register_handler(ESP_EVENT_ANY_ID, on_event, this);
+    }
+
+    esp_err_t wait_for(decltype(IP_Event) event, int milliseconds)
+    {
+        return signal.wait_any(event, milliseconds);
+    }
+
+    ip_event_t get_ip_event_type()
+    {
+        return ip_event_type;
+    }
+
+private:
+    static void on_event(void *arg, esp_event_base_t base, int32_t event, void *data)
+    {
+        auto *handler = static_cast<StatusHandler *>(arg);
+        if (base == IP_EVENT) {
+            handler->ip_event(event, data);
+        } else {
+            handler->mqtt_event(event, data);
+        }
+    }
+
+    void ip_event(int32_t id, void *data)
+    {
+        if (id == IP_EVENT_PPP_GOT_IP) {
+            auto *event = (ip_event_got_ip_t *)data;
+            ESP_LOGI(TAG, "IP          : " IPSTR, IP2STR(&event->ip_info.ip));
+            ESP_LOGI(TAG, "Netmask     : " IPSTR, IP2STR(&event->ip_info.netmask));
+            ESP_LOGI(TAG, "Gateway     : " IPSTR, IP2STR(&event->ip_info.gw));
+            signal.set(IP_Event);
+        } else if (id == IP_EVENT_PPP_LOST_IP) {
+            signal.set(IP_Event);
+        }
+        ip_event_type = static_cast<ip_event_t>(id);
+    }
+
+    void mqtt_event(int32_t event, void *data)
+    {
+        if (mqtt_client && event == mqtt_client->get_event(MqttClient::Event::CONNECT)) {
+            signal.set(MQTT_Connect);
+        } else if (mqtt_client && event == mqtt_client->get_event(MqttClient::Event::DATA)) {
+            ESP_LOGI(TAG, " TOPIC: %s", mqtt_client->get_topic(data).c_str());
+            ESP_LOGI(TAG, " DATA: %s", mqtt_client->get_data(data).c_str());
+            signal.set(MQTT_Data);
+        }
+    }
+
+    esp_modem::SignalGroup signal{};
+    MqttClient *mqtt_client{nullptr};
+    ip_event_t ip_event_type;
+};
+

 extern "C" void app_main(void)
 {
    /* Init and register system/core components */
-    auto loop = std::make_shared<ESPEventLoop>();
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
    ESP_ERROR_CHECK(esp_netif_init());

    /* Configure and create the DTE */
@ -145,45 +216,32 @@ extern "C" void app_main(void)
 #endif

    /* Try to connect to the network and publish an mqtt topic */
-    ESPEventHandlerSync event_handler(loop);
-    event_handler.listen_to(ESPEvent(IP_EVENT, ESPEventID(ESP_EVENT_ANY_ID)));
-    auto result = event_handler.wait_event_for(std::chrono::milliseconds(60000));
-    if (result.timeout) {
+    StatusHandler handler;
+    if (!handler.wait_for(StatusHandler::IP_Event, 60000)) {
        ESP_LOGE(TAG, "Cannot get IP within specified timeout... exiting");
        return;
-    } else if (result.event.id == ESPEventID(IP_EVENT_PPP_GOT_IP)) {
-        auto *event = (ip_event_got_ip_t *)result.ev_data;
-        ESP_LOGI(TAG, "IP          : " IPSTR, IP2STR(&event->ip_info.ip));
-        ESP_LOGI(TAG, "Netmask     : " IPSTR, IP2STR(&event->ip_info.netmask));
-        ESP_LOGI(TAG, "Gateway     : " IPSTR, IP2STR(&event->ip_info.gw));
+    } else if (handler.get_ip_event_type() == IP_EVENT_PPP_GOT_IP) {
        std::cout << "Got IP address" << std::endl;

        /* When connected to network, subscribe and publish some MQTT data */
        MqttClient mqtt(BROKER_URL);
-        event_handler.listen_to(MqttClient::get_event(MqttClient::Event::CONNECT));
-        event_handler.listen_to(MqttClient::get_event(MqttClient::Event::DATA));
-
-        auto reg = loop->register_event(MqttClient::get_event(MqttClient::Event::DATA),
-        [&mqtt](const ESPEvent & event, void *data) {
-            std::cout << " TOPIC:" << mqtt.get_topic(data) << std::endl;
-            std::cout << " DATA:" << mqtt.get_data(data) << std::endl;
-        });
+        handler.handle_mqtt(&mqtt);
        mqtt.connect();
-        while (true) {
-            result = event_handler.wait_event_for(std::chrono::milliseconds(60000));
-            if (result.event == MqttClient::get_event(MqttClient::Event::CONNECT)) {
-                mqtt.subscribe("/topic/esp-modem");
-                mqtt.publish("/topic/esp-modem", "Hello modem");
-                continue;
-            } else if (result.event == MqttClient::get_event(MqttClient::Event::DATA)) {
-                std::cout << "Data received" << std::endl;
-                break; /* Continue with CMUX example after getting data from MQTT */
-            } else {
-                break;
-            }
+        if (!handler.wait_for(StatusHandler::MQTT_Connect, 60000)) {
+            ESP_LOGE(TAG, "Cannot connect to %s within specified timeout... exiting", BROKER_URL);
+            return;
        }
+        std::cout << "Connected" << std::endl;

-    } else if (result.event.id == ESPEventID(IP_EVENT_PPP_LOST_IP)) {
+        mqtt.subscribe("/topic/esp-modem");
+        mqtt.publish("/topic/esp-modem", "Hello modem");
+        if (!handler.wait_for(StatusHandler::MQTT_Data, 60000)) {
+            ESP_LOGE(TAG, "Didn't receive published data within specified timeout... exiting");
+            return;
+        }
+        std::cout << "Received MQTT data" << std::endl;
+
+    } else if (handler.get_ip_event_type() == IP_EVENT_PPP_LOST_IP) {
        ESP_LOGE(TAG, "PPP client has lost connection... exiting");
        return;
    }
--- a/components/esp_modem/examples/simple_cmux_client/main/simple_mqtt_client.cpp
+++ b/components/esp_modem/examples/simple_cmux_client/main/simple_mqtt_client.cpp
@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
@ -10,11 +10,8 @@

 #include <memory>
 #include "mqtt_client.h"
-#include "esp_event_cxx.hpp"
 #include "simple_mqtt_client.hpp"

-using namespace idf::event;
-
 /**
 * Reference to the MQTT event base
 */
@ -33,7 +30,6 @@ struct MqttClientHandle {
        config.uri = uri.c_str();
 #endif
        client = esp_mqtt_client_init(&config);
-        esp_mqtt_client_register_event(client, MQTT_EVENT_ANY, mqtt_event_handler, this);
    }

    ~MqttClientHandle()
@ -41,12 +37,6 @@ struct MqttClientHandle {
        esp_mqtt_client_destroy(client);
    }

-    static void mqtt_event_handler(void *args, esp_event_base_t base, int32_t id, void *data)
-    {
-        // forwards the internal event to the global ESPEvent
-        esp_event_post(base, id, data, sizeof(esp_mqtt_event_t), portMAX_DELAY);
-    }
-
    esp_mqtt_client_handle_t client;
 };

@ -62,16 +52,16 @@ void MqttClient::connect()
    esp_mqtt_client_start(h->client);
 }

-idf::event::ESPEvent MqttClient::get_event(MqttClient::Event ev)
+int32_t MqttClient::get_event(MqttClient::Event ev)
 {
    switch (ev) {
    case Event::CONNECT: {
-        return { MQTT_EVENTS, ESPEventID(MQTT_EVENT_CONNECTED) };
+        return MQTT_EVENT_CONNECTED;
    }
    case Event::DATA:
-        return { MQTT_EVENTS, ESPEventID(MQTT_EVENT_DATA) };
+        return MQTT_EVENT_DATA;
    }
-    return { };
+    return -1;
 }

 int MqttClient::publish(const std::string &topic, const std::string &data, int qos)
@ -102,4 +92,9 @@ std::string MqttClient::get_data(void *event_data)
    return std::string(event->data, event->data_len);
 }

+void MqttClient::register_handler(int32_t event_id, esp_event_handler_t event_handler, void *arg)
+{
+    ESP_ERROR_CHECK(esp_mqtt_client_register_event(h->client, MQTT_EVENT_ANY, event_handler, arg));
+}
+
 MqttClient::~MqttClient() = default;
--- a/components/esp_modem/examples/simple_cmux_client/main/simple_mqtt_client.hpp
+++ b/components/esp_modem/examples/simple_cmux_client/main/simple_mqtt_client.hpp
@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
@ -11,7 +11,6 @@

 #include <string>
 #include <memory>
-#include "esp_event_cxx.hpp"

 struct MqttClientHandle;

@ -62,12 +61,20 @@ public:
     */
    std::string get_data(void *);

+    /**
+     * @brief Register MQTT event
+     * @param id Event id
+     * @param event_handler Event handler
+     * @param event_handler_arg Event handler parameters
+     */
+    void register_handler(int32_t id, esp_event_handler_t event_handler, void *event_handler_arg);
+
    /**
     * @brief Convert internal MQTT event to standard ESPEvent
     * @param ev internal mqtt event
-     * @return corresponding ESPEvent
+     * @return corresponding esp_event id
     */
-    static idf::event::ESPEvent get_event(Event ev);
+    static int32_t get_event(Event ev);

 private:
    std::unique_ptr<MqttClientHandle> h;
--- a/components/esp_modem/idf_component.yml
+++ b/components/esp_modem/idf_component.yml
@ -1,4 +1,4 @@
-version: "0.1.25"
+version: "0.1.26"
 description: esp modem
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_modem
 dependencies:
--- a/components/esp_modem/include/cxx_include/esp_modem_dte.hpp
+++ b/components/esp_modem/include/cxx_include/esp_modem_dte.hpp
@ -116,8 +116,8 @@ private:
    Lock internal_lock{};                                   /*!< Locks DTE operations */
    unique_buffer buffer;                                   /*!< DTE buffer */
    std::shared_ptr<CMux> cmux_term;                        /*!< Primary terminal for this DTE */
-    std::shared_ptr<Terminal> command_term;                 /*!< Reference to the terminal used for sending commands */
-    std::shared_ptr<Terminal> data_term;                    /*!< Secondary terminal for this DTE */
+    std::shared_ptr<Terminal> primary_term;                 /*!< Reference to the primary terminal (mostly for sending commands) */
+    std::shared_ptr<Terminal> secondary_term;               /*!< Secondary terminal for this DTE */
    modem_mode mode;                                        /*!< DTE operation mode */
    SignalGroup signal;                                     /*!< Event group used to signal request-response operations */
    command_result result;                                  /*!< Command result of the currently exectuted command */
--- a/components/esp_modem/include/cxx_include/esp_modem_types.hpp
+++ b/components/esp_modem/include/cxx_include/esp_modem_types.hpp
@ -29,8 +29,13 @@ enum class modem_mode {
    UNDEF,
    COMMAND_MODE, /*!< Command mode -- the modem is supposed to send AT commands in this mode  */
    DATA_MODE,    /*!< Data mode -- the modem communicates with network interface on PPP protocol */
-    CMUX_MODE     /*!< CMUX (Multiplex mode) -- Simplified CMUX mode, which creates two virtual terminals,
+    CMUX_MODE,    /*!< CMUX (Multiplex mode) -- Simplified CMUX mode, which creates two virtual terminals,
                   *  assigning one solely to command interface and the other  to the data mode */
+    CMUX_MANUAL_MODE,    /*!< Enter CMUX mode manually -- just creates two virtual terminals */
+    CMUX_MANUAL_EXIT,    /*!< Exits CMUX mode manually -- just destroys two virtual terminals */
+    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) */
 };

 /**
--- a/components/esp_modem/include/esp_modem_c_api_types.h
+++ b/components/esp_modem/include/esp_modem_c_api_types.h
@ -36,6 +36,11 @@ typedef enum esp_modem_dce_mode {
    ESP_MODEM_MODE_COMMAND,  /**< Default mode after modem startup, used for sending AT commands */
    ESP_MODEM_MODE_DATA,     /**< Used for switching to PPP mode for the modem to connect to a network */
    ESP_MODEM_MODE_CMUX,     /**< Multiplexed terminal mode */
+    ESP_MODEM_MODE_CMUX_MANUAL,         /**< CMUX manual mode */
+    ESP_MODEM_MODE_CMUX_MANUAL_EXIT,    /**< Exit CMUX manual 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_dce_mode_t;

 /**
@ -113,6 +118,8 @@ esp_err_t esp_modem_set_error_cb(esp_modem_dce_t *dce, esp_modem_terminal_error_
 */
 esp_err_t esp_modem_set_mode(esp_modem_dce_t *dce, esp_modem_dce_mode_t mode);

+esp_err_t esp_modem_command(esp_modem_dce_t *dce, const char *command, esp_err_t(*got_line_cb)(uint8_t *data, size_t len), uint32_t timeout_ms);
+
 /**
 * @}
 */
--- a/components/esp_modem/src/esp_modem_c_api.cpp
+++ b/components/esp_modem/src/esp_modem_c_api.cpp
@ -1,393 +1,425 @@
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include <cassert>
-#include "cxx_include/esp_modem_dte.hpp"
-#include "uart_terminal.hpp"
-#include "esp_log.h"
-#include "cxx_include/esp_modem_api.hpp"
-#include "cxx_include/esp_modem_dce_factory.hpp"
-#include "esp_modem_c_api_types.h"
-#include "esp_modem_config.h"
-#include "exception_stub.hpp"
-#include "esp_private/c_api_wrapper.hpp"
-#include "cstring"
-
-#ifndef ESP_MODEM_C_API_STR_MAX
-#define ESP_MODEM_C_API_STR_MAX 64
-#endif
-
-#ifndef HAVE_STRLCPY
-size_t strlcpy(char *dest, const char *src, size_t len);
-#endif
-
-//
-// C API definitions
-using namespace esp_modem;
-
-extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
-{
-    auto dce_wrap = new (std::nothrow) esp_modem_dce_wrap;
-    if (dce_wrap == nullptr) {
-        return nullptr;
-    }
-    auto dte = create_uart_dte(dte_config);
-    if (dte == nullptr) {
-        delete dce_wrap;
-        return nullptr;
-    }
-    dce_wrap->dte = dte;
-    dce_factory::Factory f(convert_modem_enum(module));
-    dce_wrap->dce = f.build(dce_config, std::move(dte), netif);
-    if (dce_wrap->dce == nullptr) {
-        delete dce_wrap;
-        return nullptr;
-    }
-    dce_wrap->modem_type = convert_modem_enum(module);
-    dce_wrap->dte_type = esp_modem_dce_wrap::modem_wrap_dte_type::UART;
-    return dce_wrap;
-}
-
-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);
-}
-
-extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
-{
-    if (dce_wrap) {
-        delete dce_wrap->dce;
-        delete dce_wrap;
-    }
-}
-
-extern "C" esp_err_t esp_modem_set_error_cb(esp_modem_dce_t *dce_wrap, esp_modem_terminal_error_cbt err_cb)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || dce_wrap->dte == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    if (err_cb) {
-        dce_wrap->dte->set_error_cb([err_cb](terminal_error err) {
-            err_cb(convert_terminal_error_enum(err));
-        });
-    } else {
-        dce_wrap->dte->set_error_cb(nullptr);
-    }
-    return ESP_OK;
-}
-
-extern "C" esp_err_t esp_modem_sync(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->sync());
-}
-
-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;
-    }
-    if (mode == ESP_MODEM_MODE_DATA) {
-        return dce_wrap->dce->set_mode(modem_mode::DATA_MODE) ? ESP_OK : ESP_FAIL;
-    }
-    if (mode == ESP_MODEM_MODE_COMMAND) {
-        return dce_wrap->dce->set_mode(modem_mode::COMMAND_MODE) ? ESP_OK : ESP_FAIL;
-    }
-    if (mode == ESP_MODEM_MODE_CMUX) {
-        return dce_wrap->dce->set_mode(modem_mode::CMUX_MODE) ? ESP_OK : ESP_FAIL;
-    }
-    return ESP_ERR_NOT_SUPPORTED;
-}
-
-extern "C" esp_err_t esp_modem_read_pin(esp_modem_dce_t *dce_wrap, bool *pin)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    return command_response_to_esp_err(dce_wrap->dce->read_pin(*pin));
-}
-
-extern "C" esp_err_t esp_modem_sms_txt_mode(esp_modem_dce_t *dce_wrap, bool txt)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    return command_response_to_esp_err(dce_wrap->dce->sms_txt_mode(txt));
-}
-
-extern "C" esp_err_t esp_modem_send_sms(esp_modem_dce_t *dce_wrap, const char *number, const char *message)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string number_str(number);
-    std::string message_str(message);
-    return command_response_to_esp_err(dce_wrap->dce->send_sms(number_str, message_str));
-}
-
-extern "C" esp_err_t esp_modem_sms_character_set(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->sms_character_set());
-}
-
-extern "C" esp_err_t esp_modem_set_pin(esp_modem_dce_t *dce_wrap, const char *pin)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string pin_str(pin);
-    return command_response_to_esp_err(dce_wrap->dce->set_pin(pin_str));
-}
-
-extern "C" esp_err_t esp_modem_at(esp_modem_dce_t *dce_wrap, const char *at, char *p_out, int timeout)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string out;
-    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);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_signal_quality(esp_modem_dce_t *dce_wrap, int *rssi, int *ber)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->get_signal_quality(*rssi, *ber));
-}
-
-extern "C" esp_err_t esp_modem_get_imsi(esp_modem_dce_t *dce_wrap, char *p_imsi)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    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);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_flow_control(esp_modem_dce_t *dce_wrap, int dce_flow, int dte_flow)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_flow_control(dce_flow, dte_flow));
-}
-
-extern "C" esp_err_t esp_modem_store_profile(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->store_profile());
-}
-
-extern "C" esp_err_t esp_modem_get_imei(esp_modem_dce_t *dce_wrap, char *p_imei)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    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);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_operator_name(esp_modem_dce_t *dce_wrap, char *p_name, int *p_act)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_name == nullptr || p_act == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string name;
-    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);
-        *p_act = act;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_module_name(esp_modem_dce_t *dce_wrap, char *p_name)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    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);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_battery_status(esp_modem_dce_t *dce_wrap, int *p_volt, int *p_bcs, int *p_bcl)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_bcs == nullptr || p_bcl == nullptr || p_volt == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int bcs, bcl, volt;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_battery_status(volt, bcs, bcl));
-    if (ret == ESP_OK) {
-        *p_volt = volt;
-        *p_bcs = bcs;
-        *p_bcl = bcl;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_power_down(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->power_down());
-}
-
-extern "C" esp_err_t esp_modem_set_operator(esp_modem_dce_t *dce_wrap, int mode, int format, const char *oper)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string operator_str(oper);
-    return command_response_to_esp_err(dce_wrap->dce->set_operator(mode, format, operator_str));
-}
-
-extern "C" esp_err_t esp_modem_set_network_attachment_state(esp_modem_dce_t *dce_wrap, int state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_network_attachment_state(state));
-}
-
-extern "C" esp_err_t esp_modem_get_network_attachment_state(esp_modem_dce_t *dce_wrap, int *p_state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int state;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_attachment_state(state));
-    if (ret == ESP_OK) {
-        *p_state = state;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_radio_state(esp_modem_dce_t *dce_wrap, int state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_radio_state(state));
-}
-
-extern "C" esp_err_t esp_modem_get_radio_state(esp_modem_dce_t *dce_wrap, int *p_state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int state;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_radio_state(state));
-    if (ret == ESP_OK) {
-        *p_state = state;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_network_mode(esp_modem_dce_t *dce_wrap, int mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_network_mode(mode));
-}
-
-extern "C" esp_err_t esp_modem_set_preferred_mode(esp_modem_dce_t *dce_wrap, int mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_preferred_mode(mode));
-}
-
-extern "C" esp_err_t esp_modem_set_network_bands(esp_modem_dce_t *dce_wrap, const char *mode, const int *bands, int size)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string mode_str(mode);
-    return command_response_to_esp_err(dce_wrap->dce->set_network_bands(mode, bands, size));
-}
-
-extern "C" esp_err_t esp_modem_get_network_system_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int mode;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_system_mode(mode));
-    if (ret == ESP_OK) {
-        *p_mode = mode;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_gnss_power_mode(esp_modem_dce_t *dce_wrap, int mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_gnss_power_mode(mode));
-}
-
-extern "C" esp_err_t esp_modem_get_gnss_power_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int mode;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_gnss_power_mode(mode));
-    if (ret == ESP_OK) {
-        *p_mode = mode;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_reset(esp_modem_dce_t *dce_wrap)
-{
-    return command_response_to_esp_err(dce_wrap->dce->reset());
-}
-
-extern "C" esp_err_t esp_modem_set_pdp_context(esp_modem_dce_t *dce_wrap, esp_modem_PdpContext_t *c_api_pdp)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    esp_modem::PdpContext pdp{c_api_pdp->apn};
-    pdp.context_id = c_api_pdp->context_id;
-    pdp.protocol_type = c_api_pdp->protocol_type;
-    return command_response_to_esp_err(dce_wrap->dce->set_pdp_context(pdp));
-}
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <cassert>
+#include "cxx_include/esp_modem_dte.hpp"
+#include "uart_terminal.hpp"
+#include "esp_log.h"
+#include "cxx_include/esp_modem_api.hpp"
+#include "cxx_include/esp_modem_dce_factory.hpp"
+#include "esp_modem_c_api_types.h"
+#include "esp_modem_config.h"
+#include "exception_stub.hpp"
+#include "esp_private/c_api_wrapper.hpp"
+#include "cstring"
+
+#ifndef ESP_MODEM_C_API_STR_MAX
+#define ESP_MODEM_C_API_STR_MAX 64
+#endif
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *dest, const char *src, size_t len);
+#endif
+
+//
+// C API definitions
+using namespace esp_modem;
+
+extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
+{
+    auto dce_wrap = new (std::nothrow) esp_modem_dce_wrap;
+    if (dce_wrap == nullptr) {
+        return nullptr;
+    }
+    auto dte = create_uart_dte(dte_config);
+    if (dte == nullptr) {
+        delete dce_wrap;
+        return nullptr;
+    }
+    dce_wrap->dte = dte;
+    dce_factory::Factory f(convert_modem_enum(module));
+    dce_wrap->dce = f.build(dce_config, std::move(dte), netif);
+    if (dce_wrap->dce == nullptr) {
+        delete dce_wrap;
+        return nullptr;
+    }
+    dce_wrap->modem_type = convert_modem_enum(module);
+    dce_wrap->dte_type = esp_modem_dce_wrap::modem_wrap_dte_type::UART;
+    return dce_wrap;
+}
+
+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);
+}
+
+extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap) {
+        delete dce_wrap->dce;
+        delete dce_wrap;
+    }
+}
+
+extern "C" esp_err_t esp_modem_set_error_cb(esp_modem_dce_t *dce_wrap, esp_modem_terminal_error_cbt err_cb)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || dce_wrap->dte == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (err_cb) {
+        dce_wrap->dte->set_error_cb([err_cb](terminal_error err) {
+            err_cb(convert_terminal_error_enum(err));
+        });
+    } else {
+        dce_wrap->dte->set_error_cb(nullptr);
+    }
+    return ESP_OK;
+}
+
+extern "C" esp_err_t esp_modem_sync(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->sync());
+}
+
+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_DATA:
+        return dce_wrap->dce->set_mode(modem_mode::DATA_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_COMMAND:
+        return dce_wrap->dce->set_mode(modem_mode::COMMAND_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_EXIT:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_EXIT) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_SWAP:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_SWAP) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_DATA:
+        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;
+    }
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+extern "C" esp_err_t esp_modem_read_pin(esp_modem_dce_t *dce_wrap, bool *pin)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->read_pin(*pin));
+}
+
+extern "C" esp_err_t esp_modem_sms_txt_mode(esp_modem_dce_t *dce_wrap, bool txt)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->sms_txt_mode(txt));
+}
+
+extern "C" esp_err_t esp_modem_send_sms(esp_modem_dce_t *dce_wrap, const char *number, const char *message)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string number_str(number);
+    std::string message_str(message);
+    return command_response_to_esp_err(dce_wrap->dce->send_sms(number_str, message_str));
+}
+
+extern "C" esp_err_t esp_modem_sms_character_set(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->sms_character_set());
+}
+
+extern "C" esp_err_t esp_modem_set_pin(esp_modem_dce_t *dce_wrap, const char *pin)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string pin_str(pin);
+    return command_response_to_esp_err(dce_wrap->dce->set_pin(pin_str));
+}
+
+extern "C" esp_err_t esp_modem_at(esp_modem_dce_t *dce_wrap, const char *at, char *p_out, int timeout)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string out;
+    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);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_signal_quality(esp_modem_dce_t *dce_wrap, int *rssi, int *ber)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->get_signal_quality(*rssi, *ber));
+}
+
+extern "C" esp_err_t esp_modem_get_imsi(esp_modem_dce_t *dce_wrap, char *p_imsi)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    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);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_flow_control(esp_modem_dce_t *dce_wrap, int dce_flow, int dte_flow)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_flow_control(dce_flow, dte_flow));
+}
+
+extern "C" esp_err_t esp_modem_store_profile(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->store_profile());
+}
+
+extern "C" esp_err_t esp_modem_get_imei(esp_modem_dce_t *dce_wrap, char *p_imei)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    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);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_operator_name(esp_modem_dce_t *dce_wrap, char *p_name, int *p_act)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_name == nullptr || p_act == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string name;
+    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);
+        *p_act = act;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_module_name(esp_modem_dce_t *dce_wrap, char *p_name)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    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);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_battery_status(esp_modem_dce_t *dce_wrap, int *p_volt, int *p_bcs, int *p_bcl)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_bcs == nullptr || p_bcl == nullptr || p_volt == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int bcs, bcl, volt;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_battery_status(volt, bcs, bcl));
+    if (ret == ESP_OK) {
+        *p_volt = volt;
+        *p_bcs = bcs;
+        *p_bcl = bcl;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_power_down(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->power_down());
+}
+
+extern "C" esp_err_t esp_modem_set_operator(esp_modem_dce_t *dce_wrap, int mode, int format, const char *oper)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string operator_str(oper);
+    return command_response_to_esp_err(dce_wrap->dce->set_operator(mode, format, operator_str));
+}
+
+extern "C" esp_err_t esp_modem_set_network_attachment_state(esp_modem_dce_t *dce_wrap, int state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_network_attachment_state(state));
+}
+
+extern "C" esp_err_t esp_modem_get_network_attachment_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_attachment_state(state));
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_radio_state(esp_modem_dce_t *dce_wrap, int state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_radio_state(state));
+}
+
+extern "C" esp_err_t esp_modem_get_radio_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_radio_state(state));
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_network_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_network_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_set_preferred_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_preferred_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_set_network_bands(esp_modem_dce_t *dce_wrap, const char *mode, const int *bands, int size)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string mode_str(mode);
+    return command_response_to_esp_err(dce_wrap->dce->set_network_bands(mode, bands, size));
+}
+
+extern "C" esp_err_t esp_modem_get_network_system_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int mode;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_system_mode(mode));
+    if (ret == ESP_OK) {
+        *p_mode = mode;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_gnss_power_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_gnss_power_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_get_gnss_power_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int mode;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_gnss_power_mode(mode));
+    if (ret == ESP_OK) {
+        *p_mode = mode;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_reset(esp_modem_dce_t *dce_wrap)
+{
+    return command_response_to_esp_err(dce_wrap->dce->reset());
+}
+
+extern "C" esp_err_t esp_modem_set_pdp_context(esp_modem_dce_t *dce_wrap, esp_modem_PdpContext_t *c_api_pdp)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    esp_modem::PdpContext pdp{c_api_pdp->apn};
+    pdp.context_id = c_api_pdp->context_id;
+    pdp.protocol_type = c_api_pdp->protocol_type;
+    return command_response_to_esp_err(dce_wrap->dce->set_pdp_context(pdp));
+}
+
+extern "C" esp_err_t esp_modem_command(esp_modem_dce_t *dce_wrap, const char *command, esp_err_t(*got_line_fn)(uint8_t *data, size_t len), uint32_t timeout_ms)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || command == nullptr || got_line_fn == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string cmd(command);
+    return command_response_to_esp_err(dce_wrap->dce->command(cmd, [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;
+        }
+    }, timeout_ms));
+}
+
+extern "C" esp_err_t esp_modem_set_baud(esp_modem_dce_t *dce_wrap, int baud)
+{
+    return command_response_to_esp_err(dce_wrap->dce->set_baud(baud));
+}
--- a/components/esp_modem/src/esp_modem_command_library.cpp
+++ b/components/esp_modem/src/esp_modem_command_library.cpp
@ -218,7 +218,7 @@ command_result get_battery_status_sim7xxx(CommandableIf *t, int &voltage, int &b
 command_result set_flow_control(CommandableIf *t, int dce_flow, int dte_flow)
 {
    ESP_LOGV(TAG, "%s", __func__ );
-    return generic_command_common(t, "AT+IFC=" + std::to_string(dce_flow) + ", " + std::to_string(dte_flow) + "\r");
+    return generic_command_common(t, "AT+IFC=" + std::to_string(dce_flow) + "," + std::to_string(dte_flow) + "\r");
 }

 command_result get_operator_name(CommandableIf *t, std::string &operator_name, int &act)
--- a/components/esp_modem/src/esp_modem_dce.cpp
+++ b/components/esp_modem/src/esp_modem_dce.cpp
@ -14,6 +14,59 @@

 namespace esp_modem {

+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([weak_signal](uint8_t *data, size_t len) -> bool {
+        if (memchr(data, '\n', len))
+        {
+            ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, len, ESP_LOG_DEBUG);
+            const auto pass = std::list<std::string_view>({"NO CARRIER", "DISCONNECTED"});
+            std::string_view response((char *) data, len);
+            for (auto &it : pass)
+                if (response.find(it) != std::string::npos) {
+                    if (auto signal = weak_signal.lock()) {
+                        signal->set(1);
+                    }
+                    return true;
+                }
+        }
+        return false;
+    });
+    netif.wait_until_ppp_exits();
+    if (!signal->wait(1, 2000)) {
+        if (!device.set_mode(modem_mode::COMMAND_MODE)) {
+            return false;
+        }
+    }
+    dte.set_read_cb(nullptr);
+    if (!dte.set_mode(modem_mode::COMMAND_MODE)) {
+        return false;
+    }
+    return true;
+}
+
+static bool enter_data(DTE &dte, ModuleIf &device, Netif &netif)
+{
+    if (!device.setup_data_mode()) {
+        return false;
+    }
+    if (!device.set_mode(modem_mode::DATA_MODE)) {
+        return false;
+    }
+    if (!dte.set_mode(modem_mode::DATA_MODE)) {
+        return false;
+    }
+    netif.start();
+    return true;
+}
+
+} // namespace transitions
+
 /**
 * Set mode while the entire DTE is locked
 */
@ -36,8 +89,8 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
    switch (m) {
    case modem_mode::UNDEF:
        break;
-    case modem_mode::COMMAND_MODE: {
-        if (mode == modem_mode::COMMAND_MODE) {
+    case modem_mode::COMMAND_MODE:
+        if (mode == modem_mode::COMMAND_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
            return false;
        }
        if (mode == modem_mode::CMUX_MODE) {
@ -49,59 +102,23 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
            mode = m;
            return true;
        }
-        netif.stop();
-        auto signal = std::make_shared<SignalGroup>();
-        std::weak_ptr<SignalGroup> weak_signal = signal;
-        dte->set_read_cb([weak_signal](uint8_t *data, size_t len) -> bool {
-            if (memchr(data, '\n', len))
-            {
-                ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, len, ESP_LOG_DEBUG);
-                const auto pass = std::list<std::string_view>({"NO CARRIER", "DISCONNECTED"});
-                std::string_view response((char *) data, len);
-                for (auto &it : pass)
-                    if (response.find(it) != std::string::npos) {
-                        if (auto signal = weak_signal.lock()) {
-                            signal->set(1);
-                        }
-                        return true;
-                    }
-            }
-            return false;
-        });
-        netif.wait_until_ppp_exits();
-        if (!signal->wait(1, 2000)) {
-            if (!device->set_mode(modem_mode::COMMAND_MODE)) {
-                mode = modem_mode::UNDEF;
-                return false;
-            }
-        }
-        dte->set_read_cb(nullptr);
-        if (!dte->set_mode(modem_mode::COMMAND_MODE)) {
+        if (!transitions::exit_data(*dte, *device, netif)) {
            mode = modem_mode::UNDEF;
            return false;
        }
        mode = m;
        return true;
-    }
-    break;
    case modem_mode::DATA_MODE:
-        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE) {
+        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
            return false;
        }
-        if (!device->setup_data_mode()) {
+        if (!transitions::enter_data(*dte, *device, netif)) {
            return false;
        }
-        if (!device->set_mode(modem_mode::DATA_MODE)) {
-            return false;
-        }
-        if (!dte->set_mode(modem_mode::DATA_MODE)) {
-            return false;
-        }
-        netif.start();
        mode = m;
        return true;
    case modem_mode::CMUX_MODE:
-        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE) {
+        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
            return false;
        }
        device->set_mode(modem_mode::CMUX_MODE);    // switch the device into CMUX mode
@ -111,17 +128,46 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
            return false;
        }
        mode = modem_mode::CMUX_MODE;
-        if (!device->setup_data_mode()) {
+        return transitions::enter_data(*dte, *device, netif);
+    case modem_mode::CMUX_MANUAL_MODE:
+        if (mode != modem_mode::COMMAND_MODE && mode != modem_mode::UNDEF) {
            return false;
        }
-        if (!device->set_mode(modem_mode::DATA_MODE)) {
+        device->set_mode(modem_mode::CMUX_MODE);
+        usleep(100'000);
+
+        if (!dte->set_mode(m)) {
            return false;
        }
-        if (!dte->set_mode(modem_mode::DATA_MODE)) {
-            return false;
-        }
-        netif.start();
+        mode = modem_mode::CMUX_MANUAL_MODE;
        return true;
+    case modem_mode::CMUX_MANUAL_EXIT:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        if (!dte->set_mode(m)) {
+            return false;
+        }
+        mode = modem_mode::COMMAND_MODE;
+        return true;
+    case modem_mode::CMUX_MANUAL_SWAP:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        if (!dte->set_mode(m)) {
+            return false;
+        }
+        return true;
+    case modem_mode::CMUX_MANUAL_DATA:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        return transitions::enter_data(*dte, *device, netif);
+    case modem_mode::CMUX_MANUAL_COMMAND:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        return transitions::exit_data(*dte, *device, netif);
    }
    return false;
 }
--- a/components/esp_modem/src/esp_modem_dte.cpp
+++ b/components/esp_modem/src/esp_modem_dte.cpp
@ -16,12 +16,12 @@ static const size_t dte_default_buffer_size = 1000;

 DTE::DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> terminal):
    buffer(config->dte_buffer_size),
-    cmux_term(nullptr), command_term(std::move(terminal)), data_term(command_term),
+    cmux_term(nullptr), primary_term(std::move(terminal)), secondary_term(primary_term),
    mode(modem_mode::UNDEF) {}

 DTE::DTE(std::unique_ptr<Terminal> terminal):
    buffer(dte_default_buffer_size),
-    cmux_term(nullptr), command_term(std::move(terminal)), data_term(command_term),
+    cmux_term(nullptr), primary_term(std::move(terminal)), secondary_term(primary_term),
    mode(modem_mode::UNDEF) {}

 command_result DTE::command(const std::string &command, got_line_cb got_line, uint32_t time_ms, const char separator)
@ -29,10 +29,10 @@ command_result DTE::command(const std::string &command, got_line_cb got_line, ui
    Scoped<Lock> l(internal_lock);
    result = command_result::TIMEOUT;
    signal.clear(GOT_LINE);
-    command_term->set_read_cb([this, got_line, separator](uint8_t *data, size_t len) {
+    primary_term->set_read_cb([this, got_line, separator](uint8_t *data, size_t len) {
        if (!data) {
            data = buffer.get();
-            len = command_term->read(data + buffer.consumed, buffer.size - buffer.consumed);
+            len = primary_term->read(data + buffer.consumed, buffer.size - buffer.consumed);
        } else {
            buffer.consumed = 0; // if the underlying terminal contains data, we cannot fragment
        }
@ -46,13 +46,13 @@ command_result DTE::command(const std::string &command, got_line_cb got_line, ui
        buffer.consumed += len;
        return false;
    });
-    command_term->write((uint8_t *)command.c_str(), command.length());
+    primary_term->write((uint8_t *)command.c_str(), command.length());
    auto got_lf = signal.wait(GOT_LINE, time_ms);
    if (got_lf && result == command_result::TIMEOUT) {
        ESP_MODEM_THROW_IF_ERROR(ESP_ERR_INVALID_STATE);
    }
    buffer.consumed = 0;
-    command_term->set_read_cb(nullptr);
+    primary_term->set_read_cb(nullptr);
    return result;
 }

@ -68,26 +68,26 @@ bool DTE::exit_cmux()
    }
    auto ejected = cmux_term->detach();
    // return the ejected terminal and buffer back to this DTE
-    command_term = std::move(ejected.first);
+    primary_term = std::move(ejected.first);
    buffer = std::move(ejected.second);
-    data_term = command_term;
+    secondary_term = primary_term;
    return true;
 }

 bool DTE::setup_cmux()
 {
-    cmux_term = std::make_shared<CMux>(command_term, std::move(buffer));
+    cmux_term = std::make_shared<CMux>(primary_term, std::move(buffer));
    if (cmux_term == nullptr) {
        return false;
    }
    if (!cmux_term->init()) {
        return false;
    }
-    command_term = std::make_unique<CMuxInstance>(cmux_term, 0);
-    if (command_term == nullptr) {
+    primary_term = std::make_unique<CMuxInstance>(cmux_term, 0);
+    if (primary_term == nullptr) {
        return false;
    }
-    data_term = std::make_unique<CMuxInstance>(cmux_term, 1);
+    secondary_term = std::make_unique<CMuxInstance>(cmux_term, 1);
    return true;
 }

@ -106,14 +106,12 @@ bool DTE::set_mode(modem_mode m)
    }
    // transitions (COMMAND|CMUX|UNDEF) -> DATA
    if (m == modem_mode::DATA_MODE) {
-        if (mode == modem_mode::CMUX_MODE) {
-            // mode stays the same, but need to swap terminals (as command has been switch)
-            data_term.swap(command_term);
+        if (mode == modem_mode::CMUX_MODE || mode == modem_mode::CMUX_MANUAL_MODE) {
+            // mode stays the same, but need to swap terminals (as command has been switched)
+            secondary_term.swap(primary_term);
        } else {
            mode = m;
        }
-        // prepare the data terminal's callback to the configured std::function (used by netif)
-        data_term->set_read_cb(on_data);
        return true;
    }
    // transitions (DATA|CMUX|UNDEF) -> COMMAND
@ -125,21 +123,47 @@ bool DTE::set_mode(modem_mode m)
            }
            mode = modem_mode::UNDEF;
            return false;
+        } if (mode == modem_mode::CMUX_MANUAL_MODE) {
+            return true;
        } else {
            mode = m;
            return true;
        }
    }
-    return true;
+    // manual CMUX transitions: Enter CMUX
+    if (m == modem_mode::CMUX_MANUAL_MODE) {
+        if (setup_cmux()) {
+            mode = m;
+            return true;
+        }
+        mode = modem_mode::UNDEF;
+        return false;
+    }
+    // manual CMUX transitions: Exit CMUX
+    if (m == modem_mode::CMUX_MANUAL_EXIT && mode == modem_mode::CMUX_MANUAL_MODE) {
+        if (exit_cmux()) {
+            mode = modem_mode::COMMAND_MODE;
+            return true;
+        }
+        mode = modem_mode::UNDEF;
+        return false;
+    }
+    // manual CMUX transitions: Swap terminals
+    if (m == modem_mode::CMUX_MANUAL_SWAP && mode == modem_mode::CMUX_MANUAL_MODE) {
+        secondary_term.swap(primary_term);
+        return true;
+    }
+    mode = modem_mode::UNDEF;
+    return false;
 }

 void DTE::set_read_cb(std::function<bool(uint8_t *, size_t)> f)
 {
    on_data = std::move(f);
-    data_term->set_read_cb([this](uint8_t *data, size_t len) {
+    secondary_term->set_read_cb([this](uint8_t *data, size_t len) {
        if (!data) { // if no data available from terminal callback -> need to explicitly read some
            data = buffer.get();
-            len = data_term->read(buffer.get(), buffer.size);
+            len = secondary_term->read(buffer.get(), buffer.size);
        }
        if (on_data) {
            return on_data(data, len);
@ -150,22 +174,22 @@ void DTE::set_read_cb(std::function<bool(uint8_t *, size_t)> f)

 void DTE::set_error_cb(std::function<void(terminal_error err)> f)
 {
-    data_term->set_error_cb(f);
-    command_term->set_error_cb(f);
+    secondary_term->set_error_cb(f);
+    primary_term->set_error_cb(f);
 }

 int DTE::read(uint8_t **d, size_t len)
 {
    auto data_to_read = std::min(len, buffer.size);
    auto data = buffer.get();
-    auto actual_len = data_term->read(data, data_to_read);
+    auto actual_len = secondary_term->read(data, data_to_read);
    *d = data;
    return actual_len;
 }

 int DTE::write(uint8_t *data, size_t len)
 {
-    return data_term->write(data, len);
+    return secondary_term->write(data, len);
 }

 /**
--- a/components/esp_modem/src/esp_modem_netif.cpp
+++ b/components/esp_modem/src/esp_modem_netif.cpp
@ -21,7 +21,7 @@ void Netif::on_ppp_changed(void *arg, esp_event_base_t event_base,
                           int32_t event_id, void *event_data)
 {
    auto *ppp = static_cast<Netif *>(arg);
-    if (event_id < NETIF_PP_PHASE_OFFSET) {
+    if (event_id > NETIF_PPP_ERRORNONE && event_id < NETIF_PP_PHASE_OFFSET) {
        ESP_LOGI("esp_modem_netif", "PPP state changed event %" PRId32, event_id);
        // only notify the modem on state/error events, ignoring phase transitions
        ppp->signal.set(PPP_EXIT);
--- a/components/esp_modem/test/host_test/CMakeLists.txt
+++ b/components/esp_modem/test/host_test/CMakeLists.txt
@ -13,3 +13,15 @@ idf_component_get_property(esp_modem esp_modem COMPONENT_LIB)
 target_compile_definitions(${esp_modem} PRIVATE "-DCONFIG_COMPILER_CXX_EXCEPTIONS")
 target_compile_definitions(${esp_modem} PRIVATE "-DCONFIG_IDF_TARGET_LINUX")
 target_link_options(${esp_modem} INTERFACE -fsanitize=address -fsanitize=undefined)
+
+if(CONFIG_GCOV_ENABLED)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+
+
+    MARK_AS_ADVANCED(
+        CMAKE_CXX_FLAGS_COVERAGE
+        CMAKE_C_FLAGS_COVERAGE
+        CMAKE_EXE_LINKER_FLAGS_COVERAGE
+        CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+endif()
--- a/components/esp_modem/test/host_test/env.sh
+++ b/components/esp_modem/test/host_test/env.sh
@ -0,0 +1,10 @@
+#!/bin/bash
+
+lwip=$1
+lwip_uri=$2
+lwip_contrib=$3
+
+wget --no-verbose ${lwip_uri}/${lwip}.zip
+unzip -oq ${lwip}.zip
+wget --no-verbose ${lwip_uri}/${lwip_contrib}.zip
+unzip -oq ${lwip_contrib}.zip
--- a/components/esp_modem/test/host_test/main/Kconfig
+++ b/components/esp_modem/test/host_test/main/Kconfig
@ -0,0 +1,9 @@
+menu "Host-test config"
+
+    config GCOV_ENABLED
+        bool "Coverage analyzer"
+        default n
+        help
+	        Enables coverage analyzing for host tests.
+
+endmenu
--- a/components/esp_modem/test/host_test/sdkconfig.ci.coverage
+++ b/components/esp_modem/test/host_test/sdkconfig.ci.coverage
@ -0,0 +1 @@
+CONFIG_GCOV_ENABLED=y
--- a/components/esp_modem/test/target/main/CMakeLists.txt
+++ b/components/esp_modem/test/target/main/CMakeLists.txt
@ -8,3 +8,5 @@ set_target_properties(${COMPONENT_LIB} PROPERTIES
    CXX_STANDARD_REQUIRED ON
    CXX_EXTENSIONS ON
 )
+
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
--- a/components/esp_modem/test/target/main/Kconfig.projbuild
+++ b/components/esp_modem/test/target/main/Kconfig.projbuild
@ -1,26 +1,38 @@
-menu "Example Configuration"
+menu "Test App Configuration"

-    config ESP_WIFI_SSID
-        string "WiFi SSID"
-        default "myssid"
+    config TEST_APP_PPP_SERVER_IP
+        string "IP address of PPP server"
+        default "10.0.0.1"
        help
-            SSID (network name) for the example to connect to.
+            IP address of PPP server. Note: this is also the address
+            where the TCP server is started to test the connection

-    config ESP_WIFI_PASSWORD
-        string "WiFi Password"
-        default "mypassword"
+    config TEST_APP_PPP_CLIENT_IP
+        string "IP address of PPP client"
+        default "10.0.0.2"
        help
-            WiFi password (WPA or WPA2) for the example to use.
-    config ESP_WIFI_CHANNEL
-        int "WiFi Channel"
-        range 1 13
-        default 1
-        help
-            WiFi channel (network channel) for the example to use.
+            IP address that PPP server assigns to PPP client.

-    config ESP_MAX_STA_CONN
-        int "Maximal STA connections"
-        default 4
+    config TEST_APP_UART_TX_PIN
+        int "TXD Pin Number"
+        default 6
+        range 0 31
        help
-            Max number of the STA connects to AP.
+            Pin number of UART TX.
+
+    config TEST_APP_UART_RX_PIN
+        int "RXD Pin Number"
+        default 7
+        range 0 31
+        help
+            Pin number of UART RX.
+
+    config TEST_APP_TCP_PORT
+        int "Port of test"
+        range 0 65535
+        default 2222
+        help
+            The remote port to which the client will connects to
+            once the PPP connection established
+
 endmenu
--- a/components/esp_modem/test/target/main/NetworkDCE.cpp
+++ b/components/esp_modem/test/target/main/NetworkDCE.cpp
@ -60,6 +60,8 @@ public:
    {
        // configure
        esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+        dte_config.uart_config.tx_io_num = CONFIG_TEST_APP_UART_TX_PIN;
+        dte_config.uart_config.rx_io_num = CONFIG_TEST_APP_UART_RX_PIN;
        esp_modem_dce_config dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG("");

        // create DTE and minimal network DCE
@ -96,6 +98,7 @@ esp_err_t modem_init_network(esp_netif_t *netif)
 esp_err_t modem_start_network()
 {
    NetModule::start();
+    return ESP_OK;
 }

 void modem_stop_network()
--- a/components/esp_modem/test/target/pytest_pppd.py
+++ b/components/esp_modem/test/target/pytest_pppd.py
@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+from __future__ import print_function, unicode_literals
+
+import subprocess
+import time
+from threading import Event, Thread
+
+import netifaces
+
+
+def run_server(server_stop, port, server_ip, client_ip):
+    print('Starting PPP server on port: {}'.format(port))
+    try:
+        arg_list = [
+            'sudo', 'pppd', port, '115200',
+            '{}:{}'.format(server_ip, client_ip), 'modem', 'local', 'noauth',
+            'debug', 'nocrtscts', 'nodetach', '+ipv6'
+        ]
+        p = subprocess.Popen(arg_list, stdout=subprocess.PIPE, bufsize=1)
+        while not server_stop.is_set():
+            if p.poll() is not None:
+                if p.poll() == 16:
+                    print('[PPPD:] Terminated: hang-up received')
+                    break
+                else:
+                    raise ValueError(
+                        'ENV_TEST_FAILURE: PPP terminated unexpectedly with {}'
+                        .format(p.poll()))
+            line = p.stdout.readline()
+            if line:
+                print('[PPPD:]{}'.format(line.rstrip()))
+            time.sleep(0.1)
+    except Exception as e:
+        print(e)
+        raise ValueError('ENV_TEST_FAILURE: Error running PPP server')
+    finally:
+        p.terminate()
+    print('PPP server stopped')
+
+
+def test_examples_protocol_pppos_connect(dut):
+    """
+    steps:
+      1. starts PPP server
+      2. get DUT as PPP client to connect to the server
+      3. run unit test FW
+    """
+
+    # Look for test case symbolic names
+    try:
+        server_ip = dut.app.sdkconfig.get('TEST_APP_PPP_SERVER_IP')
+        client_ip = dut.app.sdkconfig.get('TEST_APP_PPP_CLIENT_IP')
+    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'
+    # Start the PPP server
+    server_stop = Event()
+    t = Thread(target=run_server,
+               args=(server_stop, port, server_ip, client_ip))
+    t.start()
+    try:
+        ppp_server_timeout = time.time() + 30
+        while 'ppp0' not in netifaces.interfaces():
+            print(
+                "PPP server haven't yet setup its netif, list of active netifs:{}"
+                .format(netifaces.interfaces()))
+            time.sleep(0.5)
+            if time.time() > ppp_server_timeout:
+                raise ValueError(
+                    'ENV_TEST_FAILURE: PPP server failed to setup ppp0 interface within timeout'
+                )
+
+        dut.expect('All tests passed')
+    finally:
+        server_stop.set()
+        t.join()
--- a/components/esp_modem/test/target/sdkconfig.defaults
+++ b/components/esp_modem/test/target/sdkconfig.defaults
@ -1,3 +1,4 @@
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
 CONFIG_CXX_EXCEPTIONS=y
 CONFIG_PPP_SUPPORT=y
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=4096
--- a/components/esp_mqtt_cxx/CMakeLists.txt
+++ b/components/esp_mqtt_cxx/CMakeLists.txt
@ -0,0 +1,8 @@
+idf_build_get_property(target IDF_TARGET)
+
+idf_component_register(SRCS "esp_mqtt_cxx.cpp"
+                    INCLUDE_DIRS "include"
+                    REQUIRES mqtt
+                    )
+
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
--- a/components/esp_mqtt_cxx/docs/Doxyfile
+++ b/components/esp_mqtt_cxx/docs/Doxyfile
@ -0,0 +1,73 @@
+# This is Doxygen configuration file
+#
+# Doxygen provides over 260 configuration statements
+# To make this file easier to follow,
+# it contains only statements that are non-default
+#
+# NOTE:
+# It is recommended not to change defaults unless specifically required
+# Test any changes how they affect generated documentation
+# Make sure that correct warnings are generated to flag issues with documented code
+#
+# For the complete list of configuration statements see:
+# http://doxygen.nl/manual/config.html
+
+
+PROJECT_NAME = "MQTT C++ client"
+
+## The 'INPUT' statement below is used as input by script 'gen-df-input.py'
+## to automatically generate API reference list files heder_file.inc
+## These files are placed in '_inc' directory
+## and used to include in API reference documentation
+
+INPUT = \
+    $(PROJECT_PATH)/include/esp_mqtt.hpp \
+    $(PROJECT_PATH)/include/esp_mqtt_client_config.hpp
+
+## Get warnings for functions that have no documentation for their parameters or return value
+##
+WARN_NO_PARAMDOC = YES
+
+## Enable preprocessing and remove __attribute__(...) expressions from the INPUT files
+##
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = YES
+PREDEFINED             = \
+    $(ENV_DOXYGEN_DEFINES) \
+    __DOXYGEN__=1 \
+    __attribute__(x)= \
+	_Static_assert()= \
+    IDF_DEPRECATED(X)= \
+    IRAM_ATTR= \
+    configSUPPORT_DYNAMIC_ALLOCATION=1 \
+    configSUPPORT_STATIC_ALLOCATION=1 \
+    configQUEUE_REGISTRY_SIZE=1 \
+    configUSE_RECURSIVE_MUTEXES=1 \
+    configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS=1 \
+    configNUM_THREAD_LOCAL_STORAGE_POINTERS=1 \
+    configUSE_APPLICATION_TASK_TAG=1 \
+    configTASKLIST_INCLUDE_COREID=1 \
+    "ESP_EVENT_DECLARE_BASE(x)=extern esp_event_base_t x"
+
+## Do not complain about not having dot
+##
+HAVE_DOT = NO
+
+## Generate XML that is required for Breathe
+##
+GENERATE_XML    = YES
+XML_OUTPUT      = xml
+
+GENERATE_HTML   = NO
+HAVE_DOT        = NO
+GENERATE_LATEX  = NO
+GENERATE_MAN    = YES
+
+## Skip distracting progress messages
+##
+QUIET = YES
+## Enable Section Tags for conditional documentation
+##
+ENABLED_SECTIONS += \
+    DOC_EXCLUDE_HEADER_SECTION   ## To conditionally remove doc sections from IDF source files without affecting documentation in upstream files.
--- a/components/esp_mqtt_cxx/docs/conf_common.py
+++ b/components/esp_mqtt_cxx/docs/conf_common.py
@ -0,0 +1,23 @@
+# flake8: noqa
+from esp_docs.conf_docs import *
+
+extensions += [
+    'sphinx_copybutton',
+    # Needed as a trigger for running doxygen
+    'esp_docs.esp_extensions.dummy_build_system',
+    'esp_docs.esp_extensions.run_doxygen',
+]
+
+# link roles config
+github_repo = 'espressif/esp-protocols'
+
+# context used by sphinx_idf_theme
+html_context['github_user'] = 'espressif'
+html_context['github_repo'] = 'esp-docs'
+
+# Extra options required by sphinx_idf_theme
+project_slug = 'esp-idf'  # >=5.0
+versions_url = 'https://github.com/espressif/esp-protocols/docs/docs_versions.js'
+
+idf_targets = ['esp32']
+languages = ['en']
--- a/components/esp_mqtt_cxx/docs/doxygen-known-warnings.txt
+++ b/components/esp_mqtt_cxx/docs/doxygen-known-warnings.txt
@ -0,0 +1,25 @@
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::BrokerConfiguration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::ClientCredentials is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::Configuration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::Connection is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::Event is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::LastWill is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::Session is not documented.
+esp_mqtt_client_config.hpp:line: warning: Compound idf::mqtt::Task is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member address (variable) of struct idf::mqtt::BrokerConfiguration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member security (variable) of struct idf::mqtt::BrokerConfiguration is not documented.
+esp_mqtt.hpp:line: warning: Member operator()(esp_mqtt_client *client_handler) (function) of struct idf::mqtt::Client::MqttClientDeleter is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member username (variable) of struct idf::mqtt::ClientCredentials is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member authentication (variable) of struct idf::mqtt::ClientCredentials is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member client_id (variable) of struct idf::mqtt::ClientCredentials is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member event (variable) of struct idf::mqtt::Configuration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member task (variable) of struct idf::mqtt::Configuration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member session (variable) of struct idf::mqtt::Configuration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member connection (variable) of struct idf::mqtt::Configuration is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member data (variable) of struct idf::mqtt::DER is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member len (variable) of struct idf::mqtt::DER is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member ds_data (variable) of struct idf::mqtt::DigitalSignatureData is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member data (variable) of struct idf::mqtt::Password is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member data (variable) of struct idf::mqtt::PEM is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member hint_key (variable) of struct idf::mqtt::PSK is not documented.
+esp_mqtt_client_config.hpp:line: warning: Member last_will (variable) of struct idf::mqtt::Session is not documented.
--- a/components/esp_mqtt_cxx/docs/en/conf.py
+++ b/components/esp_mqtt_cxx/docs/en/conf.py
@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+#
+# English Language RTD & Sphinx config file
+#
+# Uses ../conf_common.py for most non-language-specific settings.
+
+# Importing conf_common adds all the non-language-specific
+# parts to this conf module
+
+try:
+    from conf_common import *  # noqa: F403,F401
+except ImportError:
+    import os
+    import sys
+    sys.path.insert(0, os.path.abspath('../'))
+    from conf_common import *  # noqa: F403,F401
+
+# General information about the project.
+project = u'ESP-Protocols'
+copyright = u'2016 - 2023, Espressif Systems (Shanghai) Co., Ltd'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+language = 'en'
--- a/components/esp_mqtt_cxx/docs/en/index.rst
+++ b/components/esp_mqtt_cxx/docs/en/index.rst
@ -0,0 +1,132 @@
+ESP MQTT C++ client
+====================
+
+Overview
+--------
+The ESP MQTT client is a wrapper over the `esp_mqtt` client with the goal of providing a higher level API.
+
+Features
+--------
+   * Supports MQTT version 3.11
+   * Adds a Filter validation class for topic filters
+   * Split the event handlers to member functions
+
+Configuration
+-------------
+
+The current design uses exception as an error handling mechanism, therefore exceptions need to be enabled in menuconfig.
+
+Usage
+-----
+
+User code needs to inherit fromm :cpp:class:`idf::mqtt::Client` and provide overloads for the event handlers.
+
+.. note:: The handler is available to allow user code to interact directly with it in case of need. This member will likely be made private in the future once the class API stabilizes.
+
+
+.. doxygenclass:: idf::mqtt::Client
+    :members:
+    :protected-members:
+
+Event Handling
+--------------
+
+Events are dispatched throug calls to member functions each one dedicated to a type of event.
+
+Application Example
+-------------------
+
+* :example:`tcp <../examples/tcp>`
+* :example:`ssl <../examples/ssl>`
+
+API Reference
+-------------
+
+Header File
+^^^^^^^^^^^
+
+* :project_file:`include/esp_mqtt.hpp`
+
+Structures
+^^^^^^^^^^
+
+.. doxygenstruct:: idf::mqtt::MQTTException
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Message
+    :members:
+
+Classes
+^^^^^^^
+
+
+.. doxygenclass:: idf::mqtt::Filter
+    :members:
+
+Header File
+^^^^^^^^^^^
+
+* :project_file:`include/esp_mqtt_client_config.hpp`
+
+Structures
+^^^^^^^^^^
+
+.. doxygenstruct:: idf::mqtt::Host
+    :members:
+
+.. doxygenstruct:: idf::mqtt::URI
+    :members:
+
+.. doxygenstruct:: idf::mqtt::BrokerAddress
+    :members:
+
+.. doxygenstruct:: idf::mqtt::PEM
+    :members:
+
+.. doxygenstruct:: idf::mqtt::DER
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Insecure
+    :members:
+
+.. doxygenstruct:: idf::mqtt::GlobalCAStore
+    :members:
+
+.. doxygenstruct:: idf::mqtt::PSK
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Password
+    :members:
+
+.. doxygenstruct:: idf::mqtt::ClientCertificate
+    :members:
+
+.. doxygenstruct:: idf::mqtt::SecureElement
+    :members:
+
+.. doxygenstruct:: idf::mqtt::DigitalSignatureData
+    :members:
+
+.. doxygenstruct:: idf::mqtt::BrokerConfiguration
+    :members:
+
+.. doxygenstruct:: idf::mqtt::ClientCredentials
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Event
+    :members:
+
+.. doxygenstruct:: idf::mqtt::LastWill
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Session
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Task
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Connection
+    :members:
+
+.. doxygenstruct:: idf::mqtt::Configuration
+    :members:
--- a/components/esp_mqtt_cxx/docs/generate_docs
+++ b/components/esp_mqtt_cxx/docs/generate_docs
@ -0,0 +1,26 @@
+build-docs --target esp32 --language en
+
+cp -rf _build/en/esp32/html .
+rm -rf _build __pycache__
+
+# Modifes some version and target fields of index.html
+echo "<script type="text/javascript">
+window.onload =(function() {
+    var myAnchor = document.getElementById('version-select');
+    var mySpan = document.createElement('input');
+    mySpan.setAttribute('type', 'text');
+    mySpan.setAttribute('maxLength', '10');
+    mySpan.value = 'latest';
+    mySpan.setAttribute('disabled', true);
+    myAnchor.parentNode.replaceChild(mySpan, myAnchor);
+
+    var myAnchor = document.getElementById('target-select');
+    var mySpan = document.createElement('input');
+    mySpan.setAttribute('type', 'text');
+    mySpan.setAttribute('maxLength', '10');
+    mySpan.value = 'all targets';
+    mySpan.setAttribute('disabled', true);
+    myAnchor.parentNode.replaceChild(mySpan, myAnchor);
+
+})();
+</script>" >> html/index.html
--- a/components/esp_mqtt_cxx/esp_mqtt_cxx.cpp
+++ b/components/esp_mqtt_cxx/esp_mqtt_cxx.cpp
@ -0,0 +1,292 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string>
+#include <algorithm>
+#include <stdexcept>
+
+#include "mqtt_client.h"
+#include "esp_log.h"
+
+#include "esp_mqtt.hpp"
+#include "esp_mqtt_client_config.hpp"
+
+namespace {
+
+// Helper for static assert.
+template<class T>
+constexpr bool always_false = false;
+
+template<class... Ts> struct overloaded : Ts... {
+    using Ts::operator()...;
+};
+template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+using namespace idf::mqtt;
+
+/*
+ *  This function is responsible for fill in the configurations for the broker related data
+ *  of mqtt_client_config_t
+ */
+void config_broker(esp_mqtt_client_config_t &mqtt_client_cfg, BrokerConfiguration const &broker)
+{
+    std::visit(overloaded{
+        [&mqtt_client_cfg](Host const & host)
+        {
+            mqtt_client_cfg.broker.address.hostname = host.address.c_str();
+            mqtt_client_cfg.broker.address.path = host.path.c_str();
+            mqtt_client_cfg.broker.address.transport = host.transport;
+        },
+        [&mqtt_client_cfg](URI const & uri)
+        {
+            mqtt_client_cfg.broker.address.uri = uri.address.c_str();
+        },
+        []([[maybe_unused ]]auto & unknown)
+        {
+            static_assert(always_false<decltype(unknown)>, "Missing type handler for variant handler");
+        }
+    },
+    broker.address.address);
+
+    std::visit(overloaded{
+        []([[maybe_unused]]Insecure const & insecure) {},
+        [&mqtt_client_cfg](GlobalCAStore const & use_global_store)
+        {
+            mqtt_client_cfg.broker.verification.use_global_ca_store = true;
+        },
+        [&mqtt_client_cfg](CryptographicInformation const & certificates)
+        {
+            std::visit(overloaded{
+                [&mqtt_client_cfg](PEM const & pem)
+                {
+                    mqtt_client_cfg.broker.verification.certificate = pem.data;
+                }, [&mqtt_client_cfg](DER const & der)
+                {
+                    mqtt_client_cfg.broker.verification.certificate = der.data;
+                    mqtt_client_cfg.broker.verification.certificate_len = der.len;
+                }}, certificates);
+        },
+        []([[maybe_unused]] PSK const & psk) {},
+        []([[maybe_unused]] auto & unknown)
+        {
+            static_assert(always_false<decltype(unknown)>, "Missing type handler for variant handler");
+        }
+    },
+    broker.security);
+    mqtt_client_cfg.broker.address.port = broker.address.port;
+}
+
+/*
+ *  This function is responsible for fill in the configurations for the client credentials related data
+ *  of mqtt_client_config_t
+ */
+void config_client_credentials(esp_mqtt_client_config_t &mqtt_client_cfg, ClientCredentials const &credentials)
+{
+    mqtt_client_cfg.credentials.client_id = credentials.client_id.has_value() ?  credentials.client_id.value().c_str() : nullptr ;
+    mqtt_client_cfg.credentials.username = credentials.username.has_value() ?  credentials.username.value().c_str() : nullptr ;
+    std::visit(overloaded{
+        [&mqtt_client_cfg](Password const & password)
+        {
+            mqtt_client_cfg.credentials.authentication.password = password.data.c_str();
+        },
+        [](ClientCertificate const & certificate) {},
+        [](SecureElement const & enable_secure_element) {},
+        []([[maybe_unused ]]auto & unknown)
+        {
+            static_assert(always_false<decltype(unknown)>, "Missing type handler for variant handler");
+        }
+    }, credentials.authentication);
+}
+
+esp_mqtt_client_config_t make_config(BrokerConfiguration const &broker, ClientCredentials const  &credentials, Configuration const &config)
+{
+    esp_mqtt_client_config_t mqtt_client_cfg{};
+    config_broker(mqtt_client_cfg, broker);
+    config_client_credentials(mqtt_client_cfg, credentials);
+    return mqtt_client_cfg;
+}
+}
+
+namespace idf::mqtt {
+
+Client::Client(BrokerConfiguration const &broker, ClientCredentials const  &credentials, Configuration const &config): Client(make_config(broker, credentials, config))  {}
+
+Client::Client(esp_mqtt_client_config_t const &config) :  handler(esp_mqtt_client_init(&config))
+{
+    if (handler == nullptr) {
+        throw MQTTException(ESP_FAIL);
+    };
+    CHECK_THROW_SPECIFIC(esp_mqtt_client_register_event(handler.get(), MQTT_EVENT_ANY, mqtt_event_handler, this), mqtt::MQTTException);
+    CHECK_THROW_SPECIFIC(esp_mqtt_client_start(handler.get()), mqtt::MQTTException);
+}
+
+
+void Client::mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) noexcept
+{
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
+    auto *event = static_cast<esp_mqtt_event_t *>(event_data);
+    auto &client = *static_cast<Client *>(handler_args);
+    switch (event->event_id) {
+    case MQTT_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+        client.on_connected(event);
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+        client.on_disconnected(event);
+        break;
+
+    case MQTT_EVENT_SUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
+        client.on_subscribed(event);
+        break;
+    case MQTT_EVENT_UNSUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
+        client.on_unsubscribed(event);
+        break;
+    case MQTT_EVENT_PUBLISHED:
+        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
+        client.on_published(event);
+        break;
+    case MQTT_EVENT_DATA:
+        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
+        client.on_data(event);
+        break;
+    case MQTT_EVENT_ERROR:
+        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+        client.on_error(event);
+        break;
+    case MQTT_EVENT_BEFORE_CONNECT:
+        ESP_LOGI(TAG, "MQTT_EVENT_BEFORE_CONNECT");
+        client.on_before_connect(event);
+        break;
+    default:
+        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
+        break;
+    }
+}
+
+void Client::on_error(esp_mqtt_event_handle_t const event)
+{
+    auto 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);
+        }
+    };
+    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));
+    }
+}
+void Client::on_disconnected(esp_mqtt_event_handle_t const event)
+{
+}
+void Client::on_subscribed(esp_mqtt_event_handle_t const event)
+{
+    printf("Subscribed to %.*s\r\n", event->topic_len, event->topic);
+}
+void Client::on_unsubscribed(esp_mqtt_event_handle_t const event)
+{
+}
+void Client::on_published(esp_mqtt_event_handle_t const event)
+{
+}
+void Client::on_before_connect(esp_mqtt_event_handle_t const event)
+{
+}
+void Client::on_connected(esp_mqtt_event_handle_t const event)
+{
+}
+void Client::on_data(esp_mqtt_event_handle_t const event)
+{
+}
+
+std::optional<MessageID> Client::subscribe(std::string const &topic, QoS qos)
+{
+    auto res = esp_mqtt_client_subscribe(handler.get(), topic.c_str(),
+                                         static_cast<int>(qos));
+    if (res < 0) {
+        return std::nullopt;
+    }
+    return MessageID{res};
+}
+
+bool is_valid(std::string::const_iterator first, std::string::const_iterator last)
+{
+    if (first == last) {
+        return false;
+    }
+    auto number = std::find(first, last, '#');
+    if (number != last) {
+        if (std::next(number) != last) {
+            return false;
+        }
+        if (*std::prev(number) != '/' && number != first) {
+            return false;
+        }
+    }
+
+    auto plus = std::find(first, last, '+');
+    if (plus != last) {
+        if (*(std::prev(plus)) != '/' && plus != first) {
+            return false;
+        }
+        if (std::next(plus) != last && *(std::next(plus)) != '/') {
+            return false;
+        }
+    }
+    return true;
+}
+
+Filter::Filter(std::string user_filter) : filter(std::move(user_filter))
+{
+    if (!is_valid(filter.begin(), filter.end())) {
+        throw std::domain_error("Forbidden Filter string");
+    }
+}
+
+[[nodiscard]] bool Filter::match(std::string::const_iterator topic_begin, std::string::const_iterator topic_end) const noexcept
+{
+    auto filter_begin = filter.begin();
+    auto filter_end = filter.end();
+    for (auto mismatch = std::mismatch(filter_begin, filter_end, topic_begin);
+            mismatch.first != filter.end() and mismatch.second != topic_end;
+            mismatch = std::mismatch(filter_begin, filter_end, topic_begin)) {
+        if (*mismatch.first != '#' and * mismatch.first != '+') {
+            return false;
+        }
+        if (*mismatch.first == '#') {
+            return true;
+        }
+        if (*mismatch.first == '+') {
+            filter_begin = advance(mismatch.first, filter_end);
+            topic_begin = advance(mismatch.second, topic_end);
+            if (filter_begin == filter_end and topic_begin != topic_end) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+const std::string &Filter::get()
+{
+    return filter;
+}
+
+[[nodiscard]] bool Filter::match(char *const begin, int size) const noexcept
+{
+    auto it = static_cast<std::string::const_iterator>(begin);
+    return match(it, it + size);
+}
+std::string::const_iterator Filter::advance(std::string::const_iterator begin, std::string::const_iterator end) const
+{
+    constexpr auto separator = '/';
+    return std::find(begin, end, separator);
+}
+
+}
--- a/components/esp_mqtt_cxx/examples/ssl/CMakeLists.txt
+++ b/components/esp_mqtt_cxx/examples/ssl/CMakeLists.txt
@ -0,0 +1,14 @@
+# The following four lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+# (Not part of the boilerplate) This example uses an extra component for common
+# functions such as Wi-Fi and Ethernet connection.
+# The path to esp_mqtt_cxx is also added.
+set(EXTRA_COMPONENT_DIRS
+    "../../../../common_components/protocol_examples_common" "../../")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(mqtt_ssl_cxx)
+
+target_add_binary_data(mqtt_ssl_cxx.elf "main/mqtt_eclipseprojects_io.pem" TEXT)
--- a/components/esp_mqtt_cxx/examples/ssl/README.md
+++ b/components/esp_mqtt_cxx/examples/ssl/README.md
@ -0,0 +1,2 @@
+| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-S2 | ESP32-S3 |
+| ----------------- | ----- | -------- | -------- | -------- | -------- |
--- a/components/esp_mqtt_cxx/examples/ssl/main/CMakeLists.txt
+++ b/components/esp_mqtt_cxx/examples/ssl/main/CMakeLists.txt
@ -0,0 +1,3 @@
+idf_component_register(SRCS "mqtt_ssl_example.cpp"
+                    INCLUDE_DIRS ".")
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
--- a/components/esp_mqtt_cxx/examples/ssl/main/Kconfig.projbuild
+++ b/components/esp_mqtt_cxx/examples/ssl/main/Kconfig.projbuild
@ -0,0 +1,9 @@
+menu "Example Configuration"
+
+    config BROKER_URI
+        string "Broker URL"
+        default "mqtts://mqtt.eclipseprojects.io:8883"
+        help
+            URL of the broker to connect to
+
+endmenu
--- a/components/esp_mqtt_cxx/examples/ssl/main/mqtt_eclipse_org.pem
+++ b/components/esp_mqtt_cxx/examples/ssl/main/mqtt_eclipse_org.pem
@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEkjCCA3qgAwIBAgIQCgFBQgAAAVOFc2oLheynCDANBgkqhkiG9w0BAQsFADA/
+MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT
+DkRTVCBSb290IENBIFgzMB4XDTE2MDMxNzE2NDA0NloXDTIxMDMxNzE2NDA0Nlow
+SjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUxldCdzIEVuY3J5cHQxIzAhBgNVBAMT
+GkxldCdzIEVuY3J5cHQgQXV0aG9yaXR5IFgzMIIBIjANBgkqhkiG9w0BAQEFAAOC
+AQ8AMIIBCgKCAQEAnNMM8FrlLke3cl03g7NoYzDq1zUmGSXhvb418XCSL7e4S0EF
+q6meNQhY7LEqxGiHC6PjdeTm86dicbp5gWAf15Gan/PQeGdxyGkOlZHP/uaZ6WA8
+SMx+yk13EiSdRxta67nsHjcAHJyse6cF6s5K671B5TaYucv9bTyWaN8jKkKQDIZ0
+Z8h/pZq4UmEUEz9l6YKHy9v6Dlb2honzhT+Xhq+w3Brvaw2VFn3EK6BlspkENnWA
+a6xK8xuQSXgvopZPKiAlKQTGdMDQMc2PMTiVFrqoM7hD8bEfwzB/onkxEz0tNvjj
+/PIzark5McWvxI0NHWQWM6r6hCm21AvA2H3DkwIDAQABo4IBfTCCAXkwEgYDVR0T
+AQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAYYwfwYIKwYBBQUHAQEEczBxMDIG
+CCsGAQUFBzABhiZodHRwOi8vaXNyZy50cnVzdGlkLm9jc3AuaWRlbnRydXN0LmNv
+bTA7BggrBgEFBQcwAoYvaHR0cDovL2FwcHMuaWRlbnRydXN0LmNvbS9yb290cy9k
+c3Ryb290Y2F4My5wN2MwHwYDVR0jBBgwFoAUxKexpHsscfrb4UuQdf/EFWCFiRAw
+VAYDVR0gBE0wSzAIBgZngQwBAgEwPwYLKwYBBAGC3xMBAQEwMDAuBggrBgEFBQcC
+ARYiaHR0cDovL2Nwcy5yb290LXgxLmxldHNlbmNyeXB0Lm9yZzA8BgNVHR8ENTAz
+MDGgL6AthitodHRwOi8vY3JsLmlkZW50cnVzdC5jb20vRFNUUk9PVENBWDNDUkwu
+Y3JsMB0GA1UdDgQWBBSoSmpjBH3duubRObemRWXv86jsoTANBgkqhkiG9w0BAQsF
+AAOCAQEA3TPXEfNjWDjdGBX7CVW+dla5cEilaUcne8IkCJLxWh9KEik3JHRRHGJo
+uM2VcGfl96S8TihRzZvoroed6ti6WqEBmtzw3Wodatg+VyOeph4EYpr/1wXKtx8/
+wApIvJSwtmVi4MFU5aMqrSDE6ea73Mj2tcMyo5jMd6jmeWUHK8so/joWUoHOUgwu
+X4Po1QYz+3dszkDqMp4fklxBwXRsW10KXzPMTZ+sOPAveyxindmjkW8lGy+QsRlG
+PfZ+G6Z6h7mjem0Y+iWlkYcV4PIWL1iwBi8saCbGS5jN2p8M+X+Q7UNKEkROb3N6
+KOqkqm57TH2H3eDJAkSnh6/DNFu0Qg==
+-----END CERTIFICATE-----
--- a/components/esp_mqtt_cxx/examples/ssl/main/mqtt_eclipseprojects_io.pem
+++ b/components/esp_mqtt_cxx/examples/ssl/main/mqtt_eclipseprojects_io.pem
@ -0,0 +1,30 @@
+-----BEGIN CERTIFICATE-----
+MIIFFjCCAv6gAwIBAgIRAJErCErPDBinU/bWLiWnX1owDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjAwOTA0MDAwMDAw
+WhcNMjUwOTE1MTYwMDAwWjAyMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNTGV0J3Mg
+RW5jcnlwdDELMAkGA1UEAxMCUjMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQC7AhUozPaglNMPEuyNVZLD+ILxmaZ6QoinXSaqtSu5xUyxr45r+XXIo9cP
+R5QUVTVXjJ6oojkZ9YI8QqlObvU7wy7bjcCwXPNZOOftz2nwWgsbvsCUJCWH+jdx
+sxPnHKzhm+/b5DtFUkWWqcFTzjTIUu61ru2P3mBw4qVUq7ZtDpelQDRrK9O8Zutm
+NHz6a4uPVymZ+DAXXbpyb/uBxa3Shlg9F8fnCbvxK/eG3MHacV3URuPMrSXBiLxg
+Z3Vms/EY96Jc5lP/Ooi2R6X/ExjqmAl3P51T+c8B5fWmcBcUr2Ok/5mzk53cU6cG
+/kiFHaFpriV1uxPMUgP17VGhi9sVAgMBAAGjggEIMIIBBDAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1UdEwEB/wQIMAYB
+Af8CAQAwHQYDVR0OBBYEFBQusxe3WFbLrlAJQOYfr52LFMLGMB8GA1UdIwQYMBaA
+FHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcw
+AoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzAnBgNVHR8EIDAeMBygGqAYhhZodHRw
+Oi8veDEuYy5sZW5jci5vcmcvMCIGA1UdIAQbMBkwCAYGZ4EMAQIBMA0GCysGAQQB
+gt8TAQEBMA0GCSqGSIb3DQEBCwUAA4ICAQCFyk5HPqP3hUSFvNVneLKYY611TR6W
+PTNlclQtgaDqw+34IL9fzLdwALduO/ZelN7kIJ+m74uyA+eitRY8kc607TkC53wl
+ikfmZW4/RvTZ8M6UK+5UzhK8jCdLuMGYL6KvzXGRSgi3yLgjewQtCPkIVz6D2QQz
+CkcheAmCJ8MqyJu5zlzyZMjAvnnAT45tRAxekrsu94sQ4egdRCnbWSDtY7kh+BIm
+lJNXoB1lBMEKIq4QDUOXoRgffuDghje1WrG9ML+Hbisq/yFOGwXD9RiX8F6sw6W4
+avAuvDszue5L3sz85K+EC4Y/wFVDNvZo4TYXao6Z0f+lQKc0t8DQYzk1OXVu8rp2
+yJMC6alLbBfODALZvYH7n7do1AZls4I9d1P4jnkDrQoxB3UqQ9hVl3LEKQ73xF1O
+yK5GhDDX8oVfGKF5u+decIsH4YaTw7mP3GFxJSqv3+0lUFJoi5Lc5da149p90Ids
+hCExroL1+7mryIkXPeFM5TgO9r0rvZaBFOvV2z0gp35Z0+L4WPlbuEjN/lxPFin+
+HlUjr8gRsI3qfJOQFy/9rKIJR0Y/8Omwt/8oTWgy1mdeHmmjk7j1nYsvC9JSQ6Zv
+MldlTTKB3zhThV1+XWYp6rjd5JW1zbVWEkLNxE7GJThEUG3szgBVGP7pSWTUTsqX
+nLRbwHOoq7hHwg==
+-----END CERTIFICATE-----
--- a/components/esp_mqtt_cxx/examples/ssl/main/mqtt_ssl_example.cpp
+++ b/components/esp_mqtt_cxx/examples/ssl/main/mqtt_ssl_example.cpp
@ -0,0 +1,90 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+/* C++ MQTT (over TCP) Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <cstdint>
+#include <string>
+#include "esp_mqtt_client_config.hpp"
+#include "nvs_flash.h"
+#include "protocol_examples_common.h"
+
+
+#include "esp_log.h"
+#include "esp_mqtt.hpp"
+
+namespace {
+constexpr auto *TAG = "MQTT_EXAMPLE";
+
+extern const char mqtt_eclipse_org_pem_start[]   asm("_binary_mqtt_eclipseprojects_io_pem_start");
+extern const char mqtt_eclipse_org_pem_end[]   asm("_binary_mqtt_eclipseprojects_io_pem_end");
+
+class MyClient final : public idf::mqtt::Client {
+public:
+    using idf::mqtt::Client::Client;
+private:
+    void on_connected(esp_mqtt_event_handle_t const event) override
+    {
+        using idf::mqtt::QoS;
+        subscribe(messages.get());
+        subscribe(sent_load.get(), QoS::AtMostOnce);
+    }
+    void on_data(esp_mqtt_event_handle_t const event) override
+    {
+        if (messages.match(event->topic, event->topic_len)) {
+            ESP_LOGI(TAG, "Received in the messages topic");
+        }
+    }
+    idf::mqtt::Filter messages{std::string{"$SYS/broker/messages/received"}};
+    idf::mqtt::Filter sent_load{std::string{"$SYS/broker/load/+/sent"}};
+};
+}
+
+namespace mqtt = idf::mqtt;
+
+extern "C" void app_main(void)
+{
+    ESP_LOGI(TAG, "[APP] Startup..");
+    ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    esp_log_level_set("*", ESP_LOG_INFO);
+    esp_log_level_set("MQTT_CLIENT", ESP_LOG_VERBOSE);
+    esp_log_level_set("MQTT_EXAMPLE", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_TCP", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_SSL", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE);
+    esp_log_level_set("OUTBOX", ESP_LOG_VERBOSE);
+
+    ESP_ERROR_CHECK(nvs_flash_init());
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
+     * Read "Establishing Wi-Fi or Ethernet Connection" section in
+     * examples/protocols/README.md for more information about this function.
+     */
+    ESP_ERROR_CHECK(example_connect());
+
+    mqtt::BrokerConfiguration broker{
+        .address = {mqtt::URI{std::string{CONFIG_BROKER_URI}}},
+        .security = mqtt::CryptographicInformation{mqtt::PEM{mqtt_eclipse_org_pem_start}}
+    };
+    idf::mqtt::ClientCredentials credentials{};
+    idf::mqtt::Configuration config{};
+
+    MyClient client{broker, credentials, config};
+    while (true) {
+        constexpr TickType_t xDelay = 500 / portTICK_PERIOD_MS;
+        vTaskDelay( xDelay );
+    }
+}
--- a/components/esp_mqtt_cxx/examples/ssl/pytest_mqtt_ssl.py
+++ b/components/esp_mqtt_cxx/examples/ssl/pytest_mqtt_ssl.py
@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+import pytest
+
+
+@pytest.mark.esp32
+def test_dummy() -> None:
+    pass
--- a/components/esp_mqtt_cxx/examples/ssl/sdkconfig.defaults
+++ b/components/esp_mqtt_cxx/examples/ssl/sdkconfig.defaults
@ -0,0 +1,21 @@
+# Enable C++ exceptions and set emergency pool size for exception objects
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
+CONFIG_COMPILER_CXX_EXCEPTIONS_EMG_POOL_SIZE=1024
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
--- a/components/esp_mqtt_cxx/examples/tcp/CMakeLists.txt
+++ b/components/esp_mqtt_cxx/examples/tcp/CMakeLists.txt
@ -0,0 +1,12 @@
+# The following four lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+# (Not part of the boilerplate)
+# This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
+# The path to esp_mqtt_cxx is also added.
+set(EXTRA_COMPONENT_DIRS
+    "../../../../common_components/protocol_examples_common" "../../")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(mqtt_tcp_cxx)
--- a/components/esp_mqtt_cxx/examples/tcp/README.md
+++ b/components/esp_mqtt_cxx/examples/tcp/README.md
@ -0,0 +1,2 @@
+| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-S2 | ESP32-S3 |
+| ----------------- | ----- | -------- | -------- | -------- | -------- |
--- a/components/esp_mqtt_cxx/examples/tcp/main/CMakeLists.txt
+++ b/components/esp_mqtt_cxx/examples/tcp/main/CMakeLists.txt
@ -0,0 +1,3 @@
+idf_component_register(SRCS "mqtt_tcp_example.cpp"
+                    INCLUDE_DIRS ".")
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
--- a/components/esp_mqtt_cxx/examples/tcp/main/Kconfig.projbuild
+++ b/components/esp_mqtt_cxx/examples/tcp/main/Kconfig.projbuild
@ -0,0 +1,9 @@
+menu "Example Configuration"
+
+    config BROKER_URL
+        string "Broker URL"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of the broker to connect to
+
+endmenu
--- a/components/esp_mqtt_cxx/examples/tcp/main/mqtt_tcp_example.cpp
+++ b/components/esp_mqtt_cxx/examples/tcp/main/mqtt_tcp_example.cpp
@ -0,0 +1,86 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+/* C++ MQTT (over TCP) Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include "nvs_flash.h"
+#include "protocol_examples_common.h"
+
+#include "esp_log.h"
+#include "esp_mqtt.hpp"
+#include "esp_mqtt_client_config.hpp"
+
+namespace mqtt = idf::mqtt;
+
+namespace {
+constexpr auto *TAG = "MQTT_EXAMPLE";
+
+class MyClient final : public mqtt::Client {
+public:
+    using mqtt::Client::Client;
+
+private:
+    void on_connected(esp_mqtt_event_handle_t const event) override
+    {
+        using mqtt::QoS;
+        subscribe(messages.get());
+        subscribe(sent_load.get(), QoS::AtMostOnce);
+    }
+    void on_data(esp_mqtt_event_handle_t const event) override
+    {
+        if (messages.match(event->topic, event->topic_len)) {
+            ESP_LOGI(TAG, "Received in the messages topic");
+        }
+    }
+    mqtt::Filter messages{"$SYS/broker/messages/received"};
+    mqtt::Filter sent_load{"$SYS/broker/load/+/sent"};
+};
+}
+
+extern "C" void app_main(void)
+{
+    ESP_LOGI(TAG, "[APP] Startup..");
+    ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    esp_log_level_set("*", ESP_LOG_INFO);
+    esp_log_level_set("MQTT_CLIENT", ESP_LOG_VERBOSE);
+    esp_log_level_set("MQTT_EXAMPLE", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_TCP", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT_SSL", ESP_LOG_VERBOSE);
+    esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE);
+    esp_log_level_set("OUTBOX", ESP_LOG_VERBOSE);
+
+    ESP_ERROR_CHECK(nvs_flash_init());
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
+     * Read "Establishing Wi-Fi or Ethernet Connection" section in
+     * examples/protocols/README.md for more information about this function.
+     */
+    ESP_ERROR_CHECK(example_connect());
+
+    mqtt::BrokerConfiguration broker{
+        .address = {mqtt::URI{std::string{CONFIG_BROKER_URL}}},
+        .security =  mqtt::Insecure{}
+    };
+    mqtt::ClientCredentials credentials{};
+    mqtt::Configuration config{};
+
+    MyClient client{broker, credentials, config};
+
+    while (true) {
+        constexpr TickType_t xDelay = 500 / portTICK_PERIOD_MS;
+        vTaskDelay(xDelay);
+    }
+}
--- a/components/esp_mqtt_cxx/examples/tcp/pytest_mqtt_tcp.py
+++ b/components/esp_mqtt_cxx/examples/tcp/pytest_mqtt_tcp.py
@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+import pytest
+
+
+@pytest.mark.esp32
+def test_dummy() -> None:
+    pass
--- a/components/esp_mqtt_cxx/examples/tcp/sdkconfig.defaults
+++ b/components/esp_mqtt_cxx/examples/tcp/sdkconfig.defaults
@ -0,0 +1,3 @@
+# Enable C++ exceptions and set emergency pool size for exception objects
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
+CONFIG_COMPILER_CXX_EXCEPTIONS_EMG_POOL_SIZE=1024
--- a/components/esp_mqtt_cxx/idf_component.yml
+++ b/components/esp_mqtt_cxx/idf_component.yml
@ -0,0 +1,8 @@
+version: "0.1.0"
+description: esp mqtt cxx
+url: https://github.com/espressif/esp-protocols/tree/master/components/esp_mqtt_cxx
+dependencies:
+  espressif/esp-idf-cxx: "^1.0.0-beta"
+  # Required IDF version
+  idf:
+    version: ">=5.0"
--- a/components/esp_mqtt_cxx/include/esp_mqtt.hpp
+++ b/components/esp_mqtt_cxx/include/esp_mqtt.hpp
@ -0,0 +1,296 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <string_view>
+#ifndef __cpp_exceptions
+#error MQTT class can only be used when __cpp_exceptions is enabled. Enable CONFIG_COMPILER_CXX_EXCEPTIONS in Kconfig
+#endif
+
+#include <optional>
+#include <variant>
+#include <utility>
+#include <memory>
+#include <string>
+#include "esp_exception.hpp"
+#include "esp_mqtt_client_config.hpp"
+#include "mqtt_client.h"
+
+namespace idf::mqtt {
+
+constexpr auto *TAG = "mqtt_client_cpp";
+
+struct MQTTException : ESPException {
+    using ESPException::ESPException;
+};
+
+/**
+ * @brief QoS for publish and subscribe
+ *
+ * Sets the QoS as:
+ * AtMostOnce  : Best effort delivery of messages. Message loss can occur.
+ * AtLeastOnce : Guaranteed delivery of messages. Duplicates can occur.
+ * ExactlyOnce : Guaranteed delivery of messages exactly once.
+ *
+ * @note
+ *  When subscribing to a topic the QoS means the maximum QoS that should be sent to
+ *  client on this topic
+ */
+enum class QoS { AtMostOnce = 0, AtLeastOnce = 1, ExactlyOnce = 2 };
+
+/**
+ * @brief Sets if a message must be retained.
+ *
+ * Retained messages are delivered to future subscribers that match the topic name.
+ *
+ */
+enum class Retain : bool { NotRetained = false, Retained = true };
+
+
+/**
+ * @brief Message class template to publish.
+ *
+ */
+template <typename T> struct Message {
+    T data; /*!< Data for publish. Should be a contiguous type*/
+    QoS qos = QoS::AtLeastOnce; /*!< QoS for the message*/
+    Retain retain = Retain::NotRetained; /*!< Retention mark for the message.*/
+};
+
+/**
+ * @brief Message type that holds std::string for data
+ *
+ */
+using StringMessage = Message<std::string>;
+
+[[nodiscard]] bool filter_is_valid(std::string::const_iterator first, std::string::const_iterator last);
+
+/**
+ * @brief Filter for mqtt topic subscription.
+ *
+ * Topic filter.
+ *
+ */
+class Filter {
+public:
+
+    /**
+     * @brief Constructs the topic filter from the user filter
+     * @throws std::domain_error if the filter is invalid.
+     *
+     * @param user_filter Filter to be used.
+     */
+    explicit Filter(std::string user_filter);
+
+
+    /**
+     * @brief Get the filter string used.
+     *
+     * @return Reference to the topic filter.
+     */
+    const std::string &get();
+
+    /**
+     * @brief Checks the filter string against a topic name.
+     *
+     * @param topic_begin Iterator to the beginning of the sequence.
+     * @param topic_end Iterator to the end of the sequence.
+     *
+     * @return true if the topic name match the filter
+     */
+    [[nodiscard]] bool match(std::string::const_iterator topic_begin, std::string::const_iterator topic_end) const noexcept;
+
+    /**
+     * @brief Checks the filter string against a topic name.
+     *
+     * @param topic topic name
+     *
+     * @return true if the topic name match the filter
+     */
+    [[nodiscard]] bool match(const std::string &topic) const noexcept;
+
+    /**
+     * @brief Checks the filter string against a topic name.
+     *
+     * @param begin Char array with topic name.
+     * @param size  Size of given topic name.
+     *
+     * @return true if the topic name match the filter
+     */
+    [[nodiscard]] bool match(char *begin, int size) const noexcept;
+
+
+private:
+
+    /**
+     * @brief Advance the topic to the next level.
+     *
+     * An mqtt topic ends with a /. This function is used to iterate in topic levels.
+     *
+     * @return Iterator to the start of the topic.
+     */
+    [[nodiscard]] std::string::const_iterator advance(std::string::const_iterator begin, std::string::const_iterator end) const;
+    std::string filter;
+};
+
+/**
+ * @brief Message identifier to track delivery.
+ *
+ */
+enum class MessageID : int {};
+
+/**
+ * @brief Base class for MQTT client
+ *
+ * Should be inherited to provide event handlers.
+ */
+class Client {
+public:
+    /**
+     * @brief Constructor of the client
+     *
+     * @param broker Configuration for broker connection
+     * @param credentials client credentials to be presented to the broker
+     * @param config Mqtt client configuration
+     */
+    Client(const BrokerConfiguration &broker, const ClientCredentials &credentials, const Configuration &config);
+
+    /**
+     * @brief Constructs Client using the same configuration used for
+     * `esp_mqtt_client`
+     * @param config config struct to `esp_mqtt_client`
+     */
+    Client(const esp_mqtt_client_config_t &config);
+
+    /**
+     * @brief Subscribe to topic
+     *
+     * @param topic_filter MQTT topic filter
+     * @param qos QoS subscription, defaulted as QoS::AtLeastOnce
+     *
+     * @return Optional MessageID. In case of failure std::nullopt is returned.
+     */
+    std::optional<MessageID> subscribe(const std::string &topic_filter, QoS qos = QoS::AtLeastOnce);
+
+    /**
+     * @brief publish message to topic
+     *
+     * @tparam Container Type for data container. Must be a contiguous memory.
+     * @param topic Topic name
+     * @param message Message struct containing data, qos and retain
+     * configuration.
+     *
+     * @return Optional MessageID. In case of failure std::nullopt is returned.
+     */
+    template <class Container>
+    std::optional<MessageID> publish(const std::string &topic, const Message<Container> &message)
+    {
+        return publish(topic, std::begin(message.data), std::end(message.data), message.qos, message.retain);
+    }
+
+    /**
+     * @brief publish message to topic
+     *
+     * @tparam InputIt Input data iterator type.
+     * @param topic Topic name
+     * @param first, last Iterator pair of data to publish
+     * @param qos Set qos message
+     * @param retain Set if message should be retained
+     *
+     * @return Optional MessageID. In case of failure std::nullopt is returned.
+     */
+    template <class InputIt>
+    std::optional<MessageID> publish(const std::string &topic, InputIt first, InputIt last, QoS qos = QoS::AtLeastOnce, Retain retain = Retain::NotRetained)
+    {
+        auto size = std::distance(first, last);
+        auto res =  esp_mqtt_client_publish(handler.get(), topic.c_str(), &(*first), size, static_cast<int>(qos),
+                                            static_cast<int>(retain));
+        if (res < 0) {
+            return std::nullopt;
+        }
+        return MessageID{res};
+    }
+
+    virtual ~Client() = default;
+
+protected:
+    /**
+     * @brief Helper type to be used as custom deleter for std::unique_ptr.
+     */
+    struct MqttClientDeleter {
+        void operator()(esp_mqtt_client *client_handler)
+        {
+            esp_mqtt_client_destroy(client_handler);
+        }
+    };
+
+    /**
+     * @brief Type of the handler for the underlying mqtt_client handler.
+     * It uses std::unique_ptr for lifetime management
+     */
+    using ClientHandler = std::unique_ptr<esp_mqtt_client, MqttClientDeleter>;
+    /**
+     * @brief esp_mqtt_client handler
+     *
+     */
+    ClientHandler handler;
+
+    /**
+    * @brief Called if there is an error event
+    *
+    * @param event mqtt event data
+    */
+    virtual void on_error(const esp_mqtt_event_handle_t event);
+    /**
+    * @brief Called if there is an disconnection event
+    *
+    * @param event mqtt event data
+    */
+    virtual void on_disconnected(const esp_mqtt_event_handle_t event);
+    /**
+    * @brief Called if there is an subscribed event
+    *
+    * @param event mqtt event data
+    */
+    virtual void on_subscribed(const esp_mqtt_event_handle_t event);
+    /**
+    * @brief Called if there is an unsubscribed event
+    *
+    * @param event mqtt event data
+    */
+    virtual void on_unsubscribed(const esp_mqtt_event_handle_t event);
+    /**
+    * @brief Called if there is an published event
+    *
+    * @param event mqtt event data
+    */
+    virtual void on_published(const esp_mqtt_event_handle_t event);
+    /**
+    * @brief Called if there is an before connect event
+    *
+    * @param event mqtt event data
+    */
+    virtual void on_before_connect(const esp_mqtt_event_handle_t event);
+    /**
+    * @brief Called if there is an connected event
+    *
+    * @param event mqtt event data
+    *
+    */
+    virtual void on_connected(const esp_mqtt_event_handle_t event) = 0;
+    /**
+    * @brief Called if there is an data event
+    *
+    * @param event mqtt event data
+    *
+    */
+    virtual void on_data(const esp_mqtt_event_handle_t event) = 0;
+private:
+    static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id,
+                                   void *event_data) noexcept;
+    void init(const esp_mqtt_client_config_t &config);
+};
+} // namespace idf::mqtt
--- a/components/esp_mqtt_cxx/include/esp_mqtt_client_config.hpp
+++ b/components/esp_mqtt_cxx/include/esp_mqtt_client_config.hpp
@ -0,0 +1,213 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "mqtt_client.h"
+
+namespace idf::mqtt {
+
+
+
+/**
+ * @brief Broker addresss
+ *
+ * Use this to set the broker without parsing the URI string.
+ *
+ */
+struct Host {
+    std::string address; /*!< Host name*/
+    std::string path;    /*!< Route path of the broker in host*/
+    esp_mqtt_transport_t transport; /*!< Transport scheme to use. */
+};
+
+/**
+ * @brief Broker addresss URI
+ *
+ * Use this to set the broker address using the URI.
+ *
+ */
+struct URI {
+    std::string address; /*!< Broker adddress URI*/
+};
+
+
+/**
+ * @brief Broker addresss.
+ *
+ */
+struct BrokerAddress {
+    std::variant<Host, URI> address; /*!< Address, defined by URI or Host struct */
+    uint32_t port = 0; /*!< Port used, defaults to 0 to select common port for the scheme used */
+};
+
+/**
+ * @brief PEM formated data
+ *
+ *  Store certificates, keys and cryptographic data.
+ *
+ */
+struct PEM {
+    const char *data;
+};
+
+/**
+ * @brief DER formated data
+ *
+ *  Store certificates, keys and cryptographic data.
+ *
+ */
+struct DER {
+    const char *data;
+    size_t len;
+};
+
+/**
+ * @brief Holds cryptography related information
+ *
+ *  Hold PEM or DER formated cryptographic data.
+ *
+ */
+using CryptographicInformation = std::variant<PEM, DER>;
+
+
+/**
+ * @brief Do not verify broker certificate.
+ *
+ * To be used when doing MQTT over TLS connection but not verify broker's certificates.
+ *
+ */
+struct Insecure {};
+
+/**
+ * @brief Use global CA store
+ *
+ * To be used when client should use the Global CA Store to get trusted certificates for the broker.
+ *
+ */
+struct GlobalCAStore {};
+
+/**
+ * @brief Use a pre shared key for broker authentication.
+ *
+ * To be used when client should use a PSK to authenticate the broker.
+ *
+ */
+struct PSK {
+    const struct psk_key_hint *hint_key;/*  Pointer to PSK struct defined in esp_tls.h to enable PSK authentication */
+};
+
+
+/**
+ * @brief Authentication method for Broker
+ *
+ * Selects the method for authentication based on the type it holds.
+ *
+ */
+using BrokerAuthentication = std::variant<Insecure, GlobalCAStore, CryptographicInformation, PSK>;
+
+/**
+ * @brief Password related data.
+ *
+ */
+struct Password {
+    std::string data;
+};
+
+/**
+ * @brief Data to authenticate client with certificates.
+ *
+ */
+struct ClientCertificate {
+    CryptographicInformation certificate; /*!< Certificate in PEM or DER format.*/
+    CryptographicInformation key; /*!< Key data in PEM or DER format.*/
+    std::optional<Password> key_password = std::nullopt; /*!< Optional password for key */
+};
+
+/**
+ * @brief Used to select usage of Secure Element
+ *
+ *  Enables the usage of the secure element present in ESP32-WROOM-32SE.
+ *
+ */
+struct SecureElement {};
+
+
+/**
+ * @brief Used to select usage of Digital Signature Peripheral.
+ *
+ *  Enables the usage of the Digital Signature hardware accelerator.
+ *
+ */
+struct DigitalSignatureData {
+    void *ds_data;                          /* carrier of handle for digital signature parameters */
+};
+
+using AuthenticationFactor = std::variant<Password, ClientCertificate, SecureElement>;
+
+struct BrokerConfiguration {
+    BrokerAddress address;
+    BrokerAuthentication security;
+};
+
+struct ClientCredentials {
+    std::optional<std::string> username;    // MQTT username
+    AuthenticationFactor authentication;
+    std::vector<std::string> alpn_protos;               /*!< List of supported application protocols to be used for ALPN */
+    /* default is ``ESP32_%CHIPID%`` where %CHIPID% are last 3 bytes of MAC address in hex format */
+    std::optional<std::string > client_id = std::nullopt;
+};
+
+struct Event {
+    mqtt_event_callback_t event_handle;     /*!< handle for MQTT events as a callback in legacy mode */
+    esp_event_loop_handle_t event_loop_handle; /*!< handle for MQTT event loop library */
+};
+
+struct LastWill {
+    const char *lwt_topic;                  /*!< LWT (Last Will and Testament) message topic (NULL by default) */
+    const char *lwt_msg;                    /*!< LWT message (NULL by default) */
+    int lwt_qos;                            /*!< LWT message qos */
+    int lwt_retain;                         /*!< LWT retained message flag */
+    int lwt_msg_len;                        /*!< LWT message length */
+};
+
+struct Session {
+    LastWill last_will;
+    int disable_clean_session;              /*!< mqtt clean session, default clean_session is true */
+    int keepalive;                          /*!< mqtt keepalive, default is 120 seconds */
+    bool disable_keepalive;                 /*!< Set disable_keepalive=true to turn off keep-alive mechanism, false by default (keepalive is active by default). Note: setting the config value `keepalive` to `0` doesn't disable keepalive feature, but uses a default keepalive period */
+    esp_mqtt_protocol_ver_t protocol_ver;   /*!< MQTT protocol version used for connection, defaults to value from menuconfig*/
+};
+
+struct Task {
+    int task_prio;                          /*!< MQTT task priority, default is 5, can be changed in ``make menuconfig`` */
+    int task_stack;                         /*!< MQTT task stack size, default is 6144 bytes, can be changed in ``make menuconfig`` */
+};
+
+struct Connection {
+    esp_mqtt_transport_t transport;         /*!< overrides URI transport */
+    int reconnect_timeout_ms;               /*!< Reconnect to the broker after this value in miliseconds if auto reconnect is not disabled (defaults to 10s) */
+    int network_timeout_ms;                 /*!< Abort network operation if it is not completed after this value, in milliseconds (defaults to 10s) */
+    int refresh_connection_after_ms;        /*!< Refresh connection after this value (in milliseconds) */
+    bool disable_auto_reconnect;            /*!< this mqtt client will reconnect to server (when errors/disconnect). Set disable_auto_reconnect=true to disable */
+};
+
+struct Configuration {
+    Event event;
+    Task task;
+    Session session;
+    Connection connection;
+    void *user_context;                     /*!< pass user context to this option, then can receive that context in ``event->user_context`` */
+    int buffer_size;                        /*!< size of MQTT send/receive buffer, default is 1024 (only receive buffer size if ``out_buffer_size`` defined) */
+    int out_buffer_size;                    /*!< size of MQTT output buffer. If not defined, both output and input buffers have the same size defined as ``buffer_size`` */
+};
+
+} // idf::mqtt
--- a/components/esp_websocket_client/README.md
+++ b/components/esp_websocket_client/README.md
@ -1,5 +1,7 @@
 # ESP WEBSOCKET CLIENT

+[![Component Registry](https://components.espressif.com/components/espressif/esp_websocket_client/badge.svg)](https://components.espressif.com/components/espressif/esp_websocket_client)
+
 The `esp-websocket_client` component is a managed component for `esp-idf` that contains implementation of [WebSocket protocol client](https://datatracker.ietf.org/doc/html/rfc6455) for ESP32

 ## Examples
--- a/components/esp_websocket_client/esp_websocket_client.c
+++ b/components/esp_websocket_client/esp_websocket_client.c
@ -18,6 +18,7 @@
 #include "freertos/event_groups.h"
 #include "esp_log.h"
 #include "esp_timer.h"
+#include "esp_tls_crypto.h"

 static const char *TAG = "WEBSOCKET_CLIENT";

@ -55,6 +56,7 @@ static const char *TAG = "WEBSOCKET_CLIENT";

 #define WS_OVER_TCP_SCHEME  "ws"
 #define WS_OVER_TLS_SCHEME  "wss"
+#define WS_HTTP_BASIC_AUTH  "Basic "

 const static int STOPPED_BIT = BIT0;
 const static int CLOSE_FRAME_SENT_BIT = BIT1;   // Indicates that a close frame was sent by the client
@ -63,6 +65,7 @@ const static int CLOSE_FRAME_SENT_BIT = BIT1;   // Indicates that a close frame
 ESP_EVENT_DEFINE_BASE(WEBSOCKET_EVENTS);

 typedef struct {
+    const char                 *task_name;
    int                         task_stack;
    int                         task_prio;
    char                        *uri;
@ -71,6 +74,7 @@ typedef struct {
    char                        *scheme;
    char                        *username;
    char                        *password;
+    char                        *auth;
    int                         port;
    bool                        auto_reconnect;
    void                        *user_context;
@ -115,8 +119,11 @@ struct esp_websocket_client {
    int                         auto_reconnect;
    bool                        run;
    bool                        wait_for_pong_resp;
+    bool                        selected_for_destroying;
    EventGroupHandle_t          status_bits;
    SemaphoreHandle_t            lock;
+    size_t                      errormsg_size;
+    char                        *errormsg_buffer;
    char                        *rx_buffer;
    char                        *tx_buffer;
    int                         buffer_size;
@ -213,20 +220,64 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
    return ESP_OK;
 }

-static esp_err_t esp_websocket_client_error_connection(esp_websocket_client_handle_t client)
+static esp_err_t esp_websocket_client_error(esp_websocket_client_handle_t client, const char *format, ...) __attribute__ ((format (printf, 2, 3)));
+static esp_err_t esp_websocket_client_error(esp_websocket_client_handle_t client, const char *format, ...)
 {
-    ESP_WS_CLIENT_STATE_CHECK(TAG, client, return ESP_FAIL);
-    esp_transport_close(client->transport);
+    va_list myargs;
+    va_start(myargs, format);

-    if (client->config->auto_reconnect) {
-        client->reconnect_tick_ms = _tick_get_ms();
-        ESP_LOGI(TAG, "Reconnect after %d ms", client->wait_timeout_ms);
+    size_t needed_size = vsnprintf(NULL, 0, format, myargs);
+    needed_size++; // null terminator
+
+    if (needed_size > client->errormsg_size) {
+        if (client->errormsg_buffer) {
+            free(client->errormsg_buffer);
+        }
+        client->errormsg_buffer = malloc(needed_size);
+        if (client->errormsg_buffer == NULL) {
+            client->errormsg_size = 0;
+            ESP_LOGE(TAG, "Failed to allocate...");
+            return ESP_ERR_NO_MEM;
+        }
+        client->errormsg_size = needed_size;
    }
-    client->state = WEBSOCKET_STATE_WAIT_TIMEOUT;
-    esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_ERROR, NULL, 0);
+
+    needed_size = vsnprintf(client->errormsg_buffer, client->errormsg_size, format, myargs);
+
+    va_end(myargs);
+
+    ESP_LOGE(TAG, "%s", client->errormsg_buffer);
+
+    esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_ERROR, client->errormsg_buffer, needed_size);
    return ESP_OK;
 }

+static char *http_auth_basic(const char *username, const char *password)
+{
+    int out;
+    char *user_info = NULL;
+    char *digest = NULL;
+    size_t n = 0;
+
+    if (asprintf(&user_info, "%s:%s", username, password) < 0) {
+        return NULL;
+    }
+
+    if (!user_info) {
+        ESP_LOGE(TAG, "No enough memory for user information");
+        return NULL;
+    }
+
+    esp_crypto_base64_encode(NULL, 0, &n, (const unsigned char *)user_info, strlen(user_info));
+    digest = calloc(1, strlen(WS_HTTP_BASIC_AUTH) + n + 1);
+    if (digest) {
+        strcpy(digest, WS_HTTP_BASIC_AUTH);
+        esp_crypto_base64_encode((unsigned char *)digest + 6, n, (size_t *)&out, (const unsigned char *)user_info, strlen(user_info));
+    }
+    free(user_info);
+    return digest;
+}
+
 static esp_err_t esp_websocket_client_set_config(esp_websocket_client_handle_t client, const esp_websocket_client_config_t *config)
 {
    websocket_config_storage_t *cfg = client->config;
@ -235,6 +286,8 @@ static esp_err_t esp_websocket_client_set_config(esp_websocket_client_handle_t c
        cfg->task_prio = WEBSOCKET_TASK_PRIORITY;
    }

+    cfg->task_name = config->task_name;
+
    cfg->task_stack = config->task_stack;
    if (cfg->task_stack == 0) {
        cfg->task_stack = WEBSOCKET_TASK_STACK;
@ -261,6 +314,12 @@ static esp_err_t esp_websocket_client_set_config(esp_websocket_client_handle_t c
        ESP_WS_CLIENT_MEM_CHECK(TAG, cfg->password, return ESP_ERR_NO_MEM);
    }

+    if (cfg->username && cfg->password) {
+        free(cfg->auth);
+        cfg->auth = http_auth_basic(cfg->username, cfg->password);
+        ESP_WS_CLIENT_MEM_CHECK(TAG, cfg->auth, return ESP_ERR_NO_MEM);
+    }
+
    if (config->uri) {
        free(cfg->uri);
        cfg->uri = strdup(config->uri);
@ -333,6 +392,7 @@ static esp_err_t esp_websocket_client_destroy_config(esp_websocket_client_handle
    free(cfg->scheme);
    free(cfg->username);
    free(cfg->password);
+    free(cfg->auth);
    free(cfg->subprotocol);
    free(cfg->user_agent);
    free(cfg->headers);
@ -342,6 +402,27 @@ static esp_err_t esp_websocket_client_destroy_config(esp_websocket_client_handle
    return ESP_OK;
 }

+static void destroy_and_free_resources(esp_websocket_client_handle_t client)
+{
+    if (client->event_handle) {
+        esp_event_loop_delete(client->event_handle);
+    }
+    if (client->if_name) {
+        free(client->if_name);
+    }
+    esp_websocket_client_destroy_config(client);
+    esp_transport_list_destroy(client->transport_list);
+    vQueueDelete(client->lock);
+    free(client->tx_buffer);
+    free(client->rx_buffer);
+    free(client->errormsg_buffer);
+    if (client->status_bits) {
+        vEventGroupDelete(client->status_bits);
+    }
+    free(client);
+    client = NULL;
+}
+
 static esp_err_t set_websocket_transport_optional_settings(esp_websocket_client_handle_t client, const char *scheme)
 {
    esp_transport_handle_t trans = esp_transport_list_get_transport(client->transport_list, scheme);
@ -351,6 +432,7 @@ static esp_err_t set_websocket_transport_optional_settings(esp_websocket_client_
            .sub_protocol = client->config->subprotocol,
            .user_agent = client->config->user_agent,
            .headers = client->config->headers,
+            .auth = client->config->auth,
            .propagate_control_frames = true
        };
        return esp_transport_ws_set_config(trans, &config);
@ -527,11 +609,14 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
    client->reconnect_tick_ms = _tick_get_ms();
    client->ping_tick_ms = _tick_get_ms();
    client->wait_for_pong_resp = false;
+    client->selected_for_destroying = false;

    int buffer_size = config->buffer_size;
    if (buffer_size <= 0) {
        buffer_size = WEBSOCKET_BUFFER_SIZE_BYTE;
    }
+    client->errormsg_buffer = NULL;
+    client->errormsg_size = 0;
 #ifndef CONFIG_ESP_WS_CLIENT_ENABLE_DYNAMIC_BUFFER
    client->rx_buffer = malloc(buffer_size);
    ESP_WS_CLIENT_MEM_CHECK(TAG, client->rx_buffer, {
@ -563,22 +648,16 @@ esp_err_t esp_websocket_client_destroy(esp_websocket_client_handle_t client)
    if (client->run) {
        esp_websocket_client_stop(client);
    }
-    if (client->event_handle) {
-        esp_event_loop_delete(client->event_handle);
+    destroy_and_free_resources(client);
+    return ESP_OK;
+}
+
+esp_err_t esp_websocket_client_destroy_on_exit(esp_websocket_client_handle_t client)
+{
+    if (client == NULL) {
+        return ESP_ERR_INVALID_ARG;
    }
-    if (client->if_name) {
-        free(client->if_name);
-    }
-    esp_websocket_client_destroy_config(client);
-    esp_transport_list_destroy(client->transport_list);
-    vQueueDelete(client->lock);
-    free(client->tx_buffer);
-    free(client->rx_buffer);
-    if (client->status_bits) {
-        vEventGroupDelete(client->status_bits);
-    }
-    free(client);
-    client = NULL;
+    client->selected_for_destroying = true;
    return ESP_OK;
 }

@ -657,8 +736,19 @@ static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client)
    do {
        rlen = esp_transport_read(client->transport, client->rx_buffer, client->buffer_size, client->config->network_timeout_ms);
        if (rlen < 0) {
-            ESP_LOGE(TAG, "Error read data");
            esp_websocket_free_buf(client, false);
+            esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
+            if (error_handle) {
+                ESP_LOGE(TAG, "esp_transport_read() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                         rlen, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                         error_handle->esp_tls_flags, errno);
+                esp_websocket_client_error(client, "esp_transport_read() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                                           rlen, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                                           error_handle->esp_tls_flags, errno);
+            } else {
+                ESP_LOGE(TAG, "esp_transport_read() failed with %d, errno=%d", rlen, errno);
+                esp_websocket_client_error(client, "esp_transport_read() failed with %d, errno=%d", rlen, errno);
+            }
            return ESP_FAIL;
        }
        client->payload_len = esp_transport_ws_get_read_payload_len(client->transport);
@ -732,8 +822,19 @@ static void esp_websocket_client_task(void *pv)
                                               client->config->port,
                                               client->config->network_timeout_ms);
            if (result < 0) {
-                ESP_LOGE(TAG, "Error transport connect %i", result);
-                esp_websocket_client_error_connection(client);
+                esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
+                if (error_handle) {
+                    ESP_LOGE(TAG, "esp_transport_connect() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                             result, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                             error_handle->esp_tls_flags, errno);
+                    esp_websocket_client_error(client, "esp_transport_connect() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                                               result, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                                               error_handle->esp_tls_flags, errno);
+                } else {
+                    ESP_LOGE(TAG, "esp_transport_connect() failed with %d, errno=%d", result, errno);
+                    esp_websocket_client_error(client, "esp_transport_connect() failed with %d, errno=%d", result, errno);
+                }
+                esp_websocket_client_abort_connection(client);
                break;
            }
            ESP_LOGD(TAG, "Transport connected to %s://%s:%d", client->config->scheme, client->config->host, client->config->port);
@ -760,6 +861,7 @@ static void esp_websocket_client_task(void *pv)
                if ( _tick_get_ms() - client->pingpong_tick_ms > client->config->pingpong_timeout_sec * 1000 ) {
                    if (client->wait_for_pong_resp) {
                        ESP_LOGE(TAG, "Error, no PONG received for more than %d seconds after PING", client->config->pingpong_timeout_sec);
+                        esp_websocket_client_error(client, "Error, no PONG received for more than %d seconds after PING", client->config->pingpong_timeout_sec);
                        esp_websocket_client_abort_connection(client);
                        break;
                    }
@ -806,7 +908,18 @@ static void esp_websocket_client_task(void *pv)
        if (WEBSOCKET_STATE_CONNECTED == client->state) {
            read_select = esp_transport_poll_read(client->transport, 1000); //Poll every 1000ms
            if (read_select < 0) {
-                ESP_LOGE(TAG, "Network error: esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
+                esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
+                if (error_handle) {
+                    ESP_LOGE(TAG, "esp_transport_poll_read() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                             read_select, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                             error_handle->esp_tls_flags, errno);
+                    esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                                               read_select, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                                               error_handle->esp_tls_flags, errno);
+                } else {
+                    ESP_LOGE(TAG, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
+                    esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
+                }
                esp_websocket_client_abort_connection(client);
            }
        } else if (WEBSOCKET_STATE_WAIT_TIMEOUT == client->state) {
@ -833,6 +946,9 @@ static void esp_websocket_client_task(void *pv)
    esp_transport_close(client->transport);
    xEventGroupSetBits(client->status_bits, STOPPED_BIT);
    client->state = WEBSOCKET_STATE_UNKNOW;
+    if (client->selected_for_destroying == true) {
+        destroy_and_free_resources(client);
+    }
    vTaskDelete(NULL);
 }

@ -850,7 +966,8 @@ esp_err_t esp_websocket_client_start(esp_websocket_client_handle_t client)
        return ESP_FAIL;
    }

-    if (xTaskCreate(esp_websocket_client_task, "websocket_task", client->config->task_stack, client, client->config->task_prio, &client->task_handle) != pdTRUE) {
+    if (xTaskCreate(esp_websocket_client_task, client->config->task_name ? client->config->task_name : "websocket_task",
+                    client->config->task_stack, client, client->config->task_prio, &client->task_handle) != pdTRUE) {
        ESP_LOGE(TAG, "Error create websocket task");
        return ESP_FAIL;
    }
@ -1000,8 +1117,19 @@ int esp_websocket_client_send_with_opcode(esp_websocket_client_handle_t client,
                                         (timeout == portMAX_DELAY) ? -1 : timeout * portTICK_PERIOD_MS);
        if (wlen < 0 || (wlen == 0 && need_write != 0)) {
            ret = wlen;
-            ESP_LOGE(TAG, "Network error: esp_transport_write() returned %d, errno=%d", ret, errno);
            esp_websocket_free_buf(client, true);
+            esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
+            if (error_handle) {
+                ESP_LOGE(TAG, "esp_transport_write() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                         ret, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                         error_handle->esp_tls_flags, errno);
+                esp_websocket_client_error(client, "esp_transport_write() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
+                                           ret, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
+                                           error_handle->esp_tls_flags, errno);
+            } else {
+                ESP_LOGE(TAG, "esp_transport_write() returned %d, errno=%d", ret, errno);
+                esp_websocket_client_error(client, "esp_transport_write() returned %d, errno=%d", ret, errno);
+            }
            esp_websocket_client_abort_connection(client);
            goto unlock_and_return;
        }
--- a/components/esp_websocket_client/examples/CMakeLists.txt
+++ b/components/esp_websocket_client/examples/CMakeLists.txt
@ -2,7 +2,7 @@
 # in this exact order for cmake to work correctly
 cmake_minimum_required(VERSION 3.5)

-set(EXTRA_COMPONENT_DIRS "../..")
+set(EXTRA_COMPONENT_DIRS "..")
 # This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
 list(APPEND EXTRA_COMPONENT_DIRS "../../../common_components/protocol_examples_common")

--- a/components/esp_websocket_client/include/esp_websocket_client.h
+++ b/components/esp_websocket_client/include/esp_websocket_client.h
@ -68,12 +68,13 @@ typedef struct {
    const char                  *uri;                       /*!< Websocket URI, the information on the URI can be overrides the other fields below, if any */
    const char                  *host;                      /*!< Domain or IP as string */
    int                         port;                       /*!< Port to connect, default depend on esp_websocket_transport_t (80 or 443) */
-    const char                  *username;                  /*!< Using for Http authentication - Not supported for now */
-    const char                  *password;                  /*!< Using for Http authentication - Not supported for now */
+    const char                  *username;                  /*!< Using for Http authentication, only support basic auth now */
+    const char                  *password;                  /*!< Using for Http authentication */
    const char                  *path;                      /*!< HTTP Path, if not set, default is `/` */
    bool                        disable_auto_reconnect;     /*!< Disable the automatic reconnect function when disconnected */
    void                        *user_context;              /*!< HTTP user data context */
    int                         task_prio;                  /*!< Websocket task priority */
+    const char                 *task_name;                  /*!< Websocket task name */
    int                         task_stack;                 /*!< Websocket task stack */
    int                         buffer_size;                /*!< Websocket buffer size */
    const char                  *cert_pem;                  /*!< Pointer to certificate data in PEM or DER format for server verify (with SSL), default is NULL, not required to verify the server. PEM-format must have a terminating NULL-character. DER-format requires the length to be passed in cert_len. */
@ -166,6 +167,18 @@ esp_err_t esp_websocket_client_stop(esp_websocket_client_handle_t client);
 */
 esp_err_t esp_websocket_client_destroy(esp_websocket_client_handle_t client);

+/**
+ * @brief      If this API called, WebSocket client will destroy and free all resources at the end of event loop.
+ *
+ *  Notes:
+ *  - After event loop finished, client handle would be dangling and should never be used
+ *
+ * @param[in]  client      The client
+ *
+ * @return     esp_err_t
+ */
+esp_err_t esp_websocket_client_destroy_on_exit(esp_websocket_client_handle_t client);
+
 /**
 * @brief      Write binary data to the WebSocket connection (data send with WS OPCODE=02, i.e. binary)
 *
--- a/components/mdns/CMakeLists.txt
+++ b/components/mdns/CMakeLists.txt
@ -6,7 +6,7 @@ endif()

 idf_build_get_property(target IDF_TARGET)
 if(${target} STREQUAL "linux")
-    set(dependencies esp_system_protocols_linux)
+    set(dependencies esp_event esp_netif_linux esp_timer_linux esp_system)
    set(srcs "mdns.c" ${MDNS_NETWORKING})
 else()
    set(dependencies lwip console esp_netif)
@ -22,6 +22,11 @@ idf_component_register(
        PRIV_REQUIRES ${private_dependencies})
 target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

+if(${target} STREQUAL "linux")
+    target_link_libraries(${COMPONENT_LIB} PRIVATE "-lbsd")
+endif()
+
+
 if(CONFIG_ETH_ENABLED)
    idf_component_optional_requires(PRIVATE esp_eth)
 endif()
--- a/components/mdns/Kconfig
+++ b/components/mdns/Kconfig
@ -64,17 +64,6 @@ menu "mDNS"
            Configures timeout for adding a new mDNS service. Adding a service
            fails if could not be completed within this time.

-    config MDNS_STRICT_MODE
-        bool "mDNS strict mode"
-        default "n"
-        help
-            Configures strict mode. Set this to 1 for the mDNS library to strictly follow the RFC6762:
-            Currently the only strict feature: Do not repeat original questions in response packets
-            (defined in RFC6762 sec. 6).
-            Default configuration is 0, i.e. non-strict mode, since some implementations,
-            such as lwIP mDNS resolver (used by standard POSIX API like getaddrinfo, gethostbyname)
-            could not correctly resolve advertised names.
-
    config MDNS_TIMER_PERIOD_MS
        int "mDNS timer period (ms)"
        range 10 10000
@ -92,6 +81,27 @@ menu "mDNS"
            This option creates a new thread to serve receiving packets (TODO).
            This option uses additional N sockets, where N is number of interfaces.

+    config MDNS_SKIP_SUPPRESSING_OWN_QUERIES
+        bool "Skip suppressing our own packets"
+        default n
+        help
+            Enable only if the querier and the responder share the same IP address.
+            This usually happens in test mode, where we may run multiple instances of
+            responders/queriers on the same interface.
+
+    config MDNS_ENABLE_DEBUG_PRINTS
+        bool "Enable debug prints of mDNS packets"
+        default n
+        help
+            Enable for the library to log received and sent mDNS packets to stdout.
+
+    config MDNS_RESPOND_REVERSE_QUERIES
+        bool "Enable responding to IPv4 reverse queries"
+        default n
+        help
+            Enables support for IPv4 reverse lookup. If enabled, the mDNS library
+            response to PTR queries of "A.B.C.D.in-addr.arpa" type.
+
    config MDNS_MULTIPLE_INSTANCE
        bool "Multiple instances under the same service type"
        default y
--- a/components/mdns/README.md
+++ b/components/mdns/README.md
@ -1,5 +1,7 @@
 # mDNS Service

+[![Component Registry](https://components.espressif.com/components/espressif/mdns/badge.svg)](https://components.espressif.com/components/espressif/mdns)
+
 mDNS is a multicast UDP service that is used to provide local network service and host discovery.

 ## Examples
--- a/components/mdns/examples/main/mdns_example_main.c
+++ b/components/mdns/examples/main/mdns_example_main.c
@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
@ -276,9 +276,15 @@ void app_main(void)
     * This is typically performed in "GOT_IP" event handler, but we call it here directly
     * since the `EXAMPLE_INTERFACE` netif is connected already, to keep the example simple.
     */
-    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ENABLE_IP4));
-    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ANNOUNCE_IP4));
+    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ENABLE_IP4 | MDNS_EVENT_ENABLE_IP6));
+    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ANNOUNCE_IP4 | MDNS_EVENT_ANNOUNCE_IP6));
+
+#if defined(CONFIG_MDNS_RESPOND_REVERSE_QUERIES)
+    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_IP4_REVERSE_LOOKUP | MDNS_EVENT_IP6_REVERSE_LOOKUP));
 #endif
+
+#endif // CONFIG_MDNS_ADD_CUSTOM_NETIF
+
    initialise_button();
    xTaskCreate(&mdns_example_task, "mdns_example_task", 2048, NULL, 5, NULL);
 }
--- a/components/mdns/examples/pytest_mdns.py
+++ b/components/mdns/examples/pytest_mdns.py
@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
 # SPDX-License-Identifier: Unlicense OR CC0-1.0
 import re
 import select
@ -8,8 +8,11 @@ import subprocess
 import time
 from threading import Event, Thread

-import dpkt
-import dpkt.dns
+try:
+    import dpkt
+    import dpkt.dns
+except ImportError:
+    pass


 def get_dns_query_for_esp(esp_host):
@ -117,10 +120,11 @@ def test_examples_protocol_mdns(dut):
      2. get the dut host name (and IP address)
      3. check the mdns name is accessible
      4. check DUT output if mdns advertized host is resolved
+      5. check if DUT responds to dig
+      6. check the DUT is searchable via reverse IP lookup
    """

-    specific_host = dut.expect(re.compile(
-        b'mdns hostname set to: \[(.*?)\]')).group(1).decode()  # noqa: W605
+    specific_host = dut.expect(r'mdns hostname set to: \[(.*?)\]')[1].decode()

    mdns_server_events = {
        'stop': Event(),
@ -129,9 +133,14 @@ def test_examples_protocol_mdns(dut):
    }
    mdns_responder = Thread(target=mdns_server,
                            args=(str(specific_host), mdns_server_events))
-    ip_address = dut.expect(
-        re.compile(b'IPv4 address:([a-zA-Z0-9]*).*')).group(1).decode()
-    print('Connected to AP with IP: {}'.format(ip_address))
+    ipv4 = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]',
+                      timeout=30)[1].decode()
+    ip_addresses = [ipv4]
+    if dut.app.sdkconfig.get('LWIP_IPV6') is True:
+        ipv6_r = r':'.join((r'[0-9a-fA-F]{4}', ) * 8)
+        ipv6 = dut.expect(ipv6_r, timeout=30)[0].decode()
+        ip_addresses.append(ipv6)
+    print('Connected with IP addresses: {}'.format(','.join(ip_addresses)))
    try:
        # 3. check the mdns name is accessible.
        mdns_responder.start()
@ -162,11 +171,25 @@ def test_examples_protocol_mdns(dut):
        ])
        print('Resolving {} using "dig" succeeded with:\n{}'.format(
            specific_host, dig_output))
-        if not ip_address.encode('utf-8') in dig_output:
+        if not ipv4.encode('utf-8') in dig_output:
            raise ValueError(
                'Test has failed: Incorrectly resolved DUT hostname using dig'
-                "Output should've contained DUT's IP address:{}".format(
-                    ip_address))
+                "Output should've contained DUT's IP address:{}".format(ipv4))
+        # 6. check the DUT reverse lookup
+        if dut.app.sdkconfig.get('MDNS_RESPOND_REVERSE_QUERIES') is True:
+            for ip_address in ip_addresses:
+                dig_output = subprocess.check_output([
+                    'dig', '+short', '-p', '5353', '@224.0.0.251', '-x',
+                    '{}'.format(ip_address)
+                ])
+                print('Reverse lookup for {} using "dig" succeeded with:\n{}'.
+                      format(ip_address, dig_output))
+                if specific_host not in dig_output.decode():
+                    raise ValueError(
+                        'Test has failed: Incorrectly resolved DUT IP address using dig'
+                        "Output should've contained DUT's name:{}".format(
+                            specific_host))
+
    finally:
        mdns_server_events['stop'].set()
        mdns_responder.join()
--- a/components/mdns/examples/sdkconfig.ci.eth_custom_netif
+++ b/components/mdns/examples/sdkconfig.ci.eth_custom_netif
@ -6,6 +6,7 @@ CONFIG_MDNS_PREDEF_NETIF_STA=n
 CONFIG_MDNS_PREDEF_NETIF_AP=n
 CONFIG_MDNS_PREDEF_NETIF_ETH=n
 CONFIG_MDNS_ADD_CUSTOM_NETIF=y
+CONFIG_MDNS_RESPOND_REVERSE_QUERIES=y
 CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
 CONFIG_EXAMPLE_CONNECT_ETHERNET=y
 CONFIG_EXAMPLE_CONNECT_WIFI=n
--- a/components/mdns/idf_component.yml
+++ b/components/mdns/idf_component.yml
@ -1,4 +1,4 @@
-version: "1.0.7"
+version: "1.0.8"
 description: mDNS
 dependencies:
  idf:
--- a/components/mdns/include/mdns.h
+++ b/components/mdns/include/mdns.h
@ -34,6 +34,8 @@ typedef enum {
    MDNS_EVENT_ANNOUNCE_IP6                 = 1 << 4,
    MDNS_EVENT_DISABLE_IP4                  = 1 << 5,
    MDNS_EVENT_DISABLE_IP6                  = 1 << 6,
+    MDNS_EVENT_IP4_REVERSE_LOOKUP           = 1 << 7,
+    MDNS_EVENT_IP6_REVERSE_LOOKUP           = 1 << 8,
 } mdns_event_actions_t;

 /**
--- a/components/mdns/mdns.c
+++ b/components/mdns/mdns.c
@ -17,10 +17,13 @@
 #include "mdns_networking.h"
 #include "esp_log.h"
 #include "esp_random.h"
-#if CONFIG_ETH_ENABLED
+
+#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH
 #include "esp_eth.h"
 #endif
+#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP
 #include "esp_wifi.h"
+#endif


 #ifdef MDNS_ENABLE_DEBUG
@ -434,8 +437,11 @@ static const uint8_t *_mdns_read_fqdn(const uint8_t *packet, const uint8_t *star
            if (name->parts == 1 && buf[0] != '_'
                    && (strcasecmp(buf, MDNS_DEFAULT_DOMAIN) != 0)
                    && (strcasecmp(buf, "arpa") != 0)
+#ifndef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
                    && (strcasecmp(buf, "ip6") != 0)
-                    && (strcasecmp(buf, "in-addr") != 0)) {
+                    && (strcasecmp(buf, "in-addr") != 0)
+#endif
+               ) {
                strlcat(name->host, ".", sizeof(name->host));
                strlcat(name->host, buf, sizeof(name->host));
            } else if (strcasecmp(buf, MDNS_SUB_STR) == 0) {
@ -639,6 +645,60 @@ static inline int append_one_txt_record_entry(uint8_t *packet, uint16_t *index,
    return len + 1;
 }

+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+static inline int append_single_str(uint8_t *packet, uint16_t *index, const char *str, int len)
+{
+    if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) {
+        return 0;
+    }
+    if (!_mdns_append_u8(packet, index, len)) {
+        return 0;
+    }
+    memcpy(packet + *index, str, len);
+    *index += len;
+    return *index;
+}
+
+/**
+ * @brief  appends FQDN to a packet from hostname separated by dots. This API works the same way as
+ * _mdns_append_fqdn(), but refrains from DNS compression (as it's mainly used for IP addresses (many short items),
+ * where we gain very little (or compression even gets counter-productive mainly for IPv6 addresses)
+ *
+ * @param  packet       MDNS packet
+ * @param  index        offset in the packet
+ * @param  name         name representing FQDN in '.' separated parts
+ * @param  last         true if appending the last part (domain, typically "arpa")
+ *
+ * @return length of added data: 0 on error or length on success
+ */
+static uint16_t append_fqdn_dots(uint8_t *packet, uint16_t *index, const char *name, bool last)
+{
+    int len = strlen(name);
+    char *host = (char *)name;
+    char *end = host;
+    char *start = host;
+    do  {
+        end = memchr(start, '.', len);
+        end = end ? end : host + len;
+        int part_len = end - start;
+        if (!append_single_str(packet, index, start, part_len)) {
+            return 0;
+        }
+        start = ++end;
+    } while (end < name + len);
+
+    if (!append_single_str(packet, index, "arpa", sizeof("arpa") - 1)) {
+        return 0;
+    }
+
+    //empty string so terminate
+    if (!_mdns_append_u8(packet, index, 0)) {
+        return 0;
+    }
+    return *index;
+}
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
+
 /**
 * @brief  appends FQDN to a packet, incrementing the index and
 *         compressing the output if previous occurrence of the string (or part of it) has been found
@ -680,7 +740,7 @@ search_next:
        const uint8_t *content = _mdns_read_fqdn(packet, len_location, &name, buf, packet_len);
        if (!content) {
            //not a readable fqdn?
-            return 0;
+            goto search_next; // could be our unfinished fqdn, continue searching
        }
        if (name.parts == count) {
            uint8_t i;
@ -1100,25 +1160,34 @@ static uint16_t _mdns_append_aaaa_record(uint8_t *packet, uint16_t *index, const
 */
 static uint16_t _mdns_append_question(uint8_t *packet, uint16_t *index, mdns_out_question_t *q)
 {
-    const char *str[4];
-    uint8_t str_index = 0;
    uint8_t part_length;
-    if (q->host) {
-        str[str_index++] = q->host;
-    }
-    if (q->service) {
-        str[str_index++] = q->service;
-    }
-    if (q->proto) {
-        str[str_index++] = q->proto;
-    }
-    if (q->domain) {
-        str[str_index++] = q->domain;
-    }
-
-    part_length = _mdns_append_fqdn(packet, index, str, str_index, MDNS_MAX_PACKET_SIZE);
-    if (!part_length) {
-        return 0;
+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+    if (q->host && (strstr(q->host, "in-addr") || strstr(q->host, "ip6"))) {
+        part_length = append_fqdn_dots(packet, index, q->host, false);
+        if (!part_length) {
+            return 0;
+        }
+    } else
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
+    {
+        const char *str[4];
+        uint8_t str_index = 0;
+        if (q->host) {
+            str[str_index++] = q->host;
+        }
+        if (q->service) {
+            str[str_index++] = q->service;
+        }
+        if (q->proto) {
+            str[str_index++] = q->proto;
+        }
+        if (q->domain) {
+            str[str_index++] = q->domain;
+        }
+        part_length = _mdns_append_fqdn(packet, index, str, str_index, MDNS_MAX_PACKET_SIZE);
+        if (!part_length) {
+            return 0;
+        }
    }

    part_length += _mdns_append_u16(packet, index, q->type);
@ -1200,6 +1269,37 @@ static uint8_t _mdns_append_host_answer(uint8_t *packet, uint16_t *index, mdns_h
    return num_records;
 }

+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+/**
+ * @brief Appends reverse lookup PTR record
+ */
+static uint8_t _mdns_append_reverse_ptr_record(uint8_t *packet, uint16_t *index, const char *name)
+{
+    if (strstr(name, "in-addr") == NULL && strstr(name, "ip6") == NULL) {
+        return 0;
+    }
+
+    if (!append_fqdn_dots(packet, index, name, false)) {
+        return 0;
+    }
+
+    if (!_mdns_append_type(packet, index, MDNS_ANSWER_PTR, false, 10 /* TTL set to 10s*/ )) {
+        return 0;
+    }
+
+    uint16_t data_len_location = *index - 2; /* store the position of size (2=16bis) of this record */
+    const char *str[2] = { _mdns_self_host.hostname, MDNS_DEFAULT_DOMAIN };
+
+    int part_length = _mdns_append_fqdn(packet, index, str, 2, MDNS_MAX_PACKET_SIZE);
+    if (!part_length) {
+        return 0;
+    }
+
+    _mdns_set_u16(packet, data_len_location, part_length);
+    return 1; /* appending only 1 record */
+}
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
+
 /**
 * @brief  Append PTR answers to packet
 *
@ -1238,6 +1338,11 @@ static uint8_t _mdns_append_answer(uint8_t *packet, uint16_t *index, mdns_out_an
    if (answer->type == MDNS_TYPE_PTR) {
        if (answer->service) {
            return _mdns_append_service_ptr_answers(packet, index, answer->service, answer->flush, answer->bye);
+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+        } else if (answer->host && answer->host->hostname &&
+                   (strstr(answer->host->hostname, "in-addr") || strstr(answer->host->hostname, "ip6"))) {
+            return _mdns_append_reverse_ptr_record(packet, index, answer->host->hostname) > 0;
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
        } else {
            return _mdns_append_ptr_record(packet, index,
                                           answer->custom_instance, answer->custom_service, answer->custom_proto,
@ -1723,14 +1828,24 @@ static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_
                _mdns_free_tx_packet(packet);
                return;
            }
+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+        } else if (q->type == MDNS_TYPE_PTR) {
+            mdns_host_item_t *host = mdns_get_host_item(q->host);
+            if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, NULL, host, send_flush, false)) {
+                return;
+            }
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
        } else if (!_mdns_alloc_answer(&packet->answers, q->type, NULL, NULL, send_flush, false)) {
            _mdns_free_tx_packet(packet);
            return;
        }

-#ifdef MDNS_REPEAT_QUERY_IN_RESPONSE
        if (parsed_packet->src_port != MDNS_SERVICE_PORT &&  // Repeat the queries only for "One-Shot mDNS queries"
-                (q->type == MDNS_TYPE_ANY || q->type == MDNS_TYPE_A || q->type == MDNS_TYPE_AAAA)) {
+                (q->type == MDNS_TYPE_ANY || q->type == MDNS_TYPE_A || q->type == MDNS_TYPE_AAAA
+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+                 || q->type == MDNS_TYPE_PTR
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
+                )) {
            mdns_out_question_t *out_question = malloc(sizeof(mdns_out_question_t));
            if (out_question == NULL) {
                HOOK_MALLOC_FAILED;
@ -1751,7 +1866,6 @@ static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_
            out_question->own_dynamic_memory = true;
            queueToEnd(mdns_out_question_t, packet->questions, out_question);
        }
-#endif // MDNS_REPEAT_QUERY_IN_RESPONSE
        if (q->unicast) {
            unicast = true;
        }
@ -2936,10 +3050,10 @@ static bool _mdns_delegate_hostname_remove(const char *hostname)
 static bool _mdns_name_is_discovery(mdns_name_t *name, uint16_t type)
 {
    return (
-               (name->host && name->host[0] && !strcasecmp(name->host, "_services"))
-               && (name->service && name->service[0] && !strcasecmp(name->service, "_dns-sd"))
-               && (name->proto && name->proto[0] && !strcasecmp(name->proto, "_udp"))
-               && (name->domain && name->domain[0] && !strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN))
+               (name->host[0] && !strcasecmp(name->host, "_services"))
+               && (name->service[0] && !strcasecmp(name->service, "_dns-sd"))
+               && (name->proto[0] && !strcasecmp(name->proto, "_udp"))
+               && (name->domain[0] && !strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN))
               && type == MDNS_TYPE_PTR
           );
 }
@ -2950,7 +3064,11 @@ static bool _mdns_name_is_discovery(mdns_name_t *name, uint16_t type)
 static bool _mdns_name_is_ours(mdns_name_t *name)
 {
    //domain have to be "local"
-    if (_str_null_or_empty(name->domain) || strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN)) {
+    if (_str_null_or_empty(name->domain) || ( strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN)
+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+            && strcasecmp(name->domain, "arpa")
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
+                                            ) ) {
        return false;
    }

@ -3310,6 +3428,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet)
    mdns_debug_packet(data, len);
 #endif

+#ifndef CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES
    // Check if the packet wasn't sent by us
    if (packet->ip_protocol == MDNS_IP_PROTOCOL_V4) {
        esp_netif_ip_info_t if_ip_info;
@ -3326,6 +3445,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet)
        }
 #endif
    }
+#endif

    // Check for the minimum size of mdns packet
    if (len <=  MDNS_HEAD_ADDITIONAL_OFFSET) {
@ -3496,7 +3616,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet)
                discovery = true;
            } else if (!name->sub && _mdns_name_is_ours(name)) {
                ours = true;
-                if (name->service && name->service[0] && name->proto && name->proto[0]) {
+                if (name->service[0] && name->proto[0]) {
                    service = _mdns_get_service_item(name->service, name->proto, NULL);
                }
            } else {
@ -3660,7 +3780,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet)
                        }
                    }
                } else if (ours) {
-                    if (parsed_packet->questions && !parsed_packet->probe) {
+                    if (parsed_packet->questions && !parsed_packet->probe && service) {
                        _mdns_remove_parsed_question(parsed_packet, type, service);
                        continue;
                    }
@ -3847,6 +3967,13 @@ void _mdns_disable_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
    _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state = PCB_OFF;
 }

+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+static inline char nibble_to_hex(int var)
+{
+    return var > 9 ?  var - 10 + 'a' : var + '0';
+}
+#endif
+
 /**
 * @brief  Performs interface changes based on system events or custom commands
 */
@ -3873,6 +4000,48 @@ static void perform_event_action(mdns_if_t mdns_if, mdns_event_actions_t action)
    if (action & MDNS_EVENT_ANNOUNCE_IP6) {
        _mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V6, NULL, 0, true);
    }
+
+#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES
+    if (action & MDNS_EVENT_IP4_REVERSE_LOOKUP) {
+        esp_netif_ip_info_t if_ip_info;
+        if (esp_netif_get_ip_info(_mdns_get_esp_netif(mdns_if), &if_ip_info) == ESP_OK) {
+            esp_ip4_addr_t *ip = &if_ip_info.ip;
+            char *reverse_query_name = NULL;
+            if (asprintf(&reverse_query_name, "%d.%d.%d.%d.in-addr",
+                         esp_ip4_addr4_16(ip), esp_ip4_addr3_16(ip),
+                         esp_ip4_addr2_16(ip), esp_ip4_addr1_16(ip)) > 0 && reverse_query_name) {
+                ESP_LOGD(TAG, "Registered reverse query: %s.arpa", reverse_query_name);
+                _mdns_delegate_hostname_add(reverse_query_name, NULL);
+            }
+        }
+    }
+
+#ifdef CONFIG_LWIP_IPV6
+    if (action & MDNS_EVENT_IP6_REVERSE_LOOKUP) {
+        esp_ip6_addr_t addr6;
+        if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(mdns_if), &addr6) && !_ipv6_address_is_zero(addr6)) {
+            uint8_t *paddr = (uint8_t *)&addr6.addr;
+            const char sub[] = "ip6";
+            const size_t query_name_size = 4 * sizeof(addr6.addr) /* (2 nibbles + 2 dots)/per byte of IP address */ + sizeof(sub);
+            char *reverse_query_name = malloc(query_name_size);
+            if (reverse_query_name) {
+                char *ptr = &reverse_query_name[query_name_size];   // point to the end
+                memcpy(ptr - sizeof(sub), sub, sizeof(sub));        // copy the IP sub-domain
+                ptr -= sizeof(sub) + 1;                             // move before the sub-domain
+                while (reverse_query_name < ptr) {                  // continue populating reverse query from the end
+                    *ptr-- = '.';                                   // nibble by nibble, until we reach the beginning
+                    *ptr-- = nibble_to_hex(((*paddr) >> 4) & 0x0F);
+                    *ptr-- = '.';
+                    *ptr-- = nibble_to_hex((*paddr) & 0x0F);
+                    paddr++;
+                }
+                ESP_LOGD(TAG, "Registered reverse query: %s.arpa", reverse_query_name);
+                _mdns_delegate_hostname_add(reverse_query_name, NULL);
+            }
+        }
+    }
+#endif /* CONFIG_LWIP_IPV6 */
+#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */
 }

 /**
@ -3893,6 +4062,7 @@ static inline void post_mdns_announce_pcb(mdns_predef_if_t preset_if, mdns_ip_pr
    mdns_post_custom_action_tcpip_if(mdns_if_from_preset_if(preset_if), protocol == MDNS_IP_PROTOCOL_V4 ? MDNS_EVENT_ANNOUNCE_IP4 : MDNS_EVENT_ANNOUNCE_IP6);
 }

+#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH
 void mdns_preset_if_handle_system_event(void *arg, esp_event_base_t event_base,
                                        int32_t event_id, void *event_data)
 {
@ -3970,6 +4140,7 @@ void mdns_preset_if_handle_system_event(void *arg, esp_event_base_t event_base,
        }
    }
 }
+#endif /* CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH */

 /*
 * MDNS Search
@ -4646,7 +4817,7 @@ static void _mdns_execute_action(mdns_action_t *action)
        _mdns_server->hostname = action->data.hostname_set.hostname;
        _mdns_self_host.hostname = action->data.hostname_set.hostname;
        _mdns_restart_all_pcbs();
-        xTaskNotifyGive(action->data.hostname_set.calling_task);
+        xSemaphoreGive(_mdns_server->action_sema);
        break;
    case ACTION_INSTANCE_SET:
        _mdns_send_bye_all_pcbs_no_instance(false);
@ -4941,7 +5112,7 @@ static void _mdns_service_task(void *pvParameters)
    for (;;) {
        if (_mdns_server && _mdns_server->action_queue) {
            if (xQueueReceive(_mdns_server->action_queue, &a, portMAX_DELAY) == pdTRUE) {
-                if (a->type == ACTION_TASK_STOP) {
+                if (a && a->type == ACTION_TASK_STOP) {
                    break;
                }
                MDNS_SERVICE_LOCK();
@ -5189,6 +5360,12 @@ esp_err_t mdns_init(void)
        goto free_lock;
    }

+    _mdns_server->action_sema = xSemaphoreCreateBinary();
+    if (!_mdns_server->action_sema) {
+        err = ESP_ERR_NO_MEM;
+        goto free_queue;
+    }
+
 #if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP
    if ((err = esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event, NULL)) != ESP_OK) {
        goto free_event_handlers;
@ -5244,6 +5421,8 @@ free_all_and_disable_pcbs:
 free_event_handlers:
    unregister_predefined_handlers();
 #endif
+    vSemaphoreDelete(_mdns_server->action_sema);
+free_queue:
    vQueueDelete(_mdns_server->action_queue);
 free_lock:
    vSemaphoreDelete(_mdns_server->lock);
@ -5293,6 +5472,7 @@ void mdns_free(void)
        }
        free(h);
    }
+    vSemaphoreDelete(_mdns_server->action_sema);
    vSemaphoreDelete(_mdns_server->lock);
    free(_mdns_server);
    _mdns_server = NULL;
@ -5319,13 +5499,12 @@ esp_err_t mdns_hostname_set(const char *hostname)
    }
    action->type = ACTION_HOSTNAME_SET;
    action->data.hostname_set.hostname = new_hostname;
-    action->data.hostname_set.calling_task = xTaskGetCurrentTaskHandle();
    if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) {
        free(new_hostname);
        free(action);
        return ESP_ERR_NO_MEM;
    }
-    xTaskNotifyWait(0, 0x01, NULL, portMAX_DELAY);
+    xSemaphoreTake(_mdns_server->action_sema, portMAX_DELAY);
    return ESP_OK;
 }

@ -5398,7 +5577,7 @@ esp_err_t mdns_instance_name_set(const char *instance)
    if (!_mdns_server) {
        return ESP_ERR_INVALID_STATE;
    }
-    if (_str_null_or_empty(instance) || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) {
+    if (_str_null_or_empty(instance) || _mdns_server->hostname == NULL || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) {
        return ESP_ERR_INVALID_ARG;
    }
    char *new_instance = strndup(instance, MDNS_NAME_BUF_LEN - 1);
@ -6067,19 +6246,19 @@ void mdns_debug_packet(const uint8_t *data, size_t len)
    _mdns_dbg_printf("Packet[%u]: ", t);

    header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET);
-    header.flags.value = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET);
+    header.flags = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET);
    header.questions = _mdns_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET);
    header.answers = _mdns_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET);
    header.servers = _mdns_read_u16(data, MDNS_HEAD_SERVERS_OFFSET);
    header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET);

    _mdns_dbg_printf("%s",
-                     (header.flags.value == MDNS_FLAGS_QR_AUTHORITATIVE) ? "AUTHORITATIVE\n" :
-                     (header.flags.value == MDNS_FLAGS_DISTRIBUTED) ? "DISTRIBUTED\n" :
-                     (header.flags.value == 0) ? "\n" : " "
+                     (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE) ? "AUTHORITATIVE\n" :
+                     (header.flags == MDNS_FLAGS_DISTRIBUTED) ? "DISTRIBUTED\n" :
+                     (header.flags == 0) ? "\n" : " "
                    );
-    if (header.flags.value && header.flags.value != MDNS_FLAGS_QR_AUTHORITATIVE) {
-        _mdns_dbg_printf("0x%04X\n", header.flags.value);
+    if (header.flags && header.flags != MDNS_FLAGS_QR_AUTHORITATIVE) {
+        _mdns_dbg_printf("0x%04X\n", header.flags);
    }

    if (header.questions) {
--- a/components/mdns/private_include/mdns_private.h
+++ b/components/mdns/private_include/mdns_private.h
@ -14,34 +14,13 @@
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
 #include "esp_timer.h"
+#include "esp_system.h"

-//#define MDNS_ENABLE_DEBUG
-
-#ifdef MDNS_ENABLE_DEBUG
+#ifdef CONFIG_MDNS_ENABLE_DEBUG_PRINTS
+#define MDNS_ENABLE_DEBUG
 #define _mdns_dbg_printf(...) printf(__VA_ARGS__)
 #endif

-/** mDNS strict mode: Set this to 1 for the mDNS library to strictly follow the RFC6762:
- * Strict features:
- *   - to do not set original questions in response packets per RFC6762, sec 6
- *
- * The actual configuration is 0, i.e. non-strict mode, since some implementations,
- * such as lwIP mdns resolver (used by standard POSIX API like getaddrinfo, gethostbyname)
- * could not correctly resolve advertised names.
- */
-#ifndef CONFIG_MDNS_STRICT_MODE
-#define MDNS_STRICT_MODE 0
-#else
-#define MDNS_STRICT_MODE 1
-#endif
-
-#if !MDNS_STRICT_MODE
-/* mDNS responders sometimes repeat queries in responses
- * but according to RFC6762, sec 6: Responses MUST NOT contain
- * any item in question field */
-#define  MDNS_REPEAT_QUERY_IN_RESPONSE 1
-#endif
-
 /** Number of predefined interfaces */
 #ifndef CONFIG_MDNS_PREDEF_NETIF_STA
 #define CONFIG_MDNS_PREDEF_NETIF_STA 0
@ -110,7 +89,11 @@
 #define MDNS_PACKET_QUEUE_LEN       16                      // Maximum packets that can be queued for parsing
 #define MDNS_ACTION_QUEUE_LEN       16                      // Maximum actions pending to the server
 #define MDNS_TXT_MAX_LEN            1024                    // Maximum string length of text data in TXT record
+#if defined(CONFIG_LWIP_IPV6) && defined(CONFIG_MDNS_RESPOND_REVERSE_QUERIES)
+#define MDNS_NAME_MAX_LEN           (64+4)                  // Need to account for IPv6 reverse queries (64 char address  + ".ip6" )
+#else
 #define MDNS_NAME_MAX_LEN           64                      // Maximum string length of hostname, instance, service and proto
+#endif
 #define MDNS_NAME_BUF_LEN           (MDNS_NAME_MAX_LEN+1)   // Maximum char buffer size to hold hostname, instance, service or proto
 #define MDNS_MAX_PACKET_SIZE        1460                    // Maximum size of mDNS  outgoing packet

@ -401,6 +384,7 @@ typedef struct mdns_server_s {
    mdns_srv_item_t *services;
    SemaphoreHandle_t lock;
    QueueHandle_t action_queue;
+    SemaphoreHandle_t action_sema;
    mdns_tx_packet_t *tx_queue_head;
    mdns_search_once_t *search_once;
    esp_timer_handle_t timer_handle;
@ -411,7 +395,6 @@ typedef struct {
    union {
        struct {
            char *hostname;
-            TaskHandle_t calling_task;
        } hostname_set;
        char *instance;
        struct {
--- a/components/mdns/tests/host_test/CMakeLists.txt
+++ b/components/mdns/tests/host_test/CMakeLists.txt
@ -1,5 +1,7 @@
 cmake_minimum_required(VERSION 3.5)

+set(EXTRA_COMPONENT_DIRS "../..")
+
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-set(COMPONENTS main)
+set(COMPONENTS main esp_netif_linux)
 project(mdns_host)
--- a/components/mdns/tests/host_test/README.md
+++ b/components/mdns/tests/host_test/README.md
@ -1,7 +1,10 @@
 # Setup dummy network interfaces
+
+Note: Set two addresses so we could use one as source and another as destination
 ```
 sudo ip link add eth2 type dummy
 sudo ip addr add 192.168.1.200/24 dev eth2
+sudo ip addr add 192.168.1.201/24 dev eth2
 sudo ip link set eth2 up
 sudo ifconfig eth2 multicast
 ```
@ -12,6 +15,11 @@ sudo ifconfig eth2 multicast
 dig +short -b 192.168.1.200 -p 5353 @224.0.0.251 myesp.local
 ```

+or a reverse query:
+```
+dig +short -b 192.168.2.200 -p 5353 @224.0.0.251 -x 192.168.1.200
+```
+
 # Run avahi to browse services

 Avahi needs the netif to have the "multicast" flag set
--- a/components/mdns/tests/host_test/components/esp_event/CMakeLists.txt
+++ b/components/mdns/tests/host_test/components/esp_event/CMakeLists.txt
@ -0,0 +1,2 @@
+idf_component_register(SRCS esp_event_mock.c
+                       INCLUDE_DIRS include)
--- a/components/mdns/tests/host_test/components/esp_event_mock/esp_event_mock.c
+++ b/components/mdns/tests/host_test/components/esp_event_mock/esp_event_mock.c
--- a/components/mdns/tests/host_test/components/esp_event_mock/include/esp_event.h
+++ b/components/mdns/tests/host_test/components/esp_event_mock/include/esp_event.h
@ -8,16 +8,7 @@
 #include "stdbool.h"
 #include "esp_err.h"
 #include "esp_event_base.h"
-#include "bsd_strings.h"
-
-#define ESP_EVENT_DECLARE_BASE(x)
-#define ESP_EVENT_ANY_ID       (-1)
-
-typedef void *esp_event_base_t;
-typedef void *system_event_t;
-
-const char *WIFI_EVENT;
-const char *IP_EVENT;
+#include "bsd/string.h"

 esp_err_t esp_event_handler_register(const char *event_base, int32_t event_id, void *event_handler, void *event_handler_arg);

--- a/components/mdns/tests/host_test/components/esp_event_mock/include/esp_event_base.h
+++ b/components/mdns/tests/host_test/components/esp_event_mock/include/esp_event_base.h
@ -11,3 +11,9 @@ typedef enum {
    WIFI_EVENT_AP_START,                 /**< ESP32 soft-AP start */
    WIFI_EVENT_AP_STOP,                  /**< ESP32 soft-AP stop */
 } mdns_used_event_t;
+
+#define ESP_EVENT_DECLARE_BASE(x)
+#define ESP_EVENT_ANY_ID       (-1)
+
+typedef void *esp_event_base_t;
+typedef void *system_event_t;
--- a/components/mdns/tests/host_test/components/esp_event_mock/CMakeLists.txt
+++ b/components/mdns/tests/host_test/components/esp_event_mock/CMakeLists.txt
@ -1,3 +0,0 @@
-idf_component_register(SRCS esp_event_mock.c
-                       INCLUDE_DIRS include
-                       REQUIRES esp_system_protocols_linux)
--- a/components/mdns/tests/host_test/components/esp_netif_linux/CMakeLists.txt
+++ b/components/mdns/tests/host_test/components/esp_netif_linux/CMakeLists.txt
@ -1,3 +1,3 @@
 idf_component_register(SRCS esp_netif_linux.c
-                       INCLUDE_DIRS include
-                       REQUIRES esp_system_protocols_linux)
+                       INCLUDE_DIRS include $ENV{IDF_PATH}/components/esp_netif/include
+                       REQUIRES esp_event)
--- a/components/mdns/tests/host_test/components/esp_netif_linux/esp_netif_linux.c
+++ b/components/mdns/tests/host_test/components/esp_netif_linux/esp_netif_linux.c
@ -50,9 +50,7 @@ esp_err_t esp_netif_get_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_
            struct sockaddr_in *pAddr = (struct sockaddr_in *) tmp->ifa_addr;
            inet_ntop(AF_INET, &pAddr->sin_addr, addr, sizeof(addr) );
            if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) {
-                printf("AF_INET: %s: %s\n", tmp->ifa_name, addr);
                memcpy(&ip_info->ip.addr, &pAddr->sin_addr, 4);
-                break;
            }
        }
        tmp = tmp->ifa_next;
--- a/components/mdns/tests/host_test/components/esp_system_protocols_linux/include/machine/endian.h
+++ b/components/mdns/tests/host_test/components/esp_system_protocols_linux/include/machine/endian.h
--- a/components/mdns/tests/host_test/components/esp_system_protocols_linux/CMakeLists.txt
+++ b/components/mdns/tests/host_test/components/esp_system_protocols_linux/CMakeLists.txt
@ -1,3 +0,0 @@
-idf_component_register(SRCS esp_log_impl.c strlcat.c
-                       INCLUDE_DIRS include
-                       REQUIRES esp_netif_linux esp_timer_linux freertos_linux esp_event_mock esp_netif log esp_common)
--- a/components/mdns/tests/host_test/components/esp_system_protocols_linux/esp_log_impl.c
+++ b/components/mdns/tests/host_test/components/esp_system_protocols_linux/esp_log_impl.c
@ -1,27 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#include "esp_err.h"
-#include "esp_log.h"
-#include <stdlib.h>
-
-void _esp_error_check_failed(esp_err_t rc, const char *file, int line, const char *function, const char *expression)
-{
-    ESP_LOGE("ESP_ERROR_CHECK", "Failed with esp_err_t: 0x%x", rc);
-    ESP_LOGE("ESP_ERROR_CHECK", "Expression: %s", expression);
-    ESP_LOGE("ESP_ERROR_CHECK", "Functions: %s %s(%d)", function, file, line);
-    abort();
-}
-
-void esp_log_buffer_hexdump_internal(const char *tag, const void *buffer, uint16_t buff_len, esp_log_level_t log_level)
-{
-    if ( LOG_LOCAL_LEVEL >= log_level ) {
-        ESP_LOG_LEVEL(log_level, tag, "Buffer:%p length:%d", buffer, buff_len);
-        for (int i = 0; i < buff_len; ++i) {
-            printf("%02x ", ((uint8_t *)buffer)[i]);
-        }
-        printf("\n");
-    }
-}
--- a/components/mdns/tests/host_test/components/esp_system_protocols_linux/include/bsd_strings.h
+++ b/components/mdns/tests/host_test/components/esp_system_protocols_linux/include/bsd_strings.h
@ -1,8 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#pragma once
-
-size_t strlcat(char *dest, const char *src, size_t size);
--- a/components/mdns/tests/host_test/components/esp_system_protocols_linux/strlcat.c
+++ b/components/mdns/tests/host_test/components/esp_system_protocols_linux/strlcat.c
@ -1,70 +0,0 @@
-/*  $OpenBSD: strlcat.c,v 1.2 1999/06/17 16:28:58 millert Exp $ */
-
-/*-
- * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
- * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "string.h"
-
-/*
- * Appends src to string dst of size siz (unlike strncat, siz is the
- * full size of dst, not space left).  At most siz-1 characters
- * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
- * Returns strlen(src) + MIN(siz, strlen(initial dst)).
- * If retval >= siz, truncation occurred.
- */
-size_t
-strlcat(dst, src, siz)
-char *dst;
-const char *src;
-size_t siz;
-{
-    char *d = dst;
-    const char *s = src;
-    size_t n = siz;
-    size_t dlen;
-
-    /* Find the end of dst and adjust bytes left but don't go past end */
-    while (n-- != 0 && *d != '\0') {
-        d++;
-    }
-    dlen = d - dst;
-    n = siz - dlen;
-
-    if (n == 0) {
-        return (dlen + strlen(s));
-    }
-    while (*s != '\0') {
-        if (n != 1) {
-            *d++ = *s;
-            n--;
-        }
-        s++;
-    }
-    *d = '\0';
-
-    return (dlen + (s - src));  /* count does not include NUL */
-}
--- a/components/mdns/tests/host_test/components/esp_timer_linux/CMakeLists.txt
+++ b/components/mdns/tests/host_test/components/esp_timer_linux/CMakeLists.txt
@ -1,6 +1,6 @@
 idf_component_register(SRCS esp_timer_linux.c timer_task.cpp
                       INCLUDE_DIRS include
-                       REQUIRES esp_system_protocols_linux freertos_linux)
+                       REQUIRES esp_event)

 set_target_properties(${COMPONENT_LIB} PROPERTIES
    CXX_STANDARD 17
--- a/components/mdns/tests/host_test/components/esp_timer_linux/timer_task.hpp
+++ b/components/mdns/tests/host_test/components/esp_timer_linux/timer_task.hpp
@ -16,7 +16,7 @@ typedef void (*cb_t)(void *arg);

 class TimerTaskMock {
 public:
-    TimerTaskMock(cb_t cb): cb(cb), t(run_static, this), active(false), ms(INT32_MAX) {}
+    TimerTaskMock(cb_t cb): cb(cb), active(false), ms(INT32_MAX) {}
    ~TimerTaskMock(void)
    {
        active = false;
@ -27,6 +27,7 @@ public:
    {
        ms = m;
        active = true;
+        t = std::thread(run_static, this);
    }

 private:
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Euripedes Rocha	1407dfc2e7	Adds esp_mqtt_cxx component - Component moved from esp-idf - Files moved to adjust to esp-protocol structure	2023-02-16 09:59:46 +01:00
Ivan Grokhotkov	34c6f52f70	build system: re-add -Wno-format as private flag for some example components	2023-02-15 10:26:19 +01:00
Euripedes Rocha	c674b8855d	[MQTT] - Updates esp_mqtt configuration struct - Layered config struct - Fix examples.	2023-02-15 10:26:19 +01:00
Fu Hanxi	256389613f	docs: changes docs supported targets tables	2023-02-15 10:26:19 +01:00
Ivan Grokhotkov	2865255ec0	examples, components: remove C/C++ standard overrides ...where they are not necessary after switching to C17 and C++20.	2023-02-15 10:26:19 +01:00
Michael (XIAO Xufeng)	7b2470ddd6	ci: partially enable example build for esp32c2	2023-02-15 10:26:19 +01:00
Djordje Nedic	dda2722563	tools: Increase the minimal supported CMake version to 3.16 This updates the minimal supported version of CMake to 3.16, which in turn enables us to use more CMake features and have a cleaner build system. This is the version that provides most new features and also the one we use in our latest docker image for CI.	2023-02-15 10:26:19 +01:00
Anton Maklakov	36db37ea2b	examples/cxx: add missing header	2023-02-15 10:26:19 +01:00
Roland Dobai	4f013e3522	Build & config: Remove leftover files from the unsupported "make" build system	2023-02-15 10:26:19 +01:00
Euripedes Rocha Filho	231392d0c6	experimental/mqtt_cxx: Adds a C++ Mqtt client wrapper - Base class with separated event handlers for each Mqtt client event. - Topic matcher added to support data events. - Filter class to allow only mqtt valid topic filters. - Initial code for unit test on the host.	2023-02-15 10:26:19 +01:00
david-cermak	9fb01ca534	Merge pull request #219 from david-cermak/feat/mdns_reverse_query_ip6 feat(mdns): Add support for IPv6 reverse query	2023-02-15 08:07:17 +01:00
David Cermak	d464ed7d30	feat(mdns): Add reverse lookup to the example and test	2023-02-15 07:48:04 +01:00
david-cermak	b94a211e4b	Merge pull request #222 from boborjan2/mdns_task_notification components/mdns: use semaphore instead of task notification bits (IDFGH-9380) (IDFGH-9388)	2023-02-15 07:12:26 +01:00
Viktor Babrian	73f2800b59	components/mdns: use semaphore instead of task notification bits (IDFGH-9380) Component should not alter the task notification bits of the calling task.	2023-02-14 11:43:02 +01:00
Suren	e00e056162	Merge pull request #215 from ESP-YJM/feat/add_auth_for_websocket websocket: Support HTTP basic authorization	2023-02-10 17:29:31 +04:00
yuanjianmin	1b134486db	websocket: Support HTTP basic authorization	2023-02-09 15:09:40 +08:00
david-cermak	7ba1085e9f	Merge pull request #32 from 0xFEEDC0DE64/websocketclient-errormsg Add websocket client error message string (IDFGH-7591)	2023-02-08 16:11:38 +01:00
david-cermak	3bdb2067e0	Merge pull request #218 from 0xFEEDC0DE64/add_task_name Add task_name config option (for websocket client) (IDFGH-9346)	2023-02-08 16:10:05 +01:00
0xFEEDC0DE64	1d6888445d	Add task_name config option	2023-02-08 15:52:03 +01:00
0xFEEDC0DE64	d68624ec4f	Add websocket error messages	2023-02-08 15:35:01 +01:00
David Cermak	d4825f5c53	feat(mdns): Add support for IPv6 reverse query Implements reverse querries together with `b87bef52e5` (IPv4) Closes https://github.com/espressif/esp-protocols/issues/101	2023-02-07 20:16:26 +01:00
david-cermak	de1480a072	Merge pull request #217 from david-cermak/mdns/bump_component_version mdns: bump the component version to 1.0.8	2023-02-06 20:13:17 +01:00
David Cermak	b9b4a75000	mdns: bump the component version to 1.0.8	2023-02-06 15:43:01 +01:00
david-cermak	cc259aa035	Merge pull request #203 from david-cermak/feat/mdns_reverse_query feat(mdns): Add support for IPv4 reverse query	2023-02-03 15:21:38 +01:00
David Cermak	91134f10ff	mdns: Make reverse query conditional per Kconfig and auto-register reverse logical names	2023-02-02 10:32:01 +01:00
David Cermak	fb8a2f0198	fix(mdns): Host test with IDFv5.1	2023-02-02 10:31:01 +01:00
David Cermak	b87bef52e5	feat(mdns): Add support for IPv4 reverse query Partially addresses https://github.com/espressif/esp-protocols/issues/101	2023-02-02 10:31:00 +01:00
Suren	28813148b2	Merge pull request #211 from gabsuren/websocket/add_new_api_esp_destroy_selected websocket: Added new API `esp_websocket_client_destroy_on_exit` (IDF-6458)	2023-02-01 18:00:30 +04:00
david-cermak	ae38f27997	Merge pull request #206 from david-cermak/bugfix/mdns_unit_tests fix(mdns): Make unit test executable with pytest	2023-02-01 12:28:52 +01:00
David Cermak	d0c9070715	fix(mdns): Remove strict mode as it's invalid Strict mode was introduced to support "one-shot" queries (described in RFC6762/sec5.1) that are sent by lwip or dig. It was incorrectly assumed that responding to such queries violates the spec, as we have to repeat queries in responces, which is forbidden in RFC6762/sec6. It is however required to repeat query fields according to the Section 6.7. Legacy Unicast Responses: "it MUST repeat the query ID and the question given in the query message."	2023-01-31 16:06:52 +01:00
David Cermak	a8339e4618	fix(mdns): Allow setting instance name only after hostname set Closes https://github.com/espressif/esp-protocols/issues/190	2023-01-31 16:06:52 +01:00
David Cermak	12cfcb5aed	fix(mdns): Make unit test executable with pytest	2023-01-31 16:06:52 +01:00
david-cermak	2cfffb056e	Merge pull request #214 from david-cermak/bugfix/modem_cxx_broken_components fix(esp_modem): Fix cmux client compilation issue	2023-01-31 14:42:46 +01:00
David Cermak	0247926219	fix(mdns): AFL port layer per IDF-latest changes	2023-01-31 11:15:06 +01:00
David Cermak	05fff94b91	update(esp_modem): Bump component version to 0.1.26 Closes https://github.com/espressif/esp-protocols/issues/213 Closes https://github.com/espressif/esp-protocols/issues/212	2023-01-31 11:02:52 +01:00
David Cermak	8958d5e37c	fix(esp-modem): Example to use variable mqtt topic/data This example is used in the CI with public broker and users playing with the example can influence stability of tests if we share the same topic id	2023-01-31 11:02:52 +01:00
David Cermak	f71192b876	fix(esp_modem): Fix cmux client compilation issue Removed dependency on esp_event_cxx	2023-01-30 15:30:48 +01:00
Suren Gabrielyan	f9b47900f2	websocket: Added new API `esp_websocket_client_destroy_on_exit`	2023-01-24 22:29:09 +04:00
term-est	0e215b118f	Added the missing definition for the esp_modem_set_baud function (IDFGH-9181) (#209 ) fix(esp_modem): Added the missing definition for the esp_modem_set_baud function	2023-01-19 13:57:06 +01:00
Suren	dc8b916561	Merge pull request #205 from gabsuren/docs/fix_documentation docs: Disable code coverage report publishing to Github Pages	2023-01-13 17:54:04 +04:00
Suren Gabrielyan	a01096f621	docs: Disable code coverage report publishing to Github Pages	2023-01-13 17:30:33 +04:00
david-cermak	3de4727385	Merge pull request #202 from gabsuren/CI/minor_fix_ci CI: minor fix of host test *yml file	2023-01-12 20:02:12 +01:00
Suren Gabrielyan	59053b8c98	CI: minor fix of host test *yml file	2023-01-09 22:09:53 +04:00
david-cermak	2956477353	Merge pull request #196 from gabsuren/CI/gcovr_analyser CI: Added coverage analyzer for esp_modem host tests	2023-01-09 14:09:11 +01:00
david-cermak	1d9b6f7e90	Merge pull request #199 from franz-ms-muc/patch-1 Update esp_modem_command_library.cpp (IDFGH-9018)	2023-01-04 12:30:45 +01:00
Suren Gabrielyan	6b684ceb0f	CI: Added coverage analyzer for esp_modem host tests	2022-12-30 13:11:59 +04:00
franz-ms-muc	5304a6ec0e	Update esp_modem_command_library.cpp AT+IFC=2,2 instead AT+IFC=2, 2	2022-12-22 11:55:37 +01:00
Suren	c7f20ee98e	Merge pull request #191 from gabsuren/CI/refactor_yml_files CI: Minor refactoring of *yml files for the target tests	2022-12-16 11:32:14 +04:00
david-cermak	7d47ec3b6b	Merge pull request #192 from XDanielPaul/master Added badges with version of components to the respective README files (IDFGH-8940)	2022-12-14 12:47:48 +01:00
Daniel Paul	e4c8a5932c	Added badges with version of components to the respective README files	2022-12-12 18:13:04 +01:00
Suren Gabrielyan	b56b1c577b	CI: Minor refactoring of *yml files for target tests	2022-12-12 12:31:44 +04:00
david-cermak	4e212c31fe	Merge pull request #182 from david-cermak/feat/modem_target_test feat(esp_modem): Added target test	2022-12-09 15:26:26 +01:00
David Cermak	9a7bd90ad9	fix(esp_modem): Exit data mode only after state change Previously, we set the notification also for event causing permature PPP mode exit	2022-12-01 18:35:06 +01:00
David Cermak	4314c78ca0	feat(esp_modem): Added target test	2022-12-01 18:35:01 +01:00
david-cermak	457f8335bb	Merge pull request #169 from david-cermak/feat/modem_dce_on_read fix(esp-modem): Extend CMUX mode to support manual transitions	2022-11-23 20:24:26 +01:00
david-cermak	42565ff5d7	Merge pull request #177 from gabsuren/CI/asio_fix CI: Fix ASIO example test	2022-11-23 20:23:20 +01:00
Suren Gabrielyan	6e2bb518fd	CI: Fix ASIO example test	2022-11-23 19:07:26 +04:00
David Cermak	2180ab17d8	fix(esp-modem): Support AT with callback in C-API Closes https://github.com/espressif/esp-protocols/issues/143	2022-11-21 14:58:15 +01:00
David Cermak	ac5d43882b	feat(esp-modem): Add support for manual CMUX operations Closes https://github.com/espressif/esp-protocols/issues/168	2022-11-21 14:58:15 +01:00
david-cermak	3f0262dfe5	Merge pull request #176 from gabsuren/CI/flake_use_github CI: Updated flake8 to use github repo	2022-11-21 14:41:43 +01:00
Suren Gabrielyan	74787c9aa8	CI: Updated flake8 to use github repo	2022-11-21 16:31:20 +04:00
david-cermak	045009bb82	Merge pull request #173 from mahavirj/bugfix/some_issue_with_coverity_scan mdns: fix some coverity reported issues	2022-11-07 15:11:08 +01:00
david-cermak	79c11e9ecd	Merge pull request #171 from gabsuren/feature/make_public_websocket_client_send_with_opcode websocket: make `esp_websocket_client_send_with_opcode` a public API (IDFGH-6937)	2022-11-07 14:28:36 +01:00
Mahavir Jain	c73c797595	mdns: fix some coverity reported issues - Array compared against 0 NO_EFFECT - dereference null pointer, FORWARD_NULL check	2022-11-07 18:38:06 +05:30
david-cermak	1547aa8c03	Merge pull request #166 from espressif-abhikroy/esp_modem/power_saving_mode esp_modem/examples: Added example Power Saving Mode(PSM) in LTE modem.	2022-11-07 08:36:30 +01:00
Abhik Roy	1ca139109a	esp_modem/examples: Add an example to synchronise PSM sleep in Sim70XX modem and esp32. This example enables Power saving mode in Sim70XX modem and tries to synchronise the sleep cycle of the modem with esp32. When the modem wakes up from PSM sleep it wakes up the esp32. While the modem is awake esp32 is set to light sleep. Closes: https://github.com/espressif/esp-protocols/issues/54	2022-11-06 18:52:50 +05:30