Merge pull request #372 from espressif-abhikroy/components/console_simple_init

feat(common): Added simple component for console initialization

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

@@ -13,7 +13,7 @@ jobs:
     name: Build
     strategy:
       matrix:
-        idf_ver: ["latest", "release-v5.0"]
+        idf_ver: ["latest", "release-v5.0", "release-v5.1"]
         idf_target: ["esp32", "esp32s2"]
         example: ["asio_chat", "async_request", "socks4", "ssl_client_server", "tcp_echo_server", "udp_echo_server"]
     runs-on: ubuntu-20.04

.github/workflows/console_simple_init__build.yml

@@ -0,0 +1,32 @@
+name: "console_simple_init: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_console_simple_init:
+    if: contains(github.event.pull_request.labels.*.name, 'console') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.0"]
+        idf_target: ["esp32"]
+        test: [ { app: example, path: "components/console_simple_init/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

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

@@ -22,6 +22,8 @@ jobs:
             example: modem_tcp_client
           - idf_ver: "release-v4.3"
             example: modem_tcp_client
+          - idf_ver: "release-v4.4"
+            example: modem_tcp_client
         include:
           - idf_ver: "release-v4.2"
             skip_config: usb
@@ -62,7 +64,7 @@ jobs:
       COMP_DIR: esp-protocols/components/esp_modem
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@master
+        uses: actions/checkout@v3
         with:
           path: esp-protocols
 
@@ -109,7 +111,6 @@ jobs:
       - 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
@@ -129,9 +130,9 @@ jobs:
           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
-          cp -rf docs_gcovr $GITHUB_WORKSPACE
+          mkdir modem_coverage_report
+          cp $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/index.html modem_coverage_report
+          cp -rf modem_coverage_report $GITHUB_WORKSPACE
       - name: Code Coverage Summary Report
         uses: irongut/CodeCoverageSummary@v1.3.0
         with:
@@ -151,13 +152,7 @@ jobs:
         uses: actions/upload-artifact@v3
         if: always()
         with:
-          name: docs_gcovr
+          name: modem_coverage_report
           path: |
-            ${{ env.COMP_DIR }}/docs_gcovr
+            ${{ env.COMP_DIR }}/modem_coverage_report
           if-no-files-found: error
-      - name: Deploy code coverage results
-        if: github.ref == 'refs/heads/master'
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./docs_gcovr

.github/workflows/modem__target-test.yml

@@ -15,7 +15,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client } ]
+        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
     runs-on: ubuntu-20.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
@@ -54,7 +54,7 @@ jobs:
       matrix:
         idf_ver: ["latest"]
         idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client } ]
+        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client }, { app: sim800_cmux, path: examples/simple_cmux_client } ]
     needs: build_esp_modem_tests
     runs-on:
       - self-hosted

.github/workflows/publish-coverage-report.yml

@@ -0,0 +1,45 @@
+name: Publish coverage report to Github Pages
+
+on:
+  workflow_run:
+    workflows: ["websocket: build/host-tests", "esp-modem: build/host-tests"]
+    types:
+      - completed
+    branches:
+      - master
+
+jobs:
+  publish_github_pages:
+    runs-on: ubuntu-latest
+    if: github.repository == 'espressif/esp-protocols'
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+      - name: Download Websocket Artifact
+        uses: dawidd6/action-download-artifact@v2
+        with:
+          workflow: websocket__build-host-tests.yml
+          workflow_conclusion: success
+          name: websocket_coverage_report
+          path: websocket_coverage_report_artifact
+      - name: Download Modem Artifact
+        uses: dawidd6/action-download-artifact@v2
+        with:
+          workflow: modem__build-host-tests.yml
+          workflow_conclusion: success
+          name: modem_coverage_report
+          path: modem_coverage_report_artifact
+      - name: Merge HTML files
+        run: |
+          echo "<html><body>" > index.html
+          cat modem_coverage_report_artifact/index.html >> index.html
+          cat websocket_coverage_report_artifact/index.html >> index.html
+          echo "</body></html>" >> index.html
+          mkdir coverage_report
+          mv index.html coverage_report
+
+      - name: Deploy generated docs
+        uses: JamesIves/github-pages-deploy-action@4.1.5
+        with:
+          branch: gh-pages
+          folder: coverage_report

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

@@ -89,5 +89,6 @@ jobs:
             components/esp_mqtt_cxx;
             components/esp_websocket_client;
             components/mdns;
+            components/console_simple_init;
           namespace: "espressif"
           api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}

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

@@ -0,0 +1,86 @@
+name: Run on host
+
+on:
+    workflow_call:
+        inputs:
+            idf_version:
+                required: true
+                type: string
+            app_name:
+                type: string
+                required: true
+            app_path:
+                type: string
+                required: true
+            component_path:
+                type: string
+                required: true
+            upload_artifacts:
+                type: boolean
+                required: true
+
+jobs:
+  build:
+      name: Build App
+      runs-on: ubuntu-20.04
+      permissions:
+        contents: write
+      container: espressif/idf:${{inputs.idf_version}}
+      steps:
+        - name: Checkout esp-protocols
+          uses: actions/checkout@v3
+          with:
+            path: esp-protocols
+        - name: Build ${{ inputs.app_name }} with IDF-${{ inputs.idf_version }}
+          shell: bash
+          run: |
+            . ${IDF_PATH}/export.sh
+            cd $GITHUB_WORKSPACE/${{inputs.app_path}}
+            rm -rf sdkconfig sdkconfig.defaults build
+            cp sdkconfig.ci.linux sdkconfig.defaults
+            idf.py build
+            ./build/${{inputs.app_name}}.elf
+        - name: Build with Coverage Enabled
+          shell: bash
+          run: |
+            . ${IDF_PATH}/export.sh
+            cd $GITHUB_WORKSPACE/${{inputs.app_path}}
+            rm -rf build sdkconfig sdkconfig.defaults
+            cp sdkconfig.ci.coverage sdkconfig.defaults
+            idf.py fullclean
+            idf.py build
+            ./build/${{inputs.app_name}}.elf
+        - name: Run Coverage
+          shell: bash
+          run: |
+            apt-get update && apt-get install -y python3-pip rsync
+            python -m pip install gcovr
+            cd $GITHUB_WORKSPACE/${{inputs.component_path}}
+            gcov `find . -name "*gcda"`
+            gcovr --gcov-ignore-parse-errors -g -k -r . --html index.html -x ${{inputs.app_name}}_coverage.xml
+            mkdir ${{inputs.app_name}}_coverage_report
+            touch ${{inputs.app_name}}_coverage_report/.nojekyll
+            cp index.html ${{inputs.app_name}}_coverage_report
+            cp -rf ${{inputs.app_name}}_coverage_report ${{inputs.app_name}}_coverage.xml $GITHUB_WORKSPACE
+        - name: Code Coverage Summary Report
+          uses: irongut/CodeCoverageSummary@v1.3.0
+          with:
+            filename: esp-protocols/**/${{inputs.app_name}}_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 files to artifacts for run-target job
+          uses: actions/upload-artifact@v3
+          if: ${{inputs.upload_artifacts}}
+          with:
+            name: ${{inputs.app_name}}_coverage_report
+            path: |
+              ${{inputs.component_path}}/${{inputs.app_name}}_coverage_report
+            if-no-files-found: error

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

@@ -0,0 +1,20 @@
+name: "websocket: build/host-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+
+jobs:
+  host_test_websocket:
+    if: contains(github.event.pull_request.labels.*.name, 'websocket') || github.event_name == 'push'
+    uses: "./.github/workflows/run-host-tests.yml"
+    with:
+        idf_version: "latest"
+        app_name: "websocket"
+        app_path: "esp-protocols/components/esp_websocket_client/examples/linux"
+        component_path: "esp-protocols/components/esp_websocket_client"
+        upload_artifacts: true

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

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         idf_ver: ["release-v5.0", "release-v5.1", "latest"]
-        test: [ { app: example, path: "examples" }, { app: unit_test, path: "test" } ]
+        test: [ { app: example, path: "examples/target" }, { app: unit_test, path: "test" } ]
     runs-on: ubuntu-20.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
@@ -53,7 +53,7 @@ jobs:
       matrix:
         idf_ver: ["release-v5.0", "release-v5.1", "latest"]
         idf_target: ["esp32"]
-        test: [ { app: example, path: "examples" }, { app: unit_test, path: "test" } ]
+        test: [ { app: example, path: "examples/target" }, { app: unit_test, path: "test" } ]
     runs-on:
       - self-hosted
       - ESP32-ETHERNET-KIT

.pre-commit-config.yaml

@@ -43,7 +43,7 @@ repos:
     hooks:
       - id: eradicate
   - repo: https://github.com/espressif/check-copyright/
-    rev: v1.0.1
+    rev: v1.0.3
     hooks:
       - id: check-copyright
         args: ['--ignore', 'ci/check_copyright_ignore.txt', '--config', 'ci/check_copyright_config.yaml']
@@ -61,8 +61,8 @@ repos:
   - repo: local
     hooks:
       - id: commit message scopes
-        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, common"
-        entry: '\A(?!(feat|fix|ci|bump|test|docs)\((mdns|modem|common|websocket|asio|mqtt_cxx|examples)\)\:)'
+        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, console, common"
+        entry: '\A(?!(feat|fix|ci|bump|test|docs)\((mdns|modem|common|console|websocket|asio|mqtt_cxx|examples)\)\:)'
         language: pygrep
         args: [--multiline]
         stages: [commit-msg]

README.md

@@ -1,5 +1,11 @@
 # Collection of protocol components for ESP-IDF
 
