/** ****************************************************************************** * @file tcp_protocol.c * @brief TCP通信协议解析实现 ****************************************************************************** */ #include "tcp_protocol.h" #include "tcp_server.h" #include "cJSON.h" #include #include #include "publicdata/publicdata.h" #include "publicdata/type.h" #include "fault_cheak/fault_interface.h" #if BLE_DEBUG_EN #include "debug_link.h" #endif #if TCP_DEBUG_EN #include "system_data.h" #include "debug_files.h" #include "FreeRTOS.h" #include "task.h" /* 兼容历史代码中涉及的数据结构声明（当前实际读取逻辑已迁移到 system_data.c） */ #include "flash_file_mgr/fault_flash_impl.h" #include "flash_file_mgr/meter_calculate_flash_impl.h" #include "app_fatfs/fatfs_card.h" /* 内部函数声明 */ static void tcp_fill_default_timestamp(char *buffer, uint32_t size); int tcp_process_file_operation(const tcp_file_operation_data_t *fileOperation); /* GetCurrentTime函数声明（在项目中已定义） */ extern void GetCurrentTime(Comm_Time *time); /* v_rtc_set_time函数声明（在BSP/app_rtc/app_rtc.c中定义） */ extern void v_rtc_set_time(Comm_Time *time); /** * @brief 生成当前时间戳字符串 * @param buffer 缓冲区 * @param size 缓冲区大小 * @retval 0成功，-1失败 */ int tcp_generate_timestamp(char *buffer, uint32_t size) { Comm_Time curTime; if (buffer == NULL || size < 24) { return -1; } /* 获取当前系统时间 */ GetCurrentTime(&curTime); /* 格式化为字符串：YYYY-MM-DD HH:MM:SS.000 */ snprintf(buffer, size, "%04d-%02d-%02d %02d:%02d:%02d.000", curTime.iYear, curTime.ucMonth, curTime.ucDay, curTime.ucHour, curTime.ucMin, curTime.ucSec); return 0; } /** * @brief 填充默认时间戳（用于测试） */ static void tcp_fill_default_timestamp(char *buffer, uint32_t size) { /* 保留此函数作为备用，但主函数已使用真实时间 */ Comm_Time curTime; GetCurrentTime(&curTime); snprintf(buffer, size, "%04d-%02d-%02d %02d:%02d:%02d.000", curTime.iYear, curTime.ucMonth, curTime.ucDay, curTime.ucHour, curTime.ucMin, curTime.ucSec); } /** * @brief 生成心跳消息JSON * @param sequence 序列号 * @param source 来源字符串 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_heartbeat_json(uint32_t sequence, const char *source, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_HEARTBEAT); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddNumberToObject(data, "sequence", sequence); cJSON_AddStringToObject(data, "source", source); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** * @brief 生成系统信息消息JSON * @param systemInfo 系统信息结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_system_info_json(const tcp_system_info_data_t *systemInfo, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || systemInfo == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_SYSTEM_INFO); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "systemModel", systemInfo->systemModel); cJSON_AddNumberToObject(data, "gunCount", systemInfo->gunCount); cJSON_AddNumberToObject(data, "devicePower", systemInfo->devicePower); cJSON_AddNumberToObject(data, "networkStatus", systemInfo->networkStatus); cJSON_AddNumberToObject(data, "faultCount", systemInfo->faultCount); cJSON_AddStringToObject(data, "version", systemInfo->version); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** * @brief 生成充电枪数据消息JSON * @param gunData 充电枪数据结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_gun_data_json(const tcp_gun_data_t *gunData, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || gunData == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_GUN_INFO); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddNumberToObject(data, "gunNumber", gunData->gunNumber); cJSON_AddNumberToObject(data, "chargingStatus", gunData->chargingStatus); cJSON_AddNumberToObject(data, "gunConnectionStatus", gunData->gunConnectionStatus); cJSON_AddNumberToObject(data, "chargingTime", gunData->charge_time); cJSON_AddNumberToObject(data, "demandVoltage", gunData->demandVoltage); cJSON_AddNumberToObject(data, "demandCurrent", gunData->demandCurrent); cJSON_AddNumberToObject(data, "actualVoltage", gunData->actualVoltage); cJSON_AddNumberToObject(data, "actualCurrent", gunData->actualCurrent); cJSON_AddNumberToObject(data, "energy", gunData->energy); cJSON_AddNumberToObject(data, "cost", gunData->cost); cJSON_AddNumberToObject(data, "batterySOC", gunData->batterySOC); cJSON_AddStringToObject(data, "userId", gunData->userId); cJSON_AddStringToObject(data, "orderNumber", gunData->orderNumber); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** * @brief 解析接收到的JSON消息 * @param json JSON字符串 * @param message 输出消息结构体 * @retval 0成功，-1失败 */ int tcp_parse_json_message(const char *json, tcp_message_t *message) { cJSON *root = NULL; cJSON *item = NULL; cJSON *data = NULL; if (json == NULL || message == NULL) { TCP_PRINT("tcp_parse_json_message: NULL parameters\r\n"); return -1; } /* 解析JSON */ root = cJSON_Parse(json); if (root == NULL) { TCP_PRINT("tcp_parse_json_message: cJSON_Parse failed\r\n"); return -1; } /* 清空消息结构体 */ memset(message, 0, sizeof(tcp_message_t)); /* 解析version */ item = cJSON_GetObjectItem(root, "version"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->version, item->valuestring, sizeof(message->version) - 1); } /* 解析timestamp */ item = cJSON_GetObjectItem(root, "timestamp"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->timestamp, item->valuestring, sizeof(message->timestamp) - 1); } /* 解析command */ item = cJSON_GetObjectItem(root, "command"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->command, item->valuestring, sizeof(message->command) - 1); } else { cJSON_Delete(root); return -1; } /* 解析data */ data = cJSON_GetObjectItem(root, "data"); if (data == NULL || !cJSON_IsObject(data)) { TCP_PRINT("tcp_parse_json_message: missing or invalid data object\r\n"); cJSON_Delete(root); return -1; } /* 根据command类型解析data */ if (strcmp(message->command, CMD_HEARTBEAT) == 0) { /* 解析心跳数据 */ item = cJSON_GetObjectItem(data, "sequence"); if (item != NULL && cJSON_IsNumber(item)) { message->data.heartbeat.sequence = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "source"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.heartbeat.source, item->valuestring, sizeof(message->data.heartbeat.source) - 1); } } else if (strcmp(message->command, CMD_CHARGE_CONTROL) == 0) { /* 解析充电启停控制数据 */ item = cJSON_GetObjectItem(data, "gunNumber"); if (item != NULL && cJSON_IsNumber(item)) { message->data.chargeControl.gunNumber = (uint8_t)item->valueint; } item = cJSON_GetObjectItem(data, "action"); if (item != NULL && cJSON_IsNumber(item)) { message->data.chargeControl.action = (uint8_t)item->valueint; } } else if (strcmp(message->command, CMD_PARAM_QUERY) == 0) { /* 解析参数查询数据 */ item = cJSON_GetObjectItem(data, "type"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.paramQuery.type, item->valuestring, sizeof(message->data.paramQuery.type) - 1); } else { cJSON_Delete(root); return -1; } } else if (strcmp(message->command, CMD_PARAM_MODIFY) == 0) { /* 解析参数修改数据 */ item = cJSON_GetObjectItem(data, "type"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.paramModify.type, item->valuestring, sizeof(message->data.paramModify.type) - 1); } else { cJSON_Delete(root); return -1; } /* 解析参数数组 */ cJSON *params_array = cJSON_GetObjectItem(data, "params"); if (params_array != NULL && cJSON_IsArray(params_array)) { int array_size = cJSON_GetArraySize(params_array); if (array_size > 0) { /* 分配内存存储参数 */ message->data.paramModify.count = array_size; message->data.paramModify.params = (tcp_param_item_t *)pvPortMalloc( array_size * sizeof(tcp_param_item_t)); if (message->data.paramModify.params == NULL) { cJSON_Delete(root); return -1; } /* 清空参数数组 */ memset(message->data.paramModify.params, 0, array_size * sizeof(tcp_param_item_t)); /* 解析每个参数项 */ for (int i = 0; i < array_size; i++) { cJSON *param_item = cJSON_GetArrayItem(params_array, i); if (param_item != NULL && cJSON_IsObject(param_item)) { /* 解析参数名称 */ cJSON *name_item = cJSON_GetObjectItem(param_item, "name"); if (name_item != NULL && cJSON_IsString(name_item)) { strncpy(message->data.paramModify.params[i].name, name_item->valuestring, sizeof(message->data.paramModify.params[i].name) - 1); } /* 解析参数值 */ cJSON *value_item = cJSON_GetObjectItem(param_item, "value"); if (value_item != NULL && cJSON_IsString(value_item)) { strncpy(message->data.paramModify.params[i].value, value_item->valuestring, sizeof(message->data.paramModify.params[i].value) - 1); } } } } else { message->data.paramModify.count = 0; message->data.paramModify.params = NULL; } } else { message->data.paramModify.count = 0; message->data.paramModify.params = NULL; } } else if (strcmp(message->command, CMD_FIRMWARE_UPGRADE) == 0) { /* 解析固件升级数据 */ item = cJSON_GetObjectItem(data, "subCommand"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.firmwareUpgrade.subCommand, item->valuestring, sizeof(message->data.firmwareUpgrade.subCommand) - 1); } else { cJSON_Delete(root); return -1; } /* 根据子命令解析不同的字段 */ if (strcmp(message->data.firmwareUpgrade.subCommand, FIRMWARE_SUBCMD_START) == 0) { /* 解析Start子命令 */ item = cJSON_GetObjectItem(data, "fileSize"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.start.fileSize = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "totalPackets"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.start.totalPackets = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "packetSize"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.start.packetSize = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "firmwareVersion"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.firmwareUpgrade.u.start.firmwareVersion, item->valuestring, sizeof(message->data.firmwareUpgrade.u.start.firmwareVersion) - 1); } } else if (strcmp(message->data.firmwareUpgrade.subCommand, FIRMWARE_SUBCMD_DATA) == 0) { /* 解析Data子命令 */ item = cJSON_GetObjectItem(data, "packetIndex"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.data.packetIndex = (uint32_t)item->valueint; } else { /* 如果packetIndex字段不存在或不是数字，使用默认值0 */ message->data.firmwareUpgrade.u.data.packetIndex = 0; } item = cJSON_GetObjectItem(data, "totalPackets"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.data.totalPackets = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "data"); if (item != NULL && cJSON_IsString(item)) { /* 动态分配内存存储数据 */ const char *data_str = item->valuestring; size_t data_len = strlen(data_str); message->data.firmwareUpgrade.u.data.data = (char *)pvPortMalloc(data_len + 1); if (message->data.firmwareUpgrade.u.data.data != NULL) { strncpy(message->data.firmwareUpgrade.u.data.data, data_str, data_len); message->data.firmwareUpgrade.u.data.data[data_len] = '\0'; message->data.firmwareUpgrade.u.data.data_len = data_len; } else { TCP_PRINT("Failed to allocate memory for firmware data\r\n"); cJSON_Delete(root); return -1; } } else { message->data.firmwareUpgrade.u.data.data = NULL; message->data.firmwareUpgrade.u.data.data_len = 0; } item = cJSON_GetObjectItem(data, "crc"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.data.crc = (uint32_t)item->valueint; } } else if (strcmp(message->data.firmwareUpgrade.subCommand, FIRMWARE_SUBCMD_END) == 0) { /* 解析End子命令 */ item = cJSON_GetObjectItem(data, "status"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.end.status = (uint8_t)item->valueint; } item = cJSON_GetObjectItem(data, "errorMessage"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.firmwareUpgrade.u.end.errorMessage, item->valuestring, sizeof(message->data.firmwareUpgrade.u.end.errorMessage) - 1); } } else if (strcmp(message->data.firmwareUpgrade.subCommand, FIRMWARE_SUBCMD_RESPONSE) == 0) { /* 解析Response子命令 */ item = cJSON_GetObjectItem(data, "response"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.response.response = (uint8_t)item->valueint; } item = cJSON_GetObjectItem(data, "packetIndex"); if (item != NULL && cJSON_IsNumber(item)) { message->data.firmwareUpgrade.u.response.packetIndex = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "message"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.firmwareUpgrade.u.response.message, item->valuestring, sizeof(message->data.firmwareUpgrade.u.response.message) - 1); } } else { /* 未知子命令 */ cJSON_Delete(root); return -1; } } else if (strcmp(message->command, CMD_FILE_OPERATIONS) == 0) { /* 解析文件操作数据 */ item = cJSON_GetObjectItem(data, "subCommand"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.fileOperation.subCommand, item->valuestring, sizeof(message->data.fileOperation.subCommand) - 1); } else { cJSON_Delete(root); return -1; } /* 根据子命令解析不同的字段 */ if (strcmp(message->data.fileOperation.subCommand, FILE_OP_SUBCMD_QUERY) == 0) { /* 解析查询子命令 - 支持两种格式： 1. 直接格式：data中包含path字段 2. 嵌套格式：data中包含request对象，request对象中包含path和recursive字段 */ cJSON *request_obj = cJSON_GetObjectItem(data, "request"); if (request_obj != NULL && cJSON_IsObject(request_obj)) { /* 嵌套格式：从request对象中获取path */ item = cJSON_GetObjectItem(request_obj, "path"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.fileOperation.request.query.path, item->valuestring, sizeof(message->data.fileOperation.request.query.path) - 1); } /* 解析recursive字段（可选） */ item = cJSON_GetObjectItem(request_obj, "recursive"); if (item != NULL && cJSON_IsNumber(item)) { message->data.fileOperation.request.query.recursive = (uint8_t)item->valueint; } } else { /* 直接格式：从data对象中直接获取path */ item = cJSON_GetObjectItem(data, "path"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.fileOperation.request.query.path, item->valuestring, sizeof(message->data.fileOperation.request.query.path) - 1); } } } else if (strcmp(message->data.fileOperation.subCommand, FILE_OP_SUBCMD_DELETE) == 0) { /* 解析删除子命令 - 支持两种格式： 1. 直接格式：data中包含path字段（完整路径） 2. 新格式：data中包含fileName和path字段，需要组合成完整路径 */ cJSON *fileName_item = cJSON_GetObjectItem(data, "fileName"); cJSON *path_item = cJSON_GetObjectItem(data, "path"); if (fileName_item != NULL && cJSON_IsString(fileName_item) && path_item != NULL && cJSON_IsString(path_item)) { /* 新格式：组合路径和文件名 */ char full_path[256]; const char *path_str = path_item->valuestring; const char *file_name = fileName_item->valuestring; /* 构建完整路径：path + "/" + fileName */ if (path_str[0] == '\0') { /* 如果路径为空，直接使用文件名 */ snprintf(full_path, sizeof(full_path), "/%s", file_name); } else if (path_str[strlen(path_str) - 1] == '/') { /* 如果路径以斜杠结尾，直接拼接 */ snprintf(full_path, sizeof(full_path), "%s%s", path_str, file_name); } else { /* 否则添加斜杠分隔符 */ snprintf(full_path, sizeof(full_path), "%s/%s", path_str, file_name); } strncpy(message->data.fileOperation.request.delete.path, full_path, sizeof(message->data.fileOperation.request.delete.path) - 1); message->data.fileOperation.request.delete.path[sizeof(message->data.fileOperation.request.delete.path) - 1] = '\0'; TCP_PRINT("Delete request with fileName and path: path=%s, fileName=%s, fullPath=%s\r\n", path_str, file_name, message->data.fileOperation.request.delete.path); } else if (path_item != NULL && cJSON_IsString(path_item)) { /* 直接格式：使用完整的path字段 */ strncpy(message->data.fileOperation.request.delete.path, path_item->valuestring, sizeof(message->data.fileOperation.request.delete.path) - 1); message->data.fileOperation.request.delete.path[sizeof(message->data.fileOperation.request.delete.path) - 1] = '\0'; TCP_PRINT("Delete request with full path: %s\r\n", message->data.fileOperation.request.delete.path); } else { /* 两种格式都不满足，返回错误 */ TCP_PRINT("Delete request missing required fields (need either path or both fileName and path)\r\n"); cJSON_Delete(root); return -1; } /* 解析force字段（可选） */ item = cJSON_GetObjectItem(data, "force"); if (item != NULL && cJSON_IsNumber(item)) { message->data.fileOperation.request.delete.force = (uint8_t)item->valueint; } else { message->data.fileOperation.request.delete.force = 0; /* 默认不强制删除 */ } } else if (strcmp(message->data.fileOperation.subCommand, FILE_OP_SUBCMD_DOWNLOAD) == 0) { /* 解析下载子命令 - 支持两种格式： 1. 直接格式：data中包含path字段（完整路径） 2. 新格式：data中包含fileName和path字段，需要组合成完整路径 */ cJSON *fileName_item = cJSON_GetObjectItem(data, "fileName"); cJSON *path_item = cJSON_GetObjectItem(data, "path"); if (fileName_item != NULL && cJSON_IsString(fileName_item) && path_item != NULL && cJSON_IsString(path_item)) { /* 新格式：组合路径和文件名 */ char full_path[64]; const char *path_str = path_item->valuestring; const char *file_name = fileName_item->valuestring; /* 构建完整路径：path + "/" + fileName */ if (path_str[0] == '\0') { /* 如果路径为空，直接使用文件名 */ snprintf(full_path, sizeof(full_path), "/%s", file_name); } else if (path_str[strlen(path_str) - 1] == '/') { /* 如果路径以斜杠结尾，直接拼接 */ snprintf(full_path, sizeof(full_path), "%s%s", path_str, file_name); } else { /* 否则添加斜杠分隔符 */ snprintf(full_path, sizeof(full_path), "%s/%s", path_str, file_name); } strncpy(message->data.fileOperation.request.download.path, full_path, sizeof(message->data.fileOperation.request.download.path) - 1); message->data.fileOperation.request.download.path[sizeof(message->data.fileOperation.request.download.path) - 1] = '\0'; TCP_PRINT("Download request with fileName and path: path=%s, fileName=%s, fullPath=%s\r\n", path_str, file_name, message->data.fileOperation.request.download.path); } else if (path_item != NULL && cJSON_IsString(path_item)) { /* 直接格式：使用完整的path字段 */ strncpy(message->data.fileOperation.request.download.path, path_item->valuestring, sizeof(message->data.fileOperation.request.download.path) - 1); message->data.fileOperation.request.download.path[sizeof(message->data.fileOperation.request.download.path) - 1] = '\0'; TCP_PRINT("Download request with full path: %s\r\n", message->data.fileOperation.request.download.path); } else { /* 两种格式都不满足，返回错误 */ TCP_PRINT("Download request missing required fields (need either path or both fileName and path)\r\n"); cJSON_Delete(root); return -1; } item = cJSON_GetObjectItem(data, "offset"); if (item != NULL && cJSON_IsNumber(item)) { message->data.fileOperation.request.download.offset = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "chunkSize"); if (item != NULL && cJSON_IsNumber(item)) { message->data.fileOperation.request.download.chunk_size = (uint32_t)item->valueint; } } else if (strcmp(message->data.fileOperation.subCommand, FILE_OP_SUBCMD_UPLOAD) == 0) { /* 解析上传子命令 */ item = cJSON_GetObjectItem(data, "path"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.fileOperation.request.upload.path, item->valuestring, sizeof(message->data.fileOperation.request.upload.path) - 1); } item = cJSON_GetObjectItem(data, "data"); if (item != NULL && cJSON_IsString(item)) { /* 注意：data字段是uint8_t*，但我们需要将其作为char*处理 */ strncpy((char *)message->data.fileOperation.request.upload.data, item->valuestring, sizeof(message->data.fileOperation.request.upload.data) - 1); } item = cJSON_GetObjectItem(data, "offset"); if (item != NULL && cJSON_IsNumber(item)) { message->data.fileOperation.request.upload.offset = (uint32_t)item->valueint; } item = cJSON_GetObjectItem(data, "fileSize"); if (item != NULL && cJSON_IsNumber(item)) { message->data.fileOperation.request.upload.file_size = (uint32_t)item->valueint; } } else { /* 未知子命令 */ cJSON_Delete(root); return -1; } } else if (strcmp(message->command, CMD_HISTORY_OPERATIONS) == 0) { /* 解析历史记录查询/清除请求 */ item = cJSON_GetObjectItem(data, "subCommand"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.historyOperations.subCommand, item->valuestring, sizeof(message->data.historyOperations.subCommand) - 1); } else { cJSON_Delete(root); return -1; } item = cJSON_GetObjectItem(data, "historyType"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.historyOperations.historyType, item->valuestring, sizeof(message->data.historyOperations.historyType) - 1); } else { message->data.historyOperations.historyType[0] = '\0'; } item = cJSON_GetObjectItem(data, "queryId"); if (item != NULL && cJSON_IsNumber(item)) { message->data.historyOperations.queryId = (uint32_t)item->valueint; } else { message->data.historyOperations.queryId = 0; } item = cJSON_GetObjectItem(data, "startIndex"); if (item != NULL && cJSON_IsNumber(item)) { message->data.historyOperations.startIndex = (uint16_t)item->valueint; } else { message->data.historyOperations.startIndex = 0; } item = cJSON_GetObjectItem(data, "fetchCount"); if (item != NULL && cJSON_IsNumber(item)) { message->data.historyOperations.fetchCount = (uint16_t)item->valueint; } else { message->data.historyOperations.fetchCount = 0; } } else if (strcmp(message->command, CMD_FAULT_INFO) == 0) { /* 解析故障信息请求 */ item = cJSON_GetObjectItem(data, "faultCode"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.faultInfo.faultCode, item->valuestring, sizeof(message->data.faultInfo.faultCode) - 1); } else { /* 故障代码是可选的，如果为空表示查询所有故障 */ message->data.faultInfo.faultCode[0] = '\0'; } } else if (strcmp(message->command, CMD_CUSTOM_DATA) == 0) { /* 解析自定义数据请求 */ item = cJSON_GetObjectItem(data, "functionContent"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.customData.functionContent, item->valuestring, sizeof(message->data.customData.functionContent) - 1); } else { /* 如果字段不存在，设置为空字符串 */ message->data.customData.functionContent[0] = '\0'; } item = cJSON_GetObjectItem(data, "functionField"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.customData.functionField, item->valuestring, sizeof(message->data.customData.functionField) - 1); } else { /* 如果字段不存在，设置为空字符串 */ message->data.customData.functionField[0] = '\0'; } item = cJSON_GetObjectItem(data, "functionParams"); if (item != NULL && cJSON_IsString(item)) { strncpy(message->data.customData.functionParams, item->valuestring, sizeof(message->data.customData.functionParams) - 1); } else { /* 如果字段不存在，设置为空字符串 */ message->data.customData.functionParams[0] = '\0'; } } else { /* 未知命令 */ cJSON_Delete(root); return -1; } cJSON_Delete(root); return 0; } /** * @brief 解析时间字符串到Comm_Time结构体 * @param time_str 时间字符串，格式为"YYYY-MM-DD HH:MM:SS.xxx" * @param time 输出时间结构体 * @retval 0成功，-1失败 */ static int tcp_parse_timestamp_string(const char *time_str, Comm_Time *time) { int year, month, day, hour, minute, second, millisecond; if (time_str == NULL || time == NULL) { return -1; } /* 解析时间字符串格式：YYYY-MM-DD HH:MM:SS.xxx */ if (sscanf(time_str, "%d-%d-%d %d:%d:%d.%d", &year, &month, &day, &hour, &minute, &second, &millisecond) != 7) { /* 尝试不带毫秒的格式 */ if (sscanf(time_str, "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second) != 6) { return -1; } millisecond = 0; } /* 验证时间范围 */ if (year < 2000 || year > 2100 || month < 1 || month > 12 || day < 1 || day > 31 || hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) { return -1; } /* 填充时间结构体 */ time->iYear = (U16_T)year; time->ucMonth = (U8_T)month; time->ucDay = (U8_T)day; time->ucHour = (U8_T)hour; time->ucMin = (U8_T)minute; time->ucSec = (U8_T)second; return 0; } /** * @brief 计算两个时间之间的分钟差 * @param time1 时间1 * @param time2 时间2 * @retval 分钟差（绝对值） */ static int tcp_calculate_time_diff_minutes(const Comm_Time *time1, const Comm_Time *time2) { /* 简单计算：假设每个月30天，每年365天 */ long total_minutes1 = (long)time1->iYear * 365 * 24 * 60 + (long)time1->ucMonth * 30 * 24 * 60 + (long)time1->ucDay * 24 * 60 + (long)time1->ucHour * 60 + (long)time1->ucMin; long total_minutes2 = (long)time2->iYear * 365 * 24 * 60 + (long)time2->ucMonth * 30 * 24 * 60 + (long)time2->ucDay * 24 * 60 + (long)time2->ucHour * 60 + (long)time2->ucMin; long diff = total_minutes1 - total_minutes2; if (diff < 0) { diff = -diff; } return (int)diff; } /* 子函数声明 */ static int tcp_process_heartbeat_message(const tcp_message_t *message); static int tcp_process_charge_control_message(const tcp_message_t *message); static int tcp_process_param_query_message(const tcp_message_t *message); static int tcp_process_param_modify_message(const tcp_message_t *message); static int tcp_process_firmware_upgrade_message(const tcp_message_t *message); static int tcp_process_file_operation_message(const tcp_message_t *message); static int tcp_process_fault_info_message(const tcp_message_t *message); static int tcp_process_history_operations_message(const tcp_message_t *message); static int tcp_process_custom_data_message(const tcp_message_t *message); static int tcp_generate_fault_info_json(const tcp_fault_info_response_t *response, char *buffer, uint32_t size); /* 子函数实现 */ /** * @brief 处理心跳消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_heartbeat_message(const tcp_message_t *message) { Comm_Time curTime; Comm_Time receivedTime; int time_diff_minutes = 0; TCP_PRINT("Received heartbeat: sequence=%u, source=%s\r\r\n", message->data.heartbeat.sequence, message->data.heartbeat.source); /* 解析消息中的时间戳并进行校时检查 */ if (message->timestamp[0] != '\0') { /* 解析接收到的消息时间戳 */ if (tcp_parse_timestamp_string(message->timestamp, &receivedTime) == 0) { /* 获取当前系统时间 */ GetCurrentTime(&curTime); /* 计算时间差（分钟） */ time_diff_minutes = tcp_calculate_time_diff_minutes(&receivedTime, &curTime); TCP_PRINT("Time check: received=%04d-%02d-%02d %02d:%02d:%02d, current=%04d-%02d-%02d %02d:%02d:%02d, diff=%d minutes\r\r\n", receivedTime.iYear, receivedTime.ucMonth, receivedTime.ucDay, receivedTime.ucHour, receivedTime.ucMin, receivedTime.ucSec, curTime.iYear, curTime.ucMonth, curTime.ucDay, curTime.ucHour, curTime.ucMin, curTime.ucSec, time_diff_minutes); /* 如果时间差大于5分钟，进行校时 */ if (time_diff_minutes > 5) { TCP_PRINT("Time difference too large (%d minutes), adjusting system time...\r\r\n", time_diff_minutes); /* 调用RTC校时函数 */ v_rtc_set_time(&receivedTime); TCP_PRINT("System time adjusted to: %04d-%02d-%02d %02d:%02d:%02d\r\r\n", receivedTime.iYear, receivedTime.ucMonth, receivedTime.ucDay, receivedTime.ucHour, receivedTime.ucMin, receivedTime.ucSec); } else { TCP_PRINT("Time difference within acceptable range (%d minutes), no adjustment needed\r\r\n", time_diff_minutes); } } else { TCP_PRINT("Failed to parse timestamp: %s\r\r\n", message->timestamp); } } return 0; } /** * @brief 处理充电控制消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_charge_control_message(const tcp_message_t *message) { char msg[64]; TCP_PRINT("Received charge control: gun=%u, action=%u\r\r\n", message->data.chargeControl.gunNumber, message->data.chargeControl.action); /* 调用system_data模块处理充电控制 */ if (message->data.chargeControl.action == CHARGE_ACTION_STOP) { /* 停止充电 */ if (system_data_stop_charge(message->data.chargeControl.gunNumber, msg) != 0) { TCP_PRINT("Failed to stop charge: %s\r\r\n", msg); return -1; } TCP_PRINT("Charge stopped: %s\r\r\n", msg); } else if (message->data.chargeControl.action == CHARGE_ACTION_START) { /* 启动充电 */ if (system_data_start_charge(message->data.chargeControl.gunNumber, "", "", msg) != 0) { TCP_PRINT("Failed to start charge: %s\r\r\n", msg); return -1; } TCP_PRINT("Charge started: %s\r\r\n", msg); } else { TCP_PRINT("Unknown charge action: %u\r\r\n", message->data.chargeControl.action); return -1; } return 0; } /** * @brief 处理参数查询消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_param_query_message(const tcp_message_t *message) { tcp_param_query_response_t response; char *response_json = NULL; int json_len = 0; int result = 0; /* 参数查询：按固定大小缓冲 + 分包发送 */ #define TCP_PARAM_QUERY_JSON_BUF_SIZE (2048) #define TCP_PARAM_QUERY_MAX_PARAMS_PER_PACKET (20) TCP_PRINT("Received param query: type=%s\r\r\n", message->data.paramQuery.type); /* 处理参数查询请求 */ memset(&response, 0, sizeof(response)); if (tcp_process_param_query(&message->data.paramQuery, &response) != 0) { TCP_PRINT("Failed to process param query\r\r\n"); return -1; } /* 动态分配响应JSON缓冲区（固定 2048） */ response_json = (char *)pvPortMalloc(TCP_PARAM_QUERY_JSON_BUF_SIZE); if (response_json == NULL) { TCP_PRINT("Failed to allocate memory for response JSON\r\r\n"); result = -1; goto cleanup; } /* 按“每包最多 20 个参数”分包应答 */ { uint16_t total = response.count; uint16_t offset = 0; uint16_t pkt_index = 0; uint16_t total_pkts = (total + TCP_PARAM_QUERY_MAX_PARAMS_PER_PACKET - 1) / TCP_PARAM_QUERY_MAX_PARAMS_PER_PACKET; while (offset < total) { uint16_t chunk = total - offset; if (chunk > TCP_PARAM_QUERY_MAX_PARAMS_PER_PACKET) { chunk = TCP_PARAM_QUERY_MAX_PARAMS_PER_PACKET; } tcp_param_query_response_t chunk_resp; memset(&chunk_resp, 0, sizeof(chunk_resp)); strncpy(chunk_resp.type, response.type, sizeof(chunk_resp.type) - 1); chunk_resp.count = chunk; chunk_resp.params = &response.params[offset]; json_len = tcp_generate_param_query_response(&chunk_resp, response_json, TCP_PARAM_QUERY_JSON_BUF_SIZE); if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, (uint16_t)json_len); if (send_err == ERR_OK) { TCP_PRINT("Param query response sent pkt %u/%u, params %u~%u, json %d bytes\r\r\n", (unsigned)(pkt_index + 1), (unsigned)total_pkts, (unsigned)offset, (unsigned)(offset + chunk - 1), json_len); } else { TCP_PRINT("Failed to send param query response pkt %u/%u: %d\r\r\n", (unsigned)(pkt_index + 1), (unsigned)total_pkts, send_err); result = -1; break; } } else { TCP_PRINT("Failed to generate param query response pkt %u/%u (offset=%u, chunk=%u)\r\r\n", (unsigned)(pkt_index + 1), (unsigned)total_pkts, (unsigned)offset, (unsigned)chunk); result = -1; break; } offset = (uint16_t)(offset + chunk); pkt_index++; } } cleanup: /* 释放动态分配的内存 */ if (response.params != NULL) { vPortFree(response.params); } if (response_json != NULL) { vPortFree(response_json); } return result; } /** * @brief 处理参数修改消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_param_modify_message(const tcp_message_t *message) { tcp_param_modify_response_t response; char *response_json = NULL; int json_len = 0; int result = 0; TCP_PRINT("Received param modify: type=%s, count=%u\r\r\n", message->data.paramModify.type, message->data.paramModify.count); /* 处理参数修改请求 */ memset(&response, 0, sizeof(response)); if (tcp_process_param_modify(&message->data.paramModify, &response) != 0) { TCP_PRINT("Failed to process param modify\r\r\n"); return -1; } /* 动态分配响应JSON缓冲区 */ response_json = (char *)pvPortMalloc(2048); if (response_json == NULL) { TCP_PRINT("Failed to allocate memory for response JSON\r\r\n"); result = -1; goto cleanup; } /* 生成响应JSON */ json_len = tcp_generate_param_modify_response(&response, response_json, 2048); if (json_len > 0) { TCP_PRINT("Param modify response generated (%d bytes)\r\r\n", json_len); /* 发送响应到客户端 */ err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("Param modify response sent successfully\r\r\n"); } else { TCP_PRINT("Failed to send param modify response: %d\r\r\n", send_err); result = -1; } } else { TCP_PRINT("Failed to generate param modify response\r\r\n"); result = -1; } cleanup: /* 注意：message->data.paramModify.params 的内存由 tcp_free_message 函数释放 这里不释放，因为 message 是 const 指针，不能修改 */ if (response_json != NULL) { vPortFree(response_json); response_json = NULL; } return result; } /** * @brief 处理固件升级消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_firmware_upgrade_message(const tcp_message_t *message) { TCP_PRINT("Received firmware upgrade: subCommand=%s\r\r\n", message->data.firmwareUpgrade.subCommand); /* 处理固件升级请求 */ if (tcp_process_firmware_upgrade(&message->data.firmwareUpgrade) != 0) { TCP_PRINT("Failed to process firmware upgrade\r\r\n"); return -1; } return 0; } /** * @brief 处理文件操作消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_file_operation_message(const tcp_message_t *message) { TCP_PRINT("Received file operation: subCommand=%s\r\r\n", message->data.fileOperation.subCommand); /* 处理文件操作请求 */ if (tcp_process_file_operation(&message->data.fileOperation) != 0) { TCP_PRINT("Failed to process file operation\r\r\n"); return -1; } return 0; } /** * @brief 处理接收到的消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ int tcp_process_received_message(const tcp_message_t *message) { if (message == NULL) { return -1; } /* 根据命令类型调用相应的处理函数 */ if (strcmp(message->command, CMD_HEARTBEAT) == 0) { return tcp_process_heartbeat_message(message); } else if (strcmp(message->command, CMD_CHARGE_CONTROL) == 0) { return tcp_process_charge_control_message(message); } else if (strcmp(message->command, CMD_PARAM_QUERY) == 0) { return tcp_process_param_query_message(message); } else if (strcmp(message->command, CMD_PARAM_MODIFY) == 0) { return tcp_process_param_modify_message(message); } else if (strcmp(message->command, CMD_FIRMWARE_UPGRADE) == 0) { return tcp_process_firmware_upgrade_message(message); } else if (strcmp(message->command, CMD_FILE_OPERATIONS) == 0) { return tcp_process_file_operation_message(message); } else if (strcmp(message->command, CMD_FAULT_INFO) == 0) { return tcp_process_fault_info_message(message); } else if (strcmp(message->command, CMD_HISTORY_OPERATIONS) == 0) { return tcp_process_history_operations_message(message); } else if (strcmp(message->command, CMD_CUSTOM_DATA) == 0) { return tcp_process_custom_data_message(message); } else { TCP_PRINT("Received unknown command: %s\r\r\n", message->command); return -1; } } /** * @brief 填充参数项（辅助函数） * @param item 参数项指针 * @param name 参数名称 * @param type 参数类型 * @param value 参数值（字符串格式） * @retval 无 */ static void tcp_fill_param_item(tcp_param_item_t *item, const char *name, const char *type, const char *value) { if (item == NULL || name == NULL || type == NULL || value == NULL) { return; } strncpy(item->name, name, sizeof(item->name) - 1); strncpy(item->type, type, sizeof(item->type) - 1); strncpy(item->value, value, sizeof(item->value) - 1); } /** * @brief 处理参数查询请求（使用参数映射表） * @param request 参数查询请求 * @param response 参数查询响应 * @retval 0成功，-1失败 */ int tcp_process_param_query(const tcp_param_query_request_t *request, tcp_param_query_response_t *response) { const param_map_item_t *param_map = NULL; uint16_t param_count = 0; uint16_t i; char value_buffer[128]; if (request == NULL || response == NULL) { return -1; } /* 复制参数类型 */ strncpy(response->type, request->type, sizeof(response->type) - 1); /* 根据参数类型获取对应的映射表 */ if (strcmp(request->type, PARAM_TYPE_BASIC) == 0) { param_map = param_get_basic_map(); param_count = param_get_basic_map_size(); } else if (strcmp(request->type, PARAM_TYPE_NETWORK) == 0) { param_map = param_get_network_map(); param_count = param_get_network_map_size(); } else if (strcmp(request->type, PARAM_TYPE_METER) == 0) { param_map = param_get_meter_map(); param_count = param_get_meter_map_size(); } else if (strcmp(request->type, PARAM_TYPE_ENABLE) == 0) { param_map = param_get_enable_map(); param_count = param_get_enable_map_size(); } else if (strcmp(request->type, PARAM_TYPE_FEE) == 0) { param_map = param_get_fee_map(); param_count = param_get_fee_map_size(); } else if (strcmp(request->type, PARAM_TYPE_SDK) == 0) { param_map = param_get_sdk_map(); param_count = param_get_sdk_map_size(); } else if (strcmp(request->type, PARAM_TYPE_QRCODE) == 0) { param_map = param_get_qrcode_map(); param_count = param_get_qrcode_map_size(); } else { /* 其他参数类型暂不支持 */ response->count = 0; response->params = NULL; TCP_PRINT("Unsupported param type: %s\r\r\n", request->type); return -1; } if (param_map == NULL || param_count == 0) { response->count = 0; response->params = NULL; TCP_PRINT("No parameter map found for type: %s\r\r\n", request->type); return -1; } /* 分配参数数组内存 */ response->count = param_count; response->params = (tcp_param_item_t *)pvPortMalloc(response->count * sizeof(tcp_param_item_t)); if (response->params == NULL) { response->count = 0; return -1; } /* 填充基本参数 */ memset(response->params, 0, response->count * sizeof(tcp_param_item_t)); /* 使用参数映射表填充参数 */ for (i = 0; i < param_count; i++) { const param_map_item_t *map_item = ¶m_map[i]; /* 获取参数值字符串 */ if (param_get_value_as_string(map_item, value_buffer, sizeof(value_buffer)) != 0) { snprintf(value_buffer, sizeof(value_buffer), "error"); } /* 填充参数项 */ strncpy(response->params[i].name, map_item->param_name, sizeof(response->params[i].name) - 1); strncpy(response->params[i].type, param_type_to_string(map_item->data_type), sizeof(response->params[i].type) - 1); strncpy(response->params[i].value, value_buffer, sizeof(response->params[i].value) - 1); /* 填充描述字段（如果存在） */ if (map_item->decs != NULL) { strncpy(response->params[i].decs, map_item->decs, sizeof(response->params[i].decs) - 1); } else { response->params[i].decs[0] = '\0'; /* 设置为空字符串 */ } } return 0; } /** * @brief 生成参数查询响应JSON * @param response 参数查询响应 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_param_query_response(const tcp_param_query_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; cJSON *params_array = NULL; cJSON *param_item = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; int i; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_PARAM_QUERY); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "type", response->type); cJSON_AddNumberToObject(data, "count", response->count); /* 创建参数数组 */ params_array = cJSON_CreateArray(); if (params_array == NULL) { cJSON_Delete(data); cJSON_Delete(root); return -1; } /* 添加参数项到数组 */ for (i = 0; i < response->count; i++) { param_item = cJSON_CreateObject(); if (param_item == NULL) { cJSON_Delete(params_array); cJSON_Delete(data); cJSON_Delete(root); return -1; } cJSON_AddStringToObject(param_item, "name", response->params[i].name); cJSON_AddStringToObject(param_item, "type", response->params[i].type); cJSON_AddStringToObject(param_item, "value", response->params[i].value); cJSON_AddStringToObject(param_item, "decs", response->params[i].decs); cJSON_AddItemToArray(params_array, param_item); } cJSON_AddItemToObject(data, "params", params_array); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** * @brief 处理参数修改请求 * @param request 参数修改请求 * @param response 参数修改响应 * @retval 0成功，-1失败 */ int tcp_process_param_modify(const tcp_param_modify_request_t *request, tcp_param_modify_response_t *response) { const param_map_item_t *param_map = NULL; uint16_t param_count = 0; uint16_t i; if (request == NULL || response == NULL) { return -1; } /* 初始化响应 */ memset(response, 0, sizeof(tcp_param_modify_response_t)); strncpy(response->type, request->type, sizeof(response->type) - 1); response->received = request->count; /* 根据参数类型获取对应的映射表 */ if (strcmp(request->type, PARAM_TYPE_BASIC) == 0) { param_map = param_get_basic_map(); param_count = param_get_basic_map_size(); } else if (strcmp(request->type, PARAM_TYPE_NETWORK) == 0) { param_map = param_get_network_map(); param_count = param_get_network_map_size(); } else if (strcmp(request->type, PARAM_TYPE_METER) == 0) { param_map = param_get_meter_map(); param_count = param_get_meter_map_size(); } else if (strcmp(request->type, PARAM_TYPE_ENABLE) == 0) { param_map = param_get_enable_map(); param_count = param_get_enable_map_size(); } else if (strcmp(request->type, PARAM_TYPE_FEE) == 0) { param_map = param_get_fee_map(); param_count = param_get_fee_map_size(); } else if (strcmp(request->type, PARAM_TYPE_SDK) == 0) { param_map = param_get_sdk_map(); param_count = param_get_sdk_map_size(); } else if (strcmp(request->type, PARAM_TYPE_QRCODE) == 0) { param_map = param_get_qrcode_map(); param_count = param_get_qrcode_map_size(); } else { /* 其他参数类型暂不支持 */ TCP_PRINT("Unsupported param type for modify: %s\r\r\n", request->type); return -1; } if (param_map == NULL || param_count == 0) { TCP_PRINT("No parameter map found for type: %s\r\r\n", request->type); return -1; } /* 处理每个参数 */ for (i = 0; i < request->count; i++) { const tcp_param_item_t *req_item = &request->params[i]; const param_map_item_t *map_item = NULL; uint16_t j; /* 在映射表中查找参数 */ for (j = 0; j < param_count; j++) { if (strcmp(param_map[j].param_name, req_item->name) == 0) { map_item = ¶m_map[j]; break; } } if (map_item == NULL) { /* 未找到参数 */ TCP_PRINT("Parameter not found: %s\r\r\n", req_item->name); response->failed++; continue; } /* 尝试设置参数值 */ if (param_set_value_from_string(map_item, req_item->value) == 0) { TCP_PRINT("Parameter set successfully: %s = %s\r\r\n", req_item->name, req_item->value); response->success++; } else { TCP_PRINT("Failed to set parameter: %s = %s\r\r\n", req_item->name, req_item->value); response->failed++; } response->processed++; } v_flash_save_cfg_data(); return 0; } /** * @brief 生成参数修改响应JSON * @param response 参数修改响应 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_param_modify_response(const tcp_param_modify_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_PARAM_MODIFY); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "type", response->type); cJSON_AddNumberToObject(data, "received", response->received); cJSON_AddNumberToObject(data, "processed", response->processed); cJSON_AddNumberToObject(data, "success", response->success); cJSON_AddNumberToObject(data, "failed", response->failed); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** * @brief 生成固件升级消息JSON * @param firmwareUpgrade 固件升级数据结构体指针 * @param subCommand 子命令字符串 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_firmware_upgrade_json(const tcp_firmware_upgrade_data_t *firmwareUpgrade, const char *subCommand, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || firmwareUpgrade == NULL || subCommand == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_FIRMWARE_UPGRADE); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "subCommand", subCommand); /* 根据子命令添加不同的字段 */ if (strcmp(subCommand, FIRMWARE_SUBCMD_START) == 0) { cJSON_AddNumberToObject(data, "fileSize", firmwareUpgrade->u.start.fileSize); cJSON_AddNumberToObject(data, "totalPackets", firmwareUpgrade->u.start.totalPackets); cJSON_AddNumberToObject(data, "packetSize", firmwareUpgrade->u.start.packetSize); cJSON_AddStringToObject(data, "firmwareVersion", firmwareUpgrade->u.start.firmwareVersion); } else if (strcmp(subCommand, FIRMWARE_SUBCMD_DATA) == 0) { cJSON_AddNumberToObject(data, "packetIndex", firmwareUpgrade->u.data.packetIndex); cJSON_AddNumberToObject(data, "totalPackets", firmwareUpgrade->u.data.totalPackets); if (firmwareUpgrade->u.data.data != NULL && firmwareUpgrade->u.data.data_len > 0) { cJSON_AddStringToObject(data, "data", firmwareUpgrade->u.data.data); } else { cJSON_AddStringToObject(data, "data", ""); } cJSON_AddNumberToObject(data, "crc", firmwareUpgrade->u.data.crc); } else if (strcmp(subCommand, FIRMWARE_SUBCMD_END) == 0) { cJSON_AddNumberToObject(data, "status", firmwareUpgrade->u.end.status); cJSON_AddStringToObject(data, "errorMessage", firmwareUpgrade->u.end.errorMessage); } else if (strcmp(subCommand, FIRMWARE_SUBCMD_RESPONSE) == 0) { cJSON_AddNumberToObject(data, "response", firmwareUpgrade->u.response.response); cJSON_AddNumberToObject(data, "packetIndex", firmwareUpgrade->u.response.packetIndex); cJSON_AddStringToObject(data, "message", firmwareUpgrade->u.response.message); } else { cJSON_Delete(data); cJSON_Delete(root); return -1; } cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** 固件升级 Response：0=ACK，非0=NAK */ #define FIRMWARE_RESP_ACK 0U #define FIRMWARE_RESP_NAK 1U void tcp_firmware_upgrade_log_io(const char *dir, const char *data, uint32_t len) { uint32_t off = 0U; enum { kChunk = 480U }; if ((dir == NULL) || (data == NULL) || (len == 0U)) { return; } if (len <= kChunk) { printf("[FW_UPGRADE] %s (%u): %.*s\r\n", dir, (unsigned)len, (int)len, data); return; } printf("[FW_UPGRADE] %s (%u bytes):\r\n", dir, (unsigned)len); while (off < len) { uint32_t n = len - off; if (n > kChunk) { n = kChunk; } printf("[FW_UPGRADE] %s+%u: %.*s\r\n", dir, (unsigned)off, (int)n, data + off); off += n; } } void tcp_firmware_upgrade_log_buf(const char *dir, const uint8_t *data, uint32_t len) { uint32_t off = 0U; uint32_t i; enum { kHexShow = 48U, kChunk = 256U }; if ((dir == NULL) || (data == NULL) || (len == 0U)) { return; } printf("[FW_UPGRADE] %s (%u) HEX:", dir, (unsigned)len); for (i = 0U; i < len && i < kHexShow; i++) { printf(" %02X", (unsigned)data[i]); } if (len > kHexShow) { printf(" ..."); } printf("\r\n"); if (len <= kChunk) { printf("[FW_UPGRADE] %s TXT: %.*s\r\n", dir, (int)len, (const char *)data); return; } while (off < len) { uint32_t n = len - off; if (n > kChunk) { n = kChunk; } printf("[FW_UPGRADE] %s+%u TXT: %.*s\r\n", dir, (unsigned)off, (int)n, (const char *)(data + off)); off += n; } } void tcp_firmware_upgrade_log_meta(const char *tag, uint32_t a, uint32_t b, uint32_t c, uint32_t d) { if (tag == NULL) { return; } printf("[FW_UPGRADE] %s used=%u proc=%u cap=%u pending=%u\r\n", tag, (unsigned)a, (unsigned)b, (unsigned)c, (unsigned)d); } static int tcp_send_firmware_upgrade_response(uint8_t response_code, int packet_index, const char *message) { tcp_firmware_upgrade_data_t response_data; char response_json[512]; int json_len; err_t send_err; memset(&response_data, 0, sizeof(response_data)); strncpy(response_data.subCommand, FIRMWARE_SUBCMD_RESPONSE, sizeof(response_data.subCommand) - 1U); response_data.u.response.response = response_code; response_data.u.response.packetIndex = packet_index; if (message != NULL) { strncpy(response_data.u.response.message, message, sizeof(response_data.u.response.message) - 1U); } json_len = tcp_generate_firmware_upgrade_json(&response_data, FIRMWARE_SUBCMD_RESPONSE, response_json, sizeof(response_json)); if (json_len <= 0) { return -1; } tcp_firmware_upgrade_log_io("TX", response_json, (uint32_t)json_len); send_err = tcp_server_send_json(response_json, (uint32_t)json_len); return (send_err == ERR_OK) ? 0 : -1; } /** * @brief 处理固件升级请求 * @param firmwareUpgrade 固件升级数据结构体指针 * @retval 0成功，-1失败 */ int tcp_process_firmware_upgrade(const tcp_firmware_upgrade_data_t *firmwareUpgrade) { int ret; if (firmwareUpgrade == NULL) { return -1; } TCP_PRINT("Processing firmware upgrade: subCommand=%s\r\n", firmwareUpgrade->subCommand); if (strcmp(firmwareUpgrade->subCommand, FIRMWARE_SUBCMD_START) == 0) { TCP_PRINT("Firmware upgrade start:\r\n"); TCP_PRINT(" File size: %u bytes\r\n", firmwareUpgrade->u.start.fileSize); TCP_PRINT(" Total packets: %u\r\n", firmwareUpgrade->u.start.totalPackets); TCP_PRINT(" Packet size: %u bytes\r\n", firmwareUpgrade->u.start.packetSize); TCP_PRINT(" Firmware version: %s\r\n", firmwareUpgrade->u.start.firmwareVersion); (void)tcp_server_rx_upgrade_begin(); if (system_filetransfer_start_firmware_upgrade( firmwareUpgrade->u.start.fileSize, firmwareUpgrade->u.start.totalPackets, firmwareUpgrade->u.start.packetSize, firmwareUpgrade->u.start.firmwareVersion) != 0) { TCP_PRINT("Failed to start firmware upgrade\r\n"); tcp_server_rx_upgrade_end(); tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, -1, "Start rejected"); return -1; } if (system_filetransfer_commit_firmware_start() != 0) { TCP_PRINT("Failed to erase firmware area\r\n"); tcp_server_rx_upgrade_end(); tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, -1, "Erase failed"); return -1; } tcp_send_firmware_upgrade_response(FIRMWARE_RESP_ACK, -1, "Start accepted"); tcp_server_link_rx_drain(); } else if (strcmp(firmwareUpgrade->subCommand, FIRMWARE_SUBCMD_DATA) == 0) { int pkt = (int)firmwareUpgrade->u.data.packetIndex; TCP_PRINT("Firmware upgrade data packet:\r\n"); TCP_PRINT(" Packet index: %u/%u\r\n", firmwareUpgrade->u.data.packetIndex, firmwareUpgrade->u.data.totalPackets); TCP_PRINT(" Data length: %u bytes (Base64)\r\n", firmwareUpgrade->u.data.data_len); TCP_PRINT(" CRC: 0x%08X\r\n", firmwareUpgrade->u.data.crc); if (system_filetransfer_receive_firmware_packet( firmwareUpgrade->u.data.packetIndex, (const uint8_t *)firmwareUpgrade->u.data.data, firmwareUpgrade->u.data.data_len, firmwareUpgrade->u.data.crc) != 0) { TCP_PRINT("Failed to receive firmware packet\r\n"); tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, pkt, "Packet rejected"); return -1; } tcp_send_firmware_upgrade_response(FIRMWARE_RESP_ACK, pkt, "Packet received"); } else if (strcmp(firmwareUpgrade->subCommand, FIRMWARE_SUBCMD_END) == 0) { firmware_upgrade_context_t fw_ctx; TCP_PRINT("Firmware upgrade end:\r\n"); TCP_PRINT(" Status: %u\r\n", firmwareUpgrade->u.end.status); TCP_PRINT(" Error message: %s\r\n", firmwareUpgrade->u.end.errorMessage); memset(&fw_ctx, 0, sizeof(fw_ctx)); if (system_filetransfer_get_firmware_status(&fw_ctx) != 0 || fw_ctx.state == FILE_TRANSFER_IDLE) { TCP_PRINT("No active firmware upgrade session\r\n"); tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, 0, "No upgrade session"); return -1; } if ((firmwareUpgrade->u.end.status == FIRMWARE_STATUS_SUCCESS || firmwareUpgrade->u.end.status == FIRMWARE_STATUS_COMPLETED) && fw_ctx.received_packets == fw_ctx.total_packets && fw_ctx.received_bytes >= fw_ctx.file_size) { tcp_send_firmware_upgrade_response(FIRMWARE_RESP_ACK, 0, "Upgrade completed"); tcp_server_link_rx_drain(); vTaskDelay(pdMS_TO_TICKS(200)); (void)system_filetransfer_end_firmware_upgrade( firmwareUpgrade->u.end.status, firmwareUpgrade->u.end.errorMessage); return 0; } ret = system_filetransfer_end_firmware_upgrade( firmwareUpgrade->u.end.status, firmwareUpgrade->u.end.errorMessage); if (ret < 0) { TCP_PRINT("No active firmware upgrade session\r\n"); tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, 0, "No upgrade session"); return -1; } tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, 0, "Upgrade failed"); return -1; } else if (strcmp(firmwareUpgrade->subCommand, FIRMWARE_SUBCMD_RESPONSE) == 0) { TCP_PRINT("Firmware upgrade response from client: code=%u index=%d msg=%s\r\n", firmwareUpgrade->u.response.response, firmwareUpgrade->u.response.packetIndex, firmwareUpgrade->u.response.message); } else { TCP_PRINT("Unknown firmware upgrade subCommand: %s\r\n", firmwareUpgrade->subCommand); tcp_send_firmware_upgrade_response(FIRMWARE_RESP_NAK, -1, "Unknown subCommand"); return -1; } return 0; } /** * @brief 生成文件查询响应JSON * @param response 文件查询响应结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_file_query_response(const tcp_file_query_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; cJSON *files_array = NULL; cJSON *file_item = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; int i; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_FILE_OPERATIONS); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "subCommand", FILE_OP_SUBCMD_QUERY); cJSON_AddStringToObject(data, "path", response->path); cJSON_AddNumberToObject(data, "fileCount", response->file_count); cJSON_AddNumberToObject(data, "dirCount", response->dir_count); cJSON_AddNumberToObject(data, "totalSize", response->total_size); /* 创建文件数组 */ if (response->file_count > 0 && response->files != NULL) { files_array = cJSON_CreateArray(); if (files_array == NULL) { cJSON_Delete(data); cJSON_Delete(root); return -1; } /* 添加文件项到数组 */ for (i = 0; i < response->file_count; i++) { file_item = cJSON_CreateObject(); if (file_item == NULL) { cJSON_Delete(files_array); cJSON_Delete(data); cJSON_Delete(root); return -1; } cJSON_AddStringToObject(file_item, "name", response->files[i].name); cJSON_AddNumberToObject(file_item, "type", response->files[i].type); cJSON_AddNumberToObject(file_item, "size", response->files[i].size); cJSON_AddStringToObject(file_item, "modifiedTime", response->files[i].modified_time); cJSON_AddStringToObject(file_item, "createdTime", response->files[i].created_time); cJSON_AddItemToArray(files_array, file_item); } cJSON_AddItemToObject(data, "files", files_array); } cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); TCP_PRINT("Generated file query response JSON (%d bytes)\r\n", json_len); return json_len; } /** * @brief 生成文件删除响应JSON * @param response 文件删除响应结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_file_delete_response(const tcp_file_delete_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_FILE_OPERATIONS); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "subCommand", FILE_OP_SUBCMD_DELETE); cJSON_AddStringToObject(data, "path", response->path); cJSON_AddNumberToObject(data, "status", response->status); cJSON_AddStringToObject(data, "message", response->message); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); TCP_PRINT("Generated file delete response JSON (%d bytes)\r\n", json_len); return json_len; } /** * @brief 生成文件下载响应JSON * @param response 文件下载响应结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_file_download_response(const tcp_file_download_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_FILE_OPERATIONS); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "subCommand", FILE_OP_SUBCMD_DOWNLOAD); cJSON_AddStringToObject(data, "path", response->path); cJSON_AddNumberToObject(data, "fileSize", response->file_size); cJSON_AddNumberToObject(data, "offset", response->offset); cJSON_AddNumberToObject(data, "chunkSize", response->chunk_size); cJSON_AddNumberToObject(data, "dataLen", response->data_len); cJSON_AddNumberToObject(data, "isLastChunk", response->is_last_chunk); /* 添加数据字段：文件块经 Base64 编码后写入，避免日志中的控制字符/非 UTF-8 导致 JSON 非法 */ if (response->data != NULL && response->data_len > 0) { uint32_t b64_size = ((response->data_len + 2) / 3) * 4 + 1; char *b64_buf = (char *)pvPortMalloc(b64_size); if (b64_buf != NULL) { if (base64_encode(response->data, response->data_len, b64_buf, b64_size) > 0) { cJSON_AddStringToObject(data, "data", b64_buf); } else { cJSON_AddStringToObject(data, "data", ""); } vPortFree(b64_buf); } else { cJSON_AddStringToObject(data, "data", ""); } } else { cJSON_AddStringToObject(data, "data", ""); } cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); TCP_PRINT("Generated file download response JSON (%d bytes)\r\n", json_len); return json_len; } /** * @brief 生成文件上传响应JSON * @param response 文件上传响应结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_file_upload_response(const tcp_file_upload_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_FILE_OPERATIONS); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddStringToObject(data, "subCommand", FILE_OP_SUBCMD_UPLOAD); cJSON_AddStringToObject(data, "path", response->path); cJSON_AddNumberToObject(data, "receivedSize", response->received_size); cJSON_AddNumberToObject(data, "totalSize", response->total_size); cJSON_AddNumberToObject(data, "status", response->status); cJSON_AddStringToObject(data, "message", response->message); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); TCP_PRINT("Generated file upload response JSON (%d bytes)\r\n", json_len); return json_len; } /** * @brief 处理文件操作请求 * @param fileOperation 文件操作数据结构体指针 * @retval 0成功，-1失败 */ int tcp_process_file_operation(const tcp_file_operation_data_t *fileOperation) { if (fileOperation == NULL) { return -1; } TCP_PRINT("Processing file operation: subCommand=%s\r\n", fileOperation->subCommand); /* 根据子命令处理 */ if (strcmp(fileOperation->subCommand, FILE_OP_SUBCMD_QUERY) == 0) { TCP_PRINT("File query operation:\r\n"); TCP_PRINT(" Path: %s\r\n", fileOperation->request.query.path); /* 调用system_filectrl模块处理文件查询 */ tcp_file_query_response_t response; memset(&response, 0, sizeof(response)); if (system_filectrl_process_query((const file_query_request_t *)&fileOperation->request.query, (file_query_response_t *)&response) != 0) { TCP_PRINT("Failed to query files\r\n"); return -1; } /* 生成响应JSON并发送 */ char response_json[2048]; int json_len = tcp_generate_file_query_response(&response, response_json, sizeof(response_json)); if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("File query response sent successfully\r\n"); } else { TCP_PRINT("Failed to send file query response: %d\r\n", send_err); } } else { TCP_PRINT("Failed to generate file query response JSON\r\n"); } /* 释放动态分配的内存 - 使用专门的释放函数 */ system_filectrl_free_query_response((file_query_response_t *)&response); } else if (strcmp(fileOperation->subCommand, FILE_OP_SUBCMD_DELETE) == 0) { TCP_PRINT("File delete operation:\r\n"); TCP_PRINT(" Path: %s\r\n", fileOperation->request.delete.path); /* 调用system_filectrl模块处理文件删除 */ tcp_file_delete_response_t response; memset(&response, 0, sizeof(response)); if (system_filectrl_process_delete((const file_delete_request_t *)&fileOperation->request.delete, (file_delete_response_t *)&response) != 0) { TCP_PRINT("Failed to delete file\r\n"); return -1; } /* 生成响应JSON并发送 */ char response_json[512]; int json_len = tcp_generate_file_delete_response(&response, response_json, sizeof(response_json)); if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("File delete response sent successfully\r\n"); } else { TCP_PRINT("Failed to send file delete response: %d\r\n", send_err); } } else { TCP_PRINT("Failed to generate file delete response JSON\r\n"); } } else if (strcmp(fileOperation->subCommand, FILE_OP_SUBCMD_DOWNLOAD) == 0) { TCP_PRINT("File download operation:\r\n"); TCP_PRINT(" Path: %s\r\n", fileOperation->request.download.path); TCP_PRINT(" Offset: %u\r\n", fileOperation->request.download.offset); TCP_PRINT(" Chunk size: %u\r\n", fileOperation->request.download.chunk_size); /* 调用system_filectrl模块处理文件下载 */ tcp_file_download_response_t response; memset(&response, 0, sizeof(response)); if (system_filectrl_process_download((const file_download_request_t *)&fileOperation->request.download, (file_download_response_t *)&response) != 0) { TCP_PRINT("Failed to download file\r\n"); return -1; } /* 生成响应JSON并发送 */ char response_json[2048]; /* 需要足够大以容纳Base64数据 */ int json_len = tcp_generate_file_download_response(&response, response_json, sizeof(response_json)); if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("File download response sent successfully\r\n"); } else { TCP_PRINT("Failed to send file download response: %d\r\n", send_err); } } else { TCP_PRINT("Failed to generate file download response JSON\r\n"); } /* 释放动态分配的内存 - 使用专门的释放函数 */ system_filectrl_free_download_response((file_download_response_t *)&response); } else if (strcmp(fileOperation->subCommand, FILE_OP_SUBCMD_UPLOAD) == 0) { TCP_PRINT("File upload operation:\r\n"); TCP_PRINT(" Path: %s\r\n", fileOperation->request.upload.path); TCP_PRINT(" Offset: %u\r\n", fileOperation->request.upload.offset); TCP_PRINT(" File size: %u\r\n", fileOperation->request.upload.file_size); TCP_PRINT(" Data length: %u bytes (Base64)\r\n", (uint32_t)strlen((const char *)fileOperation->request.upload.data)); /* 调用system_filectrl模块处理文件上传 */ tcp_file_upload_response_t response; memset(&response, 0, sizeof(response)); if (system_filectrl_process_upload((const file_upload_request_t *)&fileOperation->request.upload, (file_upload_response_t *)&response) != 0) { TCP_PRINT("Failed to upload file\r\n"); return -1; } /* 生成响应JSON并发送 */ char response_json[512]; int json_len = tcp_generate_file_upload_response(&response, response_json, sizeof(response_json)); if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("File upload response sent successfully\r\n"); } else { TCP_PRINT("Failed to send file upload response: %d\r\n", send_err); } } else { TCP_PRINT("Failed to generate file upload response JSON\r\n"); } } else { TCP_PRINT("Unknown file operation subCommand: %s\r\n", fileOperation->subCommand); return -1; } return 0; } /** * @brief 释放消息结构体中分配的内存 * @param message 消息结构体指针 */ void tcp_free_message(tcp_message_t *message) { if (message == NULL) { return; } /* 根据命令类型释放不同的动态分配内存 */ if (strcmp(message->command, CMD_PARAM_MODIFY) == 0) { /* 释放参数修改请求中的参数数组 */ if (message->data.paramModify.params != NULL) { vPortFree(message->data.paramModify.params); message->data.paramModify.params = NULL; message->data.paramModify.count = 0; } } else if (strcmp(message->command, CMD_FIRMWARE_UPGRADE) == 0) { /* 释放固件升级Data子命令中的数据 */ if (strcmp(message->data.firmwareUpgrade.subCommand, FIRMWARE_SUBCMD_DATA) == 0) { if (message->data.firmwareUpgrade.u.data.data != NULL) { vPortFree(message->data.firmwareUpgrade.u.data.data); message->data.firmwareUpgrade.u.data.data = NULL; message->data.firmwareUpgrade.u.data.data_len = 0; } } } /* 注意：文件操作中的内存由专门的释放函数处理，不需要在这里释放 */ } /** * @brief 处理故障信息消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_fault_info_message(const tcp_message_t *message) { tcp_fault_info_response_t response; char *response_json = NULL; int json_len = 0; int result = 0; TCP_PRINT("Received fault info request: faultCode=%s\r\r\n", message->data.faultInfo.faultCode); /* 处理故障信息请求 */ memset(&response, 0, sizeof(response)); /* 调用v_get_fault_data函数获取故障数据 */ tcp_get_system_fault_data(&response); /* 动态分配响应JSON缓冲区 */ response_json = (char *)pvPortMalloc(2048); if (response_json == NULL) { TCP_PRINT("Failed to allocate memory for response JSON\r\r\n"); result = -1; goto cleanup; } /* 生成响应JSON */ json_len = tcp_generate_fault_info_json(&response, response_json, 2048); if (json_len > 0) { TCP_PRINT("Fault info response generated (%d bytes)\r\r\n", json_len); /* 发送响应到客户端 */ err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("Fault info response sent successfully\r\r\n"); } else { TCP_PRINT("Failed to send fault info response: %d\r\r\n", send_err); result = -1; } } else { TCP_PRINT("Failed to generate fault info response\r\r\n"); result = -1; } cleanup: /* 释放动态分配的内存 */ if (response.faults != NULL) { vPortFree(response.faults); } if (response_json != NULL) { vPortFree(response_json); } return result; } /** * @brief 生成故障信息响应JSON * @param response 故障信息响应结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ static int tcp_generate_fault_info_json(const tcp_fault_info_response_t *response, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; cJSON *faults_array = NULL; cJSON *fault_item = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; int i; if (buffer == NULL || size == 0 || response == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_FAULT_INFO); cJSON_AddNumberToObject(root, "status", 0); /* 成功状态 */ /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } cJSON_AddNumberToObject(data, "faultCount", response->faultCount); /* 创建故障数组 */ if (response->faultCount > 0 && response->faults != NULL) { faults_array = cJSON_CreateArray(); if (faults_array == NULL) { cJSON_Delete(data); cJSON_Delete(root); return -1; } /* 添加故障项到数组 */ for (i = 0; i < response->faultCount; i++) { fault_item = cJSON_CreateObject(); if (fault_item == NULL) { cJSON_Delete(faults_array); cJSON_Delete(data); cJSON_Delete(root); return -1; } cJSON_AddStringToObject(fault_item, "location", response->faults[i].location); cJSON_AddStringToObject(fault_item, "code", response->faults[i].code); cJSON_AddStringToObject(fault_item, "time", response->faults[i].time); cJSON_AddStringToObject(fault_item, "description", response->faults[i].description); cJSON_AddItemToArray(faults_array, fault_item); } cJSON_AddItemToObject(data, "faults", faults_array); } cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } /** * @brief 处理历史记录查询/清除消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_history_operations_message(const tcp_message_t *message) { char *response_json = NULL; int json_len = 0; int result = 0; uint16_t totalCount = 0; uint16_t startIndex = 0; uint16_t fetchCount = 0; uint16_t wantedCount = 0; uint16_t filledCount = 0; uint16_t returnedCount = 0; uint8_t isLastPacket = 1; uint8_t include_time = 0; const tcp_history_operations_data_t *req = NULL; req = &message->data.historyOperations; TCP_PRINT("Received history operations: subCommand=%s, historyType=%s, startIndex=%u, fetchCount=%u, queryId=%u\r\r\n", req->subCommand, req->historyType, req->startIndex, req->fetchCount, (unsigned int)req->queryId); /* 清除响应/查询响应最终都需要 JSON 缓冲区 */ response_json = (char *)pvPortMalloc(2048); if (response_json == NULL) { TCP_PRINT("Failed to allocate memory for history response JSON\r\r\n"); return -1; } memset(response_json, 0, 2048); /* 子命令：Query */ if (strcmp(req->subCommand, HISTORY_OP_SUBCMD_QUERY) == 0) { tcp_history_query_xfer_t *hx = NULL; char (*time_buf)[HISTORY_TIME_STR_SIZE] = NULL; char (*content_buf)[HISTORY_CONTENT_STR_SIZE] = NULL; startIndex = req->startIndex; fetchCount = req->fetchCount; /* 约 13KB+ 传输缓冲放堆上，避免任务栈溢出导致死机 */ hx = (tcp_history_query_xfer_t *)pvPortMalloc(sizeof(tcp_history_query_xfer_t)); if (hx != NULL) { memset(hx, 0, sizeof(*hx)); time_buf = hx->time_buf; content_buf = hx->content_buf; wantedCount = fetchCount; if (wantedCount > HISTORY_QUERY_MAX_RECORDS) { wantedCount = HISTORY_QUERY_MAX_RECORDS; } filledCount = tcp_history_build_records(req->historyType, startIndex, wantedCount, time_buf, content_buf, &include_time, &totalCount); } else { TCP_PRINT("tcp_process_history_operations_message: hx malloc failed (history query)\r\r\n"); totalCount = tcp_history_get_total_count(req->historyType); include_time = (strcmp(req->historyType, "fault") == 0 || strcmp(req->historyType, "charging") == 0) ? 1u : 0u; filledCount = 0u; } /* 按1024字节JSON长度限制裁剪 returnedCount */ returnedCount = 0; /* 逐步尝试：从filledCount开始往下裁剪 */ for (int tryCount = (int)filledCount; tryCount >= 0; --tryCount) { uint16_t tmpReturned = (uint16_t)tryCount; isLastPacket = ((uint16_t)(startIndex + tmpReturned) >= totalCount) ? 1u : 0u; /* 生成 QueryResponse JSON */ cJSON *root = cJSON_CreateObject(); cJSON *data = NULL; cJSON *records = NULL; char timestamp[32] = {0}; char *json_str = NULL; if (root == NULL) { continue; } cJSON_AddStringToObject(root, "version", "2.0"); if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { cJSON_Delete(root); continue; } cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_HISTORY_OPERATIONS); cJSON_AddNumberToObject(root, "status", 0); data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); continue; } cJSON_AddItemToObject(root, "data", data); cJSON_AddStringToObject(data, "subCommand", "QueryResponse"); cJSON_AddStringToObject(data, "historyType", req->historyType); cJSON_AddNumberToObject(data, "queryId", req->queryId); cJSON_AddNumberToObject(data, "startIndex", startIndex); cJSON_AddNumberToObject(data, "totalCount", totalCount); cJSON_AddNumberToObject(data, "returnedCount", tmpReturned); cJSON_AddNumberToObject(data, "isLastPacket", isLastPacket); records = cJSON_CreateArray(); if (records == NULL) { cJSON_Delete(root); continue; } cJSON_AddItemToObject(data, "records", records); for (uint16_t i = 0; i < tmpReturned; i++) { cJSON *rec = cJSON_CreateObject(); if (rec == NULL) { continue; } if (include_time != 0u && time_buf != NULL) { cJSON_AddStringToObject(rec, "time", time_buf[i]); } cJSON_AddStringToObject(rec, "content", (content_buf != NULL) ? content_buf[i] : ""); cJSON_AddItemToArray(records, rec); } json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); continue; } json_len = (int)strlen(json_str); cJSON_free(json_str); /* 1024字节限制：符合才停止 */ if (json_len <= 1024) { /* 重新生成一次，拷贝到 response_json */ json_str = cJSON_PrintUnformatted(root); if (json_str != NULL) { json_len = (int)strlen(json_str); if (json_len + 1 <= 2048) { strncpy(response_json, json_str, 2047); response_json[2047] = '\0'; returnedCount = tmpReturned; } cJSON_free(json_str); } cJSON_Delete(root); break; } cJSON_Delete(root); } /* 若仍未生成合法返回，返回空records也要确保返回 */ if (returnedCount == 0) { /* 生成一个最小 QueryResponse（0条记录） */ cJSON *root = cJSON_CreateObject(); cJSON *data = cJSON_CreateObject(); cJSON *records = cJSON_CreateArray(); char timestamp[32] = {0}; cJSON_AddItemToObject(root, "data", data); cJSON_AddStringToObject(root, "version", "2.0"); if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) == 0) { cJSON_AddStringToObject(root, "timestamp", timestamp); } else { cJSON_AddStringToObject(root, "timestamp", "0"); } cJSON_AddStringToObject(root, "command", CMD_HISTORY_OPERATIONS); cJSON_AddNumberToObject(root, "status", 0); cJSON_AddStringToObject(data, "subCommand", "QueryResponse"); cJSON_AddStringToObject(data, "historyType", req->historyType); cJSON_AddNumberToObject(data, "queryId", req->queryId); cJSON_AddNumberToObject(data, "startIndex", startIndex); cJSON_AddNumberToObject(data, "totalCount", totalCount); cJSON_AddNumberToObject(data, "returnedCount", 0); cJSON_AddNumberToObject(data, "isLastPacket", 1); cJSON_AddItemToObject(data, "records", records); char *json_str = cJSON_PrintUnformatted(root); if (json_str != NULL) { json_len = (int)strlen(json_str); if (json_len + 1 <= 2048) { strncpy(response_json, json_str, 2047); response_json[2047] = '\0'; } cJSON_free(json_str); } cJSON_Delete(root); } if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, (uint16_t)json_len); if (send_err != ERR_OK) { TCP_PRINT("Failed to send history query response: %d\r\r\n", send_err); result = -1; } } else { TCP_PRINT("Failed to generate history query response\r\r\n"); result = -1; } if (hx != NULL) { vPortFree(hx); hx = NULL; } } else if (strcmp(req->subCommand, HISTORY_OP_SUBCMD_CLEAR) == 0) { /* 清除记录 */ uint32_t status = 0; char message[128] = {0}; int clearRet = tcp_history_clear_records(req->historyType, message, (uint32_t)sizeof(message)); status = (clearRet == 0) ? 0u : 1u; /* 生成 ClearResponse JSON */ cJSON *root = cJSON_CreateObject(); cJSON *data = NULL; char timestamp[32] = {0}; if (root == NULL) { vPortFree(response_json); return -1; } cJSON_AddStringToObject(root, "version", "2.0"); if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) == 0) { cJSON_AddStringToObject(root, "timestamp", timestamp); } else { cJSON_AddStringToObject(root, "timestamp", "0"); } cJSON_AddStringToObject(root, "command", CMD_HISTORY_OPERATIONS); cJSON_AddNumberToObject(root, "status", status); data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); vPortFree(response_json); return -1; } cJSON_AddItemToObject(root, "data", data); cJSON_AddStringToObject(data, "subCommand", "ClearResponse"); cJSON_AddStringToObject(data, "historyType", req->historyType); cJSON_AddNumberToObject(data, "queryId", req->queryId); cJSON_AddNumberToObject(data, "status", status); cJSON_AddStringToObject(data, "message", message); char *json_str = cJSON_PrintUnformatted(root); if (json_str != NULL) { json_len = (int)strlen(json_str); if (json_len + 1 <= 2048) { strncpy(response_json, json_str, 2047); response_json[2047] = '\0'; } cJSON_free(json_str); } cJSON_Delete(root); if (json_len > 0) { err_t send_err = tcp_server_send_json(response_json, (uint16_t)json_len); if (send_err != ERR_OK) { TCP_PRINT("Failed to send history clear response: %d\r\r\n", send_err); result = -1; } } else { TCP_PRINT("Failed to generate history clear response\r\r\n"); result = -1; } } else { TCP_PRINT("Unknown history subCommand: %s\r\r\n", req->subCommand); result = -1; } if (response_json != NULL) { vPortFree(response_json); response_json = NULL; } return result; } /** * @brief 处理自定义数据消息 * @param message 消息结构体指针 * @retval 0成功，-1失败 */ static int tcp_process_custom_data_message(const tcp_message_t *message) { tcp_custom_data_t response_data; char *response_json = NULL; int json_len = 0; int result = 0; TCP_PRINT("Received custom data: functionContent=%s, functionField=%s, functionParams=%s\r\r\n", message->data.customData.functionContent, message->data.customData.functionField, message->data.customData.functionParams); /* 处理自定义数据请求 */ memset(&response_data, 0, sizeof(response_data)); /* 调用自定义数据处理函数 */ if (tcp_process_custom_data(&message->data.customData, &response_data) != 0) { TCP_PRINT("Failed to process custom data\r\r\n"); return -1; } /* 动态分配响应JSON缓冲区 */ response_json = (char *)pvPortMalloc(1024); if (response_json == NULL) { TCP_PRINT("Failed to allocate memory for response JSON\r\r\n"); result = -1; goto cleanup; } /* 生成响应JSON */ json_len = tcp_generate_custom_data_json(&response_data, response_json, 1024); if (json_len > 0) { TCP_PRINT("Custom data response generated (%d bytes)\r\r\n", json_len); /* 发送响应到客户端 */ err_t send_err = tcp_server_send_json(response_json, json_len); if (send_err == ERR_OK) { TCP_PRINT("Custom data response sent successfully\r\r\n"); } else { TCP_PRINT("Failed to send custom data response: %d\r\r\n", send_err); result = -1; } } else { TCP_PRINT("Failed to generate custom data response\r\r\n"); result = -1; } cleanup: /* 释放动态分配的内存 */ if (response_json != NULL) { vPortFree(response_json); } return result; } /** * @brief 生成自定义数据JSON * @param customData 自定义数据结构体指针 * @param buffer 输出缓冲区 * @param size 缓冲区大小 * @retval JSON字符串长度，-1表示失败 */ int tcp_generate_custom_data_json(const tcp_custom_data_t *customData, char *buffer, uint32_t size) { cJSON *root = NULL; cJSON *data = NULL; char timestamp[32]; char *json_str = NULL; int json_len = 0; if (buffer == NULL || size == 0 || customData == NULL) { return -1; } /* 生成时间戳 */ if (tcp_generate_timestamp(timestamp, sizeof(timestamp)) != 0) { return -1; } /* 创建JSON对象 */ root = cJSON_CreateObject(); if (root == NULL) { return -1; } cJSON_AddStringToObject(root, "version", "2.0"); cJSON_AddStringToObject(root, "timestamp", timestamp); cJSON_AddStringToObject(root, "command", CMD_CUSTOM_DATA); /* 创建data对象 */ data = cJSON_CreateObject(); if (data == NULL) { cJSON_Delete(root); return -1; } /* 添加自定义数据字段 */ cJSON_AddStringToObject(data, "functionContent", customData->functionContent); cJSON_AddStringToObject(data, "functionField", customData->functionField); cJSON_AddStringToObject(data, "functionParams", customData->functionParams); cJSON_AddItemToObject(root, "data", data); /* 生成JSON字符串 */ json_str = cJSON_PrintUnformatted(root); if (json_str == NULL) { cJSON_Delete(root); return -1; } json_len = strlen(json_str); if (json_len + 1 > size) { cJSON_free(json_str); cJSON_Delete(root); return -1; } /* 复制到输出缓冲区 */ strncpy(buffer, json_str, size); buffer[size - 1] = '\0'; /* 释放内存 */ cJSON_free(json_str); cJSON_Delete(root); return json_len; } #endif