Component/net connect

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;
 

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,

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

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

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) {

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) {

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
     {

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()");
 

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

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 == "+++") {

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

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,

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) {

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

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) {

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)

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

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

components/net_connect/CMakeLists.txt

@@ -0,0 +1,52 @@
+idf_build_get_property(target IDF_TARGET)
+
+if(${target} STREQUAL "linux")
+    # Header only library for linux
+
+    idf_component_register(INCLUDE_DIRS include
+                           SRCS protocol_examples_utils.c)
+    return()
+endif()
+
+set(srcs "stdin_out.c"
+         "addr_from_stdin.c"
+         "connect.c"
+         "wifi_connect.c"
+         "protocol_examples_utils.c")
+
+if(CONFIG_NET_CONNECT_PROVIDE_WIFI_CONSOLE_CMD)
+    list(APPEND srcs "console_cmd.c")
+endif()
+
+if(CONFIG_NET_CONNECT_CONNECT_ETHERNET)
+    list(APPEND srcs "eth_connect.c")
+endif()
+
+if(CONFIG_NET_CONNECT_CONNECT_THREAD)
+    list(APPEND srcs "thread_connect.c")
+endif()
+
+if(CONFIG_NET_CONNECT_CONNECT_PPP)
+    list(APPEND srcs "ppp_connect.c")
+endif()
+
+
+idf_component_register(SRCS "${srcs}"
+                       INCLUDE_DIRS "include"
+                       PRIV_REQUIRES esp_netif esp_driver_gpio esp_driver_uart esp_wifi vfs console esp_eth openthread)
+
+if(CONFIG_NET_CONNECT_PROVIDE_WIFI_CONSOLE_CMD)
+    idf_component_optional_requires(PRIVATE console)
+endif()
+
+if(CONFIG_NET_CONNECT_CONNECT_ETHERNET)
+    idf_component_optional_requires(PUBLIC esp_eth)
+endif()
+
+if(CONFIG_NET_CONNECT_CONNECT_THREAD)
+    idf_component_optional_requires(PRIVATE openthread)
+endif()
+
+if(CONFIG_NET_CONNECT_CONNECT_PPP)
+    idf_component_optional_requires(PRIVATE esp_tinyusb espressif__esp_tinyusb)
+endif()