Merge pull request #411 from gabsuren/bump_mdns_2

bump(mdns): 1.2.1 -> 1.2.2

.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
 

.github/workflows/modem__target-test.yml

@@ -15,7 +15,11 @@ 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 } ]
+        include:
+          - idf_ver: "latest"
+            idf_target: "esp32s2"
+            test: { app: usb_a7670_s2, path: examples/pppos_client }
     runs-on: ubuntu-20.04
     container: espressif/idf:${{ matrix.idf_ver }}
     env:
@@ -54,7 +58,11 @@ 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 } ]
+        include:
+          - idf_ver: "latest"
+            idf_target: "esp32s2"
+            test: { app: usb_a7670_s2, path: examples/pppos_client }
     needs: build_esp_modem_tests
     runs-on:
       - self-hosted

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

@@ -50,13 +50,15 @@ jobs:
             sudo apt-get -y install doxygen clang python3-pip
             python -m pip install breathe recommonmark esp-docs==1.4.1
             for comp in  `ls components`; do
-              cd $GITHUB_WORKSPACE/docs/${comp}
-              if [[ "${{ env.BUMP_COMPONENT }}" == "${comp}" ]]; then
-                echo "Building specific version of ${comp} (${{ env.BUMP_VERSION }})"
-                ./generate_docs ${{ env.BUMP_VERSION }}
-              else
-                echo "Building latest version of ${comp}"
-                ./generate_docs
+              if [[ -d $GITHUB_WORKSPACE/docs/${comp} ]]; then
+                cd $GITHUB_WORKSPACE/docs/${comp}
+                if [[ "${{ env.BUMP_COMPONENT }}" == "${comp}" ]]; then
+                  echo "Building specific version of ${comp} (${{ env.BUMP_VERSION }})"
+                  ./generate_docs ${{ env.BUMP_VERSION }}
+                else
+                  echo "Building latest version of ${comp}"
+                  ./generate_docs
+                fi
               fi
             done
       - name: Deploying generated docs
@@ -67,15 +69,17 @@ jobs:
             export GIT_VER=$(git describe --always)
             export GITHUB_REF_NAME=latest
             for comp in  `ls components`; do
-              echo "Deploying latest of ${comp}"
-              export DOCS_BUILD_DIR=$GITHUB_WORKSPACE/docs/${comp}
-              export DOCS_DEPLOY_PATH=$DOCS_DEPLOY_PATH_ORIG/${comp}
-              cd $GITHUB_WORKSPACE/docs/${comp}
-              deploy-docs
+              if [[ -d $GITHUB_WORKSPACE/docs/${comp} ]]; then
+                echo "Deploying latest of ${comp}"
+                export DOCS_BUILD_DIR=$GITHUB_WORKSPACE/docs/${comp}
+                export DOCS_DEPLOY_PATH=$DOCS_DEPLOY_PATH_ORIG/${comp}
+                cd $GITHUB_WORKSPACE/docs/${comp}
+                deploy-docs
+              fi
             done;
             # Deploy docs with version path
-            if [[ "${{ env.BUMP_VERSION }}" != "" ]]; then
-                echo "Deploying specific version of ${comp} (${{ env.BUMP_VERSION }})"
+            if [[ "${{ env.BUMP_VERSION }}" != "" ]] && [[ -d $GITHUB_WORKSPACE/docs/${{ env.BUMP_COMPONENT }} ]]; then
+                echo "Deploying specific version of ${{ env.BUMP_COMPONENT }} (${{ env.BUMP_VERSION }})"
                 cd $GITHUB_WORKSPACE/docs/${{ env.BUMP_COMPONENT }}
                 export GITHUB_REF_NAME=${{ env.BUMP_VERSION }}
                 deploy-docs
@@ -89,5 +93,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 }}

.pre-commit-config.yaml

@@ -61,8 +61,8 @@ repos:
   - repo: local
     hooks:
       - id: commit message scopes
-        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, 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]

CONTRIBUTING.md

@@ -2,6 +2,11 @@
 
 Contributions in the form of pull requests, issue reports, and feature requests are welcome!
 