+## How to use
+
+The [ESP-Protocols](https://github.com/espressif/esp-protocols) repository contains a collection of protocol components for [ESP-IDF](https://github.com/espressif/esp-idf).
+Additionally, each component is available in [IDF Component Registry](https://components.espressif.com).
+Please refer to instructions in [ESP-IDF](https://github.com/espressif/esp-idf)
+
 ## Components
 
 ### esp_modem

components/asio/CMakeLists.txt

@@ -7,39 +7,40 @@ if(NOT CONFIG_LWIP_IPV6 AND NOT CMAKE_BUILD_EARLY_EXPANSION)
 endif()
 
 set(asio_sources "asio/asio/src/asio.cpp")
+set(asio_requires lwip)
 
 if(CONFIG_ASIO_SSL_SUPPORT)
-    if(CONFIG_ASIO_USE_ESP_OPENSSL)
-        list(APPEND asio_sources
-                "port/src/asio_ssl_impl.cpp"
-                "port/mbedtls/src/mbedtls_context.cpp"
-                "port/mbedtls/src/mbedtls_engine.cpp")
-        set(asio_priv_includes "port/mbedtls/include")
-    endif()
-
-    if(CONFIG_ASIO_USE_ESP_WOLFSSL)
-        list(APPEND asio_sources
-                "asio/asio/src/asio_ssl.cpp")
-    endif()
+    list(APPEND asio_sources
+            "port/src/asio_ssl_impl.cpp"
+            "port/mbedtls/src/mbedtls_context.cpp"
+            "port/mbedtls/src/mbedtls_engine.cpp")
+    set(asio_priv_includes "port/mbedtls/include")
 endif()
 
 idf_component_register(SRCS ${asio_sources}
                     INCLUDE_DIRS "asio/asio/include" "port/include"
                     PRIV_INCLUDE_DIRS ${asio_priv_includes}
-                    REQUIRES lwip)
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
+                    PRIV_REQUIRES ${asio_requires})
+
+target_compile_definitions(${COMPONENT_LIB} PUBLIC SA_RESTART=0x01
+                                                   SA_NOCLDSTOP=0x2
+                                                   SA_NOCLDWAIT=0x4
+                                                   ASIO_DISABLE_SERIAL_PORT
+                                                   ASIO_SEPARATE_COMPILATION
+                                                   ASIO_STANDALONE
+                                                   ASIO_HAS_PTHREADS
+                                                   OPENSSL_NO_ENGINE
+)
+
+if(NOT CONFIG_COMPILER_CXX_EXCEPTIONS)
+    target_compile_definitions(${COMPONENT_LIB} PUBLIC ASIO_NO_EXCEPTIONS)
+endif()
+
+if(NOT CONFIG_COMPILER_RTTI)
+    target_compile_definitions(${COMPONENT_LIB} PUBLIC ASIO_NO_TYPEID)
+endif()
 
 if(CONFIG_ASIO_SSL_SUPPORT)
-    if(CONFIG_ASIO_USE_ESP_WOLFSSL)
-        idf_component_get_property(wolflib esp-wolfssl COMPONENT_LIB)
-        idf_component_get_property(wolfdir esp-wolfssl COMPONENT_DIR)
-
-        target_link_libraries(${COMPONENT_LIB} PUBLIC ${wolflib})
-        target_include_directories(${COMPONENT_LIB} PUBLIC ${wolfdir}/wolfssl/wolfssl)
-    endif()
-
-    if(CONFIG_ASIO_USE_ESP_OPENSSL)
         idf_component_get_property(mbedtls mbedtls COMPONENT_LIB)
         target_link_libraries(${COMPONENT_LIB} PUBLIC ${mbedtls})
-    endif()
 endif()

components/asio/Kconfig

@@ -6,23 +6,6 @@ menu "ESP-ASIO"
         default n
         help
             Enable support for basic SSL/TLS features, available for mbedTLS/OpenSSL
-            as well as wolfSSL TLS library.
-
-    choice ASIO_SSL_LIBRARY_CHOICE
-        prompt "Choose SSL/TLS library for ESP-TLS (See help for more Info)"
-        default ASIO_USE_ESP_OPENSSL
-        depends on ASIO_SSL_SUPPORT
-        help
-            The ASIO support multiple backend TLS libraries. Currently the mbedTLS with a thin ESP-OpenSSL
-            port layer (default choice) and WolfSSL are supported.
-            Different TLS libraries may support different features and have different resource
-            usage. Consult the ESP-TLS documentation in ESP-IDF Programming guide for more details.
-        config ASIO_USE_ESP_OPENSSL
-            bool "esp-openssl"
-        config ASIO_USE_ESP_WOLFSSL
-            depends on TLS_STACK_WOLFSSL
-            bool "wolfSSL (License info in wolfSSL directory README)"
-    endchoice
 
     config ASIO_SSL_BIO_SIZE
         int "Size of BIO object"

components/asio/examples/asio_chat/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/asio:
+    version: "^1.14.1"
+    override_path: '../../../'

components/asio/examples/async_request/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/asio:
+    version: "^1.14.1"
+    override_path: '../../../'

components/asio/examples/async_request/sdkconfig.defaults

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

components/asio/examples/socks4/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/asio:
+    version: "^1.14.1"
+    override_path: '../../../'

components/asio/examples/ssl_client_server/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/asio:
+    version: "^1.14.1"
+    override_path: '../../../'

components/asio/examples/ssl_client_server/sdkconfig.defaults

@@ -2,6 +2,7 @@ CONFIG_ASIO_SSL_SUPPORT=y
 CONFIG_PARTITION_TABLE_CUSTOM=y
 CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
 CONFIG_PARTITION_TABLE_FILENAME="partitions.csv"
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
 
 #
 # Partition Table

components/asio/examples/tcp_echo_server/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/asio:
+    version: "^1.14.1"
+    override_path: '../../../'

components/asio/examples/tcp_echo_server/sdkconfig.defaults

@@ -1,4 +1,5 @@
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
 
 #
 # Partition Table

components/asio/examples/udp_echo_server/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/asio:
+    version: "^1.14.1"
+    override_path: '../../../'

components/asio/examples/udp_echo_server/sdkconfig.defaults

@@ -1,4 +1,5 @@
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
 
 #
 # Partition Table

components/asio/port/include/esp_asio_config.h

@@ -1,45 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2018-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2018-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 #ifndef _ESP_ASIO_CONFIG_H_
 #define _ESP_ASIO_CONFIG_H_
 
-//
-// Enabling exceptions only when they are enabled in menuconfig
-//
-# include <sdkconfig.h>
-# ifndef CONFIG_COMPILER_CXX_EXCEPTIONS
-#  define ASIO_NO_EXCEPTIONS
-# endif   // CONFIG_COMPILER_CXX_EXCEPTIONS
-
-# ifndef CONFIG_COMPILER_RTTI
-#  define ASIO_NO_TYPEID
-# endif   // CONFIG_COMPILER_RTTI
-
-//
-// Use system sockets
-//
-# include "sys/socket.h"
-
-//
-// Specific ASIO feature flags
-//
-# define ASIO_DISABLE_SERIAL_PORT
-# define ASIO_SEPARATE_COMPILATION
-# define ASIO_STANDALONE
-# define ASIO_HAS_PTHREADS
-# define ASIO_DISABLE_CONCEPTS
-
-# ifdef CONFIG_ASIO_USE_ESP_OPENSSL
-#  define ASIO_USE_ESP_OPENSSL
-#  define OPENSSL_NO_ENGINE
-#  define ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
-#  include "openssl_stub.hpp"
-
-# elif CONFIG_ASIO_USE_ESP_WOLFSSL
-#  define ASIO_USE_WOLFSSL
-# endif   // CONFIG_ASIO_USE_ESP_OPENSSL
+#define ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
+#include "openssl_stub.hpp"
 
 #endif // _ESP_ASIO_CONFIG_H_

components/asio/port/include/esp_exception.h

@@ -1,31 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2018-2021 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#ifndef _ESP_EXCEPTION_H_
-#define _ESP_EXCEPTION_H_
-
-//
-// This exception stub is enabled only if exceptions are disabled in menuconfig
-//
-#if !defined(CONFIG_COMPILER_CXX_EXCEPTIONS) && defined (ASIO_NO_EXCEPTIONS)
-
-#include "esp_log.h"
-
-//
-// asio exception stub
-//
-namespace asio {
-namespace detail {
-template <typename Exception>
-void throw_exception(const Exception &e)
-{
-    ESP_LOGE("esp32_asio_exception", "Caught exception: %s!", e.what());
-    abort();
-}
-}
-}
-#endif // CONFIG_COMPILER_CXX_EXCEPTIONS==1 && defined (ASIO_NO_EXCEPTIONS)
-
-#endif // _ESP_EXCEPTION_H_

components/console_simple_init/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS "console_simple_init.c"
+                    INCLUDE_DIRS "."
+                    PRIV_REQUIRES console)

components/console_simple_init/LICENSE

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

components/console_simple_init/README.md

@@ -0,0 +1,37 @@
+# Simple Console Initializer
+The component provides a simple api's to initialize and start the esp console.
+It also provides an api to register an user provided command.
+
+## API
+
+### Steps to enable console in an example code:
+1. Add this component to your project using ```idf.py add-dependency``` command.
+2. In the main file of the example, add the following line:
+    ```c
+    #include "console_simple_init.h"
+    ```
+3. Ensure NVS flash is initialized and default event loop is created in your app_main():
+    ```c
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+    esp_err_t ret = nvs_flash_init();   //Initialize NVS
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        ret = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK(ret);
+    ```
+4. In your app_main() function, add the following line as the last line:
+    ```c
+    ESP_ERROR_CHECK(console_cmd_init());     // Initialize console
+
+    // Define the function prototype for do_user_cmd
+    // It's a function that takes an integer (argc) and a pointer to a pointer to char (argv)
+    int do_user_cmd(int argc, char **argv);
+
+    // Register the do_user_cmd function as a command callback function for "user" command
+    // This allows you to execute the do_user_cmd function when the "user" command is invoked
+    ESP_ERROR_CHECK(console_cmd_user_register("user", do_user_cmd));
+
+
+    ESP_ERROR_CHECK(console_cmd_start());    // Start console
+    ```

components/console_simple_init/console_simple_init.c

@@ -0,0 +1,79 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdio.h>
+#include "esp_console.h"
+#include "esp_log.h"
+#include "console_simple_init.h"
+
+static esp_console_repl_t *repl = NULL;
+static const char *TAG = "console_simple_init";
+
+/**
+ * @brief Initializes the esp console
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_init(void)
+{
+    esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT();
+
+    // install console REPL environment
+#if defined(CONFIG_ESP_CONSOLE_UART_DEFAULT) || defined(CONFIG_ESP_CONSOLE_UART_CUSTOM)
+    esp_console_dev_uart_config_t hw_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
+    return esp_console_new_repl_uart(&hw_config, &repl_config, &repl);
+
+#elif defined(CONFIG_ESP_CONSOLE_USB_CDC)
+    esp_console_dev_usb_cdc_config_t hw_config = ESP_CONSOLE_DEV_CDC_CONFIG_DEFAULT();
+    return esp_console_new_repl_usb_cdc(&hw_config, &repl_config, &repl);
+
+#elif defined(CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG)
+    esp_console_dev_usb_serial_jtag_config_t hw_config = ESP_CONSOLE_DEV_USB_SERIAL_JTAG_CONFIG_DEFAULT();
+    return esp_console_new_repl_usb_serial_jtag(&hw_config, &repl_config, &repl);
+
+#else
+#error Unsupported console type
+#endif
+
+}
+
+/**
+ * @brief Initialize Ethernet driver based on Espressif IoT Development Framework Configuration
+ *
+ * @param[in] cmd string that is the user defined command
+ * @param[in] do_user_cmd Function pointer for a user-defined command callback function
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_user_register(char *cmd, esp_console_cmd_func_t do_user_cmd)
+{
+    esp_err_t ret;
+
+    const esp_console_cmd_t user_cmd = {
+        .command = cmd,
+        .help = "User defined command",
+        .hint = NULL,
+        .func = do_user_cmd,
+    };
+
+    ret = esp_console_cmd_register(&user_cmd);
+    if (ret) {
+        ESP_LOGE(TAG, "Unable to register user cmd");
+    }
+
+    return ret;
+}
+
+/**
+ * @brief Starts the esp console
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_start(void)
+{
+    // start console REPL
+    return esp_console_start_repl(repl);
+}

components/console_simple_init/console_simple_init.h

@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "esp_err.h"
+#include "esp_console.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Initializes the esp console
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_init(void);
+
+/**
+ * @brief Initialize Ethernet driver based on Espressif IoT Development Framework Configuration
+ *
+ * @param[in] cmd string that is the user defined command
+ * @param[in] do_user_cmd Function pointer for a user-defined command callback function
+ *
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_user_register(char *user_cmd, esp_console_cmd_func_t do_user_cmd);
+
+/**
+ * @brief Starts the esp console
+ * @return
+ *          - esp_err_t
+ */
+esp_err_t console_cmd_start(void);
+
+#ifdef __cplusplus
+}
+#endif

components/console_simple_init/examples/console_basic/CMakeLists.txt

@@ -0,0 +1,8 @@
+# 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)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(console_basic)

components/console_simple_init/examples/console_basic/main/CMakeLists.txt

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

components/console_simple_init/examples/console_basic/main/console_basic.c

@@ -0,0 +1,36 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#include <stdio.h>
+#include "nvs_flash.h"
+#include "esp_event.h"
+#include "console_simple_init.h"
+
+int do_user_cmd(int argc, char **argv)
+{
+    printf("Hello from user command\n");
+    return 0;
+}
+
+void app_main(void)
+{
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+    esp_err_t ret = nvs_flash_init();   //Initialize NVS
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        ret = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK(ret);
+
+    // Initialize console REPL
+    ESP_ERROR_CHECK(console_cmd_init());
+
+    // Register user command
+    ESP_ERROR_CHECK(console_cmd_user_register("user", do_user_cmd));
+
+    // start console REPL
+    ESP_ERROR_CHECK(console_cmd_start());
+
+}

components/console_simple_init/examples/console_basic/main/idf_component.yml

@@ -0,0 +1,6 @@
+dependencies:
+  idf:
+    version: '*'
+  console_simple_init:
+    version: "*"
+    override_path: '../../../'

components/console_simple_init/examples/console_basic/pytest_console_basic.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+
+# -*- coding: utf-8 -*-
+import pytest
+
+
+@pytest.mark.esp32
+def test_examples_user_command(dut):
+    dut.expect('esp>', timeout=30)
+    dut.write('user')
+    dut.expect('Hello from user command', timeout=30)
+    pass

components/console_simple_init/idf_component.yml

@@ -0,0 +1,6 @@
+version: 1.0.0
+url: https://github.com/espressif/esp-protocols/tree/master/components/console_simple_init
+description: The component provides helper functions for easy initialization and start of esp console.
+dependencies:
+  idf:
+    version: '>=5.0'

components/esp_modem/.cz.yaml

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

