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