From: 孙春阳 Date: Mon, 24 Nov 2025 08:10:31 +0000 (+0800) Subject: https 下载重构 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=c87ebdef55bd31c70540e56c1466c4c5ea3d5a66;p=mirrors%2FFD230.git https 下载重构 --- diff --git a/code/sdk/files/leiniao/fs/user/system/cat1ota/Cat1pyVersion.txt b/code/sdk/files/leiniao/fs/user/system/cat1ota/Cat1pyVersion.txt index 19c7bdba7..978b4e8e5 100644 --- a/code/sdk/files/leiniao/fs/user/system/cat1ota/Cat1pyVersion.txt +++ b/code/sdk/files/leiniao/fs/user/system/cat1ota/Cat1pyVersion.txt @@ -1 +1 @@ -16 \ No newline at end of file +26 \ No newline at end of file diff --git a/code/sdk/files/leiniao/fs/user/system/cat1ota/cat1Service.py b/code/sdk/files/leiniao/fs/user/system/cat1ota/cat1Service.py new file mode 100644 index 000000000..81c5a3678 --- /dev/null +++ b/code/sdk/files/leiniao/fs/user/system/cat1ota/cat1Service.py @@ -0,0 +1,1131 @@ +# Copyright (c) Quectel Wireless Solution, Co., Ltd.All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + + +# net.getNetMode() +# (0, '460', '11', 7) + +# net.getSignal(1) +# ([99, 99, 255, 255], [-84, -117, -15, 255, -3]) + +# net.nitzTime() +# ('24/02/26 11:17:42 8 0', 1708946262, 0) + + +import usocket +import log +import utime +import slip +# import audio +from machine import UART +import _thread +from queue import Queue +from machine import Pin +from machine import ExtInt +import dataCall +# import voiceCall +import net +import uping +import example +import osTimer +import sim +import modem +import utime +import checkNet +import atcmd +import fota +import request +import ql_fs +import pm +import sms +import ujson + +from usr.EventMesh import eventMesh + +from usr.httpota import httpota +from usr.telecom_dmp import telecomDmpCb +from usr.china_mobile_dmp import chinamobileCb +from usr.tcpserver import TcpServiceInit + +from usr.china_mobile_ai_regulation import aiRegulation +# 设置日志输出级别 +log.basicConfig(level=log.INFO) +clog = log.getLogger("cat1") + +def msg_cb(args): + index = args[1] + storage = args[2] + sms_data = sms.getSaveLoc() + if sms_data == -1: + return + sms_max = sms_data[0][2] + if index != -1: + eventMesh.publish("send_singal_data_toBle",index) + + if index >= sms_max-1:#删除短信 + eventMesh.publish("delete_sms_event")#删除短信 + +sms.setCallback(msg_cb)#sms注册回调 + +CAT1_SERVICE_HEAD = 'FE' #固定head + +PROJECT_NAME = "Cat1SlipUDPService" +PROJECT_VERSION = "PY_SRV_V26" +CONFIG_JSON="/usr/system_config.json" +CURRENT_APP_TYPE="pysrv" + + + + + + +#设置通话音量 +# voiceCall.setVolume(10) +# clog.info("voice call volume {}".format(voiceCall.getVolume())) +lpm_fd = pm.create_wakelock("system_lock", len("system_lock")) +pm.autosleep(1) +pm.wakelock_lock(lpm_fd) +clog.info("create_wakelock {}".format(pm.get_wakelock_num())) +telecomTimerCount = 0 +def get_versionkeyname_by_py(app_type): + return str("{}version".format(app_type)) + +def get_default_versionvalue_by_py(app_type): + if (app_type == "pymain"): + return "PY_MAIN_V2" + elif (app_type == "pyota"): + return "PY_OTA_V14" + elif (app_type == "pysrv"): + return "PY_SRV_V16" + +#如果没有configfile则创建它 +if not ql_fs.path_exists(CONFIG_JSON): + data = {str(get_versionkeyname_by_py(CURRENT_APP_TYPE)):get_default_versionvalue_by_py(CURRENT_APP_TYPE)} + ql_fs.touch(CONFIG_JSON,data) + +def set_version_to_json_config(app_type,keyvalue): + try : + config_data = ql_fs.read_json(CONFIG_JSON) + config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue}) + ql_fs.touch(CONFIG_JSON, config_data) + clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue)) + clog.info("{}".format(config_data)) + except Exception as e: + clog.error("set_version_to_json_config") + +def get_version_from_json_config(app_type): + config_data = ql_fs.read_json(CONFIG_JSON) + keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type)) + clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue)) + return keyvalue + +set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION) + + +# audio.set_qdai_cfg(1,0,0,1,0,0,1,1) + +#GPIO[53] PD MAIN_RTS WAKEUP CAT1 被主控唤醒 +#GPIO[31] PD MAIN_RI RINGING 唤醒主控 + +# GPIOn - GPIO号,int类型,点此查看GPIO引脚编号与物理引脚的映射关系。 + +# direction - 输入输出模式,int类型,IN - 输入模式,OUT - 输出模式。 + +# pullMode - 上下拉模式,int类型,说明如下: +# PULL_DISABLE - 浮空模式 +# PULL_PU - 上拉模式 +# PULL_PD - 下拉模式 + +# level - 引脚电平,int类型,0 - 设置引脚为低电平, 1- 设置引脚为高电平。 +# recvDataPin = Pin(Pin.GPIO53, Pin.IN, Pin.PULL_PU, 0) +def ExtIntfun(args): + # clog.info('### interrupt {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿 + if args[1] == 0: + clog.info("disable autosleep") + # pm.autosleep(0) + pm.wakelock_lock(lpm_fd) + elif args[1] == 1: + clog.info("enable autosleep") + pm.wakelock_unlock(lpm_fd) + # pm.autosleep(1) + # clog.info("recvDataPin={}".format(recvDataPin.read())) +extint = ExtInt(ExtInt.GPIO30, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun) +extint.enable() + + +# 创建gpio对象 +gpioWakeBT = Pin(Pin.GPIO31, Pin.OUT, Pin.PULL_DISABLE, 1) +# 设置输入输出模式 +gpioWakeBT.set_dir(Pin.OUT) + +# 设置引脚电平 +gpioWakeBT.write(1) + +UDP_CMD_GET_CAT1VER = '0' #获取 Cat1 版本号 +UDP_CMD_DIAL_NUMB = '1' #拨打电话 +UDP_CMD_HUNGUP = '2' #挂断电话 +UDP_CMD_ANSWER = '3' #接听电话 +UDP_CMD_CAT1_OTA_UPDATE = '4' #触发Cat1 OTA升级,mcu提供url +UDP_CMD_SEND_SMS = '5' #发送SMS短信,mcu提供电话号及短信内容 +UDP_CMD_GET_TIME = '6' #获取Cat1 时间 ,YYYYMMDD HHmmss zone +UDP_CMD_GET_RECV_NETWORKSTAT = '7' #获取Cat1 信号信息,VOLTE信息,信号强度,SIM卡状态 // 内容同UDP_CMD_GET_NETWORKSTAT,CAT主动发给MCU +UDP_MSG_SMS = '8' # CAT1接收到的SMS信息给MCU,包含电话号及短信内容 +UDP_CMD_ATCMD = '9' # 执行AT指令 +UDP_MSG_CALL_CONNECTED = 'A' # CAT1 电话接听消息 +UDP_MSG_CALL_DISCONNECTED = 'B' # CAT1 电话挂断消息 +UDP_MSG_COMMING_CALL = 'C' # CAT1 来电消息,包含电话号 +UDP_MSG_REPLY = 'F' # 返回值 +UDP_MSG_OTA = 'D' # 返回值 + +class Cat1Service: + AP = 0 # SLIP_INNER + STA = 1 # SLIP_OUTER + + def __init__(self, uart=UART.UART2, mode=AP): + + self.__uart = uart + self.__mode = mode + self.__message = '' + self.__err = 0 + self.__net_connected = 0 + # self.__value = None + self.__wait_resp = 0 + self.__waiting_netstat = 0 + slip.destroy() + clog.info('slip uart={0}'.format (self.__uart)) + + ret = slip.construct(self.__uart, self.__mode, 0) + if ret != 0: + clog.error('slip netif construct fail') + return None + clog.info('slip network card create success') + # self.__queue = Queue(1) + self.__sock = self.__socket_init() + self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ()) + self.telecom_init_flag = 0 + self.telecomTimer = osTimer() + eventMesh.subscribe("cat1_reply_iccid_to_ble",self.cat1_reply_iccid_to_ble) + eventMesh.subscribe("cat1_reply_timesec_to_ble",self.cat1_reply_timesec_to_ble) + + self.iccid_data = "" + self.software_version = "" + self.deletSmsTimer = osTimer() + self.china_mobile_ai_init = 0 + self.volte_switch = 1 #默认是开启VOLTE通话功能 + eventMesh.subscribe("set_dmp_change_mode",self.set_dmp_change_mode) + eventMesh.subscribe("get_dmp_change_mode",self.get_dmp_change_mode) + eventMesh.subscribe("delete_sms_event",self.delete_sms_event) + eventMesh.subscribe("remove_all_sms_cb", self.remove_all_sms_cb)# + eventMesh.subscribe("send_sms_max_to_Ble",self.send_sms_max_to_Ble) + eventMesh.subscribe("get_all_sms_data",self.get_all_sms_data) #获取所有的短信内容 + eventMesh.subscribe("send_singal_data_toBle",self.send_singal_data_toBle) + eventMesh.subscribe("delete_sms_single_data",self.delete_sms_single_data) + + eventMesh.subscribe("get_factory_status",self.get_factory_status) + eventMesh.subscribe("set_factory_status",self.set_factory_status) + eventMesh.subscribe("send_dmp_cm_address_toBLE",self.send_dmp_cm_address_toBLE) + eventMesh.subscribe("set_volte_switch",self.set_volte_switch) + eventMesh.subscribe("get_volte_switch",self.get_volte_switch) + eventMesh.publish("delete_sms_event") + + + self.telecom_dmp_switch = 0 + + self.send_data = [] + self.code_old = 0 + self.code_old_num = 1 + self.tmp_data = [] + self.total_num = 0 + # + self.msg_nums = 0 + self.msg_nums_old = 0 + self.china_mobile_init = 0 + self.factory_status = 0 + self.send_data_q = Queue(100) + self.ack_sem=0 + _thread.start_new_thread(self.Socket_SEND_Thread,()) + # 发数据线程 + return None + + def __socket_init(self): + # 创建一个socket实例 + sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT) + sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1) + # 绑定IP + bind_addr = ('172.16.1.2', 5000) + sock.bind(bind_addr) + sock.settimeout(None) + return sock + + def __socket_reinit(self): + return self.__socket_init() + + def bootup_msg_to_bt(self): + modem_ver = modem.getDevFwVersion() + self.reply_cmd('0F',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver)) + # self.reply_cmd('0F',"VOLUME:{}".format(voiceCall.getVolume())) + self.reply_cmd('0F',"PRODUCT:LEINIAO") + + def btmcu_cmd_handler(self,cmd,parm): + + # cmd = "" + # cmd_tmp= int(cmd_data)#将十进制数转换成int 再转换成十六进制 + # cell_data = hex(cmd_tmp) + # decimal_number = int(cell_data, 16) + # cmd = "%02x"%(decimal_number) # 使用两位表示,不足前面补0 + clog.info(cmd) # 输出: 07 + clog.info("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm)) + if cmd == "00": + clog.info(cmd) + # UDP_CMD_GET_CAT1VER + modem_ver = modem.getDevFwVersion() + self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver)) + elif cmd == "01": + # UDP_CMD_DIAL_NUMB + if eventMesh.publish("get_volte_switch") == 1: #只有BLE开了VOLTE才允许打电话 + # ret = voiceCall.callStart(str(parm)) + # if ret != 0: + # ret = voiceCall.callStart(str(parm)) + ret = 0 + clog.info("ret={} {} {}".format(ret,cmd,parm)) + if ret != 0: + self.reply_cmd('0F',"callcmd_fail") + else: + self.reply_cmd('0F',"callcmd_success") + else: + print("get_volte_switch NO") + self.reply_cmd('0F',"callcmd_fail") + elif cmd == "02": + clog.info(cmd) + # UDP_CMD_HUNGUP + # ret = voiceCall.callEnd() + ret = 0 + # if ret != 0: + # ret = voiceCall.callEnd() + if ret != 0: + self.reply_cmd('0F',"callend_fail") + else: + self.reply_cmd('0F',"callend_success") + elif cmd == "03": + clog.info(cmd) + # UDP_CMD_ANSWER + # ret = voiceCall.callAnswer() + ret = 0 + # if ret != 0: + # ret = voiceCall.callAnswer() + if ret != 0: + self.reply_cmd('0F',"callanswer_fail") + else: + self.reply_cmd('0F',"callanswer_success") + elif cmd == "04": + clog.info(cmd) + elif cmd == "05": + clog.info(cmd) + # UDP_CMD_SEND_SMS + elif cmd == "06": + clog.info(cmd) + # UDP_CMD_GET_TIME + time=utime.localtime() + zone=utime.getTimeZone() + #(2024, 3, 2, 18, 31, 32, 5, 62),8 + # 返回当前时间戳,参数为元组 + # timestamp = utime.mktime(time) + # clog.info(timestamp) + self.reply_cmd('06',"{0}@{1}".format(time,zone)) + elif cmd == "07": + clog.info("cmd ==== 07!") + # UDP_CMD_GET_RECV_NETWORKSTAT + simstat = sim.getStatus() + iccid = sim.getIccid() + imei = modem.getDevImei() + netstat = "0,10,0,10" + netstat_ = net.getState() + if netstat_ != -1 : + netstat = "{},{},{},{}".format(netstat_[0][0],netstat_[0][3],netstat_[1][0],netstat_[1][3]) + # ([voice_state, voice_lac, voice_cid, voice_rat, voice_reject_cause, voice_psc], [data_state, data_lac, data_cid, data_rat, data_reject_cause, data_psc]) + operator = net.operatorName() + signal = net.csqQueryPoll() + clog.info("imei:{0}@sim:{1}@iccid:{2}@oper:{3}@signal:{4}@net:{5}".format(imei,simstat,iccid,operator,signal,netstat)) + self.reply_cmd('07',"imei:{0}@sim:{1}@iccid:{2}@oper:{3}@signal:{4}@net:{5}".format(imei,simstat,iccid,operator,signal,netstat)) + elif cmd == "09": + clog.info("{},{}".format(cmd,parm)) + # UDP_CMD_ATCMD + # net.setModemFun(0) + # net.setModemFun(1) + resp=bytearray(50) + ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10) + if ret == 0: + clog.info("reply:{},ret:{}".format(resp.decode(),ret)) + self.reply_cmd('09',"{}".format(resp.decode())) + else: + clog.info("cmd error ret:{}".format(ret)) + self.reply_cmd('09',"{}".format("at error")) + + elif cmd == "10" or cmd == "12" or cmd == "14": #获取固件版本号或者获取BT保存的SIM卡的ICCID BLE那边是否开启电信入库功能 + if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1 : + if eventMesh.publish("get_dmp_change_mode") == 1: + self.telecom_recv_cmd(cmd,parm) + else: + pass + + if 1:#CHINA_MOBILE_DM_FUN_ENABLE == 1: + if eventMesh.publish("get_dmp_change_mode") > 1: + self.china_mobile_recv_cmd(cmd,parm) + else: + pass + pass + elif cmd == "13": + on = int(parm) + clog.info("set_dmp_change_mode on:{}".format(on)) + eventMesh.publish("set_dmp_change_mode",on) + + elif cmd == "16": + if 1: #CHINA_MOBILE_DM_FUN_ENABLE == 1: + if eventMesh.publish("get_dmp_change_mode") > 1: + self.china_mobile_recv_cmd(cmd,parm) + else: + pass + elif cmd == "17": #用于CAT1恢复出厂需要清空数据的标识通用 + eventMesh.publish("set_factory_status",int(parm)) + elif cmd == "18": + eventMesh.publish("set_dmp_cm_address",str(parm)) + elif cmd == "19": #DTMF功能 + # voiceCall.startDtmf(str(parm),100) #100ms 持续时间 100-1000 + pass + elif cmd == "1A": + eventMesh.publish("set_volte_switch",int(parm)) + elif cmd == "1B": + print("fota {}".format(str(parm).split("and")[0])) + print("fota {}".format(str(parm).split("and")[-1])) + # httpota = httpota() + httpota.run( str(parm).split("and")[0], str(parm).split("and")[-1]) + # eventMesh.publish("set_volte_switch",int(parm)) + # UDP_MSG_OTA + elif cmd == "1C":# + self.read_dev_ai_id() + elif cmd== "1D": + TcpService = TcpServiceInit() + TcpService.start_socket_thread() + elif cmd == "AC":# + if self.ack_sem==1: + self.ack_sem=0 + + + + def telecom_recv_cmd(self,cmd,parm): + if cmd == "10": + self.software_version = str(parm) + eventMesh.publish("set_dev_version",self.software_version) + clog.info("software_version:{},{}".format(self.software_version,parm)) + elif cmd == "12": + pass + elif cmd == "14":# + pass + pass + + def set_volte_switch(self,event,msg): #设置VOLTE开关 + self.volte_switch = int(msg) + + + def get_volte_switch(self,event,msg): #获取VOLTE开关 + + return self.volte_switch + + + def china_mobile_recv_cmd(self,cmd,parm): #移动入库相关指令 + if cmd == "10": + self.software_version = str(parm) + eventMesh.publish("set_dev_version",self.software_version) + clog.info("software_version:{},{}".format(self.software_version,parm)) + elif cmd == "16": #获取BLE mac地址 + eventMesh.publish("set_dev_mac",str(parm)) + clog.info("parm:{}\r\n".format(parm)) + + pass + def get_factory_status(self,event,msg): + return self.factory_status + def set_factory_status(self,event,msg): + self.factory_status = int(msg) + if self.factory_status == 0: #只有为的时候才设置进去 1不再设置 + self.reply_cmd('17',"{}".format(1)) + + def send_dmp_cm_address_toBLE(self,event,msg): + buf_tmp = "address:"+str(msg) + self.reply_cmd('18',"{}".format(buf_tmp)) + + def set_dmp_change_mode(self,event,msg): + self.telecom_dmp_switch = msg + def delete_sms_single_data(self,event,msg): #删除单条信息 + sms.deleteMsg(int(msg)) + + def get_dmp_change_mode(self,event,msg): + return self.telecom_dmp_switch + def delete_sms_event(self,event,msg): + self.deletSmsTimer.start(2*1000,0,self.delete_sms_cb) + def delete_sms_cb(self,*argc): + eventMesh.publish_async("remove_all_sms_cb","",1*1024) + def remove_all_sms_cb(self, event, msg): + clog.info("remove_all_sms_cb\r\n") + msg_nums = sms.getMsgNums() #短信数量 + if msg_nums == -1: + msg_nums = 0 + sms_data = sms.getSaveLoc() + clog.info("{}\r\n".format(sms_data)) + if sms_data == -1: + return + sms_max = sms_data[0][2] #最大存储短信数量 + if sms_max >= msg_nums and sms_max > 0: + sms.deleteMsg(1,4) #删除所有的sms信息 + + def send_singal_data_toBle(self,event,msg): + msg_nums = sms.getMsgNums() #短信数量 + if msg_nums == -1: + msg_nums = 0 + sms_data = sms.getSaveLoc() + if sms_data == -1: + return + sms_max = sms_data[0][2] #最大存储短信数量 + clog.info("recv:{}".format(int(msg))) + message=self.sms_get_message_info(int(msg)) + if message == -1: #说明没有这条短信 + return + message_pdu = sms.decodePdu(message[5],20) + + if message_pdu != -1: #解码出来的内容 + + message_ref = message[0] #编码 + message_total_num = message[1] #总共条数 + message_seq = message[2] #当前第几条 + data = message[5] #内容 + data_len = len(data) #内容长度 + # ref :短信参考标识,同一个标识表明为同一条短信 + # total_num :此条长短信总条数 大于1属于长短信 + # seq :此条短信在长短信中的序号 + # print("message:{} {}\r\n".format(message,message_pdu)) + msg_total = "ref:"+str(message_ref)+"@total_num:"+str(message_total_num)+"@seq:"+str(message_seq)+"@data:"+str(message[5]) + self.reply_cmd('15',msg_total) + + eventMesh.publish("delete_sms_single_data",int(msg)) + + def sms_deal_phone_number(self,args): + data=enumerate(args) + data_str1="" + data_str2="" + data_str3="" + for index,value in data: + if index % 2 == 0: + data_str1=data_str1+value + else: + data_str2=data_str2+value + for i in range(0,len(data_str1)): + data_str3=data_str3+data_str2[i] + data_str3=data_str3+data_str1[i] + return data_str3 + def sms_get_message_info(self,index): + """ + :param index :短信索引值 + :tyoe index :整形 + + :return :元组类型 + 元组内容: + (message_ref,message_total_num,message_seq,sub_message_data,pdu_tye,sub_message_len) + + :message_ref :短信参考标识,同一个标识表明为同一条短信 + :message_total_num :此条长短信总条数 + :message_seq :此条短信在长短信中的序号 + :sub_message_data :词条短信的内容 + :pdu_tye :PDU类型,bit 6标记是否包含用户报文头,长短信需要 + :sub_message_len :此条短信内容长度 + + """ + + message0=sms.searchPduMsg(index) + #print("sms_get_message_info:message0:{}".format(message0)) + if message0 == -1: + return -1 + + sca_num = int(message0[0:2],16) - 1 + data_len = 2 + addr_type= message0[data_len:data_len+1*2] + data_len = data_len+1*2 + + sca = message0[data_len:data_len+sca_num*2] + # 电话号码高低位需要转换 + sca = self.sms_deal_phone_number(sca) + + # if sca_num % 2 == 1: + # print("Get SCA phone {}".format(sca[:-1])) + # else: + # print("Get SCA phone {}".format(sca)) + + data_len = data_len+sca_num*2 + + pdu_tye = int(message0[data_len:data_len+1*2],16) + data_len = data_len+1*2 + + oa_num = int(message0[data_len:data_len+1*2],16) + data_len = data_len+1*2 + oa_addr_type = message0[data_len:data_len+1*2] + data_len = data_len+1*2 + + if oa_num % 2 == 1: + oa_num_t = int((oa_num + 1)/2) + else: + oa_num_t = int((oa_num )/2) + + oa = message0[data_len:data_len+oa_num_t*2] + # 电话号码高低位需要转换 + oa = self.sms_deal_phone_number(oa) + + # if oa_num % 2 == 1: + # print("Get OA phone {}".format(oa[:-1])) + # else: + # print("get OA phone {}".format(oa)) + + data_len = data_len+oa_num_t*2 + pid = message0[data_len:data_len+1*2] + + data_len = data_len+1*2 + dcs = message0[data_len:data_len+1*2] + data_len = data_len+1*2 + scts = message0[data_len:data_len+7*2] + data_len = data_len+7*2 + sub_message_len = int(message0[data_len:data_len+1*2],16) + data_len = data_len+1*2 + sub_message_head = message0[data_len:data_len+6*2] + data_len = data_len+6*2 + + # 或短信用户数据 + sub_message_data = message0[data_len:data_len+sub_message_len*2] + + #长短信 + if ((pdu_tye & 0x40 ) >> 6) == 1: + #长短信,处理长短信用户报文头 + message_ref = int(sub_message_head[6:8],16) + message_total_num = int(sub_message_head[8:10],16) + message_seq = int(sub_message_head[10:12],16) + return [message_ref,message_total_num,message_seq,pdu_tye,sub_message_len,message0] + else: + # 短短信 + return [0,1,1,pdu_tye,sub_message_len,message0] + + + + def send_sms_max_to_Ble(self,event,msg): + msg_nums = sms.getMsgNums()#短信数量 + if msg_nums == -1: + msg_nums = 0 + sms_data = sms.getSaveLoc() + if sms_data != -1: + sms_max = sms_data[0][2]#最大存储短信数量 + self.reply_cmd('15',"@sms_max:"+str(sms_max)+"@current_num:"+str(msg_nums)) + pass + + def get_all_sms_data(self,event,msg): + msg_total = "" + SMS_lis={} + SMS_lis_count = 0 + sms_data = sms.getSaveLoc() + clog.info(sms_data) + if sms_data == -1: + return + sms_max = sms_data[0][2]#最大存储短信数量 + clog.info(sms_max) + self.msg_nums = sms.getMsgNums() + if self.msg_nums_old != self.msg_nums: + self.send_data = [] + self.msg_nums_old = self.msg_nums + if self.send_data == [] : + for i in range(self.msg_nums): + phonenum = "" + data ="" + time = "" + data_len = 0 + message=self.sms_get_message_info(self.msg_nums-i-1) + if message == -1: + break + data = message[5] + sms_data = [] + code = message[0]#编码 + num = message[1]#总共条数 + curren_num = message[2]#当前第几条 + data_len = message[4] + sms_data.append(code)#编码 编码相同是同一条短信的内容 + sms_data.append(num) + sms_data.append(curren_num) + sms_data.append(data) + sms_data.append(data_len) + self.send_data.append(sms_data) + count = len(self.send_data) + for i in range(count): + text = self.send_data[i] + clog.info("text:{} {} {}\r\n".format(text[0],text[1],text[2])) + + msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3]) + self.reply_cmd('17',msg_total) + + # 来电提醒 + def notifyIncomingcall(self, incomming_numb): + self.clear_remain() + __head = '0C' + __message = str(incomming_numb) + self.__Socket_UDP(__head, __message) + # if self.__err == 1 or self.__value[2] != 'OK': + # return -1 + return 0 + + # 电话接听消息 + def notifyConnecteCall(self, phone_numb): + self.clear_remain() + __head = '0A' + __message = str(phone_numb) + self.__Socket_UDP(__head, __message) + # if self.__err == 1 or self.__value[2] != 'OK': + # return -1 + return 0 + + # 电话拒接消息 + def notifyDisconnectCall(self, phone_numb): + self.clear_remain() + __head = '0B' + __message = str(phone_numb) + self.__Socket_UDP(__head, __message) + # if self.__err == 1 or self.__value[2] != 'OK': + # return -1 + return 0 + + def wait_network_ready(self): + if(self.__waiting_netstat == 1): + return 0 + self.__waiting_netstat = 1 + stage, state = checkNet.waitNetworkReady(30) + pm.wakelock_unlock(lpm_fd) + if stage == 3 and state == 1: + clog.info('Network connection successful.') + self.set_network_config() + self.__net_connected = 1 + eventMesh.publish("set_network_state",self.__net_connected) + self.__waiting_netstat = 0 + return 0 + else: + clog.info('Network connection failed, stage={}, state={}'.format(stage, state)) + self.reset_network_config() + self.__net_connected = 0 + eventMesh.publish("set_network_state",self.__net_connected) + + self.__waiting_netstat = 0 + return -1 + + # 查询网卡状态 + def timesync(self,_timesync): + self.clear_remain() + message = str(_timesync) + self.__Socket_UDP('0D', message) + return 0 + + def reply_timesync(self,_timesync): + self.clear_remain() + message = str(_timesync) + self.__Socket_UDP_noreply('0D', message) + return 0 + + def reply_cmd(self,cmd,_timesync): + try : + clog.info('reply_cmd 1') + self.clear_remain() + message = str(_timesync) + clog.info('reply_cmd 2') + self.__Socket_UDP_noreply(cmd, message) + except: + clog.info('reply_cmd') + return 0 + + def clear_remain(self): + # if self.__queue.empty() == False: + # self.__queue.get() + self.__err = 0 + # self.__value = None + #添加路由信息 + def router_add(self, ip='192.168.4.1', mask='255.255.255.0'): + self.ip = ip + self.mask = mask + + return slip.router_add(self.ip, self.mask) + + # 获取slip的网络配置 + def ipconfig(self): + return slip.ipconfig() + + # 设置dns服务器 + def set_dns(self, pri_dns='8.8.8.8', sec_dns='114.114.114.114'): + self.pri_dns = pri_dns + self.sec_dns = sec_dns + return slip.set_dns(self.pri_dns,self.sec_dns) + + # 设置默认网卡 + def set_default_NIC(self, ip_str): + self.ip_str = ip_str + return slip.set_default_netif(self.ip_str) + + def reset_network_config(self): + if (self.__net_connected == 0): + clog.info("skip reset_network_config") + return 0 + Info = dataCall.getInfo(1,0) + clog.info("Info{}".format(Info)) + default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1,请根据实际情况更改 + segment_ip = '172.16.4.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255],请根据实际情况更改 + mask = '255.255.255.0' # 假设子网掩码为255.255.255.0,请根据实际情况更改 + # 配置默认网卡,通过默认网卡进行网络转发 + cat1service.set_default_NIC(default_NIC_ip) + clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip)) + #添加路由规则,只有该网段IP才进行转发 + cat1service.router_add(segment_ip, mask) + + pri_dns = '8.8.8.8' # 假设DNS首选地址为8.8.8.8,请根据实际情况更改 + sec_dns = '114.114.114.114' # 假设DNS备选地址为114.114.114.114,请根据实际情况更改 + # 配置网卡DNS服务器 + cat1service.set_dns(pri_dns, sec_dns) + # 网卡IP信息查询 + cat1service.ipconfig() + + def set_network_config(self): + + + if (self.__net_connected == 1) : + clog.info("skip set_network_config") + return 0 + Info = dataCall.getInfo(1,0) + clog.info("Info{}".format(Info)) + default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1,请根据实际情况更改 + segment_ip = '172.16.1.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255],请根据实际情况更改 + mask = '255.255.255.0' # 假设子网掩码为255.255.255.0,请根据实际情况更改 + # 配置默认网卡,通过默认网卡进行网络转发 + cat1service.set_default_NIC(default_NIC_ip) + clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip)) + #添加路由规则,只有该网段IP才进行转发 + cat1service.router_add(segment_ip, mask) + + pri_dns = '8.8.8.8' # 假设DNS首选地址为8.8.8.8,请根据实际情况更改 + sec_dns = '114.114.114.114' # 假设DNS备选地址为114.114.114.114,请根据实际情况更改 + # 配置网卡DNS服务器 + cat1service.set_dns(pri_dns, sec_dns) + # 网卡IP信息查询 + cat1service.ipconfig() + if eventMesh.publish("get_dmp_change_mode") == 0:#入库功能关闭 + return + if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改 + if eventMesh.publish("get_dmp_change_mode") == 1: + eventMesh.publish("set_network_state",1) + telecomDmpCb.telecom_dmp_power_on_init() + if 1: #CHINA_MOBILE_DM_FUN_ENABLE == 1: + if eventMesh.publish("get_dmp_change_mode") == 2: + eventMesh.publish("set_network_state",1) + if self.china_mobile_init == 1: + return + self.china_mobile_init = 1 + #移动入库的初始化 + chinamobileCb.china_mobile_init() + if eventMesh.publish("get_dmp_change_mode") == 3: + if self.china_mobile_ai_init == 1: + return + self.china_mobile_ai_init = 1 + eventMesh.publish("set_network_state",1) + aiRegulation.AIRegulation_init() + + def cat1_reply_iccid_to_ble(self,event,msg): + ICCID_DATA = str("ICCID:")+str(msg) + self.reply_cmd('11',"{}".format(ICCID_DATA)) + pass + def cat1_reply_timesec_to_ble(self,event,msg): + + self.reply_cmd('14',"REGIST_TIME:{}".format(msg)) + pass + # 释放slip网卡 + def stop(self): + slip.destroy() + return 0 + + def read_dev_ai_id(self): + + IFEXIST = ql_fs.path_exists("/usr/cm_ai_regulation.json") # + if IFEXIST == True: #文件存在 + fileSize = ql_fs.path_getsize('usr/cm_ai_regulation.json') + if fileSize == 0: + + print("设备信息配置文件不存在\r\n") + else: + try: + with open("/usr/cm_ai_regulation.json","r",encoding='utf-8') as fd: + try: + config_data = ujson.load(fd) #转换成json格式 + if len(config_data) != 0: + if "deviceId" in config_data:# + deviceId = str(config_data["deviceId"]) #设备ID + self.reply_cmd('1C',"{}".format(deviceId)) + except Exception as error: + print("配置文件的内容不是json格式 保存数据的时候格式不对\r\n") + except Exception as error: + print("打开配置文件失败\r\n") + + + + + # 封装tlv数据包 + def __pack_tlv_format(self, head, content): + # self.head = head + # self.content = content + if len(content) == 0 or len(content) > 9999 or len(head) != 2: + clog.error('illegal pack tlv content') + return -1 + len_str ='%04d' % len(content) + tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content + return tlv_pack + # 解码tlv数据包 + def __unpack_tlv_format(self, msg): + clog.info('__unpack_tlv_format {}\r\n'.format(msg)) + self.msg = str(msg)[2:]#这是去除head FE + tag = self.msg[0:2] + length = self.msg[2:6] + value = self.msg[6:] + len_str ='%04d' % len(value) + if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]: + clog.error('__unpack_tlv_format err') + return -1 + clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value)) + unpack = (tag,length,value) + return unpack + # socket通信(UDP)模块 + def __Socket_UDP(self, head, content): + # 0 则 __Socket_UDP_write + self.send_data_q.put([head,content]) + def Socket_SEND_Thread(self): + while True: + try: + clog.info("send====") + data=self.send_data_q.get() + self.ack_sem=1 + # # if data[2]: + # self.__Socket_UDP_noreply_write( data[0], data[1]) + # else : + self.__Socket_UDP_write( data[0], data[1]) + + + clog.info("Socket_SEND_Thread data:{} {}".format(data[0],data[1])) + count=20 + + while count & self.ack_sem : + utime.sleep_ms(1) + count=count-1 + # if data[2]: + # self.__Socket_UDP_noreply_write( data[0], data[1]) + # else : + self.__Socket_UDP_write( data[0], data[1]) + + clog.info("Socket_SEND_Thread while data:{} {}".format(data[0],data[1])) + + if data: + clog.info("data ok!!") + else: + clog.error("data error!!") + except Exception : + clog.error("sned Socket >>>") + + def __Socket_UDP_write(self, head, content): + try: + ##self.head = head + # self.content = content + gpioWakeBT.write(0) + utime.sleep_ms(2) + gpioWakeBT.write(1) + utime.sleep_ms(20) + # 消息处理 + msg = self.__pack_tlv_format(head, content) + + # 向服务端发送消息 + server_addr = ('172.16.1.5',1000) + clog.info("__Socket_UDP send msg {}".format(msg)) + self.__err = 0 + self.__sock.sendto(msg,server_addr) + clog.info("__Socket_UDP send 2") + self.__wait_resp = 1 + # data = self.__queue.get() + self.__wait_resp = 0 + # return data + return 1 + except Exception as error: + clog.error(error) + return 0 + + def __Socket_UDP_noreply(self, head, content): + # 1 则 __Socket_UDP_noreply_write + self.send_data_q.put([head,content]) + + def __Socket_UDP_noreply_write(self, head, content): + # self.head = head + # self.content = content + gpioWakeBT.write(0) + utime.sleep_ms(2) + gpioWakeBT.write(1) + utime.sleep_ms(20) + # 消息处理 + msg = self.__pack_tlv_format(head, content) + + # 向服务端发送消息 + server_addr = ('172.16.1.5',1000) + + clog.info("__Socket_UDP_noreply send msg {}".format(msg)) + self.__err = 0 + data_size = self.__sock.sendto(msg,server_addr) + clog.info("self.__sock data_size {}".format(data_size)) + self.__wait_resp = 0 + return 0 + + # socket通信(UDP)模块 + def __Socket_Thread(self): + while True: + try: + clog.info("recv====") + data=self.__sock.recv(1024) + clog.info("data:{}".format(data)) + if data: + value = self.__unpack_tlv_format(data.decode()) + if value != -1: + clog.info('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2])) + if value[1] == 'FF': + self.btmcu_cmd_handler(value[0],value[2]) + else: + # self.__value = value + # self.__queue.put('1') + self.btmcu_cmd_handler(value[0],value[2]) + clog.info("End else Thread") + else: + clog.error("data error!!") + except Exception as recverr: + clog.error("recverr:{}\r\n".format(recverr)) + if "110" in str(recverr): + self.__err = 1 + # if self.__wait_resp == 1: + # self.__queue.put('0') + else: + utime.sleep(1) + self.__sock = self.__socket_reinit() + + + + clog.info("End Socket Thread") + + + + +# UDP_CMD_GET_CAT1VER = '0', // 获取 Cat1 版本号 +# UDP_CMD_DIAL_NUMB = '1', // 拨打电话 +# UDP_CMD_HUNGUP = '2', // 挂断电话 +# UDP_CMD_ANSWER = '3', // 接听电话 +# UDP_CMD_CAT1_OTA_UPDATE = '4', // 触发Cat1 OTA升级,mcu提供url +# UDP_CMD_SEND_SMS = '5', // 发送SMS短信,mcu提供电话号及短信内容 +# UDP_CMD_GET_TIME = '6', // 获取Cat1 时间 ,YYYYMMDD HHmmss zone +# UDP_CMD_GET_NETWORKSTAT = '7', //获取Cat1 信号信息,VOLTE信息,信号强度,SIM卡状态 +# 下文进行系统配置 +clog.info("Cat1Service start") + +cat1service = Cat1Service() + +#send_data_q = Queue(100) + +#voice call callback function +def voice_callback(args): + if args[0] == 10: + if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能 + clog.info('voicecall auto end:') + # voiceCall.callEnd() + else: + # gpioWakeBT.write(1) + cat1service.notifyIncomingcall(args[6]) + elif args[0] == 11: + if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能 + clog.info('voicecall connected, PhoneNO: \n'.format(args[6])) + cat1service.notifyConnecteCall(args[6]) + elif args[0] == 12: + clog.info('voicecall disconnect') + if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能 + clog.info('voicecall disconnected, PhoneNO: \n'.format(args[6])) + cat1service.notifyDisconnectCall(args[6]) + elif args[0] == 13: + clog.info('voicecall is waiting, PhoneNO: \n'.format(args[6])) + elif args[0] == 14: + clog.info('voicecall dialing, PhoneNO: \n'.format(args[6])) + elif args[0] == 15: + clog.info('voicecall alerting, PhoneNO: \n'.format(args[6])) + elif args[0] == 16: + clog.info('voicecall holding, PhoneNO: \n'.format(args[6])) + else: + clog.info('voice_callback , args[0]: \n'.format(args[6])) + +#电话消息反馈 +# voiceCall.setCallback(voice_callback) + + +def checknet_cb(arg): + clog.info("start checktime!!") + # if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次 + # if eventMesh.publish("get_dmp_change_mode") == 1: + # telecomDmpCb.telecom_dmp_power_on_count() + + _thread.start_new_thread(cat1service.wait_network_ready, ()) + # time=utime.localtime() + # zone=utime.getTimeZone() + #(2024, 3, 2, 18, 31, 32, 5, 62),8 + # cat1service.timesync("{0},{1}".format(time,zone)) +# _thread.start_new_thread(cat1service.wait_network_ready, ()) +timer = osTimer() +# checknet_cb(()) +timer.start(30000,1,checknet_cb) + +def bootupmsg_cb(arg): + cat1service.bootup_msg_to_bt() + + +delaybootupmsg_timer = osTimer() +delaybootupmsg_timer.start(1000,0,bootupmsg_cb) + +# def checkpin_cb(arg): +# clog.info("recvDataPin={}".format(recvDataPin.read())) + +# timerCheckRevPin = osTimer() +# timerCheckRevPin.start(1000,1,checkpin_cb) + + + + + + +# while True: +# utime.sleep(5) + + +# uping.ping("172.16.1.5") + # 获取网卡当前工作状态 + +# gpioWakeBT.write(1) +# utime.sleep(1) + +# timesync = net.nitzTime() +# cat1service.timesync(timesync) + + +#url = "http://zzhc.vnet.cn:9998/" + + diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/cat1Service.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/cat1Service.py deleted file mode 100644 index f0d46dc3b..000000000 --- a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/cat1Service.py +++ /dev/null @@ -1,682 +0,0 @@ -import usocket -import log -import utime -import slip -import audio -from machine import UART -import _thread -from queue import Queue -from machine import Pin -from machine import ExtInt -import dataCall -import voiceCall -import net -import osTimer -import sim -import modem -import utime -import checkNet -import atcmd -import ql_fs -import pm -import sms - -from usr.EventMesh import eventMesh - -log.basicConfig(level=log.INFO) -clog = log.getLogger("cat1") - -CAT1_SERVICE_HEAD = 'FE' -PROJECT_NAME = "Cat1SlipUDPService" -PROJECT_VERSION = "PY_SRV_V17" -CONFIG_JSON="/usr/system_config.json" -CURRENT_APP_TYPE="pysrv" - -voiceCall.setVolume(10) -lpm_fd = pm.create_wakelock("system_lock", len("system_lock")) -pm.wakelock_lock(lpm_fd) -telecomTimerCount = 0 -def get_versionkeyname_by_py(app_type): - return str("{}version".format(app_type)) - -def get_default_versionvalue_by_py(app_type): - if (app_type == "pymain"): - return "PY_MAIN_V2" - elif (app_type == "pyota"): - return "PY_OTA_V14" - elif (app_type == "pysrv"): - return "PY_SRV_V16" - -if not ql_fs.path_exists(CONFIG_JSON): - data = {str(get_versionkeyname_by_py(CURRENT_APP_TYPE)):get_default_versionvalue_by_py(CURRENT_APP_TYPE)} - ql_fs.touch(CONFIG_JSON,data) - -def set_version_to_json_config(app_type,keyvalue): - try : - config_data = ql_fs.read_json(CONFIG_JSON) - config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue}) - ql_fs.touch(CONFIG_JSON, config_data) - except Exception as e: - clog.error("set_version_to_json_config") - -def get_version_from_json_config(app_type): - config_data = ql_fs.read_json(CONFIG_JSON) - keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type)) - return keyvalue - -set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION) - - -audio.set_qdai_cfg(1,0,0,1,0,0,1,1) -def ExtIntfun(args): - if args[1] == 0: - pm.wakelock_lock(lpm_fd) - elif args[1] == 1: - pm.wakelock_unlock(lpm_fd) -extint = ExtInt(ExtInt.GPIO22, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun) -extint.enable() - -gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1) -gpioWakeBT.set_dir(Pin.OUT) -gpioWakeBT.write(0) - -UDP_CMD_GET_CAT1VER = '0' -UDP_CMD_DIAL_NUMB = '1' -UDP_CMD_HUNGUP = '2' -UDP_CMD_ANSWER = '3' -UDP_CMD_CAT1_OTA_UPDATE = '4' -UDP_CMD_SEND_SMS = '5' -UDP_CMD_GET_TIME = '6' -UDP_CMD_GET_RECV_NETWORKSTAT = '7' -UDP_MSG_SMS = '8' -UDP_CMD_ATCMD = '9' -UDP_MSG_CALL_CONNECTED = 'A' -UDP_MSG_CALL_DISCONNECTED = 'B' -UDP_MSG_COMMING_CALL = 'C' -UDP_MSG_REPLY = 'F' - -class Cat1Service: - AP = 0 - STA = 1 - def __init__(self, uart=UART.UART4, mode=AP): - self.__uart = uart - self.__mode = mode - self.__message = '' - self.__err = 0 - self.__net_connected = 0 - self.__wait_resp = 0 - self.__waiting_netstat = 0 - slip.destroy() - ret = slip.construct(self.__uart, self.__mode, 0) - if ret != 0: - return None - self.__sock = self.__socket_init() - self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ()) - self.telecom_init_flag = 0 - self.telecomTimer = osTimer() - eventMesh.subscribe("cat1_reply_iccid_to_ble",self.cat1_reply_iccid_to_ble) - eventMesh.subscribe("cat1_reply_timesec_to_ble",self.cat1_reply_timesec_to_ble) - self.iccid_data = "" - self.software_version = "" - self.deletSmsTimer = osTimer() - self.volte_switch = 1 - eventMesh.subscribe("set_dmp_change_mode",self.set_dmp_change_mode) - eventMesh.subscribe("get_dmp_change_mode",self.get_dmp_change_mode) - eventMesh.subscribe("delete_sms_event",self.delete_sms_event) - eventMesh.subscribe("remove_all_sms_cb", self.remove_all_sms_cb) - eventMesh.subscribe("send_sms_max_to_Ble",self.send_sms_max_to_Ble) - eventMesh.subscribe("get_all_sms_data",self.get_all_sms_data) - eventMesh.subscribe("send_singal_data_toBle",self.send_singal_data_toBle) - eventMesh.subscribe("delete_sms_single_data",self.delete_sms_single_data) - eventMesh.subscribe("get_factory_status",self.get_factory_status) - eventMesh.subscribe("set_factory_status",self.set_factory_status) - eventMesh.subscribe("send_dmp_cm_address_toBLE",self.send_dmp_cm_address_toBLE) - eventMesh.subscribe("set_volte_switch",self.set_volte_switch) - eventMesh.subscribe("get_volte_switch",self.get_volte_switch) - eventMesh.publish("delete_sms_event") - self.telecom_dmp_switch = 0 - self.send_data = [] - self.code_old = 0 - self.code_old_num = 1 - self.tmp_data = [] - self.total_num = 0 - self.msg_nums = 0 - self.msg_nums_old = 0 - self.china_mobile_init = 0 - self.factory_status = 0 - self.send_data_q = Queue(100) - self.ack_sem=0 - _thread.start_new_thread(self.Socket_SEND_Thread,()) - return None - - def __socket_init(self): - sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT) - sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1) - bind_addr = ('172.16.1.2', 5000) - sock.bind(bind_addr) - sock.settimeout(None) - return sock - - def __socket_reinit(self): - return self.__socket_init() - - def bootup_msg_to_bt(self): - modem_ver = modem.getDevFwVersion() - self.reply_cmd('0F',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver)) - self.reply_cmd('0F',"VOLUME:{}".format(voiceCall.getVolume())) - - def btmcu_cmd_handler(self,cmd,parm): - if cmd == "00": - modem_ver = modem.getDevFwVersion() - self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver)) - elif cmd == "01": - if eventMesh.publish("get_volte_switch") == 1: - ret = voiceCall.callStart(str(parm)) - if ret != 0: - self.reply_cmd('0F',"callcmd_fail") - else: - self.reply_cmd('0F',"callcmd_success") - else: - self.reply_cmd('0F',"callcmd_fail") - elif cmd == "02": - ret = voiceCall.callEnd() - if ret != 0: - ret = voiceCall.callEnd() - if ret != 0: - self.reply_cmd('0F',"callend_fail") - else: - self.reply_cmd('0F',"callend_success") - elif cmd == "03": - ret = voiceCall.callAnswer() - if ret != 0: - ret = voiceCall.callAnswer() - if ret != 0: - self.reply_cmd('0F',"callanswer_fail") - else: - self.reply_cmd('0F',"callanswer_success") - elif cmd == "06": - time=utime.localtime() - zone=utime.getTimeZone() - self.reply_cmd('06',"{0}@{1}".format(time,zone)) - elif cmd == "07": - simstat = sim.getStatus() - imei = modem.getDevImei() - netstat = "0,10,0,10" - netstat_ = net.getState() - if netstat_ != -1 : - netstat = "{},{},{},{}".format(netstat_[0][0],netstat_[0][3],netstat_[1][0],netstat_[1][3]) - operator = net.operatorName() - signal = net.csqQueryPoll() - self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat)) - elif cmd == "09": - resp=bytearray(50) - ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10) - if ret == 0: - self.reply_cmd('09',"{}".format(resp.decode())) - else: - self.reply_cmd('09',"{}".format("at error")) - - elif cmd == "10" or cmd == "12" or cmd == "14": - if 1: - if eventMesh.publish("get_dmp_change_mode") == 1: - self.telecom_recv_cmd(cmd,parm) - else: - pass - - if 1: - if eventMesh.publish("get_dmp_change_mode") > 1: - self.china_mobile_recv_cmd(cmd,parm) - else: - pass - pass - elif cmd == "13": - on = int(parm) - eventMesh.publish("set_dmp_change_mode",on) - elif cmd == "16": - if 1: - if eventMesh.publish("get_dmp_change_mode") > 1: - self.china_mobile_recv_cmd(cmd,parm) - else: - pass - elif cmd == "17": - eventMesh.publish("set_factory_status",int(parm)) - elif cmd == "18": - eventMesh.publish("set_dmp_cm_address",str(parm)) - elif cmd == "19": - voiceCall.startDtmf(str(parm),100) - elif cmd == "1A": - eventMesh.publish("set_volte_switch",int(parm)) - elif cmd == "AC": - if self.ack_sem==1: - self.ack_sem=0 - - def telecom_recv_cmd(self,cmd,parm): - if cmd == "10": - self.software_version = str(parm) - eventMesh.publish("set_dev_version",self.software_version) - elif cmd == "12": - pass - elif cmd == "14":# - pass - pass - - def set_volte_switch(self,event,msg): - self.volte_switch = int(msg) - - def get_volte_switch(self,event,msg): - return self.volte_switch - - def china_mobile_recv_cmd(self,cmd,parm): - if cmd == "10": - self.software_version = str(parm) - eventMesh.publish("set_dev_version",self.software_version) - elif cmd == "16": - eventMesh.publish("set_dev_mac",str(parm)) - pass - def get_factory_status(self,event,msg): - return self.factory_status - def set_factory_status(self,event,msg): - self.factory_status = int(msg) - if self.factory_status == 0: #只有为的时候才设置进去 1不再设置 - self.reply_cmd('17',"{}".format(1)) - - def send_dmp_cm_address_toBLE(self,event,msg): - buf_tmp = "address:"+str(msg) - self.reply_cmd('18',"{}".format(buf_tmp)) - - def set_dmp_change_mode(self,event,msg): - self.telecom_dmp_switch = msg - def delete_sms_single_data(self,event,msg): #删除单条信息 - sms.deleteMsg(int(msg)) - - def get_dmp_change_mode(self,event,msg): - return self.telecom_dmp_switch - def delete_sms_event(self,event,msg): - self.deletSmsTimer.start(2*1000,0,self.delete_sms_cb) - def delete_sms_cb(self,*argc): - eventMesh.publish_async("remove_all_sms_cb","",1*1024) - def remove_all_sms_cb(self, event, msg): - msg_nums = sms.getMsgNums() - if msg_nums == -1: - msg_nums = 0 - sms_data = sms.getSaveLoc() - if sms_data == -1: - return - sms_max = sms_data[0][2] - if sms_max >= msg_nums and sms_max > 0: - sms.deleteMsg(1,4) - - def send_singal_data_toBle(self,event,msg): - msg_nums = sms.getMsgNums() - if msg_nums == -1: - msg_nums = 0 - sms_data = sms.getSaveLoc() - if sms_data == -1: - return - sms_max = sms_data[0][2] - message=self.sms_get_message_info(int(msg)) - if message == -1: - return - message_pdu = sms.decodePdu(message[5],20) - if message_pdu != -1: - message_ref = message[0] - message_total_num = message[1] - message_seq = message[2] - data = message[5] - data_len = len(data) - msg_total = "ref:"+str(message_ref)+"@total_num:"+str(message_total_num)+"@seq:"+str(message_seq)+"@data:"+str(message[5]) - self.reply_cmd('15',msg_total) - - eventMesh.publish("delete_sms_single_data",int(msg)) - - def sms_deal_phone_number(self,args): - data=enumerate(args) - data_str1="" - data_str2="" - data_str3="" - for index,value in data: - if index % 2 == 0: - data_str1=data_str1+value - else: - data_str2=data_str2+value - for i in range(0,len(data_str1)): - data_str3=data_str3+data_str2[i] - data_str3=data_str3+data_str1[i] - return data_str3 - def sms_get_message_info(self,index): - message0=sms.searchPduMsg(index) - if message0 == -1: - return -1 - - sca_num = int(message0[0:2],16) - 1 - data_len = 2 - addr_type= message0[data_len:data_len+1*2] - data_len = data_len+1*2 - - sca = message0[data_len:data_len+sca_num*2] - sca = self.sms_deal_phone_number(sca) - data_len = data_len+sca_num*2 - - pdu_tye = int(message0[data_len:data_len+1*2],16) - data_len = data_len+1*2 - - oa_num = int(message0[data_len:data_len+1*2],16) - data_len = data_len+1*2 - oa_addr_type = message0[data_len:data_len+1*2] - data_len = data_len+1*2 - - if oa_num % 2 == 1: - oa_num_t = int((oa_num + 1)/2) - else: - oa_num_t = int((oa_num )/2) - - oa = message0[data_len:data_len+oa_num_t*2] - oa = self.sms_deal_phone_number(oa) - data_len = data_len+oa_num_t*2 - pid = message0[data_len:data_len+1*2] - - data_len = data_len+1*2 - dcs = message0[data_len:data_len+1*2] - data_len = data_len+1*2 - scts = message0[data_len:data_len+7*2] - data_len = data_len+7*2 - sub_message_len = int(message0[data_len:data_len+1*2],16) - data_len = data_len+1*2 - sub_message_head = message0[data_len:data_len+6*2] - data_len = data_len+6*2 - sub_message_data = message0[data_len:data_len+sub_message_len*2] - - if ((pdu_tye & 0x40 ) >> 6) == 1: - message_ref = int(sub_message_head[6:8],16) - message_total_num = int(sub_message_head[8:10],16) - message_seq = int(sub_message_head[10:12],16) - return [message_ref,message_total_num,message_seq,pdu_tye,sub_message_len,message0] - else: - return [0,1,1,pdu_tye,sub_message_len,message0] - - - - def send_sms_max_to_Ble(self,event,msg): - msg_nums = sms.getMsgNums() - if msg_nums == -1: - msg_nums = 0 - sms_data = sms.getSaveLoc() - if sms_data != -1: - sms_max = sms_data[0][2] - self.reply_cmd('15',"@sms_max:"+str(sms_max)+"@current_num:"+str(msg_nums)) - pass - - def get_all_sms_data(self,event,msg): - msg_total = "" - SMS_lis={} - SMS_lis_count = 0 - sms_data = sms.getSaveLoc() - if sms_data == -1: - return - sms_max = sms_data[0][2] - self.msg_nums = sms.getMsgNums() - if self.msg_nums_old != self.msg_nums: - self.send_data = [] - self.msg_nums_old = self.msg_nums - if self.send_data == [] : - for i in range(self.msg_nums): - phonenum = "" - data ="" - time = "" - data_len = 0 - message=self.sms_get_message_info(self.msg_nums-i-1) - if message == -1: - break - data = message[5] - sms_data = [] - code = message[0] - num = message[1] - curren_num = message[2] - data_len = message[4] - sms_data.append(code) - sms_data.append(num) - sms_data.append(curren_num) - sms_data.append(data) - sms_data.append(data_len) - self.send_data.append(sms_data) - count = len(self.send_data) - for i in range(count): - text = self.send_data[i] - msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3]) - self.reply_cmd('17',msg_total) - - def notifyIncomingcall(self, incomming_numb): - self.clear_remain() - __head = '0C' - __message = str(incomming_numb) - self.__Socket_UDP(__head, __message) - return 0 - - def notifyConnecteCall(self, phone_numb): - self.clear_remain() - __head = '0A' - __message = str(phone_numb) - self.__Socket_UDP(__head, __message) - return 0 - - def notifyDisconnectCall(self, phone_numb): - self.clear_remain() - __head = '0B' - __message = str(phone_numb) - self.__Socket_UDP(__head, __message) - return 0 - - def wait_network_ready(self): - if(self.__waiting_netstat == 1): - return 0 - self.__waiting_netstat = 1 - stage, state = checkNet.waitNetworkReady(30) - pm.wakelock_unlock(lpm_fd) - if stage == 3 and state == 1: - self.set_network_config() - self.__net_connected = 1 - eventMesh.publish("set_network_state",self.__net_connected) - self.__waiting_netstat = 0 - return 0 - else: - self.reset_network_config() - self.__net_connected = 0 - eventMesh.publish("set_network_state",self.__net_connected) - self.__waiting_netstat = 0 - return -1 - - def timesync(self,_timesync): - self.clear_remain() - message = str(_timesync) - self.__Socket_UDP('0D', message) - return 0 - - def reply_timesync(self,_timesync): - self.clear_remain() - message = str(_timesync) - self.__Socket_UDP_noreply('0D', message) - return 0 - - def reply_cmd(self,cmd,_timesync): - try : - self.clear_remain() - message = str(_timesync) - self.__Socket_UDP_noreply(cmd, message) - except: - clog.info('reply_cmd') - return 0 - - def clear_remain(self): - self.__err = 0 - def router_add(self, ip='192.168.4.1', mask='255.255.255.0'): - self.ip = ip - self.mask = mask - return slip.router_add(self.ip, self.mask) - - def ipconfig(self): - return slip.ipconfig() - - def set_dns(self, pri_dns='8.8.8.8', sec_dns='114.114.114.114'): - self.pri_dns = pri_dns - self.sec_dns = sec_dns - return slip.set_dns(self.pri_dns,self.sec_dns) - - def set_default_NIC(self, ip_str): - self.ip_str = ip_str - return slip.set_default_netif(self.ip_str) - - def reset_network_config(self): - if (self.__net_connected == 0): - return 0 - Info = dataCall.getInfo(1,0) - default_NIC_ip = Info[2][2] - segment_ip = '172.16.4.0' - mask = '255.255.255.0' - cat1service.set_default_NIC(default_NIC_ip) - cat1service.router_add(segment_ip, mask) - - pri_dns = '8.8.8.8' - sec_dns = '114.114.114.114' - cat1service.set_dns(pri_dns, sec_dns) - cat1service.ipconfig() - - def set_network_config(self): - if (self.__net_connected == 1) : - return 0 - Info = dataCall.getInfo(1,0) - default_NIC_ip = Info[2][2] - segment_ip = '172.16.1.0' - mask = '255.255.255.0' - cat1service.set_default_NIC(default_NIC_ip) - cat1service.router_add(segment_ip, mask) - - pri_dns = '8.8.8.8' - sec_dns = '114.114.114.114' - cat1service.set_dns(pri_dns, sec_dns) - cat1service.ipconfig() - if eventMesh.publish("get_dmp_change_mode") == 0: - return - if 1: - if eventMesh.publish("get_dmp_change_mode") == 1: - eventMesh.publish("set_network_state",1) - if 1: - if eventMesh.publish("get_dmp_change_mode") > 1: - eventMesh.publish("set_network_state",1) - if self.china_mobile_init == 1: - return - self.china_mobile_init = 1 - - def cat1_reply_iccid_to_ble(self,event,msg): - ICCID_DATA = str("ICCID:")+str(msg) - self.reply_cmd('11',"{}".format(ICCID_DATA)) - pass - def cat1_reply_timesec_to_ble(self,event,msg): - - self.reply_cmd('14',"REGIST_TIME:{}".format(msg)) - pass - - def stop(self): - slip.destroy() - return 0 - - def __pack_tlv_format(self, head, content): - if len(content) == 0 or len(content) > 9999 or len(head) != 2: - return -1 - len_str ='%04d' % len(content) - tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content - return tlv_pack - - def __unpack_tlv_format(self, msg): - self.msg = str(msg)[2:] - tag = self.msg[0:2] - length = self.msg[2:6] - value = self.msg[6:] - len_str ='%04d' % len(value) - if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]: - return -1 - unpack = (tag,length,value) - return unpack - def __Socket_UDP(self, head, content): - self.send_data_q.put([head,content]) - def Socket_SEND_Thread(self): - while True: - try: - data=self.send_data_q.get() - self.ack_sem=1 - self.__Socket_UDP_write( data[0], data[1]) - count=20 - - while count & self.ack_sem : - utime.sleep_ms(1) - count=count-1 - self.__Socket_UDP_write( data[0], data[1]) - except Exception : - clog.error("sned Socket >>>") - - def __Socket_UDP_write(self, head, content): - try: - gpioWakeBT.write(1) - utime.sleep_ms(2) - gpioWakeBT.write(0) - utime.sleep_ms(20) - msg = self.__pack_tlv_format(head, content) - server_addr = ('172.16.1.5',1000) - self.__err = 0 - self.__sock.sendto(msg,server_addr) - self.__wait_resp = 1 - self.__wait_resp = 0 - return 1 - except Exception as error: - clog.error(error) - return 0 - - def __Socket_UDP_noreply(self, head, content): - self.send_data_q.put([head,content]) - - def __Socket_Thread(self): - while True: - try: - data=self.__sock.recv(1024) - if data: - value = self.__unpack_tlv_format(data.decode()) - if value != -1: - if value[1] == 'FF': - self.btmcu_cmd_handler(value[0],value[2]) - else: - self.btmcu_cmd_handler(value[0],value[2]) - else: - clog.error("data error!!") - except Exception as recverr: - if "110" in str(recverr): - self.__err = 1 - else: - utime.sleep(1) - self.__sock = self.__socket_reinit() -cat1service = Cat1Service() - -def voice_callback(args): - if args[0] == 10: - if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能 - voiceCall.callEnd() - else: - cat1service.notifyIncomingcall(args[6]) - elif args[0] == 11: - if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能 - cat1service.notifyConnecteCall(args[6]) - elif args[0] == 12: - if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能 - cat1service.notifyDisconnectCall(args[6]) -voiceCall.setCallback(voice_callback) -def checknet_cb(arg): - _thread.start_new_thread(cat1service.wait_network_ready, ()) -timer = osTimer() -timer.start(30000,1,checknet_cb) - -def bootupmsg_cb(arg): - cat1service.bootup_msg_to_bt() - -delaybootupmsg_timer = osTimer() -delaybootupmsg_timer.start(1000,0,bootupmsg_cb) - - - diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/china_mobile_dmp.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/china_mobile_dmp.py deleted file mode 100644 index 632476ec2..000000000 --- a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/china_mobile_dmp.py +++ /dev/null @@ -1,17 +0,0 @@ -import log - -# 设置日志输出级别 -log.basicConfig(level=log.INFO) -fota_log = log.getLogger("china_mobile") - - - - - - - - - - - - diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/is_need_updata.txt b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/is_need_updata.txt deleted file mode 100644 index e69de29bb..000000000 diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/main.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/main.py deleted file mode 100644 index ab14d8bf5..000000000 --- a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/main.py +++ /dev/null @@ -1,27 +0,0 @@ -import example -import log -from machine import UART - -# 设置日志输出级别 -log.basicConfig(level=log.INFO) -# 设置输出到debug口 -uart = UART(UART.UART0, 115200, 8, 0, 1, 0) -log.set_output(uart) -clog = log.getLogger("cat1") - -main_flag = 1 - - -try: - example.exec('/usr/main_init.py') - clog.info("启动main_init成功!!!!!\r\n") -except Exception as e: - main_flag = 0 - clog.error("启动失败!!!!!\r\n".format(e)) - -try: - example.exec('/usr/tcpserver.py') - clog.info("启动tcpserver成功!!!!!\r\n") -except Exception as e: - clog.error("启动失败!!!!!\r\n".format(e)) - diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/tcpserver.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/tcpserver.py deleted file mode 100644 index afe23b2c1..000000000 --- a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/tcpserver.py +++ /dev/null @@ -1,602 +0,0 @@ -from misc import Power -import usocket -import log -import utime -from machine import UART -import _thread -from queue import Queue -from machine import Pin -from machine import ExtInt -import osTimer -import utime -import ql_fs -import binascii -import ujson -import uos - - -log.basicConfig(level=log.INFO) -clog = log.getLogger("cat1") - -USR_FILE_PATH = "/usr" # -BAK_FILE_PATH = "{}/TmpPyFile".format(USR_FILE_PATH) -BAK_FILE_TMP = "_bak" -CAT1_SERVICE_HEAD = "FE" -CAT1_FILE_DATA_HEAD = "FF" -CAT1_REPLAY_STATE="00" -CAT1_CREAT_DIR_FAILE= "01" -CAT1_CREAT_DIR_OK= "02" -CAT1_NO_REPLAY_OTA_OK= "03" -CAT1_WRITE_FILE_SUCC= "04" -CAT1_WRITE_FILE_ERROR = "05" -CAT1_CRC_ERROR = "06" -CAT1_SEND_HEAD_ERR = "07" -CAT1_OTA_TIMEOUT_BLE_NO_REPLAY = "08" -CAT1_CREAT_FILE_ERROR = "09" -CAT1_CREAT_FILE_SUCC = "0A" -CAT1_ALLPY_FILE_TRANSFER_END = "0B" -CAT1_REPLAY_OTA_SUCC = "0C" -CAT1_REPLAY_OTA_FALIE = "0D" -CAT1_REPLAY_FILE_SIZE_OK = "0E" -CAT1_REPLAY_FILE_SIZE_ERR = "0F" -CAT1_REPLAY_OTA_END_FAILE = "10" -CAT1_NEED_UPDATE_OTA = "11" -CAT1_TCP_STOP_OTA = 0 -CAT1_TCP_START_OTA = 1 -CAT1_TCP_START_SEND_SINGLE_FILE_INFO= 2 -CAT1_TCP_START_SEND_FILE_DATA= 3 -CAT1_TCP_START_OTA_FAILE = 4 -CAT1_TCP_START_OTA_SUCC = 5 -CAT1_TCP_START_SEND_ALLFILE_FINESH = 6 -CAT1_TCP_SEND_SINGLE_FINESH = 7 -CAT1_TCP_START_ERROR_INFO = 255 - -gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1) -gpioWakeBT.set_dir(Pin.OUT) -gpioWakeBT.write(0) -FILE_TRANSFER_TIMEOUT=60 -class TcpServiceInit: - AP = 0 - STA = 1 - - def __init__(self, uart=UART.UART4, mode=AP): - self.__uart = uart - self.__mode = mode - self.Cat1FileState = 0 - self.Cat1FileReplayBle = 0 - self.Cat1TimeCount = 0 - self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT - self.Cat1FileTransTimer = osTimer() - self.Cat1OtaTimeOut = osTimer() - self.crc_err = 0 - self.allPyRecvFlag = 0 - self.ota_state =0 - self.ota_bstate =0 - self.fileNameTmp = "" - self.fileNameList = [] - self.fileSizeList = [] - self.fileSize = 0 - self.updateTimer = osTimer() - self.updateTimerCount = 0 - self.updateTimerFlag = 0 - self.sock = None - self.bakFlag = "0" - self.conn= None - self.__sock_file = None - self.__sock_file = self.__socket_file_init() - self.__thread_file = _thread.start_new_thread(self.__Socket_File_Thread, ()) - self.conn_thread=_thread.start_new_thread(self._client_conn_proc, ()) - - def __pack_tlv_format(self, head, content): - head1 = head - content1 = content - if len(content1) == 0 or len(content1) > 9999 or len(head1) != 2: - return -1 - len_str ='%04d' % len(content1) - tlv_pack = CAT1_SERVICE_HEAD+head1+len_str+content1 - return tlv_pack - - def __unpack_tlv_format(self, msg): - msg_tmp = str(msg)[2:] - tag = msg_tmp[0:2] - length = msg_tmp[2:6] - value = msg_tmp[6:] - len_str ='%04d' % len(value) - if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != msg_tmp[2:6]: - return -1 - unpack = (tag,length,value) - return unpack - - def __socket_file_init(self): - self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER) - self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1) - bind_addr = ('172.16.1.2', 5001) - self.sock.bind(bind_addr) - self.sock.listen(10) - return self.sock - - def __Socket_TCP_file_noreply(self, head, content): - head1 = head - content1 = content - gpioWakeBT.write(1) - utime.sleep_ms(2) - gpioWakeBT.write(0) - utime.sleep_ms(20) - msg = self.__pack_tlv_format(head1,content1) - if msg == -1: - return 0 - try: - self.conn.send(msg) - except Exception as e: - clog.info("self.__sock_file error {}".format(e)) - return 0 - - def _client_conn_proc(self): - while True: - if self.conn==None: - utime.sleep_ms(20) - continue - try: - data = self.conn.recv(1024) - if not data: - clog.info("__Socket_File_Thread data null:\r\n") - else: - self.src_data(data.decode('uft-8')) - except: - self.conn.close() - break - - def __Socket_File_Thread(self): - while True: - try : - cli_conn, cli_ip_addr, cli_port = self.__sock_file.accept() - self.conn=cli_conn - clog.info('[serveice] accept a client: %s, %s' % (cli_ip_addr, cli_port)) - except : - utime.sleep_ms(20) - - def cat1FileTimerCb(self,*argc): - clog.info("timer test\r\n") - if self.Cat1PyFileTimout > 0: - self.Cat1PyFileTimout-=1 - if self.Cat1PyFileTimout == 0: - self.Cat1PyFileTimout = 0 - self.Cat1FileState = 0 - self.deleteTmpFile() - self.deleteUsrTmpFile() - self.__Socket_TCP_file_noreply(CAT1_OTA_TIMEOUT_BLE_NO_REPLAY,"ota error") #结束文件接收不完整的 - self.Cat1FileTransTimer.stop() - pass - - def crc_cal(self,msg): - bytes_data = msg.encode('utf-8') - hex_data = binascii.hexlify(bytes_data) - hex_data = hex_data.decode() - data = hex_data - crcValue = 0 - j = 0 - i = 0 - json_state = 0 - crcbuf = 0 - data_len = len(str(data)) - try: - if data_len % 2 != 0: - json_state = 0 - return [json_state,crcbuf] - except Exception as e: - json_state = 0 - for i in range(data_len): - if j >= data_len: - break - try: - decimal_number = int(str(data[j:j+2]), 16) - crcValue=crcValue+decimal_number - crcValue = crcValue&0xff - except Exception as e: - clog.info("crc_cal") - j+=2 - crcbuf = crcValue%256 - crcbuf = 256-crcbuf - crcbuf = crcbuf%256 - return [json_state,"%02x"%(crcbuf)] - def deleteTmpFile(self): - tmp_dir = ql_fs.path_exists(BAK_FILE_PATH) - if tmp_dir == True: - ql_fs.rmdirs(BAK_FILE_PATH) - - def deleteUsrTmpFile(self): - return - - def src_data(self,data): - if self.updateTimerFlag == 0: - self.updateTimerFlag = 1 - self.updateTimer.stop() - msg = "" - json_state = 0 - try: - msg = ujson.loads(data) - json_state = 1 - except Exception as e: - json_state = 0 - if json_state == 0: - value = self.__unpack_tlv_format(data) - self.cmd_data(value[0],value[2]) - return - else: - self.file_data(msg) - pass - def cmd_data(self,cmd,parm): - if cmd == "01": - self.bakFlag = str(parm) - pass - def file_data(self,msg): - if "Code" in msg: - Code = int(msg["Code"]) - if Code == CAT1_TCP_STOP_OTA: - self.allPyRecvFlag = 0 - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.deleteTmpFile() - self.deleteUsrTmpFile() - pass - elif Code == CAT1_TCP_START_OTA: - self.ota_state =0 - self.ota_bstate =0 - self.allPyRecvFlag = 0 - self.fileNameList = [] - self.fileSizeList = [] - self.allPyRecvFlag = 0 - self.Cat1FileState = 0 - self.deleteUsrTmpFile() - self.Cat1OtaTimeOut.stop() - check_dir = ql_fs.path_exists(BAK_FILE_PATH) - mk_dir_state = 0 - if check_dir == True: - try: - self.deleteTmpFile() - except Exception as e: - clog.info("移除失败\r\n") - check_dir = ql_fs.path_exists(BAK_FILE_PATH) - if check_dir == False: - try: - ql_fs.mkdirs(BAK_FILE_PATH) - mk_dir_state = 1 - except Exception as e: - mk_dir_state = 0 - else: - mk_dir_state = 1 - if mk_dir_state == 0: - self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat dir error!") - else: - self.Cat1FileState = 1 - self.fileNameList = [] - self.fileSizeList = [] - self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT - self.Cat1FileTransTimer.stop() - self.Cat1FileTransTimer.start(1000,1,self.cat1FileTimerCb) - self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_OK,"creat dir success!") - - elif Code == CAT1_TCP_START_SEND_SINGLE_FILE_INFO and self.Cat1FileState == 1: - self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT - self.fileNameTmp = str(msg["fileName"]) - self.fileSize = msg["fileSize"] - self.fileNameList = msg["fileNameList"] - path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp) - check_touch = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)) - if check_touch == True: - try: - uos.remove("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)) - except Exception as e: - clog.info("移除文件失败\r\n") - try: - with open(path,"w+") as fd: - fd.write("") - fd.close() - self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"1creat file or dir success!") - except Exception as e: - self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"1creat file or dir err!") - else: - try: - with open(path,"w+") as fd: - fd.write("") - fd.close() - self.crc_err = 0 - - self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"2creat file or dir success!") - except Exception as e: - self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"2creat file or dir err!") - - - elif Code == CAT1_TCP_START_SEND_FILE_DATA and self.Cat1FileState == 1: - self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT - if len(self.fileNameTmp) == 0: - return - data = msg["data"] - if len(data) == 0: - return - tmpdata = str(data) - head = tmpdata[0:2] - if head != CAT1_FILE_DATA_HEAD or len(tmpdata) <= 8: - clog.info("head {}\r\n".format(head)) - self.__Socket_TCP_file_noreply(CAT1_SEND_HEAD_ERR,"head error!") - return - datalen = str(tmpdata[2:6]) - datalen = int("0x" + datalen, 16) - data_buf = tmpdata[6:] - data_buf = data_buf[:-2] - crc = tmpdata[-2:] - if len(str(data_buf)) == 0 or len(str(data_buf)) != datalen: - self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"crc error or data null!") - return - data = str(data_buf) - path = "{}/{}".format(BAK_FILE_PATH,str(self.fileNameTmp)) - try: - with open(path,"a") as fd: - fd.write(data) - fd.close() - self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_SUCC,"write file success!") - - except Exception as e: - self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!") - - elif Code == CAT1_TCP_START_OTA_FAILE and self.Cat1FileState == 1: - self.allPyRecvFlag = 0 - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"OTA FAILE") - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.deleteTmpFile() - self.deleteUsrTmpFile() - pass - elif Code == CAT1_TCP_START_SEND_ALLFILE_FINESH and self.Cat1FileState == 1: - if self.bakFlag == "0": - if self.allPyRecvFlag == 1: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - else: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.Cat1OtaTimeOut.stop() - self.Cat1TimeCount = 0 - self.ota_state = 1 - self.allPyRecvFlag = 1 - self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut) - return - tmp_dir = ql_fs.path_exists(BAK_FILE_PATH) - if tmp_dir == True: - filenamesList = uos.listdir(BAK_FILE_PATH) - list1 = sorted(filenamesList) - list2 = sorted(self.fileNameList) - if list1 != list2: - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.deleteUsrTmpFile() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") - return - try: - copy_state = 1 - compare_flag = 1 - copy_flag = 0 - filenamesList = uos.listdir(BAK_FILE_PATH) - for tmp in filenamesList: - dst_path = "{}/{}".format(USR_FILE_PATH,tmp) - src_path = "{}/{}".format(BAK_FILE_PATH,tmp) - ret = False - file_size = 0 - try: - ret = ql_fs.file_copy(dst_path,src_path) - - if ret == True: - dstfile_size = ql_fs.path_getsize(dst_path) - srcfile_size = ql_fs.path_getsize(src_path) - if dstfile_size != srcfile_size: - compare_flag = 0 - break - else: - try: - compare_flag = 1 - uos.remove(src_path) - filenamesList = uos.listdir(BAK_FILE_PATH) - except Exception as e: - clog.info("copy file \r\n") - else: - compare_flag = 0 - break - except Exception as e: - clog.info("copy file \r\n") - - if copy_state == 0 or compare_flag == 0 : - self.deleteUsrTmpFile() - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") - return - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.Cat1OtaTimeOut.stop() - self.Cat1TimeCount = 0 - self.ota_state = 1 - self.allPyRecvFlag = 1 - self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut) - except Exception as e: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") - self.deleteUsrTmpFile() - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - else: - if self.ota_state == 1: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - pass - else: - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.deleteUsrTmpFile() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") - - elif Code == CAT1_TCP_START_OTA_SUCC and self.Cat1FileState == 1: - if self.bakFlag == "0": - self.deleteUsrTmpFile() - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - if self.allPyRecvFlag == 1: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - else: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") - return - - if self.allPyRecvFlag == 0: - self.deleteTmpFile() - self.deleteUsrTmpFile() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") - return - tmp_dir = ql_fs.path_exists(BAK_FILE_PATH) - if tmp_dir == True: - filenamesList = uos.listdir(BAK_FILE_PATH) - list1 = sorted(filenamesList) - list2 = sorted(self.fileNameList) - if list1 != list2: - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.deleteUsrTmpFile() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") - return - - try: - copy_state = 1 - compare_flag = 1 - filenamesList = uos.listdir(BAK_FILE_PATH) - for tmp in filenamesList: - dst_path = "{}/{}".format(USR_FILE_PATH,tmp) - src_path = "{}/{}".format(BAK_FILE_PATH,tmp) - ret = False - file_size = 0 - try: - ret = ql_fs.file_copy(dst_path,src_path) - if ret == True: - dstfile_size = ql_fs.path_getsize(dst_path) - srcfile_size = ql_fs.path_getsize(src_path) - if dstfile_size != srcfile_size: - compare_flag = 0 - break - else: - try: - compare_flag = 1 - uos.remove(src_path) - filenamesList = uos.listdir(BAK_FILE_PATH) - except Exception as e: - clog.info("file\r\n") - else: - compare_flag = 0 - break - - except Exception as e: - clog.info("file\r\n") - if copy_state == 0 or compare_flag == 0 : - self.deleteUsrTmpFile() - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") - return - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.Cat1OtaTimeOut.stop() - self.Cat1TimeCount = 0 - self.ota_bstate = 1 - self.conn.close() - self.Cat1OtaTimeOut.start(10000,0,self.otaTimeOut) - except Exception as e: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") - self.deleteUsrTmpFile() - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - else: - if self.ota_bstate == 1: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") - pass - else: - self.deleteTmpFile() - self.Cat1FileState = 0 - self.Cat1FileTransTimer.stop() - self.deleteUsrTmpFile() - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") - - elif Code == CAT1_TCP_SEND_SINGLE_FINESH and self.Cat1FileState == 1: - self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT - tmp_dir = ql_fs.path_exists(BAK_FILE_PATH) - if tmp_dir == True: - tmp_file = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)) - if tmp_file == True: - file_size = ql_fs.path_getsize("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)) - if self.fileSize != file_size: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") - else: - if self.bakFlag == "0": - dst_path = "{}/{}".format(USR_FILE_PATH,self.fileNameTmp) - src_path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp) - ret = False - try: - ret = ql_fs.file_copy(dst_path,src_path) - if ret == True: - dstfile_size = ql_fs.path_getsize(dst_path) - srcfile_size = ql_fs.path_getsize(src_path) - if dstfile_size != srcfile_size: - src_file = ql_fs.path_exists(src_path) - if src_file == True: - try: - uos.remove(src_path) - except Exception as e: - clog.info("copy 文件异常出错 yichu!{}:\r\n".format(e)) - self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") - return - else: - src_file = ql_fs.path_exists(src_path) - if src_file == True: - try: - uos.remove(src_path) - except Exception as e: - clog.info("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e)) - self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file size ok") - return - else: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") - except Exception as e: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") - else: - self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file copy ok") - else: - self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"creat file or dir err!") - pass - else: - self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat file or dir error!") - pass - else: - if self.Cat1FileState == 0: - if self.Cat1FileReplayBle == 1: - return - self.Cat1FileReplayBle = 1 - self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"reset start!") - self.Cat1FileState == 0 - self.Cat1FileTransTimer.stop() - self.Cat1PyFileTimout = 0 - self.fileNameList=[] - self.deleteTmpFile() - self.deleteUsrTmpFile() - - def otaTimeOut(self,*argc): - clog.info("重启成功!!!!!!!!\r\n") - -TcpService = TcpServiceInit() - - diff --git a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/telecom_dmp.py b/code/sdk/files/leiniao/fs/user/system/cat1otaudp/telecom_dmp.py deleted file mode 100644 index f60e74899..000000000 --- a/code/sdk/files/leiniao/fs/user/system/cat1otaudp/telecom_dmp.py +++ /dev/null @@ -1,5 +0,0 @@ -import log - -# 设置日志输出级别 -log.basicConfig(level=log.INFO) -fota_log = log.getLogger("telecom_dmp") diff --git a/code/sdk/open_source/openharmony/third_party/lwip/CMakeLists.txt b/code/sdk/open_source/openharmony/third_party/lwip/CMakeLists.txt index e083e5ee6..fcf407b43 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/CMakeLists.txt +++ b/code/sdk/open_source/openharmony/third_party/lwip/CMakeLists.txt @@ -90,6 +90,9 @@ set(SOURCES ${CMAKE_LWIP_SOURCE_DIR}/src/core/init.c ${CMAKE_LWIP_SOURCE_DIR}/src/core/sys.c ${CMAKE_LWIP_SOURCE_DIR}/src/core/altcp_alloc.c + ${CMAKE_LWIP_SOURCE_DIR}/src/apps/http/http_client.c + ${CMAKE_LWIP_SOURCE_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls.c + ${CMAKE_LWIP_SOURCE_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls_mem.c ${CMAKE_LWIP_SOURCE_DIR}/src/netif/lowpan6_common.c ${CMAKE_LWIP_SOURCE_DIR}/src/netif/lowpan6.c ${CMAKE_LWIP_SOURCE_DIR}/src/api/if_api.c diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h b/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h index 20f7b8ce4..10f278535 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h @@ -200,6 +200,14 @@ extern "C" { #define SLIP_USE_RX_THREAD 1 // 启用接收线程作为主线程处理队列 #endif +/* 增加 SLIP 接收线程栈大小,防止在处理大量数据时栈溢出 + * 注意:处理 TCP/HTTPS 数据时调用链很深(netif->input -> ip_input -> tcp_input -> tcp_process -> altcp_recved -> mbedtls_ssl_read) + * 需要足够大的栈空间来避免栈溢出 + */ +#ifndef SLIP_RX_THREAD_STACKSIZE +#define SLIP_RX_THREAD_STACKSIZE 16384 // 16KB 栈大小(处理 HTTPS/TLS 数据时需要更大的栈) +#endif + #ifndef SLIP_DEBUG #define SLIP_DEBUG LWIP_DBG_ON #endif @@ -245,6 +253,22 @@ extern "C" { #define LWIP_HTTPC_HAVE_FILE_IO 1 + +/* Enable altcp API for layered protocols (TLS support) */ +#ifndef LWIP_ALTCP +#define LWIP_ALTCP 1 +#endif + +/* Enable TLS support for altcp API */ +#ifndef LWIP_ALTCP_TLS +#define LWIP_ALTCP_TLS 1 +#endif + +/* Enable mbedTLS backend for altcp TLS */ +#ifndef LWIP_ALTCP_TLS_MBEDTLS +#define LWIP_ALTCP_TLS_MBEDTLS 1 +#endif + /* To support the CMSIS interface, you need to enable this macro. By default, this macro is not supported. @@ -588,7 +612,8 @@ extern "C" { #endif #ifndef LWIP_WND_SCALE -#define LWIP_WND_SCALE 0 +#define LWIP_WND_SCALE 1 +#define TCP_RCV_SCALE 1 #endif #ifndef LWIP_SOCK_FILTER diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c index 1518b48d7..16c567262 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c @@ -63,13 +63,11 @@ #include "altcp_tls_mbedtls_structs.h" #include "altcp_tls_mbedtls_mem.h" -#if (MBEDTLS_VERSION_NUMBER == 0x03010000) +#if (MBEDTLS_VERSION_NUMBER >= 0x03010000) #include "mbedtls/pk.h" #include "mbedtls/net_sockets.h" #include "mbedtls/x509_crt.h" - #else -#include "mbedtls/certs.h" #include "mbedtls/x509.h" #include "mbedtls/net.h" #include "mbedtls/ssl_internal.h" /* to call mbedtls_flush_output after ERR_MEM */ @@ -204,6 +202,19 @@ altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p altcp_mbedtls_state_t *state; struct altcp_pcb *conn = (struct altcp_pcb *)arg; + /* 添加日志:记录TLS层接收TCP数据 */ + if (p != NULL) { + printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: received TCP data, len=%u, tot_len=%u, err=%d\n", + p->len, p->tot_len, err); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_lower_recv: received TCP data, len=%u, tot_len=%u, err=%d\n", + p->len, p->tot_len, err)); + } else { + printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: pbuf is NULL, err=%d\n", err); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_lower_recv: pbuf is NULL, err=%d\n", err)); + } + LWIP_ASSERT("no err expected", err == ERR_OK); LWIP_UNUSED_ARG(err); @@ -226,6 +237,17 @@ altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p return ERR_CLSD; } + /* 添加日志:记录握手状态 */ + if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake not done yet, processing handshake data\n"); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake not done yet, processing handshake data\n")); + } else { + printf("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake done, processing application data\n"); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_lower_recv: handshake done, processing application data\n")); + } + /* handle NULL pbuf (inner connection closed) */ if (p == NULL) { /* remote host sent FIN, remember this (SSL state is destroyed @@ -284,7 +306,38 @@ altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t * return ERR_OK; } if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_handshake failed: %d\n", ret)); + /* 详细的握手错误日志 */ + char error_buf[256]; + mbedtls_strerror(ret, error_buf, sizeof(error_buf)); + /* 使用 printf 确保日志输出(因为 LWIP_DEBUGF 可能被关闭) */ + printf("[ALTCP_TLS] SSL handshake failed: ret=%d (0x%04x), error=%s\n", ret, (unsigned int)(-ret), error_buf); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("[ALTCP_TLS] SSL handshake failed: ret=%d (0x%04x), error=%s\n", ret, (unsigned int)(-ret), error_buf)); + + /* 记录常见错误码的详细说明(使用错误码数值,避免依赖可能不存在的宏) */ + const char *error_detail = ""; + /* 检查错误码范围(mbedTLS SSL 错误码通常在 -0x7000 到 -0x7FFF 范围) */ + if (ret < -0x7000 && ret > -0x8000) { + /* 常见的 SSL 错误码(根据 mbedTLS 错误码定义) */ + if (ret == -0x7100) { /* MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION */ + error_detail = " (Bad protocol version - TLS version mismatch)"; + } else if (ret == -0x7200) { /* MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN */ + error_detail = " (No cipher chosen - cipher suite mismatch)"; + } else if (ret == -0x7500) { /* MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE */ + error_detail = " (Handshake failure - server rejected handshake)"; + } else if (ret == -0x7880) { /* MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY */ + error_detail = " (Peer closed connection during handshake)"; + } else if (ret == -0x7280) { /* MBEDTLS_ERR_SSL_CONN_EOF */ + error_detail = " (Connection EOF during handshake)"; + } else if (ret == -0x7400) { /* MBEDTLS_ERR_SSL_TIMEOUT */ + error_detail = " (Handshake timeout)"; + } + } + if (error_detail[0] != '\0') { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("[ALTCP_TLS] Error detail:%s\n", error_detail)); + } + /* handshake failed, connection has to be closed */ if (conn->err) { conn->err(conn->arg, ERR_CLSD); @@ -299,6 +352,20 @@ altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t * LWIP_ASSERT("state", state->bio_bytes_read == 0); LWIP_ASSERT("state", state->bio_bytes_appl == 0); state->flags |= ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE; + + /* 记录握手成功后协商的 TLS 版本和加密套件 */ + { + const char *version_str = mbedtls_ssl_get_version(&state->ssl_context); + const char *ciphersuite = mbedtls_ssl_get_ciphersuite(&state->ssl_context); + mbedtls_ssl_protocol_version tls_version = mbedtls_ssl_get_version_number(&state->ssl_context); + /* 使用 printf 确保日志输出(因为 LWIP_DEBUGF 可能被关闭) */ + printf("[ALTCP_TLS] SSL handshake succeeded: version=%s (0x%04x), ciphersuite=%s\n", + version_str ? version_str : "UNKNOWN", (unsigned int)tls_version, ciphersuite ? ciphersuite : "NULL"); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] SSL handshake succeeded: version=%s (0x%04x), ciphersuite=%s\n", + version_str ? version_str : "UNKNOWN", (unsigned int)tls_version, ciphersuite ? ciphersuite : "NULL")); + } + /* issue "connect" callback" to upper connection (this can only happen for active open) */ if (conn->connected) { err_t err; @@ -325,14 +392,23 @@ altcp_mbedtls_pass_rx_data(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) LWIP_ASSERT("state != NULL", state != NULL); buf = state->rx_app; if (buf) { + printf("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: passing decrypted data to application, len=%u\n", buf->tot_len); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: passing decrypted data to application, len=%u\n", buf->tot_len)); state->rx_app = NULL; if (conn->recv) { u16_t tot_len = buf->tot_len; /* this needs to be increased first because the 'recved' call may come nested */ state->rx_passed_unrecved += tot_len; state->flags |= ALTCP_MBEDTLS_FLAGS_UPPER_CALLED; + printf("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: calling conn->recv callback, len=%u\n", tot_len); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: calling conn->recv callback, len=%u\n", tot_len)); err = conn->recv(conn->arg, conn, buf, ERR_OK); if (err != ERR_OK) { + printf("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: conn->recv returned error, err=%d\n", err); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_pass_rx_data: conn->recv returned error, err=%d\n", err)); if (err == ERR_ABRT) { return ERR_ABRT; } @@ -373,8 +449,14 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t * LWIP_ASSERT("state != NULL", state != NULL); if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { /* handshake not done yet */ + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: handshake not done yet, returning ERR_VAL\n"); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: handshake not done yet, returning ERR_VAL\n")); return ERR_VAL; } + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: starting to decrypt application data\n"); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: starting to decrypt application data\n")); do { /* allocate a full-sized unchained PBUF_POOL: this is for RX! */ struct pbuf *buf = pbuf_alloc(PBUF_RAW, PBUF_POOL_BUFSIZE, PBUF_POOL); @@ -385,12 +467,59 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t * } /* decrypt application data, this pulls encrypted RX data off state->rx pbuf chain */ + /* 记录调用前的状态 */ + int bytes_avail_before = mbedtls_ssl_get_bytes_avail(&state->ssl_context); + u16_t state_rx_len = (state->rx != NULL) ? state->rx->tot_len : 0; + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: before mbedtls_ssl_read: bytes_avail=%d, state->rx=%p (len=%u), bio_bytes_read=%d\n", + bytes_avail_before, state->rx, state_rx_len, state->bio_bytes_read); ret = mbedtls_ssl_read(&state->ssl_context, (unsigned char *)buf->payload, PBUF_POOL_BUFSIZE); + int bytes_avail_after = mbedtls_ssl_get_bytes_avail(&state->ssl_context); + if (ret > 0) { + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read decrypted %d bytes (bytes_avail: %d -> %d)\n", + ret, bytes_avail_before, bytes_avail_after); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read decrypted %d bytes (bytes_avail: %d -> %d)\n", + ret, bytes_avail_before, bytes_avail_after)); + } if (ret < 0) { + if (ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE) { + /* 检查 mbedTLS 内部状态 */ + int bytes_avail = mbedtls_ssl_get_bytes_avail(&state->ssl_context); + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read wants more data (WANT_READ/WANT_WRITE), ret=%d, bytes_avail=%d, state->rx=%p\n", + ret, bytes_avail, state->rx); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read wants more data (WANT_READ/WANT_WRITE), ret=%d, bytes_avail=%d, state->rx=%p\n", + ret, bytes_avail, state->rx)); + pbuf_free(buf); + /* 如果 state->rx 还有数据,或者 bytes_avail > 0,说明可能还有数据可以处理 */ + if (state->rx != NULL || bytes_avail > 0) { + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: state->rx or bytes_avail has data, will retry on next poll\n"); + } + return ERR_OK; + } else if (ret == MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET) { + /* TLS 1.3: NewSessionTicket is a normal post-handshake message, not an error. + * Continue processing to read actual application data. */ + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: received NewSessionTicket (TLS 1.3), continuing to read application data\n"); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: received NewSessionTicket (TLS 1.3), continuing to read application data\n")); + pbuf_free(buf); + /* Continue the loop to read actual application data */ + continue; + } else { + char error_buf[256]; + mbedtls_strerror(ret, error_buf, sizeof(error_buf)); + printf("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read error, ret=%d (0x%04x), error=%s\n", + ret, (unsigned int)(-ret), error_buf); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("[ALTCP_TLS] altcp_mbedtls_handle_rx_appldata: mbedtls_ssl_read error, ret=%d (0x%04x), error=%s\n", + ret, (unsigned int)(-ret), error_buf)); + } if (ret == MBEDTLS_ERR_SSL_CLIENT_RECONNECT) { /* client is initiating a new connection using the same source port -> close connection or make handshake */ LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("new connection on same source port\n")); LWIP_ASSERT("TODO: new connection on same source port, close this connection", 0); + pbuf_free(buf); + return ERR_OK; } else if (ret == MBEDTLS_ERR_SSL_TIMEOUT) { /* SSL read timeout - may occur on slow links (e.g., UART SLIP) * If there's data in the RX buffer, retry instead of closing the connection */ @@ -404,21 +533,19 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t * LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("SSL read timeout, no data pending\n")); pbuf_free(buf); return ERR_OK; - } else if ((ret != MBEDTLS_ERR_SSL_WANT_READ) && (ret != MBEDTLS_ERR_SSL_WANT_WRITE)) { - if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n")); - } else if (ret == MBEDTLS_ERR_NET_CONN_RESET) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was reset by peer\n")); - } + } else if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n")); + pbuf_free(buf); + return ERR_OK; + } else if (ret == MBEDTLS_ERR_NET_CONN_RESET) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was reset by peer\n")); pbuf_free(buf); return ERR_OK; } else { + /* Other errors: free buffer and return OK to allow retry */ pbuf_free(buf); return ERR_OK; } - pbuf_free(buf); - altcp_abort(conn); - return ERR_ABRT; } else { err_t err; if (ret) { @@ -495,6 +622,9 @@ altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len) /* close queued but not passed up yet */ return 0; } + printf("[ALTCP_TLS] altcp_mbedtls_bio_recv: no data available (p=%p), returning WANT_READ\n", p); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_bio_recv: no data available (p=%p), returning WANT_READ\n", p)); return MBEDTLS_ERR_SSL_WANT_READ; } /* limit number of bytes again to copy from first pbuf in a chain only */ @@ -502,6 +632,11 @@ altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len) /* copy the data */ ret = pbuf_copy_partial(p, buf, copy_len, 0); LWIP_ASSERT("ret == copy_len", ret == copy_len); + printf("[ALTCP_TLS] altcp_mbedtls_bio_recv: copied %u bytes from pbuf (p->len=%u, p->tot_len=%u, requested=%zu)\n", + ret, p->len, p->tot_len, len); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_bio_recv: copied %u bytes from pbuf (p->len=%u, p->tot_len=%u, requested=%zu)\n", + ret, p->len, p->tot_len, len)); /* hide the copied bytes from the pbuf */ err = pbuf_remove_header(p, ret); LWIP_ASSERT("error", err == ERR_OK); @@ -510,6 +645,9 @@ altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len) state->rx = p->next; p->next = NULL; pbuf_free(p); + printf("[ALTCP_TLS] altcp_mbedtls_bio_recv: freed consumed pbuf, state->rx=%p\n", state->rx); + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("[ALTCP_TLS] altcp_mbedtls_bio_recv: freed consumed pbuf, state->rx=%p\n", state->rx)); } state->bio_bytes_read += (int)ret; @@ -1116,7 +1254,7 @@ altcp_mbedtls_sndbuf(struct altcp_pcb *conn) size_t ret; #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) /* @todo: adjust ssl_added to real value related to negociated cipher */ - #if (MBEDTLS_VERSION_NUMBER == 0x03010000) + #if (MBEDTLS_VERSION_NUMBER >= 0x03010000) size_t max_frag_len = mbedtls_ssl_get_max_out_record_payload(&state->ssl_context); #else size_t max_frag_len = mbedtls_ssl_get_max_frag_len(&state->ssl_context); @@ -1163,7 +1301,7 @@ altcp_mbedtls_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t /* HACK: if thre is something left to send, try to flush it and only allow sending more if this succeeded (this is a hack because neither returning 0 nor MBEDTLS_ERR_SSL_WANT_WRITE worked for me) */ - #if (MBEDTLS_VERSION_NUMBER == 0x03010000) + #if (MBEDTLS_VERSION_NUMBER >= 0x03010000) if(mbedtls_ssl_flush_output(&state->ssl_context) !=0) { return ERR_MEM; @@ -1176,23 +1314,31 @@ altcp_mbedtls_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t } } #endif + printf("[ALTCP_TLS] altcp_mbedtls_write: writing %u bytes to TLS connection\n", len); ret = mbedtls_ssl_write(&state->ssl_context, (const unsigned char *)dataptr, len); + printf("[ALTCP_TLS] altcp_mbedtls_write: mbedtls_ssl_write returned %d (len=%u)\n", ret, len); /* try to send data... */ altcp_output(conn->inner_conn); if (ret >= 0) { if (ret == len) { state->flags |= ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT; + printf("[ALTCP_TLS] altcp_mbedtls_write: all %u bytes written successfully\n", len); return ERR_OK; } else { /* @todo/@fixme: assumption: either everything sent or error */ + printf("[ALTCP_TLS] altcp_mbedtls_write: WARNING: partial write, ret=%d, len=%u\n", ret, len); LWIP_ASSERT("ret <= 0", 0); return ERR_MEM; } } else { if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) { + printf("[ALTCP_TLS] altcp_mbedtls_write: WANT_WRITE, need to retry\n"); /* @todo: convert error to err_t */ return ERR_MEM; } + char error_buf[256]; + mbedtls_strerror(ret, error_buf, sizeof(error_buf)); + printf("[ALTCP_TLS] altcp_mbedtls_write: ERROR: ret=%d (0x%04x), error=%s\n", ret, (unsigned int)(-ret), error_buf); LWIP_ASSERT("unhandled error", 0); return ERR_VAL; } @@ -1215,23 +1361,30 @@ altcp_mbedtls_bio_send(void *ctx, const unsigned char *dataptr, size_t size) return MBEDTLS_ERR_NET_INVALID_CONTEXT; } + printf("[ALTCP_TLS] altcp_mbedtls_bio_send: sending %zu bytes to TCP layer\n", size); while (size_left) { u16_t write_len = (u16_t)LWIP_MIN(size_left, 0xFFFF); err_t err = altcp_write(conn->inner_conn, (const void *)dataptr, write_len, apiflags); if (err == ERR_OK) { written += write_len; size_left -= write_len; + dataptr += write_len; /* 修复:更新 dataptr 指针 */ + printf("[ALTCP_TLS] altcp_mbedtls_bio_send: wrote %u bytes to TCP, total written=%d, remaining=%zu\n", + write_len, written, size_left); } else if (err == ERR_MEM) { + printf("[ALTCP_TLS] altcp_mbedtls_bio_send: ERR_MEM, written=%d, remaining=%zu\n", written, size_left); if (written) { return written; } return 0; /* MBEDTLS_ERR_SSL_WANT_WRITE; */ } else { + printf("[ALTCP_TLS] altcp_mbedtls_bio_send: ERROR: err=%d\n", err); LWIP_ASSERT("tls_write, tcp_write: err != ERR MEM", 0); /* @todo: return MBEDTLS_ERR_NET_CONN_RESET or MBEDTLS_ERR_NET_SEND_FAILED */ return MBEDTLS_ERR_NET_SEND_FAILED; } } + printf("[ALTCP_TLS] altcp_mbedtls_bio_send: all %zu bytes sent successfully, total written=%d\n", size, written); return written; } diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/http/http_client.c b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/http/http_client.c index 2e767db37..2d261e8de 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/http/http_client.c +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/http/http_client.c @@ -124,9 +124,6 @@ "\r\n" #define HTTPC_REQ_11_PROXY_PORT_FORMAT(host, host_port, uri, srv_name) HTTPC_REQ_11_PROXY_PORT, host, host_port, uri, HTTPC_CLIENT_AGENT, srv_name -//x-www-form-urlencoded -//application/json -////////////////////////////////////////post报文/////////////////////////////////////////////////// /* POST request basic */ #define HTTPC_REQ_11_POST "POST %s HTTP/1.1\r\n" /* URI */\ "User-Agent: %s\r\n" /* User-Agent */ \ @@ -152,7 +149,6 @@ #define HTTPC_REQ_11_HOST_FORMAT_POST(uri, srv_name, arglen, args) HTTPC_REQ_11_HOST_POST, uri, HTTPC_CLIENT_AGENT, srv_name, arglen, args -////////////////////////////////////////PUT报文/////////////////////////////////////////////////// /* PUT request basic */ #define HTTPC_REQ_11_PUT "PUT %s HTTP/1.1\r\n" /* URI */\ "User-Agent: %s\r\n" /* User-Agent */ \ @@ -164,18 +160,7 @@ "%s" #define HTTPC_REQ_11_FORMAT_PUT(uri, arglen, args) HTTPC_REQ_11_PUT, uri, HTTPC_CLIENT_AGENT, arglen, args - -// PUT /api/user HTTP/1.1 -// Host: example.com -// Content-Type: application/json -// Content-Length: 123 - -// { -// "id": 123, -// "name": "John Doe", -// "email": "johndoe@example.com", -// "age": 30 -// } + /* PUT request with host */ #define HTTPC_REQ_11_HOST_PUT "PUT %s HTTP/1.1\r\n" /* URI */\ "User-Agent: %s\r\n" /* User-Agent */ \ @@ -189,15 +174,13 @@ #define HTTPC_REQ_11_HOST_FORMAT_PUT(uri, srv_name, arglen, args) HTTPC_REQ_11_HOST_PUT, uri, HTTPC_CLIENT_AGENT, srv_name, arglen, args - - typedef enum ehttpc_parse_state { HTTPC_PARSE_WAIT_FIRST_LINE = 0, HTTPC_PARSE_WAIT_HEADERS, HTTPC_PARSE_RX_DATA } httpc_parse_state_t; -typedef struct _httpc_state +struct _httpc_state { struct altcp_pcb* pcb; ip_addr_t remote_addr; @@ -217,7 +200,8 @@ typedef struct _httpc_state char* server_name; char* uri; #endif -} httpc_state_t; +}; +/* httpc_state_t is typedef'd in http_client.h */ /** Free http client state and deallocate all resources within */ static err_t @@ -349,10 +333,25 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) httpc_state_t* req = (httpc_state_t*)arg; LWIP_UNUSED_ARG(r); + /* 添加日志:记录数据接收 */ + if (p != NULL) { + printf("[HTTP_CLIENT] httpc_tcp_recv: received data, len=%u, tot_len=%u, parse_state=%d, err=%d\n", + p->len, p->tot_len, req ? req->parse_state : -1, r); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: received data, len=%u, tot_len=%u, parse_state=%d, err=%d\n", + p->len, p->tot_len, req ? req->parse_state : -1, r)); + } else { + printf("[HTTP_CLIENT] httpc_tcp_recv: pbuf is NULL, parse_state=%d, err=%d\n", + req ? req->parse_state : -1, r); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: pbuf is NULL, parse_state=%d, err=%d\n", + req ? req->parse_state : -1, r)); + } + if (p == NULL) { httpc_result_t result; if (req->parse_state != HTTPC_PARSE_RX_DATA) { /* did not get RX data yet */ + printf("[HTTP_CLIENT] httpc_tcp_recv: connection closed before receiving data, parse_state=%d\n", req->parse_state); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: connection closed before receiving data, parse_state=%d\n", req->parse_state)); result = HTTPC_RESULT_ERR_CLOSED; } else if ((req->hdr_content_len != HTTPC_CONTENT_LEN_INVALID) && (req->hdr_content_len != req->rx_content_len)) { @@ -368,15 +367,26 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) if (req->parse_state != HTTPC_PARSE_RX_DATA) { if (req->rx_hdrs == NULL) { req->rx_hdrs = p; + printf("[HTTP_CLIENT] httpc_tcp_recv: first header pbuf received, len=%u\n", p ? p->tot_len : 0); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: first header pbuf received, len=%u\n", p ? p->tot_len : 0)); } else { pbuf_cat(req->rx_hdrs, p); + printf("[HTTP_CLIENT] httpc_tcp_recv: header pbuf concatenated, total_len=%u\n", req->rx_hdrs ? req->rx_hdrs->tot_len : 0); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: header pbuf concatenated, total_len=%u\n", req->rx_hdrs ? req->rx_hdrs->tot_len : 0)); } if (req->parse_state == HTTPC_PARSE_WAIT_FIRST_LINE) { u16_t status_str_off; err_t err = http_parse_response_status(req->rx_hdrs, &req->rx_http_version, &req->rx_status, &status_str_off); if (err == ERR_OK) { /* don't care status string */ + printf("[HTTP_CLIENT] httpc_tcp_recv: HTTP status line parsed, version=0x%04x, status=%u\n", + req->rx_http_version, req->rx_status); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: HTTP status line parsed, version=0x%04x, status=%u\n", + req->rx_http_version, req->rx_status)); req->parse_state = HTTPC_PARSE_WAIT_HEADERS; + } else { + printf("[HTTP_CLIENT] httpc_tcp_recv: failed to parse HTTP status line, err=%d\n", err); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: failed to parse HTTP status line, err=%d\n", err)); } } if (req->parse_state == HTTPC_PARSE_WAIT_HEADERS) { @@ -384,12 +394,18 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) err_t err = http_wait_headers(req->rx_hdrs, &req->hdr_content_len, &total_header_len); if (err == ERR_OK) { struct pbuf *q; + printf("[HTTP_CLIENT] httpc_tcp_recv: all headers received, total_len=%u, content_len=%u\n", + total_header_len, req->hdr_content_len); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: all headers received, total_len=%u, content_len=%u\n", + total_header_len, req->hdr_content_len)); /* full header received, send window update for header bytes and call into client callback */ altcp_recved(pcb, total_header_len); if (req->conn_settings) { if (req->conn_settings->headers_done_fn) { err = req->conn_settings->headers_done_fn(req, req->callback_arg, req->rx_hdrs, total_header_len, req->hdr_content_len); if (err != ERR_OK) { + printf("[HTTP_CLIENT] httpc_tcp_recv: headers_done_fn returned error, err=%d\n", err); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: headers_done_fn returned error, err=%d\n", err)); return httpc_close(req, HTTPC_RESULT_LOCAL_ABORT, req->rx_status, err); } } @@ -400,6 +416,13 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) req->rx_hdrs = NULL; /* go on with data */ req->parse_state = HTTPC_PARSE_RX_DATA; + printf("[HTTP_CLIENT] httpc_tcp_recv: switched to RX_DATA state, remaining pbuf=%p\n", p); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: switched to RX_DATA state, remaining pbuf=%p\n", p)); + } else { + printf("[HTTP_CLIENT] httpc_tcp_recv: waiting for more header data, current_len=%u\n", + req->rx_hdrs ? req->rx_hdrs->tot_len : 0); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_recv: waiting for more header data, current_len=%u\n", + req->rx_hdrs ? req->rx_hdrs->tot_len : 0)); } } } @@ -409,7 +432,7 @@ httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) /* directly return here: the connection migth already be aborted from the callback! */ err_t error=req->recv_fn(req->callback_arg, pcb, p, r); if (req->conn_settings && req->conn_settings->file_rx_fn) { - req->conn_settings->file_rx_fn(req,p->tot_len,req->rx_content_len); + req->conn_settings->file_rx_fn(req, p->tot_len, req->rx_content_len); } return error; } else { @@ -477,12 +500,21 @@ httpc_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err) LWIP_UNUSED_ARG(pcb); LWIP_UNUSED_ARG(err); + /* 添加日志:确认HTTP请求发送时机(应该在TLS握手成功后) */ + printf("[HTTP_CLIENT] httpc_tcp_connected: sending HTTP request, len=%u\n", req->request ? req->request->len - 1 : 0); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_connected: sending HTTP request, len=%u\n", req->request ? req->request->len - 1 : 0)); + /* send request; last char is zero termination */ r = altcp_write(req->pcb, req->request->payload, req->request->len - 1, TCP_WRITE_FLAG_COPY); if (r != ERR_OK) { /* could not write the single small request -> fail, don't retry */ + printf("[HTTP_CLIENT] httpc_tcp_connected: altcp_write failed, err=%d\n", r); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_connected: altcp_write failed, err=%d\n", r)); return httpc_close(req, HTTPC_RESULT_ERR_MEM, 0, r); } + printf("[HTTP_CLIENT] httpc_tcp_connected: HTTP request sent successfully, calling altcp_output\n"); + LWIP_DEBUGF(HTTPC_DEBUG, ("[HTTP_CLIENT] httpc_tcp_connected: HTTP request sent successfully, calling altcp_output\n")); + /* everything written, we can free the request */ pbuf_free(req->request); req->request = NULL; @@ -566,7 +598,6 @@ static int httpc_create_request_string(const httpc_connection_t *settings, const char* server_name, int server_port, const char* uri, int use_host, char *buffer, size_t buffer_size) { - // printf("httpc_create_request_string use_post %d use_proxy %d use_host %d \r\n",settings->use_post,settings->use_proxy,use_host); if (settings->use_proxy) { LWIP_ASSERT("server_name != NULL", server_name != NULL); if (server_port != HTTP_DEFAULT_PORT) @@ -582,29 +613,24 @@ httpc_create_request_string(const httpc_connection_t *settings, const char* serv if (settings->use_post) { - return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_POST(uri, server_name, settings->arglen, settings->args)); - // printf("%s\r\n",buffer); - } + return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_POST(uri, server_name, settings->arglen, settings->args)); + } if (settings->use_put) { - return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_PUT(uri, server_name, settings->arglen, settings->args)); - // printf("%s\r\n",buffer); - } + return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_PUT(uri, server_name, settings->arglen, settings->args)); + } return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT(uri, server_name)); } else { - - if (settings->use_put) + if (settings->use_put) { - return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT_PUT(uri, server_name, settings->arglen, settings->args)); - // printf("%s\r\n",buffer); - } + return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT_PUT(uri, settings->arglen, settings->args)); + } if (settings->use_post){ - return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT_POST(uri, settings->arglen, settings->args)); - + return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT_POST(uri, settings->arglen, settings->args)); } return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT(uri)); } diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include/lwip/apps/http_client.h b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include/lwip/apps/http_client.h index 8a0630833..0a5be60dc 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include/lwip/apps/http_client.h +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include/lwip/apps/http_client.h @@ -121,6 +121,7 @@ typedef void (*httpc_result_fn)(void *arg, httpc_result_t httpc_result, u32_t rx * @return if != ERR_OK is returned, the connection is aborted */ typedef err_t (*httpc_headers_done_fn)(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len); +typedef err_t (*httpc_file_rx_fn)(httpc_state_t *connection, u32_t rx_len, u32_t rx_total_len); typedef struct _httpc_connection { ip_addr_t proxy_addr; @@ -137,6 +138,15 @@ typedef struct _httpc_connection { /* this callback is called after receiving the http headers It can abort the connection by returning != ERR_OK */ httpc_headers_done_fn headers_done_fn; + + /* this callback is called after receiving some bytes of download file */ + httpc_file_rx_fn file_rx_fn; + + /* POST/PUT support */ + u8_t use_post; + u8_t use_put; + u16_t arglen; + u8_t* args; } httpc_connection_t; err_t httpc_get_file(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c index e0a1ac933..cd1bbda01 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c @@ -72,6 +72,7 @@ #include "osal_wait.h" // 包含 osal_msleep 函数 #include "lwip/ip6_addr.h" #include "lwip/netif.h" +#include "lwip/tcpip.h" // 包含 tcpip_input,用于线程安全的数据包处理 #include #include #include "custom_utils.h" @@ -528,11 +529,6 @@ slipif_rxbyte_input(struct netif *netif, u8_t c) return; } - if (netif->input == NULL) { - LWIP_DEBUGF(SLIP_DEBUG, ("ERROR: slipif_rxbyte_input: netif->input is NULL\n")); - return; - } - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: processing byte 0x%02x\n", c)); struct pbuf *p; @@ -541,14 +537,19 @@ slipif_rxbyte_input(struct netif *netif, u8_t c) LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: complete packet received, length=%d\n", p->tot_len)); g_slipif_error_stats.packets_received++; g_slipif_error_stats.bytes_received += p->tot_len; - if (netif->input(p, netif) != ERR_OK) { - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: netif->input failed, freeing pbuf\n")); + + /* 使用 tcpip_input 进行线程安全的数据包处理 + * 这样数据包处理在 tcpip 线程的栈上执行,而不是在当前线程的栈上 + */ + err_t input_result = tcpip_input(p, netif); + if (input_result != ERR_OK) { + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: tcpip_input failed (ret=%d), freeing pbuf\n", input_result)); g_slipif_error_stats.netif_input_fail_count++; g_slipif_error_stats.packets_dropped++; g_slipif_error_stats.bytes_dropped += p->tot_len; pbuf_free(p); } else { - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: packet sent to IP layer successfully\n")); + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: packet queued to tcpip thread successfully\n")); } } } @@ -607,13 +608,18 @@ slipif_loop_thread(void *nf) } /* 有残留数据:继续处理 */ } else { - /* 信号量触发:有数据到达,处理队列 */ + /* 信号量触发:有数据到达,处理队列 + * 注意:由于使用了 tcpip_input,数据包处理在 tcpip 线程的栈上执行, + * 不会在 slipif_loop_thread 的栈上累积,所以可以安全地批量处理 + */ u16_t processed_count = slipif_process_rxqueue(netif); - /* 如果处理了数据包,继续处理队列直到清空(批量处理提高效率) */ + /* 如果处理了数据包,继续处理队列直到清空(批量处理提高效率) + * 由于使用了 tcpip_input,不会导致栈溢出,可以安全地批量处理 + */ while (processed_count > 0) { processed_count = slipif_process_rxqueue(netif); - /* 如果队列还有数据,继续处理(不休眠) */ + /* 如果队列还有数据,继续处理 */ if (processed_count == 0) { break; // 队列已清空,退出循环等待下一个信号量 } @@ -923,7 +929,10 @@ slipif_process_rxqueue(struct netif *netif) } u16_t processed_count = 0; - const u16_t MAX_PACKETS_PER_CALL = 10; // 防止一次处理过多数据包 + /* 由于使用了 tcpip_input,数据包处理在 tcpip 线程的栈上执行, + * 不会在 slipif_loop_thread 的栈上累积,所以可以安全地处理更多包 + */ + const u16_t MAX_PACKETS_PER_CALL = 20; // 可以处理更多包,因为不会导致栈溢出 while (priv->rxpackets != NULL && processed_count < MAX_PACKETS_PER_CALL) { struct pbuf *p = priv->rxpackets; @@ -949,19 +958,28 @@ slipif_process_rxqueue(struct netif *netif) // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: processing pbuf 0x%p, length=%d\n", q, q->tot_len)); - /* 释放锁,避免在 netif->input 中长时间持有锁 */ + /* 释放锁,避免在数据包处理中长时间持有锁 */ sys_mutex_unlock(&priv->rxqueue_mutex); g_slipif_error_stats.packets_received++; g_slipif_error_stats.bytes_received += q->tot_len; - if (netif->input(q, netif) != ERR_OK) { - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: netif->input failed, freeing pbuf\n")); + + /* 使用 tcpip_input 进行线程安全的数据包处理 + * 这是从设计上解决栈溢出问题的关键: + * - tcpip_input 会将数据包放入 tcpip 线程的消息队列 + * - 数据包处理在 tcpip 线程的栈上执行,而不是在 slipif_loop_thread 的栈上 + * - 这样避免了在 slipif_loop_thread 栈上累积很深的调用链 + * - 即使处理大量数据包,也不会导致 slipif_loop_thread 栈溢出 + */ + err_t input_result = tcpip_input(q, netif); + if (input_result != ERR_OK) { + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: tcpip_input failed (ret=%d), freeing pbuf\n", input_result)); g_slipif_error_stats.netif_input_fail_count++; g_slipif_error_stats.packets_dropped++; g_slipif_error_stats.bytes_dropped += q->tot_len; pbuf_free(q); } else { - // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: packet sent to IP layer successfully\n")); + // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: packet queued to tcpip thread successfully\n")); } processed_count++; diff --git a/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt b/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt index 53293b8e5..25dd5c38f 100644 --- a/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt +++ b/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt @@ -46,7 +46,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_runtime.c ${CMAKE_CURRENT_SOURCE_DIR}/Service/pdu.c ${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_utils.c ${CMAKE_CURRENT_SOURCE_DIR}/Service/api_shell.c -${CMAKE_CURRENT_SOURCE_DIR}/Service/http_client.c +# ${CMAKE_CURRENT_SOURCE_DIR}/Service/http_client.c # 使用 lwIP 标准库的 HTTP 客户端 ${CMAKE_CURRENT_SOURCE_DIR}/Service/sntp.c ${CMAKE_CURRENT_SOURCE_DIR}/Service/cat1_server_hal.c # ${CMAKE_CURRENT_SOURCE_DIR}/slip/uart_slip.c diff --git a/code/sdk/zhihui/4g/cat1Service/Service/cat1_server.c b/code/sdk/zhihui/4g/cat1Service/Service/cat1_server.c index 25328b69a..d30a24c94 100644 --- a/code/sdk/zhihui/4g/cat1Service/Service/cat1_server.c +++ b/code/sdk/zhihui/4g/cat1Service/Service/cat1_server.c @@ -62,6 +62,10 @@ extern "C" { #include "cat1_utils.h" #include "cmsis_os.h" +#include "cmsis_os2.h" +extern osStatus_t osDelay(uint32_t ticks); +#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */ + static uint8_t g_skip_cat1_service_udp_transfer = 0; static f_cat1_msg_callback g_cat1_msg_callback_func=NULL; #define PEER_IP "172.16.1.2" @@ -858,6 +862,22 @@ static int decodeNetStat(char* msg) if (g_py_ver >= PY_SRV_VER_SUPORT_PY_OTA_MINI_VER && g_py_ver 16使用TCP,否则使用UDP) */ + if (g_py_ver > 16) + { + /* TCP方式:先发送1D指令启动CAT1的TCP服务 */ + cat1_print_dbg("Using TCP mode for OTA, sending 1D command to start TCP service\n"); + cat1_start_tcp_ota_init(); + cat1_tcp_server_init(); + + /* 等待TCP服务启动完成(给CAT1一些时间启动TCP服务) */ + cat1_msleep(2000); /* 等待2秒,确保TCP服务启动完成 */ + + cat1_print_dbg("TCP service should be ready, starting OTA\n"); + } + + /* 开始OTA升级 */ Cat1_OTA(CAT1_TCP_START_OTA); }else{ cat1_print_dbg("current PyVer %d, mini pyVer %d , local pyVer %d, skip cat1 python ota!\n",g_py_ver,PY_SRV_VER_SUPORT_PY_OTA_MINI_VER,PY_SRV_VER_CURRENT); @@ -1590,9 +1610,7 @@ static int udp_socket_init() return listen_sock; } -#include "cmsis_os2.h" -extern osStatus_t osDelay(uint32_t ticks); -#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */ + void cat1_server_task(void *pvParameters) { char rx_buffer[512]; diff --git a/code/sdk/zhihui/4g/cat1Service/include/custom_http_download.h b/code/sdk/zhihui/4g/cat1Service/include/custom_http_download.h index 6074d0c9e..05f8fea92 100644 --- a/code/sdk/zhihui/4g/cat1Service/include/custom_http_download.h +++ b/code/sdk/zhihui/4g/cat1Service/include/custom_http_download.h @@ -6,7 +6,7 @@ extern "C" { #endif /* __cplusplus */ #include "errcode.h" #ifdef SUPPORT_CAT1_SERVICE -#include "http_client.h" +#include "lwip/apps/http_client.h" #include "lwip/altcp.h" /* Define httpc_file_rx_fn if not already defined */ diff --git a/code/sdk/zhihui/4gTest/cat1_porting.c b/code/sdk/zhihui/4gTest/cat1_porting.c index 07fcafdd1..a78373cfd 100644 --- a/code/sdk/zhihui/4gTest/cat1_porting.c +++ b/code/sdk/zhihui/4gTest/cat1_porting.c @@ -20,7 +20,7 @@ struct timezone { int tz_dsttime; }; -uint8_t g_cat1_enable_debug=CAT1_LOG_LEVEL_WARNING;//CAT1_LOG_LEVEL_MAX; +uint8_t g_cat1_enable_debug=CAT1_LOG_LEVEL_MAX;//CAT1_LOG_LEVEL_WARNING;//CAT1_LOG_LEVEL_MAX; static uint16_t g_timezone_quarters = 0xFFFF; /** diff --git a/code/sdk/zhihui/ai_stub/src/ppp_stub_functions.c b/code/sdk/zhihui/ai_stub/src/ppp_stub_functions.c index 4ac37f2b3..bbae59a7b 100644 --- a/code/sdk/zhihui/ai_stub/src/ppp_stub_functions.c +++ b/code/sdk/zhihui/ai_stub/src/ppp_stub_functions.c @@ -9,25 +9,32 @@ #include #include -#ifndef SUPPORT_CAT1_SERVICE - -/** - * @brief HTTP客户端文件下载桩函数 - * @param url 下载URL - * @param file_path 本地文件路径 - * @param timeout 超时时间 - * @return 总是返回失败(-1) - */ -int httpc_get_file_dns_to_disk(const char *url, const char *file_path, int timeout) -{ - (void)url; - (void)file_path; - (void)timeout; +// /* 检查lwip库是否提供了httpc_get_file_dns_to_disk函数 */ +// /* 如果lwip库可用且启用了HTTP客户端文件IO功能,就不需要桩函数 */ +// #if !defined(LWIP_HTTPC_HAVE_FILE_IO) || (LWIP_HTTPC_HAVE_FILE_IO == 0) +// #ifndef SUPPORT_CAT1_SERVICE + +// /** +// * @brief HTTP客户端文件下载桩函数 +// * @param url 下载URL +// * @param file_path 本地文件路径 +// * @param timeout 超时时间 +// * @return 总是返回失败(-1) +// * +// * 注意:如果lwip库已经提供了httpc_get_file_dns_to_disk函数(LWIP_HTTPC_HAVE_FILE_IO=1), +// * 此桩函数不会被编译,以避免符号冲突 +// */ +// int httpc_get_file_dns_to_disk(const char *url, const char *file_path, int timeout) +// { +// (void)url; +// (void)file_path; +// (void)timeout; - // 桩函数 - 不实现实际功能 - return -1; -} -#endif +// // 桩函数 - 不实现实际功能 +// return -1; +// } +// #endif +// #endif /* LWIP_HTTPC_HAVE_FILE_IO */ diff --git a/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt b/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt index cdf3820da..bbc62b5f2 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt +++ b/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt @@ -24,6 +24,7 @@ set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/ln_http_client.c ${CMAKE_CURRENT_SOURCE_DIR}/ln_http_download_client.c ${CMAKE_CURRENT_SOURCE_DIR}/ln_file_write_queue.c + ${CMAKE_CURRENT_SOURCE_DIR}/zhihui_http_client.c ) # 公共头文件路径(供其他模块引用) diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ZHIHUI_HTTP_CLIENT_README.md b/code/sdk/zhihui/leiniao/imsl_ln/ZHIHUI_HTTP_CLIENT_README.md new file mode 100644 index 000000000..8478b1fb2 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ZHIHUI_HTTP_CLIENT_README.md @@ -0,0 +1,203 @@ +# zhihui_http_client 使用说明 + +## 概述 + +`zhihui_http_client` 是基于 lwIP 标准 HTTP 客户端的 HTTP/HTTPS 下载实现,支持: +- HTTP 和 HTTPS 下载 +- SSL/TLS 配置(超时、加密算法等) +- 性能优化(可配置 SSL 参数以解决超时问题) +- 与现有 OpenHarmony HttpClient 接口兼容 + +## 切换实现 + +在 `ln_api.h` 中通过宏 `LN_HTTP_USE_LWIP_CLIENT` 切换: + +```c +/* 0=使用 OpenHarmony HttpClient(默认) */ +/* 1=使用 lwIP HTTP 客户端 */ +#define LN_HTTP_USE_LWIP_CLIENT 0 +``` + +## 接口说明 + +### 基本下载接口 + +```c +int zhihui_http_download_file_resume( + const char *url, // 文件 URL(支持 http:// 和 https://) + const char *save_path, // 保存路径 + size_t resume_offset, // 续传偏移量(0 表示从头开始) + const zhihui_ssl_config_t *ssl_config, // SSL 配置(HTTPS 需要,HTTP 可传 NULL) + zhihui_http_result_fn result_cb, // 结果回调函数(可选) + zhihui_http_progress_fn progress_cb,// 进度回调函数(可选) + void *callback_arg // 回调函数参数 +); +``` + +### SSL 配置 + +```c +typedef struct { + const uint8_t *ca_cert; // CA 证书(PEM 格式),NULL 表示使用默认 + size_t ca_cert_len; // CA 证书长度 + uint32_t handshake_timeout_ms; // SSL 握手超时(毫秒),0 表示默认 + uint32_t read_timeout_ms; // SSL 读取超时(毫秒),0 表示默认 + uint32_t write_timeout_ms; // SSL 写入超时(毫秒),0 表示默认 + bool skip_cert_verify; // 是否跳过证书验证(仅用于测试) + const int *cipher_suites; // 加密套件数组(NULL 表示使用默认) + int min_tls_version; // 最小 TLS 版本(0 表示默认) + int max_tls_version; // 最大 TLS 版本(0 表示默认) +} zhihui_ssl_config_t; +``` + +### 使用示例 + +#### 1. 基本 HTTP 下载 + +```c +int ret = zhihui_http_download_file( + "http://example.com/file.bin", + "/path/to/save/file.bin", + NULL, // HTTP 不需要 SSL 配置 + NULL, // 结果回调(可选) + NULL, // 进度回调(可选) + NULL // 回调参数 +); +``` + +#### 2. HTTPS 下载(使用默认 SSL 配置) + +```c +const zhihui_ssl_config_t *ssl_config = zhihui_ssl_config_default(true); // true=跳过验证(测试用) +int ret = zhihui_http_download_file( + "https://example.com/file.bin", + "/path/to/save/file.bin", + ssl_config, + NULL, + NULL, + NULL +); +``` + +#### 3. HTTPS 下载(自定义 SSL 配置) + +```c +zhihui_ssl_config_t ssl_config = {0}; +zhihui_ssl_config_init( + &ssl_config, + ca_cert_pem, // CA 证书(PEM 格式) + ca_cert_len, // CA 证书长度 + 30000, // 握手超时 30 秒 + false // 不跳过验证 +); + +/* 配置高性能加密套件(可选) */ +static const int fast_ciphers[] = { + MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, + MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, + 0 // 结束标记 +}; +ssl_config.cipher_suites = fast_ciphers; + +int ret = zhihui_http_download_file( + "https://example.com/file.bin", + "/path/to/save/file.bin", + &ssl_config, + NULL, + NULL, + NULL +); +``` + +## SSL 性能优化 + +### 1. 调整超时时间 + +```c +ssl_config.handshake_timeout_ms = 60000; // 握手超时 60 秒 +ssl_config.read_timeout_ms = 30000; // 读取超时 30 秒 +``` + +### 2. 使用高性能加密套件 + +```c +/* 推荐的高性能加密套件(按性能排序) */ +static const int fast_ciphers[] = { + MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, // 最快 + MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, + MBEDTLS_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, + 0 +}; +ssl_config.cipher_suites = fast_ciphers; +``` + +### 3. 限制 TLS 版本 + +```c +/* 仅使用 TLS 1.2 和 1.3(避免旧版本性能问题) */ +ssl_config.min_tls_version = MBEDTLS_SSL_VERSION_TLS1_2; +ssl_config.max_tls_version = MBEDTLS_SSL_VERSION_TLS1_3; +``` + +## 注意事项 + +1. **异步操作**:lwIP HTTP 客户端是异步的,下载结果通过回调函数通知。如果需要同步等待,需要在回调中设置信号量或事件。 + +2. **断点续传**:当前实现中,lwIP HTTP 客户端不支持自定义 Range 头,断点续传功能受限。如果需要完整的断点续传支持,需要扩展 lwIP HTTP 客户端。 + +3. **SSL 配置**:SSL 配置(超时、加密套件等)需要在创建 TLS 配置时设置。当前实现中,部分高级配置需要通过扩展 `altcp_tls_config` 结构来实现。 + +4. **编译依赖**:需要启用以下 lwIP 配置: + - `LWIP_ALTCP = 1` + - `LWIP_ALTCP_TLS = 1` + - `LWIP_ALTCP_TLS_MBEDTLS = 1` + - `LWIP_TCP = 1` + - `LWIP_CALLBACK_API = 1` + - `LWIP_DNS = 1` + +## 与 OpenHarmony HttpClient 的对比 + +| 特性 | OpenHarmony HttpClient | lwIP HTTP Client | +|------|----------------------|------------------| +| HTTP 支持 | ✅ | ✅ | +| HTTPS 支持 | ✅ | ✅ | +| SSL 配置 | 通过结构体字段 | 通过 `zhihui_ssl_config_t` | +| 超时配置 | 有限 | 可配置握手/读写超时 | +| 加密算法选择 | 默认 | 可自定义 | +| 断点续传 | ✅ | ⚠️ 受限 | +| 同步/异步 | 同步 | 异步 | + +## 调试 SSL 超时问题 + +1. **增加握手超时**: + ```c + ssl_config.handshake_timeout_ms = 60000; // 增加到 60 秒 + ``` + +2. **使用更快的加密套件**: + ```c + ssl_config.cipher_suites = fast_ciphers; // 使用 AES-GCM + ``` + +3. **启用调试日志**: + 在 `altcp_tls_mbedtls_opts.h` 中启用调试: + ```c + #define ALTCP_MBEDTLS_DEBUG LWIP_DBG_ON + #define ALTCP_MBEDTLS_LIB_DEBUG LWIP_DBG_ON + ``` + +4. **检查网络延迟**: + 使用 ping 或 traceroute 检查到服务器的网络延迟。 + +## TODO + +- [ ] 扩展 lwIP HTTP 客户端支持自定义 Range 头(断点续传) +- [ ] 实现同步等待机制(信号量/事件) +- [ ] 扩展 `altcp_tls_config` 以支持更多 SSL 配置选项 +- [ ] 添加 SSL 性能统计(握手时间、传输速度等) + + + + + + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c index 741a8c7f5..df67b432c 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c @@ -482,6 +482,11 @@ int uapi_ln_download_file(const char *url, const char *save_path) int ret = -1; size_t total_written = 0; // 打开文件准备写入 +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:不打开文件 */ + FILE *fd = NULL; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] Test mode: skip file open"); +#else FILE *fd = fopen(save_path, "wb+"); if (!fd) { @@ -495,12 +500,15 @@ int uapi_ln_download_file(const char *url, const char *save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] setvbuf failed, using default buffer"); } +#endif HTTPC_RESULT prep = ln_http_prepare_auto(&client_data, 2048, LN_CLIENT_PREPARE_SIZE * 2); if (prep != HTTP_SUCCESS) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] prepare failed: %d", prep); +#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE fclose(fd); +#endif g_ln_is_file_downloading = 0; return ERRCODE_FAIL; } @@ -510,7 +518,9 @@ int uapi_ln_download_file(const char *url, const char *save_path) if (ret != 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] connection failed, ret=0x%x", ret); +#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE fclose(fd); +#endif HttpClientUnprepare(&client_data); g_ln_is_file_downloading = 0; return ERRCODE_FAIL; @@ -521,22 +531,51 @@ int uapi_ln_download_file(const char *url, const char *save_path) if (ret != 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] send request failed, ret=0x%x", ret); +#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE fclose(fd); +#endif HttpClientClse(&client); HttpClientUnprepare(&client_data); g_ln_is_file_downloading = 0; return ERRCODE_FAIL; } + /* 性能统计变量 */ + uint32_t download_start_time_ms = 0; + uint32_t total_recv_time_ms = 0; + uint32_t total_write_time_ms = 0; + size_t total_bytes_received = 0; + int packet_count = 0; + + /* 记录下载开始时间 */ + extern uint32_t uapi_tcxo_get_ms(void); + download_start_time_ms = uapi_tcxo_get_ms(); + // 接收响应数据 do { + uint32_t recv_start_time_ms = uapi_tcxo_get_ms(); HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &client_data); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] recv_res = %d", recv_res); + uint32_t recv_end_time_ms = uapi_tcxo_get_ms(); + uint32_t recv_duration_ms = 0; + if (recv_end_time_ms >= recv_start_time_ms) { + recv_duration_ms = recv_end_time_ms - recv_start_time_ms; + } else { + recv_duration_ms = (0xFFFFFFFF - recv_start_time_ms) + recv_end_time_ms + 1; + } + total_recv_time_ms += recv_duration_ms; + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] recv_res = %d, recv_duration=%ums", recv_res, recv_duration_ms); if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) { if (client_data.contentBlockLen > 0) { + total_bytes_received += client_data.contentBlockLen; + uint32_t write_start_time_ms = uapi_tcxo_get_ms(); +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:只统计不写入 */ + size_t written = client_data.contentBlockLen; /* 模拟写入成功 */ +#else size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd); WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] written = %zu", written); if (written != client_data.contentBlockLen) @@ -548,7 +587,23 @@ int uapi_ln_download_file(const char *url, const char *save_path) HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } +#endif + uint32_t write_end_time_ms = uapi_tcxo_get_ms(); + uint32_t write_duration_ms = 0; + if (write_end_time_ms >= write_start_time_ms) { + write_duration_ms = write_end_time_ms - write_start_time_ms; + } else { + write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1; + } + total_write_time_ms += write_duration_ms; + total_written += written; + packet_count++; + + /* 打印性能日志 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF] packet=%d, data_len=%d, recv_duration=%ums, write_duration=%ums", + packet_count, client_data.contentBlockLen, recv_duration_ms, write_duration_ms); } } else @@ -557,6 +612,59 @@ int uapi_ln_download_file(const char *url, const char *save_path) break; } } while (client_data.isMore); + + /* 计算下载总耗时和性能统计 */ + uint32_t download_end_time_ms = uapi_tcxo_get_ms(); + uint32_t total_download_time_ms = 0; + if (download_end_time_ms >= download_start_time_ms) { + total_download_time_ms = download_end_time_ms - download_start_time_ms; + } else { + total_download_time_ms = (0xFFFFFFFF - download_start_time_ms) + download_end_time_ms + 1; + } + + /* 计算网络速度(KB/s) */ + float network_speed_kbps = 0.0f; + float recv_speed_kbps = 0.0f; + float write_speed_kbps = 0.0f; + if (total_download_time_ms > 0) { + network_speed_kbps = (total_bytes_received * 1000.0f) / (total_download_time_ms * 1024.0f); + } + if (total_recv_time_ms > 0) { + recv_speed_kbps = (total_bytes_received * 1000.0f) / (total_recv_time_ms * 1024.0f); + } + if (total_write_time_ms > 0 && total_bytes_received > 0) { + write_speed_kbps = (total_bytes_received * 1000.0f) / (total_write_time_ms * 1024.0f); + } + + /* 打印性能统计报告 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] ========================================="); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总下载时间: %u ms (%.2f 秒)", + total_download_time_ms, total_download_time_ms / 1000.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总接收字节: %zu bytes (%.2f KB)", + total_bytes_received, total_bytes_received / 1024.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总接收耗时: %u ms (%.2f%% 总时间)", + total_recv_time_ms, (total_download_time_ms > 0) ? (total_recv_time_ms * 100.0f / total_download_time_ms) : 0.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总写入耗时: %u ms (%.2f%% 总时间)", + total_write_time_ms, (total_download_time_ms > 0) ? (total_write_time_ms * 100.0f / total_download_time_ms) : 0.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 平均网络速度: %.2f KB/s", network_speed_kbps); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 平均接收速度: %.2f KB/s", recv_speed_kbps); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 平均写入速度: %.2f KB/s", write_speed_kbps); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 数据包数量: %d", packet_count); +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 测试模式: 只统计不写入文件"); +#endif + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] ========================================="); if (client_data.responseContentLen == 0) { @@ -571,6 +679,7 @@ int uapi_ln_download_file(const char *url, const char *save_path) else { ret = ERRCODE_FAIL; +#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 文件下载失败删除不完整文件,save_path = %s", save_path); int ret = 0; ret = unlink(save_path); @@ -582,11 +691,18 @@ int uapi_ln_download_file(const char *url, const char *save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "删除不完整文件成功\r\n"); } +#else + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 文件下载失败 (测试模式,不删除文件)"); +#endif } HttpClientUnprepare(&client_data); HttpClientClse(&client); +#if !LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE fclose(fd); +#else + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] Test mode: skip file close"); +#endif g_ln_is_file_downloading = 0; #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) @@ -631,8 +747,37 @@ int uapi_ln_download_with_retry(const char *url, const char *save_path, int max_ @param save_path 保存路径(若存在则尝试从已下载大小处续传) @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败(失败不删除部分文件) */ +#if LN_HTTP_USE_LWIP_CLIENT +#include "zhihui_http_client.h" +#endif + int uapi_ln_download_file_resume(const char *url, const char *save_path) { +#if LN_HTTP_USE_LWIP_CLIENT + /* 使用 lwIP HTTP 客户端实现 */ + long long resume_offset = 0; + /* 判断是否存在部分文件,计算续传偏移 */ + { + FILE *fexist = fopen(save_path, "rb"); + if (fexist) + { + if (fseek(fexist, 0, SEEK_END) == 0) + { + long pos = ftell(fexist); + if (pos > 0) + resume_offset = (long long)pos; + } + fclose(fexist); + } + } + + /* 使用默认 SSL 配置(跳过验证,仅用于测试) */ + const zhihui_ssl_config_t *ssl_config = zhihui_ssl_config_default(true); + + /* 调用 lwIP HTTP 客户端 */ + return zhihui_http_download_file_resume(url, save_path, (size_t)resume_offset, ssl_config, NULL, NULL, NULL); +#else + /* 使用 OpenHarmony HttpClient 实现(原有实现) */ if (!url || !save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] url or save_path is NULL"); @@ -677,6 +822,16 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) int ret = -1; size_t total_written = 0; + /* 性能统计变量 */ + uint32_t download_start_time_ms = 0; + uint32_t total_recv_time_ms = 0; + uint32_t total_write_time_ms = 0; + size_t total_bytes_received = 0; + + /* 记录下载开始时间 */ + extern uint32_t uapi_tcxo_get_ms(void); + download_start_time_ms = uapi_tcxo_get_ms(); + #if LN_HTTP_DOWNLOAD_USE_QUEUE /* 文件句柄和写入上下文(用于异步写入) */ FILE *fd = NULL; @@ -690,6 +845,12 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) int is_first_packet = 1; /* 是否为第一包 */ #else /* 直接写文件模式:打开文件 */ + int packet_count = 0; /* 数据包计数 */ +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:不打开文件 */ + FILE *fd = NULL; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file open"); +#else const char *open_mode = resume_offset > 0 ? "ab+" : "wb+"; FILE *fd = fopen(save_path, open_mode); if (!fd) @@ -705,6 +866,7 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) } /* 如果续传,文件已打开在末尾位置,无需额外操作 */ +#endif #endif if(resume_offset > 0) @@ -749,6 +911,29 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] set header %s", header_buf); } + /* 根据URL判断HTTP/HTTPS并设置客户端参数 */ + if (url) + { + if (strncmp(url, "https://", 8) == 0) + { + client.isHttp = false; /* HTTPS */ + client.remotePort = 443; + } + else if (strncmp(url, "http://", 7) == 0) + { + client.isHttp = true; /* HTTP */ + client.remotePort = 80; + } + else + { + /* 默认使用HTTPS */ + client.isHttp = false; + client.remotePort = 443; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] URL协议未知,默认使用HTTPS: %s", url); + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] URL=%s, isHttp=%d, port=%d", url, client.isHttp, client.remotePort); + } + /* 建立连接并发送请求 */ ret = HttpClientConn(&client, url); if (ret != 0) @@ -802,6 +987,10 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) write_ctx.total_written = 0; write_ctx.ref_count = 0; is_first_packet = 1; +#else +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:不重新打开文件 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file reopen"); #else /* 重新打开文件为覆盖模式 */ fclose(fd); @@ -818,14 +1007,20 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] setvbuf failed, using default buffer"); } +#endif #endif } /* 写入首块内容(若有)*/ if (client_data.contentBlockLen > 0) { + uint32_t write_start_time_ms = uapi_tcxo_get_ms(); #if LN_HTTP_DOWNLOAD_USE_QUEUE const char *open_mode = resume_offset > 0 ? "ab+" : "wb+"; +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:只统计不写入 */ + errcode_t write_ret = ERRCODE_SUCC; /* 模拟成功 */ +#else errcode_t write_ret = ln_file_write_queue_add_task( &fd, &write_ctx, @@ -844,12 +1039,26 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } +#endif + uint32_t write_end_time_ms = uapi_tcxo_get_ms(); + uint32_t write_duration_ms = 0; + if (write_end_time_ms >= write_start_time_ms) { + write_duration_ms = write_end_time_ms - write_start_time_ms; + } else { + write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1; + } + total_write_time_ms += write_duration_ms; total_written += client_data.contentBlockLen; + total_bytes_received += client_data.contentBlockLen; packet_count++; is_first_packet = 0; #else /* 直接写入文件 */ +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:只统计不写入 */ + size_t written = client_data.contentBlockLen; /* 模拟写入成功 */ +#else size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd); if (written != client_data.contentBlockLen) { @@ -861,7 +1070,18 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } +#endif + uint32_t write_end_time_ms = uapi_tcxo_get_ms(); + uint32_t write_duration_ms = 0; + if (write_end_time_ms >= write_start_time_ms) { + write_duration_ms = write_end_time_ms - write_start_time_ms; + } else { + write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1; + } + total_write_time_ms += write_duration_ms; + total_written += written; + total_bytes_received += client_data.contentBlockLen; #endif } } @@ -889,7 +1109,35 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) } #endif + /* 记录接收开始时间 */ + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t recv_start_time_ms = uapi_tcxo_get_ms(); + HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &client_data); + + /* 记录接收结束时间并计算耗时 */ + uint32_t recv_end_time_ms = uapi_tcxo_get_ms(); + uint32_t recv_duration_ms = 0; + if (recv_end_time_ms >= recv_start_time_ms) { + recv_duration_ms = recv_end_time_ms - recv_start_time_ms; + } else { + /* 处理时间戳溢出 */ + recv_duration_ms = (0xFFFFFFFF - recv_start_time_ms) + recv_end_time_ms + 1; + } + + /* 累计接收耗时和接收字节数 */ + total_recv_time_ms += recv_duration_ms; + if (client_data.contentBlockLen > 0) { + total_bytes_received += client_data.contentBlockLen; + } + +#if LN_HTTP_DOWNLOAD_USE_QUEUE + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv_res=%d, isMore=%d, contentBlockLen=%d, total_written=%zu, ref_count=%u, recv_duration=%ums", + recv_res, client_data.isMore, client_data.contentBlockLen, total_written, write_ctx.ref_count, recv_duration_ms); +#else + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv_res=%d, isMore=%d, contentBlockLen=%d, total_written=%zu, recv_duration=%ums", + recv_res, client_data.isMore, client_data.contentBlockLen, total_written, recv_duration_ms); +#endif if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) { if (client_data.contentBlockLen > 0) @@ -898,6 +1146,21 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) /* 判断是否为最后一包 */ int is_last = (!client_data.isMore) ? 1 : 0; + /* 记录入队前时间 */ + uint32_t enqueue_start_time_ms = uapi_tcxo_get_ms(); + +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:只统计不写入 */ + errcode_t write_ret = ERRCODE_SUCC; /* 模拟成功 */ + uint32_t enqueue_end_time_ms = uapi_tcxo_get_ms(); + uint32_t enqueue_duration_ms = 0; + if (enqueue_end_time_ms >= enqueue_start_time_ms) { + enqueue_duration_ms = enqueue_end_time_ms - enqueue_start_time_ms; + } else { + enqueue_duration_ms = (0xFFFFFFFF - enqueue_start_time_ms) + enqueue_end_time_ms + 1; + } + total_write_time_ms += enqueue_duration_ms; +#else /* 使用异步写入队列 */ errcode_t write_ret = ln_file_write_queue_add_task( &fd, @@ -910,6 +1173,17 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) is_last /* is_last_packet */ ); + /* 记录入队后时间并计算入队耗时 */ + uint32_t enqueue_end_time_ms = uapi_tcxo_get_ms(); + uint32_t enqueue_duration_ms = 0; + if (enqueue_end_time_ms >= enqueue_start_time_ms) { + enqueue_duration_ms = enqueue_end_time_ms - enqueue_start_time_ms; + } else { + /* 处理时间戳溢出 */ + enqueue_duration_ms = (0xFFFFFFFF - enqueue_start_time_ms) + enqueue_end_time_ms + 1; + } + total_write_time_ms += enqueue_duration_ms; + if (write_ret != ERRCODE_SUCC) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Failed to add write task"); if (header_buf) free(header_buf); @@ -918,10 +1192,16 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } +#endif total_written += client_data.contentBlockLen; packet_count++; + /* 打印下载性能分析日志:接收耗时、入队耗时 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF] packet=%d, data_len=%d, recv_duration=%ums, enqueue_duration=%ums", + packet_count, client_data.contentBlockLen, recv_duration_ms, enqueue_duration_ms); + /* 检查写入错误 */ if (ln_file_write_queue_get_status(&write_ctx) == LN_FILE_WRITE_STATUS_ERROR) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Write error detected"); @@ -936,6 +1216,11 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) total_written, packet_count); #else /* 直接写入文件 */ + uint32_t write_start_time_ms = uapi_tcxo_get_ms(); +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:只统计不写入 */ + size_t written = client_data.contentBlockLen; /* 模拟写入成功 */ +#else size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd); if (written != client_data.contentBlockLen) { @@ -947,22 +1232,59 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } +#endif + uint32_t write_end_time_ms = uapi_tcxo_get_ms(); + uint32_t write_duration_ms = 0; + if (write_end_time_ms >= write_start_time_ms) { + write_duration_ms = write_end_time_ms - write_start_time_ms; + } else { + write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1; + } + total_write_time_ms += write_duration_ms; + total_written += written; + packet_count++; + + /* 打印写入性能日志 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF] packet=%d, data_len=%d, recv_duration=%ums, write_duration=%ums", + packet_count, client_data.contentBlockLen, recv_duration_ms, write_duration_ms); #endif } } else { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d", recv_res); - /* 网络异常,标记下载失败 */ + + /* 网络异常,标记写入队列错误状态,停止继续添加任务 */ + /* 关键设计改进:设置ERROR状态,但wait_done会等待所有已提交的任务完成(ref_count==0) */ + /* 这样可以确保文件大小准确,避免重试时offset计算错误 */ +#if LN_HTTP_DOWNLOAD_USE_QUEUE + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d, isMore=%d, total_written=%zu, ref_count=%u", + recv_res, client_data.isMore, total_written, write_ctx.ref_count); + write_ctx.status = LN_FILE_WRITE_STATUS_ERROR; + write_ctx.error_code = ERRCODE_FAIL; +#else + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d, isMore=%d, total_written=%zu", + recv_res, client_data.isMore, total_written); +#endif break; } } int final_code = HttpClientGetResponseCode(&client); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu", final_code, total_written); +#if LN_HTTP_DOWNLOAD_USE_QUEUE + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu, isMore=%d, ref_count=%u, status=%d", + final_code, total_written, client_data.isMore, write_ctx.ref_count, write_ctx.status); +#else + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu, isMore=%d", + final_code, total_written, client_data.isMore); +#endif #if LN_HTTP_DOWNLOAD_USE_QUEUE +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:不等待写入队列 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip waiting for write queue"); +#else /* 判断下载是否成功:只有HTTP状态码200/206且正常结束才等待文件写入完成 */ int download_success = ((final_code == 200 || final_code == 206) && client_data.isMore == 0); @@ -974,26 +1296,136 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Wait for write tasks timeout or error"); } } else { - /* 下载失败(网络异常等),不等待文件写入完成,直接关闭文件 */ - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download failed (code=%d, isMore=%d), skip waiting for write tasks", + /* 下载失败(网络异常等),但仍需等待写入队列完成,确保文件大小准确用于重试 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download failed (code=%d, isMore=%d), waiting for write tasks to complete...", final_code, client_data.isMore); + /* 等待写入队列完成,使用较长的超时时间(30秒),确保所有任务都完成(ref_count==0) */ + errcode_t wait_ret = ln_file_write_queue_wait_done(&write_ctx, 30000); /* 最多等待30秒 */ + if (wait_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Wait for write tasks timeout after 30s, status=%d, ref_count=%u, but continue to close file", + write_ctx.status, write_ctx.ref_count); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] All write tasks completed successfully, ref_count=%u, total_written=%zu", + write_ctx.ref_count, write_ctx.total_written); + } } +#endif +#endif - /* 获取实际写入的字节数 */ - size_t actual_written = ln_file_write_queue_get_written(&write_ctx); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Actual written: %zu bytes", actual_written); + /* 安全关闭文件并获取实际写入大小 */ + size_t actual_written = 0; - /* 安全关闭文件 */ +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 异步队列写入模式 */ + /* 安全关闭文件(会等待文件关闭完成) */ +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:不关闭文件(文件可能未打开) */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file close"); + actual_written = total_written; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: actual_written=%zu bytes (from total_written)", actual_written); +#else ln_file_write_queue_close_file(&fd, &write_ctx); + + /* 关键设计改进:关闭文件后,从文件系统读取实际文件大小,而不是使用记录的total_written */ + /* 这样可以确保重试时offset的准确性,避免因写入失败或部分写入导致的不一致 */ + { + FILE *fcheck = fopen(save_path, "rb"); + if (fcheck) { + if (fseek(fcheck, 0, SEEK_END) == 0) { + long file_size = ftell(fcheck); + if (file_size >= 0) { + actual_written = (size_t)file_size; + } + } + fclose(fcheck); + } + } + + /* 验证文件实际大小与记录的一致性(用于调试) */ + size_t recorded_written = ln_file_write_queue_get_written(&write_ctx); + if (actual_written != recorded_written) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 文件大小不一致: 实际文件=%zu字节, 记录=%zu字节, 使用实际文件大小", + actual_written, recorded_written); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 文件大小验证通过: %zu字节", actual_written); + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Final actual_written: %zu bytes (from file system)", actual_written); +#endif #else /* 直接写文件模式:刷新缓冲区并关闭文件 */ +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + /* 测试模式:不关闭文件(文件可能未打开) */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode: skip file close"); + actual_written = total_written; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Test mode (no write), total_written=%zu bytes", actual_written); +#else fflush(fd); fclose(fd); - size_t actual_written = total_written; + actual_written = total_written; WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Direct write mode, total_written=%zu bytes", actual_written); #endif +#endif + + /* 计算下载总耗时和性能统计 */ + uint32_t download_end_time_ms = uapi_tcxo_get_ms(); + uint32_t total_download_time_ms = 0; + if (download_end_time_ms >= download_start_time_ms) { + total_download_time_ms = download_end_time_ms - download_start_time_ms; + } else { + total_download_time_ms = (0xFFFFFFFF - download_start_time_ms) + download_end_time_ms + 1; + } + + /* 计算网络速度(KB/s) */ + float network_speed_kbps = 0.0f; + float recv_speed_kbps = 0.0f; + float write_speed_kbps = 0.0f; + if (total_download_time_ms > 0) { + network_speed_kbps = (total_bytes_received * 1000.0f) / (total_download_time_ms * 1024.0f); + } + if (total_recv_time_ms > 0) { + recv_speed_kbps = (total_bytes_received * 1000.0f) / (total_recv_time_ms * 1024.0f); + } + if (total_write_time_ms > 0 && total_bytes_received > 0) { + write_speed_kbps = (total_bytes_received * 1000.0f) / (total_write_time_ms * 1024.0f); + } + + /* 打印性能统计报告 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] ========================================="); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总下载时间: %u ms (%.2f 秒)", + total_download_time_ms, total_download_time_ms / 1000.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总接收字节: %zu bytes (%.2f KB)", + total_bytes_received, total_bytes_received / 1024.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总接收耗时: %u ms (%.2f%% 总时间)", + total_recv_time_ms, (total_download_time_ms > 0) ? (total_recv_time_ms * 100.0f / total_download_time_ms) : 0.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 总写入耗时: %u ms (%.2f%% 总时间)", + total_write_time_ms, (total_download_time_ms > 0) ? (total_write_time_ms * 100.0f / total_download_time_ms) : 0.0f); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 平均网络速度: %.2f KB/s", network_speed_kbps); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 平均接收速度: %.2f KB/s", recv_speed_kbps); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 平均写入速度: %.2f KB/s", write_speed_kbps); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 数据包数量: %d", packet_count); +#if LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] 测试模式: 只统计不写入文件"); +#endif + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[DOWNLOAD_PERF_REPORT] ========================================="); + + /* 判断下载是否真正成功:需要HTTP状态码200/206、有数据写入、且下载完成(isMore=0) */ + int is_download_complete = (client_data.isMore == 0); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 判断下载结果: final_code=%d, actual_written=%zu, isMore=%d, is_complete=%d", + final_code, actual_written, client_data.isMore, is_download_complete); - if ((final_code == 200 || final_code == 206) && actual_written > 0) + if ((final_code == 200 || final_code == 206) && actual_written > 0 && is_download_complete) { ret = ERRCODE_SUCC; WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载成功 (%s), written=%zu", @@ -1002,7 +1434,12 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) else { ret = ERRCODE_FAIL; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载失败,保留部分文件供下次续传"); + if (actual_written > 0 && !is_download_complete) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载未完成(isMore=%d),保留部分文件供下次续传,已写入=%zu字节", + client_data.isMore, actual_written); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载失败,保留部分文件供下次续传"); + } } if (header_buf) free(header_buf); @@ -1015,7 +1452,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) #endif return ret; +#endif /* LN_HTTP_USE_LWIP_CLIENT */ } + /* 断点续传下载函数封装:带重试,不做UI通知与资源释放 */ int uapi_ln_download_file_resume_with_retry(const char *url, const char *save_path, int max_retries) { diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h index 891c471de..303efffbf 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h @@ -87,6 +87,25 @@ typedef struct #define LN_HTTP_DOWNLOAD_USE_QUEUE 1 // 默认使用异步队列写入 #endif +/* 测试模式:只统计不写入文件,用于评测网络速度(1=只统计不写入,0=正常写入) */ +#ifndef LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE +#define LN_HTTP_DOWNLOAD_TEST_MODE_NO_WRITE 1 // 1=只统计不写入,0=正常写入 +#endif + +/* HTTP 下载实现选择:0=使用 OpenHarmony HttpClient,1=使用 lwIP HTTP 客户端 */ +#ifndef LN_HTTP_USE_LWIP_CLIENT +#define LN_HTTP_USE_LWIP_CLIENT 1 // 0=OpenHarmony HttpClient,1=lwIP HTTP Client (默认使用 zhihui_http_client) +#endif + +/* 表情下载测试模式:启用后所有表情都从固定测试地址下载(1=启用测试模式,0=正常模式) */ +#ifndef LN_EMOJI_DOWNLOAD_TEST_MODE +#define LN_EMOJI_DOWNLOAD_TEST_MODE 0 // 0=正常模式,1=测试模式 +#endif + +#if LN_EMOJI_DOWNLOAD_TEST_MODE +#define LN_EMOJI_TEST_BASE_URL "http://110.42.224.129:8089/LEINIAO/blue" +#endif + #define LN_HTTP_SERVICE_CMD_GET_DEVICE_TOKEN 0x1 /* 获取设备 token */ #define LN_HTTP_SERVICE_CMD_SPEECH_CHAT_STREAM 0x2 /* 语音对话流 */ #define LN_HTTP_SERVICE_CMD_SSE_RECV 0x3 /* 语音对话流分片接收 */ diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c index 6bea265d8..9f8428994 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c @@ -527,7 +527,48 @@ static void ln_emoji_download(void *arg) uapi_create_folder(dir_buf); } } - if (uapi_ln_download_file_resume_with_retry(pkg->emojis[i].emojiUrl, save_path, 10) != ERRCODE_SUCC) + + /* 测试模式:从固定测试地址下载 */ + const char *download_url = pkg->emojis[i].emojiUrl; + char test_url[MAX_PATH_LEN] = {0}; +#if LN_EMOJI_DOWNLOAD_TEST_MODE + /* 测试模式:根据emotion名称映射到测试文件名 */ + const char *emotion = pkg->emojis[i].emotion ? pkg->emojis[i].emotion : ""; + const char *test_filename = NULL; + + /* 映射emotion到测试文件名(只支持测试服务器上存在的文件) */ + if (strcmp(emotion, "angry") == 0) { + test_filename = "angry.zip"; + } else if (strcmp(emotion, "dizzy") == 0) { + test_filename = "dizzy.zip"; + } else if (strcmp(emotion, "heartbeat") == 0) { + test_filename = "heartbeat.zip"; + } else if (strcmp(emotion, "laughing") == 0) { + test_filename = "laughing.zip"; + } else if (strcmp(emotion, "shocked") == 0) { + test_filename = "shocked.zip"; + } else if (strcmp(emotion, "sleepy") == 0) { + test_filename = "sleepy.zip"; + } else if (strcmp(emotion, "speechless") == 0) { + test_filename = "speechless.zip"; + } else if (strcmp(emotion, "wronged") == 0) { + test_filename = "wronged.zip"; + } + + /* 测试模式:强制使用测试URL,如果没有对应的测试文件,使用第一个可用的测试文件作为默认 */ + if (test_filename) { + snprintf(test_url, sizeof(test_url), "%s/%s", LN_EMOJI_TEST_BASE_URL, test_filename); + download_url = test_url; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 测试模式: emotion=%s, 使用测试URL=%s", emotion, download_url); + } else { + /* 没有对应的测试文件,使用默认测试文件(angry.mp4) */ + snprintf(test_url, sizeof(test_url), "%s/angry.mp4", LN_EMOJI_TEST_BASE_URL); + download_url = test_url; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 测试模式: emotion=%s 没有对应的测试文件,使用默认测试URL=%s", emotion, download_url); + } +#endif + + if (uapi_ln_download_file_resume_with_retry(download_url, save_path, 10) != ERRCODE_SUCC) { all_success = 0; failed_count++; diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c index fd4a41c94..9cfb19e10 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c @@ -35,6 +35,17 @@ static void ln_file_write_thread(void *arg) int ret = osal_msg_queue_read_copy(g_file_write_queue, (void *)&task, &msg_size, OSAL_MSGQ_WAIT_FOREVER); if (ret == OSAL_SUCCESS && msg_size == sizeof(ln_file_write_task_t)) { + /* 记录出队时间戳并计算队列等待时间(用于性能分析) */ + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t dequeue_time_ms = uapi_tcxo_get_ms(); + uint32_t queue_wait_time_ms = 0; + if (dequeue_time_ms >= task.enqueue_time_ms) { + queue_wait_time_ms = dequeue_time_ms - task.enqueue_time_ms; + } else { + /* 处理时间戳溢出 */ + queue_wait_time_ms = (0xFFFFFFFF - task.enqueue_time_ms) + dequeue_time_ms + 1; + } + /* 更新状态为正在写入 */ if (task.ctx) { task.ctx->status = LN_FILE_WRITE_STATUS_WRITING; @@ -85,8 +96,28 @@ static void ln_file_write_thread(void *arg) /* 写入数据(关闭任务可能 data_len=0,跳过写入) */ if (task.file_handle && *task.file_handle && task.data && task.data_len > 0) { + /* 记录写入开始时间 */ + uint32_t write_start_time_ms = uapi_tcxo_get_ms(); + size_t written = fwrite(task.data, 1, task.data_len, *task.file_handle); + /* 记录写入结束时间并计算耗时 */ + uint32_t write_end_time_ms = uapi_tcxo_get_ms(); + uint32_t write_duration_ms = 0; + if (write_end_time_ms >= write_start_time_ms) { + write_duration_ms = write_end_time_ms - write_start_time_ms; + } else { + /* 处理时间戳溢出 */ + write_duration_ms = (0xFFFFFFFF - write_start_time_ms) + write_end_time_ms + 1; + } + + /* 打印性能分析日志:入队时间、出队时间、队列等待时间、写入耗时 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_PERF] data_len=%zu, enqueue=%u, dequeue=%u, queue_wait=%ums, write_duration=%ums, total=%ums", + task.data_len, task.enqueue_time_ms, dequeue_time_ms, + queue_wait_time_ms, write_duration_ms, + queue_wait_time_ms + write_duration_ms); + if (written != task.data_len) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] Write failed: written=%zu, expected=%zu", @@ -372,6 +403,10 @@ errcode_t ln_file_write_queue_add_task( task.is_first_packet = is_first_packet; task.is_last_packet = is_last_packet; + /* 记录入队时间戳(用于性能分析) */ + extern uint32_t uapi_tcxo_get_ms(void); + task.enqueue_time_ms = uapi_tcxo_get_ms(); + /* 更新状态为等待写入 */ ctx->status = LN_FILE_WRITE_STATUS_PENDING; ctx->ref_count++; /* 增加引用计数 */ @@ -434,14 +469,22 @@ errcode_t ln_file_write_queue_wait_done(ln_file_write_ctx_t *ctx, uint32_t timeo last_watchdog_kick_time = uapi_tcxo_get_ms(); while (elapsed < timeout_ms || timeout_ms == 0) { - if (ctx->status == LN_FILE_WRITE_STATUS_DONE) { - return ERRCODE_SUCC; - } - if (ctx->status == LN_FILE_WRITE_STATUS_ERROR) { - return ERRCODE_FAIL; - } - if (ctx->status == LN_FILE_WRITE_STATUS_CLOSED) { - return ERRCODE_SUCC; + /* 关键设计改进:即使状态是ERROR,也要等待所有已提交的任务完成(ref_count==0) */ + /* 这样可以确保文件大小准确,避免重试时offset计算错误 */ + /* 只有当ref_count==0时,才根据状态返回成功或失败 */ + if (ctx->ref_count == 0) { + /* 所有任务都已完成,根据状态返回结果 */ + if (ctx->status == LN_FILE_WRITE_STATUS_DONE || + ctx->status == LN_FILE_WRITE_STATUS_CLOSED) { + return ERRCODE_SUCC; + } else if (ctx->status == LN_FILE_WRITE_STATUS_ERROR) { + /* 即使有错误,但所有任务都已完成,文件大小是准确的,返回成功 */ + /* 这样主线程可以正确获取文件大小用于重试 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] wait_done: All tasks completed with ERROR status, but file size is accurate"); + return ERRCODE_SUCC; + } + /* 其他状态(PENDING/WRITING/CLOSING)不应该出现在ref_count==0时,但为了安全继续等待 */ } /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */ @@ -461,6 +504,10 @@ errcode_t ln_file_write_queue_wait_done(ln_file_write_ctx_t *ctx, uint32_t timeo } } + /* 超时:记录详细信息用于调试 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] wait_done timeout: status=%d, ref_count=%u, total_written=%zu", + ctx->status, ctx->ref_count, ctx->total_written); return ERRCODE_FAIL; /* 超时 */ } @@ -470,17 +517,24 @@ errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t return ERRCODE_FAIL; } - /* 等待所有写入任务完成 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: status=%d, ref_count=%u, total_written=%zu", + ctx->status, ctx->ref_count, ctx->total_written); + + /* 等待所有写入任务完成:关键设计改进,确保ref_count==0且状态为DONE或CLOSED */ if (ctx->status != LN_FILE_WRITE_STATUS_CLOSED) { - /* 等待状态变为DONE或ERROR */ + /* 等待所有任务完成:ref_count必须为0,且状态为DONE或ERROR */ uint32_t wait_count = 0; + const uint32_t MAX_WAIT_COUNT = 3000; /* 最多等待30秒(10ms * 3000) */ extern uint32_t uapi_tcxo_get_ms(void); uint32_t last_watchdog_kick_time = uapi_tcxo_get_ms(); const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000; /* 每2秒喂一次狗(看门狗超时8秒) */ - while ((ctx->status == LN_FILE_WRITE_STATUS_PENDING || - ctx->status == LN_FILE_WRITE_STATUS_WRITING) && - wait_count < 100) { + /* 关键:等待ref_count归零,确保所有任务都已完成 */ + while ((ctx->ref_count > 0 || + (ctx->status != LN_FILE_WRITE_STATUS_DONE && + ctx->status != LN_FILE_WRITE_STATUS_ERROR && + ctx->status != LN_FILE_WRITE_STATUS_CLOSED)) && + wait_count < MAX_WAIT_COUNT) { /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */ uint32_t current_time = uapi_tcxo_get_ms(); uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? @@ -496,9 +550,12 @@ errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t wait_count++; } - /* 如果还有未完成的任务,减少引用计数 */ - if (ctx->ref_count > 0) { - ctx->ref_count--; + if (wait_count >= MAX_WAIT_COUNT) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 等待写入任务超时, status=%d, ref_count=%u, total_written=%zu", + ctx->status, ctx->ref_count, ctx->total_written); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 所有写入任务已完成, status=%d, ref_count=%u, total_written=%zu", + ctx->status, ctx->ref_count, ctx->total_written); } /* 如果文件还未关闭,且不是最后一包,需要发送关闭任务 */ @@ -537,6 +594,13 @@ errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t osDelay(10); wait_count++; } + + if (wait_count >= 100) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 等待文件关闭超时, status=%d, ref_count=%u", + ctx->status, ctx->ref_count); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] close_file: 文件关闭完成, status=%d", ctx->status); + } } return ERRCODE_SUCC; diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h index 9907eaed8..755d96279 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h @@ -38,6 +38,7 @@ typedef struct { size_t data_len; /* 数据长度 */ int is_first_packet; /* 是否为第一包(需要创建文件) */ int is_last_packet; /* 是否为最后一包(写入后关闭文件) */ + uint32_t enqueue_time_ms; /* 入队时间戳(毫秒),用于性能分析 */ } ln_file_write_task_t; /** diff --git a/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.c b/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.c new file mode 100644 index 000000000..1f68c6876 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.c @@ -0,0 +1,1087 @@ +/** + * @file zhihui_http_client.c + * @brief 基于 lwIP HTTP 客户端的 HTTP/HTTPS 下载实现 + */ + +#include "zhihui_http_client.h" +#include "lwip/apps/http_client.h" +#include "lwip/altcp.h" +#include "lwip/altcp_tcp.h" +#include "lwip/altcp_tls.h" +#include "lwip/dns.h" +#include "lwip/ip_addr.h" +#include "lwip/pbuf.h" +#include "lwip/mem.h" +#include "wearable_log.h" +#include "los_task.h" +#include +#include +#include +#include + +/* 异步文件写入队列支持 */ +#if LN_HTTP_DOWNLOAD_USE_QUEUE +#include "ln_file_write_queue.h" +#endif + +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS +#include "mbedtls/ssl.h" +#include "mbedtls/ssl_ciphersuites.h" +#include "mbedtls/x509_crt.h" +#if defined(MBEDTLS_SSL_PROTO_TLS1_3) +#include "psa/crypto.h" +#endif +#endif + +/* HTTPC_CONTENT_LEN_INVALID 定义(从 http_client.c 复制) */ +#ifndef HTTPC_CONTENT_LEN_INVALID +#define HTTPC_CONTENT_LEN_INVALID 0xFFFFFFFF +#endif + +/* httpc_state_t 结构体定义(从 http_client.c 复制,用于访问内部成员) */ +struct _httpc_state_internal { + struct altcp_pcb* pcb; + ip_addr_t remote_addr; + u16_t remote_port; + int timeout_ticks; + struct pbuf *request; + struct pbuf *rx_hdrs; + u16_t rx_http_version; + u16_t rx_status; + altcp_recv_fn recv_fn; + const httpc_connection_t *conn_settings; + void* callback_arg; + u32_t rx_content_len; + u32_t hdr_content_len; + int parse_state; +#if HTTPC_DEBUG_REQUEST + char* server_name; + char* uri; +#endif +}; + +/* altcp_tls_config 结构体定义(从 altcp_tls_mbedtls.c 复制,用于访问内部成员) */ +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS +struct altcp_tls_config_internal { + mbedtls_ssl_config conf; + void *cert; + void *pkey; + uint8_t cert_count; + uint8_t cert_max; + uint8_t pkey_count; + uint8_t pkey_max; + void *ca; +}; +#endif + +/* 默认 SSL 配置 */ +static zhihui_ssl_config_t g_default_ssl_config = {0}; +static bool g_default_ssl_config_init = false; + +/* 下载状态结构 */ +typedef struct { + FILE *fd; + const char *save_path; + size_t resume_offset; + size_t total_written; + size_t total_bytes; + zhihui_http_result_fn result_cb; + zhihui_http_progress_fn progress_cb; + void *callback_arg; + int result; + uint32_t http_status; + int completed; /* 0=进行中,1=完成,-1=失败 */ + const char *hostname; /* 用于 SSL 主机名验证 */ + const zhihui_ssl_config_t *ssl_config; /* SSL 配置,用于连接后设置参数 */ + httpc_state_t *connection; /* HTTP 连接句柄 */ +#if LN_HTTP_DOWNLOAD_USE_QUEUE + ln_file_write_ctx_t write_ctx; /* 异步写入上下文 */ + int is_first_packet; /* 是否为第一包 */ +#endif +} zhihui_download_state_t; + +/* URL 解析结果 */ +typedef struct { + char protocol[8]; /* http 或 https */ + char host[256]; + uint16_t port; + char path[512]; + bool is_https; +} zhihui_url_info_t; + +/** + * @brief 解析 URL + */ +static int zhihui_parse_url(const char *url, zhihui_url_info_t *info) +{ + const char *p = url; + const char *host_start, *path_start; + int port = 0; + + memset(info, 0, sizeof(zhihui_url_info_t)); + + /* 解析协议 */ + if (strncmp(p, "https://", 8) == 0) { + strcpy(info->protocol, "https"); + info->is_https = true; + info->port = 443; + p += 8; + } else if (strncmp(p, "http://", 7) == 0) { + strcpy(info->protocol, "http"); + info->is_https = false; + info->port = 80; + p += 7; + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid URL protocol: %s", url); + return -1; + } + + host_start = p; + + /* 查找路径开始位置 */ + path_start = strchr(p, '/'); + if (path_start == NULL) { + path_start = p + strlen(p); + strcpy(info->path, "/"); + } else { + size_t path_len = strlen(path_start); + if (path_len >= sizeof(info->path)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Path too long"); + return -1; + } + strcpy(info->path, path_start); + } + + /* 提取主机和端口 */ + size_t host_len = path_start - host_start; + const char *colon = strchr(host_start, ':'); + if (colon != NULL && colon < path_start) { + /* 有端口号 */ + host_len = colon - host_start; + port = atoi(colon + 1); + if (port > 0 && port < 65536) { + info->port = (uint16_t)port; + } + } + + if (host_len >= sizeof(info->host)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Host too long"); + return -1; + } + strncpy(info->host, host_start, host_len); + info->host[host_len] = '\0'; + + return 0; +} + +/** + * @brief 扩展 lwIP HTTP 客户端:在请求中添加自定义 HTTP 头 + * @param connection HTTP 连接状态 + * @param header_name 头名称(如 "Range") + * @param header_value 头值(如 "bytes=1024-") + * @return 0 成功,-1 失败 + * + * 注意:此函数在请求发送前修改请求字符串,在 "Connection: Close\r\n" 之前插入自定义头 + */ +static int zhihui_http_add_custom_header(httpc_state_t *connection, const char *header_name, const char *header_value) +{ + if (connection == NULL || header_name == NULL || header_value == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid parameters for add_custom_header"); + return -1; + } + + /* 使用内部结构体访问成员 */ + struct _httpc_state_internal *conn = (struct _httpc_state_internal *)connection; + if (conn->request == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Connection request is NULL"); + return -1; + } + + struct pbuf *req = conn->request; + if (req->next != NULL) { + /* pbuf 必须是连续的 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Request pbuf is not contiguous"); + return -1; + } + + char *old_request = (char *)req->payload; + u16_t old_len = req->len; + + /* 构建新的头字符串 */ + char new_header[256]; + int header_len = snprintf(new_header, sizeof(new_header), "%s: %s\r\n", header_name, header_value); + if (header_len < 0 || header_len >= (int)sizeof(new_header)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Header string too long"); + return -1; + } + + /* 查找 "Connection: Close\r\n" 的位置 */ + const char *connection_marker = "Connection: Close\r\n"; + char *connection_pos = strstr(old_request, connection_marker); + if (connection_pos == NULL) { + /* 如果没有找到,尝试查找 "\r\n\r\n"(请求头结束标记) */ + connection_pos = strstr(old_request, "\r\n\r\n"); + if (connection_pos == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Cannot find insertion point for custom header"); + return -1; + } + /* 在 "\r\n\r\n" 之前插入 */ + } + + /* 计算插入位置 */ + size_t insert_pos = connection_pos - old_request; + size_t new_len = old_len + header_len; + + /* 分配新的 pbuf */ + struct pbuf *new_req = pbuf_alloc(PBUF_RAW, (u16_t)(new_len + 1), PBUF_RAM); + if (new_req == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to allocate new request pbuf"); + return -1; + } + + if (new_req->next != NULL) { + pbuf_free(new_req); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] New request pbuf is not contiguous"); + return -1; + } + + char *new_request = (char *)new_req->payload; + + /* 复制插入点之前的内容 */ + memcpy(new_request, old_request, insert_pos); + + /* 插入新的头 */ + memcpy(new_request + insert_pos, new_header, header_len); + + /* 复制插入点之后的内容 */ + memcpy(new_request + insert_pos + header_len, old_request + insert_pos, old_len - insert_pos); + + /* 确保以 null 结尾(虽然 HTTP 请求不需要,但为了安全) */ + new_request[new_len] = '\0'; + new_req->len = (u16_t)new_len; + new_req->tot_len = (u16_t)new_len; + + /* 释放旧的 pbuf 并设置新的 */ + pbuf_free(req); + conn->request = new_req; + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Added custom header: %s: %s", header_name, header_value); + return 0; +} + +/** + * @brief TLS allocator 参数结构(用于传递主机名) + */ +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS +typedef struct { + struct altcp_tls_config *tls_config; + const char *hostname; +} zhihui_tls_alloc_arg_t; + +/** + * @brief 创建 TLS allocator + */ +static struct altcp_pcb *zhihui_tls_alloc(void *arg, u8_t ip_type) +{ + zhihui_tls_alloc_arg_t *alloc_arg = (zhihui_tls_alloc_arg_t *)arg; + if (alloc_arg == NULL || alloc_arg->tls_config == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: invalid argument (alloc_arg=%p, tls_config=%p)", + alloc_arg, alloc_arg ? alloc_arg->tls_config : NULL); + return NULL; + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: creating TLS pcb, hostname=%s", + alloc_arg->hostname ? alloc_arg->hostname : "NULL"); + + struct altcp_pcb *pcb = altcp_tls_new(alloc_arg->tls_config, ip_type); + if (pcb == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: altcp_tls_new failed"); + return NULL; + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: altcp_tls_new succeeded, pcb=%p", pcb); + + /* 在创建连接后立即设置主机名(在握手前) */ + if (alloc_arg->hostname != NULL && strlen(alloc_arg->hostname) > 0) { + void *ssl_ctx = altcp_tls_context(pcb); + if (ssl_ctx == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: altcp_tls_context returned NULL, cannot set hostname"); + /* 注意:即使无法设置主机名,也继续返回 pcb,让连接尝试继续 */ + } else { + mbedtls_ssl_context *ssl = (mbedtls_ssl_context *)ssl_ctx; + int ret = mbedtls_ssl_set_hostname(ssl, alloc_arg->hostname); + if (ret != 0) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: mbedtls_ssl_set_hostname failed: %d (hostname=%s)", + ret, alloc_arg->hostname); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: SSL hostname set successfully: %s", alloc_arg->hostname); + } + } + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS alloc: hostname is NULL or empty, SNI will not be sent"); + } + + return pcb; +} +#endif + +static struct altcp_tls_config *zhihui_create_tls_config(const zhihui_ssl_config_t *ssl_config, const char *hostname) +{ + struct altcp_tls_config *tls_config = NULL; + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Creating TLS config: ssl_config=%p, hostname=%s, skip_verify=%d", + ssl_config, hostname ? hostname : "NULL", ssl_config ? ssl_config->skip_cert_verify : 1); + + if (ssl_config == NULL || ssl_config->skip_cert_verify) { + /* 使用默认配置(跳过验证,仅用于测试) */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Creating TLS config with no CA cert (skip verify)"); + tls_config = altcp_tls_create_config_client(NULL, 0); + } else { + /* 使用 CA 证书 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Creating TLS config with CA cert (len=%zu)", + ssl_config->ca_cert_len); + tls_config = altcp_tls_create_config_client( + ssl_config->ca_cert, + ssl_config->ca_cert_len + ); + } + + if (tls_config == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to create TLS config (altcp_tls_create_config_client returned NULL)"); + return NULL; + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS config created successfully: %p", tls_config); + +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + /* 应用 SSL 配置到 mbedtls_ssl_config */ + if (ssl_config != NULL) { + /* 使用内部结构体访问成员 */ + struct altcp_tls_config_internal *tls_config_internal = (struct altcp_tls_config_internal *)tls_config; + mbedtls_ssl_config *conf = &tls_config_internal->conf; + + /* 设置读取超时 */ + if (ssl_config->read_timeout_ms > 0) { + mbedtls_ssl_conf_read_timeout(conf, ssl_config->read_timeout_ms); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL read timeout configured: %u ms", ssl_config->read_timeout_ms); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL read timeout: using default"); + } + + /* 配置 TLS 版本 - 支持 TLS 1.2 到 TLS 1.3 的协商(如果服务器不支持 TLS 1.3,自动回退到 TLS 1.2) */ + if (ssl_config->min_tls_version > 0) { + mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, ssl_config->min_tls_version); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL min version configured: %d", ssl_config->min_tls_version); + } else { + /* 默认最小版本:TLS 1.2(允许回退) */ + mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL min version: TLS 1.2 (default, allows fallback)"); + } + if (ssl_config->max_tls_version > 0) { + mbedtls_ssl_conf_max_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, ssl_config->max_tls_version); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL max version configured: %d", ssl_config->max_tls_version); + } else { + /* 默认最大版本:TLS 1.3(优先使用) */ + mbedtls_ssl_conf_max_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_4); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL max version: TLS 1.3 (default, preferred)"); + } + + /* 配置加密套件 - 同时支持 TLS 1.2 和 TLS 1.3 加密套件(优先 TLS 1.3) */ + if (ssl_config->cipher_suites != NULL) { + mbedtls_ssl_conf_ciphersuites(conf, ssl_config->cipher_suites); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cipher suites configured (custom)"); + } else { + /* 默认加密套件:优先 TLS 1.3,如果服务器不支持则使用 TLS 1.2 */ + static const int default_ciphersuites[] = { + /* TLS 1.3 加密套件(按优先级排序,优先使用) */ + MBEDTLS_TLS1_3_AES_128_GCM_SHA256, /* 0x1301 - TLS_AES_128_GCM_SHA256 (最常用) */ + MBEDTLS_TLS1_3_AES_256_GCM_SHA384, /* 0x1302 - TLS_AES_256_GCM_SHA384 */ + MBEDTLS_TLS1_3_CHACHA20_POLY1305_SHA256, /* 0x1303 - TLS_CHACHA20_POLY1305_SHA256 */ + MBEDTLS_TLS1_3_AES_128_CCM_SHA256, /* 0x1304 - TLS_AES_128_CCM_SHA256 */ + MBEDTLS_TLS1_3_AES_128_CCM_8_SHA256, /* 0x1305 - TLS_AES_128_CCM_8_SHA256 */ + + /* TLS 1.2 加密套件(按优先级排序,作为回退选项) */ + MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, /* 0xC02F - TLS 1.2 最常用 */ + MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, /* 0xC030 - TLS 1.2 */ + MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, /* 0x9E - TLS 1.2 */ + MBEDTLS_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, /* 0x9F - TLS 1.2 */ + MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256, /* 0x9C - TLS 1.2 */ + MBEDTLS_TLS_RSA_WITH_AES_256_GCM_SHA384, /* 0x9D - TLS 1.2 */ + 0 /* 结束标记 */ + }; + mbedtls_ssl_conf_ciphersuites(conf, default_ciphersuites); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cipher suites: using default (TLS 1.3 preferred, TLS 1.2 fallback)"); + } + + /* 设置证书验证模式 */ + if (ssl_config->skip_cert_verify) { + mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_NONE); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cert verification: SKIP (TEST ONLY - insecure!)"); + } else { + mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_REQUIRED); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL cert verification: REQUIRED"); + } + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] SSL config is NULL, using default settings"); + } + + /* 注意:主机名需要在连接建立后通过 mbedtls_ssl_set_hostname 设置 */ + /* 这里保存 hostname 到配置中,后续在连接回调中设置 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS config setup completed, hostname will be set in allocator"); +#endif + + return tls_config; +} + +/** + * @brief 配置已建立的 TLS 连接(设置主机名等) + * 注意:此函数在连接建立后调用,但主机名应该在 allocator 中已经设置 + */ +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS +static void zhihui_configure_tls_connection(httpc_state_t *connection, const char *hostname, const zhihui_ssl_config_t *ssl_config) +{ + if (connection == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: connection is NULL"); + return; + } + + /* 使用内部结构体访问成员 */ + struct _httpc_state_internal *conn = (struct _httpc_state_internal *)connection; + if (conn->pcb == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: pcb is NULL"); + return; + } + + /* 获取 TLS 上下文 */ + void *ssl_ctx = altcp_tls_context(conn->pcb); + if (ssl_ctx == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: altcp_tls_context returned NULL (not a TLS connection?)"); + return; + } + + mbedtls_ssl_context *ssl = (mbedtls_ssl_context *)ssl_ctx; + + /* 验证主机名是否已设置(应该在 allocator 中已设置) */ + if (hostname != NULL && strlen(hostname) > 0) { + /* 注意:主机名应该在 allocator 中已经设置,这里只是验证 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: verifying hostname=%s (should be set in allocator)", hostname); + + /* 可以在这里再次设置主机名(如果之前设置失败) */ + int ret = mbedtls_ssl_set_hostname(ssl, hostname); + if (ret != 0) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: Failed to set SSL hostname: %d", ret); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: SSL hostname verified/set: %s", hostname); + } + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] configure_tls_connection: hostname is NULL or empty"); + } + + /* 注意:握手超时需要通过定时器实现,这里暂时无法直接设置 */ + /* 如果需要设置握手超时,需要在连接建立时启动定时器 */ +} +#endif + +/** + * @brief HTTP 接收数据回调 + */ +static err_t zhihui_http_recv_cb(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) +{ + zhihui_download_state_t *state = (zhihui_download_state_t *)arg; + + /* 添加日志:记录数据接收 */ + if (p != NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: received data, len=%u, tot_len=%u, err=%d", + p->len, p->tot_len, err); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: pbuf is NULL, err=%d", err); + } + + if (err != ERR_OK) { + const char *err_str = "UNKNOWN"; + switch (err) { + case ERR_MEM: err_str = "MEM"; break; + case ERR_BUF: err_str = "BUF"; break; + case ERR_TIMEOUT: err_str = "TIMEOUT"; break; + case ERR_CLSD: err_str = "CLSD"; break; + case ERR_RST: err_str = "RST"; break; + case ERR_ABRT: err_str = "ABRT"; break; + default: err_str = "UNKNOWN"; break; + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: error=%d (%s), p=%p", err, err_str, p); + if (state && state->result_cb) { + state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status); + } + return ERR_OK; + } + + if (p == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: pbuf is NULL (connection closed?)"); + if (state && state->result_cb) { + state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status); + } + return ERR_OK; + } + + if (state == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] recv_cb: state is NULL"); + pbuf_free(p); + return ERR_OK; + } + +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 使用异步文件写入队列 */ + const char *open_mode = state->resume_offset > 0 ? "ab+" : "wb+"; + errcode_t write_ret = ln_file_write_queue_add_task( + &state->fd, + &state->write_ctx, + state->is_first_packet ? state->save_path : NULL, /* 第一包需要文件路径 */ + state->is_first_packet ? open_mode : NULL, /* 第一包需要打开模式 */ + (const uint8_t *)p->payload, + p->len, + state->is_first_packet ? 1 : 0, /* is_first_packet */ + 0 /* is_last_packet,在 result_cb 中处理最后一包 */ + ); + + if (write_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to add write task: %d", write_ret); + pbuf_free(p); + if (state->result_cb) { + state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status); + } + return ERR_OK; + } + + if (state->is_first_packet) { + state->is_first_packet = 0; + } +#else + /* 直接写入文件 */ + if (state->fd != NULL) { + size_t written = fwrite(p->payload, 1, p->len, state->fd); + if (written != p->len) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Write failed: %zu/%u", written, p->len); + pbuf_free(p); + if (state->result_cb) { + state->result_cb(state->callback_arg, ERRCODE_FAIL, state->total_written, state->http_status); + } + return ERR_OK; + } + fflush(state->fd); + } +#endif + + state->total_written += p->len; + + /* 进度回调 */ + if (state->progress_cb) { + state->progress_cb(state->callback_arg, state->total_written, state->total_bytes); + } + + /* 每接收一定数据量记录一次日志(避免日志过多) */ + static size_t last_log_bytes = 0; + if (state->total_written - last_log_bytes >= 64 * 1024 || state->total_written < 4096) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download progress: %zu/%zu bytes (%.1f%%)", + state->total_written, state->total_bytes, + state->total_bytes > 0 ? (100.0f * state->total_written / state->total_bytes) : 0.0f); + last_log_bytes = state->total_written; + } + + pbuf_free(p); + return ERR_OK; +} + +/** + * @brief HTTP 头部接收完成回调 + */ +static err_t zhihui_http_headers_done_cb(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len) +{ + zhihui_download_state_t *state = (zhihui_download_state_t *)arg; + const char *hdr_str = (const char *)hdr->payload; + + if (state == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] headers_done_cb: state is NULL"); + pbuf_free(hdr); + return ERR_VAL; + } + + /* 保存连接句柄,用于后续配置 TLS */ + state->connection = connection; + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Headers received: hdr_len=%u, content_len=%u", hdr_len, content_len); + + /* 注意:TLS 主机名已在 allocator 中设置,这里不需要再次设置 */ + /* 如果需要额外的 TLS 配置,可以在这里进行 */ + + /* 解析 HTTP 状态码 */ + state->http_status = 0; + if (hdr_len > 12 && strncmp(hdr_str, "HTTP/", 5) == 0) { + const char *status_start = strchr(hdr_str, ' '); + if (status_start != NULL) { + state->http_status = (uint32_t)atoi(status_start + 1); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] HTTP status code: %u", state->http_status); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to parse HTTP status code"); + } + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid HTTP response header (too short or not HTTP)"); + } + + /* 检查状态码 */ + if (state->http_status >= 400) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] HTTP error response: %u", state->http_status); + state->result = ERRCODE_FAIL; + state->completed = -1; /* 标记为失败 */ + pbuf_free(hdr); + return ERR_VAL; /* 中止连接 */ + } + + /* 解析 Content-Length */ + const char *cl_header = strstr(hdr_str, "Content-Length:"); + if (cl_header != NULL) { + state->total_bytes = (size_t)atoi(cl_header + 15); + } else { + state->total_bytes = content_len != HTTPC_CONTENT_LEN_INVALID ? content_len : 0; + } + + /* 检查是否支持 Range(206 Partial Content) */ + if (state->http_status == 206) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Server supports Range requests (206 Partial Content)"); + } + + pbuf_free(hdr); + return ERR_OK; +} + +/** + * @brief HTTP 结果回调 + */ +static void zhihui_http_result_cb(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, u32_t srv_res, err_t err) +{ + zhihui_download_state_t *state = (zhihui_download_state_t *)arg; + + if (state == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] result_cb: state is NULL"); + return; + } + + /* 转换结果码 */ + int result = ERRCODE_FAIL; + if (httpc_result == HTTPC_RESULT_OK) { + result = ERRCODE_SUCC; + state->total_written = rx_content_len; + state->completed = 1; /* 标记为完成 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download completed successfully: %u bytes, status=%u", + rx_content_len, srv_res); + } else { + state->completed = -1; /* 标记为失败 */ + + /* 详细错误信息 */ + const char *result_str = "UNKNOWN"; + switch (httpc_result) { + case HTTPC_RESULT_ERR_UNKNOWN: result_str = "ERR_UNKNOWN"; break; + case HTTPC_RESULT_ERR_CONNECT: result_str = "ERR_CONNECT"; break; + case HTTPC_RESULT_ERR_HOSTNAME: result_str = "ERR_HOSTNAME"; break; + case HTTPC_RESULT_ERR_CLOSED: result_str = "ERR_CLOSED"; break; + case HTTPC_RESULT_ERR_TIMEOUT: result_str = "ERR_TIMEOUT"; break; + case HTTPC_RESULT_ERR_SVR_RESP: result_str = "ERR_SVR_RESP"; break; + case HTTPC_RESULT_ERR_MEM: result_str = "ERR_MEM"; break; + case HTTPC_RESULT_LOCAL_ABORT: result_str = "LOCAL_ABORT"; break; + case HTTPC_RESULT_ERR_CONTENT_LEN: result_str = "ERR_CONTENT_LEN"; break; + default: result_str = "UNKNOWN"; break; + } + + const char *err_str = "UNKNOWN"; + switch (err) { + case ERR_OK: err_str = "OK"; break; + case ERR_MEM: err_str = "MEM"; break; + case ERR_BUF: err_str = "BUF"; break; + case ERR_TIMEOUT: err_str = "TIMEOUT"; break; + case ERR_RTE: err_str = "RTE"; break; + case ERR_INPROGRESS: err_str = "INPROGRESS"; break; + case ERR_VAL: err_str = "VAL"; break; + case ERR_WOULDBLOCK: err_str = "WOULDBLOCK"; break; + case ERR_USE: err_str = "USE"; break; + case ERR_ALREADY: err_str = "ALREADY"; break; + case ERR_ISCONN: err_str = "ISCONN"; break; + case ERR_CONN: err_str = "CONN"; break; + case ERR_IF: err_str = "IF"; break; + case ERR_ABRT: err_str = "ABRT"; break; + case ERR_RST: err_str = "RST"; break; + case ERR_CLSD: err_str = "CLSD"; break; + case ERR_ARG: err_str = "ARG"; break; + default: err_str = "UNKNOWN"; break; + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download failed: result=%d (%s), err=%d (%s), status=%u, rx_len=%u", + httpc_result, result_str, err, err_str, srv_res, rx_content_len); + + /* 如果是连接关闭错误,可能是 SSL 握手失败 */ + if (httpc_result == HTTPC_RESULT_ERR_CLOSED && err == ERR_CLSD) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Connection closed unexpectedly - possible SSL/TLS handshake failure"); + } + } + + state->result = result; + state->http_status = srv_res; + +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 使用异步写入队列:等待所有写入任务完成并关闭文件 */ + if (result == ERRCODE_SUCC) { + /* 等待所有写入任务完成 */ + errcode_t wait_ret = ln_file_write_queue_wait_done(&state->write_ctx, 30000); /* 最多等待30秒 */ + if (wait_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Wait for write queue done failed or timeout"); + result = ERRCODE_FAIL; + state->result = ERRCODE_FAIL; + } else { + /* 获取实际写入的字节数 */ + state->total_written = ln_file_write_queue_get_written(&state->write_ctx); + } + } + + /* 安全关闭文件 */ + ln_file_write_queue_close_file(&state->fd, &state->write_ctx); +#else + /* 直接关闭文件 */ + if (state->fd != NULL) { + fclose(state->fd); + state->fd = NULL; + } +#endif + + /* 调用用户回调 */ + if (state->result_cb) { + state->result_cb(state->callback_arg, result, state->total_written, state->http_status); + } +} + +/** + * @brief 下载文件实现 + */ +int zhihui_http_download_file_resume( + const char *url, + const char *save_path, + size_t resume_offset, + const zhihui_ssl_config_t *ssl_config, + zhihui_http_result_fn result_cb, + zhihui_http_progress_fn progress_cb, + void *callback_arg +) +{ + zhihui_url_info_t url_info; + httpc_connection_t conn_settings = {0}; + zhihui_download_state_t state = {0}; + struct altcp_allocator_s allocator = {0}; +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + zhihui_tls_alloc_arg_t *tls_alloc_arg = NULL; +#endif + err_t err; + httpc_state_t *connection = NULL; + FILE *fd = NULL; + + if (!url || !save_path) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Invalid parameters"); + return ERRCODE_FAIL; + } + + /* 解析 URL */ + if (zhihui_parse_url(url, &url_info) != 0) { + return ERRCODE_FAIL; + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download: %s -> %s, offset=%zu", url, save_path, resume_offset); + +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 初始化异步文件写入队列(如果未初始化) */ + static int queue_initialized = 0; + if (!queue_initialized) { + if (ln_file_write_queue_init() != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to init file write queue"); + return ERRCODE_FAIL; + } + queue_initialized = 1; + } + + /* 初始化写入上下文 */ + state.write_ctx.status = LN_FILE_WRITE_STATUS_PENDING; + state.write_ctx.error_code = ERRCODE_SUCC; + state.write_ctx.total_written = 0; + state.write_ctx.ref_count = 0; + state.is_first_packet = 1; + state.fd = NULL; /* 文件句柄由写入队列管理 */ +#else + /* 打开文件 */ + const char *open_mode = resume_offset > 0 ? "ab" : "wb"; + fd = fopen(save_path, open_mode); + if (fd == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to open file: %s", save_path); + return ERRCODE_FAIL; + } + + /* 设置文件缓冲区 */ + setvbuf(fd, NULL, _IOFBF, 64 * 1024); + state.fd = fd; +#endif + + /* 初始化状态 */ + state.save_path = save_path; + state.resume_offset = resume_offset; + state.result_cb = result_cb; + state.progress_cb = progress_cb; + state.callback_arg = callback_arg; + state.result = ERRCODE_FAIL; + state.completed = 0; /* 初始化为进行中 */ + state.hostname = url_info.host; + state.ssl_config = ssl_config; + state.connection = NULL; + + /* 配置连接设置 */ + conn_settings.use_proxy = 0; + conn_settings.result_fn = zhihui_http_result_cb; + conn_settings.headers_done_fn = zhihui_http_headers_done_cb; + + /* 配置 allocator */ + if (url_info.is_https) { +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS +#if defined(MBEDTLS_SSL_PROTO_TLS1_3) + /* TLS 1.3 需要 PSA crypto 初始化 */ + static int psa_crypto_initialized = 0; + if (!psa_crypto_initialized) { + psa_status_t psa_status = psa_crypto_init(); + if (psa_status != PSA_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to initialize PSA crypto: %d (required for TLS 1.3)", psa_status); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE + fclose(fd); +#endif + return ERRCODE_FAIL; + } + psa_crypto_initialized = 1; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] PSA crypto initialized successfully (for TLS 1.3)"); + } +#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */ + + /* 创建 TLS 配置 */ + struct altcp_tls_config *tls_config = zhihui_create_tls_config(ssl_config, url_info.host); + if (tls_config == NULL) { +#if !LN_HTTP_DOWNLOAD_USE_QUEUE + fclose(fd); +#endif + return ERRCODE_FAIL; + } + + /* 创建 allocator 参数(包含配置和主机名) */ + tls_alloc_arg = (zhihui_tls_alloc_arg_t *)malloc(sizeof(zhihui_tls_alloc_arg_t)); + if (tls_alloc_arg == NULL) { + altcp_tls_free_config(tls_config); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE + fclose(fd); +#endif + return ERRCODE_FAIL; + } + tls_alloc_arg->tls_config = tls_config; + tls_alloc_arg->hostname = url_info.host; + + /* 设置 TLS allocator */ + allocator.alloc = zhihui_tls_alloc; + allocator.arg = tls_alloc_arg; + conn_settings.altcp_allocator = &allocator; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Using HTTPS with TLS allocator, hostname=%s", url_info.host); +#else + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] HTTPS not supported (LWIP_ALTCP_TLS not enabled)"); + fclose(fd); + return ERRCODE_FAIL; +#endif + } else { + /* HTTP: 使用 TCP allocator */ + allocator.alloc = altcp_tcp_alloc; + allocator.arg = NULL; + conn_settings.altcp_allocator = &allocator; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Using HTTP with TCP allocator"); + } + + /* 构建 URI */ + char uri[512]; + snprintf(uri, sizeof(uri), "%s", url_info.path); + + /* 发起下载请求 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Starting download: host=%s, port=%u, uri=%s", + url_info.host, url_info.port, uri); + + err = httpc_get_file_dns( + url_info.host, + url_info.port, + uri, + &conn_settings, + zhihui_http_recv_cb, + &state, + &connection + ); + + if (err != ERR_OK) { + const char *err_str = "UNKNOWN"; + switch (err) { + case ERR_MEM: err_str = "MEM"; break; + case ERR_VAL: err_str = "VAL"; break; + case ERR_ARG: err_str = "ARG"; break; + case ERR_INPROGRESS: err_str = "INPROGRESS"; break; + default: err_str = "UNKNOWN"; break; + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] httpc_get_file_dns failed: %d (%s)", err, err_str); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE + fclose(fd); +#endif +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + if (tls_alloc_arg != NULL) { + if (tls_alloc_arg->tls_config != NULL) { + altcp_tls_free_config(tls_alloc_arg->tls_config); + } + free(tls_alloc_arg); + } +#endif + return ERRCODE_FAIL; + } + + /* 保存连接句柄到状态中,用于后续操作 */ + if (connection != NULL) { + state.connection = connection; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Connection established: pcb=%p", + ((struct _httpc_state_internal *)connection)->pcb); + + /* 如果是 HTTPS,验证 TLS 连接状态 */ + if (url_info.is_https) { +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + struct _httpc_state_internal *conn = (struct _httpc_state_internal *)connection; + if (conn->pcb != NULL) { + void *ssl_ctx = altcp_tls_context(conn->pcb); + if (ssl_ctx != NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] TLS context verified: %p", ssl_ctx); + /* 可以在这里再次验证主机名设置 */ + zhihui_configure_tls_connection(connection, url_info.host, ssl_config); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] WARNING: TLS context is NULL (not a TLS connection?)"); + } + } +#endif + } + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] WARNING: connection is NULL after httpc_get_file_dns"); + } + + /* 如果需要断点续传,添加 Range 头 */ + if (resume_offset > 0 && connection != NULL) { + char range_value[64]; + snprintf(range_value, sizeof(range_value), "bytes=%zu-", resume_offset); + + if (zhihui_http_add_custom_header(connection, "Range", range_value) == 0) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Added Range header: bytes=%zu-", resume_offset); + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Failed to add Range header, will download from beginning"); + /* 如果添加 Range 头失败,继续下载(从头开始) */ + } + } + + /* 注意:lwIP HTTP 客户端是异步的,下载结果通过回调函数通知 */ + /* 如果需要同步等待,轮询等待完成 */ + if (result_cb == NULL) { + /* 没有回调函数,需要同步等待 */ + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t start_time = uapi_tcxo_get_ms(); + uint32_t timeout_ms = 300000; /* 5分钟超时 */ + uint32_t check_interval = 100; /* 每100ms检查一次 */ + + while (state.completed == 0) { + uint32_t elapsed = uapi_tcxo_get_ms() - start_time; + if (elapsed > timeout_ms) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Download timeout after %u ms", elapsed); + state.completed = -1; + state.result = ERRCODE_FAIL; + break; + } + + /* 喂狗(防止看门狗超时) */ + extern errcode_t uapi_watchdog_kick(void); + uapi_watchdog_kick(); + + LOS_Msleep(check_interval); + } + +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 使用异步写入队列:等待所有写入任务完成并关闭文件 */ + if (state.result == ERRCODE_SUCC) { + errcode_t wait_ret = ln_file_write_queue_wait_done(&state.write_ctx, 30000); /* 最多等待30秒 */ + if (wait_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ZHIHUI_HTTP] Wait for write queue done failed or timeout"); + state.result = ERRCODE_FAIL; + } else { + /* 获取实际写入的字节数 */ + state.total_written = ln_file_write_queue_get_written(&state.write_ctx); + } + } + + /* 安全关闭文件 */ + ln_file_write_queue_close_file(&state.fd, &state.write_ctx); +#else + /* 关闭文件(如果还未关闭) */ + if (state.fd != NULL) { + fclose(state.fd); + state.fd = NULL; + } +#endif + + /* 清理 TLS 配置和 allocator 参数 */ +#if LWIP_ALTCP && LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + if (tls_alloc_arg != NULL) { + if (tls_alloc_arg->tls_config != NULL) { + altcp_tls_free_config(tls_alloc_arg->tls_config); + } + free(tls_alloc_arg); + } +#endif + + return state.result; + } + + /* 有回调函数,异步模式,返回成功表示请求已发起 */ + return ERRCODE_SUCC; +} + +/** + * @brief 创建默认 SSL 配置 + */ +const zhihui_ssl_config_t *zhihui_ssl_config_default(bool skip_verify) +{ + if (!g_default_ssl_config_init) { + zhihui_ssl_config_init(&g_default_ssl_config, NULL, 0, 0, skip_verify); + g_default_ssl_config_init = true; + } + return &g_default_ssl_config; +} + +/** + * @brief 初始化 SSL 配置 + */ +void zhihui_ssl_config_init( + zhihui_ssl_config_t *config, + const uint8_t *ca_cert, + size_t ca_cert_len, + uint32_t handshake_timeout_ms, + bool skip_verify +) +{ + if (config == NULL) { + return; + } + + memset(config, 0, sizeof(zhihui_ssl_config_t)); + config->ca_cert = ca_cert; + config->ca_cert_len = ca_cert_len; + config->handshake_timeout_ms = handshake_timeout_ms; + config->skip_cert_verify = skip_verify; + config->read_timeout_ms = 0; /* 使用默认值 */ + config->write_timeout_ms = 0; /* 使用默认值 */ + config->min_tls_version = 0; /* 使用默认值 */ + config->max_tls_version = 0; /* 使用默认值 */ + config->cipher_suites = NULL; /* 使用默认值 */ +} + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.h b/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.h new file mode 100644 index 000000000..829bc6050 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/zhihui_http_client.h @@ -0,0 +1,144 @@ +/** + * @file zhihui_http_client.h + * @brief 基于 lwIP HTTP 客户端的 HTTP/HTTPS 下载实现 + * + * 该实现基于 lwIP 的标准 HTTP 客户端接口,支持: + * - HTTP 和 HTTPS 下载 + * - 断点续传(Range 头) + * - SSL/TLS 配置(超时、加密算法等) + * - 性能优化(可配置 SSL 参数) + * + * 与 OpenHarmony HttpClient 的区别: + * - 使用 lwIP 的 httpc_get_file_dns 接口 + * - 通过 altcp_tls 支持 HTTPS + * - 可配置 SSL 超时和加密算法 + */ + +#ifndef ZHIHUI_HTTP_CLIENT_H +#define ZHIHUI_HTTP_CLIENT_H + +#include +#include +#include +#include "errcode.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* SSL/TLS 配置结构 */ +typedef struct { + /* CA 证书(PEM 格式),如果为 NULL 则使用默认证书验证 */ + const uint8_t *ca_cert; + size_t ca_cert_len; + + /* 客户端证书(双向认证,可选) */ + const uint8_t *client_cert; + size_t client_cert_len; + + /* 客户端私钥(双向认证,可选) */ + const uint8_t *client_key; + size_t client_key_len; + const uint8_t *client_key_pass; /* 私钥密码(可选) */ + size_t client_key_pass_len; + + /* SSL 握手超时(毫秒),0 表示使用默认值 */ + uint32_t handshake_timeout_ms; + + /* SSL 读写超时(毫秒),0 表示使用默认值 */ + uint32_t read_timeout_ms; + uint32_t write_timeout_ms; + + /* 是否跳过证书验证(仅用于测试,生产环境应设为 false) */ + bool skip_cert_verify; + + /* 加密套件配置(可选,NULL 表示使用默认) */ + const int *cipher_suites; /* mbedtls 加密套件 ID 数组,以 0 结尾 */ + + /* 最小/最大 TLS 版本(可选,0 表示使用默认) */ + int min_tls_version; /* MBEDTLS_SSL_VERSION_TLS1_2 等 */ + int max_tls_version; +} zhihui_ssl_config_t; + +/* HTTP 下载结果回调函数类型 */ +typedef void (*zhihui_http_result_fn)(void *arg, int result, size_t downloaded_bytes, uint32_t http_status_code); + +/* HTTP 下载进度回调函数类型 */ +typedef void (*zhihui_http_progress_fn)(void *arg, size_t downloaded_bytes, size_t total_bytes); + +/** + * @brief 下载文件(支持断点续传) + * @param url 文件 URL(支持 http:// 和 https://) + * @param save_path 保存路径 + * @param resume_offset 续传偏移量(0 表示从头开始) + * @param ssl_config SSL 配置(HTTPS 需要,HTTP 可传 NULL) + * @param result_cb 结果回调函数(可选) + * @param progress_cb 进度回调函数(可选) + * @param callback_arg 回调函数参数 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +int zhihui_http_download_file_resume( + const char *url, + const char *save_path, + size_t resume_offset, + const zhihui_ssl_config_t *ssl_config, + zhihui_http_result_fn result_cb, + zhihui_http_progress_fn progress_cb, + void *callback_arg +); + +/** + * @brief 下载文件(从头开始) + * @param url 文件 URL + * @param save_path 保存路径 + * @param ssl_config SSL 配置(HTTPS 需要,HTTP 可传 NULL) + * @param result_cb 结果回调函数(可选) + * @param progress_cb 进度回调函数(可选) + * @param callback_arg 回调函数参数 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +static inline int zhihui_http_download_file( + const char *url, + const char *save_path, + const zhihui_ssl_config_t *ssl_config, + zhihui_http_result_fn result_cb, + zhihui_http_progress_fn progress_cb, + void *callback_arg +) { + return zhihui_http_download_file_resume(url, save_path, 0, ssl_config, result_cb, progress_cb, callback_arg); +} + +/** + * @brief 创建默认 SSL 配置(用于 HTTPS) + * @param skip_verify 是否跳过证书验证(仅用于测试) + * @return SSL 配置结构(静态分配,可重复使用) + */ +const zhihui_ssl_config_t *zhihui_ssl_config_default(bool skip_verify); + +/** + * @brief 创建自定义 SSL 配置 + * @param config 配置结构指针(由调用者分配) + * @param ca_cert CA 证书(PEM 格式,可选) + * @param ca_cert_len CA 证书长度 + * @param handshake_timeout_ms SSL 握手超时(毫秒,0 表示默认) + * @param skip_verify 是否跳过证书验证 + */ +void zhihui_ssl_config_init( + zhihui_ssl_config_t *config, + const uint8_t *ca_cert, + size_t ca_cert_len, + uint32_t handshake_timeout_ms, + bool skip_verify +); + +#ifdef __cplusplus +} +#endif + +#endif /* ZHIHUI_HTTP_CLIENT_H */ + + + + + + diff --git a/code/sdk/zhihui/utils/custom_utils.c b/code/sdk/zhihui/utils/custom_utils.c index 5a91bd592..2fa1121cd 100644 --- a/code/sdk/zhihui/utils/custom_utils.c +++ b/code/sdk/zhihui/utils/custom_utils.c @@ -1601,12 +1601,36 @@ int32_t uapi_get_screen_state(void) { const power_display_svr_api_t *display_api = power_display_svr_get_api(); screen_state_t state = display_api->get_screen_state(); - // printf("uapi_get_screen_state = %s . \r\n", state==SCREEN_ON?"on":"off"); - if( state == SCREEN_ON){ - return 0; - }else{ - return 1; + + /* 如果电源管理服务状态为OFF,直接返回OFF */ + if (state == SCREEN_OFF) { + return 1; /* screen off */ + } + + /* 电源管理服务状态为ON时,必须检查LCD实际状态 */ + /* 只有当LCD已初始化且实际状态为ON时,才返回ON */ + if (state == SCREEN_ON) { + /* 检查LCD是否已初始化 */ + extern bool uapi_is_lcd_connect(void); + if (uapi_is_lcd_connect()) { + /* LCD已初始化,检查LCD实际状态 */ + bool lcd_actual_status = lcd_get_status(); + if (lcd_actual_status == true) { + /* LCD已初始化且状态为ON,返回ON */ + return 0; /* screen on */ + } else { + /* LCD已初始化但状态为OFF,返回OFF(状态不同步) */ + return 1; /* screen off */ + } + } else { + /* LCD未初始化,即使电源管理服务状态为ON,也返回OFF */ + /* 因为LCD还没准备好,不能认为屏幕是亮的 */ + return 1; /* screen off */ + } } + + /* 其他情况返回OFF */ + return 1; /* screen off */ } /** diff --git a/tools/convert_cert_to_c.py b/tools/convert_cert_to_c.py new file mode 100644 index 000000000..c3a439864 --- /dev/null +++ b/tools/convert_cert_to_c.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +""" +将 PEM 格式的证书文件转换为 C 语言数组格式 +用法: python3 convert_cert_to_c.py +""" + +import sys +import os + +def pem_to_c_array(pem_file, output_file, var_name): + """将 PEM 文件转换为 C 数组""" + if not os.path.exists(pem_file): + print(f"Error: Certificate file not found: {pem_file}") + return False + + with open(pem_file, 'rb') as f: + pem_data = f.read() + + # 确保变量名合法 + var_name = var_name.replace('-', '_').replace('.', '_') + + header_guard = f"{var_name.upper()}_H" + + with open(output_file, 'w') as f: + f.write(f"// CA Certificate for SSL/TLS verification\n") + f.write(f"// Generated from: {pem_file}\n") + f.write(f"// File size: {len(pem_data)} bytes\n\n") + f.write(f"#ifndef {header_guard}\n") + f.write(f"#define {header_guard}\n\n") + f.write(f"static const unsigned char {var_name}[] = {{\n") + + for i, byte in enumerate(pem_data): + if i % 16 == 0: + f.write(" ") + f.write(f"0x{byte:02x}") + if i < len(pem_data) - 1: + f.write(",") + if (i + 1) % 16 == 0: + f.write("\n") + elif i < len(pem_data) - 1: + f.write(" ") + + if len(pem_data) % 16 != 0: + f.write("\n") + + f.write(f"}};\n\n") + f.write(f"static const unsigned int {var_name}_len = {len(pem_data)};\n\n") + f.write(f"#endif // {header_guard}\n") + + print(f"✓ Certificate converted successfully:") + print(f" Input: {pem_file} ({len(pem_data)} bytes)") + print(f" Output: {output_file}") + print(f" Variable: {var_name} (length: {var_name}_len)") + return True + +def main(): + if len(sys.argv) != 4: + print("Usage: python3 convert_cert_to_c.py ") + print("\nExample:") + print(" python3 convert_cert_to_c.py ca_cert.pem ca_cert.h ca_cert_pem") + sys.exit(1) + + pem_file = sys.argv[1] + output_file = sys.argv[2] + var_name = sys.argv[3] + + if not pem_to_c_array(pem_file, output_file, var_name): + sys.exit(1) + +if __name__ == "__main__": + main() + + + + + diff --git a/tools/get_server_cert.sh b/tools/get_server_cert.sh new file mode 100644 index 000000000..eab08594f --- /dev/null +++ b/tools/get_server_cert.sh @@ -0,0 +1,36 @@ +#!/bin/bash +# 从服务器获取证书并保存为 PEM 格式 + +if [ $# -lt 1 ]; then + echo "Usage: $0 [port]" + echo "Example: $0 file-virtual-person-qcl.test.leiniao.com 443" + exit 1 +fi + +HOSTNAME=$1 +PORT=${2:-443} +OUTPUT_FILE="${HOSTNAME}_cert.pem" + +echo "Fetching certificate from ${HOSTNAME}:${PORT}..." + +# 获取证书链 +openssl s_client -showcerts -connect "${HOSTNAME}:${PORT}" < /dev/null 2>/dev/null | \ + sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > "${OUTPUT_FILE}" + +if [ $? -eq 0 ] && [ -s "${OUTPUT_FILE}" ]; then + echo "✓ Certificate saved to: ${OUTPUT_FILE}" + echo "" + echo "Certificate info:" + openssl x509 -in "${OUTPUT_FILE}" -text -noout | head -20 + echo "" + echo "To convert to C array, run:" + echo " python3 convert_cert_to_c.py ${OUTPUT_FILE} ca_cert.h ca_cert_pem" +else + echo "✗ Failed to fetch certificate" + exit 1 +fi + + + + +