espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-16 03:52:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

esp_websocket_client:

Browse Source 
* Error handling improved to show status code from server
* Added new API `esp_websocket_client_set_headers`
* Dispatches 'WEBSOCKET_EVENT_BEFORE_CONNECT' event before tcp connection
This commit is contained in:
Steinbart Andreas (HAU-EDS)
2022-10-04 11:01:08 +02:00
committed by Suren Gabrielyan
parent 02be2b76f8
commit d047ff569c
3 changed files with 101 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
components/esp_websocket_client/esp_websocket_client.c
View File

@ -107,6 +107,7 @@ typedef enum {
struct esp_websocket_client { struct esp_websocket_client {
esp_event_loop_handle_t event_handle; esp_event_loop_handle_t event_handle;
TaskHandle_t task_handle; TaskHandle_t task_handle;
esp_websocket_error_codes_t error_handle;
esp_transport_list_handle_t transport_list; esp_transport_list_handle_t transport_list;
esp_transport_handle_t transport; esp_transport_handle_t transport;
websocket_config_storage_t *config; websocket_config_storage_t *config;
@ -196,6 +197,16 @@ static esp_err_t esp_websocket_client_dispatch_event(esp_websocket_client_handle
event_data.payload_len = client->payload_len; event_data.payload_len = client->payload_len;
event_data.payload_offset = client->payload_offset; event_data.payload_offset = client->payload_offset;
if (client->error_handle.error_type == WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT) {
event_data.error_handle.esp_tls_last_esp_err = esp_tls_get_and_clear_last_error(esp_transport_get_error_handle(client->transport),
&client->error_handle.esp_tls_stack_err,
&client->error_handle.esp_tls_cert_verify_flags);
event_data.error_handle.esp_transport_sock_errno = esp_transport_get_errno(client->transport);
}
event_data.error_handle.error_type = client->error_handle.error_type;
event_data.error_handle.esp_ws_handshake_status_code = client->error_handle.esp_ws_handshake_status_code;
if ((err = esp_event_post_to(client->event_handle, if ((err = esp_event_post_to(client->event_handle,
WEBSOCKET_EVENTS, event, WEBSOCKET_EVENTS, event,
&event_data, &event_data,
@ -206,7 +217,7 @@ static esp_err_t esp_websocket_client_dispatch_event(esp_websocket_client_handle
return esp_event_loop_run(client->event_handle, 0); return esp_event_loop_run(client->event_handle, 0);
} }
static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_handle_t client) static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_handle_t client, esp_websocket_error_type_t error_type)
{ {
ESP_WS_CLIENT_STATE_CHECK(TAG, client, return ESP_FAIL); ESP_WS_CLIENT_STATE_CHECK(TAG, client, return ESP_FAIL);
esp_transport_close(client->transport); esp_transport_close(client->transport);
@ -215,6 +226,8 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
client->reconnect_tick_ms = _tick_get_ms(); client->reconnect_tick_ms = _tick_get_ms();
ESP_LOGI(TAG, "Reconnect after %d ms", client->wait_timeout_ms); ESP_LOGI(TAG, "Reconnect after %d ms", client->wait_timeout_ms);
} }
client->error_handle.error_type = error_type;
client->state = WEBSOCKET_STATE_WAIT_TIMEOUT; client->state = WEBSOCKET_STATE_WAIT_TIMEOUT;
esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_DISCONNECTED, NULL, 0); esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_DISCONNECTED, NULL, 0);
return ESP_OK; return ESP_OK;
@ -725,6 +738,19 @@ esp_err_t esp_websocket_client_set_uri(esp_websocket_client_handle_t client, con
return ESP_OK; return ESP_OK;
} }
esp_err_t esp_websocket_client_set_headers(esp_websocket_client_handle_t client, const char *headers)
{
if (client == NULL || client->state != WEBSOCKET_STATE_CONNECTED || headers == NULL) {
return ESP_ERR_INVALID_ARG;
}
xSemaphoreTakeRecursive(client->lock, portMAX_DELAY);
esp_err_t ret = esp_transport_ws_set_headers(client->transport, headers);
xSemaphoreGiveRecursive(client->lock);
return ret;
}
static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client) static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client)
{ {
int rlen; int rlen;
@ -739,14 +765,10 @@ static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client)
esp_websocket_free_buf(client, false); esp_websocket_free_buf(client, false);
esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport); esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
if (error_handle) { if (error_handle) {
ESP_LOGE(TAG, "esp_transport_read() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d", esp_websocket_client_error(client, "esp_transport_read() failed with %d, transport_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
rlen, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno);
esp_websocket_client_error(client, "esp_transport_read() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
rlen, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code, rlen, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno); error_handle->esp_tls_flags, errno);
} else { } else {
ESP_LOGE(TAG, "esp_transport_read() failed with %d, errno=%d", rlen, errno);
esp_websocket_client_error(client, "esp_transport_read() failed with %d, errno=%d", rlen, errno); esp_websocket_client_error(client, "esp_transport_read() failed with %d, errno=%d", rlen, errno);
} }
return ESP_FAIL; return ESP_FAIL;
@ -817,32 +839,32 @@ static void esp_websocket_client_task(void *pv)
client->run = false; client->run = false;
break; break;
} }
esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_BEFORE_CONNECT, NULL, 0);
int result = esp_transport_connect(client->transport, int result = esp_transport_connect(client->transport,
client->config->host, client->config->host,
client->config->port, client->config->port,
client->config->network_timeout_ms); client->config->network_timeout_ms);
if (result < 0) { if (result < 0) {
esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport); esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
client->error_handle.esp_ws_handshake_status_code = esp_transport_ws_get_upgrade_request_status(client->transport);
if (error_handle) { if (error_handle) {
ESP_LOGE(TAG, "esp_transport_connect() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d", esp_websocket_client_error(client, "esp_transport_connect() failed with %d,\
result, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code, transport_error=%s, tls_error_code=%i, tls_flags=%i, esp_ws_handshake_status_code=%d, errno=%d",
error_handle->esp_tls_flags, errno);
esp_websocket_client_error(client, "esp_transport_connect() failed with %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
result, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code, result, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno); error_handle->esp_tls_flags, client->error_handle.esp_ws_handshake_status_code, errno);
} else { } else {
ESP_LOGE(TAG, "esp_transport_connect() failed with %d, errno=%d", result, errno); esp_websocket_client_error(client, "esp_transport_connect() failed with %d, esp_ws_handshake_status_code=%d, errno=%d",
esp_websocket_client_error(client, "esp_transport_connect() failed with %d, errno=%d", result, errno); result, client->error_handle.esp_ws_handshake_status_code, errno);
} }
esp_websocket_client_abort_connection(client); esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
break; break;
} }
ESP_LOGD(TAG, "Transport connected to %s://%s:%d", client->config->scheme, client->config->host, client->config->port); ESP_LOGD(TAG, "Transport connected to %s://%s:%d", client->config->scheme, client->config->host, client->config->port);
client->state = WEBSOCKET_STATE_CONNECTED; client->state = WEBSOCKET_STATE_CONNECTED;
client->wait_for_pong_resp = false; client->wait_for_pong_resp = false;
client->error_handle.error_type = WEBSOCKET_ERROR_TYPE_NONE;
esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_CONNECTED, NULL, 0); esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_CONNECTED, NULL, 0);
break; break;
case WEBSOCKET_STATE_CONNECTED: case WEBSOCKET_STATE_CONNECTED:
if ((CLOSE_FRAME_SENT_BIT & xEventGroupGetBits(client->status_bits)) == 0) { // only send and check for PING if ((CLOSE_FRAME_SENT_BIT & xEventGroupGetBits(client->status_bits)) == 0) { // only send and check for PING
@ -860,14 +882,14 @@ static void esp_websocket_client_task(void *pv)
if ( _tick_get_ms() - client->pingpong_tick_ms > client->config->pingpong_timeout_sec * 1000 ) { if ( _tick_get_ms() - client->pingpong_tick_ms > client->config->pingpong_timeout_sec * 1000 ) {
if (client->wait_for_pong_resp) { if (client->wait_for_pong_resp) {
ESP_LOGE(TAG, "Error, no PONG received for more than %d seconds after PING", client->config->pingpong_timeout_sec);
esp_websocket_client_error(client, "Error, no PONG received for more than %d seconds after PING", client->config->pingpong_timeout_sec); esp_websocket_client_error(client, "Error, no PONG received for more than %d seconds after PING", client->config->pingpong_timeout_sec);
esp_websocket_client_abort_connection(client); esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_PONG_TIMEOUT);
break; break;
} }
} }
} }
if (read_select == 0) { if (read_select == 0) {
ESP_LOGV(TAG, "Read poll timeout: skipping esp_transport_read()..."); ESP_LOGV(TAG, "Read poll timeout: skipping esp_transport_read()...");
break; break;
@ -876,7 +898,7 @@ static void esp_websocket_client_task(void *pv)
if (esp_websocket_client_recv(client) == ESP_FAIL) { if (esp_websocket_client_recv(client) == ESP_FAIL) {
ESP_LOGE(TAG, "Error receive data"); ESP_LOGE(TAG, "Error receive data");
esp_websocket_client_abort_connection(client); esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
break; break;
} }
break; break;
@ -910,17 +932,13 @@ static void esp_websocket_client_task(void *pv)
if (read_select < 0) { if (read_select < 0) {
esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport); esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
if (error_handle) { if (error_handle) {
ESP_LOGE(TAG, "esp_transport_poll_read() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d", esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, transport_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
read_select, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno);
esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
read_select, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code, read_select, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno); error_handle->esp_tls_flags, errno);
} else { } else {
ESP_LOGE(TAG, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno); esp_websocket_client_error(client, "esp_transport_poll_read() returned %d, errno=%d", read_select, errno);
} }
esp_websocket_client_abort_connection(client); esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
} }
} else if (WEBSOCKET_STATE_WAIT_TIMEOUT == client->state) { } else if (WEBSOCKET_STATE_WAIT_TIMEOUT == client->state) {
// waiting for reconnecting... // waiting for reconnecting...
@ -1120,17 +1138,13 @@ int esp_websocket_client_send_with_opcode(esp_websocket_client_handle_t client,
esp_websocket_free_buf(client, true); esp_websocket_free_buf(client, true);
esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport); esp_tls_error_handle_t error_handle = esp_transport_get_error_handle(client->transport);
if (error_handle) { if (error_handle) {
ESP_LOGE(TAG, "esp_transport_write() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d", esp_websocket_client_error(client, "esp_transport_write() returned %d, transport_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
ret, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno);
esp_websocket_client_error(client, "esp_transport_write() returned %d, last_error=%s, tls_error_code=%i, tls_flags=%i, errno=%d",
ret, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code, ret, esp_err_to_name(error_handle->last_error), error_handle->esp_tls_error_code,
error_handle->esp_tls_flags, errno); error_handle->esp_tls_flags, errno);
} else { } else {
ESP_LOGE(TAG, "esp_transport_write() returned %d, errno=%d", ret, errno);
esp_websocket_client_error(client, "esp_transport_write() returned %d, errno=%d", ret, errno); esp_websocket_client_error(client, "esp_transport_write() returned %d, errno=%d", ret, errno);
} }
esp_websocket_client_abort_connection(client); esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
goto unlock_and_return; goto unlock_and_return;
} }
current_opcode = 0; current_opcode = 0;

