gpr_route_layer.pr.c

opnet Ad hoc仿真源程序,自己构建的路由协议和网络模型

	AddItemToQ(iSeq,& q_request_list);//see this request


	//queue the request
	iItem.pkt_id=iSeq;
	iItem.pkt=pk_ptr;
	iItem.iStale=0;
	Pkt_AddItemToQ(iItem,&q_pkt_req_list);
	//send ns for the request
	gpr_send_NS_for_route(ND_REQEST);	


	printf("Node %s will issue a request\n",my_name);//

	sprintf(msg,"Node %d will issue a request\n",my_gpr_address);//reply proxyly
	//GPR_message(msg,10);
	
}	


void gpr_transmit_request_repeat(int destination_gpr_address)
{
Packet* pk_ptr;
sPkBuff iItem;
int iSeq;
	
	pk_ptr=op_pk_create_fmt("GPR_Request");
	op_pk_nfd_set(pk_ptr,"Type",REQUET_PACKET_TYPE);
	op_pk_nfd_set(pk_ptr,"SRC",my_gpr_address);


	op_pk_nfd_set(pk_ptr,"DEST",destination_gpr_address);
	op_pk_nfd_set(pk_ptr,"GP_0",my_group_id);
	op_pk_nfd_set(pk_ptr,"Size_Route",1);
	op_pk_nfd_set(pk_ptr,"SRC_GP",my_group_id);	

	op_pk_nfd_set(pk_ptr,"Seq_number",++g_pkt_id);
	op_pk_nfd_set(pk_ptr,"TTL",0);

	iSeq=g_pkt_id;
	AddItemToQ(iSeq,& q_request_list);//see this request


	//queue the request
	iItem.pkt_id=iSeq;
	iItem.pkt=pk_ptr;
	iItem.iStale=0;
	Pkt_AddItemToQ(iItem,&q_pkt_req_list);
		
	sprintf(msg,"Node %d will issue a request proxy\n",my_gpr_address);//reply proxyly
//	GPR_message(msg,10);
}	


void gpr_send_reply_proxy(Packet* pk_ptr)
{

int request_source_gpr_address;
int size_route,iSeq;
int i;
char field[10];
int iGP_id;
sPkBuff iItem;
int iTTL;



int dest_address,iDest_gp;


op_pk_nfd_get(pk_ptr,"SRC",&request_source_gpr_address);
op_pk_nfd_get(pk_ptr,"SRC_GP",&iGP_id);
op_pk_nfd_get(pk_ptr,"DEST",&dest_address);
op_pk_nfd_get(pk_ptr,"DEST_GP",&iDest_gp); 

iSeq=++g_pkt_id;	//set the new seq for reply
op_pk_nfd_set(pk_ptr,"Seq_number",iSeq);

op_pk_nfd_set(pk_ptr,"Type",REPLY_PACKET_TYPE);
op_pk_nfd_set(pk_ptr,"SRC",dest_address);
op_pk_nfd_set(pk_ptr,"SRC_GP",iDest_gp);

op_pk_nfd_get(pk_ptr,"Size_Route",&size_route);
op_pk_nfd_set(pk_ptr,"DEST",request_source_gpr_address);
op_pk_nfd_set(pk_ptr,"DEST_GP",&iGP_id); 

iTTL=GP_route_cache[dest_address].iDistance;
op_pk_nfd_set (pk_ptr, "TTL",iTTL);//fordge the ttl

	size_route=GP_route_cache[dest_address].size_route;
						if (size_route!=0)
						{
							for (i=0;i<size_route;i++)
							{
									sprintf(field,"GP_%d",i);
									op_pk_nfd_set(pk_ptr,field,GP_route_cache[dest_address].Gp_route[i] );

							}
				
							op_pk_nfd_set (pk_ptr,"Size_Route",size_route); 					
						
			
						}

		  



					
			
	AddItemToQ(iSeq,& q_reply_list);//see this request


	//queue the reply
	iItem.pkt_id=iSeq;
	iItem.pkt=pk_ptr;
	iItem.iStale=0;
	Pkt_AddItemToQ(iItem,&q_pkt_reply_list);
	//send ns for the request
	gpr_send_NS_for_route(ND_REPLY);	
	

	sprintf(msg,"Node %d will reply proxyly\n",my_gpr_address);//reply proxyly
//	GPR_message(msg,10);
	
}


