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