+## Common Terminology:
+* [Type]: Examples include feat (for new features), fix (for bug fixes), ci (for continuous integration), bump (for version updates), etc. You can find a comprehensive list of types in .pre-commit-config.yaml on line 65.
+* [Scope]: Refers to specific sections or areas within the project, such as mdns, modem, common, console, etc. You can discover additional scopes in .pre-commit-config.yaml on line 65.
+* [Component]: This is the name of the component, and it should match the directory name where the component code is located.
+
 ## Submitting a PR
 
 - [ ] Fork the [esp-protocols repository on GitHub](https://github.com/espressif/esp-protocols) to start making your changes.
@@ -14,6 +19,37 @@ For quick merging, the contribution should be short, and concentrated on a singl
 
 Please follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) rule when writing commit messages.
 
+A typical commit message title template:
+
+Template:
+`[type]([scope]): Message`
+
+e.g.
+`feat(console): Added fully operational ifconfig command`
+
+
+## Creating a new component
+
+Steps:
+1. Add a file named .cz.yaml to the root of the component.
+
+The template for .cz.yaml should look like this:
+```
+---
+commitizen:
+  bump_message: 'bump([scope]): $current_version -> $new_version'
+  pre_bump_hooks: python ../../ci/changelog.py [component]
+  tag_format: [component]-v$version
+  version: 0.0.0
+  version_files:
+  - idf_component.yml
+```
+2. Run the following command to bump the version of the component:
+
+`ci/bump [component] [version] --bump-message "bump([scope]): First version [version]"`
+
+Replace [component], [version] and [scope] with the specific component name, version and scope you are working with. This command will help you bump the version of the component with the provided details.
+
 ## Release process
 
 When releasing a new component version we have to:

README.md

@@ -3,7 +3,7 @@
 ## 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). 