19
components/esp_websocket_client/examples/main/websocket_example.c
View File

@ -37,6 +37,13 @@ static const char *TAG = "websocket";
static TimerHandle_t shutdown_signal_timer; static TimerHandle_t shutdown_signal_timer;
static SemaphoreHandle_t shutdown_sema; static SemaphoreHandle_t shutdown_sema;
static void log_error_if_nonzero(const char *message, int error_code)
{
if (error_code != 0) {
ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
}
}
static void shutdown_signaler(TimerHandle_t xTimer) static void shutdown_signaler(TimerHandle_t xTimer)
{ {
ESP_LOGI(TAG, "No data received for %d seconds, signaling shutdown", NO_DATA_TIMEOUT_SEC); ESP_LOGI(TAG, "No data received for %d seconds, signaling shutdown", NO_DATA_TIMEOUT_SEC);
@ -71,6 +78,12 @@ static void websocket_event_handler(void *handler_args, esp_event_base_t base, i
break; break;
case WEBSOCKET_EVENT_DISCONNECTED: case WEBSOCKET_EVENT_DISCONNECTED:
ESP_LOGI(TAG, "WEBSOCKET_EVENT_DISCONNECTED"); ESP_LOGI(TAG, "WEBSOCKET_EVENT_DISCONNECTED");
log_error_if_nonzero("HTTP status code", data->error_handle.esp_ws_handshake_status_code);
if (data->error_handle.error_type == WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT) {
log_error_if_nonzero("reported from esp-tls", data->error_handle.esp_tls_last_esp_err);
log_error_if_nonzero("reported from tls stack", data->error_handle.esp_tls_stack_err);
log_error_if_nonzero("captured as transport's socket errno", data->error_handle.esp_transport_sock_errno);
}
break; break;
case WEBSOCKET_EVENT_DATA: case WEBSOCKET_EVENT_DATA:
ESP_LOGI(TAG, "WEBSOCKET_EVENT_DATA"); ESP_LOGI(TAG, "WEBSOCKET_EVENT_DATA");
@ -99,6 +112,12 @@ static void websocket_event_handler(void *handler_args, esp_event_base_t base, i
break; break;
case WEBSOCKET_EVENT_ERROR: case WEBSOCKET_EVENT_ERROR:
ESP_LOGI(TAG, "WEBSOCKET_EVENT_ERROR"); ESP_LOGI(TAG, "WEBSOCKET_EVENT_ERROR");
log_error_if_nonzero("HTTP status code", data->error_handle.esp_ws_handshake_status_code);
if (data->error_handle.error_type == WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT) {
log_error_if_nonzero("reported from esp-tls", data->error_handle.esp_tls_last_esp_err);
log_error_if_nonzero("reported from tls stack", data->error_handle.esp_tls_stack_err);
log_error_if_nonzero("captured as transport's socket errno", data->error_handle.esp_transport_sock_errno);
}
break; break;
} }
} }

