mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
tcp_transport: renamed possibly generic function names to be esp_ prefixed and not to colide with user namespace
This commit is contained in:
David Cermak
parent
2c5a25a42e
commit
e02225cc07
@ -93,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;
|
||||
@ -443,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 = (
|
||||
@ -466,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");
|
||||
@ -477,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) {
|
||||
@ -491,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
|
||||
|
||||
@ -545,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);
|
||||
@ -740,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);
|
||||
}
|
||||
@ -778,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) {
|
||||
@ -893,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;
|
||||
}
|
||||
@ -924,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
|
||||
@ -935,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;
|
||||
@ -1036,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);
|
||||
@ -1102,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;
|
||||
}
|
||||
@ -1119,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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -1 +1 @@
|
||||
Subproject commit ca893e2c23a104cead0bb756a11af7b80464c2d4
|
||||
Subproject commit fe3ac2af1b708f44e710f35c4731584a3f69acd5
|
||||
@ -9,11 +9,3 @@ set(COMPONENT_ADD_INCLUDEDIRS "include")
|
||||
set(COMPONENT_REQUIRES lwip esp-tls)
|
||||
|
||||
register_component()
|
||||
|
||||
if(GCC_NOT_5_2_0)
|
||||
# Temporary suppress "format-overflow" warning until it is fixed
|
||||
set_source_files_properties(
|
||||
transport_ws.c
|
||||
PROPERTIES COMPILE_FLAGS
|
||||
-Wno-format-overflow)
|
||||
endif()
|
||||
|
||||
@ -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
|
||||
@ -265,7 +265,7 @@ esp_err_t transport_set_context_data(transport_handle_t t, void *data);
|
||||
* @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,
|
||||
@ -286,9 +286,9 @@ 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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#endif /* _ESP_TRANSPORT_ */
|
||||
|
||||
@ -12,8 +12,8 @@
|
||||
// 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 "esp_transport.h"
|
||||
|
||||
@ -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,8 +12,8 @@
|
||||
// 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 "esp_transport.h"
|
||||
|
||||
@ -22,15 +22,15 @@ 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_ */
|
||||
@ -4,8 +4,8 @@
|
||||
* Tuan PM <tuanpm at live dot com>
|
||||
*/
|
||||
|
||||
#ifndef _TRANSPORT_WS_H_
|
||||
#define _TRANSPORT_WS_H_
|
||||
#ifndef _ESP_TRANSPORT_WS_H_
|
||||
#define _ESP_TRANSPORT_WS_H_
|
||||
|
||||
#include "esp_transport.h"
|
||||
|
||||
@ -13,29 +13,17 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#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
|
||||
|
||||
/**
|
||||
* @brief Create TCP transport
|
||||
* @brief Create web socket transport
|
||||
*
|
||||
* @return
|
||||
* - transport
|
||||
* - NULL
|
||||
*/
|
||||
transport_handle_t transport_ws_init(transport_handle_t parent_handle);
|
||||
esp_transport_handle_t esp_transport_ws_init(esp_transport_handle_t parent_handle);
|
||||
|
||||
void transport_ws_set_path(transport_handle_t t, const char *path);
|
||||
void esp_transport_ws_set_path(esp_transport_handle_t t, const char *path);
|
||||
|
||||
|
||||
|
||||
@ -43,4 +31,4 @@ void transport_ws_set_path(transport_handle_t t, const char *path);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* _ESP_TRANSPORT_WS_H_ */
|
||||
|
||||
@ -27,7 +27,7 @@ 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 */
|
||||
@ -43,37 +43,37 @@ struct transport_item_t {
|
||||
connect_async_func _connect_async; /*!< non-blocking connect function of this transport */
|
||||
payload_transfer_func _parrent_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()
|
||||
esp_transport_list_handle_t esp_transport_list_init()
|
||||
{
|
||||
transport_list_handle_t list = calloc(1, sizeof(struct transport_list_t));
|
||||
TRANSPORT_MEM_CHECK(TAG, list, return NULL);
|
||||
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 +81,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,37 +90,37 @@ 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);
|
||||
@ -128,7 +128,7 @@ transport_handle_t transport_get_payload_transport_handle(transport_handle_t 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 +137,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 +146,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 +155,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 +163,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 +171,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 +179,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 +187,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 +195,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 +203,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,7 +212,7 @@ 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,
|
||||
@ -237,7 +237,7 @@ esp_err_t transport_set_func(transport_handle_t t,
|
||||
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 +245,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 +254,12 @@ 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)
|
||||
esp_transport_handle_t transport_get_handle(esp_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;
|
||||
|
||||
@ -43,13 +43,13 @@ typedef struct {
|
||||
transport_ssl_conn_state_t conn_state;
|
||||
} transport_ssl_t;
|
||||
|
||||
transport_handle_t transport_get_handle(transport_handle_t t);
|
||||
esp_transport_handle_t transport_get_handle(esp_transport_handle_t t);
|
||||
|
||||
static int ssl_close(transport_handle_t t);
|
||||
static int ssl_close(esp_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 +69,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 +85,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 +124,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 +141,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 +153,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, transport_get_handle);
|
||||
esp_transport_set_async_connect_func(t, ssl_connect_async);
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
@ -32,7 +32,7 @@ typedef struct {
|
||||
int sock;
|
||||
} transport_tcp_t;
|
||||
|
||||
transport_handle_t transport_get_handle(transport_handle_t t);
|
||||
esp_transport_handle_t transport_get_handle(esp_transport_handle_t t);
|
||||
|
||||
static int resolve_dns(const char *host, struct sockaddr_in *ip) {
|
||||
|
||||
@ -51,11 +51,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 +76,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 +90,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 +114,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 +147,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, transport_get_handle);
|
||||
esp_transport_set_context_data(t, tcp);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
#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;
|
||||
|
||||
@ -14,16 +14,28 @@
|
||||
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;
|
||||
transport_handle_t parent;
|
||||
esp_transport_handle_t parent;
|
||||
} transport_ws_t;
|
||||
|
||||
transport_handle_t ws_transport_get_payload_transport_handle(transport_handle_t t)
|
||||
static esp_transport_handle_t ws_get_payload_transport_handle(esp_transport_handle_t t)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
transport_ws_t *ws = esp_transport_get_context_data(t);
|
||||
return ws->parent;
|
||||
}
|
||||
|
||||
@ -64,10 +76,10 @@ static char *get_http_header(const char *buffer, const char *key)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int ws_connect(transport_handle_t t, const char *host, int port, int timeout_ms)
|
||||
static int ws_connect(esp_transport_handle_t t, const char *host, int port, int timeout_ms)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
if (transport_connect(ws->parent, host, port, timeout_ms) < 0) {
|
||||
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");
|
||||
}
|
||||
|
||||
@ -96,11 +108,11 @@ static int ws_connect(transport_handle_t t, const char *host, int port, int time
|
||||
return -1;
|
||||
}
|
||||
ESP_LOGD(TAG, "Write upgrate request\r\n%s", ws->buffer);
|
||||
if (transport_write(ws->parent, ws->buffer, len, timeout_ms) <= 0) {
|
||||
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 = transport_read(ws->parent, ws->buffer, DEFAULT_WS_BUFFER, timeout_ms)) <= 0) {
|
||||
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;
|
||||
}
|
||||
@ -132,15 +144,15 @@ static int ws_connect(transport_handle_t t, const char *host, int port, int time
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ws_write(transport_handle_t t, const char *buff, int len, int timeout_ms)
|
||||
static int ws_write(esp_transport_handle_t t, const char *buff, int len, int timeout_ms)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
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 = transport_poll_write(ws->parent, timeout_ms)) <= 0) {
|
||||
if ((poll_write = esp_transport_poll_write(ws->parent, timeout_ms)) <= 0) {
|
||||
return poll_write;
|
||||
}
|
||||
|
||||
@ -161,25 +173,25 @@ static int ws_write(transport_handle_t t, const char *buff, int len, int timeout
|
||||
for (i = 0; i < len; ++i) {
|
||||
buffer[i] = (buffer[i] ^ mask[i % 4]);
|
||||
}
|
||||
if (transport_write(ws->parent, ws_header, header_len, timeout_ms) != header_len) {
|
||||
if (esp_transport_write(ws->parent, ws_header, header_len, timeout_ms) != header_len) {
|
||||
ESP_LOGE(TAG, "Error write header");
|
||||
return -1;
|
||||
}
|
||||
return transport_write(ws->parent, buffer, len, timeout_ms);
|
||||
return esp_transport_write(ws->parent, buffer, len, timeout_ms);
|
||||
}
|
||||
|
||||
static int ws_read(transport_handle_t t, char *buffer, int len, int timeout_ms)
|
||||
static int ws_read(esp_transport_handle_t t, char *buffer, int len, int timeout_ms)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
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 = transport_poll_read(ws->parent, timeout_ms)) <= 0) {
|
||||
if ((poll_read = esp_transport_poll_read(ws->parent, timeout_ms)) <= 0) {
|
||||
return poll_read;
|
||||
}
|
||||
if ((rlen = transport_read(ws->parent, buffer, len, timeout_ms)) <= 0) {
|
||||
if ((rlen = esp_transport_read(ws->parent, buffer, len, timeout_ms)) <= 0) {
|
||||
ESP_LOGE(TAG, "Error read data");
|
||||
return rlen;
|
||||
}
|
||||
@ -223,56 +235,56 @@ static int ws_read(transport_handle_t t, char *buffer, int len, int timeout_ms)
|
||||
return payload_len;
|
||||
}
|
||||
|
||||
static int ws_poll_read(transport_handle_t t, int timeout_ms)
|
||||
static int ws_poll_read(esp_transport_handle_t t, int timeout_ms)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
return transport_poll_read(ws->parent, 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(transport_handle_t t, int timeout_ms)
|
||||
static int ws_poll_write(esp_transport_handle_t t, int timeout_ms)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
return transport_poll_write(ws->parent, 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(transport_handle_t t)
|
||||
static int ws_close(esp_transport_handle_t t)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
return transport_close(ws->parent);
|
||||
transport_ws_t *ws = esp_transport_get_context_data(t);
|
||||
return esp_transport_close(ws->parent);
|
||||
}
|
||||
|
||||
static esp_err_t ws_destroy(transport_handle_t t)
|
||||
static esp_err_t ws_destroy(esp_transport_handle_t t)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
transport_ws_t *ws = esp_transport_get_context_data(t);
|
||||
free(ws->buffer);
|
||||
free(ws->path);
|
||||
free(ws);
|
||||
return 0;
|
||||
}
|
||||
void transport_ws_set_path(transport_handle_t t, const char *path)
|
||||
void esp_transport_ws_set_path(esp_transport_handle_t t, const char *path)
|
||||
{
|
||||
transport_ws_t *ws = transport_get_context_data(t);
|
||||
transport_ws_t *ws = esp_transport_get_context_data(t);
|
||||
ws->path = realloc(ws->path, strlen(path) + 1);
|
||||
strcpy(ws->path, path);
|
||||
}
|
||||
transport_handle_t transport_ws_init(transport_handle_t parent_handle)
|
||||
esp_transport_handle_t esp_transport_ws_init(esp_transport_handle_t parent_handle)
|
||||
{
|
||||
transport_handle_t t = transport_init();
|
||||
esp_transport_handle_t t = esp_transport_init();
|
||||
transport_ws_t *ws = calloc(1, sizeof(transport_ws_t));
|
||||
TRANSPORT_MEM_CHECK(TAG, ws, return NULL);
|
||||
ESP_TRANSPORT_MEM_CHECK(TAG, ws, return NULL);
|
||||
ws->parent = parent_handle;
|
||||
|
||||
ws->path = strdup("/");
|
||||
TRANSPORT_MEM_CHECK(TAG, ws->path, return NULL);
|
||||
ESP_TRANSPORT_MEM_CHECK(TAG, ws->path, return NULL);
|
||||
ws->buffer = malloc(DEFAULT_WS_BUFFER);
|
||||
TRANSPORT_MEM_CHECK(TAG, ws->buffer, {
|
||||
ESP_TRANSPORT_MEM_CHECK(TAG, ws->buffer, {
|
||||
free(ws->path);
|
||||
free(ws);
|
||||
return NULL;
|
||||
});
|
||||
|
||||
transport_set_func(t, ws_connect, ws_read, ws_write, ws_close, ws_poll_read, ws_poll_write, ws_destroy, ws_transport_get_payload_transport_handle);
|
||||
transport_set_context_data(t, ws);
|
||||
esp_transport_set_func(t, ws_connect, ws_read, ws_write, ws_close, ws_poll_read, ws_poll_write, ws_destroy, ws_get_payload_transport_handle);
|
||||
esp_transport_set_context_data(t, ws);
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user