Merge pull request #367 from david-cermak/test/sim800_cmux

fix(modem): Release v1.0.3: Fixes CMUX on SIM800

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

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

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

components/asio/CMakeLists.txt

@@ -27,7 +27,6 @@ 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")
 
 if(CONFIG_ASIO_SSL_SUPPORT)
     if(CONFIG_ASIO_USE_ESP_WOLFSSL)

components/esp_modem/.cz.yaml

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

components/esp_modem/CHANGELOG.md

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

components/esp_modem/Kconfig

@@ -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/main/CMakeLists.txt

@@ -9,4 +9,3 @@ idf_component_register(SRCS "modem_client.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/modem_client.cpp

@@ -34,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;

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;
     }

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

@@ -128,7 +128,7 @@ esp_modem::return_type name(__VA_ARGS__);
             return false;
         }
         if (state != status::IDLE) {
-            ESP_LOGE("dce", "Unexpected state %d", state);
+            ESP_LOGE("dce", "Unexpected state %d", static_cast<int>(state));
             return false;
         }
         return true;

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

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

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

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

components/esp_modem/examples/simple_cmux_client/pytest_cmux.py

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

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

@@ -0,0 +1,17 @@
+CONFIG_IDF_TARGET="esp32c3"
+# Override some defaults to enable PPP
+CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_LWIP_PPP_NOTIFY_PHASE_SUPPORT=y
+CONFIG_LWIP_PPP_PAP_SUPPORT=y
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=4096
+CONFIG_LWIP_PPP_ENABLE_IPV6=n
+CONFIG_EXAMPLE_MODEM_UART_TX_PIN=4
+CONFIG_EXAMPLE_MODEM_UART_RX_PIN=5
+CONFIG_EXAMPLE_MODEM_DEVICE_SIM800=y
+CONFIG_EXAMPLE_MODEM_DEVICE_BG96=n
+CONFIG_EXAMPLE_MODEM_PPP_APN="lpwa.vodafone.com"
+CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
+CONFIG_ESP32_PANIC_PRINT_HALT=y
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
+CONFIG_EXAMPLE_CLOSE_CMUX_AT_END=y

components/esp_modem/idf_component.yml

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

components/esp_modem/include/cxx_include/esp_modem_cmux.hpp

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

components/esp_modem/include/cxx_include/esp_modem_dce.hpp

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

components/esp_modem/include/cxx_include/esp_modem_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
  */
@@ -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)
@@ -330,13 +343,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/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/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/mdns/CMakeLists.txt

@@ -20,7 +20,6 @@ idf_component_register(
         PRIV_INCLUDE_DIRS "private_include"
         REQUIRES ${dependencies}
         PRIV_REQUIRES ${private_dependencies})
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
 
 if(${target} STREQUAL "linux")
     target_link_libraries(${COMPONENT_LIB} PRIVATE "-lbsd")

components/mdns/examples/main/CMakeLists.txt

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

components/mdns/examples/main/mdns_example_main.c