void gpr_send_reply(Packet* pk_ptr)
{

int request_source_gpr_address;
int size_route,iSeq;
int i;
char field[10];
int bAppear,iGP_id;
sPkBuff iItem;
int iPos;

bAppear=0;

op_pk_nfd_get(pk_ptr,"SRC",&request_source_gpr_address);
op_pk_nfd_get(pk_ptr,"SRC_GP",&iGP_id);

iSeq=++g_pkt_id;	//set the new seq for reply
op_pk_nfd_set(pk_ptr,"Seq_number",iSeq);

op_pk_nfd_set(pk_ptr,"Type",REPLY_PACKET_TYPE);
op_pk_nfd_set(pk_ptr,"SRC",my_gpr_address);
op_pk_nfd_set(pk_ptr,"SRC_GP",my_group_id);

op_pk_nfd_get(pk_ptr,"Size_Route",&size_route);
op_pk_nfd_set(pk_ptr,"DEST",request_source_gpr_address);
op_pk_nfd_set(pk_ptr,"DEST_GP",&iGP_id); 
op_pk_nfd_set (pk_ptr, "TTL",0);//resume the ttl


	AddItemToQ(iSeq,& q_reply_list);//see this request

for (i=0;i<size_route;i++)
	{
		
		sprintf(field,"GP_%d",i);
		op_pk_nfd_get (pk_ptr,field,&iGP_id);	
		if (iGP_id==my_group_id)
			{
				bAppear=1;
				break;
			}
	
	}

//if diff group, add its group name to the gp link
if (bAppear==0)
	{
	
		if (size_route< MAX_SIZE_GROUP_LINK-1)
			{
			
		sprintf(field,"GP_%d",size_route);
		op_pk_nfd_set (pk_ptr,field,my_group_id);
	   // increment by one the Size_Route field of the packet
		op_pk_nfd_set(pk_ptr,"Size_Route",++size_route);
		}
		else
			{
			
			sprintf(field,"GP_%d",MAX_SIZE_GROUP_LINK-1);
			op_pk_nfd_set (pk_ptr,field,my_group_id);
			// increment by one the Size_Route field of the packet
			op_pk_nfd_set(pk_ptr,"Size_Route",MAX_SIZE_GROUP_LINK);		
			}
		

	 }

		//learn the route

			//gpr_update_route(pk_ptr,destination_gpr_address);
			//route 2
			if ( GP_route_cache[request_source_gpr_address].size_route!=0)//better one?
				{
					//no chg
					sprintf(msg,"old route to %d,len is %d(%d)!\n",request_source_gpr_address,size_route,GP_route_cache[request_source_gpr_address].size_route);
					//GPR_message(msg,5);	
				}
			else
				{
				
					
					iPos=-1;
					//printf("node %d learn path len %d from the request:",my_gpr_address,size_route);
					//better one,wrtie the route cache
					for (i=0;i<size_route;i++)
						{
							sprintf(field,"GP_%d",i);
							op_pk_nfd_get(pk_ptr,field,&iGP_id);
							GP_route_cache[request_source_gpr_address].Gp_route[i] = iGP_id ;
							printf("%d->",iGP_id);	
							if (iGP_id==my_group_id)
								iPos=i;										   
					   	}	
					printf("Node %s Echo a reply,time:%.2f\n",my_name,op_sim_time());
					
					GP_route_cache[request_source_gpr_address].size_route=size_route;
					GP_route_cache[request_source_gpr_address].iTimeStamp=op_sim_time();
					
				 }			
		///////////////
			




	//queue the reply
	iItem.pkt_id=iSeq;
	iItem.pkt=pk_ptr;
	iItem.iStale=0;
	Pkt_AddItemToQ(iItem,&q_pkt_reply_list);
	//send ns for the request
	gpr_send_NS_for_route(ND_REPLY);	
	

	//gpr_send_to_mac(pk_ptr,GPR_BROADCAST_ADDR);
}