components/esp_modem/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.0.3](https://github.com/espressif/esp-protocols/commits/modem-v1.0.3)
+
+### Bug Fixes
+
+- Fix to allow MSC frame (SIM800 CMUX) after v1.0.2 ([8d5947e](https://github.com/espressif/esp-protocols/commit/8d5947e), [#366](https://github.com/espressif/esp-protocols/issues/366))
+- Add CMUX example to target tests ([4f2ebaa](https://github.com/espressif/esp-protocols/commit/4f2ebaa))
+
+## [1.0.2](https://github.com/espressif/esp-protocols/commits/modem-v1.0.2)
+
+### Features
+
+- Add factory method for simple creation of custom DCEs ([4cf9e50](https://github.com/espressif/esp-protocols/commit/4cf9e50))
+- Support custom transport in AT TCP client example ([ae629ed](https://github.com/espressif/esp-protocols/commit/ae629ed))
+
+### Bug Fixes
+
+- Fix host test race with async read and d'structor ([c89d42f](https://github.com/espressif/esp-protocols/commit/c89d42f))
+- More error handling in cmux protocol ([8edbac6](https://github.com/espressif/esp-protocols/commit/8edbac6))
+- Fix netif to set PPP config in C++ way ([5287432](https://github.com/espressif/esp-protocols/commit/5287432))
+- Fix vfs terminal not to reset read_cb() automatically ([25a35e2](https://github.com/espressif/esp-protocols/commit/25a35e2))
+- Fix netif data race causing PPP startup delays ([c8c0507](https://github.com/espressif/esp-protocols/commit/c8c0507), [#308](https://github.com/espressif/esp-protocols/issues/308))
+- Added support for inflatable buffer ([cb6e03a](https://github.com/espressif/esp-protocols/commit/cb6e03a), [#272](https://github.com/espressif/esp-protocols/issues/272))
+- Fix LoadProhibited after failed CMUX initialization (IDFGH-10845) ([60c87dd](https://github.com/espressif/esp-protocols/commit/60c87dd))
+
 ## [1.0.1](https://github.com/espressif/esp-protocols/commits/modem-v1.0.1)
 
 ### Bug Fixes

components/esp_modem/Kconfig

@@ -16,6 +16,17 @@ menu "esp-modem"
             in command mode might come fragmented in rare cases so might need to retry
             AT commands.
 
+    config ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+        bool "Use inflatable buffer in DCE"
+        default n
+        help
+            If enabled we will process the ongoing AT command by growing the current
+            buffer (if we've run out the preconfigured buffer).
+            If disabled, we simply report a failure.
+            Use this if additional allocation is not a problem and you need to reliably process
+            all commands, usually with sporadically longer responses than the configured buffer.
+            Could be also used to defragment AT replies in CMUX mode if CMUX_DEFRAGMENT_PAYLOAD=n
+
     config ESP_MODEM_CMUX_DELAY_AFTER_DLCI_SETUP
         int "Delay in ms to wait before creating another virtual terminal"
         default 0
@@ -25,4 +36,13 @@ menu "esp-modem"
             The typical reason for failing SABM request without a delay is that
             some devices (SIM800) send MSC requests just after opening a new DLCI.
 
+    config ESP_MODEM_CMUX_USE_SHORT_PAYLOADS_ONLY
+        bool "CMUX to support only short payloads (<128 bytes)"
+        default n
+        help
+            If enabled, the CMUX protocol would only use 1 byte size field.
+            You can use this option for devices that support only short CMUX payloads
+            to make the protocol more robust on noisy environments or when underlying
+            transport gets corrupted often (for example by Rx buffer overflows)
+
 endmenu

components/esp_modem/examples/modem_console/main/CMakeLists.txt

@@ -5,4 +5,3 @@ idf_component_register(SRCS "modem_console_main.cpp"
                             "ping_handle.c"
                        REQUIRES console esp_http_client nvs_flash
                        INCLUDE_DIRS ".")
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

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

@@ -173,7 +173,7 @@ extern "C" void app_main(void)
         ESP_LOGI(TAG, "Waiting for USB device connection...");
         auto dte = create_usb_dte(&dte_config);
         dte->set_error_cb([&](terminal_error err) {
-            ESP_LOGI(TAG, "error handler %d", err);
+            ESP_LOGI(TAG, "error handler %d", (int)err);
             if (err == terminal_error::DEVICE_GONE) {
                 exit_signal.set(1);
             }
@@ -482,7 +482,7 @@ extern "C" void app_main(void)
     // wait for exit
     exit_signal.wait_any(1, UINT32_MAX);
     s_repl->del(s_repl);
-    ESP_LOGI(TAG, "Exiting...%d", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "Exiting...%" PRIu32, esp_get_free_heap_size());
 #if defined(CONFIG_EXAMPLE_SERIAL_CONFIG_USB)
     // USB example runs in a loop to demonstrate hot-plugging and sudden disconnection features.
 } // while (1)

components/esp_modem/examples/modem_console/main/ping_handle.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
  */
@@ -28,7 +28,7 @@ static void cmd_ping_on_ping_success(esp_ping_handle_t hdl, void *args)
     esp_ping_get_profile(hdl, ESP_PING_PROF_IPADDR, &target_addr, sizeof(target_addr));
     esp_ping_get_profile(hdl, ESP_PING_PROF_SIZE, &recv_len, sizeof(recv_len));
     esp_ping_get_profile(hdl, ESP_PING_PROF_TIMEGAP, &elapsed_time, sizeof(elapsed_time));
-    ESP_LOGI(TAG, "%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n",
+    ESP_LOGI(TAG, "%" PRIu32 " bytes from %s icmp_seq=%d ttl=%d time=%" PRIu32 " ms\n",
              recv_len, inet_ntoa(target_addr.u_addr.ip4), seqno, ttl, elapsed_time);
 }
 
@@ -57,7 +57,7 @@ static void cmd_ping_on_ping_end(esp_ping_handle_t hdl, void *args)
     } else {
         ESP_LOGI(TAG, "\n--- %s ping statistics ---\n", inet6_ntoa(*ip_2_ip6(&target_addr)));
     }
-    ESP_LOGI(TAG, "%d packets transmitted, %d received, %d%% packet loss, time %dms\n",
+    ESP_LOGI(TAG, "%" PRIu32 " packets transmitted, %" PRIu32 " received, %" PRIu32 " packet loss, time %" PRIu32 "ms\n",
              transmitted, received, loss, total_time_ms);
     // delete the ping sessions, so that we clean up all resources and can create a new ping session
     // we don't have to call delete function in the callback, instead we can call delete function from other tasks

components/esp_modem/examples/modem_psm/main/CMakeLists.txt

@@ -1,3 +1,2 @@
-
 idf_component_register(SRCS "modem_psm.c"
                     INCLUDE_DIRS ".")

components/esp_modem/examples/modem_tcp_client/CMakeLists.txt

@@ -1,7 +1,6 @@
 # The following 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.8)
-set(CMAKE_CXX_STANDARD 17)
 
 set(EXTRA_COMPONENT_DIRS "../..")
 

components/esp_modem/examples/modem_tcp_client/README.md

@@ -5,6 +5,10 @@
 ## Overview
 This example demonstrates how to act as a MQTT client using modem's TCP commands (provided, the device supports "socket" related commands)
 
+This example could be used in two different configurations:
+1) Custom TCP transport: Implements a TCP transport in form of AT commands and uses it as custom transport for mqtt client.
+2) Localhost listener: Uses standard transports to connect and forwards socket layer data from the client to the modem using AT commands.
+
 ### Supported IDF versions
 
-This example is supported from IDF `v4.4`.
+This example is supported from IDF `v5.0`.

components/esp_modem/examples/modem_tcp_client/components/extra_tcp_transports/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(SRCS mbedtls_wrap.cpp
+                            tls_transport.cpp
+                       INCLUDE_DIRS include
+                       REQUIRES tcp_transport)

components/esp_modem/examples/modem_tcp_client/components/extra_tcp_transports/README.md

@@ -0,0 +1,9 @@
+# Custom transports
+
+This component is a placeholder of custom transports. It contains mbedTLS cxx wrapper which could be used to create a custom TLS layer on any kind of IO function.
+
+# List of Transports
+
+## TLS Transport
+
+TLS layer on top of any custom transport. Very similar to `ssl_transport` (standard IDF transport), but this is customizable and could work on any kind of transport, not only  the BSD socket based tcp transport (like `ssl_transport`).

components/esp_modem/examples/modem_tcp_client/components/extra_tcp_transports/include/mbedtls_wrap.hpp

@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <utility>
+#include <span>
+#include "mbedtls/ssl.h"
+#include "mbedtls/entropy.h"
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/error.h"
+
+using  const_buf = std::span<const unsigned char>;
+
+class Tls {
+public:
+    enum class is_server : bool {};
+    enum class do_verify : bool {};
+
+    Tls();
+    virtual ~Tls();
+    bool init(is_server server, do_verify verify);
+    int handshake();
+    int write(const unsigned char *buf, size_t len);
+    int read(unsigned char *buf, size_t len);
+    [[nodiscard]] bool set_own_cert(const_buf crt, const_buf key);
+    [[nodiscard]] bool set_ca_cert(const_buf crt);
+    virtual int send(const unsigned char *buf, size_t len) = 0;
+    virtual int recv(unsigned char *buf, size_t len) = 0;
+    size_t get_available_bytes();
+
+protected:
+    mbedtls_ssl_context ssl_{};
+    mbedtls_x509_crt public_cert_{};
+    mbedtls_pk_context pk_key_{};
+    mbedtls_x509_crt ca_cert_{};
+    mbedtls_ssl_config conf_{};
+    mbedtls_ctr_drbg_context ctr_drbg_{};
+    mbedtls_entropy_context entropy_{};
+    virtual void delay() {}
+
+private:
+    static void print_error(const char *function, int error_code);
+    static int bio_write(void *ctx, const unsigned char *buf, size_t len);
+    static int bio_read(void *ctx, unsigned char *buf, size_t len);
+    int mbedtls_pk_parse_key( mbedtls_pk_context *ctx,
+                              const unsigned char *key, size_t keylen,
+                              const unsigned char *pwd, size_t pwdlen);
+
+};

components/esp_modem/examples/modem_tcp_client/components/extra_tcp_transports/include/tcp_transport_mbedtls.h

@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include "esp_transport.h"
+
+/**
+ * @brief Initializes TLS transport based on mbetls wrapper
+ *
+ * @param parent Transport on top of which we run TLS layer
+ * @return Transport handle on success
+ */
+esp_transport_handle_t esp_transport_tls_init(esp_transport_handle_t parent);

components/esp_modem/examples/modem_tcp_client/components/extra_tcp_transports/mbedtls_wrap.cpp

@@ -0,0 +1,134 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "mbedtls/ctr_drbg.h"
+#include "mbedtls/ssl.h"
+#include "mbedtls_wrap.hpp"
+
+bool Tls::init(is_server server, do_verify verify)
+{
+    const char pers[] = "mbedtls_wrapper";
+    mbedtls_entropy_init(&entropy_);
+    mbedtls_ctr_drbg_seed(&ctr_drbg_, mbedtls_entropy_func, &entropy_, (const unsigned char *)pers, sizeof(pers));
+    int ret = mbedtls_ssl_config_defaults(&conf_, server == is_server{true} ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT);
+    if (ret) {
+        print_error("mbedtls_ssl_config_defaults", ret);
+        return false;
+    }
+    mbedtls_ssl_conf_rng(&conf_, mbedtls_ctr_drbg_random, &ctr_drbg_);
+    mbedtls_ssl_conf_authmode(&conf_, verify == do_verify{true} ? MBEDTLS_SSL_VERIFY_REQUIRED : MBEDTLS_SSL_VERIFY_NONE);
+    ret = mbedtls_ssl_conf_own_cert(&conf_, &public_cert_, &pk_key_);
+    if (ret) {
+        print_error("mbedtls_ssl_conf_own_cert", ret);
+        return false;
+    }
+    if (verify == do_verify{true}) {
+        mbedtls_ssl_conf_ca_chain(&conf_, &ca_cert_, nullptr);
+    }
+    ret = mbedtls_ssl_setup(&ssl_, &conf_);
+    if (ret) {
+        print_error("mbedtls_ssl_setup", ret);
+        return false;
+    }
+    return true;
+}
+
+void Tls::print_error(const char *function, int error_code)
+{
+    static char error_buf[100];
+    mbedtls_strerror(error_code, error_buf, sizeof(error_buf));
+
+    printf("%s() returned -0x%04X\n", function, -error_code);
+    printf("-0x%04X: %s\n", -error_code, error_buf);
+}
+
+int Tls::handshake()
+{
+    int ret = 0;
+    mbedtls_ssl_set_bio(&ssl_, this, bio_write, bio_read, nullptr);
+
+    while ( ( ret = mbedtls_ssl_handshake( &ssl_ ) ) != 0 ) {
+        if ( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE ) {
+            print_error( "mbedtls_ssl_handshake returned", ret );
+            return -1;
+        }
+        delay();
+    }
+    return ret;
+}
+
+int Tls::bio_write(void *ctx, const unsigned char *buf, size_t len)
+{
+    auto s = static_cast<Tls *>(ctx);
+    return s->send(buf, len);
+}
+
+int Tls::bio_read(void *ctx, unsigned char *buf, size_t len)
+{
+    auto s = static_cast<Tls *>(ctx);
+    return s->recv(buf, len);
+}
+
+int Tls::write(const unsigned char *buf, size_t len)
+{
+    return mbedtls_ssl_write( &ssl_, buf, len );
+}
+
+int Tls::read(unsigned char *buf, size_t len)
+{
+    return mbedtls_ssl_read( &ssl_, buf, len );
+}
+
+bool Tls::set_own_cert(const_buf crt, const_buf key)
+{
+    int ret = mbedtls_x509_crt_parse(&public_cert_, crt.data(), crt.size());
+    if (ret < 0) {
+        print_error("mbedtls_x509_crt_parse", ret);
+        return false;
+    }
+    ret = mbedtls_pk_parse_key(&pk_key_, key.data(), key.size(), nullptr, 0);
+    if (ret < 0) {
+        print_error("mbedtls_pk_parse_keyfile", ret);
+        return false;
+    }
+    return true;
+}
+
+bool Tls::set_ca_cert(const_buf crt)
+{
+    int ret = mbedtls_x509_crt_parse(&ca_cert_, crt.data(), crt.size());
+    if (ret < 0) {
+        print_error("mbedtls_x509_crt_parse", ret);
+        return false;
+    }
+    return true;
+}
+
+Tls::Tls()
+{
+    mbedtls_x509_crt_init(&public_cert_);
+    mbedtls_pk_init(&pk_key_);
+    mbedtls_x509_crt_init(&ca_cert_);
+}
+
+int Tls::mbedtls_pk_parse_key(mbedtls_pk_context *ctx, const unsigned char *key, size_t keylen, const unsigned char *pwd, size_t pwdlen)
+{
+
+    return ::mbedtls_pk_parse_key(ctx, key, keylen, pwd, pwdlen, nullptr, nullptr);
+}
+
+size_t Tls::get_available_bytes()
+{
+    return ::mbedtls_ssl_get_bytes_avail(&ssl_);
+}
+
+Tls::~Tls()
+{
+    ::mbedtls_ssl_config_free(&conf_);
+    ::mbedtls_ssl_free(&ssl_);
+    ::mbedtls_pk_free(&pk_key_);
+    ::mbedtls_x509_crt_free(&public_cert_);
+    ::mbedtls_x509_crt_free(&ca_cert_);
+}

components/esp_modem/examples/modem_tcp_client/components/extra_tcp_transports/tls_transport.cpp

@@ -0,0 +1,137 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "esp_transport.h"
+#include "mbedtls_wrap.hpp"
+
+static const char *TAG = "tls_transport";
+
+class TlsTransport: public Tls {
+public:
+    explicit TlsTransport(esp_transport_handle_t parent) : Tls(), transport_(parent) {}
+    int send(const unsigned char *buf, size_t len) override;
+    int recv(unsigned char *buf, size_t len) override;
+    static bool set_func(esp_transport_handle_t tls_transport);
+
+private:
+    esp_transport_handle_t transport_{};
+    int connect(const char *host, int port, int timeout_ms);
+    void delay() override;
+
+    struct transport {
+        static int connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms);
+        static int read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms);
+        static int write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms);
+        static int close(esp_transport_handle_t t);
+        static int poll_read(esp_transport_handle_t t, int timeout_ms);
+        static int poll_write(esp_transport_handle_t t, int timeout_ms);
+        static int destroy(esp_transport_handle_t t);
+    };
+};
+
+esp_transport_handle_t esp_transport_tls_init(esp_transport_handle_t parent)
+{
+    esp_transport_handle_t ssl = esp_transport_init();
+    auto *tls = new TlsTransport(parent);
+    esp_transport_set_context_data(ssl, tls);
+    TlsTransport::set_func(ssl);
+    return ssl;
+}
+
+int TlsTransport::send(const unsigned char *buf, size_t len)
+{
+    return esp_transport_write(transport_, reinterpret_cast<const char *>(buf), len, 0);
+}
+
+int TlsTransport::recv(unsigned char *buf, size_t len)
+{
+    int ret = esp_transport_read(transport_, reinterpret_cast<char *>(buf), len, 0);
+
+    if (ret == ERR_TCP_TRANSPORT_CONNECTION_TIMEOUT) {
+        return MBEDTLS_ERR_SSL_WANT_READ;
+    }
+    return ret == ERR_TCP_TRANSPORT_CONNECTION_CLOSED_BY_FIN ? 0 : ret;
+}
+
+bool TlsTransport::set_func(esp_transport_handle_t tls_transport)
+{
+    return esp_transport_set_func(tls_transport, TlsTransport::transport::connect, TlsTransport::transport::read, TlsTransport::transport::write, TlsTransport::transport::close, TlsTransport::transport::poll_read, TlsTransport::transport::poll_write, TlsTransport::transport::destroy) == ESP_OK;
+}
+
+int TlsTransport::connect(const char *host, int port, int timeout_ms)
+{
+    return esp_transport_connect(transport_, host, port, timeout_ms);
+}
+
+void TlsTransport::delay()
+{
+    vTaskDelay(pdMS_TO_TICKS(500));
+}
+
+int TlsTransport::transport::connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms)
+{
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    tls->init(is_server{false}, do_verify{false});
+
+    auto ret = tls->connect(host, port, timeout_ms);
+    if (ret < 0) {
+        return ret;
+    }
+    return tls->handshake();
+}
+
+int TlsTransport::transport::read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms)
+{
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    if (tls->get_available_bytes() <= 0) {
+        int poll = esp_transport_poll_read(t, timeout_ms);
+        if (poll == -1) {
+            return ERR_TCP_TRANSPORT_CONNECTION_FAILED;
+        }
+        if (poll == 0) {
+            return ERR_TCP_TRANSPORT_CONNECTION_TIMEOUT;
+        }
+    }
+    return tls->read(reinterpret_cast<unsigned char *>(buffer), len);
+}
+
+int TlsTransport::transport::write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms)
+{
+    int poll;
+    if ((poll = esp_transport_poll_write(t, timeout_ms)) <= 0) {
+        ESP_LOGW(TAG, "Poll timeout or error timeout_ms=%d", timeout_ms);
+        return poll;
+    }
+
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    return tls->write(reinterpret_cast<const unsigned char *>(buffer), len);
+}
+
+int TlsTransport::transport::close(esp_transport_handle_t t)
+{
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    return esp_transport_close(tls->transport_);
+}
+
+int TlsTransport::transport::poll_read(esp_transport_handle_t t, int timeout_ms)
+{
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    return esp_transport_poll_read(tls->transport_, timeout_ms);
+}
+
+int TlsTransport::transport::poll_write(esp_transport_handle_t t, int timeout_ms)
+{
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    return esp_transport_poll_write(tls->transport_, timeout_ms);
+}
+
+int TlsTransport::transport::destroy(esp_transport_handle_t t)
+{
+    auto tls = static_cast<TlsTransport *>(esp_transport_get_context_data(t));
+    return esp_transport_destroy(tls->transport_);
+}

components/esp_modem/examples/modem_tcp_client/main/CMakeLists.txt

@@ -6,6 +6,6 @@ endif()
 
 idf_component_register(SRCS "modem_client.cpp"
                             "sock_dce.cpp"
+                            "tcp_transport_at.cpp"
                             "${device_srcs}"
                        INCLUDE_DIRS ".")
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

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

@@ -1,5 +1,10 @@
 menu "Example Configuration"
 
+    config EXAMPLE_CUSTOM_TCP_TRANSPORT
+        bool "Custom TCP transport"
+        help
+            Use custom TCP transport to connect to MQTT broker
+
     choice EXAMPLE_MODEM_DEVICE
         prompt "Choose supported modem device (DCE)"
         default EXAMPLE_MODEM_DEVICE_BG96

components/esp_modem/examples/modem_tcp_client/main/modem_client.cpp

@@ -15,14 +15,17 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/event_groups.h"
 #include "esp_netif.h"
-#include "esp_netif_ppp.h"
 #include "mqtt_client.h"
 #include "esp_modem_config.h"
 #include "cxx_include/esp_modem_api.hpp"
 #include "sock_dce.hpp"
 #include "esp_log.h"
+#include "tcp_transport_mbedtls.h"
+#include "tcp_transport_at.h"
 
 #define BROKER_URL "mqtt.eclipseprojects.io"
+#define BROKER_PORT 8883
+
 
 static const char *TAG = "modem_client";
 static EventGroupHandle_t event_group = NULL;
@@ -31,7 +34,7 @@ static const int GOT_DATA_BIT = BIT2;
 
 static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
 {
-    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRId32, base, event_id);
     esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
     esp_mqtt_client_handle_t client = event->client;
     int msg_id;
@@ -70,6 +73,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
     }
 }
 
+
 extern "C" void app_main(void)
 {
 
@@ -101,24 +105,29 @@ extern "C" void app_main(void)
 
     /* create the DCE and initialize network manually (using AT commands) */
     auto dce = sock_dce::create(&dce_config, std::move(dte));
-    if (!dce->init_network()) {
+    if (!dce->init()) {
         ESP_LOGE(TAG,  "Failed to setup network");
         return;
     }
 
-    dce->init_sock(8883);
     esp_mqtt_client_config_t mqtt_config = {};
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-    mqtt_config.broker.address.uri = "mqtts://127.0.0.1";
+    mqtt_config.broker.address.port = BROKER_PORT;
     mqtt_config.session.message_retransmit_timeout = 10000;
+#ifndef CONFIG_EXAMPLE_CUSTOM_TCP_TRANSPORT
+    mqtt_config.broker.address.uri = "mqtts://127.0.0.1";
+    dce->start_listening(BROKER_PORT);
 #else
-    mqtt_config.uri = "mqtt://127.0.0.1";
-    mqtt_config.message_retransmit_timeout = 10000;
+    mqtt_config.broker.address.uri = "mqtt://" BROKER_URL;
+    esp_transport_handle_t at = esp_transport_at_init(dce.get());
+    esp_transport_handle_t ssl = esp_transport_tls_init(at);
+
+    mqtt_config.network.transport = ssl;
 #endif
     esp_mqtt_client_handle_t mqtt_client = esp_mqtt_client_init(&mqtt_config);
     esp_mqtt_client_register_event(mqtt_client, static_cast<esp_mqtt_event_id_t>(ESP_EVENT_ANY_ID), mqtt_event_handler, NULL);
     esp_mqtt_client_start(mqtt_client);
-    if (!dce->start(BROKER_URL, 8883)) {
+#ifndef CONFIG_EXAMPLE_CUSTOM_TCP_TRANSPORT
+    if (!dce->connect(BROKER_URL, BROKER_PORT)) {
         ESP_LOGE(TAG, "Failed to start DCE");
         return;
     }
@@ -128,13 +137,16 @@ extern "C" void app_main(void)
         }
         ESP_LOGE(TAG, "Loop exit.. retrying");
         // handle disconnections errors
-        if (!dce->init_network()) {
+        if (!dce->init()) {
             ESP_LOGE(TAG, "Failed to reinit network");
             return;
         }
-        if (!dce->start("test.mosquitto.org", 1883)) {
+        if (!dce->connect(BROKER_URL, BROKER_PORT)) {
             ESP_LOGI(TAG, "Network reinitialized, retrying");
         }
     }
+#else
+    vTaskDelay(portMAX_DELAY);
+#endif
 
 }

components/esp_modem/examples/modem_tcp_client/main/sock_commands.hpp

@@ -13,8 +13,6 @@
 
 namespace sock_commands {
 
-//using namespace esp_modem;
-
 #define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, num, ...) \
         esp_modem::return_type name(esp_modem::CommandableIf *t, ## __VA_ARGS__);
 

components/esp_modem/examples/modem_tcp_client/main/sock_commands_bg96.cpp

@@ -6,7 +6,6 @@
 
 #include <charconv>
 #include <cstring>
-#include <sys/socket.h>
 #include "sock_commands.hpp"
 #include "cxx_include/esp_modem_command_library_utils.hpp"
 #include "sock_dce.hpp"
@@ -132,7 +131,7 @@ Responder::ret Responder::recv(uint8_t *data, size_t len)
     if (data_to_recv == 0) {
         const std::string_view head = "+QIRD: ";
         auto head_pos = std::search(recv_data, recv_data + len, head.begin(), head.end());
-        if (head_pos == nullptr) {
+        if (head_pos == recv_data + len) {
             return ret::FAIL;
         }
 
@@ -160,17 +159,17 @@ Responder::ret Responder::recv(uint8_t *data, size_t len)
         recv_data = next_nl + 1;
         auto first_data_len = len - (recv_data - (char *)data) /* minus size of the command marker */;
         if (actual_len > first_data_len) {
-            ::send(sock, recv_data, first_data_len, 0);
+            on_read(recv_data, first_data_len);
             data_to_recv = actual_len - first_data_len;
             return ret::NEED_MORE_DATA;
         }
-        ::send(sock, recv_data, actual_len, 0);
+        on_read(recv_data, actual_len);
     } else if (data_to_recv > len) {    // continue sending
-        ::send(sock, recv_data, len, 0);
+        on_read(recv_data, len);
         data_to_recv -= len;
         return ret::NEED_MORE_DATA;
     } else if (data_to_recv <= len) {    // last read -> looking for "OK" marker
-        ::send(sock, recv_data, data_to_recv, 0);
+        on_read(recv_data, data_to_recv);
         actual_len = data_to_recv;
     }
 

components/esp_modem/examples/modem_tcp_client/main/sock_commands_sim7600.cpp

@@ -6,7 +6,6 @@
 
 #include <charconv>
 #include <cstring>
-#include <sys/socket.h>
 #include "sock_commands.hpp"
 #include "cxx_include/esp_modem_command_library_utils.hpp"
 #include "sock_dce.hpp"
@@ -218,7 +217,7 @@ Responder::ret Responder::recv(uint8_t *data, size_t len)
     if (data_to_recv == 0) {
         static constexpr std::string_view head = "+CIPRXGET: 2,0,";
         auto head_pos = std::search(recv_data, recv_data + len, head.begin(), head.end());
-        if (head_pos == nullptr) {
+        if (head_pos == recv_data + len) {
             return ret::FAIL;
         }
 
@@ -246,7 +245,7 @@ Responder::ret Responder::recv(uint8_t *data, size_t len)
             ESP_LOGE(TAG, "TOO BIG");
             return ret::FAIL;
         }
-        size_t total_len = 0;
+        total_len = 0;
         if (std::from_chars(next_comma + 1, next_nl - 1, total_len).ec == std::errc::invalid_argument) {
             ESP_LOGE(TAG, "cannot convert");
             return ret::FAIL;
@@ -255,17 +254,17 @@ Responder::ret Responder::recv(uint8_t *data, size_t len)
         recv_data = next_nl + 1;
         auto first_data_len = len - (recv_data - (char *)data) /* minus size of the command marker */;
         if (actual_len > first_data_len) {
-            ::send(sock, recv_data, first_data_len, 0);
+            on_read(recv_data, first_data_len);
             data_to_recv = actual_len - first_data_len;
             return ret::NEED_MORE_DATA;
         }
-        ::send(sock, recv_data, actual_len, 0);
+        on_read(recv_data, actual_len);
     } else if (data_to_recv > len) {    // continue sending
-        ::send(sock, recv_data, len, 0);
+        on_read(recv_data, len);
         data_to_recv -= len;
         return ret::NEED_MORE_DATA;
     } else if (data_to_recv <= len) {    // last read -> looking for "OK" marker
-        ::send(sock, recv_data, data_to_recv, 0);
+        on_read(recv_data, data_to_recv);
         actual_len = data_to_recv;
     }
 

components/esp_modem/examples/modem_tcp_client/main/sock_dce.cpp

@@ -120,14 +120,14 @@ bool DCE::at_to_sock()
 {
     uint64_t data;
     read(data_ready_fd, &data, sizeof(data));
-    ESP_LOGD(TAG, "select read: modem data available %x", data);
+    ESP_LOGD(TAG, "select read: modem data available %" PRIu64, data);
     if (!signal.wait(IDLE, 1000)) {
         ESP_LOGE(TAG, "Failed to get idle");
         close_sock();
         return false;
     }
     if (state != status::IDLE) {
-        ESP_LOGE(TAG, "Unexpected state %d", state);
+        ESP_LOGE(TAG, "Unexpected state %d", static_cast<int>(state));
         close_sock();
         return false;
     }
@@ -145,7 +145,7 @@ bool DCE::sock_to_at()
         return false;
     }
     if (state != status::IDLE) {
-        ESP_LOGE(TAG,  "Unexpected state %d", state);
+        ESP_LOGE(TAG,  "Unexpected state %d", static_cast<int>(state));
         close_sock();
         return false;
     }
@@ -192,14 +192,8 @@ bool DCE::accept_sock()
     return false;
 }
 
-void DCE::init_sock(int port)
+void DCE::start_listening(int port)
 {
-    esp_vfs_eventfd_config_t config = ESP_VFS_EVENTD_CONFIG_DEFAULT();
-    esp_vfs_eventfd_register(&config);
-
-    data_ready_fd = eventfd(0, EFD_SUPPORT_ISR);
-    assert(data_ready_fd > 0);
-
     listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
     if (listen_sock < 0) {
         ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
@@ -228,7 +222,7 @@ void DCE::init_sock(int port)
 
 }
 
-bool DCE::start(std::string host, int port)
+bool DCE::connect(std::string host, int port)
 {
     dte->on_read(nullptr);
     tcp_close();
@@ -245,8 +239,14 @@ bool DCE::start(std::string host, int port)
     return true;
 }
 
-bool DCE::init_network()
+bool DCE::init()
 {
+    esp_vfs_eventfd_config_t config = ESP_VFS_EVENTD_CONFIG_DEFAULT();
+    esp_vfs_eventfd_register(&config);
+
+    data_ready_fd = eventfd(0, EFD_SUPPORT_ISR);
+    assert(data_ready_fd > 0);
+
     dte->on_read(nullptr);
     const int retries = 5;
     int i = 0;

components/esp_modem/examples/modem_tcp_client/main/sock_dce.hpp

@@ -9,6 +9,7 @@
 #include <cxx_include/esp_modem_dce_factory.hpp>
 #include "socket_commands.inc"
 #include "sock_commands.hpp"
+#include <sys/socket.h>
 
 #pragma  once
 
@@ -46,9 +47,36 @@ public:
     {
         return buffer_size;
     }
+
+    void clear_offsets()
+    {
+        actual_read = 0;
+    }
+
+    size_t data_available()
+    {
+        return actual_read;
+    }
+
+    size_t has_data()
+    {
+        return total_len;
+    }
+
 private:
     static constexpr size_t buffer_size = 512;
 
+    bool on_read(char *data, size_t len)
+    {
+#ifndef CONFIG_EXAMPLE_CUSTOM_TCP_TRANSPORT
+        ::send(sock, data, len, 0);
+#else
+        ::memcpy(&buffer[actual_read], data, len);
+        actual_read += len;
+#endif
+        return true;
+    }
+
     ret recv(uint8_t *data, size_t len);
     ret send(uint8_t *data, size_t len);
     ret send(std::string_view response);
@@ -59,6 +87,9 @@ private:
     }
     std::array<uint8_t, buffer_size> buffer;
     size_t data_to_recv = 0;
+    size_t actual_read = 0;
+    size_t total_len = 0;
+
     bool read_again = false;
     int &sock;
     int &data_ready_fd;
@@ -78,13 +109,101 @@ esp_modem::return_type name(__VA_ARGS__);
 
 #undef ESP_MODEM_DECLARE_DCE_COMMAND
 
-    bool init_network();
-    bool start(std::string host, int port);
+    bool init();
+    bool connect(std::string host, int port);
 
-    void init_sock(int port);
+    void start_listening(int port);
 
     bool perform_sock();
 
+    void set_idle()
+    {
+        signal.set(IDLE);
+    }
+
+    bool wait_to_idle(uint32_t ms)
+    {
+        if (!signal.wait(IDLE, ms)) {
+            ESP_LOGE("dce", "Failed to get idle");
+            return false;
+        }
+        if (state != status::IDLE) {
+            ESP_LOGE("dce", "Unexpected state %d", static_cast<int>(state));
+            return false;
+        }
+        return true;
+    }
+
+    int sync_recv(char *buffer, int len, int timeout_ms)
+    {
+        if (!wait_to_idle(timeout_ms)) {
+            return 0;
+        }
+        at.clear_offsets();
+        state = status::RECEIVING;
+        uint64_t data;
+        read(data_ready_fd, &data, sizeof(data));
+        int max_len = std::min(len, (int)at.get_buf_len());
+        at.start_receiving(max_len);
+        if (!signal.wait(IDLE, 500 + timeout_ms)) {
+            return 0;
+        }
+        int ret = at.data_available();
+        if (ret > 0) {
+            memcpy(buffer, at.get_buf(), ret);
+        }
+        set_idle();
+        return ret;
+    }
+
+    int sync_send(const char *buffer, size_t len, int timeout_ms)
+    {
+        int len_to_send = std::min(len, at.get_buf_len());
+        if (!wait_to_idle(timeout_ms)) {
+            return -1;
+        }
+        state = status::SENDING;
+        memcpy(at.get_buf(), buffer, len_to_send);
+        ESP_LOG_BUFFER_HEXDUMP("dce", at.get_buf(), len, ESP_LOG_VERBOSE);
+        at.start_sending(len_to_send);
+        if (!signal.wait(IDLE, timeout_ms + 1000)) {
+            if (state == status::PENDING) {
+                state = status::IDLE;
+            } else {
+                return -1;
+            }
+        }
+        set_idle();
+        return len_to_send;
+    }
+
+    int wait_to_read(uint32_t ms)
+    {
+        if (at.has_data() > 0) {
+            ESP_LOGD("dce",  "Data buffered in modem (len=%d)", at.has_data());
+            return 1;
+        }
+        struct timeval tv = {
+            .tv_sec = static_cast<time_t>(ms / 1000),
+            .tv_usec = 0,
+        };
+        fd_set fdset;
+        FD_ZERO(&fdset);
+        FD_SET(data_ready_fd, &fdset);
+        int s = select(data_ready_fd + 1, &fdset, nullptr, nullptr, &tv);
+        if (s == 0) {
+            return 0;
+        } else if (s < 0) {
+            ESP_LOGE("dce",  "select error %d", errno);
+            return -1;
+        }
+        if (FD_ISSET(data_ready_fd, &fdset)) {
+            ESP_LOGD("dce", "select read: modem data available");
+            return 1;
+        }
+        return -1;
+    }
+
 private:
     esp_modem::SignalGroup signal;
 

components/esp_modem/examples/modem_tcp_client/main/tcp_transport_at.cpp

@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+#include "sock_dce.hpp"
+#include "esp_log.h"
+#include "esp_transport.h"
+
+
+static int tcp_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms)
+{
+    auto *dce = (sock_dce::DCE *)esp_transport_get_context_data(t);
+    if (!dce->connect(host, port)) {
+        return -1;
+    }
+    if (dce->wait_to_idle(timeout_ms)) {
+        dce->set_idle();
+        return 1;
+    }
+    return -1;
+}
+
+static int tcp_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms)
+{
+    auto *dce = (sock_dce::DCE *)esp_transport_get_context_data(t);
+    auto ret = dce->wait_to_read(1000);
+    if (ret > 0) {
+        return dce->sync_recv(buffer, len, timeout_ms);
+    }
+    return ret;
+}
+
+static int tcp_write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms)
+{
+
+    auto *dce = (sock_dce::DCE *)esp_transport_get_context_data(t);
+    return dce->sync_send(buffer, len, timeout_ms);
+
+}
+
+static int base_close(esp_transport_handle_t t)
+{
+    auto *dce = (sock_dce::DCE *)esp_transport_get_context_data(t);
+    return dce->tcp_close() == esp_modem::command_result::OK ? 0 : -1;
+}
+
+static int base_poll_read(esp_transport_handle_t t, int timeout_ms)
+{
+    auto *dce = (sock_dce::DCE *)esp_transport_get_context_data(t);
+    return dce->wait_to_read(timeout_ms);
+}
+
+static int base_poll_write(esp_transport_handle_t t, int timeout_ms)
+{
+    // expect the socket is always writable
+    return 1;
+}
+
+static int base_destroy(esp_transport_handle_t transport)
+{
+    return 0;
+}
+
+esp_transport_handle_t esp_transport_at_init(sock_dce::DCE *dce)
+{
+    esp_transport_handle_t at = esp_transport_init();
+    if (!at) {
+        return nullptr;
+    }
+    esp_transport_set_context_data(at, (void *)dce);
+    esp_transport_set_func(at, tcp_connect, tcp_read, tcp_write, base_close, base_poll_read, base_poll_write, base_destroy);
+    return at;
+}

components/esp_modem/examples/modem_tcp_client/main/tcp_transport_at.h

@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include "esp_transport.h"
+#include "sock_dce.hpp"
+
+/**
+ * @brief Initializes TCP transport based on AT commands
+ *
+ * @param DCE
+ * @return Transport handle on success
+ */
+esp_transport_handle_t esp_transport_at_init(sock_dce::DCE *dce);

components/esp_modem/examples/pppos_client/main/CMakeLists.txt

@@ -1,3 +1,2 @@
 idf_component_register(SRCS "pppos_client_main.c"
                        INCLUDE_DIRS ".")
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

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

@@ -60,7 +60,7 @@ if ((xEventGroupGetBits(event_group) & USB_DISCONNECTED_BIT) == USB_DISCONNECTED
 
 static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
 {
-    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIu32, base, event_id);
     esp_mqtt_event_handle_t event = event_data;
     esp_mqtt_client_handle_t client = event->client;
     int msg_id;
@@ -102,7 +102,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
 static void on_ppp_changed(void *arg, esp_event_base_t event_base,
                            int32_t event_id, void *event_data)
 {
-    ESP_LOGI(TAG, "PPP state changed event %d", event_id);
+    ESP_LOGI(TAG, "PPP state changed event %" PRIu32, event_id);
     if (event_id == NETIF_PPP_ERRORUSER) {
         /* User interrupted event from esp-netif */
         esp_netif_t *netif = event_data;
@@ -114,7 +114,7 @@ static void on_ppp_changed(void *arg, esp_event_base_t event_base,
 static void on_ip_event(void *arg, esp_event_base_t event_base,
                         int32_t event_id, void *event_data)
 {
-    ESP_LOGD(TAG, "IP event! %d", event_id);
+    ESP_LOGD(TAG, "IP event! %" PRIu32, event_id);
     if (event_id == IP_EVENT_PPP_GOT_IP) {
         esp_netif_dns_info_t dns_info;
 

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

@@ -175,6 +175,9 @@ extern "C" void app_main(void)
 #endif
     assert(dce);
 
+    /* Try to connect to the network and publish an mqtt topic */
+    StatusHandler handler;
+
     if (dte_config.uart_config.flow_control == ESP_MODEM_FLOW_CONTROL_HW) {
         if (command_result::OK != dce->set_flow_control(2, 2)) {
             ESP_LOGE(TAG, "Failed to set the set_flow_control mode");
@@ -215,8 +218,6 @@ extern "C" void app_main(void)
     }
 #endif
 
-    /* Try to connect to the network and publish an mqtt topic */
-    StatusHandler handler;
     if (!handler.wait_for(StatusHandler::IP_Event, 60000)) {
         ESP_LOGE(TAG, "Cannot get IP within specified timeout... exiting");
         return;

components/esp_modem/examples/simple_cmux_client/pytest_cmux.py

@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+from __future__ import print_function, unicode_literals
+
+
+def test_cmux_connection(dut):
+    """
+    steps:
+      1. initializes connection with SIM800
+      2. checks we get an IP
+      3. checks for the MQTT events
+    """
+    # Check the sequence of connecting, publishing, disconnecting
+    dut.expect('Modem has correctly entered multiplexed')
+    # Check for MQTT connection and the data event
+    dut.expect('TOPIC: /topic/esp-modem')
+    dut.expect('DATA: Hello modem')

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

@@ -0,0 +1,17 @@
+CONFIG_IDF_TARGET="esp32c3"
+# 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_ESP_SYSTEM_PANIC_PRINT_HALT=y
+CONFIG_ESP32_PANIC_PRINT_HALT=y
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
+CONFIG_EXAMPLE_CLOSE_CMUX_AT_END=y

components/esp_modem/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.0.1"
+version: "1.0.3"
 description: esp modem
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_modem
 dependencies:

components/esp_modem/include/cxx_include/esp_modem_cmux.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -86,9 +86,30 @@ public:
      */
     int write(int i, uint8_t *data, size_t len);
 
+    /**
+     * @brief Recovers the protocol
+     *
+     * This restarts the CMUX state machine, which could have been in a wrong state due to communication
+     * issue on a lower layer.
+     *
+     * @return true on success
+     */
+    bool recover();
+
 private:
+
+    enum class protocol_mismatch_reason {
+        MISSED_LEAD_SOF,
+        MISSED_TRAIL_SOF,
+        WRONG_CRC,
+        UNEXPECTED_HEADER,
+        UNEXPECTED_DATA,
+        READ_BEHIND_BUFFER,
+        UNKNOWN
+    };
+
     static uint8_t fcs_crc(const uint8_t frame[6]);     /*!< Utility to calculate FCS CRC */
-    void data_available(uint8_t *data, size_t len);     /*!< Called when valid data available */
+    bool data_available(uint8_t *data, size_t len);     /*!< Called when valid data available (returns false on unexpected data format) */
     void send_sabm(size_t i);                           /*!< Sending initial SABM */
     void send_disconnect(size_t i);                     /*!< Sending closing request for each virtual or control terminal */
     bool on_cmux_data(uint8_t *data, size_t len);       /*!< Called from terminal layer when raw CMUX protocol data available */
@@ -105,6 +126,7 @@ private:
     bool on_header(CMuxFrame &frame);
     bool on_payload(CMuxFrame &frame);
     bool on_footer(CMuxFrame &frame);
+    void recover_protocol(protocol_mismatch_reason reason);
 
     std::function<bool(uint8_t *data, size_t len)> read_cb[MAX_TERMINALS_NUM];  /*!< Function pointers to read callbacks */
     std::shared_ptr<Terminal> term;                   /*!< The original terminal */

components/esp_modem/include/cxx_include/esp_modem_dce.hpp

@@ -84,6 +84,11 @@ public:
         return mode.set(dte.get(), device.get(), netif, m);
     }
 
+    bool recover()
+    {
+        return dte->recover();
+    }
+
 protected:
     std::shared_ptr<DTE> dte;
     std::shared_ptr<SpecificModule> device;

components/esp_modem/include/cxx_include/esp_modem_dce_factory.hpp

@@ -236,6 +236,14 @@ public:
         return nullptr;
     }
 
+    template <typename T_Module>
+    static std::unique_ptr<DCE> create_unique_dce_from(const esp_modem::dce_config *config,
+            std::shared_ptr<esp_modem::DTE> dte,
+            esp_netif_t *netif)
+    {
+        return build_generic_DCE<T_Module, DCE, std::unique_ptr<DCE>>(config, std::move(dte), netif);
+    }
+
 private:
     ModemType m;
 

components/esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -79,6 +79,13 @@ public:
      */
     void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f);
 
+    /**
+     * @brief Sets read callback for manual command processing
+     * Note that this API also locks the command API, which can only be used
+     * after you remove the callback by dte->on_read(nullptr)
+     *
+     * @param on_data Function to be called when a command response is available
+     */
     void on_read(got_line_cb on_data) override;
 
     /**
@@ -108,6 +115,13 @@ public:
      */
     command_result command(const std::string &command, got_line_cb got_line, uint32_t time_ms, char separator) override;
 
+    /**
+     * @brief Allows this DTE to recover from a generic connection issue
+     *
+     * @return true if success
+     */
+    bool recover();
+
 protected:
     /**
      * @brief Allows for locking the DTE
@@ -122,10 +136,11 @@ protected:
     }
     friend class Scoped<DTE>;                               /*!< Declaring "Scoped<DTE> lock(dte)" locks this instance */
 private:
-    static const size_t GOT_LINE = SignalGroup::bit0;       /*!< Bit indicating response available */
 
+    void handle_error(terminal_error err);                  /*!< Performs internal error handling */
     [[nodiscard]] bool setup_cmux();                        /*!< Internal setup of CMUX mode */
-    [[nodiscard]] bool exit_cmux();                         /*!< Exit of CMUX mode */
+    [[nodiscard]] bool exit_cmux();                         /*!< Exit of CMUX mode and cleanup  */
+    void exit_cmux_internal();                              /*!< Cleanup CMUX */
 
     Lock internal_lock{};                                   /*!< Locks DTE operations */
     unique_buffer buffer;                                   /*!< DTE buffer */
@@ -133,9 +148,82 @@ private:
     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 */
     std::function<bool(uint8_t *data, size_t len)> on_data; /*!< on data callback for current terminal */
+    std::function<void(terminal_error err)> user_error_cb;  /*!< user callback on error event from attached terminals */
+
+#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+    /**
+     * @brief Implements an extra buffer that is used to capture partial reads from underlying terminals
+     * when we run out of the standard buffer
+     */
+    struct extra_buffer {
+        extra_buffer(): buffer(nullptr) {}
+        ~extra_buffer()
+        {
+            delete buffer;
+        }
+        std::vector<uint8_t> *buffer;
+        size_t consumed{0};
+        void grow(size_t need_size);
+        void deflate()
+        {
+            grow(0);
+            consumed = 0;
+        }
+        [[nodiscard]] uint8_t *begin() const
+        {
+            return &buffer->at(0);
+        }
+        [[nodiscard]] uint8_t *current() const
+        {
+            return &buffer->at(0) + consumed;
+        }
+    } inflatable;
+#endif // CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+
+    /**
+     * @brief Set internal command callbacks to the underlying terminal.
+     * Here we capture command replies to be processed by supplied command callbacks in  struct command_cb.
+     */
+    void set_command_callbacks();
+
+    /**
+     * @brief This abstracts command callback processing and implements its locking, signaling of completion and timeouts.
+     */
+    struct command_cb {
+        static const size_t GOT_LINE = SignalGroup::bit0;       /*!< Bit indicating response available */
+        got_line_cb got_line;                                   /*!< Supplied command callback */
+        Lock line_lock{};                                       /*!< Command callback locking mechanism */
+        char separator{};                                       /*!< Command reply separator (end of line/processing unit) */
+        command_result result{};                                /*!< Command return code */
+        SignalGroup signal;                                     /*!< Event group used to signal request-response operations */
+        bool process_line(uint8_t *data, size_t consumed, size_t len);  /*!< Lets the processing callback handle one line (processing unit) */
+        bool wait_for_line(uint32_t time_ms)                    /*!< Waiting for command processing */
+        {
+            return signal.wait_any(command_cb::GOT_LINE, time_ms);
+        }
+        void set(got_line_cb l, char s = '\n')                  /*!< Sets the command callback atomically */
+        {
+            Scoped<Lock> lock(line_lock);
+            if (l) {
+                // if we set the line callback, we have to reset the signal and the result
+                signal.clear(GOT_LINE);
+                result = command_result::TIMEOUT;
+            } else {
+                // if we clear the line callback, we check consistency (since we've locked the line processing)
+                if (signal.is_any(command_cb::GOT_LINE) && result == command_result::TIMEOUT) {
+                    ESP_MODEM_THROW_IF_ERROR(ESP_ERR_INVALID_STATE);
+                }
+            }
+            got_line = std::move(l);
+            separator = s;
+        }
+        void give_up()                                          /*!< Reports other than timeout error when processing replies (out of buffer) */
+        {
+            result = command_result::FAIL;
+            signal.set(GOT_LINE);
+        }
+    } command_cb;                                               /*!< Command callback utility class */
 };
 
 /**

components/esp_modem/include/cxx_include/esp_modem_netif.hpp

@@ -54,9 +54,10 @@ public:
      */
     void stop();
 
-private:
     void receive(uint8_t *data, size_t len);
 
+private:
+
     static esp_err_t esp_modem_dte_transmit(void *h, void *buffer, size_t len);
 
     static esp_err_t esp_modem_post_attach(esp_netif_t *esp_netif, void *args);

components/esp_modem/include/vfs_resource/vfs_create.hpp

@@ -14,7 +14,7 @@
             .stop_bits = UART_STOP_BITS_1,          \
             .parity = UART_PARITY_DISABLE,          \
             .flow_control = ESP_MODEM_FLOW_CONTROL_NONE,\
-            .source_clk = UART_SCLK_APB,            \
+            .source_clk = ESP_MODEM_DEFAULT_UART_CLK,   \
             .baud_rate = 115200,                    \
             .tx_io_num = 25,                        \
             .rx_io_num = 26,                        \

components/esp_modem/src/esp_modem_cmux.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -113,7 +113,7 @@ struct CMux::CMuxFrame {
     }
 };
 
-void CMux::data_available(uint8_t *data, size_t len)
+bool CMux::data_available(uint8_t *data, size_t len)
 {
     if (data && (type & FT_UIH) == FT_UIH && len > 0 && dlci > 0) { // valid payload on a virtual term
         int virtual_term = dlci - 1;
@@ -128,32 +128,38 @@ void CMux::data_available(uint8_t *data, size_t len)
 #else
             read_cb[virtual_term](data, len);
 #endif
+        } else {
+            return false;
         }
-    } else if (data == nullptr && type == 0x73 && len == 0) { // notify the initial SABM command
+    } else if (data == nullptr && type == (FT_UA | PF) && len == 0) { // notify the initial SABM command
         Scoped<Lock> l(lock);
         sabm_ack = dlci;
-    } else if (data == nullptr) {
+    } else if (data == nullptr && dlci > 0) {
         int virtual_term = dlci - 1;
         if (virtual_term < MAX_TERMINALS_NUM && read_cb[virtual_term]) {
 #ifdef DEFRAGMENT_CMUX_PAYLOAD
             read_cb[virtual_term](payload_start, total_payload_size);
 #endif
+        } else {
+            return false;
         }
     } else if ((type & FT_UIH) == FT_UIH && dlci == 0) { // notify the internal DISC command
-        if (len > 0 && (data[0] & 0xE1) == 0xE1) {
+        if ((len > 0 && (data[0] & 0xE1) == 0xE1) || (data == nullptr)) {
             // Not a DISC, ignore (MSC frame)
-            return;
+            return true;
         }
         Scoped<Lock> l(lock);
         sabm_ack = dlci;
+    } else {
+        return false;
     }
+    return true;
 }
 
 bool CMux::on_init(CMuxFrame &frame)
 {
     if (frame.ptr[0] != SOF_MARKER) {
-        ESP_LOGW("CMUX", "Protocol mismatch: Missed leading SOF, recovering...");
-        state = cmux_state::RECOVER;
+        recover_protocol(protocol_mismatch_reason::MISSED_LEAD_SOF);
         return true;
     }
     if (frame.len > 1 && frame.ptr[1] == SOF_MARKER) {
@@ -206,6 +212,7 @@ bool CMux::on_header(CMuxFrame &frame)
     }
     size_t payload_offset = std::min(frame.len, 4 - frame_header_offset);
     memcpy(frame_header + frame_header_offset, frame.ptr, payload_offset);
+#ifndef ESP_MODEM_CMUX_USE_SHORT_PAYLOADS_ONLY
     if ((frame_header[3] & 1) == 0) {
         if (frame_header_offset + frame.len <= 4) {
             frame_header_offset += frame.len;
@@ -215,12 +222,21 @@ bool CMux::on_header(CMuxFrame &frame)
         memcpy(frame_header + frame_header_offset, frame.ptr, payload_offset);
         payload_len = frame_header[4] << 7;
         frame_header_offset += payload_offset - 1; // rewind frame_header back to hold only 6 bytes size
-    } else {
+    } else
+#endif // ! ESP_MODEM_CMUX_USE_SHORT_PAYLOADS_ONLY
+    {
         payload_len = 0;
         frame_header_offset += payload_offset;
     }
     dlci = frame_header[1] >> 2;
     type = frame_header[2];
+    // Sanity check for expected values of DLCI and type,
+    // since CRC could be evaluated after the frame payload gets received
+    if (dlci > MAX_TERMINALS_NUM || (frame_header[1] & 0x01) == 0 ||
+            (((type & FT_UIH) != FT_UIH) &&  type != (FT_UA | PF) ) ) {
+        recover_protocol(protocol_mismatch_reason::UNEXPECTED_HEADER);
+        return true;
+    }
     payload_len += (frame_header[3] >> 1);
     frame.advance(payload_offset);
     state = cmux_state::PAYLOAD;
@@ -232,12 +248,18 @@ bool CMux::on_payload(CMuxFrame &frame)
     ESP_LOGD("CMUX", "Payload frame: dlci:%02x type:%02x payload:%d available:%d", dlci, type, payload_len, frame.len);
     if (frame.len < payload_len) { // payload
         state = cmux_state::PAYLOAD;
-        data_available(frame.ptr, frame.len); // partial read
+        if (!data_available(frame.ptr, frame.len)) { // partial read
+            recover_protocol(protocol_mismatch_reason::UNEXPECTED_DATA);
+            return true;
+        }
         payload_len -= frame.len;
         return false;
     } else { // complete
         if (payload_len > 0) {
-            data_available(&frame.ptr[0], payload_len); // rest read
+            if (!data_available(&frame.ptr[0], payload_len)) { // rest read
+                recover_protocol(protocol_mismatch_reason::UNEXPECTED_DATA);
+                return true;
+            }
         }
         frame.advance((payload_len));
         state = cmux_state::FOOTER;
@@ -257,16 +279,23 @@ bool CMux::on_footer(CMuxFrame &frame)
         footer_offset = std::min(frame.len, 6 - frame_header_offset);
         memcpy(frame_header + frame_header_offset, frame.ptr, footer_offset);
         if (frame_header[5] != SOF_MARKER) {
-            ESP_LOGW("CMUX", "Protocol mismatch: Missed trailing SOF, recovering...");
-            payload_start = nullptr;
-            total_payload_size = 0;
-            state = cmux_state::RECOVER;
+            recover_protocol(protocol_mismatch_reason::MISSED_TRAIL_SOF);
             return true;
         }
+#ifdef ESP_MODEM_CMUX_USE_SHORT_PAYLOADS_ONLY
+        uint8_t crc = 0xFF - fcs_crc(frame_header);
+        if (crc != frame_header[4]) {
+            recover_protocol(protocol_mismatch_reason::WRONG_CRC);
+            return true;
+        }
+#endif
         frame.advance(footer_offset);
         state = cmux_state::INIT;
         frame_header_offset = 0;
-        data_available(nullptr, 0);
+        if (!data_available(nullptr, 0)) {
+            recover_protocol(protocol_mismatch_reason::UNEXPECTED_DATA);
+            return true;
+        }
         payload_start = nullptr;
         total_payload_size = 0;
     }
@@ -280,7 +309,28 @@ bool CMux::on_cmux_data(uint8_t *data, size_t actual_len)
         auto data_to_read = buffer.size - 128; // keep 128 (max CMUX payload) backup buffer)
         if (payload_start) {
             data = payload_start + total_payload_size;
-            data_to_read = payload_len + 2;
+            auto data_end = buffer.get() + buffer.size;
+            data_to_read = payload_len + 2; // 2 -- CMUX protocol footer
+            if (data + data_to_read >= data_end) {
+                ESP_LOGW("CUMX", "Failed to defragment longer payload (payload=%d)", payload_len);
+                // If you experience this error, your device uses longer payloads while
+                // the configured buffer is too small to defragment the payload properly.
+                // To resolve this issue you can:
+                // * Either increase `dte_buffer_size`
+                // * Or disable `ESP_MODEM_CMUX_DEFRAGMENT_PAYLOAD` in menuconfig
+
+                // Attempts to process the data accumulated so far (rely on upper layers to process correctly)
+                data_available(nullptr, 0);
+                if (payload_len > total_payload_size) {
+                    payload_start = nullptr;
+                    total_payload_size = 0;
+                } else {
+                    // cannot continue with this payload, give-up and recover the protocol
+                    recover_protocol(protocol_mismatch_reason::READ_BEHIND_BUFFER);
+                }
+                data_to_read = buffer.size;
+                data = buffer.get();
+            }
         } else {
             data = buffer.get();
         }
@@ -435,3 +485,19 @@ std::pair<std::shared_ptr<Terminal>, unique_buffer> CMux::detach()
 {
     return std::make_pair(std::move(term), std::move(buffer));
 }
+
+void esp_modem::CMux::recover_protocol(protocol_mismatch_reason reason)
+{
+    ESP_LOGW("CMUX", "Restarting CMUX state machine (reason: %d)", static_cast<int>(reason));
+    payload_start = nullptr;
+    total_payload_size = 0;
+    frame_header_offset = 0;
+    state = cmux_state::RECOVER;
+}
+
+bool CMux::recover()
+{
+    Scoped<Lock> l(lock);
+    recover_protocol(protocol_mismatch_reason::UNKNOWN);
+    return true;
+}

components/esp_modem/src/esp_modem_dce.cpp

@@ -21,10 +21,17 @@ 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 {
+    dte.set_read_cb([&netif, weak_signal](uint8_t *data, size_t len) -> bool {
+        // post the transitioning data to the network layers if it contains PPP SOF marker
+        if (memchr(data, 0x7E, len))
+        {
+            ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data (PPP)", data, len, ESP_LOG_DEBUG);
+            netif.receive(data, len);
+        }
+        // treat the transitioning data as a textual message if it contains a newline char
         if (memchr(data, '\n', len))
         {
-            ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, len, ESP_LOG_DEBUG);
+            ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data (CMD)", data, len, ESP_LOG_DEBUG);
             const auto pass = std::list<std::string_view>({"NO CARRIER", "DISCONNECTED"});
             std::string_view response((char *) data, len);
             for (auto &it : pass)
@@ -39,6 +46,7 @@ static bool exit_data(DTE &dte, ModuleIf &device, Netif &netif)
     });
     netif.wait_until_ppp_exits();
     if (!signal->wait(1, 2000)) {
+        dte.set_read_cb(nullptr);
         if (!device.set_mode(modem_mode::COMMAND_MODE)) {
             return false;
         }

components/esp_modem/src/esp_modem_dte.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -17,53 +17,131 @@ 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), primary_term(std::move(terminal)), secondary_term(primary_term),
-    mode(modem_mode::UNDEF) {}
+    mode(modem_mode::UNDEF)
+{
+    set_command_callbacks();
+}
 
 DTE::DTE(std::unique_ptr<Terminal> terminal):
     buffer(dte_default_buffer_size),
     cmux_term(nullptr), primary_term(std::move(terminal)), secondary_term(primary_term),
-    mode(modem_mode::UNDEF) {}
+    mode(modem_mode::UNDEF)
+{
+    set_command_callbacks();
+}
 
 DTE::DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> t, std::unique_ptr<Terminal> s):
     buffer(config->dte_buffer_size),
     cmux_term(nullptr), primary_term(std::move(t)), secondary_term(std::move(s)),
-    mode(modem_mode::DUAL_MODE) {}
+    mode(modem_mode::UNDEF)
+{
+    set_command_callbacks();
+}
 
 DTE::DTE(std::unique_ptr<Terminal> t, std::unique_ptr<Terminal> s):
     buffer(dte_default_buffer_size),
     cmux_term(nullptr), primary_term(std::move(t)), secondary_term(std::move(s)),
-    mode(modem_mode::DUAL_MODE) {}
+    mode(modem_mode::UNDEF)
+{
+    set_command_callbacks();
+}
+
+void DTE::set_command_callbacks()
+{
+    primary_term->set_read_cb([this](uint8_t *data, size_t len) {
+        Scoped<Lock> l(command_cb.line_lock);
+        if (command_cb.got_line == nullptr) {
+            return false;
+        }
+        if (data) {
+            // For terminals which post data directly with the callback (CMUX)
+            // we cannot defragment unless we allocate, but
+            // we'll try to process the data on the actual buffer
+#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+            if (inflatable.consumed != 0) {
+                inflatable.grow(inflatable.consumed + len);
+                std::memcpy(inflatable.current(), data, len);
+                data = inflatable.begin();
+            }
+            if (command_cb.process_line(data, inflatable.consumed, len)) {
+                return true;
+            }
+            // at this point we're sure that the data processing hasn't finished,
+            // and we have to grow the inflatable buffer (if enabled) or give up
+            if (inflatable.consumed == 0) {
+                inflatable.grow(len);
+                std::memcpy(inflatable.begin(), data, len);
+            }
+            inflatable.consumed += len;
+            return false;
+#else
+            if (command_cb.process_line(data, 0, len)) {
+                return true;
+            }
+            // cannot inflate and the processing hasn't finishes in the first iteration -> report a failure
+            command_cb.give_up();
+            return true;
+#endif
+        }
+        // data == nullptr: Terminals which request users to read current data
+        // we're able to use DTE's buffer to defragment it; as long as we consume less that the buffer size
+        if (buffer.size > buffer.consumed) {
+            data = buffer.get();
+            len = primary_term->read(data + buffer.consumed, buffer.size - buffer.consumed);
+            if (command_cb.process_line(data, buffer.consumed, len)) {
+                return true;
+            }
+            buffer.consumed += len;
+            return false;
+        }
+        // we have used the entire DTE's buffer, need to use the inflatable buffer to continue
+#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+        if (inflatable.consumed == 0) {
+            inflatable.grow(buffer.size + len);
+            std::memcpy(inflatable.begin(), buffer.get(), buffer.size);
+            inflatable.consumed = buffer.size;
+        } else {
+            inflatable.grow(inflatable.consumed + len);
+        }
+        len = primary_term->read(inflatable.current(), len);
+        if (command_cb.process_line(inflatable.begin(), inflatable.consumed, len)) {
+            return true;
+        }
+        inflatable.consumed += len;
+        return false;
+#else
+        // cannot inflate -> report a failure
+        command_cb.give_up();
+        return true;
+#endif
+    });
+    primary_term->set_error_cb([this](terminal_error err) {
+        if (user_error_cb) {
+            user_error_cb(err);
+        }
+        handle_error(err);
+    });
+    secondary_term->set_error_cb([this](terminal_error err) {
+        if (user_error_cb) {
+            user_error_cb(err);
+        }
+        handle_error(err);
+    });
+
+}
 
 command_result DTE::command(const std::string &command, got_line_cb got_line, uint32_t time_ms, const char separator)
 {
-    Scoped<Lock> l(internal_lock);
-    result = command_result::TIMEOUT;
-    signal.clear(GOT_LINE);
-    primary_term->set_read_cb([this, got_line, separator](uint8_t *data, size_t len) {
-        if (!data) {
-            data = buffer.get();
-            len = primary_term->read(data + buffer.consumed, buffer.size - buffer.consumed);
-        } else {
-            buffer.consumed = 0; // if the underlying terminal contains data, we cannot fragment
-        }
-        if (memchr(data + buffer.consumed, separator, len)) {
-            result = got_line(data, buffer.consumed + len);
-            if (result == command_result::OK || result == command_result::FAIL) {
-                signal.set(GOT_LINE);
-                return true;
-            }
-        }
-        buffer.consumed += len;
-        return false;
-    });
+    Scoped<Lock> l1(internal_lock);
+    command_cb.set(got_line, separator);
     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);
-    }
+    command_cb.wait_for_line(time_ms);
+    command_cb.set(nullptr);
     buffer.consumed = 0;
-    primary_term->set_read_cb(nullptr);
-    return result;
+#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+    inflatable.deflate();
+#endif
+    return command_cb.result;
 }
 
 command_result DTE::command(const std::string &cmd, got_line_cb got_line, uint32_t time_ms)
@@ -76,12 +154,22 @@ bool DTE::exit_cmux()
     if (!cmux_term->deinit()) {
         return false;
     }
+    exit_cmux_internal();
+    return true;
+}
+
+void DTE::exit_cmux_internal()
+{
+    if (!cmux_term) {
+        return;
+    }
+
     auto ejected = cmux_term->detach();
     // return the ejected terminal and buffer back to this DTE
     primary_term = std::move(ejected.first);
     buffer = std::move(ejected.second);
     secondary_term = primary_term;
-    return true;
+    set_command_callbacks();
 }
 
 bool DTE::setup_cmux()
@@ -90,14 +178,21 @@ bool DTE::setup_cmux()
     if (cmux_term == nullptr) {
         return false;
     }
+
     if (!cmux_term->init()) {
+        exit_cmux_internal();
+        cmux_term = nullptr;
         return false;
     }
-    primary_term = std::make_unique<CMuxInstance>(cmux_term, 0);
-    if (primary_term == nullptr) {
-        return false;
-    }
+
+    primary_term   = std::make_unique<CMuxInstance>(cmux_term, 0);
     secondary_term = std::make_unique<CMuxInstance>(cmux_term, 1);
+    if (primary_term == nullptr || secondary_term == nullptr) {
+        exit_cmux_internal();
+        cmux_term = nullptr;
+        return false;
+    }
+    set_command_callbacks();
     return true;
 }
 
@@ -119,6 +214,7 @@ bool DTE::set_mode(modem_mode m)
         if (mode == modem_mode::CMUX_MODE || mode == modem_mode::CMUX_MANUAL_MODE || mode == modem_mode::DUAL_MODE) {
             // mode stays the same, but need to swap terminals (as command has been switched)
             secondary_term.swap(primary_term);
+            set_command_callbacks();
         } else {
             mode = m;
         }
@@ -161,6 +257,7 @@ bool DTE::set_mode(modem_mode m)
     // manual CMUX transitions: Swap terminals
     if (m == modem_mode::CMUX_MANUAL_SWAP && mode == modem_mode::CMUX_MANUAL_MODE) {
         secondary_term.swap(primary_term);
+        set_command_callbacks();
         return true;
     }
     mode = modem_mode::UNDEF;
@@ -169,6 +266,10 @@ bool DTE::set_mode(modem_mode m)
 
 void DTE::set_read_cb(std::function<bool(uint8_t *, size_t)> f)
 {
+    if (f == nullptr) {
+        set_command_callbacks();
+        return;
+    }
     on_data = std::move(f);
     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
@@ -184,8 +285,8 @@ 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)
 {
-    secondary_term->set_error_cb(f);
-    primary_term->set_error_cb(f);
+    user_error_cb = std::move(f);
+    set_command_callbacks();
 }
 
 int DTE::read(uint8_t **d, size_t len)
@@ -230,6 +331,49 @@ void DTE::on_read(got_line_cb on_read_cb)
     });
 }
 
+bool DTE::command_cb::process_line(uint8_t *data, size_t consumed, size_t len)
+{
+    if (memchr(data + consumed, separator, len)) {
+        result = got_line(data, consumed + len);
+        if (result == command_result::OK || result == command_result::FAIL) {
+            signal.set(GOT_LINE);
+            return true;
+        }
+    }
+    return false;
+}
+
+bool DTE::recover()
+{
+    if (mode == modem_mode::CMUX_MODE || mode == modem_mode::CMUX_MANUAL_MODE || mode == modem_mode::DUAL_MODE) {
+        return cmux_term->recover();
+    }
+    return false;
+}
+
+void DTE::handle_error(terminal_error err)
+{
+    if (err == terminal_error::BUFFER_OVERFLOW ||
+            err == terminal_error::CHECKSUM_ERROR ||
+            err == terminal_error::UNEXPECTED_CONTROL_FLOW) {
+        recover();
+    }
+}
+
+#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
+void DTE::extra_buffer::grow(size_t need_size)
+{
+    if (need_size == 0) {
+        delete buffer;
+        buffer = nullptr;
+    } else if (buffer == nullptr) {
+        buffer = new std::vector<uint8_t>(need_size);
+    } else {
+        buffer->resize(need_size);
+    }
+}
+#endif
+
 /**
  * Implemented here to keep all headers C++11 compliant
  */

components/esp_modem/src/esp_modem_netif.cpp

@@ -49,9 +49,9 @@ esp_err_t Netif::esp_modem_post_attach(esp_netif_t *esp_netif, void *args)
     ESP_ERROR_CHECK(esp_netif_set_driver_config(esp_netif, &driver_ifconfig));
     // check if PPP error events are enabled, if not, do enable the error occurred/state changed
     // to notify the modem layer when switching modes
-    esp_netif_ppp_config_t ppp_config = { .ppp_phase_event_enabled = true,    // assuming phase enabled, as earlier IDFs
-                                          .ppp_error_event_enabled = false
-                                        }; // don't provide cfg getters so we enable both events
+    esp_netif_ppp_config_t ppp_config = { };
+    ppp_config.ppp_phase_event_enabled = true;    // assuming phase enabled, as earlier IDFs
+    ppp_config.ppp_error_event_enabled = false;   // don't provide cfg getters so we enable both events
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
     esp_netif_ppp_get_params(esp_netif, &ppp_config);
 #endif // ESP-IDF >= v4.4
@@ -65,9 +65,7 @@ esp_err_t Netif::esp_modem_post_attach(esp_netif_t *esp_netif, void *args)
 
 void Netif::receive(uint8_t *data, size_t len)
 {
-    if (signal.is_any(PPP_STARTED)) {
-        esp_netif_receive(driver.base.netif, data, len, nullptr);
-    }
+    esp_netif_receive(driver.base.netif, data, len, nullptr);
 }
 
 Netif::Netif(std::shared_ptr<DTE> e, esp_netif_t *ppp_netif) :
@@ -89,8 +87,8 @@ void Netif::start()
         receive(data, len);
         return true;
     });
-    esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
     signal.set(PPP_STARTED);
+    esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
 }
 
 void Netif::stop()

components/esp_modem/src/esp_modem_term_fs.cpp

@@ -122,9 +122,7 @@ void FdTerminal::task()
         } else {
             if (FD_ISSET(f.fd, &rfds)) {
                 if (on_read_priv) {
-                    if (on_read_priv(nullptr, 0)) {
-                        on_read_priv = nullptr;
-                    }
+                    on_read_priv(nullptr, 0);
                 }
             }
         }

components/esp_modem/src/esp_modem_uart.cpp

@@ -64,7 +64,6 @@ public:
 
     void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f) override
     {
-        ESP_MODEM_THROW_IF_FALSE(signal.wait(TASK_PARAMS, 1000), "Failed to set UART task params");
         on_read = std::move(f);
     }
 
@@ -91,7 +90,6 @@ private:
     static const size_t TASK_INIT = BIT0;
     static const size_t TASK_START = BIT1;
     static const size_t TASK_STOP = BIT2;
-    static const size_t TASK_PARAMS = BIT3;
 
     QueueHandle_t event_queue;
     uart_resource uart;
@@ -118,9 +116,7 @@ void UartTerminal::task()
         return; // exits to the static method where the task gets deleted
     }
     while (signal.is_any(TASK_START)) {
-        signal.set(TASK_PARAMS);
         if (get_event(event, 100)) {
-            signal.clear(TASK_PARAMS);
             switch (event.type) {
             case UART_DATA:
                 uart_get_buffered_data_len(uart.port, &len);

components/esp_modem/test/host_test/main/LoopbackTerm.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
  */
@@ -21,6 +21,7 @@ void LoopbackTerm::stop()
 int LoopbackTerm::write(uint8_t *data, size_t len)
 {
     if (inject_by) {    // injection test: ignore what we write, but respond with injected data
+        signal.clear(1);
         auto ret = std::async(&LoopbackTerm::batch_read, this);
         async_results.push_back(std::move(ret));
         return len;
@@ -66,6 +67,7 @@ int LoopbackTerm::write(uint8_t *data, size_t len)
             data_len = response.length();
             loopback_data.resize(data_len);
             memcpy(&loopback_data[0], &response[0], data_len);
+            signal.clear(1);
             auto ret = std::async(on_read, nullptr, data_len);
             return len;
         }
@@ -81,6 +83,7 @@ int LoopbackTerm::write(uint8_t *data, size_t len)
     loopback_data.resize(data_len + len);
     memcpy(&loopback_data[data_len], data, len);
     data_len += len;
+    signal.clear(1);
     auto ret = std::async(on_read, nullptr, data_len);
     return len;
 }
@@ -102,9 +105,15 @@ int LoopbackTerm::read(uint8_t *data, size_t len)
     return read_len;
 }
 
-LoopbackTerm::LoopbackTerm(bool is_bg96): loopback_data(), data_len(0), pin_ok(false), is_bg96(is_bg96), inject_by(0) {}
+LoopbackTerm::LoopbackTerm(bool is_bg96): loopback_data(), data_len(0), pin_ok(false), is_bg96(is_bg96), inject_by(0)
+{
+    init_signal();
+}
 
-LoopbackTerm::LoopbackTerm(): loopback_data(), data_len(0), pin_ok(false), is_bg96(false), inject_by(0) {}
+LoopbackTerm::LoopbackTerm(): loopback_data(), data_len(0), pin_ok(false), is_bg96(false), inject_by(0)
+{
+    init_signal();
+}
 
 int LoopbackTerm::inject(uint8_t *data, size_t len, size_t injected_by, size_t delay_before, size_t delay_after)
 {
@@ -132,6 +141,29 @@ void LoopbackTerm::batch_read()
         }
         Task::Delay(delay_after_inject);
     }
+    signal.set(1);
 }
 
-LoopbackTerm::~LoopbackTerm() = default;
+LoopbackTerm::~LoopbackTerm()
+{
+    data_len = 0;
+    signal.wait(1, INT32_MAX); // wait "very long" to let the std::async() finish
+}
+
+void LoopbackTerm::init_signal()
+{
+    // This indicates, that we can safely exit
+    // we clear the signal upon an async operation, so the destructor needs to wait until
+    // it's finished
+    signal.set(1);
+}
+
+void LoopbackTerm::set_read_cb(std::function<bool(uint8_t *, size_t)> f)
+{
+    user_on_read = std::move(f);
+    on_read = [this](uint8_t *data, size_t len) {
+        auto ret = user_on_read(data, len);
+        signal.set(1);
+        return ret;
+    };
+}

components/esp_modem/test/host_test/main/LoopbackTerm.h

@@ -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
  */
@@ -31,11 +31,7 @@ public:
 
     int read(uint8_t *data, size_t len) override;
 
-    void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f) override
-    {
-        Scoped<Lock> lock(on_read_guard);
-        on_read = std::move(f);
-    }
+    void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f) override;
 
 private:
     enum class status_t {
@@ -43,8 +39,10 @@ private:
         STOPPED
     };
     void batch_read();
+    std::function<bool(uint8_t *data, size_t len)> user_on_read;
     status_t status;
     SignalGroup signal;
+    void init_signal();
     std::vector<uint8_t> loopback_data;
     size_t data_len;
     bool pin_ok;

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

@@ -8,5 +8,3 @@ set_target_properties(${COMPONENT_LIB} PROPERTIES
     CXX_STANDARD_REQUIRED ON
     CXX_EXTENSIONS ON
 )
-
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/esp_modem/test/target/main/pppd_test.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
  */
@@ -27,7 +27,7 @@ static void on_modem_event(void *arg, esp_event_base_t event_base,
                            int32_t event_id, void *event_data)
 {
     if (event_base == IP_EVENT) {
-        ESP_LOGD(TAG, "IP event! %d", event_id);
+        ESP_LOGD(TAG, "IP event! %" PRId32, event_id);
         if (event_id == IP_EVENT_PPP_GOT_IP) {
             esp_netif_dns_info_t dns_info;
 
@@ -61,7 +61,7 @@ static void on_modem_event(void *arg, esp_event_base_t event_base,
 static void on_ppp_changed(void *arg, esp_event_base_t event_base,
                            int32_t event_id, void *event_data)
 {
-    ESP_LOGI(TAG, "PPP state changed event %d", event_id);
+    ESP_LOGI(TAG, "PPP state changed event %" PRId32, event_id);
     if (event_id == NETIF_PPP_ERRORUSER) {
         /* User interrupted event from esp-netif */
         esp_netif_t *netif = static_cast<esp_netif_t *>(event_data);

components/esp_mqtt_cxx/CMakeLists.txt

@@ -4,5 +4,3 @@ idf_component_register(SRCS "esp_mqtt_cxx.cpp"
                     INCLUDE_DIRS "include"
                     REQUIRES mqtt
                     )
-
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/esp_mqtt_cxx/esp_mqtt_cxx.cpp

@@ -153,7 +153,7 @@ Client::Client(esp_mqtt_client_config_t const &config) :  handler(esp_mqtt_clien
 
 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);
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIu32, base, event_id);
     auto *event = static_cast<esp_mqtt_event_t *>(event_data);
     auto &client = *static_cast<Client *>(handler_args);
     switch (event->event_id) {
@@ -215,7 +215,6 @@ 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)
 {

components/esp_mqtt_cxx/examples/ssl/main/CMakeLists.txt

@@ -1,3 +1,2 @@
 idf_component_register(SRCS "mqtt_ssl_example.cpp"
                     INCLUDE_DIRS ".")
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/esp_mqtt_cxx/examples/ssl/main/idf_component.yml

@@ -0,0 +1,5 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/esp_mqtt_cxx:
+    version: "^0.1.0"

components/esp_mqtt_cxx/examples/ssl/main/mqtt_ssl_example.cpp

@@ -54,7 +54,7 @@ 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] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
     ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
 
     esp_log_level_set("*", ESP_LOG_INFO);

components/esp_mqtt_cxx/examples/tcp/main/CMakeLists.txt

@@ -1,3 +1,2 @@
 idf_component_register(SRCS "mqtt_tcp_example.cpp"
                     INCLUDE_DIRS ".")
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/esp_mqtt_cxx/examples/tcp/main/idf_component.yml

@@ -0,0 +1,5 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/esp_mqtt_cxx:
+    version: "^0.1.0"

components/esp_mqtt_cxx/examples/tcp/main/mqtt_tcp_example.cpp

@@ -49,7 +49,7 @@ private:
 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] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
     ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
 
     esp_log_level_set("*", ESP_LOG_INFO);

components/esp_mqtt_cxx/include/esp_mqtt_client_config.hpp

@@ -166,11 +166,6 @@ struct ClientCredentials {
     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) */
@@ -201,7 +196,6 @@ struct Connection {
 };
 
 struct Configuration {
-    Event event;
     Task task;
     Session session;
     Connection connection;

components/esp_websocket_client/.cz.yaml

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

components/esp_websocket_client/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [1.1.0](https://github.com/espressif/esp-protocols/commits/websocket-v1.1.0)
+
+### Features
+
+- Added linux port for websocket ([a22391a](https://github.com/espressif/esp-protocols/commit/a22391a))
+
+### Bug Fixes
+
+- added idf_component.yml for examples ([d273e10](https://github.com/espressif/esp-protocols/commit/d273e10))
+
 ## [1.0.1](https://github.com/espressif/esp-protocols/commits/websocket-v1.0.1)
 
 ### Bug Fixes

components/esp_websocket_client/CMakeLists.txt

@@ -1,3 +1,5 @@
+idf_build_get_property(target IDF_TARGET)
+
 if(NOT CONFIG_WS_TRANSPORT AND NOT CMAKE_BUILD_EARLY_EXPANSION)
     message(STATUS "Websocket transport is disabled so the esp_websocket_client component will not be built")
     # note: the component is still included in the build so it can become visible again in config
@@ -6,7 +8,14 @@ if(NOT CONFIG_WS_TRANSPORT AND NOT CMAKE_BUILD_EARLY_EXPANSION)
     return()
 endif()
 
-idf_component_register(SRCS "esp_websocket_client.c"
+if(${IDF_TARGET} STREQUAL "linux")
+	idf_component_register(SRCS "esp_websocket_client.c"
+                    INCLUDE_DIRS "include"
+                    REQUIRES esp-tls tcp_transport http_parser esp_event nvs_flash esp_stubs json
+                    PRIV_REQUIRES esp_timer)
+else()
+    idf_component_register(SRCS "esp_websocket_client.c"
                     INCLUDE_DIRS "include"
                     REQUIRES lwip esp-tls tcp_transport http_parser
                     PRIV_REQUIRES esp_timer esp_event)
+endif()

components/esp_websocket_client/esp_websocket_client.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -19,6 +19,9 @@
 #include "esp_log.h"
 #include "esp_timer.h"
 #include "esp_tls_crypto.h"
+#include "esp_system.h"
+#include <errno.h>
+#include <arpa/inet.h>
 
 static const char *TAG = "websocket_client";
 
@@ -542,6 +545,42 @@ static esp_err_t esp_websocket_client_create_transport(esp_websocket_client_hand
     return ESP_OK;
 }
 
+static bool esp_websocket_client_send_with_exact_opcode(esp_websocket_client_handle_t client, ws_transport_opcodes_t opcode, const uint8_t *data, int len, TickType_t timeout)
+{
+    int ret = -1;
+    int need_write = len;
+    int wlen = 0, widx = 0;
+
+    while (widx < len || opcode) {  // allow for sending "current_opcode" only message with len==0
+        if (need_write > client->buffer_size) {
+            need_write = client->buffer_size;
+        }
+        memcpy(client->tx_buffer, data + widx, need_write);
+        // send with ws specific way and specific opcode
+        wlen = esp_transport_ws_send_raw(client->transport, opcode, (char *)client->tx_buffer, need_write,
+                                         (timeout == portMAX_DELAY) ? -1 : timeout * portTICK_PERIOD_MS);
+        if (wlen < 0 || (wlen == 0 && need_write != 0)) {
+            ret = wlen;
+            esp_websocket_free_buf(client, true);
+            esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
+            if (error_handle) {
+                esp_websocket_client_error(client, "esp_transport_write() returned %d, transport_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_websocket_client_error(client, "esp_transport_write() returned %d, errno=%d", ret, errno);
+            }
+            esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
+            return false;
+        }
+        opcode = 0;
+        widx += wlen;
+        need_write = len - widx;
+    }
+    esp_websocket_free_buf(client, true);
+    return true;
+}
+
 esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_client_config_t *config)
 {
     esp_websocket_client_handle_t client = calloc(1, sizeof(struct esp_websocket_client));
@@ -1089,17 +1128,33 @@ int esp_websocket_client_send_text(esp_websocket_client_handle_t client, const c
     return esp_websocket_client_send_with_opcode(client, WS_TRANSPORT_OPCODES_TEXT, (const uint8_t *)data, len, timeout);
 }
 
+int esp_websocket_client_send_text_partial(esp_websocket_client_handle_t client, const char *data, int len, TickType_t timeout)
+{
+    return esp_websocket_client_send_with_exact_opcode(client, WS_TRANSPORT_OPCODES_TEXT, (const uint8_t *)data, len, timeout);
+}
+
+int esp_websocket_client_send_cont_msg(esp_websocket_client_handle_t client, const char *data, int len, TickType_t timeout)
+{
+    return esp_websocket_client_send_with_exact_opcode(client, WS_TRANSPORT_OPCODES_CONT, (const uint8_t *)data, len, timeout);
+}
+
 int esp_websocket_client_send_bin(esp_websocket_client_handle_t client, const char *data, int len, TickType_t timeout)
 {
     return esp_websocket_client_send_with_opcode(client, WS_TRANSPORT_OPCODES_BINARY, (const uint8_t *)data, len, timeout);
 }
 
+int esp_websocket_client_send_bin_partial(esp_websocket_client_handle_t client, const char *data, int len, TickType_t timeout)
+{
+    return esp_websocket_client_send_with_exact_opcode(client, WS_TRANSPORT_OPCODES_BINARY, (const uint8_t *)data, len, timeout);
+}
+
+int esp_websocket_client_send_fin(esp_websocket_client_handle_t client, TickType_t timeout)
+{
+    return esp_websocket_client_send_with_exact_opcode(client, WS_TRANSPORT_OPCODES_FIN, NULL, 0, timeout);
+}
+
 int esp_websocket_client_send_with_opcode(esp_websocket_client_handle_t client, ws_transport_opcodes_t opcode, const uint8_t *data, int len, TickType_t timeout)
 {
-    int need_write = len;
-    int wlen = 0, widx = 0;
-    int ret = ESP_FAIL;
-
     if (client == NULL || len < 0 || (data == NULL && len > 0)) {
         ESP_LOGE(TAG, "Invalid arguments");
         return ESP_FAIL;
@@ -1123,41 +1178,13 @@ int esp_websocket_client_send_with_opcode(esp_websocket_client_handle_t client,
         ESP_LOGE(TAG, "Failed to setup tx buffer");
         goto unlock_and_return;
     }
-    uint32_t current_opcode = opcode;
-    while (widx < len || current_opcode) {  // allow for sending "current_opcode" only message with len==0
-        if (need_write > client->buffer_size) {
-            need_write = client->buffer_size;
-        } else {
-            current_opcode |= WS_TRANSPORT_OPCODES_FIN;
-        }
-        memcpy(client->tx_buffer, data + widx, need_write);
-        // send with ws specific way and specific opcode
-        wlen = esp_transport_ws_send_raw(client->transport, current_opcode, (char *)client->tx_buffer, need_write,
-                                         (timeout == portMAX_DELAY) ? -1 : timeout * portTICK_PERIOD_MS);
-        if (wlen < 0 || (wlen == 0 && need_write != 0)) {
-            ret = wlen;
-            esp_websocket_free_buf(client, true);
-            esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
-            if (error_handle) {
-                esp_websocket_client_error(client, "esp_transport_write() returned %d, transport_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_websocket_client_error(client, "esp_transport_write() returned %d, errno=%d", ret, errno);
-            }
-            esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
-            goto unlock_and_return;
-        }
-        current_opcode = 0;
-        widx += wlen;
-        need_write = len - widx;
-
+    if (esp_websocket_client_send_with_exact_opcode(client, opcode | WS_TRANSPORT_OPCODES_FIN, data, len, timeout) != true) {
+        ESP_LOGE(TAG, "Failed to send the buffer");
+        goto unlock_and_return;
     }
-    ret = widx;
-    esp_websocket_free_buf(client, true);
 unlock_and_return:
     xSemaphoreGiveRecursive(client->lock);
-    return ret;
+    return ESP_FAIL;
 }
 
 bool esp_websocket_client_is_connected(esp_websocket_client_handle_t client)

components/esp_websocket_client/examples/linux/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.5)
+
+set(COMPONENTS esp_websocket_client main)
+set(common_component_dir ../../../../common_components)
+set(EXTRA_COMPONENT_DIRS
+   ../../..
+  "${common_component_dir}/linux_compat/esp_timer"
+  "${common_component_dir}/linux_compat"
+  "${common_component_dir}/linux_compat/freertos")
+
+list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/protocols/linux_stubs/esp_stubs)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+project(websocket)

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

@@ -0,0 +1,14 @@
+idf_component_register(SRCS "main.c"
+                    INCLUDE_DIRS
+                    "."
+                    REQUIRES esp_websocket_client protocol_examples_common)
+
+if(CONFIG_GCOV_ENABLED)
+    target_compile_options(${COMPONENT_LIB} PUBLIC --coverage -fprofile-arcs -ftest-coverage)
+    target_link_options(${COMPONENT_LIB} PUBLIC  --coverage -fprofile-arcs -ftest-coverage)
+
+    idf_component_get_property(esp_websocket_client esp_websocket_client COMPONENT_LIB)
+
+    target_compile_options(${esp_websocket_client} PUBLIC --coverage -fprofile-arcs -ftest-coverage)
+    target_link_options(${esp_websocket_client} PUBLIC  --coverage -fprofile-arcs -ftest-coverage)
+endif()

components/esp_websocket_client/examples/linux/main/Kconfig.projbuild

@@ -0,0 +1,15 @@
+menu "Host-test config"
+
+    config GCOV_ENABLED
+        bool "Coverage analyzer"
+        default n
+        help
+            Enables coverage analyzing for host tests.
+
+    config WEBSOCKET_URI
+          string "Websocket endpoint URI"
+          default "ws://echo.websocket.events"
+          help
+              URL of websocket endpoint this example connects to and sends echo
+
+endmenu