static void Send_Poll(void) { unsigned char i; unsigned int cur_timestamp; static CMD_Session_Tab * cmd_session = Get_CMD_Session_Tab(); for(i = 1 ; i < SESSION_TABLE_NUM ; i ++) { if(cmd_session[i].usage_flag == 1) { cur_timestamp = Get_TimeStamp(); if((cur_timestamp - cmd_session[i].pre_timestamp) > cmd_session[i].ack_timeout) { Get_Memory_Lock(); if(cmd_session[i].retry_send_time > 0 ) { if(cmd_session[i].sent_time >= cmd_session[i].retry_send_time ) { Free_CMD_Session(&cmd_session[i]); } else { Send_Pro_Data(cmd_session[i].mmu->pmem); cmd_session[i].pre_timestamp = cur_timestamp; cmd_session[i].sent_time ++; } } else { Send_Pro_Data(cmd_session[i].mmu->pmem); cmd_session[i].pre_timestamp = cur_timestamp; } Free_Memory_Lock(); } } } }
static void Send_Poll(void) { unsigned char i; unsigned int cur_timestamp; pthread_mutex_lock(&send_lock); for(i = 0 ; i < SESSION_AND_MEM_COUNT ; i ++) { if(Send_Session_Tab[i].usage_flag == 1) { cur_timestamp = Get_TimeStamp(); if((cur_timestamp - Send_Session_Tab[i].pre_timestamp) > Send_Session_Tab[i].ack_timeout) { if(Send_Session_Tab[i].retry_send_time > 0 ) { if(Send_Session_Tab[i].sent_time >= Send_Session_Tab[i].retry_send_time ) { Free_Send_Session(&Send_Session_Tab[i]); } else { Send_Pro_Data((unsigned char*)Send_Session_Tab[i].mmu->start_addr); Send_Session_Tab[i].pre_timestamp = cur_timestamp; Send_Session_Tab[i].sent_time ++; } } else { Send_Pro_Data((unsigned char*)Send_Session_Tab[i].mmu->start_addr); Send_Session_Tab[i].pre_timestamp = cur_timestamp; } } } } pthread_mutex_unlock(&send_lock); }
int Pro_Ack_Interface(ProAckParameter *parameter) { unsigned short ret = 0; Ack_Session_Queue *p2acksession; Memory_Manage_Unit *p2mmu; if(parameter->session_id == 0) { ; } else if(parameter->session_id > 0 && parameter->session_id < 32) { p2acksession = Search_Ack_Session(parameter->session_id); if(p2acksession) { if(parameter->length > PRO_ACK_MAX_SIZE) { printf("%s:ERROR,ACK buffer is not enough\n",__func__); p2acksession->session_status = ACK_SESSION_IDLE; return -1; } p2mmu = Request_Ack_MMU(parameter->length + sizeof(ProHeader) + 4); if(p2mmu) { p2acksession->mmu = p2mmu; ret = sdk_encrypt_interface((unsigned char*)p2mmu->start_addr,parameter->buf, parameter->length,1,parameter->need_encrypt, parameter->session_id,parameter->seq_num); if(ret == 0) { printf("%s:%d:ERROR\n",__func__,__LINE__); return -1; } pthread_mutex_lock(&send_lock); Send_Pro_Data((unsigned char *)p2mmu->start_addr); pthread_mutex_unlock(&send_lock); p2acksession->session_status = ACK_SESSION_USING; } } } return 0; }
int Pro_Ack_Interface(ProAckParameter *parameter) { unsigned short ret = 0; ACK_Session_Tab * ack_session = (ACK_Session_Tab *)NULL;; if(parameter->length > PRO_PURE_DATA_MAX_SIZE) { printf("%s:%d:ERROR,length=%d is oversize\n",__func__,__LINE__,parameter->length); return -1; } if(parameter->session_id == 0) { ; } else if(parameter->session_id > 0 && parameter->session_id < 32) { Get_Memory_Lock(); ack_session = Request_ACK_Session(parameter->session_id, Pro_Calc_Length(parameter->length,parameter->need_encrypt)); if(ack_session == (ACK_Session_Tab*)NULL) { printf("%s:%d:ERROR,there is not enough memory\n",__func__,__LINE__); Free_Memory_Lock(); return -1; } ret = sdk_encrypt_interface(ack_session->mmu->pmem,parameter->buf, parameter->length,1,parameter->need_encrypt, parameter->session_id,parameter->seq_num); if(ret == 0) { printf("%s:%d:encrypt ERROR\n",__func__,__LINE__); Free_Memory_Lock(); return -1; } Send_Pro_Data(ack_session->mmu->pmem); Free_Memory_Lock(); ack_session->session_status = ACK_SESSION_USING; return 0; } return -1; }
void Pro_Link_Recv_Hook(ProHeader *header) { ProHeader *p2header; static ACK_Session_Tab * ack_session = Get_ACK_Session_Tab(); static CMD_Session_Tab * cmd_session = Get_CMD_Session_Tab(); //TODO: parse the protocol data stream here if(header->is_ack == 1) { if(header->session_id == 1) { if(cmd_session[1].usage_flag == 1 && cmd_session[1].ack_callback) { cmd_session[1].ack_callback(header); Get_Memory_Lock(); Free_CMD_Session(&cmd_session[1]); Free_Memory_Lock(); } } else if(header->session_id > 1 && header->session_id < 32) { if(cmd_session[header->session_id].usage_flag == 1) { Get_Memory_Lock(); p2header = (ProHeader*)cmd_session[header->session_id].mmu->pmem; if(p2header->session_id == header->session_id && p2header->sequence_number == header->sequence_number) { //printf("%s:Recv Session %d ACK\n",__func__,p2header->session_id); Call_APP_Func = cmd_session[header->session_id].ack_callback; Free_CMD_Session(&cmd_session[header->session_id]); Free_Memory_Lock(); if(Call_APP_Func) { Call_APP_Func(header); } } else { Free_Memory_Lock(); } } } } else { //TODO,is a request package switch(header->session_id) { case 0: Pro_Request_Interface(header); break; case 1: default: if(ack_session[header->session_id - 1].session_status == ACK_SESSION_PROCESS) { printf("%s,This session is waiting for App ack:" "session id=%d,seq_num=%d\n",__func__, header->session_id,header->sequence_number); } else if(ack_session[header->session_id - 1].session_status == ACK_SESSION_IDLE) { if(header->session_id > 1) { ack_session[header->session_id - 1].session_status = ACK_SESSION_PROCESS; } Pro_Request_Interface(header); } else if(ack_session[header->session_id - 1].session_status == ACK_SESSION_USING) { Get_Memory_Lock(); p2header = (ProHeader *)ack_session[header->session_id - 1].mmu->pmem; if(p2header->sequence_number == header->sequence_number) { printf("%s:repeat ACK to remote,session id=%d,seq_num=%d\n", __func__,header->session_id,header->sequence_number); Send_Pro_Data(ack_session[header->session_id - 1].mmu->pmem); Free_Memory_Lock(); } else { printf("%s:same session,but new seq_num pkg,session id=%d," "pre seq_num=%d,""cur seq_num=%d\n",__func__, header->session_id,p2header->sequence_number, header->sequence_number); ack_session[header->session_id - 1].session_status = ACK_SESSION_PROCESS; Free_Memory_Lock(); Pro_Request_Interface(header); } } break; } } }
int Pro_Send_Interface(ProSendParameter *parameter) { unsigned short ret = 0; CMD_Session_Tab * cmd_session = (CMD_Session_Tab *) NULL; static unsigned short global_seq_num = 0; if(parameter->length > PRO_PURE_DATA_MAX_SIZE) { printf("%s:%d:ERROR,length=%d is oversize\n",__func__,__LINE__,parameter->length); return -1; } switch(parameter->session_mode) { case 0: Get_Memory_Lock(); cmd_session = Request_CMD_Session(CMD_SESSION_0,Pro_Calc_Length(parameter->length,parameter->need_encrypt)); if(cmd_session == (CMD_Session_Tab *)NULL) { Free_Memory_Lock(); printf("%s:%d:ERROR,there is not enough memory\n",__func__,__LINE__); return -1; } ret = sdk_encrypt_interface(cmd_session->mmu->pmem,parameter->buf,parameter->length, 0,parameter->need_encrypt,cmd_session->session_id,global_seq_num); if(ret == 0) { printf("%s:%d:encrypt ERROR\n",__func__,__LINE__); Free_CMD_Session(cmd_session); Free_Memory_Lock(); return -1; } Send_Pro_Data(cmd_session->mmu->pmem); global_seq_num ++; Free_CMD_Session(cmd_session); Free_Memory_Lock(); break; case 1: Get_Memory_Lock(); cmd_session = Request_CMD_Session(CMD_SESSION_1,Pro_Calc_Length(parameter->length,parameter->need_encrypt)); if(cmd_session == (CMD_Session_Tab *)NULL) { Free_Memory_Lock(); printf("%s:%d:ERROR,there is not enough memory\n",__func__,__LINE__); return -1; } if(global_seq_num == cmd_session->pre_seq_num) { global_seq_num ++; } ret = sdk_encrypt_interface(cmd_session->mmu->pmem,parameter->buf,parameter->length, 0,parameter->need_encrypt,cmd_session->session_id,global_seq_num); if(ret == 0) { printf("%s:%d:encrypt ERROR\n",__func__,__LINE__); Free_CMD_Session(cmd_session); Free_Memory_Lock(); return -1; } cmd_session->pre_seq_num = global_seq_num ++; cmd_session->ack_callback = parameter->ack_callback; cmd_session->ack_timeout = (parameter->ack_timeout > POLL_TICK) ? parameter->ack_timeout : POLL_TICK; cmd_session->pre_timestamp = Get_TimeStamp(); cmd_session->sent_time = 1; cmd_session->retry_send_time = 1; Send_Pro_Data(cmd_session->mmu->pmem); Free_Memory_Lock(); break; case 2: Get_Memory_Lock(); cmd_session = Request_CMD_Session(CMD_SESSION_AUTO,Pro_Calc_Length(parameter->length,parameter->need_encrypt)); if(cmd_session == (CMD_Session_Tab *)NULL) { Free_Memory_Lock(); printf("%s:%d:ERROR,there is not enough memory\n",__func__,__LINE__); return -1; } if(global_seq_num == cmd_session->pre_seq_num) { global_seq_num ++; } ret = sdk_encrypt_interface(cmd_session->mmu->pmem,parameter->buf,parameter->length, 0,parameter->need_encrypt,cmd_session->session_id,global_seq_num); if(ret == 0) { printf("%s:%d:encrypt ERROR\n",__func__,__LINE__); Free_CMD_Session(cmd_session); Free_Memory_Lock(); return -1; } cmd_session->pre_seq_num = global_seq_num ++; cmd_session->ack_callback = parameter->ack_callback; cmd_session->ack_timeout = (parameter->ack_timeout > POLL_TICK) ? parameter->ack_timeout : POLL_TICK; cmd_session->pre_timestamp = Get_TimeStamp(); cmd_session->sent_time = 1; cmd_session->retry_send_time = parameter->retry_time; Send_Pro_Data(cmd_session->mmu->pmem); Free_Memory_Lock(); break; } return 0; }
int Pro_Send_Interface(ProSendParameter *parameter) { unsigned short ret = 0; Session_Queue *p2session = NULL; static unsigned short global_seq_num = 0; if(parameter->length > PRO_DATA_MAX_SIZE) { return -1; } pthread_mutex_lock(&send_lock); switch(parameter->pkg_type) { case 0: ret = sdk_encrypt_interface(Send_Global_Common_Memory,parameter->buf,parameter->length, 0,parameter->need_encrypt,0,global_seq_num ++); if(ret == 0) { printf("%s:%d:ERROR\n",__func__,__LINE__); pthread_mutex_unlock(&send_lock); return -1; } Send_Pro_Data(Send_Global_Common_Memory); break; case 1: if(global_seq_num == Send_Session_Common_Tab.pre_seq_num) { global_seq_num ++; } Send_Session_Common_Tab.pre_seq_num = global_seq_num; ret = sdk_encrypt_interface(Send_Global_Common_Memory,parameter->buf,parameter->length, 0,parameter->need_encrypt,1,global_seq_num ++); if(ret == 0) { printf("%s:%d:ERROR\n",__func__,__LINE__); pthread_mutex_unlock(&send_lock); return -1; } Send_Session_Common_Tab.ack_callback = parameter->ack_callback; Send_Session_Common_Tab.ack_timeout = (parameter->ack_timeout > POLL_TICK) ? parameter->ack_timeout : POLL_TICK; Send_Session_Common_Tab.pre_timestamp = Get_TimeStamp(); Send_Session_Common_Tab.usage_flag = 1; Send_Pro_Data(Send_Global_Common_Memory); break; case 2: p2session = Request_Send_Session(parameter->length + sizeof(ProHeader) + 4); if(p2session) { if(global_seq_num == p2session->pre_seq_num) { global_seq_num ++; } p2session->pre_seq_num = global_seq_num; ret = sdk_encrypt_interface((unsigned char*)p2session->mmu->start_addr, parameter->buf,parameter->length,0,parameter->need_encrypt, p2session->session_id,global_seq_num ++); if(ret == 0) { printf("%s:%d:ERROR\n",__func__,__LINE__); Free_Send_Session(p2session); pthread_mutex_unlock(&send_lock); return -1; } p2session->ack_callback = parameter->ack_callback; p2session->ack_timeout = (parameter->ack_timeout > POLL_TICK) ? parameter->ack_timeout : POLL_TICK; p2session->pre_timestamp = Get_TimeStamp(); Send_Pro_Data((unsigned char*)p2session->mmu->start_addr); p2session->sent_time = 1; p2session->retry_send_time = parameter->retry_time; ret = 0; } break; } pthread_mutex_unlock(&send_lock); return 0; }
void Pro_Link_Recv_Hook(ProHeader *header) { unsigned char i; ProHeader *p2header; Ack_Session_Queue *p2acksession; //TODO: parse the protocol data stream here if(header->is_ack == 1) { if(header->session_id == 1) { printf("%s:Recv Session 1 ACK\n",__func__); if(Send_Session_Common_Tab.usage_flag == 1 && Send_Session_Common_Tab.ack_callback) { Send_Session_Common_Tab.ack_callback(header); } } else if(header->session_id > 1 && header->session_id < 32) { pthread_mutex_lock(&send_lock); for(i = 0 ; i < SESSION_AND_MEM_COUNT ; i ++) { if(Send_Session_Tab[i].usage_flag == 1) { p2header = (ProHeader*)Send_Session_Tab[i].mmu->start_addr; if(p2header->session_id == header->session_id && p2header->sequence_number == header->sequence_number) { printf("%s:Recv Session %d ACK\n",__func__,p2header->session_id); Send_Session_Tab[i].ack_callback(header); Free_Send_Session(&Send_Session_Tab[i]); break; } } } pthread_mutex_unlock(&send_lock); } } else { //TODO,is a request package switch(header->session_id) { case 0: Pro_Request_Interface(header); break; case 1: default: p2acksession = Search_Ack_Session(header->session_id); if(p2acksession) { if(p2acksession->session_status == ACK_SESSION_PROCESS) { printf("%s,This session is waiting for App ack:" "session id=%d,seq_num=%d\n",__func__, header->session_id,header->sequence_number); } else if(p2acksession->session_status == ACK_SESSION_IDLE) { if(header->session_id > 1) { p2acksession->session_status = ACK_SESSION_PROCESS; } Pro_Request_Interface(header); } else if(p2acksession->session_status == ACK_SESSION_USING) { p2header = (ProHeader *)p2acksession->mmu->start_addr; if(p2header->sequence_number == header->sequence_number) { printf("%s:repeat ACK to remote,session id=%d,seq_num=%d\n", __func__,header->session_id,header->sequence_number); pthread_mutex_lock(&send_lock); Send_Pro_Data((unsigned char*)p2acksession->mmu->start_addr); pthread_mutex_unlock(&send_lock); } else { printf("%s:same session,but new seq_num pkg,session id=%d," "pre seq_num=%d,""cur seq_num=%d\n",__func__, header->session_id,p2header->sequence_number, header->sequence_number); p2acksession->session_status = ACK_SESSION_PROCESS; Pro_Request_Interface(header); } } } break; } } }