/////////////
void  gpr_handle_reply(Packet* pk_ptr)
{
int source_gpr_address;
int destination_gpr_address;
int size_route,iGP_id;
int iSeq;
char field[10];
int iPos;
int iNext_hop,iRelay,iTTL;
int i;


// read the different fields of the packet
op_pk_nfd_get (pk_ptr,"SRC",&source_gpr_address);
op_pk_nfd_get (pk_ptr,"DEST",&destination_gpr_address); 
op_pk_nfd_get (pk_ptr,"Size_Route",&size_route); 
op_pk_nfd_get(pk_ptr,"Seq_number",&iSeq);
op_pk_nfd_get(pk_ptr,"RELAY",&iRelay);
op_pk_nfd_get(pk_ptr,"TTL",&iTTL);
	op_pk_nfd_get(pk_ptr,"Next_hop",&iNext_hop);

	//have ever seen it
	iPos=IsInQueue(iSeq, & q_reply_list);
	if (iPos==-1)
	{//never seen it then see it
	//if (iNext_hop==my_gpr_address)
		AddItemToQ(iSeq,& q_reply_list);
		op_ima_obj_attr_set(my_node_id,"Conceived",1);
		
				
	}
	else
		{
			return;
		
		
		}
	
	if (source_gpr_address==my_gpr_address)
		return;




	printf("%s hear a reply..\n",my_name);
	if ( (GP_route_cache[source_gpr_address].iDistance==-1)||(GP_route_cache[source_gpr_address].iDistance>=iTTL) )
		GP_route_cache[source_gpr_address].iDistance=iTTL;//move to gpr_update_route
	else
		return;
	
	if (GP_route_cache[source_gpr_address].iExpectedVal==0)
		{
		GP_route_cache[source_gpr_address].iExpectedVal= (MAX_SIZE_TTL-GP_route_cache[source_gpr_address].iDistance)*1000;
		
		}
	
	sprintf(msg,"hear reply %d from %d,TTL %d(%d) to %d",
		iSeq,iRelay,
		iTTL,GP_route_cache[source_gpr_address].iDistance,	
		iNext_hop);
	GPR_message(msg,10);	
	
	printf("%s fwd the reply..\n",my_name);
	
		////////////////
		//node on the path will learn the group link infor in the reply
			//update the route cache, intermidiate node will learn 2 route to 2 end of link
			//gpr_update_route(pk_ptr,source_gpr_address);
			//route 1
			if ( GP_route_cache[source_gpr_address].size_route!=0)//better one?
				{
					//no chg
					sprintf(msg,"old route to %d,len is %d(%d)!\n",source_gpr_address,size_route,GP_route_cache[source_gpr_address].size_route);
					//GPR_message(msg,5);	
				}
			else
				{
				
//					printf("node %d learn path1 len %d from the reply:",my_gpr_address,size_route);
					iPos=-1;
					//better one,wrtie the route cache
					for (i=0;i<size_route;i++)
						{
							sprintf(field,"GP_%d",i);
							op_pk_nfd_get(pk_ptr,field,&iGP_id);
							GP_route_cache[source_gpr_address].Gp_route[i] = iGP_id ;
							//printf("%d->",iGP_id);	
							if (iGP_id==my_group_id)
								iPos=i;
										   
					   	}	
					//printf("..\n");
					op_prg_odb_bkpt("reply");
					
					GP_route_cache[source_gpr_address].size_route=size_route;//size_route-iPos;
					
				 }
			//gpr_update_route(pk_ptr,destination_gpr_address);
			//route 2
			if ( GP_route_cache[destination_gpr_address].size_route!=0)//better one?
				{
					//no chg
					
				
						
				}
			else
				{
				
					//printf("Node %d learn from reply,route to %d is:.!\n",my_group_id,source_gpr_address);
					iPos=-1;
					//printf("node %d learn path2 len %d from the reply:",my_gpr_address,size_route);
					//better one,wrtie the route cache
					for (i=0;i<size_route;i++)
						{
							sprintf(field,"GP_%d",i);
							op_pk_nfd_get(pk_ptr,field,&iGP_id);
							GP_route_cache[destination_gpr_address].Gp_route[i] = iGP_id ;
							//printf("%d->",iGP_id);	
							if (iGP_id==my_group_id)
								iPos=i;										   
					   	}	
			
					
					GP_route_cache[destination_gpr_address].size_route=size_route;//iPos+1;
					
				 }			
		///////////////
		

	if (my_gpr_address==destination_gpr_address)
		{

			printf("node %d got the reply,time:%.2f\n",my_gpr_address,op_sim_time());
			op_prg_odb_bkpt("route");			
								
			for (i=0;i<size_route;i++)
						{
							sprintf(field,"GP_%d",i);
							op_pk_nfd_get(pk_ptr,field,&iGP_id);
							GP_route_cache[destination_gpr_address].Gp_route[i] = iGP_id ;
							printf("%d->",iGP_id);	
							if (iGP_id==my_group_id)
								iPos=i;										   
					   	}	
			printf("..\n");
			
			op_pk_destroy (pk_ptr);
		

			
		
		}
	else
		{
		

			if (iNext_hop==my_gpr_address)//
				{
				
							
					gpr_forward_reply(pk_ptr);
				}
			else
				{
					
					
				}
		
		}
	
	
	
	
	
	


}

