4G_module/custom/jt808/src/jt808_msg_pkg.c

254 lines
12 KiB
C
Raw Normal View History

#include "jt808_msg_pkg.h"
#include "jt808_msg_parse.h"
// 协议消息体打包(会自动为p_msg_body分配合适长度的内存注意释放)
static int jt808_BodyPackage(JT808_2013_MsgFrame_t *p_MsgFrame, MessageID_t Msg_ID){
if(PrsResult.term_param_item == NULL){
JT808_DEBUG("[%s,%s] term_param_item is NULL \r\n", __FUNCTION__,__LINE__);
return -1;
}
p_MsgFrame->msg_head.msgbody_attr.encrypt = 0;// 数据加密方式
p_MsgFrame->msg_head.msgbody_attr.packet = 0;// 分包标记
p_MsgFrame->msg_head.msgbody_attr.retain = 0;// 保留2位
p_MsgFrame->msg_head.total_packet = 0;// 总包数, 分包情况下使用
p_MsgFrame->msg_head.packet_seq = 0;// 当前包序号, 分包情况下使用
// 填充消息体
switch(Msg_ID){
case ID_Term_GenResp:{ // 终端通用应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Term_GenResp_t);// 消息体长度
// 定义大端结构体
Term_GenResp_t *big_term_reg_resp = (Term_GenResp_t *)jt808_malloc(sizeof(Term_GenResp_t));
if(big_term_reg_resp == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
memset(big_term_reg_resp, 0, sizeof(Term_GenResp_t));
// 大小端转换
big_term_reg_resp->msg_flow_num = Swap16(PrsResult.Rsp_flow_num); // 返回消息应答结果
big_term_reg_resp->msg_id_ack = Swap16(PrsResult.Rsp_msg_id);
big_term_reg_resp->result = PrsResult.Rsp_result;
p_MsgFrame->p_msg_body = (void *)big_term_reg_resp;
break;
}
case ID_Term_HB:{ // 终端心跳
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = 0;// 消息体长度
break;
}
case ID_Term_Reg:{ // 终端注册
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Term_RegInfo_t);// 消息体长度
// 定义大端结构体
Term_RegInfo_t *big_term_reg = (Term_RegInfo_t *)jt808_malloc(sizeof(Term_RegInfo_t));
if(big_term_reg == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
// memset(big_term_reg, 0, sizeof(Term_RegInfo_t));
memcpy(big_term_reg, &PrsResult.term_param_item->big_reg_info, sizeof(Term_RegInfo_t)); // 复制注册信息内容
p_MsgFrame->p_msg_body = (void *)big_term_reg;
break;
}
case ID_Term_Logout:{ // 终端注销
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = 0;// 消息体长度
break;
}
case ID_Term_Auth:{ // 终端鉴权
// JT808_DEBUG("ID_Term_Auth\r\n");
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = strlen(PrsResult.term_param_item->big_auth_info.str_auth_code);// 消息体长度
if((NULL == PrsResult.term_param_item->big_auth_info.str_auth_code) || (1 >= p_MsgFrame->msg_head.msgbody_attr.msgbodylen)){
JT808_DEBUG("[%s,%s] auth_code len is 0 \r\n", __FUNCTION__,__LINE__);
return -1;
}
void *str_auth_code = jt808_malloc(p_MsgFrame->msg_head.msgbody_attr.msgbodylen);
if(str_auth_code == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
// memset(str_auth_code, 0, p_MsgFrame->msg_head.msgbody_attr.msgbodylen);
JT808_DEBUG("auth_code:%d,%s\r\n",strlen(PrsResult.term_param_item->big_auth_info.str_auth_code),
PrsResult.term_param_item->big_auth_info.str_auth_code);
memcpy(str_auth_code, PrsResult.term_param_item->big_auth_info.str_auth_code, p_MsgFrame->msg_head.msgbody_attr.msgbodylen);
p_MsgFrame->p_msg_body = (void *)str_auth_code;
break;
}
case ID_GetTermParamsResp:{ // 查询终端参数应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetTermParamsResp_t);// 消息体长度
GetTermParamsResp_t *get_term_params_resp = (GetTermParamsResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetTermParamsResp_t));
if(get_term_params_resp == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
p_MsgFrame->p_msg_body = (void *)get_term_params_resp;
break;
}
case ID_GetTermAttrResp:{ // 查询终端属性应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetTermAttrResp_t);// 消息体长度
GetTermAttrResp_t *get_term_attr_resp = (GetTermAttrResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetTermAttrResp_t));
if(get_term_attr_resp == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
p_MsgFrame->p_msg_body = (void *)get_term_attr_resp;
break;
}
case ID_Term_UpgradeResult:{ // 终端升级结果通知
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Term_UpgradeResult_t);// 消息体长度
Term_UpgradeResult_t *term_upgrade_result = (Term_UpgradeResult_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(Term_UpgradeResult_t));
if(term_upgrade_result == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
p_MsgFrame->p_msg_body = (void *)term_upgrade_result;
break;
}
case ID_LocReport:{ // 位置信息汇报
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(Loc_basic_info_t);// 消息体长度
Loc_addi_info_t *p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
while(p_loc_addi_info != NULL){ // 计算附加信息长度
p_MsgFrame->msg_head.msgbody_attr.msgbodylen += p_loc_addi_info->msg_len + 2;
p_loc_addi_info = p_loc_addi_info->next;
}
uint8_t *loc_report_buf = (uint8_t *)jt808_malloc(p_MsgFrame->msg_head.msgbody_attr.msgbodylen);
if(loc_report_buf == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
memcpy(loc_report_buf, &PrsResult.term_param_item->big_loc_report, sizeof(Loc_basic_info_t)); // 复制基本信息内容
p_loc_addi_info = PrsResult.term_param_item->big_loc_report.addi_info;
uint16_t loc_report_offset = sizeof(Loc_basic_info_t);
uint8_t loc_len = 0;
while(p_loc_addi_info != NULL){ // 填充附加信息内容
loc_len= p_loc_addi_info->msg_len + 2;
memcpy(loc_report_buf + loc_report_offset, &p_loc_addi_info->msg_id, 2);
memcpy(loc_report_buf + loc_report_offset + 2, p_loc_addi_info->msg, p_loc_addi_info->msg_len);
loc_report_offset += loc_len;
p_loc_addi_info = p_loc_addi_info->next;
}
p_MsgFrame->p_msg_body = (void *)loc_report_buf;
break;
}
case ID_GetLocInfoResp:{ // 查询位置信息应答
p_MsgFrame->msg_head.msgbody_attr.msgbodylen = sizeof(GetLocInfoResp_t);// 消息体长度
GetLocInfoResp_t *get_loc_info_resp = (GetLocInfoResp_t *)jt808_realloc(p_MsgFrame->p_msg_body, sizeof(GetLocInfoResp_t));
if(get_loc_info_resp == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
return -1;
}
p_MsgFrame->p_msg_body = (void *)get_loc_info_resp;
break;
}
default:
return -2;
break;
}
return 0;
}
// 消息帧打包 (会自动为msgEscape->buf分配合适长度的内存注意释放)
int jt808_msg_pkg(MessageID_t Msg_ID, JT808MsgESC_t *msgEscape){
JT808_2013_MsgFrame_t big_MsgFrame;// 定义大端消息帧
JT808_DEBUG("BodyPackage ID:0x%04X\r\n", Msg_ID);
big_MsgFrame.p_msg_body = NULL;
if(0 != jt808_BodyPackage(&big_MsgFrame, Msg_ID)){// 填充消息体 注意释放p_msg_body内存
JT808_DEBUG("jt808_BodyPackage failed\r\n");
return -1;
}
// 计算消息帧总长度
uint16_t msg_total_len = 1 + sizeof(MsgHead_t) - (1 ==big_MsgFrame.msg_head.msgbody_attr.packet ? 0 : 4);
uint16_t msgbody_len =big_MsgFrame.msg_head.msgbody_attr.msgbodylen;
msg_total_len += msgbody_len + 2;
JT808_DEBUG("total_len:%d,len:%d\r\n", msg_total_len, msgbody_len);
big_MsgFrame.Head_SIGN = PSIGN;
big_MsgFrame.Tail_SIGN = PSIGN;
// 大端转换
big_MsgFrame.msg_head.msg_id = Swap16(Msg_ID);// 消息ID
big_MsgFrame.msg_head.msgbody_attr.val16 = Swap16(big_MsgFrame.msg_head.msgbody_attr.val16);
memcpy(big_MsgFrame.msg_head.phone_BCDnum, PrsResult.term_param_item->phone_BCDnum, 6);
big_MsgFrame.msg_head.msg_flow_num = Swap16(PrsResult.term_param_item->msg_flow_num);// 消息流水号
big_MsgFrame.msg_head.total_packet = Swap16(big_MsgFrame.msg_head.total_packet);// 总包数, 分包情况下使用
big_MsgFrame.msg_head.packet_seq = Swap16(big_MsgFrame.msg_head.total_packet);// 当前包序号, 分包情况下使用
uint8_t *msg_buf = (uint8_t *)jt808_malloc(msg_total_len);
if(msg_buf == NULL){
JT808_DEBUG("[%s,%s] malloc failed \r\n", __FUNCTION__,__LINE__);
if(big_MsgFrame.p_msg_body != NULL){ // 释放消息体内存(必要操作)
jt808_free(big_MsgFrame.p_msg_body);
big_MsgFrame.p_msg_body = NULL;
}
return -1;
}
// 填充头标识和消息头
memcpy(msg_buf, &big_MsgFrame.Head_SIGN, msg_total_len - msgbody_len - 2);
// 填充消息体
if(0 < msgbody_len && big_MsgFrame.p_msg_body != NULL){
memcpy(msg_buf + (msg_total_len - msgbody_len - 2), big_MsgFrame.p_msg_body, msgbody_len);
}
// 计算BCC校验码
big_MsgFrame.BCC_Check = BCC_Check(msg_buf + 1, msg_total_len - 2 - 1);
memcpy(msg_buf + msg_total_len - 2, &big_MsgFrame.BCC_Check, 2);
//// DEBUG
// app_printf("JT808_2013_MsgFrame_t:\r\n");
// for (size_t i = 0; i < msg_total_len - msgbody_len - 2; i++){
// app_printf("%02X ", *((uint8_t *)(&big_MsgFrame) + i));
// }
// app_printf("\r\n");
// for (size_t i = 0; i < msgbody_len; i++){
// app_printf("%02X ", *((uint8_t *)big_MsgFrame.p_msg_body + i));
// }
// app_printf("\r\n");
// for (size_t i = 0; i < 2; i++){
// app_printf("%02X ", *((uint8_t *)(&big_MsgFrame.BCC_Check) + i));
// }
// app_printf("\r\n");
if(big_MsgFrame.p_msg_body != NULL){ // 释放消息体内存(必要操作)
jt808_free(big_MsgFrame.p_msg_body);
big_MsgFrame.p_msg_body = NULL;
}
// 7E 转义处理
uint16_t escape_len = 0;
for(uint16_t i = 1; i < msg_total_len - 1; i++){
if(msg_buf[i] == PSIGN || msg_buf[i] == PESC){
escape_len++;
}
}
msgEscape->buf = (uint8_t *)jt808_malloc(msg_total_len + escape_len);
uint16_t offset_num = 0;
msgEscape->buf[0] = PSIGN;
msgEscape->buf[msg_total_len + escape_len - 1] = PSIGN;
for(uint16_t i = 1; i < msg_total_len - 1; i++){
if(msg_buf[i] == PSIGN){
msgEscape->buf[i + offset_num++] = PESC;
msgEscape->buf[i + offset_num] = PESC_SIGN;
}else if(msg_buf[i] == PESC){
msgEscape->buf[i + offset_num++] = PESC;
msgEscape->buf[i + offset_num] = PESC_ESCAPE;
}else {
msgEscape->buf[i + offset_num] = msg_buf[i];
}
}
jt808_free(msg_buf);
// 返回消息帧总长度
msgEscape->len = msg_total_len + escape_len;
app_printf("msgEscape->buf:%d\r\n", msg_total_len + escape_len);
for(uint16_t i = 0; i < msg_total_len + escape_len; i++){
app_printf("%02X ", *(msgEscape->buf + i));
}
app_printf("\r\n");
// jt808_free(msgEscape->buf);
return 0;
}