38
components/esp_websocket_client/include/esp_websocket_client.h
View File

@ -35,9 +35,35 @@ typedef enum {
WEBSOCKET_EVENT_DISCONNECTED, /*!< The connection has been disconnected */ WEBSOCKET_EVENT_DISCONNECTED, /*!< The connection has been disconnected */
WEBSOCKET_EVENT_DATA, /*!< When receiving data from the server, possibly multiple portions of the packet */ WEBSOCKET_EVENT_DATA, /*!< When receiving data from the server, possibly multiple portions of the packet */
WEBSOCKET_EVENT_CLOSED, /*!< The connection has been closed cleanly */ WEBSOCKET_EVENT_CLOSED, /*!< The connection has been closed cleanly */
WEBSOCKET_EVENT_BEFORE_CONNECT, /*!< The event occurs before connecting */
WEBSOCKET_EVENT_MAX WEBSOCKET_EVENT_MAX
} esp_websocket_event_id_t; } esp_websocket_event_id_t;
/**
* @brief Websocket connection error codes propagated via ERROR event
*/
typedef enum {
WEBSOCKET_ERROR_TYPE_NONE = 0,
WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT,
WEBSOCKET_ERROR_TYPE_PONG_TIMEOUT,
WEBSOCKET_ERROR_TYPE_HANDSHAKE
} esp_websocket_error_type_t;
/**
* @brief Websocket error code structure to be passed as a contextual information into ERROR event
*/
typedef struct {
/* compatible portion of the struct corresponding to struct esp_tls_last_error */
esp_err_t esp_tls_last_esp_err; /*!< last esp_err code reported from esp-tls component */
int esp_tls_stack_err; /*!< tls specific error code reported from underlying tls stack */
int esp_tls_cert_verify_flags; /*!< tls flags reported from underlying tls stack during certificate verification */
/* esp-websocket specific structure extension */
esp_websocket_error_type_t error_type;
int esp_ws_handshake_status_code; /*!< http status code of the websocket upgrade handshake */
/* tcp_transport extension */
int esp_transport_sock_errno; /*!< errno from the underlying socket */
} esp_websocket_error_codes_t;
/** /**
* @brief Websocket event data * @brief Websocket event data
*/ */
@ -50,6 +76,7 @@ typedef struct {
void *user_context; /*!< user_data context, from esp_websocket_client_config_t user_data */ void *user_context; /*!< user_data context, from esp_websocket_client_config_t user_data */
int payload_len; /*!< Total payload length, payloads exceeding buffer will be posted through multiple events */ int payload_len; /*!< Total payload length, payloads exceeding buffer will be posted through multiple events */
int payload_offset; /*!< Actual offset for the data associated with this event */ int payload_offset; /*!< Actual offset for the data associated with this event */
esp_websocket_error_codes_t error_handle; /*!< esp-websocket error handle including esp-tls errors as well as internal websocket errors */
} esp_websocket_event_data_t; } esp_websocket_event_data_t;
/** /**
@ -127,6 +154,17 @@ esp_websocket_client_handle_t esp_websocket_client_init(const esp_websocket_clie
*/ */
esp_err_t esp_websocket_client_set_uri(esp_websocket_client_handle_t client, const char *uri); esp_err_t esp_websocket_client_set_uri(esp_websocket_client_handle_t client, const char *uri);
/**
* @brief Set additional websocket headers for the client, when performing this behavior, the headers will replace the old ones
* @pre Must stop the WebSocket client before set headers if the client has been connected
*
* @param[in] client The client
* @param headers additional header strings each terminated with \r\n
*
* @return esp_err_t
*/
esp_err_t esp_websocket_client_set_headers(esp_websocket_client_handle_t client, const char *headers);
/** /**
* @brief Open the WebSocket connection * @brief Open the WebSocket connection
* *