Merge branch 'feature/transpost_methods_renamed_no_collision' into 'master'
Renamed transport header files to esp_ prefixed See merge request idf/esp-idf!3359
This commit is contained in:
Angus Gratton
commit
3977d4b565
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
#ifndef _HTTP_UTILS_H_
|
||||
#define _HTTP_UTILS_H_
|
||||
#include <sys/time.h>
|
||||
#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
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit bcb38e45f521085f997439a8b6c4ead34dff9043
|
||||
Subproject commit 85ee406d03fd84f5613c6dead1ea653e384b9559
|
||||
|
|
@ -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()
|
||||
register_component()
|
||||
|
|
|
|||
|
|
@ -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 <esp_err.h>
|
||||
|
||||
|
|
@ -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_ */
|
||||
|
|
@ -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_ */
|
||||
|
||||
|
|
@ -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_ */
|
||||
|
|
@ -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 <sys/time.h>
|
||||
|
||||
#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_ */
|
||||
#endif /* _ESP_TRANSPORT_UTILS_H_ */
|
||||
34
components/tcp_transport/include/esp_transport_ws.h
Normal file
34
components/tcp_transport/include/esp_transport_ws.h
Normal file
|
|
@ -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 <tuanpm at live dot com>
|
||||
*/
|
||||
|
||||
#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_ */
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,9 +4,9 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
|
||||
#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;
|
||||
|
|
|
|||
293
components/tcp_transport/transport_ws.c
Normal file
293
components/tcp_transport/transport_ws.c
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <sys/random.h>
|
||||
|
||||
#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;
|
||||
}
|
||||
|
||||
Loading…
Reference in a new issue