From 0cdc355a8847a899d2f09e50f17a35625f1a805d Mon Sep 17 00:00:00 2001
From: =?utf8?q?=E5=AD=99=E6=98=A5=E9=98=B3?= <snickersun@163.com>
Date: Thu, 14 Aug 2025 07:47:38 +0800
Subject: [PATCH] =?utf8?q?=E5=8E=BB=E6=8E=89=E4=B8=80=E4=BA=9Bwebsocket?=
 =?utf8?q?=E8=B0=83=E8=AF=95=E6=97=A5=E5=BF=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

---
 .../peripheral/slip/cat1Service/cat1_ws.cpp   | 152 ++++++++++--------
 1 file changed, 82 insertions(+), 70 deletions(-)

diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp
index 999cd6d3b..d02329c5a 100644
--- a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp
+++ b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp
@@ -95,7 +95,19 @@ extern "C" {
 #include <stdint.h>
 #include <asm/delay.h>
 
-
+#if 0
+// WebSocket日志控制宏
+#define WS_LOG_ERROR(fmt, ...)   printf("[WS_ERROR] " fmt "\n", ##__VA_ARGS__)
+#define WS_LOG_WARNING(fmt, ...) printf("[WS_WARN] " fmt "\n", ##__VA_ARGS__)
+#define WS_LOG_INFO(fmt, ...)    printf("[WS_INFO] " fmt "\n", ##__VA_ARGS__)
+#define WS_LOG_DEBUG(fmt, ...)   printf("[WS_DEBUG] " fmt "\n", ##__VA_ARGS__)
+#else
+// 可以通过注释/取消注释来控制日志级别
+#define WS_LOG_ERROR(fmt, ...)   printf("[WS_ERROR] " fmt "\n", ##__VA_ARGS__)
+#define WS_LOG_WARNING(fmt, ...) printf("[WS_WARN] " fmt "\n", ##__VA_ARGS__)
+#define WS_LOG_INFO(fmt, ...)    printf("[WS_INFO] " fmt "\n", ##__VA_ARGS__)
+#define WS_LOG_DEBUG(fmt, ...)   
+#endif
 extern osStatus_t osDelay(uint32_t ticks);
 #define cat1_msleep(ms) LOS_Msleep(ms) /* osDelay(1) : 1ms */
 
@@ -149,14 +161,14 @@ void set_url_error(BK_URL *url, const char *error_msg) {
     url->error_message = bk_strdup(error_msg);
     if (!url->error_message) {
         // 若分配失败，输出提示信息
-        printf("Memory allocation failed for error message.\n");
+        WS_LOG_ERROR("Memory allocation failed for error message.");
     }
 
 }
 
 // 解析URL的函数
 BK_URL parse_url(const char *url) {
-    printf("parse_url url=%s.\n",url);
+    WS_LOG_WARNING("parse_url url=%s", url);
     BK_URL result = {NULL, NULL, 0, NULL, NULL, 0, NULL};
     char *temp_url_t = bk_strdup(url);
     char *temp_url = temp_url_t;
@@ -330,7 +342,7 @@ void generate_websocket_key(char *key) {
     unsigned char encoded[WEBSOCKET_KEY_LEN * 2];
     size_t olen;
     mbedtls_base64_encode(encoded, sizeof(encoded), &olen, (const unsigned char *)key, strlen(key));
-    printf("generate_websocket_key %s %d\r\n",encoded ,olen);
+    WS_LOG_WARNING("generate_websocket_key %s %d", encoded, olen);
 
     if(olen>=(WEBSOCKET_KEY_LEN))
     olen=WEBSOCKET_KEY_LEN;
@@ -365,11 +377,11 @@ void generate_accept_key(const char *key, char *accept_key) {
  */
 int send_handshake(WebSocketClient *client,const char *headers,char *response,int response_len) {
     char key[WEBSOCKET_KEY_LEN+1];
-    printf("send_handshake1");
+    WS_LOG_INFO("send_handshake1");
 
     if(client==NULL|| response==NULL || response_len<=0)
     {
-        printf("send_handshake client or response is NULL , or response_len <= 0\r\n");
+        WS_LOG_ERROR("send_handshake client or response is NULL , or response_len <= 0");
         return -1;
     }
 
@@ -377,11 +389,11 @@ int send_handshake(WebSocketClient *client,const char *headers,char *response,in
     char accept_key[64];
     int ret = 0;
     generate_accept_key(key, accept_key);
-    printf("send_handshake2");
+    WS_LOG_INFO("send_handshake2");
     char *request =( char *)aic_zalloc(BUFFER_SIZE);
     if(request==NULL)
     {
-        printf("request aic_zalloc erro");
+        WS_LOG_ERROR("request aic_zalloc error");
         return -1;
     }
     
@@ -412,38 +424,38 @@ int send_handshake(WebSocketClient *client,const char *headers,char *response,in
             client->path,client->query , client->host,client->port, accept_key,client->host,client->port);
     }
     
-    printf("send_handshake request:\r\n%s",request);
+    WS_LOG_WARNING("send_handshake request:\r\n%s", request);
     
     // 发送WebSocket握手请求并等待响应
-    printf("发送WebSocket握手请求...\r\n");
+    WS_LOG_INFO("发送WebSocket握手请求...");
     ret = tcp_send_and_wait_response(client->tcp_handle, (uint8_t *)request, strlen(request), (uint8_t *)response, response_len, 1000);
     
     if (ret < 0) {
-        printf("WebSocket握手发送失败: %d\r\n", ret);
+        WS_LOG_ERROR("WebSocket握手发送失败: %d", ret);
         ret = -1;
     } else {
-        printf("WebSocket握手发送成功，接收到 %d 字节响应\r\n", ret);
+        WS_LOG_INFO("WebSocket握手发送成功，接收到 %d 字节响应", ret);
         
         // 检查响应内容
         if (ret > 0 && response[0] != '\0') {
-            printf("WebSocket握手响应:\r\n%s\r\n", response);
+            WS_LOG_WARNING("WebSocket握手响应:\r\n%s", response);
             
             // 检查是否包含"HTTP/1.1 101"
             if (strstr(response, "HTTP/1.1 101") != NULL) {
-                printf("WebSocket握手成功！\r\n");
+                WS_LOG_INFO("WebSocket握手成功！");
                 client->handshake = 1;
             } else {
-                printf("WebSocket握手失败：响应不是101状态码\r\n");
+                WS_LOG_ERROR("WebSocket握手失败：响应不是101状态码");
                 ret = -1;
             }
         } else {
-            printf("WebSocket握手失败：无响应数据\r\n");
+            WS_LOG_ERROR("WebSocket握手失败：无响应数据");
             ret = -1;
         }
     }
     
     free(request);
-    printf("send_handshake3 返回: %d\r\n", ret);
+    WS_LOG_INFO("send_handshake3 返回: %d", ret);
     return ret;
 }
 
@@ -453,7 +465,7 @@ int send_websocket_message(WebSocketClient *client, uint8_t *message, size_t mes
 
     if(client==NULL||message==NULL )
     {
-         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"send_websocket_message client or message is NULL %s %s\r\n",client,message);
+         WS_LOG_ERROR("send_websocket_message client or message is NULL %s %s", client, message);
         return -1;
     }
     uint8_t* frame=( uint8_t *)aic_zalloc(message_len + 50);
@@ -461,7 +473,7 @@ int send_websocket_message(WebSocketClient *client, uint8_t *message, size_t mes
     int ret = -1;
     if(!frame)
     {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"send_websocket_message zalloc error\r\n");
+        WS_LOG_ERROR("send_websocket_message zalloc error");
         return -1;
     }
     // 第一个字节：FIN = 1, 设置 opcode
@@ -501,10 +513,10 @@ int send_websocket_message(WebSocketClient *client, uint8_t *message, size_t mes
     offset += message_len;
 
     // 发送帧
-    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"offset %d\r\n",offset);
+    WS_LOG_DEBUG("offset %d", offset);
     int ret_tcp_send_data=tcp_send_data(client->tcp_handle, frame, offset);
     if (ret_tcp_send_data < 0) {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"lwip_send message failed %d\r\n",ret_tcp_send_data);
+        WS_LOG_ERROR("lwip_send message failed %d", ret_tcp_send_data);
         ret =  -1;
         goto send_websocket_message_ERROR;
     }
@@ -518,17 +530,17 @@ int send_websocket_message(WebSocketClient *client, uint8_t *message, size_t mes
 
 void _tcp_on_connect_cb(tcp_handle_t handle, bool success)
 {
-    printf("tcp_on_connect_cb %p %d\r\n", handle, success);
+    WS_LOG_INFO("tcp_on_connect_cb %p %d", handle, success);
     
     if (success) {
         // 连接成功，查找对应的WebSocket客户端
         extern WebSocketClient * get_ws_client_by_handle(void* handle);
         WebSocketClient * client = get_ws_client_by_handle(handle);
         if (client != NULL) {
-            printf("连接成功，开始WebSocket握手\r\n");
+            WS_LOG_INFO("连接成功，开始WebSocket握手");
             
             // 等待连接稳定后再发送握手
-            printf("等待TCP连接稳定...\r\n");
+            WS_LOG_INFO("等待TCP连接稳定...");
             msleep(100);  // 等待100ms让连接稳定
             
             // 发送WebSocket握手请求
@@ -538,21 +550,21 @@ void _tcp_on_connect_cb(tcp_handle_t handle, bool success)
                 const int max_retries = 3;
                 
                 while (retry_count < max_retries) {
-                    printf("WebSocket握手尝试 #%d...\r\n", retry_count + 1);
+                    WS_LOG_INFO("WebSocket握手尝试 #%d...", retry_count + 1);
                     
                     int bytes_received = send_handshake(client, NULL, buffer, BUFFER_SIZE);
                     if (bytes_received < 0) {
                         retry_count++;
                         if (retry_count < max_retries) {
-                            printf("WebSocket握手失败，等待重试...\r\n");
+                            WS_LOG_INFO("WebSocket握手失败，等待重试...");
                             msleep(500);  // 等待500ms后重试
                             continue;
                         } else {
-                            printf("WebSocket握手失败，已达到最大重试次数\r\n");
+                            WS_LOG_INFO("WebSocket握手失败，已达到最大重试次数");
                             tcp_manager_close(client->tcp_handle);
                         }
                     } else {
-                        printf("WebSocket握手发送成功\r\n");
+                        WS_LOG_INFO("WebSocket握手发送成功");
                         break;
                     }
                 }
@@ -560,35 +572,35 @@ void _tcp_on_connect_cb(tcp_handle_t handle, bool success)
                 free(buffer);
             }
         } else {
-            printf("未找到对应的WebSocket客户端\r\n");
+            WS_LOG_INFO("未找到对应的WebSocket客户端");
         }
   
     } else {
-        printf("TCP连接失败\r\n");
+        WS_LOG_INFO("TCP连接失败");
     }
 }
 void _tcp_on_disconnect_cb(tcp_handle_t handle)
 {
-    printf("tcp_on_disconnect_cb %d\r\n",handle);
+    WS_LOG_INFO("tcp_on_disconnect_cb %d", handle);
 }
 void _tcp_on_data_received_cb(tcp_handle_t handle, uint8_t* data, uint16_t datalen)
 {
-    printf("tcp_on_data_received_cb 0x%0X %d\r\n",handle,datalen);
+    WS_LOG_INFO("tcp_on_data_received_cb 0x%0X %d", handle, datalen);
     extern WebSocketClient * get_ws_client_by_handle(void* handle);
     WebSocketClient * client = get_ws_client_by_handle(handle);
     if(client==NULL)
     {
-        printf("get_ws_client failed\r\n");
+        WS_LOG_ERROR("get_ws_client failed");
         return;
     }
        // 使用WebSocket解析器处理数据
     int processed = ws_process_received_data(client, data, datalen);
     if (processed < 0) {
-        printf("WebSocket packet processing failed\n");
+        WS_LOG_ERROR("WebSocket packet processing failed");
         return;
     }
    
-    printf("Processed %d bytes %s %s of WebSocket data\n", processed,client->host,client->path);
+    WS_LOG_WARNING("Processed %d bytes %s %s of WebSocket data", processed, client->host, client->path);
 }
 // 初始化 WebSocket 客户端
 WebSocketClient *init_websocket_client(const char *url, const char *headers,uint8_t use_dns) {
@@ -599,28 +611,28 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
     err_t ret = 0;
 
     if (!url) {
-        printf("init_websocket_client Error: URL is NULL\n");
+        WS_LOG_ERROR("init_websocket_client Error: URL is NULL");
         return NULL;
     }
 
     parsed_url = parse_url(url);//解析url
 
     if (parsed_url.error) {
-        printf("init_websocket_client Error: %s", parsed_url.error_message);
+        WS_LOG_ERROR("init_websocket_client Error: %s", parsed_url.error_message);
         goto client_ERROR;
     } else {
-        printf("Protocol: %s", parsed_url.protocol);
-        printf("Host: %s\n", parsed_url.host);
-        printf("Port: %d\n", parsed_url.port);
-        printf("Path: %s\n", parsed_url.path);
-        printf("Query: %s\n", parsed_url.query);
+        WS_LOG_INFO("Protocol: %s", parsed_url.protocol);
+        WS_LOG_INFO("Host: %s", parsed_url.host);
+        WS_LOG_INFO("Port: %d", parsed_url.port);
+        WS_LOG_INFO("Path: %s", parsed_url.path);
+        WS_LOG_INFO("Query: %s", parsed_url.query);
     }
     
     client = (WebSocketClient *)aic_zalloc(sizeof(WebSocketClient)) ;
     memset_s(client,sizeof(WebSocketClient),0,sizeof(WebSocketClient));
     if(!client)
     {
-        printf("init_websocket_client alloc error: Failed to allocate memory for WebSocketClient\n");
+        WS_LOG_ERROR("init_websocket_client alloc error: Failed to allocate memory for WebSocketClient");
         goto client_ERROR;
     }
     
@@ -629,10 +641,10 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
 
     if(client->tcp_handle == NULL)
     {
-        printf("init_websocket_client Error: TCP connection failed for %s:%d\n", parsed_url.host, parsed_url.port);
+        WS_LOG_ERROR("init_websocket_client Error: TCP connection failed for %s:%d", parsed_url.host, parsed_url.port);
         goto client_ERROR;
     }
-    printf("socket creation success\n");
+    WS_LOG_INFO("socket creation success");
     
     strcpy(client->host, parsed_url.host);
     strcpy(client->path, parsed_url.path);
@@ -642,12 +654,12 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
     /* 初始化WebSocket解析器 */
     client->parser = ws_parser_init();
     if (!client->parser) {
-        printf("init_websocket_client Error: Failed to initialize WebSocket parser\n");
+        WS_LOG_ERROR("init_websocket_client Error: Failed to initialize WebSocket parser");
         goto client_ERROR;
     }
     
     /* 握手将在连接成功回调中发送，这里不再立即发送 */
-    printf("WebSocket客户端初始化完成，等待TCP连接建立\r\n");
+    WS_LOG_INFO("WebSocket客户端初始化完成，等待TCP连接建立");
     
     // if(strstr(buffer,"HTTP/1.1 101") == NULL)
     // {
@@ -658,10 +670,10 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
     // free(buffer);
     free_url(parsed_url);
 
-     printf("init_websocket_client end 2");
+     WS_LOG_INFO("init_websocket_client end 2");
     return client;
 client_ERROR:
-    printf("init_websocket_client Error: Initialization failed, cleaning up...\n");
+    WS_LOG_ERROR("init_websocket_client Error: Initialization failed, cleaning up...");
     if(client){
         free(client);
         client = NULL;
@@ -677,7 +689,7 @@ void lwip_close_websocket_client(WebSocketClient *client) {
     {
         //移植建议： 此处调用 tcp_manager_close 进行关闭, 不必使用 lwip_close
 
-        printf("lwip_close_websocket_client %s %s",client->host,client->path);
+        WS_LOG_INFO("lwip_close_websocket_client %s %s", client->host, client->path);
         
         // 释放WebSocket解析器
         if (client->parser) {
@@ -709,7 +721,7 @@ void ws_set_packet_callback(WebSocketClient *client, on_ws_packet_callback callb
 int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_t len)
 {
     if (!client || !data || len == 0 || !client->parser) {
-        printf("ws_process_received_data: invalid parameters - client=%p, data=%p, len=%zu, parser=%p\n", 
+        WS_LOG_ERROR("ws_process_received_data: invalid parameters - client=%p, data=%p, len=%zu, parser=%p", 
                client, data, len, client->parser);
         return -1;
     }
@@ -717,7 +729,7 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
     // ========== 新增：打印收到的所有原始数据 ==========
     // printf("\n=== WebSocket Raw Data Received ===\n");
     // printf("Client: %s:%s\n", client->host, client->path);
-    printf("Total bytes: %zu\n", len);
+    WS_LOG_WARNING("Total bytes: %zu", len);
     // printf("Raw data (hex): ");
     // // 打印所有数据的十六进制表示
     // for (size_t i = 0; i < len; i++) {
@@ -777,23 +789,23 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
     //     bool valid_rsv = (rsv == 0);
     //     printf("    * Valid RSV: %s\n", valid_rsv ? "YES" : "NO");
     // }
-    printf("=====================================\n\n");
+    WS_LOG_WARNING("=====================================");
     
     ws_parser_t* parser = client->parser;
     int total_processed = 0;
     const uint8_t* current_data = data;
     size_t remaining_len = len;
     
-    printf("ws_process_received_data: processing %zu bytes for client %s:%s\n", 
+    WS_LOG_DEBUG("ws_process_received_data: processing %zu bytes for client %s:%s", 
            len, client->host, client->path);
     
     // 循环处理数据，支持连续帧
     while (remaining_len > 0) {
-        printf("ws_process_received_data: processing remaining %zu bytes, current offset: %zu\n", 
+        WS_LOG_DEBUG("ws_process_received_data: processing remaining %zu bytes, current offset: %zu", 
                remaining_len, current_data - data);
         
         // 在解析前打印当前解析器状态
-        printf("ws_process_received_data: parser state before parsing:\n");
+        WS_LOG_DEBUG("ws_process_received_data: parser state before parsing:");
         // ws_parser_debug_state(parser);
         
         // 使用新的解析器处理当前数据段
@@ -801,7 +813,7 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
 
         if(result <= 0)
         {
-            printf("ws_process_received_data: parsing error, reset parser,find next frame. Remaining: %zu bytes\n", remaining_len);
+            WS_LOG_ERROR("ws_process_received_data: parsing error, reset parser,find next frame. Remaining: %zu bytes", remaining_len);
             ws_parser_reset(parser);
             return -1;
         }
@@ -812,7 +824,7 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
         remaining_len -= result;
 
         // 在解析后打印解析器状态
-        printf("ws_process_received_data: parser state after parsing:\n");
+        WS_LOG_DEBUG("ws_process_received_data: parser state after parsing:");
         // ws_parser_debug_state(parser);
         ws_parse_state_t ws_stat =  ws_parser_get_state(parser);
         
@@ -822,11 +834,11 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
             const uint8_t* payload = ws_get_payload(parser);
             size_t payload_len = ws_get_payload_length(parser);
             
-            printf("ws_process_received_data: frame complete, total bytes: %d, payload bytes: %zu %s\n", 
+            WS_LOG_DEBUG("ws_process_received_data: frame complete, total bytes: %d, payload bytes: %zu %s", 
                    result, payload_len,client->path);
             
             if (header && payload) {
-                printf("WebSocket frame received: opcode=0x%02X, fin=%d, payload_len=%llu\n", 
+                WS_LOG_DEBUG("WebSocket frame received: opcode=0x%02X, fin=%d, payload_len=%llu", 
                        header->opcode, header->fin, header->payload_len);
                 // printf("payload = %s\n",payload);
                 
@@ -843,16 +855,16 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
                 // 根据操作码处理不同类型的消息
                 switch (header->opcode) {
                     case WS_PING:
-                        printf("Received WebSocket PING\n");
+                        WS_LOG_DEBUG("Received WebSocket PING");
                         // TODO: 自动回复PONG
                         break;
                         
                     case WS_PONG:
-                        printf("Received WebSocket PONG\n");
+                        WS_LOG_DEBUG("Received WebSocket PONG");
                         break;
                         
                     case WS_CLOSE:
-                        printf("Received WebSocket CLOSE\n");
+                        WS_LOG_DEBUG("Received WebSocket CLOSE");
                         // 调用回调函数处理关闭帧
                         if (client->packet_callback) {
                             client->packet_callback((uint8_t*)payload, payload_len, (WebSocketMessageType)WS_CLOSE);
@@ -872,21 +884,21 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
                         break;
                         
                     default:
-                        printf("Unknown WebSocket opcode: 0x%02X\n", header->opcode);
+                        WS_LOG_DEBUG("Unknown WebSocket opcode: 0x%02X", header->opcode);
                         break;
                 }
                 
                 // 重要：在数据处理完成后再重置解析器状态
                 // 这样可以确保数据被正确处理后再清理状态
-                printf("ws_process_received_data: data processing complete, resetting parser\n");
+                WS_LOG_DEBUG("ws_process_received_data: data processing complete, resetting parser");
                 ws_parser_reset(parser);
                 
                 
                 
-                printf("ws_process_received_data: frame processed, moving to next frame. Remaining: %zu bytes\n", remaining_len);
+                WS_LOG_DEBUG("ws_process_received_data: frame processed, moving to next frame. Remaining: %zu bytes", remaining_len);
                 
             } else {
-                printf("ws_process_received_data: invalid payload data - header=%p, payload=%p, payload_len=%zu\n", 
+                WS_LOG_DEBUG("ws_process_received_data: invalid payload data - header=%p, payload=%p, payload_len=%zu", 
                        header, payload, payload_len);
                 return -1;
             }
@@ -895,15 +907,15 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
             // 解析错误,重置parser
             ws_parser_reset(parser);
         
-            printf("ws_process_received_data: parsing error, find next frame. Remaining: %zu bytes\n", remaining_len);
+            WS_LOG_DEBUG("ws_process_received_data: parsing error, find next frame. Remaining: %zu bytes", remaining_len);
             
         } else {
              // 数据不完整，继续等待更多数据
-             printf("ws_process_received_data: frame incomplete, waiting for more data\n");
+             WS_LOG_DEBUG("ws_process_received_data: frame incomplete, waiting for more data");
         }
     }
     
-    printf("ws_process_received_data: total processed: %d bytes\n", total_processed);
+    WS_LOG_DEBUG("ws_process_received_data: total processed: %d bytes", total_processed);
     return total_processed;
 }
 
-- 
2.17.1