-16
\ No newline at end of file
+26
\ No newline at end of file
--- /dev/null
+# 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/"
+
+
+++ /dev/null
-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)
-
-
-
+++ /dev/null
-import log
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-fota_log = log.getLogger("china_mobile")
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-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))
-
+++ /dev/null
-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()
-
-
+++ /dev/null
-import log
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-fota_log = log.getLogger("telecom_dmp")
${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
#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
#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.
#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
#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 */
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);
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
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);
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;
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;
}
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);
}
/* 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 */
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) {
/* 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 */
/* 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);
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;
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);
/* 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;
}
}
#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;
}
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;
}
"\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 */ \
#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 */ \
"%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 */ \
#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;
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
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)) {
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) {
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);
}
}
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));
}
}
}
/* 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 {
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;
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)
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));
}
* @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;
/* 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,
#include "osal_wait.h" // 包含 osal_msleep 函数
#include "lwip/ip6_addr.h"
#include "lwip/netif.h"
+#include "lwip/tcpip.h" // 包含 tcpip_input,用于线程安全的数据包处理
#include <los_task.h>
#include <los_typedef.h>
#include "custom_utils.h"
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;
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"));
}
}
}
}
/* 有残留数据:继续处理 */
} 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; // 队列已清空,退出循环等待下一个信号量
}
}
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;
// 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++;
${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
#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"
if (g_py_ver >= PY_SRV_VER_SUPORT_PY_OTA_MINI_VER && g_py_ver<PY_SRV_VER_CURRENT )
{
cat1_print_dbg("start cat1 python ota\n");
+
+ /* 判断是否需要使用TCP方式升级(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);
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];
#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 */
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;
/**
#include <stdbool.h>
#include <stddef.h>
-#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 */
${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
)
# 公共头文件路径(供其他模块引用)
--- /dev/null
+# 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 性能统计(握手时间、传输速度等)
+
+
+
+
+
+
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)
{
{
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;
}
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;
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)
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
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)
{
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);
{
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)
@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");
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;
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)
}
/* 如果续传,文件已打开在末尾位置,无需额外操作 */
+#endif
#endif
if(resume_offset > 0)
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)
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);
{
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,
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)
{
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
}
}
}
#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)
/* 判断是否为最后一包 */
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,
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);
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");
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)
{
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);
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Wait for write tasks timeout or error");
}
} else {
- /* ä¸\8b载失败ï¼\88ç½\91ç»\9cå¼\82常ç\89ï¼\89ï¼\8cä¸\8dç\89å¾\85æ\96\87ä»¶å\86\99å\85¥å®\8cæ\88\90ï¼\8cç\9b´æ\8e¥å\85³é\97æ\96\87ä»¶ */
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download failed (code=%d, isMore=%d), skip waiting for write tasks",
+ /* ä¸\8b载失败ï¼\88ç½\91ç»\9cå¼\82常ç\89ï¼\89ï¼\8cä½\86ä»\8dé\9c\80ç\89å¾\85å\86\99å\85¥é\98\9få\88\97å®\8cæ\88\90ï¼\8cç¡®ä¿\9dæ\96\87件大å°\8få\87\86ç¡®ç\94¨äº\8eé\87\8dè¯\95 */
+ 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",
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);
#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)
{
#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 /* 语音对话流分片接收 */
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++;
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;
/* 写入数据(关闭任务可能 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",
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++; /* 增加引用计数 */
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 */
}
}
+ /* 超时:记录详细信息用于调试 */
+ 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; /* 超时 */
}
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) ?
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);
}
/* 如果文件还未关闭,且不是最后一包,需要发送关闭任务 */
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;
size_t data_len; /* 数据长度 */
int is_first_packet; /* 是否为第一包(需要创建文件) */
int is_last_packet; /* 是否为最后一包(写入后关闭文件) */
+ uint32_t enqueue_time_ms; /* 入队时间戳(毫秒),用于性能分析 */
} ln_file_write_task_t;
/**
--- /dev/null
+/**
+ * @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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+/* 异步文件写入队列支持 */
+#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; /* 使用默认值 */
+}
+
--- /dev/null
+/**
+ * @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 <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#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 */
+
+
+
+
+
+
{
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 */
}
/**
--- /dev/null
+#!/usr/bin/env python3
+"""
+将 PEM 格式的证书文件转换为 C 语言数组格式
+用法: python3 convert_cert_to_c.py <pem_file> <output_file> <var_name>
+"""
+
+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 <pem_file> <output_file> <var_name>")
+ 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()
+
+
+
+
+
--- /dev/null
+#!/bin/bash
+# 从服务器获取证书并保存为 PEM 格式
+
+if [ $# -lt 1 ]; then
+ echo "Usage: $0 <hostname> [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
+
+
+
+
+