fix(websocket): Fix reconnection data loss and memory leaks

1. Reset frame parsing state (payload_len, payload_offset, last_opcode) on new connection
2. Free errormsg_buffer in esp_websocket_client_disconnect()
3. Added sdkconfig.ci.tx_lock config

Author: surengab

components/esp_websocket_client/esp_websocket_client.c

@@ -245,16 +245,16 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
 {
     ESP_WS_CLIENT_STATE_CHECK(TAG, client, return ESP_FAIL);
 
+    // Note: This function must be called with client->lock already held
+    // The caller is responsible for acquiring the lock before calling
+
     // CRITICAL: Check if already closing/closed to prevent double-close
     if (client->state == WEBSOCKET_STATE_CLOSING || client->state == WEBSOCKET_STATE_UNKNOW) {
         ESP_LOGW(TAG, "Connection already closing/closed, skipping abort");
         return ESP_OK;
     }
 
     esp_transport_close(client->transport);
-    // Note: We do NOT set client->transport = NULL here because:
-    // 1. Transport is reused on reconnect
-    // 2. We use state instead to track if transport is valid
 
     if (!client->config->auto_reconnect) {
         client->run = false;
@@ -267,6 +267,16 @@ static esp_err_t esp_websocket_client_abort_connection(esp_websocket_client_hand
     client->error_handle.error_type = error_type;
     esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_DISCONNECTED, NULL, 0);
 
+    if (client->errormsg_buffer) {
+        ESP_LOGI(TAG, "Freeing error buffer (%d bytes) - Free heap: %" PRIu32 " bytes",
+                 client->errormsg_size, esp_get_free_heap_size());
+        free(client->errormsg_buffer);
+        client->errormsg_buffer = NULL;
+        client->errormsg_size = 0;
+    } else {
+        ESP_LOGI(TAG, "Disconnect - Free heap: %" PRIu32 " bytes", esp_get_free_heap_size());
+    }
+
     return ESP_OK;
 }
 
@@ -464,6 +474,8 @@ static void destroy_and_free_resources(esp_websocket_client_handle_t client)
     esp_websocket_client_destroy_config(client);
     if (client->transport_list) {
         esp_transport_list_destroy(client->transport_list);
+        client->transport_list = NULL;
+        client->transport = NULL;
     }
     vSemaphoreDelete(client->lock);
 #ifdef CONFIG_ESP_WS_CLIENT_SEPARATE_TX_LOCK
@@ -1076,16 +1088,21 @@ static esp_err_t esp_websocket_client_recv(esp_websocket_client_handle_t client)
 
         // CRITICAL: Check if transport is still valid after re-acquiring lock
         // Another thread may have closed it while we didn't hold client->lock
-        if (client->state == WEBSOCKET_STATE_CLOSING || client->state == WEBSOCKET_STATE_UNKNOW || client->transport == NULL) {
+        if (client->state == WEBSOCKET_STATE_CLOSING || client->state == WEBSOCKET_STATE_UNKNOW ||
+                client->state == WEBSOCKET_STATE_WAIT_TIMEOUT || client->transport == NULL) {
             ESP_LOGW(TAG, "Transport closed while preparing PONG, skipping send");
             xSemaphoreGiveRecursive(client->tx_lock);
             return ESP_OK;  // Caller expects client->lock to be held, which it is
         }
-#endif
+
         esp_transport_ws_send_raw(client->transport, WS_TRANSPORT_OPCODES_PONG | WS_TRANSPORT_OPCODES_FIN, data, client->payload_len,
                                   client->config->network_timeout_ms);
-#ifdef CONFIG_ESP_WS_CLIENT_SEPARATE_TX_LOCK
         xSemaphoreGiveRecursive(client->tx_lock);
+#else
+        // When separate TX lock is not configured, we already hold client->lock
+        // which protects the transport, so we can send PONG directly
+        esp_transport_ws_send_raw(client->transport, WS_TRANSPORT_OPCODES_PONG | WS_TRANSPORT_OPCODES_FIN, data, client->payload_len,
+                                  client->config->network_timeout_ms);
 #endif
     } else if (client->last_opcode == WS_TRANSPORT_OPCODES_PONG) {
         client->wait_for_pong_resp = false;
@@ -1183,6 +1200,11 @@ static void esp_websocket_client_task(void *pv)
             client->state = WEBSOCKET_STATE_CONNECTED;
             client->wait_for_pong_resp = false;
             client->error_handle.error_type = WEBSOCKET_ERROR_TYPE_NONE;
+            client->payload_len = 0;
+            client->payload_offset = 0;
+            client->last_fin = false;
+            client->last_opcode = WS_TRANSPORT_OPCODES_NONE;
+
             esp_websocket_client_dispatch_event(client, WEBSOCKET_EVENT_CONNECTED, NULL, 0);
             break;
         case WEBSOCKET_STATE_CONNECTED:
@@ -1273,6 +1295,7 @@ static void esp_websocket_client_task(void *pv)
                 xSemaphoreTakeRecursive(client->lock, lock_timeout);
                 if (esp_websocket_client_recv(client) == ESP_FAIL) {
                     ESP_LOGE(TAG, "Error receive data");
+                    // Note: Already holding client->lock from line above
                     esp_websocket_client_abort_connection(client, WEBSOCKET_ERROR_TYPE_TCP_TRANSPORT);
                 }
                 xSemaphoreGiveRecursive(client->lock);

components/esp_websocket_client/examples/target/main/idf_component.yml

@@ -4,5 +4,7 @@ dependencies:
   espressif/esp_websocket_client:
     version: "^1.0.0"
     override_path: "../../../"
+  espressif/cjson:
+    version: "^1.7.15"
   protocol_examples_common:
     path: ${IDF_PATH}/examples/common_components/protocol_examples_common

components/esp_websocket_client/examples/target/sdkconfig.ci.tx_lock

@@ -0,0 +1,15 @@
+CONFIG_IDF_TARGET="esp32"
+CONFIG_IDF_TARGET_LINUX=n
+CONFIG_WEBSOCKET_URI_FROM_STDIN=n
+CONFIG_WEBSOCKET_URI_FROM_STRING=y
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_ESP_WS_CLIENT_SEPARATE_TX_LOCK=y
+CONFIG_ESP_WS_CLIENT_TX_LOCK_TIMEOUT_MS=2000