+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
@@ -33,3 +33,7 @@ Please refer to instructions in [ESP-IDF](https://github.com/espressif/esp-idf)
 
 * Brief introduction [README](components/esp_mqtt_cxx/README.md)
 * Full html [documentation](https://docs.espressif.com/projects/esp-protocols/esp_mqtt_cxx/docs/latest/index.html)
+
+### console_simple_init
+
+* Brief introduction [README](components/console_simple_init/README.md)

ci/bump

@@ -14,7 +14,7 @@ if ! cz bump --dry-run; then
 fi
 
 cz_bump_out=`cz bump --files-only "$@"`
-commit_title=`echo "${cz_bump_out}" | head -1`
+commit_title=`echo "${cz_bump_out}" | grep "bump(" | head -1`
 commit_body=`cat ../../release_notes.txt`
 
 git add -u .

ci/changelog.py

@@ -31,6 +31,11 @@ def main():
         'breaking': 'Breaking changes',
         'major': 'Major changes'
     }
+
+    res = git('show-ref', '--tags', _tty_out=False)
+    if old_ref not in res:
+        old_ref = git('rev-list', '--max-parents=0', 'HEAD', _tty_out=False).strip()
+
     brief_log = git.log('--oneline', '{}..HEAD'.format(old_ref), '--', 'components/' + component, _tty_out=False)
     for oneline in brief_log.splitlines():
         [commit, brief_msg] = oneline.split(' ', 1)
@@ -80,6 +85,11 @@ def main():
                 changelog += '- {}\n'.format(it)
     changelog += '\n'
     filename = os.path.join(root_path, 'components', component, 'CHANGELOG.md')
+    # Check if the changelog file exists.
+    if not os.path.exists(filename):
+        # File does not exist, create it
+        with open(filename, 'w') as file:
+            file.write('# Changelog\n\n')
     # insert the actual changelog to the beginning of the file, just after the title (2nd line)
     with open(filename, 'r') as orig_changelog:
         changelog_title = orig_changelog.readline(

ci/detect_component_bump

@@ -12,6 +12,7 @@ if git log -1 -m --name-only --pretty="" | grep -q components/${comp}/idf_compon
     echo "${comp}: Component version file has changed"
     version=`grep version: components/${comp}/.cz.yaml`
     version=${version#*version: }
+    version="${version//\~/_}"
 
     tag_format=`grep tag_format: components/${comp}/.cz.yaml`
     tag_format=${tag_format#*tag_format: }

components/asio/.cz.yaml

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

components/asio/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.28.0~0](https://github.com/espressif/esp-protocols/commits/asio-1.28.0~0)
+
+### Features
+
+- Updates asio to 1.28 ([b310abe](https://github.com/espressif/esp-protocols/commit/b310abe))
+
+### Bug Fixes
+
+- Makes the examples to override path ([842b2b2](https://github.com/espressif/esp-protocols/commit/842b2b2))
+- Removes esp_exception and make all examples to use exceptions ([c1c9350](https://github.com/espressif/esp-protocols/commit/c1c9350))
+- removed Wno-format flag and fixed formatting warnings ([c48e442](https://github.com/espressif/esp-protocols/commit/c48e442))
+- added idf_component.yml for examples ([d273e10](https://github.com/espressif/esp-protocols/commit/d273e10))
+- Reintroduce missing CHANGELOGs ([200cbb3](https://github.com/espressif/esp-protocols/commit/200cbb3), [#235](https://github.com/espressif/esp-protocols/issues/235))
+
+### Updated
+
+- docs(common): updated component and example links ([f48d9b2](https://github.com/espressif/esp-protocols/commit/f48d9b2))
+- docs(common): improving documentation ([ca3fce0](https://github.com/espressif/esp-protocols/commit/ca3fce0))
+- Add homepage URL and License to all components ([ef3f0ee](https://github.com/espressif/esp-protocols/commit/ef3f0ee))
+- Added badges with version of components to the respective README files ([e4c8a59](https://github.com/espressif/esp-protocols/commit/e4c8a59))
+- CI: Fix ASIO example test ([6e2bb51](https://github.com/espressif/esp-protocols/commit/6e2bb51))
+- Examples: using pytest.ini from top level directory ([aee016d](https://github.com/espressif/esp-protocols/commit/aee016d))
+- CI: fixing the files to be complient with pre-commit hooks ([945bd17](https://github.com/espressif/esp-protocols/commit/945bd17))
+
 ## [1.14.1~3](https://github.com/espressif/esp-protocols/commits/f148c98)
 
 ### Updated

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

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

components/asio/examples/async_request/README.md

@@ -25,6 +25,7 @@ The control of lifetime of the class, done by `std::shared_ptr` usage, guarantee
 async operations until it's not needed any more. This makes necessary that all of the async operation class must start
 its lifetime as a `std::shared_ptr` due to the usage of `std::enable_shared_from_this`.
 
+```
 
      User creates a shared_ptr──┐
      of AddressResolution and   │
@@ -47,6 +48,7 @@ its lifetime as a `std::shared_ptr` due to the usage of `std::enable_shared_from
                                 is called.                   │
                                                              └────►Completion Handler()
 
+```
 
 The previous diagram shows the process and the life span of each of the tasks in this examples. At each stage the
 object responsible for the last action inject itself to the completion handler of the next stage for reuse.

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

@@ -1,4 +1,6 @@
 dependencies:
   ## Required IDF version
   idf: ">=5.0"
-  espressif/asio: ">=1.0.1"
+  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

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

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

@@ -1,4 +1,6 @@
 dependencies:
   ## Required IDF version
   idf: ">=5.0"
-  espressif/asio: ">=1.0.1"
+  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

@@ -1,4 +1,6 @@
 dependencies:
   ## Required IDF version
   idf: ">=5.0"
-  espressif/asio: ">=1.0.1"
+  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

@@ -1,4 +1,6 @@
 dependencies:
   ## Required IDF version
   idf: ">=5.0"
-  espressif/asio: ">=1.0.1"
+  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/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.14.1~3"
+version: "1.28.0~0"
 description: ASIO
 url: https://github.com/espressif/esp-protocols/tree/master/components/asio
 dependencies:

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

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

components/console_simple_init/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## [1.0.2](https://github.com/espressif/esp-protocols/commits/console_simple_init-v1.0.2)
+
+### Bug Fixes
+
+- Fixed bump version check in publish-docs yml ([e834d47](https://github.com/espressif/esp-protocols/commit/e834d47))
+
+## [1.0.1](https://github.com/espressif/esp-protocols/commits/console_simple_init-v1.0.1)
+
+### Bug Fixes
+
+- Fixed versioning, publishing and changelog generation ([3081f1a69c](https://github.com/espressif/esp-protocols/commit/3081f1a69c))
+
+## [1.0.0](https://github.com/espressif/esp-protocols/commits/console_simple_init-v1.0.0)
+
+
+### Features
+
+- [Added simple component for console initialization](https://github.com/espressif/esp-protocols/commit/1ac4e4177128a7b7188babd47d0e2bfa6bbb2517)

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.2
+description: The component provides helper functions for easy initialization and start of esp console.
+url: https://github.com/espressif/esp-protocols/tree/master/components/console_simple_init
+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.4
   version_files:
   - idf_component.yml

components/esp_modem/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [1.0.4](https://github.com/espressif/esp-protocols/commits/modem-v1.0.4)
+
+### Bug Fixes
+
+- Added USB runner with ESP32S2 with A7670 ([edeb936](https://github.com/espressif/esp-protocols/commit/edeb936))
+- Extend docs on AT client example ([1f2ceed](https://github.com/espressif/esp-protocols/commit/1f2ceed))
+- Fix pytest exclusion, gitignore, and changelog checks ([2696221](https://github.com/espressif/esp-protocols/commit/2696221))
+- Fix DTE to post fragments to parsers for USB term ([1db1e15](https://github.com/espressif/esp-protocols/commit/1db1e15))
+- Fix DUAL_MODE regression from cb6e03ac ([2aada0f](https://github.com/espressif/esp-protocols/commit/2aada0f))
+- Fix AT client example to use custom AT processing ([1a5ba98](https://github.com/espressif/esp-protocols/commit/1a5ba98), [#352](https://github.com/espressif/esp-protocols/issues/352))
+
+## [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

@@ -36,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,24 @@
 ## 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.
+
+### Custom TCP transport
+
+This configuration expects that the network library, that is used to communicate with the endpoint uses `tcp_transport` component. In this example, we use `esp-mqtt` which supports custom transports so that we can implement a transport layer that communicate on TCP layer using AT commands. If we want to use TLS, we could add an SSL layer on top of this TCP layer.
+
+To enable this mode, please set `EXAMPLE_CUSTOM_TCP_TRANSPORT=y`
+
+![with custom tcp transport](at_client_tcp_transport.png)
+
+### Localhost listener
+
+This configuration could be used with any network library, which is connecting to a localhost endpoint instead of remote one. This example creates a localhost listener which basically mimics the remote endpoint by forwarding the traffic between the library and the TCP/socket layer of the modem (which is already secure if the TLS is used in the network library)
+
+![with localhost listener](at_client_localhost.png)
+
 ### Supported IDF versions
 
-This example is supported from IDF `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/pppos_client/sdkconfig.ci.usb_a7670_s2

@@ -0,0 +1,14 @@
+CONFIG_IDF_TARGET="esp32s2"
+# 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_SERIAL_CONFIG_USB=y
+CONFIG_EXAMPLE_MODEM_DEVICE_A7670=y
+CONFIG_EXAMPLE_MODEM_PPP_APN="lpwa.vodafone.com"
+CONFIG_EXAMPLE_MODEM_PPP_AUTH_NONE=y
+CONFIG_EXAMPLE_MQTT_TEST_TOPIC="/ci/esp-modem/pppos-client"
+CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
+CONFIG_ESP32_PANIC_PRINT_HALT=y

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.4"
 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_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
  */
@@ -115,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
@@ -130,6 +137,7 @@ protected:
     friend class Scoped<DTE>;                               /*!< Declaring "Scoped<DTE> lock(dte)" locks this instance */
 private:
 
+    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 and cleanup  */
     void exit_cmux_internal();                              /*!< Cleanup CMUX */
@@ -141,6 +149,7 @@ private:
     std::shared_ptr<Terminal> secondary_term;               /*!< Secondary terminal for this DTE */
     modem_mode mode;                                        /*!< DTE operation mode */
     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
     /**
@@ -189,7 +198,10 @@ private:
         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 */
+        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);
@@ -197,6 +209,11 @@ private:
                 // 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;

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_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
  */
@@ -33,7 +33,7 @@ DTE::DTE(std::unique_ptr<Terminal> terminal):
 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::UNDEF)
+    mode(modem_mode::DUAL_MODE)
 {
     set_command_callbacks();
 }
@@ -41,7 +41,7 @@ DTE::DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> t, std::u
 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::UNDEF)
+    mode(modem_mode::DUAL_MODE)
 {
     set_command_callbacks();
 }
@@ -78,9 +78,9 @@ void DTE::set_command_callbacks()
             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;
+            // cannot inflate and the processing hasn't finishes in the first iteration, but continue
+            // (will post next fragments to the parser, since we might be just missing a last token or OK
+            return false;
 #endif
         }
         // data == nullptr: Terminals which request users to read current data
@@ -115,6 +115,19 @@ void DTE::set_command_callbacks()
         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)
@@ -272,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)
@@ -300,6 +313,7 @@ void DTE::on_read(got_line_cb on_read_cb)
     if (on_read_cb == nullptr) {
         primary_term->set_read_cb(nullptr);
         internal_lock.unlock();
+        set_command_callbacks();
         return;
     }
     internal_lock.lock();
@@ -330,13 +344,21 @@ bool DTE::command_cb::process_line(uint8_t *data, size_t consumed, size_t len)
     return false;
 }
 
-bool DTE::command_cb::wait_for_line(uint32_t time_ms)
+bool DTE::recover()
 {
-    auto got_lf = signal.wait(command_cb::GOT_LINE, time_ms);
-    if (got_lf && result == command_result::TIMEOUT) {
-        ESP_MODEM_THROW_IF_ERROR(ESP_ERR_INVALID_STATE);
+    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();
     }
-    return got_lf;
 }
 
 #ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED

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

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

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

components/esp_mqtt_cxx/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.2.0](https://github.com/espressif/esp-protocols/commits/mqtt_cxx-v0.2.0)
+
+### Features
+
+- configure client authentication via certificate/key or secure element ([ee09ff4](https://github.com/espressif/esp-protocols/commit/ee09ff4))
+
+### Bug Fixes
+
+- removed Wno-format flag and fixed formatting warnings ([c48e442](https://github.com/espressif/esp-protocols/commit/c48e442))
+- Removes meaningless printf on subscribed handler (#358) ([bac742d](https://github.com/espressif/esp-protocols/commit/bac742d), [#356](https://github.com/espressif/esp-protocols/issues/356))
+- Removes unused type for configuration ([839c79d](https://github.com/espressif/esp-protocols/commit/839c79d))
+- added idf_component.yml for examples ([d273e10](https://github.com/espressif/esp-protocols/commit/d273e10))
+- Reintroduce missing CHANGELOGs ([200cbb3](https://github.com/espressif/esp-protocols/commit/200cbb3), [#235](https://github.com/espressif/esp-protocols/issues/235))
+
+### Updated
+
+- docs(common): updated component and example links ([f48d9b2](https://github.com/espressif/esp-protocols/commit/f48d9b2))
+- docs(esp_mqtt_cxx): updated documentation and deployment file ([a547ec8](https://github.com/espressif/esp-protocols/commit/a547ec8))
+- docs(common): improving documentation ([ca3fce0](https://github.com/espressif/esp-protocols/commit/ca3fce0))
+- Add homepage URL and License to all components ([ef3f0ee](https://github.com/espressif/esp-protocols/commit/ef3f0ee))
+
 ## [0.1.0](https://github.com/espressif/esp-protocols/commits/1407dfc)
 
 ### Updated

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

@@ -1,4 +1,4 @@
-version: "0.1.0"
+version: "0.2.0"
 description: esp mqtt cxx
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_mqtt_cxx
 dependencies:

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/.gitignore

@@ -1,93 +0,0 @@
-.config
-*.o
-*.pyc
-
-# gtags
-GTAGS
-GRTAGS
-GPATH
-
-# emacs
-.dir-locals.el
-
-# emacs temp file suffixes
-*~
-.#*
-\#*#
-
-# eclipse setting
-.settings
-
-# MacOS directory files
-.DS_Store
-
-# Components Unit Test Apps files
-components/**/build
-components/**/sdkconfig
-components/**/sdkconfig.old
-
-# Example project files
-examples/**/sdkconfig
-examples/**/sdkconfig.old
-examples/**/build
-
-# Doc build artifacts
-docs/_build/
-docs/doxygen_sqlite3.db
-
-# Downloaded font files
-docs/_static/DejaVuSans.ttf
-docs/_static/NotoSansSC-Regular.otf
-
-# Unit test app files
-tools/unit-test-app/sdkconfig
-tools/unit-test-app/sdkconfig.old
-tools/unit-test-app/build
-tools/unit-test-app/builds
-tools/unit-test-app/output
-tools/unit-test-app/test_configs
-
-# Unit Test CMake compile log folder
-log_ut_cmake
-
-# test application build files
-test/**/build
-test/**/sdkconfig
-test/**/sdkconfig.old
-
-# IDF monitor test
-tools/test_idf_monitor/outputs
-
-TEST_LOGS
-
-# gcov coverage reports
-*.gcda
-*.gcno
-coverage.info
-coverage_report/
-
-test_multi_heap_host
-
-# VS Code Settings
-.vscode/
-
-# VIM files
-*.swp
-*.swo
-
-# Clion IDE CMake build & config
-.idea/
-cmake-build-*/
-
-# Results for the checking of the Python coding style and static analysis
-.mypy_cache
-flake8_output.txt
-
-# ESP-IDF default build directory name
-build
-
-# lock files for examples and components
-dependencies.lock
-
-# ignore generated docs
-docs/html