fix(common): Added formatting fixes

abhik-roy85 · abhik-roy85 · commit 24d6b845abe9 · 2025-11-12T00:17:22.000+11:00
diff --git a/common_components/linux_compat/freertos/include/freertos/FreeRTOS.h b/common_components/linux_compat/freertos/include/freertos/FreeRTOS.h
@@ -21,7 +21,7 @@ typedef void *EventGroupHandle_t;
 typedef uint32_t TickType_t;
 typedef TickType_t               EventBits_t;
 
-typedef void (*TaskFunction_t)( void * );
+typedef void (*TaskFunction_t)(void *);
 typedef unsigned int    UBaseType_t;
 typedef int             BaseType_t;
 
diff --git a/components/eppp_link/examples/host/main/register_iperf.c b/components/eppp_link/examples/host/main/register_iperf.c
@@ -139,9 +139,9 @@ static int ppp_cmd_iperf(int argc, char **argv)
            cfg.flag & IPERF_FLAG_TCP ? "tcp" : "udp",
            cfg.flag & IPERF_FLAG_SERVER ? "server" : "client",
            (uint16_t) cfg.source_ip4 & 0xFF,
-           (uint16_t) (cfg.source_ip4 >> 8) & 0xFF,
-           (uint16_t) (cfg.source_ip4 >> 16) & 0xFF,
-           (uint16_t) (cfg.source_ip4 >> 24) & 0xFF,
+           (uint16_t)(cfg.source_ip4 >> 8) & 0xFF,
+           (uint16_t)(cfg.source_ip4 >> 16) & 0xFF,
+           (uint16_t)(cfg.source_ip4 >> 24) & 0xFF,
            cfg.sport,
            cfg.destination_ip4 & 0xFF, (cfg.destination_ip4 >> 8) & 0xFF,
            (cfg.destination_ip4 >> 16) & 0xFF, (cfg.destination_ip4 >> 24) & 0xFF, cfg.dport,
diff --git a/components/esp_modem/examples/modem_console/main/console_helper.hpp b/components/esp_modem/examples/modem_console/main/console_helper.hpp
@@ -80,7 +80,7 @@ class ConsoleCommand {
      * @param f Function callback for the command
      */
     template<typename T> explicit ConsoleCommand(const char *command, const char *help, const T *arg_struct, size_t srg_struct_size,
-            std::function<bool(ConsoleCommand *)> f):   func(std::move(f))
+                                                 std::function<bool(ConsoleCommand *)> f):   func(std::move(f))
     {
         size_t args_plain_size = srg_struct_size / sizeof(CommandArgs);
         auto first_arg = reinterpret_cast<const CommandArgs *>(arg_struct);
diff --git a/components/esp_modem/examples/modem_console/main/ping_handle.c b/components/esp_modem/examples/modem_console/main/ping_handle.c
@@ -101,10 +101,10 @@ static int do_ping_cmd(int argc, char **argv)
         return 1;
     }
     if (res->ai_family == AF_INET) {
-        struct in_addr addr4 = ((struct sockaddr_in *) (res->ai_addr))->sin_addr;
+        struct in_addr addr4 = ((struct sockaddr_in *)(res->ai_addr))->sin_addr;
         inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4);
     } else {
-        struct in6_addr addr6 = ((struct sockaddr_in6 *) (res->ai_addr))->sin6_addr;
+        struct in6_addr addr6 = ((struct sockaddr_in6 *)(res->ai_addr))->sin6_addr;
         inet6_addr_to_ip6addr(ip_2_ip6(&target_addr), &addr6);
     }
     freeaddrinfo(res);
diff --git a/components/esp_modem/examples/modem_tcp_client/main/sock_commands_sim7600.cpp b/components/esp_modem/examples/modem_tcp_client/main/sock_commands_sim7600.cpp
@@ -18,13 +18,13 @@ using namespace esp_modem;
 
 command_result net_open(CommandableIf *term)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string response;
     auto ret = dce_commands::generic_get_string(term, "AT+NETOPEN?\r", response, 1000);
     if (ret != command_result::OK) {
         return ret;
     }