@@ -94,7 +94,7 @@ static void mdns_print_results(mdns_result_t *results)
     int i = 1, t;
     while (r) {
         if (r->esp_netif) {
-            printf("%d: Interface: %s, Type: %s, TTL: %u\n", i++, esp_netif_get_ifkey(r->esp_netif),
+            printf("%d: Interface: %s, Type: %s, TTL: %" PRIu32 "\n", i++, esp_netif_get_ifkey(r->esp_netif),
                    ip_protocol_str[r->ip_protocol], r->ttl);
         }
         if (r->instance_name) {

components/mdns/mdns.c

@@ -1476,7 +1476,7 @@ static void _mdns_dispatch_tx_packet(mdns_tx_packet_t *p)
     _mdns_set_u16(packet, MDNS_HEAD_ADDITIONAL_OFFSET, count);
 
 #ifdef MDNS_ENABLE_DEBUG
-    _mdns_dbg_printf("\nTX[%u][%u]: ", p->tcpip_if, p->ip_protocol);
+    _mdns_dbg_printf("\nTX[%lu][%lu]: ", (unsigned long)p->tcpip_if, (unsigned long)p->ip_protocol);
     if (p->dst.type == ESP_IPADDR_TYPE_V4) {
         _mdns_dbg_printf("To: " IPSTR ":%u, ", IP2STR(&p->dst.u_addr.ip4), p->port);
     } else {
@@ -3492,7 +3492,7 @@ void mdns_parse_packet(mdns_rx_packet_t *packet)
     mdns_search_once_t *search_result = NULL;
 
 #ifdef MDNS_ENABLE_DEBUG
-    _mdns_dbg_printf("\nRX[%u][%u]: ", packet->tcpip_if, (uint32_t)packet->ip_protocol);
+    _mdns_dbg_printf("\nRX[%lu][%lu]: ", (unsigned long)packet->tcpip_if, (unsigned long)packet->ip_protocol);
     if (packet->src.type == ESP_IPADDR_TYPE_V4) {
         _mdns_dbg_printf("From: " IPSTR ":%u, To: " IPSTR ", ", IP2STR(&packet->src.u_addr.ip4), packet->src_port, IP2STR(&packet->dest.u_addr.ip4));
     } else {
@@ -6537,7 +6537,7 @@ void mdns_debug_packet(const uint8_t *data, size_t len)
     mdns_name_t *name = &n;
     memset(name, 0, sizeof(mdns_name_t));
 
-    _mdns_dbg_printf("Packet[%u]: ", t);
+    _mdns_dbg_printf("Packet[%" PRIu32 "]: ", t);
 
     header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET);
     header.flags = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET);
@@ -6675,7 +6675,7 @@ void mdns_debug_packet(const uint8_t *data, size_t len)
             if (flush) {
                 _mdns_dbg_printf("FLUSH ");
             }
-            _mdns_dbg_printf("%u ", ttl);
+            _mdns_dbg_printf("%" PRIu32, ttl);
             _mdns_dbg_printf("[%u] ", data_len);
             if (type == MDNS_TYPE_PTR) {
                 if (!_mdns_parse_fqdn(data, data_ptr, name, len)) {

components/mdns/mdns_networking_socket.c

@@ -372,7 +372,7 @@ static bool create_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
 
 esp_err_t _mdns_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
 {
-    ESP_LOGI(TAG, "_mdns_pcb_init(tcpip_if=%d, ip_protocol=%d)", tcpip_if, ip_protocol);
+    ESP_LOGI(TAG, "_mdns_pcb_init(tcpip_if=%lu, ip_protocol=%lu)", (unsigned long)tcpip_if, (unsigned long)ip_protocol);
     if (!create_pcb(tcpip_if, ip_protocol)) {
         return ESP_FAIL;
     }

components/mdns/private_include/mdns_private.h

@@ -159,7 +159,7 @@
 #define PCB_STATE_IS_RUNNING(s) (s->state == PCB_RUNNING)
 
 #ifndef HOOK_MALLOC_FAILED
-#define HOOK_MALLOC_FAILED  ESP_LOGE(TAG, "Cannot allocate memory (line: %d, free heap: %d bytes)", __LINE__, esp_get_free_heap_size());
+#define HOOK_MALLOC_FAILED  ESP_LOGE(TAG, "Cannot allocate memory (line: %d, free heap: %" PRIu32 " bytes)", __LINE__, esp_get_free_heap_size());
 #endif
 
 typedef size_t mdns_if_t;

components/mdns/tests/test_apps/main/CMakeLists.txt

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

components/mdns/tests/test_apps/main/main.c

@@ -92,7 +92,7 @@ static void initialise_mdns(void)
 
 void app_main(void)
 {
-    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_ERROR_CHECK(nvs_flash_init());