void gpr_forward_reply(Packet* pk_ptr)
{	

int i;
char field[10];
int bAppear;
sPkBuff iItem;


int destination_gpr_address;
int size_route,iGP_id;
int iSeq;


// read the different fields of the packet

op_pk_nfd_get (pk_ptr,"DEST",&destination_gpr_address); 
op_pk_nfd_get (pk_ptr,"Size_Route",&size_route); 
op_pk_nfd_get(pk_ptr,"Seq_number",&iSeq);

bAppear=0;


op_pk_nfd_get(pk_ptr,"Size_Route",&size_route);

for (i=0;i<size_route;i++)
	{
		
		sprintf(field,"GP_%d",i);
		op_pk_nfd_get (pk_ptr,field,&iGP_id);	
		if (iGP_id==my_group_id)
			{
				bAppear=1;
				break;
			}
	
	}


if (bAppear==0)
	{
		//out of scope, need not fwd it


	 }
else
	{
	
		//has see this reply in handle fun


		//queue the reply
		iItem.pkt_id=iSeq;
		iItem.pkt=pk_ptr;
		iItem.iStale=0;
		Pkt_AddItemToQ(iItem,&q_pkt_reply_list);
		//send ns for the reply
		
		gpr_send_NS_for_route(ND_REPLY);	

	}


}


void gpr_update_route(Packet * pk_ptr,int destination_gpr_address)
{

int size_route,i;
int iGP_id;
char field[10];
int iPos;

		op_pk_nfd_get (pk_ptr,"Size_Route",&size_route); 
		
			
		if (size_route==0)
			{
				return;
			}

					
		iPos=-1;
					//better one,wrtie the route cache
	for (i=0;i<size_route;i++)
	{
		sprintf(field,"GP_%d",i);
		op_pk_nfd_get(pk_ptr,field,&iGP_id);
		GP_route_cache[destination_gpr_address].Gp_route[i] = iGP_id ;
		if (iGP_id==my_group_id)
				iPos=i;
										   
	}	

					
	GP_route_cache[destination_gpr_address].size_route=size_route;//size_route-iPos;
	GP_route_cache[destination_gpr_address].iTimeStamp=op_sim_time();
					
}

/* End of Function Block */

/* Undefine optional tracing in FIN/FOUT/FRET */
/* The FSM has its own tracing code and the other */
/* functions should not have any tracing.		  */
#undef FIN_TRACING
#define FIN_TRACING

#undef FOUTRET_TRACING
#define FOUTRET_TRACING

#if defined (__cplusplus)
extern "C" {
#endif
	void gpr_route_layer (OP_SIM_CONTEXT_ARG_OPT);
	VosT_Obtype gpr_route_layer_init (int * init_block_ptr);
	VosT_Address gpr_route_layer_alloc (VOS_THREAD_INDEX_ARG_COMMA VosT_Obtype, int);
	void gpr_route_layer_diag (OP_SIM_CONTEXT_ARG_OPT);
	void gpr_route_layer_terminate (OP_SIM_CONTEXT_ARG_OPT);
	void gpr_route_layer_svar (void *, const char *, void **);


	VosT_Fun_Status Vos_Define_Object (VosT_Obtype * obst_ptr, const char * name, unsigned int size, unsigned int init_obs, unsigned int inc_obs);
	VosT_Address Vos_Alloc_Object_MT (VOS_THREAD_INDEX_ARG_COMMA VosT_Obtype ob_hndl);
	VosT_Fun_Status Vos_Poolmem_Dealloc_MT (VOS_THREAD_INDEX_ARG_COMMA VosT_Address ob_ptr);
#if defined (__cplusplus)
} /* end of 'extern "C"' */
#endif




/* Process model interrupt handling procedure */


void
gpr_route_layer (OP_SIM_CONTEXT_ARG_OPT)
	{

#if !defined (VOSD_NO_FIN)
	int _op_block_origin = 0;
#endif
	FIN_MT (gpr_route_layer ());
	if (1)
		{
		Packet * pk_ptr;
		Ici* ici_dest_address;
		int packet_type;
		
		List*				proc_record_handle_list_ptr;
		int					record_handle_list_size;
		OmsT_Pr_Handle		process_record_handle;
		Objid				mac_module_objid;
		double				ne_address = OPC_DBL_UNDEF;
		


		FSM_ENTER ("gpr_route_layer")

		FSM_BLOCK_SWITCH
			{
			/*---------------------------------------------------------*/
			/** state (pre_ini) enter executives **/
			FSM_STATE_ENTER_UNFORCED_NOLABEL (0, "pre_ini", "gpr_route_layer [pre_ini enter execs]")
				FSM_PROFILE_SECTION_IN (gpr_route_layer [pre_ini enter execs], state0_enter_exec)
				{
				
					char msg[50];
					int i,iPos;
				
				
				
				
				
				
				// ensure that each node has finised its pre-initialization before going in the init sate
				
				
					my_module_id=op_id_self();