-    ESP_LOGV(TAG, "%s", response.data() );
+    ESP_LOGV(TAG, "%s", response.data());
     if (response.find("+NETOPEN: 1") != std::string::npos) {
         ESP_LOGD(TAG, "Already there");
         ret = command_result::OK;
@@ -42,37 +42,37 @@ command_result net_open(CommandableIf *term)
 
 command_result net_close(CommandableIf *term)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return dce_commands::generic_command(term, "AT+NETCLOSE\r", "+NETCLOSE:", "ERROR", 30000);
 }
 
 command_result tcp_open(CommandableIf *term, const std::string &host, int port, int timeout)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     auto ret = dce_commands::generic_command(term, "AT+CIPRXGET=1\r", "OK", "ERROR", 50000);
     if (ret != command_result::OK) {
         ESP_LOGE(TAG, "Setting Rx mode failed!");
         return ret;
     }
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string ip_open = R"(AT+CIPOPEN=0,"TCP",")" + host + "\"," + std::to_string(port) + "\r";
     ret = dce_commands::generic_command(term, ip_open, "+CIPOPEN: 0,0", "ERROR", timeout);
     if (ret != command_result::OK) {
-        ESP_LOGE(TAG, "%s Failed", __func__ );
+        ESP_LOGE(TAG, "%s Failed", __func__);
         return ret;
     }
     return command_result::OK;
 }
 
 command_result tcp_close(CommandableIf *term)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return dce_commands::generic_command(term, "AT+CIPCLOSE=0\r", "+CIPCLOSE:", "ERROR", 10000);
 }
 
 command_result tcp_send(CommandableIf *term, uint8_t *data, size_t len)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string send = "AT+CIPSEND=0," + std::to_string(len) + "\r";
     auto ret = term->command(send, [&](uint8_t *data, size_t len) {
         std::string_view response((char *)data, len);
@@ -107,7 +107,7 @@ command_result tcp_send(CommandableIf *term, uint8_t *data, size_t len)
     uint8_t ctrl_z = '\x1A';
     term->write(&ctrl_z, 1);
     int count = 0;
-    while (ret == command_result::TIMEOUT && count++ < 1000 ) {
+    while (ret == command_result::TIMEOUT && count++ < 1000) {
         vTaskDelay(pdMS_TO_TICKS(1000));
     }
     term->on_read(nullptr);
@@ -116,7 +116,7 @@ command_result tcp_send(CommandableIf *term, uint8_t *data, size_t len)
 
 command_result tcp_recv(CommandableIf *term, uint8_t *data, size_t len, size_t &out_len)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = dce_commands::generic_get_string(term, "AT+CIPRXGET=4,0\r", out);
     if (ret != command_result::OK) {
diff --git a/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.cpp b/components/esp_modem/examples/simple_cmux_client/components/SIM7070_gnss/SIM7070_gnss.cpp
@@ -43,16 +43,16 @@ class LocalFactory: public Factory {
  * @return unique pointer of the resultant DCE
  */
 std::unique_ptr<DCE_gnss> create_SIM7070_GNSS_dce(const esp_modem::dce_config *config,
-        std::shared_ptr<esp_modem::DTE> dte,
-        esp_netif_t *netif)
+                                                  std::shared_ptr<esp_modem::DTE> dte,
+                                                  esp_netif_t *netif)
 {
     return gnss_factory::LocalFactory::create(config, std::move(dte), netif);
 }
 
 esp_modem::command_result get_gnss_information_sim70xx_lib(esp_modem::CommandableIf *t, sim70xx_gps_t &gps)
 {
 
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string str_out;
     auto ret = esp_modem::dce_commands::generic_get_string(t, "AT+CGNSINF\r", str_out);
     if (ret != esp_modem::command_result::OK) {
diff --git a/components/esp_modem/include/cxx_include/esp_modem_buffer.hpp b/components/esp_modem/include/cxx_include/esp_modem_buffer.hpp
@@ -14,7 +14,7 @@ namespace esp_modem {
  */
 struct unique_buffer {
     explicit unique_buffer(size_t size);
-    unique_buffer (unique_buffer const &) = delete;
+    unique_buffer(unique_buffer const &) = delete;
     unique_buffer &operator=(unique_buffer const &) = delete;
     unique_buffer(unique_buffer &&other) noexcept
     {
diff --git a/components/esp_modem/src/esp_modem_uart_linux.cpp b/components/esp_modem/src/esp_modem_uart_linux.cpp
@@ -17,7 +17,7 @@ constexpr const char *TAG = "uart_resource";
 
 uart_resource::uart_resource(const esp_modem_uart_term_config *config, QueueHandle_t *event_queue, int fd): port(-1)
 {
-    ESP_LOGD(TAG, "Creating uart resource" );
+    ESP_LOGD(TAG, "Creating uart resource");
     struct termios tty = {};
     ESP_MODEM_THROW_IF_FALSE(tcgetattr(fd, &tty) == 0, "Failed to tcgetattr()");
 
diff --git a/components/esp_modem/src/esp_modem_vfs_socket_creator.cpp b/components/esp_modem/src/esp_modem_vfs_socket_creator.cpp
@@ -52,7 +52,7 @@ static esp_err_t hostname_to_fd(const char *host, int port, int *fd)
         auto *p = reinterpret_cast<struct sockaddr_in *>(address_info->ai_addr);
         p->sin_port = htons(port);
         ESP_LOGI(TAG, "[sock=%d] Resolved IPv4 address: %s", *fd, inet_ntoa(p->sin_addr));
-        memcpy(&address, p, sizeof(struct sockaddr ));
+        memcpy(&address, p, sizeof(struct sockaddr));
     } else {
         ESP_LOGE(TAG, "Unsupported protocol family %d", address_info->ai_family);
         close(*fd);
diff --git a/components/esp_modem/test/host_test/main/LoopbackTerm.cpp b/components/esp_modem/test/host_test/main/LoopbackTerm.cpp
@@ -26,7 +26,7 @@ int LoopbackTerm::write(uint8_t *data, size_t len)
         async_results.push_back(std::move(ret));
         return len;
     }
-    if (len > 2 && (data[len - 1] == '\r' || data[len - 1] == '+') ) { // Simple AT responder
+    if (len > 2 && (data[len - 1] == '\r' || data[len - 1] == '+')) {  // Simple AT responder
         std::string command((char *)data, len);
         std::string response;
         if (command == "+++") {
diff --git a/components/esp_modem/test/target/main/pppd_test.cpp b/components/esp_modem/test/target/main/pppd_test.cpp
@@ -131,7 +131,7 @@ extern "C" {
         ESP_LOGE(TAG, "Signal handler %d", nr);
     }
 
-    _sig_func_ptr signal (int nr, _sig_func_ptr)
+    _sig_func_ptr signal(int nr, _sig_func_ptr)
     {
         return handle;
     }
diff --git a/components/esp_modem/test/target_iperf/main/cmd_pppclient.c b/components/esp_modem/test/target_iperf/main/cmd_pppclient.c
@@ -223,9 +223,9 @@ static int ppp_cmd_iperf(int argc, char **argv)
            cfg.flag & IPERF_FLAG_TCP ? "tcp" : "udp",
            cfg.flag & IPERF_FLAG_SERVER ? "server" : "client",
            (uint16_t) cfg.source_ip4 & 0xFF,
-           (uint16_t) (cfg.source_ip4 >> 8) & 0xFF,
-           (uint16_t) (cfg.source_ip4 >> 16) & 0xFF,
-           (uint16_t) (cfg.source_ip4 >> 24) & 0xFF,
+           (uint16_t)(cfg.source_ip4 >> 8) & 0xFF,
+           (uint16_t)(cfg.source_ip4 >> 16) & 0xFF,
+           (uint16_t)(cfg.source_ip4 >> 24) & 0xFF,
            cfg.sport,
            cfg.destination_ip4 & 0xFF, (cfg.destination_ip4 >> 8) & 0xFF,
            (cfg.destination_ip4 >> 16) & 0xFF, (cfg.destination_ip4 >> 24) & 0xFF, cfg.dport,
diff --git a/components/esp_modem/test/target_ota/components/manual_ota/transport_batch_tls.cpp b/components/esp_modem/test/target_ota/components/manual_ota/transport_batch_tls.cpp
@@ -226,7 +226,7 @@ int TlsTransport::preread(size_t len, int timeout_ms)
     while (len != read_len) {
         int l = esp_transport_read(transport_, buf.data() + read_len, len - read_len, timeout_ms);
         ESP_LOGD(TAG, "need %d read %d already %d", len, l, read_len);
-        if ((l == ERR_TCP_TRANSPORT_CONNECTION_CLOSED_BY_FIN || l == ERR_TCP_TRANSPORT_CONNECTION_TIMEOUT ) && read_len > 0) {
+        if ((l == ERR_TCP_TRANSPORT_CONNECTION_CLOSED_BY_FIN || l == ERR_TCP_TRANSPORT_CONNECTION_TIMEOUT) && read_len > 0) {
             return read_len;
         }
         if (l <= 0) {
diff --git a/components/esp_mqtt_cxx/examples/ssl/main/mqtt_ssl_example.cpp b/components/esp_mqtt_cxx/examples/ssl/main/mqtt_ssl_example.cpp
@@ -85,6 +85,6 @@ extern "C" void app_main(void)
     MyClient client{broker, credentials, config};
     while (true) {
         constexpr TickType_t xDelay = 500 / portTICK_PERIOD_MS;
-        vTaskDelay( xDelay );
+        vTaskDelay(xDelay);
     }
 }
diff --git a/components/mbedtls_cxx/examples/udp_mutual_auth/main/udp_mutual.cpp b/components/mbedtls_cxx/examples/udp_mutual_auth/main/udp_mutual.cpp
@@ -39,11 +39,11 @@ class SecureLink: public Tls {
     int recv_timeout(unsigned char *buf, size_t len, int timeout) override
     {
         struct timeval tv {
-            timeout / 1000, (timeout % 1000 ) * 1000
+            timeout / 1000, (timeout % 1000) * 1000
         };
         fd_set read_fds;
-        FD_ZERO( &read_fds );
-        FD_SET( sock, &read_fds );
+        FD_ZERO(&read_fds);
+        FD_SET(sock, &read_fds);
 
         int ret = select(sock + 1, &read_fds, nullptr, nullptr, timeout == 0 ? nullptr : &tv);
         if (ret == 0) {
diff --git a/components/mbedtls_cxx/mbedtls_wrap.cpp b/components/mbedtls_cxx/mbedtls_wrap.cpp
@@ -93,8 +93,8 @@ int Tls::handshake()
     int ret = 0;
     mbedtls_ssl_set_bio(&ssl_, this, bio_write, bio_read, is_dtls_ ? bio_read_tout : nullptr);
 
-    while ( ( ret = mbedtls_ssl_handshake( &ssl_ ) ) != 0 ) {
-        if ( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE ) {
+    while ((ret = mbedtls_ssl_handshake(&ssl_)) != 0) {
+        if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
 #if CONFIG_MBEDTLS_SSL_PROTO_DTLS
             if (is_server_ && is_dtls_ && ret == MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED) {
                 // hello verification requested -> restart the session with this client_id
@@ -104,7 +104,7 @@ int Tls::handshake()
                 continue;
             }
 #endif // MBEDTLS_SSL_PROTO_DTLS
-            print_error( "mbedtls_ssl_handshake returned", ret );
+            print_error("mbedtls_ssl_handshake returned", ret);
             return -1;
         }
         delay();
@@ -132,12 +132,12 @@ int Tls::bio_read_tout(void *ctx, unsigned char *buf, size_t len, uint32_t timeo
 
 int Tls::write(const unsigned char *buf, size_t len)
 {
-    return mbedtls_ssl_write( &ssl_, buf, len );
+    return mbedtls_ssl_write(&ssl_, buf, len);
 }
 
 int Tls::read(unsigned char *buf, size_t len)
 {
-    return mbedtls_ssl_read( &ssl_, buf, len );
+    return mbedtls_ssl_read(&ssl_, buf, len);
 }
 
 bool Tls::set_own_cert(const_buf crt, const_buf key)
diff --git a/components/mdns/tests/test_afl_fuzz_host/mdns_di.h b/components/mdns/tests/test_afl_fuzz_host/mdns_di.h
@@ -11,18 +11,18 @@
 #include "mdns.h"
 #include "mdns_private.h"
 
-void              (*mdns_test_static_execute_action)(mdns_action_t *) = NULL;
+void (*mdns_test_static_execute_action)(mdns_action_t *) = NULL;
 mdns_srv_item_t *(*mdns_test_static_mdns_get_service_item)(const char *service, const char *proto, const char *hostname) = NULL;
 mdns_search_once_t *(*mdns_test_static_search_init)(const char *name, const char *service, const char *proto, uint16_t type, bool unicast,
-        uint32_t timeout, uint8_t max_results,
-        mdns_query_notify_t notifier) = NULL;
-esp_err_t         (*mdns_test_static_send_search_action)(mdns_action_type_t type, mdns_search_once_t *search) = NULL;
-void              (*mdns_test_static_search_free)(mdns_search_once_t *search) = NULL;
+                                                    uint32_t timeout, uint8_t max_results,
+                                                    mdns_query_notify_t notifier) = NULL;
+esp_err_t (*mdns_test_static_send_search_action)(mdns_action_type_t type, mdns_search_once_t *search) = NULL;
+void (*mdns_test_static_search_free)(mdns_search_once_t *search) = NULL;
 
 static void _mdns_execute_action(mdns_action_t *action);
 static mdns_srv_item_t *_mdns_get_service_item(const char *service, const char *proto, const char *hostname);
 static mdns_search_once_t *_mdns_search_init(const char *name, const char *service, const char *proto, uint16_t type, bool unicast,
-        uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier);
+                                             uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier);
 static esp_err_t _mdns_send_search_action(mdns_action_type_t type, mdns_search_once_t *search);
 static void _mdns_search_free(mdns_search_once_t *search);
 
diff --git a/components/mosquitto/port/signals.c b/components/mosquitto/port/signals.c
@@ -7,7 +7,7 @@
  */
 #include "signal.h"
 
-int sigprocmask (int, const sigset_t *, sigset_t *)
+int sigprocmask(int, const sigset_t *, sigset_t *)
 {
     return 0;
 }
diff --git a/components/net_connect/addr_from_stdin.c b/components/net_connect/addr_from_stdin.c
@@ -32,28 +32,28 @@ esp_err_t get_addr_from_stdin(int port, int sock_type, int *ip_protocol, int *ad
     do {
         fgets(host_ip, HOST_IP_SIZE, stdin);
         len = strlen(host_ip);
-    } while (len<=1 && host_ip[0] == '\n');
+    } while (len <= 1 && host_ip[0] == '\n');
     host_ip[len - 1] = '\0';
 
     struct addrinfo hints, *addr_list, *cur;
-    memset( &hints, 0, sizeof( hints ) );
+    memset(&hints, 0, sizeof(hints));
 
     // run getaddrinfo() to decide on the IP protocol
     hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = sock_type;
     hints.ai_protocol = IPPROTO_TCP;
-    if( getaddrinfo( host_ip, NULL, &hints, &addr_list ) != 0 ) {
+    if (getaddrinfo(host_ip, NULL, &hints, &addr_list) != 0) {
         return ESP_FAIL;
     }
-    for( cur = addr_list; cur != NULL; cur = cur->ai_next ) {
+    for (cur = addr_list; cur != NULL; cur = cur->ai_next) {
         memcpy(dest_addr, cur->ai_addr, sizeof(*dest_addr));
 #if CONFIG_NET_CONNECT_CONNECT_IPV4
         if (cur->ai_family == AF_INET) {
             *ip_protocol = IPPROTO_IP;
             *addr_family = AF_INET;
             // add port number and return on first IPv4 match
             ((struct sockaddr_in*)dest_addr)->sin_port = htons(port);
-            freeaddrinfo( addr_list );
+            freeaddrinfo(addr_list);
             return ESP_OK;
         }
 #endif // IPV4
@@ -64,12 +64,12 @@ esp_err_t get_addr_from_stdin(int port, int sock_type, int *ip_protocol, int *ad
             // add port and interface number and return on first IPv6 match
             ((struct sockaddr_in6*)dest_addr)->sin6_port = htons(port);
             ((struct sockaddr_in6*)dest_addr)->sin6_scope_id = esp_netif_get_netif_impl_index(NET_CONNECT_INTERFACE);
-            freeaddrinfo( addr_list );
+            freeaddrinfo(addr_list);
             return ESP_OK;
         }
 #endif // IPV6
     }
     // no match found
-    freeaddrinfo( addr_list );
+    freeaddrinfo(addr_list);
     return ESP_FAIL;
 }
diff --git a/components/net_connect/console_cmd.c b/components/net_connect/console_cmd.c
@@ -74,7 +74,7 @@ void net_register_wifi_connect_commands(void)
         .func = &cmd_do_wifi_connect,
         .argtable = &connect_args
     };
-    ESP_ERROR_CHECK( esp_console_cmd_register(&wifi_connect_cmd) );
+    ESP_ERROR_CHECK(esp_console_cmd_register(&wifi_connect_cmd));
 
 
     const esp_console_cmd_t wifi_disconnect_cmd = {
@@ -83,5 +83,5 @@ void net_register_wifi_connect_commands(void)
         .hint = NULL,
         .func = &cmd_do_wifi_disconnect,
     };
-    ESP_ERROR_CHECK( esp_console_cmd_register(&wifi_disconnect_cmd) );
+    ESP_ERROR_CHECK(esp_console_cmd_register(&wifi_disconnect_cmd));
 }
diff --git a/components/net_connect/eth_connect.c b/components/net_connect/eth_connect.c
@@ -30,7 +30,7 @@ static void eth_stop(void);
 /** Event handler for Ethernet events */
 
 static void eth_on_got_ip(void *arg, esp_event_base_t event_base,
-                      int32_t event_id, void *event_data)
+                          int32_t event_id, void *event_data)
 {
     ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
     if (!net_connect_is_our_netif(NET_CONNECT_NETIF_DESC_ETH, event->esp_netif)) {
@@ -43,7 +43,7 @@ static void eth_on_got_ip(void *arg, esp_event_base_t event_base,
 #if CONFIG_NET_CONNECT_CONNECT_IPV6
 
 static void eth_on_got_ipv6(void *arg, esp_event_base_t event_base,
-                        int32_t event_id, void *event_data)
+                            int32_t event_id, void *event_data)
 {
     ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
     if (!net_connect_is_our_netif(NET_CONNECT_NETIF_DESC_ETH, event->esp_netif)) {
diff --git a/components/net_connect/idf_component.yml b/components/net_connect/idf_component.yml
@@ -4,4 +4,3 @@ description: Network connection component providing WiFi, Ethernet, Thread, and
 dependencies:
   idf:
     version: '>=5.0'
-
diff --git a/components/net_connect/include/net_connect.h b/components/net_connect/include/net_connect.h
diff --git a/components/net_connect/ppp_connect.c b/components/net_connect/ppp_connect.c
diff --git a/components/net_connect/protocol_examples_utils.c b/components/net_connect/protocol_examples_utils.c
diff --git a/components/net_connect/stdin_out.c b/components/net_connect/stdin_out.c
diff --git a/components/net_connect/wifi_connect.c b/components/net_connect/wifi_connect.c
diff --git a/examples/esp_netif/multiple_netifs/main/check_connection.c b/examples/esp_netif/multiple_netifs/main/check_connection.c
diff --git a/examples/esp_netif/slip_custom_netif/main/slip_client_main.c b/examples/esp_netif/slip_custom_netif/main/slip_client_main.c

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ class ConsoleCommand {`
`80`	`80`	`* @param f Function callback for the command`
`81`	`81`	`*/`
`82`	`82`	`template<typename T> explicit ConsoleCommand(const char command, const char help, const T *arg_struct, size_t srg_struct_size,`
`83`		`- std::function<bool(ConsoleCommand *)> f): func(std::move(f))`
	`83`	`+ std::function<bool(ConsoleCommand *)> f): func(std::move(f))`
`84`	`84`	`{`
`85`	`85`	`size_t args_plain_size = srg_struct_size / sizeof(CommandArgs);`
`86`	`86`	`auto first_arg = reinterpret_cast<const CommandArgs *>(arg_struct);`
Original file line number	Diff line number	Diff line change
`@@ -101,10 +101,10 @@ static int do_ping_cmd(int argc, char **argv)`
`101`	`101`	`return 1;`
`102`	`102`	`}`
`103`	`103`	`if (res->ai_family == AF_INET) {`
`104`		`- struct in_addr addr4 = ((struct sockaddr_in *) (res->ai_addr))->sin_addr;`
	`104`	`+ struct in_addr addr4 = ((struct sockaddr_in *)(res->ai_addr))->sin_addr;`
`105`	`105`	`inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4);`
`106`	`106`	`} else {`
`107`		`- struct in6_addr addr6 = ((struct sockaddr_in6 *) (res->ai_addr))->sin6_addr;`
	`107`	`+ struct in6_addr addr6 = ((struct sockaddr_in6 *)(res->ai_addr))->sin6_addr;`
`108`	`108`	`inet6_addr_to_ip6addr(ip_2_ip6(&target_addr), &addr6);`
`109`	`109`	`}`
`110`	`110`	`freeaddrinfo(res);`
Original file line number	Diff line number	Diff line change
`@@ -18,13 +18,13 @@ using namespace esp_modem;`
`18`	`18`
`19`	`19`	`command_result net_open(CommandableIf *term)`
`20`	`20`	`{`
`21`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`21`	`+ ESP_LOGV(TAG, "%s", __func__);`
`22`	`22`	`std::string response;`
`23`	`23`	`auto ret = dce_commands::generic_get_string(term, "AT+NETOPEN?\r", response, 1000);`
`24`	`24`	`if (ret != command_result::OK) {`
`25`	`25`	`return ret;`
`26`	`26`	`}`
`27`		`- ESP_LOGV(TAG, "%s", response.data() );`
	`27`	`+ ESP_LOGV(TAG, "%s", response.data());`
`28`	`28`	`if (response.find("+NETOPEN: 1") != std::string::npos) {`
`29`	`29`	`ESP_LOGD(TAG, "Already there");`
`30`	`30`	`ret = command_result::OK;`
`@@ -42,37 +42,37 @@ command_result net_open(CommandableIf *term)`
`42`	`42`
`43`	`43`	`command_result net_close(CommandableIf *term)`
`44`	`44`	`{`
`45`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`45`	`+ ESP_LOGV(TAG, "%s", __func__);`
`46`	`46`	`return dce_commands::generic_command(term, "AT+NETCLOSE\r", "+NETCLOSE:", "ERROR", 30000);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`command_result tcp_open(CommandableIf *term, const std::string &host, int port, int timeout)`
`50`	`50`	`{`
`51`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`51`	`+ ESP_LOGV(TAG, "%s", __func__);`
`52`	`52`	`auto ret = dce_commands::generic_command(term, "AT+CIPRXGET=1\r", "OK", "ERROR", 50000);`
`53`	`53`	`if (ret != command_result::OK) {`
`54`	`54`	`ESP_LOGE(TAG, "Setting Rx mode failed!");`
`55`	`55`	`return ret;`
`56`	`56`	`}`
`57`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`57`	`+ ESP_LOGV(TAG, "%s", __func__);`
`58`	`58`	`std::string ip_open = R"(AT+CIPOPEN=0,"TCP",")" + host + "\"," + std::to_string(port) + "\r";`
`59`	`59`	`ret = dce_commands::generic_command(term, ip_open, "+CIPOPEN: 0,0", "ERROR", timeout);`
`60`	`60`	`if (ret != command_result::OK) {`
`61`		`- ESP_LOGE(TAG, "%s Failed", __func__ );`
	`61`	`+ ESP_LOGE(TAG, "%s Failed", __func__);`
`62`	`62`	`return ret;`
`63`	`63`	`}`
`64`	`64`	`return command_result::OK;`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`command_result tcp_close(CommandableIf *term)`
`68`	`68`	`{`
`69`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`69`	`+ ESP_LOGV(TAG, "%s", __func__);`
`70`	`70`	`return dce_commands::generic_command(term, "AT+CIPCLOSE=0\r", "+CIPCLOSE:", "ERROR", 10000);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`command_result tcp_send(CommandableIf term, uint8_t data, size_t len)`
`74`	`74`	`{`
`75`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`75`	`+ ESP_LOGV(TAG, "%s", __func__);`
`76`	`76`	`std::string send = "AT+CIPSEND=0," + std::to_string(len) + "\r";`
`77`	`77`	`auto ret = term->command(send, [&](uint8_t *data, size_t len) {`
`78`	`78`	`std::string_view response((char *)data, len);`
`@@ -107,7 +107,7 @@ command_result tcp_send(CommandableIf term, uint8_t data, size_t len)`
`107`	`107`	`uint8_t ctrl_z = '\x1A';`
`108`	`108`	`term->write(&ctrl_z, 1);`
`109`	`109`	`int count = 0;`
`110`		`- while (ret == command_result::TIMEOUT && count++ < 1000 ) {`
	`110`	`+ while (ret == command_result::TIMEOUT && count++ < 1000) {`
`111`	`111`	`vTaskDelay(pdMS_TO_TICKS(1000));`
`112`	`112`	`}`
`113`	`113`	`term->on_read(nullptr);`
`@@ -116,7 +116,7 @@ command_result tcp_send(CommandableIf term, uint8_t data, size_t len)`
`116`	`116`
`117`	`117`	`command_result tcp_recv(CommandableIf term, uint8_t data, size_t len, size_t &out_len)`
`118`	`118`	`{`
`119`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`119`	`+ ESP_LOGV(TAG, "%s", __func__);`
`120`	`120`	`std::string out;`
`121`	`121`	`auto ret = dce_commands::generic_get_string(term, "AT+CIPRXGET=4,0\r", out);`
`122`	`122`	`if (ret != command_result::OK) {`
Original file line number	Diff line number	Diff line change
`@@ -43,16 +43,16 @@ class LocalFactory: public Factory {`
`43`	`43`	`* @return unique pointer of the resultant DCE`
`44`	`44`	`*/`
`45`	`45`	`std::unique_ptr<DCE_gnss> create_SIM7070_GNSS_dce(const esp_modem::dce_config *config,`
`46`		`- std::shared_ptr<esp_modem::DTE> dte,`
`47`		`- esp_netif_t *netif)`
	`46`	`+ std::shared_ptr<esp_modem::DTE> dte,`
	`47`	`+ esp_netif_t *netif)`
`48`	`48`	`{`
`49`	`49`	`return gnss_factory::LocalFactory::create(config, std::move(dte), netif);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`esp_modem::command_result get_gnss_information_sim70xx_lib(esp_modem::CommandableIf *t, sim70xx_gps_t &gps)`
`53`	`53`	`{`
`54`	`54`
`55`		`- ESP_LOGV(TAG, "%s", __func__ );`
	`55`	`+ ESP_LOGV(TAG, "%s", __func__);`
`56`	`56`	`std::string str_out;`
`57`	`57`	`auto ret = esp_modem::dce_commands::generic_get_string(t, "AT+CGNSINF\r", str_out);`
`58`	`58`	`if (ret != esp_modem::command_result::OK) {`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace esp_modem {`
`14`	`14`	`*/`
`15`	`15`	`struct unique_buffer {`
`16`	`16`	`explicit unique_buffer(size_t size);`
`17`		`- unique_buffer (unique_buffer const &) = delete;`
	`17`	`+ unique_buffer(unique_buffer const &) = delete;`
`18`	`18`	`unique_buffer &operator=(unique_buffer const &) = delete;`
`19`	`19`	`unique_buffer(unique_buffer &&other) noexcept`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ constexpr const char *TAG = "uart_resource";`
`17`	`17`
`18`	`18`	`uart_resource::uart_resource(const esp_modem_uart_term_config config, QueueHandle_t event_queue, int fd): port(-1)`
`19`	`19`	`{`
`20`		`- ESP_LOGD(TAG, "Creating uart resource" );`
	`20`	`+ ESP_LOGD(TAG, "Creating uart resource");`
`21`	`21`	`struct termios tty = {};`
`22`	`22`	`ESP_MODEM_THROW_IF_FALSE(tcgetattr(fd, &tty) == 0, "Failed to tcgetattr()");`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ int LoopbackTerm::write(uint8_t *data, size_t len)`
`26`	`26`	`async_results.push_back(std::move(ret));`
`27`	`27`	`return len;`
`28`	`28`	`}`
`29`		`- if (len > 2 && (data[len - 1] == '\r' \|\| data[len - 1] == '+') ) { // Simple AT responder`
	`29`	`+ if (len > 2 && (data[len - 1] == '\r' \|\| data[len - 1] == '+')) { // Simple AT responder`
`30`	`30`	`std::string command((char *)data, len);`
`31`	`31`	`std::string response;`
`32`	`32`	`if (command == "+++") {`