diff --git a/components/esp_http_client/esp_http_client.c b/components/esp_http_client/esp_http_client.c index ae174f137..27181f3ec 100644 --- a/components/esp_http_client/esp_http_client.c +++ b/components/esp_http_client/esp_http_client.c @@ -19,17 +19,16 @@ #include "esp_log.h" #include "http_header.h" -#include "transport.h" -#include "transport_tcp.h" +#include "esp_transport.h" +#include "esp_transport_tcp.h" #include "http_utils.h" #include "http_auth.h" #include "sdkconfig.h" -#include "transport.h" #include "esp_http_client.h" #include "errno.h" #ifdef CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS -#include "transport_ssl.h" +#include "esp_transport_ssl.h" #endif static const char *TAG = "HTTP_CLIENT"; @@ -94,8 +93,8 @@ struct esp_http_client { int process_again; struct http_parser *parser; struct http_parser_settings *parser_settings; - transport_list_handle_t transport_list; - transport_handle_t transport; + esp_transport_list_handle_t transport_list; + esp_transport_handle_t transport; esp_http_data_t *request; esp_http_data_t *response; void *user_data; @@ -444,7 +443,7 @@ esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t *co { esp_http_client_handle_t client; - transport_handle_t tcp; + esp_transport_handle_t tcp; bool _success; _success = ( @@ -467,10 +466,10 @@ esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t *co } _success = ( - (client->transport_list = transport_list_init()) && - (tcp = transport_tcp_init()) && - (transport_set_default_port(tcp, DEFAULT_HTTP_PORT) == ESP_OK) && - (transport_list_add(client->transport_list, tcp, "http") == ESP_OK) + (client->transport_list = esp_transport_list_init()) && + (tcp = esp_transport_tcp_init()) && + (esp_transport_set_default_port(tcp, DEFAULT_HTTP_PORT) == ESP_OK) && + (esp_transport_list_add(client->transport_list, tcp, "http") == ESP_OK) ); if (!_success) { ESP_LOGE(TAG, "Error initialize transport"); @@ -478,11 +477,11 @@ esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t *co return NULL; } #ifdef CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS - transport_handle_t ssl; + esp_transport_handle_t ssl; _success = ( - (ssl = transport_ssl_init()) && - (transport_set_default_port(ssl, DEFAULT_HTTPS_PORT) == ESP_OK) && - (transport_list_add(client->transport_list, ssl, "https") == ESP_OK) + (ssl = esp_transport_ssl_init()) && + (esp_transport_set_default_port(ssl, DEFAULT_HTTPS_PORT) == ESP_OK) && + (esp_transport_list_add(client->transport_list, ssl, "https") == ESP_OK) ); if (!_success) { @@ -492,7 +491,7 @@ esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t *co } if (config->cert_pem) { - transport_ssl_set_cert_data(ssl, config->cert_pem, strlen(config->cert_pem)); + esp_transport_ssl_set_cert_data(ssl, config->cert_pem, strlen(config->cert_pem)); } #endif @@ -546,7 +545,7 @@ esp_err_t esp_http_client_cleanup(esp_http_client_handle_t client) return ESP_FAIL; } esp_http_client_close(client); - transport_list_destroy(client->transport_list); + esp_transport_list_destroy(client->transport_list); http_header_destroy(client->request->headers); free(client->request->buffer->data); free(client->request->buffer); @@ -741,7 +740,7 @@ static int esp_http_client_get_data(esp_http_client_handle_t client) ESP_LOGD(TAG, "data_process=%d, content_length=%d", client->response->data_process, client->response->content_length); - int rlen = transport_read(client->transport, res_buffer->data, client->buffer_size, client->timeout_ms); + int rlen = esp_transport_read(client->transport, res_buffer->data, client->buffer_size, client->timeout_ms); if (rlen >= 0) { http_parser_execute(client->parser, client->parser_settings, res_buffer->data, rlen); } @@ -779,7 +778,7 @@ int esp_http_client_read(esp_http_client_handle_t client, char *buffer, int len) if (byte_to_read > client->buffer_size) { byte_to_read = client->buffer_size; } - rlen = transport_read(client->transport, res_buffer->data, byte_to_read, client->timeout_ms); + rlen = esp_transport_read(client->transport, res_buffer->data, byte_to_read, client->timeout_ms); ESP_LOGD(TAG, "need_read=%d, byte_to_read=%d, rlen=%d, ridx=%d", need_read, byte_to_read, rlen, ridx); if (rlen <= 0) { @@ -894,7 +893,7 @@ int esp_http_client_fetch_headers(esp_http_client_handle_t client) client->response->status_code = -1; while (client->state < HTTP_STATE_RES_COMPLETE_HEADER) { - buffer->len = transport_read(client->transport, buffer->data, client->buffer_size, client->timeout_ms); + buffer->len = esp_transport_read(client->transport, buffer->data, client->buffer_size, client->timeout_ms); if (buffer->len < 0) { return ESP_FAIL; } @@ -925,7 +924,7 @@ static esp_err_t esp_http_client_connect(esp_http_client_handle_t client) if (client->state < HTTP_STATE_CONNECTED) { ESP_LOGD(TAG, "Begin connect to: %s://%s:%d", client->connection_info.scheme, client->connection_info.host, client->connection_info.port); - client->transport = transport_list_get_transport(client->transport_list, client->connection_info.scheme); + client->transport = esp_transport_list_get_transport(client->transport_list, client->connection_info.scheme); if (client->transport == NULL) { ESP_LOGE(TAG, "No transport found"); #ifndef CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS @@ -936,12 +935,12 @@ static esp_err_t esp_http_client_connect(esp_http_client_handle_t client) return ESP_ERR_HTTP_INVALID_TRANSPORT; } if (!client->is_async) { - if (transport_connect(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms) < 0) { + if (esp_transport_connect(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms) < 0) { ESP_LOGE(TAG, "Connection failed, sock < 0"); return ESP_ERR_HTTP_CONNECT; } } else { - int ret = transport_connect_async(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms); + int ret = esp_transport_connect_async(client->transport, client->connection_info.host, client->connection_info.port, client->timeout_ms); if (ret == ASYNC_TRANS_CONNECT_FAIL) { ESP_LOGE(TAG, "Connection failed"); return ESP_ERR_HTTP_CONNECT; @@ -1037,7 +1036,7 @@ static esp_err_t esp_http_client_request_send(esp_http_client_handle_t client) client->data_write_left = wlen; client->data_written_index = 0; while (client->data_write_left > 0) { - int wret = transport_write(client->transport, client->request->buffer->data + client->data_written_index, client->data_write_left, client->timeout_ms); + int wret = esp_transport_write(client->transport, client->request->buffer->data + client->data_written_index, client->data_write_left, client->timeout_ms); if (wret <= 0) { ESP_LOGE(TAG, "Error write request"); esp_http_client_close(client); @@ -1103,9 +1102,9 @@ int esp_http_client_write(esp_http_client_handle_t client, const char *buffer, i int wlen = 0, widx = 0; while (len > 0) { - wlen = transport_write(client->transport, buffer + widx, len, client->timeout_ms); + wlen = esp_transport_write(client->transport, buffer + widx, len, client->timeout_ms); /* client->async_block is initialised in case of non-blocking IO, and in this case we return how - much ever data was written by the transport_write() API. */ + much ever data was written by the esp_transport_write() API. */ if (client->is_async || wlen <= 0) { return wlen; } @@ -1120,7 +1119,7 @@ esp_err_t esp_http_client_close(esp_http_client_handle_t client) if (client->state >= HTTP_STATE_INIT) { http_dispatch_event(client, HTTP_EVENT_DISCONNECTED, NULL, 0); client->state = HTTP_STATE_INIT; - return transport_close(client->transport); + return esp_transport_close(client->transport); } return ESP_OK; } diff --git a/components/esp_http_client/lib/include/http_utils.h b/components/esp_http_client/lib/include/http_utils.h index 3d1728505..d57840228 100644 --- a/components/esp_http_client/lib/include/http_utils.h +++ b/components/esp_http_client/lib/include/http_utils.h @@ -16,7 +16,7 @@ #ifndef _HTTP_UTILS_H_ #define _HTTP_UTILS_H_ #include -#include "transport_utils.h" +#include "esp_transport_utils.h" /** * @brief Assign new_str to *str pointer, and realloc *str if it not NULL * @@ -80,7 +80,7 @@ char *http_utils_join_string(const char *first_str, int len_first, const char *s int http_utils_str_starts_with(const char *str, const char *start); -#define HTTP_MEM_CHECK(TAG, a, action) TRANSPORT_MEM_CHECK(TAG, a, action) +#define HTTP_MEM_CHECK(TAG, a, action) ESP_TRANSPORT_MEM_CHECK(TAG, a, action) #endif diff --git a/components/mqtt/CMakeLists.txt b/components/mqtt/CMakeLists.txt index d100f80a0..85f63cc9a 100644 --- a/components/mqtt/CMakeLists.txt +++ b/components/mqtt/CMakeLists.txt @@ -3,17 +3,8 @@ set(COMPONENT_PRIV_INCLUDEDIRS "esp-mqtt/lib/include") set(COMPONENT_SRCS "esp-mqtt/mqtt_client.c" "esp-mqtt/lib/mqtt_msg.c" "esp-mqtt/lib/mqtt_outbox.c" - "esp-mqtt/lib/platform_esp32_idf.c" - "esp-mqtt/lib/transport_ws.c") + "esp-mqtt/lib/platform_esp32_idf.c") set(COMPONENT_REQUIRES lwip nghttp mbedtls tcp_transport) register_component() - -if(GCC_NOT_5_2_0) - # Temporary suppress "format-overflow" warning until we are fixed in esp-mqtt repo - set_source_files_properties( - esp-mqtt/lib/transport_ws.c - PROPERTIES COMPILE_FLAGS - -Wno-format-overflow) -endif() diff --git a/components/mqtt/esp-mqtt b/components/mqtt/esp-mqtt index bcb38e45f..85ee406d0 160000 --- a/components/mqtt/esp-mqtt +++ b/components/mqtt/esp-mqtt @@ -1 +1 @@ -Subproject commit bcb38e45f521085f997439a8b6c4ead34dff9043 +Subproject commit 85ee406d03fd84f5613c6dead1ea653e384b9559 diff --git a/components/tcp_transport/CMakeLists.txt b/components/tcp_transport/CMakeLists.txt index 8843ac041..e8125a726 100644 --- a/components/tcp_transport/CMakeLists.txt +++ b/components/tcp_transport/CMakeLists.txt @@ -1,10 +1,11 @@ set(COMPONENT_SRCS "transport.c" "transport_ssl.c" "transport_tcp.c" + "transport_ws.c" "transport_utils.c") set(COMPONENT_ADD_INCLUDEDIRS "include") set(COMPONENT_REQUIRES lwip esp-tls) -register_component() \ No newline at end of file +register_component() diff --git a/components/tcp_transport/include/transport.h b/components/tcp_transport/include/esp_transport.h similarity index 66% rename from components/tcp_transport/include/transport.h rename to components/tcp_transport/include/esp_transport.h index f10a8f8d6..e163a010c 100644 --- a/components/tcp_transport/include/transport.h +++ b/components/tcp_transport/include/esp_transport.h @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef _TRANSPORT_H_ -#define _TRANSPORT_H_ +#ifndef _ESP_TRANSPORT_H_ +#define _ESP_TRANSPORT_H_ #include @@ -22,27 +22,27 @@ extern "C" { #endif -typedef struct transport_list_t* transport_list_handle_t; -typedef struct transport_item_t* transport_handle_t; +typedef struct esp_transport_list_t* esp_transport_list_handle_t; +typedef struct esp_transport_item_t* esp_transport_handle_t; -typedef int (*connect_func)(transport_handle_t t, const char *host, int port, int timeout_ms); -typedef int (*io_func)(transport_handle_t t, const char *buffer, int len, int timeout_ms); -typedef int (*io_read_func)(transport_handle_t t, char *buffer, int len, int timeout_ms); -typedef int (*trans_func)(transport_handle_t t); -typedef int (*poll_func)(transport_handle_t t, int timeout_ms); -typedef int (*connect_async_func)(transport_handle_t t, const char *host, int port, int timeout_ms); -typedef transport_handle_t (*payload_transfer_func)(transport_handle_t); +typedef int (*connect_func)(esp_transport_handle_t t, const char *host, int port, int timeout_ms); +typedef int (*io_func)(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms); +typedef int (*io_read_func)(esp_transport_handle_t t, char *buffer, int len, int timeout_ms); +typedef int (*trans_func)(esp_transport_handle_t t); +typedef int (*poll_func)(esp_transport_handle_t t, int timeout_ms); +typedef int (*connect_async_func)(esp_transport_handle_t t, const char *host, int port, int timeout_ms); +typedef esp_transport_handle_t (*payload_transfer_func)(esp_transport_handle_t); /** * @brief Create transport list * * @return A handle can hold all transports */ -transport_list_handle_t transport_list_init(); +esp_transport_list_handle_t esp_transport_list_init(); /** * @brief Cleanup and free all transports, include itself, - * this function will invoke transport_destroy of every transport have added this the list + * this function will invoke esp_transport_destroy of every transport have added this the list * * @param[in] list The list * @@ -50,7 +50,7 @@ transport_list_handle_t transport_list_init(); * - ESP_OK * - ESP_FAIL */ -esp_err_t transport_list_destroy(transport_list_handle_t list); +esp_err_t esp_transport_list_destroy(esp_transport_list_handle_t list); /** * @brief Add a transport to the list, and define a scheme to indentify this transport in the list @@ -62,11 +62,11 @@ esp_err_t transport_list_destroy(transport_list_handle_t list); * @return * - ESP_OK */ -esp_err_t transport_list_add(transport_list_handle_t list, transport_handle_t t, const char *scheme); +esp_err_t esp_transport_list_add(esp_transport_list_handle_t list, esp_transport_handle_t t, const char *scheme); /** * @brief This function will remove all transport from the list, - * invoke transport_destroy of every transport have added this the list + * invoke esp_transport_destroy of every transport have added this the list * * @param[in] list The list * @@ -74,24 +74,24 @@ esp_err_t transport_list_add(transport_list_handle_t list, transport_handle_t t, * - ESP_OK * - ESP_ERR_INVALID_ARG */ -esp_err_t transport_list_clean(transport_list_handle_t list); +esp_err_t esp_transport_list_clean(esp_transport_list_handle_t list); /** - * @brief Get the transport by scheme, which has been defined when calling function `transport_list_add` + * @brief Get the transport by scheme, which has been defined when calling function `esp_transport_list_add` * * @param[in] list The list * @param[in] tag The tag * * @return The transport handle */ -transport_handle_t transport_list_get_transport(transport_list_handle_t list, const char *scheme); +esp_transport_handle_t esp_transport_list_get_transport(esp_transport_list_handle_t list, const char *scheme); /** * @brief Initialize a transport handle object * * @return The transport handle */ -transport_handle_t transport_init(); +esp_transport_handle_t esp_transport_init(); /** * @brief Cleanup and free memory the transport @@ -102,7 +102,7 @@ transport_handle_t transport_init(); * - ESP_OK * - ESP_FAIL */ -esp_err_t transport_destroy(transport_handle_t t); +esp_err_t esp_transport_destroy(esp_transport_handle_t t); /** * @brief Get default port number used by this transport @@ -111,7 +111,7 @@ esp_err_t transport_destroy(transport_handle_t t); * * @return the port number */ -int transport_get_default_port(transport_handle_t t); +int esp_transport_get_default_port(esp_transport_handle_t t); /** * @brief Set default port number that can be used by this transport @@ -123,7 +123,7 @@ int transport_get_default_port(transport_handle_t t); * - ESP_OK * - ESP_FAIL */ -esp_err_t transport_set_default_port(transport_handle_t t, int port); +esp_err_t esp_transport_set_default_port(esp_transport_handle_t t, int port); /** * @brief Transport connection function, to make a connection to server @@ -137,7 +137,7 @@ esp_err_t transport_set_default_port(transport_handle_t t, int port); * - socket for will use by this transport * - (-1) if there are any errors, should check errno */ -int transport_connect(transport_handle_t t, const char *host, int port, int timeout_ms); +int esp_transport_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms); /** * @brief Non-blocking transport connection function, to make a connection to server @@ -151,7 +151,7 @@ int transport_connect(transport_handle_t t, const char *host, int port, int time * - socket for will use by this transport * - (-1) if there are any errors, should check errno */ -int transport_connect_async(transport_handle_t t, const char *host, int port, int timeout_ms); +int esp_transport_connect_async(esp_transport_handle_t t, const char *host, int port, int timeout_ms); /** * @brief Transport read function @@ -165,7 +165,7 @@ int transport_connect_async(transport_handle_t t, const char *host, int port, in * - Number of bytes was read * - (-1) if there are any errors, should check errno */ -int transport_read(transport_handle_t t, char *buffer, int len, int timeout_ms); +int esp_transport_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms); /** * @brief Poll the transport until readable or timeout @@ -178,7 +178,7 @@ int transport_read(transport_handle_t t, char *buffer, int len, int timeout_ms); * - (-1) If there are any errors, should check errno * - other The transport can read */ -int transport_poll_read(transport_handle_t t, int timeout_ms); +int esp_transport_poll_read(esp_transport_handle_t t, int timeout_ms); /** * @brief Transport write function @@ -192,7 +192,7 @@ int transport_poll_read(transport_handle_t t, int timeout_ms); * - Number of bytes was written * - (-1) if there are any errors, should check errno */ -int transport_write(transport_handle_t t, const char *buffer, int len, int timeout_ms); +int esp_transport_write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms); /** * @brief Poll the transport until writeable or timeout @@ -205,7 +205,7 @@ int transport_write(transport_handle_t t, const char *buffer, int len, int timeo * - (-1) If there are any errors, should check errno * - other The transport can write */ -int transport_poll_write(transport_handle_t t, int timeout_ms); +int esp_transport_poll_write(esp_transport_handle_t t, int timeout_ms); /** * @brief Transport close @@ -216,7 +216,7 @@ int transport_poll_write(transport_handle_t t, int timeout_ms); * - 0 if ok * - (-1) if there are any errors, should check errno */ -int transport_close(transport_handle_t t); +int esp_transport_close(esp_transport_handle_t t); /** * @brief Get user data context of this transport @@ -225,7 +225,7 @@ int transport_close(transport_handle_t t); * * @return The user data context */ -void *transport_get_context_data(transport_handle_t t); +void *esp_transport_get_context_data(esp_transport_handle_t t); /** * @brief Get transport handle of underlying protocol @@ -236,7 +236,7 @@ void *transport_get_context_data(transport_handle_t t); * * @return Payload transport handle */ -transport_handle_t transport_get_payload_transport_handle(transport_handle_t t); +esp_transport_handle_t esp_transport_get_payload_transport_handle(esp_transport_handle_t t); /** * @brief Set the user context data for this transport @@ -247,7 +247,7 @@ transport_handle_t transport_get_payload_transport_handle(transport_handle_t t); * @return * - ESP_OK */ -esp_err_t transport_set_context_data(transport_handle_t t, void *data); +esp_err_t esp_transport_set_context_data(esp_transport_handle_t t, void *data); /** * @brief Set transport functions for the transport handle @@ -260,20 +260,18 @@ esp_err_t transport_set_context_data(transport_handle_t t, void *data); * @param[in] _poll_read The poll read function pointer * @param[in] _poll_write The poll write function pointer * @param[in] _destroy The destroy function pointer - * @param[in] _parrent_transport The parrent transfer getter pointer * * @return * - ESP_OK */ -esp_err_t transport_set_func(transport_handle_t t, +esp_err_t esp_transport_set_func(esp_transport_handle_t t, connect_func _connect, io_read_func _read, io_func _write, trans_func _close, poll_func _poll_read, poll_func _poll_write, - trans_func _destroy, - payload_transfer_func _parrent_transport); + trans_func _destroy); /** @@ -286,9 +284,21 @@ esp_err_t transport_set_func(transport_handle_t t, * - ESP_OK * - ESP_FAIL */ -esp_err_t transport_set_async_connect_func(transport_handle_t t, connect_async_func _connect_async_func); +esp_err_t esp_transport_set_async_connect_func(esp_transport_handle_t t, connect_async_func _connect_async_func); + +/** + * @brief Set parent transport function to the handle + * + * @param[in] t The transport handle + * @param[in] _parent_transport The underlying transport getter pointer + * + * @return + * - ESP_OK + * - ESP_FAIL + */ +esp_err_t esp_transport_set_parent_transport_func(esp_transport_handle_t t, payload_transfer_func _parent_transport); #ifdef __cplusplus } #endif -#endif +#endif /* _ESP_TRANSPORT_ */ diff --git a/components/tcp_transport/include/transport_ssl.h b/components/tcp_transport/include/esp_transport_ssl.h similarity index 73% rename from components/tcp_transport/include/transport_ssl.h rename to components/tcp_transport/include/esp_transport_ssl.h index a00b36bab..2065db6b0 100644 --- a/components/tcp_transport/include/transport_ssl.h +++ b/components/tcp_transport/include/esp_transport_ssl.h @@ -12,10 +12,10 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef _TRANSPORT_SSL_H_ -#define _TRANSPORT_SSL_H_ +#ifndef _ESP_TRANSPORT_SSL_H_ +#define _ESP_TRANSPORT_SSL_H_ -#include "transport.h" +#include "esp_transport.h" #ifdef __cplusplus extern "C" { @@ -23,11 +23,11 @@ extern "C" { /** - * @brief Create new SSL transport, the transport handle must be release transport_destroy callback + * @brief Create new SSL transport, the transport handle must be release esp_transport_destroy callback * - * @return the allocated transport_handle_t, or NULL if the handle can not be allocated + * @return the allocated esp_transport_handle_t, or NULL if the handle can not be allocated */ -transport_handle_t transport_ssl_init(); +esp_transport_handle_t esp_transport_ssl_init(); /** * @brief Set SSL certificate data (as PEM format). @@ -38,11 +38,11 @@ transport_handle_t transport_ssl_init(); * @param[in] data The pem data * @param[in] len The length */ -void transport_ssl_set_cert_data(transport_handle_t t, const char *data, int len); +void esp_transport_ssl_set_cert_data(esp_transport_handle_t t, const char *data, int len); #ifdef __cplusplus } #endif -#endif +#endif /* _ESP_TRANSPORT_SSL_H_ */ diff --git a/components/tcp_transport/include/transport_tcp.h b/components/tcp_transport/include/esp_transport_tcp.h similarity index 71% rename from components/tcp_transport/include/transport_tcp.h rename to components/tcp_transport/include/esp_transport_tcp.h index e1cc1d343..57ad45330 100644 --- a/components/tcp_transport/include/transport_tcp.h +++ b/components/tcp_transport/include/esp_transport_tcp.h @@ -12,25 +12,25 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef _TRANSPORT_TCP_H_ -#define _TRANSPORT_TCP_H_ +#ifndef _ESP_TRANSPORT_TCP_H_ +#define _ESP_TRANSPORT_TCP_H_ -#include "transport.h" +#include "esp_transport.h" #ifdef __cplusplus extern "C" { #endif /** - * @brief Create TCP transport, the transport handle must be release transport_destroy callback + * @brief Create TCP transport, the transport handle must be release esp_transport_destroy callback * - * @return the allocated transport_handle_t, or NULL if the handle can not be allocated + * @return the allocated esp_transport_handle_t, or NULL if the handle can not be allocated */ -transport_handle_t transport_tcp_init(); +esp_transport_handle_t esp_transport_tcp_init(); #ifdef __cplusplus } #endif -#endif +#endif /* _ESP_TRANSPORT_TCP_H_ */ diff --git a/components/tcp_transport/include/transport_utils.h b/components/tcp_transport/include/esp_transport_utils.h similarity index 78% rename from components/tcp_transport/include/transport_utils.h rename to components/tcp_transport/include/esp_transport_utils.h index 0e72812ea..405b4f6b4 100644 --- a/components/tcp_transport/include/transport_utils.h +++ b/components/tcp_transport/include/esp_transport_utils.h @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef _TRANSPORT_UTILS_H_ -#define _TRANSPORT_UTILS_H_ +#ifndef _ESP_TRANSPORT_UTILS_H_ +#define _ESP_TRANSPORT_UTILS_H_ #include #ifdef __cplusplus @@ -26,10 +26,10 @@ extern "C" { * @param[in] timeout_ms The timeout milliseconds * @param[out] tv Timeval struct */ -void transport_utils_ms_to_timeval(int timeout_ms, struct timeval *tv); +void esp_transport_utils_ms_to_timeval(int timeout_ms, struct timeval *tv); -#define TRANSPORT_MEM_CHECK(TAG, a, action) if (!(a)) { \ +#define ESP_TRANSPORT_MEM_CHECK(TAG, a, action) if (!(a)) { \ ESP_LOGE(TAG,"%s:%d (%s): %s", __FILE__, __LINE__, __FUNCTION__, "Memory exhausted"); \ action; \ } @@ -37,4 +37,4 @@ void transport_utils_ms_to_timeval(int timeout_ms, struct timeval *tv); #ifdef __cplusplus } #endif -#endif /* _TRANSPORT_UTILS_H_ */ \ No newline at end of file +#endif /* _ESP_TRANSPORT_UTILS_H_ */ \ No newline at end of file diff --git a/components/tcp_transport/include/esp_transport_ws.h b/components/tcp_transport/include/esp_transport_ws.h new file mode 100644 index 000000000..582c5c7da --- /dev/null +++ b/components/tcp_transport/include/esp_transport_ws.h @@ -0,0 +1,34 @@ +/* + * This file is subject to the terms and conditions defined in + * file 'LICENSE', which is part of this source code package. + * Tuan PM + */ + +#ifndef _ESP_TRANSPORT_WS_H_ +#define _ESP_TRANSPORT_WS_H_ + +#include "esp_transport.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @brief Create web socket transport + * + * @return + * - transport + * - NULL + */ +esp_transport_handle_t esp_transport_ws_init(esp_transport_handle_t parent_handle); + +void esp_transport_ws_set_path(esp_transport_handle_t t, const char *path); + + + +#ifdef __cplusplus +} +#endif + +#endif /* _ESP_TRANSPORT_WS_H_ */ diff --git a/components/tcp_transport/transport.c b/components/tcp_transport/transport.c index c23ed8d34..5c2f913fe 100644 --- a/components/tcp_transport/transport.c +++ b/components/tcp_transport/transport.c @@ -19,15 +19,15 @@ #include "rom/queue.h" #include "esp_log.h" -#include "transport.h" -#include "transport_utils.h" +#include "esp_transport.h" +#include "esp_transport_utils.h" static const char *TAG = "TRANSPORT"; /** * Transport layer structure, which will provide functions, basic properties for transport types */ -struct transport_item_t { +struct esp_transport_item_t { int port; int socket; /*!< Socket to use in this transport */ char *scheme; /*!< Tag name */ @@ -41,39 +41,46 @@ struct transport_item_t { poll_func _poll_write; /*!< Poll and write */ trans_func _destroy; /*!< Destroy and free transport */ connect_async_func _connect_async; /*!< non-blocking connect function of this transport */ - payload_transfer_func _parrent_transfer; /*!< Function returning underlying transport layer */ + payload_transfer_func _parent_transfer; /*!< Function returning underlying transport layer */ - STAILQ_ENTRY(transport_item_t) next; + STAILQ_ENTRY(esp_transport_item_t) next; }; /** * This list will hold all transport available */ -STAILQ_HEAD(transport_list_t, transport_item_t); +STAILQ_HEAD(esp_transport_list_t, esp_transport_item_t); - -transport_list_handle_t transport_list_init() +static esp_transport_handle_t esp_transport_get_default_parent(esp_transport_handle_t t) { - transport_list_handle_t list = calloc(1, sizeof(struct transport_list_t)); - TRANSPORT_MEM_CHECK(TAG, list, return NULL); + /* + * By default, the underlying transport layer handle is the handle itself + */ + return t; +} + +esp_transport_list_handle_t esp_transport_list_init() +{ + esp_transport_list_handle_t list = calloc(1, sizeof(struct esp_transport_list_t)); + ESP_TRANSPORT_MEM_CHECK(TAG, list, return NULL); STAILQ_INIT(list); return list; } -esp_err_t transport_list_add(transport_list_handle_t list, transport_handle_t t, const char *scheme) +esp_err_t esp_transport_list_add(esp_transport_list_handle_t list, esp_transport_handle_t t, const char *scheme) { if (list == NULL || t == NULL) { return ESP_ERR_INVALID_ARG; } t->scheme = calloc(1, strlen(scheme) + 1); - TRANSPORT_MEM_CHECK(TAG, t->scheme, return ESP_ERR_NO_MEM); + ESP_TRANSPORT_MEM_CHECK(TAG, t->scheme, return ESP_ERR_NO_MEM); strcpy(t->scheme, scheme); STAILQ_INSERT_TAIL(list, t, next); return ESP_OK; } -transport_handle_t transport_list_get_transport(transport_list_handle_t list, const char *scheme) +esp_transport_handle_t esp_transport_list_get_transport(esp_transport_list_handle_t list, const char *scheme) { if (!list) { return NULL; @@ -81,7 +88,7 @@ transport_handle_t transport_list_get_transport(transport_list_handle_t list, co if (scheme == NULL) { return STAILQ_FIRST(list); } - transport_handle_t item; + esp_transport_handle_t item; STAILQ_FOREACH(item, list, next) { if (strcasecmp(item->scheme, scheme) == 0) { return item; @@ -90,45 +97,45 @@ transport_handle_t transport_list_get_transport(transport_list_handle_t list, co return NULL; } -esp_err_t transport_list_destroy(transport_list_handle_t list) +esp_err_t esp_transport_list_destroy(esp_transport_list_handle_t list) { - transport_list_clean(list); + esp_transport_list_clean(list); free(list); return ESP_OK; } -esp_err_t transport_list_clean(transport_list_handle_t list) +esp_err_t esp_transport_list_clean(esp_transport_list_handle_t list) { - transport_handle_t item = STAILQ_FIRST(list); - transport_handle_t tmp; + esp_transport_handle_t item = STAILQ_FIRST(list); + esp_transport_handle_t tmp; while (item != NULL) { tmp = STAILQ_NEXT(item, next); if (item->_destroy) { item->_destroy(item); } - transport_destroy(item); + esp_transport_destroy(item); item = tmp; } STAILQ_INIT(list); return ESP_OK; } -transport_handle_t transport_init() +esp_transport_handle_t esp_transport_init() { - transport_handle_t t = calloc(1, sizeof(struct transport_item_t)); - TRANSPORT_MEM_CHECK(TAG, t, return NULL); + esp_transport_handle_t t = calloc(1, sizeof(struct esp_transport_item_t)); + ESP_TRANSPORT_MEM_CHECK(TAG, t, return NULL); return t; } -transport_handle_t transport_get_payload_transport_handle(transport_handle_t t) +esp_transport_handle_t esp_transport_get_payload_transport_handle(esp_transport_handle_t t) { if (t && t->_read) { - return t->_parrent_transfer(t); + return t->_parent_transfer(t); } return NULL; } -esp_err_t transport_destroy(transport_handle_t t) +esp_err_t esp_transport_destroy(esp_transport_handle_t t) { if (t->scheme) { free(t->scheme); @@ -137,7 +144,7 @@ esp_err_t transport_destroy(transport_handle_t t) return ESP_OK; } -int transport_connect(transport_handle_t t, const char *host, int port, int timeout_ms) +int esp_transport_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms) { int ret = -1; if (t && t->_connect) { @@ -146,7 +153,7 @@ int transport_connect(transport_handle_t t, const char *host, int port, int time return ret; } -int transport_connect_async(transport_handle_t t, const char *host, int port, int timeout_ms) +int esp_transport_connect_async(esp_transport_handle_t t, const char *host, int port, int timeout_ms) { int ret = -1; if (t && t->_connect) { @@ -155,7 +162,7 @@ int transport_connect_async(transport_handle_t t, const char *host, int port, in return ret; } -int transport_read(transport_handle_t t, char *buffer, int len, int timeout_ms) +int esp_transport_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms) { if (t && t->_read) { return t->_read(t, buffer, len, timeout_ms); @@ -163,7 +170,7 @@ int transport_read(transport_handle_t t, char *buffer, int len, int timeout_ms) return -1; } -int transport_write(transport_handle_t t, const char *buffer, int len, int timeout_ms) +int esp_transport_write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms) { if (t && t->_write) { return t->_write(t, buffer, len, timeout_ms); @@ -171,7 +178,7 @@ int transport_write(transport_handle_t t, const char *buffer, int len, int timeo return -1; } -int transport_poll_read(transport_handle_t t, int timeout_ms) +int esp_transport_poll_read(esp_transport_handle_t t, int timeout_ms) { if (t && t->_poll_read) { return t->_poll_read(t, timeout_ms); @@ -179,7 +186,7 @@ int transport_poll_read(transport_handle_t t, int timeout_ms) return -1; } -int transport_poll_write(transport_handle_t t, int timeout_ms) +int esp_transport_poll_write(esp_transport_handle_t t, int timeout_ms) { if (t && t->_poll_write) { return t->_poll_write(t, timeout_ms); @@ -187,7 +194,7 @@ int transport_poll_write(transport_handle_t t, int timeout_ms) return -1; } -int transport_close(transport_handle_t t) +int esp_transport_close(esp_transport_handle_t t) { if (t && t->_close) { return t->_close(t); @@ -195,7 +202,7 @@ int transport_close(transport_handle_t t) return 0; } -void *transport_get_context_data(transport_handle_t t) +void *esp_transport_get_context_data(esp_transport_handle_t t) { if (t) { return t->data; @@ -203,7 +210,7 @@ void *transport_get_context_data(transport_handle_t t) return NULL; } -esp_err_t transport_set_context_data(transport_handle_t t, void *data) +esp_err_t esp_transport_set_context_data(esp_transport_handle_t t, void *data) { if (t) { t->data = data; @@ -212,15 +219,14 @@ esp_err_t transport_set_context_data(transport_handle_t t, void *data) return ESP_FAIL; } -esp_err_t transport_set_func(transport_handle_t t, +esp_err_t esp_transport_set_func(esp_transport_handle_t t, connect_func _connect, io_read_func _read, io_func _write, trans_func _close, poll_func _poll_read, poll_func _poll_write, - trans_func _destroy, - payload_transfer_func _parrent_transport) + trans_func _destroy) { if (t == NULL) { return ESP_FAIL; @@ -233,11 +239,11 @@ esp_err_t transport_set_func(transport_handle_t t, t->_poll_write = _poll_write; t->_destroy = _destroy; t->_connect_async = NULL; - t->_parrent_transfer = _parrent_transport; + t->_parent_transfer = esp_transport_get_default_parent; return ESP_OK; } -int transport_get_default_port(transport_handle_t t) +int esp_transport_get_default_port(esp_transport_handle_t t) { if (t == NULL) { return -1; @@ -245,7 +251,7 @@ int transport_get_default_port(transport_handle_t t) return t->port; } -esp_err_t transport_set_default_port(transport_handle_t t, int port) +esp_err_t esp_transport_set_default_port(esp_transport_handle_t t, int port) { if (t == NULL) { return ESP_FAIL; @@ -254,12 +260,7 @@ esp_err_t transport_set_default_port(transport_handle_t t, int port) return ESP_OK; } -transport_handle_t transport_get_handle(transport_handle_t t) -{ - return t; -} - -esp_err_t transport_set_async_connect_func(transport_handle_t t, connect_async_func _connect_async_func) +esp_err_t esp_transport_set_async_connect_func(esp_transport_handle_t t, connect_async_func _connect_async_func) { if (t == NULL) { return ESP_FAIL; @@ -267,3 +268,12 @@ esp_err_t transport_set_async_connect_func(transport_handle_t t, connect_async_f t->_connect_async = _connect_async_func; return ESP_OK; } + +esp_err_t esp_transport_set_parent_transport_func(esp_transport_handle_t t, payload_transfer_func _parent_transport) +{ + if (t == NULL) { + return ESP_FAIL; + } + t->_parent_transfer = _parent_transport; + return ESP_OK; +} diff --git a/components/tcp_transport/transport_ssl.c b/components/tcp_transport/transport_ssl.c index 8e995764e..08afe3c19 100644 --- a/components/tcp_transport/transport_ssl.c +++ b/components/tcp_transport/transport_ssl.c @@ -21,9 +21,9 @@ #include "esp_log.h" #include "esp_system.h" -#include "transport.h" -#include "transport_ssl.h" -#include "transport_utils.h" +#include "esp_transport.h" +#include "esp_transport_ssl.h" +#include "esp_transport_utils.h" static const char *TAG = "TRANS_SSL"; @@ -43,13 +43,11 @@ typedef struct { transport_ssl_conn_state_t conn_state; } transport_ssl_t; -transport_handle_t transport_get_handle(transport_handle_t t); +static int ssl_close(esp_transport_handle_t t); -static int ssl_close(transport_handle_t t); - -static int ssl_connect_async(transport_handle_t t, const char *host, int port, int timeout_ms) +static int ssl_connect_async(esp_transport_handle_t t, const char *host, int port, int timeout_ms) { - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); if (ssl->conn_state == TRANS_SSL_INIT) { if (ssl->cfg.cacert_pem_buf) { ssl->verify_server = true; @@ -69,9 +67,9 @@ static int ssl_connect_async(transport_handle_t t, const char *host, int port, i return 0; } -static int ssl_connect(transport_handle_t t, const char *host, int port, int timeout_ms) +static int ssl_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms) { - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); if (ssl->cfg.cacert_pem_buf) { ssl->verify_server = true; } @@ -85,35 +83,35 @@ static int ssl_connect(transport_handle_t t, const char *host, int port, int tim return 0; } -static int ssl_poll_read(transport_handle_t t, int timeout_ms) +static int ssl_poll_read(esp_transport_handle_t t, int timeout_ms) { - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); fd_set readset; FD_ZERO(&readset); FD_SET(ssl->tls->sockfd, &readset); struct timeval timeout; - transport_utils_ms_to_timeval(timeout_ms, &timeout); + esp_transport_utils_ms_to_timeval(timeout_ms, &timeout); return select(ssl->tls->sockfd + 1, &readset, NULL, NULL, &timeout); } -static int ssl_poll_write(transport_handle_t t, int timeout_ms) +static int ssl_poll_write(esp_transport_handle_t t, int timeout_ms) { - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); fd_set writeset; FD_ZERO(&writeset); FD_SET(ssl->tls->sockfd, &writeset); struct timeval timeout; - transport_utils_ms_to_timeval(timeout_ms, &timeout); + esp_transport_utils_ms_to_timeval(timeout_ms, &timeout); return select(ssl->tls->sockfd + 1, NULL, &writeset, NULL, &timeout); } -static int ssl_write(transport_handle_t t, const char *buffer, int len, int timeout_ms) +static int ssl_write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms) { int poll, ret; - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); - if ((poll = transport_poll_write(t, timeout_ms)) <= 0) { + if ((poll = esp_transport_poll_write(t, timeout_ms)) <= 0) { ESP_LOGW(TAG, "Poll timeout or error, errno=%s, fd=%d, timeout_ms=%d", strerror(errno), ssl->tls->sockfd, timeout_ms); return poll; } @@ -124,13 +122,13 @@ static int ssl_write(transport_handle_t t, const char *buffer, int len, int time return ret; } -static int ssl_read(transport_handle_t t, char *buffer, int len, int timeout_ms) +static int ssl_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms) { int poll, ret; - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); if (esp_tls_get_bytes_avail(ssl->tls) <= 0) { - if ((poll = transport_poll_read(t, timeout_ms)) <= 0) { + if ((poll = esp_transport_poll_read(t, timeout_ms)) <= 0) { return poll; } } @@ -141,10 +139,10 @@ static int ssl_read(transport_handle_t t, char *buffer, int len, int timeout_ms) return ret; } -static int ssl_close(transport_handle_t t) +static int ssl_close(esp_transport_handle_t t) { int ret = -1; - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); if (ssl->ssl_initialized) { esp_tls_conn_delete(ssl->tls); ssl->ssl_initialized = false; @@ -153,31 +151,31 @@ static int ssl_close(transport_handle_t t) return ret; } -static int ssl_destroy(transport_handle_t t) +static int ssl_destroy(esp_transport_handle_t t) { - transport_ssl_t *ssl = transport_get_context_data(t); - transport_close(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); + esp_transport_close(t); free(ssl); return 0; } -void transport_ssl_set_cert_data(transport_handle_t t, const char *data, int len) +void esp_transport_ssl_set_cert_data(esp_transport_handle_t t, const char *data, int len) { - transport_ssl_t *ssl = transport_get_context_data(t); + transport_ssl_t *ssl = esp_transport_get_context_data(t); if (t && ssl) { ssl->cfg.cacert_pem_buf = (void *)data; ssl->cfg.cacert_pem_bytes = len + 1; } } -transport_handle_t transport_ssl_init() +esp_transport_handle_t esp_transport_ssl_init() { - transport_handle_t t = transport_init(); + esp_transport_handle_t t = esp_transport_init(); transport_ssl_t *ssl = calloc(1, sizeof(transport_ssl_t)); - TRANSPORT_MEM_CHECK(TAG, ssl, return NULL); - transport_set_context_data(t, ssl); - transport_set_func(t, ssl_connect, ssl_read, ssl_write, ssl_close, ssl_poll_read, ssl_poll_write, ssl_destroy, transport_get_handle); - transport_set_async_connect_func(t, ssl_connect_async); + ESP_TRANSPORT_MEM_CHECK(TAG, ssl, return NULL); + esp_transport_set_context_data(t, ssl); + esp_transport_set_func(t, ssl_connect, ssl_read, ssl_write, ssl_close, ssl_poll_read, ssl_poll_write, ssl_destroy); + esp_transport_set_async_connect_func(t, ssl_connect_async); return t; } diff --git a/components/tcp_transport/transport_tcp.c b/components/tcp_transport/transport_tcp.c index 2de0dab87..ff6925b2d 100644 --- a/components/tcp_transport/transport_tcp.c +++ b/components/tcp_transport/transport_tcp.c @@ -23,8 +23,8 @@ #include "esp_system.h" #include "esp_err.h" -#include "transport_utils.h" -#include "transport.h" +#include "esp_transport_utils.h" +#include "esp_transport.h" static const char *TAG = "TRANS_TCP"; @@ -32,8 +32,6 @@ typedef struct { int sock; } transport_tcp_t; -transport_handle_t transport_get_handle(transport_handle_t t); - static int resolve_dns(const char *host, struct sockaddr_in *ip) { struct hostent *he; @@ -51,11 +49,11 @@ static int resolve_dns(const char *host, struct sockaddr_in *ip) { return ESP_OK; } -static int tcp_connect(transport_handle_t t, const char *host, int port, int timeout_ms) +static int tcp_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms) { struct sockaddr_in remote_ip; struct timeval tv; - transport_tcp_t *tcp = transport_get_context_data(t); + transport_tcp_t *tcp = esp_transport_get_context_data(t); bzero(&remote_ip, sizeof(struct sockaddr_in)); @@ -76,7 +74,7 @@ static int tcp_connect(transport_handle_t t, const char *host, int port, int tim remote_ip.sin_family = AF_INET; remote_ip.sin_port = htons(port); - transport_utils_ms_to_timeval(timeout_ms, &tv); + esp_transport_utils_ms_to_timeval(timeout_ms, &tv); setsockopt(tcp->sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); @@ -90,21 +88,21 @@ static int tcp_connect(transport_handle_t t, const char *host, int port, int tim return tcp->sock; } -static int tcp_write(transport_handle_t t, const char *buffer, int len, int timeout_ms) +static int tcp_write(esp_transport_handle_t t, const char *buffer, int len, int timeout_ms) { int poll; - transport_tcp_t *tcp = transport_get_context_data(t); - if ((poll = transport_poll_write(t, timeout_ms)) <= 0) { + transport_tcp_t *tcp = esp_transport_get_context_data(t); + if ((poll = esp_transport_poll_write(t, timeout_ms)) <= 0) { return poll; } return write(tcp->sock, buffer, len); } -static int tcp_read(transport_handle_t t, char *buffer, int len, int timeout_ms) +static int tcp_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms) { - transport_tcp_t *tcp = transport_get_context_data(t); + transport_tcp_t *tcp = esp_transport_get_context_data(t); int poll = -1; - if ((poll = transport_poll_read(t, timeout_ms)) <= 0) { + if ((poll = esp_transport_poll_read(t, timeout_ms)) <= 0) { return poll; } int read_len = read(tcp->sock, buffer, len); @@ -114,31 +112,31 @@ static int tcp_read(transport_handle_t t, char *buffer, int len, int timeout_ms) return read_len; } -static int tcp_poll_read(transport_handle_t t, int timeout_ms) +static int tcp_poll_read(esp_transport_handle_t t, int timeout_ms) { - transport_tcp_t *tcp = transport_get_context_data(t); + transport_tcp_t *tcp = esp_transport_get_context_data(t); fd_set readset; FD_ZERO(&readset); FD_SET(tcp->sock, &readset); struct timeval timeout; - transport_utils_ms_to_timeval(timeout_ms, &timeout); + esp_transport_utils_ms_to_timeval(timeout_ms, &timeout); return select(tcp->sock + 1, &readset, NULL, NULL, &timeout); } -static int tcp_poll_write(transport_handle_t t, int timeout_ms) +static int tcp_poll_write(esp_transport_handle_t t, int timeout_ms) { - transport_tcp_t *tcp = transport_get_context_data(t); + transport_tcp_t *tcp = esp_transport_get_context_data(t); fd_set writeset; FD_ZERO(&writeset); FD_SET(tcp->sock, &writeset); struct timeval timeout; - transport_utils_ms_to_timeval(timeout_ms, &timeout); + esp_transport_utils_ms_to_timeval(timeout_ms, &timeout); return select(tcp->sock + 1, NULL, &writeset, NULL, &timeout); } -static int tcp_close(transport_handle_t t) +static int tcp_close(esp_transport_handle_t t) { - transport_tcp_t *tcp = transport_get_context_data(t); + transport_tcp_t *tcp = esp_transport_get_context_data(t); int ret = -1; if (tcp->sock >= 0) { ret = close(tcp->sock); @@ -147,22 +145,22 @@ static int tcp_close(transport_handle_t t) return ret; } -static esp_err_t tcp_destroy(transport_handle_t t) +static esp_err_t tcp_destroy(esp_transport_handle_t t) { - transport_tcp_t *tcp = transport_get_context_data(t); - transport_close(t); + transport_tcp_t *tcp = esp_transport_get_context_data(t); + esp_transport_close(t); free(tcp); return 0; } -transport_handle_t transport_tcp_init() +esp_transport_handle_t esp_transport_tcp_init() { - transport_handle_t t = transport_init(); + esp_transport_handle_t t = esp_transport_init(); transport_tcp_t *tcp = calloc(1, sizeof(transport_tcp_t)); - TRANSPORT_MEM_CHECK(TAG, tcp, return NULL); + ESP_TRANSPORT_MEM_CHECK(TAG, tcp, return NULL); tcp->sock = -1; - transport_set_func(t, tcp_connect, tcp_read, tcp_write, tcp_close, tcp_poll_read, tcp_poll_write, tcp_destroy, transport_get_handle); - transport_set_context_data(t, tcp); + esp_transport_set_func(t, tcp_connect, tcp_read, tcp_write, tcp_close, tcp_poll_read, tcp_poll_write, tcp_destroy); + esp_transport_set_context_data(t, tcp); return t; } diff --git a/components/tcp_transport/transport_utils.c b/components/tcp_transport/transport_utils.c index 95174cf59..9ef56dc24 100644 --- a/components/tcp_transport/transport_utils.c +++ b/components/tcp_transport/transport_utils.c @@ -4,9 +4,9 @@ #include #include -#include "transport_utils.h" +#include "esp_transport_utils.h" -void transport_utils_ms_to_timeval(int timeout_ms, struct timeval *tv) +void esp_transport_utils_ms_to_timeval(int timeout_ms, struct timeval *tv) { tv->tv_sec = timeout_ms / 1000; tv->tv_usec = (timeout_ms - (tv->tv_sec * 1000)) * 1000; diff --git a/components/tcp_transport/transport_ws.c b/components/tcp_transport/transport_ws.c new file mode 100644 index 000000000..b453a3e55 --- /dev/null +++ b/components/tcp_transport/transport_ws.c @@ -0,0 +1,293 @@ +#include +#include +#include +#include + +#include "esp_log.h" +#include "esp_transport.h" +#include "esp_transport_tcp.h" +#include "esp_transport_ws.h" +#include "esp_transport_utils.h" +#include "mbedtls/base64.h" +#include "mbedtls/sha1.h" + +static const char *TAG = "TRANSPORT_WS"; + +#define DEFAULT_WS_BUFFER (1024) +#define WS_FIN 0x80 +#define WS_OPCODE_TEXT 0x01 +#define WS_OPCODE_BINARY 0x02 +#define WS_OPCODE_CLOSE 0x08 +#define WS_OPCODE_PING 0x09 +#define WS_OPCODE_PONG 0x0a +// Second byte +#define WS_MASK 0x80 +#define WS_SIZE16 126 +#define WS_SIZE64 127 +#define MAX_WEBSOCKET_HEADER_SIZE 10 +#define WS_RESPONSE_OK 101 + +typedef struct { + char *path; + char *buffer; + esp_transport_handle_t parent; +} transport_ws_t; + +static esp_transport_handle_t ws_get_payload_transport_handle(esp_transport_handle_t t) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + return ws->parent; +} + +static char *trimwhitespace(const char *str) +{ + char *end; + + // Trim leading space + while (isspace((unsigned char)*str)) str++; + + if (*str == 0) { + return (char *)str; + } + + // Trim trailing space + end = (char *)(str + strlen(str) - 1); + while (end > str && isspace((unsigned char)*end)) end--; + + // Write new null terminator + *(end + 1) = 0; + + return (char *)str; +} + + +static char *get_http_header(const char *buffer, const char *key) +{ + char *found = strstr(buffer, key); + if (found) { + found += strlen(key); + char *found_end = strstr(found, "\r\n"); + if (found_end) { + found_end[0] = 0;//terminal string + + return trimwhitespace(found); + } + } + return NULL; +} + +static int ws_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + if (esp_transport_connect(ws->parent, host, port, timeout_ms) < 0) { + ESP_LOGE(TAG, "Error connect to ther server"); + } + + unsigned char random_key[16]; + getrandom(random_key, sizeof(random_key), 0); + + // Size of base64 coded string is equal '((input_size * 4) / 3) + (input_size / 96) + 6' including Z-term + unsigned char client_key[28] = {0}; + + size_t outlen = 0; + mbedtls_base64_encode(client_key, sizeof(client_key), &outlen, random_key, sizeof(random_key)); + int len = snprintf(ws->buffer, DEFAULT_WS_BUFFER, + "GET %s HTTP/1.1\r\n" + "Connection: Upgrade\r\n" + "Host: %s:%d\r\n" + "Upgrade: websocket\r\n" + "Sec-WebSocket-Version: 13\r\n" + "Sec-WebSocket-Protocol: mqtt\r\n" + "Sec-WebSocket-Key: %s\r\n" + "User-Agent: ESP32 Websocket Client\r\n\r\n", + ws->path, + host, port, + client_key); + if (len <= 0 || len >= DEFAULT_WS_BUFFER) { + ESP_LOGE(TAG, "Error in request generation, %d", len); + return -1; + } + ESP_LOGD(TAG, "Write upgrate request\r\n%s", ws->buffer); + if (esp_transport_write(ws->parent, ws->buffer, len, timeout_ms) <= 0) { + ESP_LOGE(TAG, "Error write Upgrade header %s", ws->buffer); + return -1; + } + if ((len = esp_transport_read(ws->parent, ws->buffer, DEFAULT_WS_BUFFER, timeout_ms)) <= 0) { + ESP_LOGE(TAG, "Error read response for Upgrade header %s", ws->buffer); + return -1; + } + char *server_key = get_http_header(ws->buffer, "Sec-WebSocket-Accept:"); + if (server_key == NULL) { + ESP_LOGE(TAG, "Sec-WebSocket-Accept not found"); + return -1; + } + + // See mbedtls_sha1_ret() arg size + unsigned char expected_server_sha1[20]; + // Size of base64 coded string see above + unsigned char expected_server_key[33] = {0}; + // If you are interested, see https://tools.ietf.org/html/rfc6455 + const char expected_server_magic[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + unsigned char expected_server_text[sizeof(client_key) + sizeof(expected_server_magic) + 1]; + strcpy((char*)expected_server_text, (char*)client_key); + strcat((char*)expected_server_text, expected_server_magic); + + size_t key_len = strlen((char*)expected_server_text); + mbedtls_sha1_ret(expected_server_text, key_len, expected_server_sha1); + mbedtls_base64_encode(expected_server_key, sizeof(expected_server_key), &outlen, expected_server_sha1, sizeof(expected_server_sha1)); + expected_server_key[ (outlen < sizeof(expected_server_key)) ? outlen : (sizeof(expected_server_key) - 1) ] = 0; + ESP_LOGD(TAG, "server key=%s, send_key=%s, expected_server_key=%s", (char *)server_key, (char*)client_key, expected_server_key); + if (strcmp((char*)expected_server_key, (char*)server_key) != 0) { + ESP_LOGE(TAG, "Invalid websocket key"); + return -1; + } + return 0; +} + +static int ws_write(esp_transport_handle_t t, const char *buff, int len, int timeout_ms) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + char ws_header[MAX_WEBSOCKET_HEADER_SIZE]; + char *mask; + int header_len = 0, i; + char *buffer = (char *)buff; + int poll_write; + if ((poll_write = esp_transport_poll_write(ws->parent, timeout_ms)) <= 0) { + return poll_write; + } + + ws_header[header_len++] = WS_OPCODE_BINARY | WS_FIN; + + // NOTE: no support for > 16-bit sized messages + if (len > 125) { + ws_header[header_len++] = WS_SIZE16 | WS_MASK; + ws_header[header_len++] = (uint8_t)(len >> 8); + ws_header[header_len++] = (uint8_t)(len & 0xFF); + } else { + ws_header[header_len++] = (uint8_t)(len | WS_MASK); + } + mask = &ws_header[header_len]; + getrandom(ws_header + header_len, 4, 0); + header_len += 4; + + for (i = 0; i < len; ++i) { + buffer[i] = (buffer[i] ^ mask[i % 4]); + } + if (esp_transport_write(ws->parent, ws_header, header_len, timeout_ms) != header_len) { + ESP_LOGE(TAG, "Error write header"); + return -1; + } + return esp_transport_write(ws->parent, buffer, len, timeout_ms); +} + +static int ws_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + int payload_len; + int payload_len_buff = len; + char *data_ptr = buffer, opcode, mask, *mask_key = NULL; + int rlen; + int poll_read; + if ((poll_read = esp_transport_poll_read(ws->parent, timeout_ms)) <= 0) { + return poll_read; + } + if ((rlen = esp_transport_read(ws->parent, buffer, len, timeout_ms)) <= 0) { + ESP_LOGE(TAG, "Error read data"); + return rlen; + } + opcode = (*data_ptr & 0x0F); + data_ptr ++; + mask = ((*data_ptr >> 7) & 0x01); + payload_len = (*data_ptr & 0x7F); + data_ptr++; + ESP_LOGD(TAG, "Opcode: %d, mask: %d, len: %d\r\n", opcode, mask, payload_len); + if (payload_len == 126) { + // headerLen += 2; + payload_len = data_ptr[0] << 8 | data_ptr[1]; + payload_len_buff = len - 4; + data_ptr += 2; + } else if (payload_len == 127) { + // headerLen += 8; + + if (data_ptr[0] != 0 || data_ptr[1] != 0 || data_ptr[2] != 0 || data_ptr[3] != 0) { + // really too big! + payload_len = 0xFFFFFFFF; + } else { + payload_len = data_ptr[4] << 24 | data_ptr[5] << 16 | data_ptr[6] << 8 | data_ptr[7]; + } + data_ptr += 8; + payload_len_buff = len - 10; + } + if (payload_len > payload_len_buff) { + ESP_LOGD(TAG, "Actual data received (%d) are longer than mqtt buffer (%d)", payload_len, payload_len_buff); + payload_len = payload_len_buff; + } + + if (mask) { + mask_key = data_ptr; + data_ptr += 4; + for (int i = 0; i < payload_len; i++) { + buffer[i] = (data_ptr[i] ^ mask_key[i % 4]); + } + } else { + memmove(buffer, data_ptr, payload_len); + } + return payload_len; +} + +static int ws_poll_read(esp_transport_handle_t t, int timeout_ms) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + return esp_transport_poll_read(ws->parent, timeout_ms); +} + +static int ws_poll_write(esp_transport_handle_t t, int timeout_ms) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + return esp_transport_poll_write(ws->parent, timeout_ms);; +} + +static int ws_close(esp_transport_handle_t t) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + return esp_transport_close(ws->parent); +} + +static esp_err_t ws_destroy(esp_transport_handle_t t) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + free(ws->buffer); + free(ws->path); + free(ws); + return 0; +} +void esp_transport_ws_set_path(esp_transport_handle_t t, const char *path) +{ + transport_ws_t *ws = esp_transport_get_context_data(t); + ws->path = realloc(ws->path, strlen(path) + 1); + strcpy(ws->path, path); +} +esp_transport_handle_t esp_transport_ws_init(esp_transport_handle_t parent_handle) +{ + esp_transport_handle_t t = esp_transport_init(); + transport_ws_t *ws = calloc(1, sizeof(transport_ws_t)); + ESP_TRANSPORT_MEM_CHECK(TAG, ws, return NULL); + ws->parent = parent_handle; + + ws->path = strdup("/"); + ESP_TRANSPORT_MEM_CHECK(TAG, ws->path, return NULL); + ws->buffer = malloc(DEFAULT_WS_BUFFER); + ESP_TRANSPORT_MEM_CHECK(TAG, ws->buffer, { + free(ws->path); + free(ws); + return NULL; + }); + + esp_transport_set_func(t, ws_connect, ws_read, ws_write, ws_close, ws_poll_read, ws_poll_write, ws_destroy); + // webocket underlying transfer is the payload transfer handle + esp_transport_set_parent_transport_func(t, ws_get_payload_transport_handle); + + esp_transport_set_context_data(t, ws); + return t; +} +