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; }
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; }