gpr_route_layer.pr.c

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

						
						break;
						
						case ND_REPLY:
													

						
						//little endian
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me<iPos_nb) )
							{
						sprintf(msg,"2)ND_REPLY:metirc is %d\n",iTTL);
//						GPR_message(msg,10);								
								//path is in right direction 
								return  ( (iPos_nb -iPos_me+1)*MAX_SIZE_TTL-iTTL )*1000;
							}	
												
						if ( (iPos_me==iPos_nb)&&(iPos_nb!=-1) )
							{
													sprintf(msg,"3)ND_REPLY:metirc is %d\n",iTTL);
													GPR_message(msg,10);
							return (MAX_SIZE_TTL-iTTL)*1000;
							}
						
												
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me>iPos_nb) )
							{
									
								//path is in wrong direction 
								return  -1;
							}	
					
						sprintf(msg,"no direction infor,TTL(%d) to  %d\n",iTTL,iDest_addr);
//						GPR_message(msg,10);						
						return MAX_SIZE_TTL-iTTL;
						
						break;
						
						
						
						
				
				}//end of case
		
		
		}//end of if route



return iRet;

}


int IsIn_Right_Direction_NA(int iDest_addr,int iTest_GP,int iCode)
{
int iRet;
//////////////////////////
//iRet metrics assinged
///////////////////////////
// -1:	wrong direction 
//	0: 	same group,but no route   
//	1:	same group, has route  or for request
//	2~:	has route and cross group
///////////////////////////   
int size_route;
int iPos_nb,iPos_me;	
int i;

iRet=-3;
iPos_nb=iPos_me=-1;



if (FULL_CONNECT==1)
	return 4;//fixed valid level


if (iDest_addr==my_gpr_address)
	return 5;//max level
size_route=	GP_route_cache[iDest_addr].size_route;

		
if (EPIDEMIC)
	return 1;

if (size_route==0)
	{
													
			//filter:
			switch (iCode)
				{
										
				case ND_DATA:
							iRet= -1;
				break;
										
				case ND_REQEST:
				if (iTest_GP==my_group_id)
					iRet= 1;
				
				break;				
						
				case ND_REPLY:
							iRet= -18;

				break;
					
										
				
				}

	
	}
else
	{

	//has route:

			for (i=0;i<size_route;i++)
			{
	
					if (GP_route_cache[iDest_addr].Gp_route[i] == iTest_GP )
					{	
						iPos_nb=i;
						}
					if (GP_route_cache[iDest_addr].Gp_route[i] == my_group_id )
					{	
						iPos_me=i;
					}
			
			
					
					
					
			 }//end of for
			
			//filter:
			switch (iCode)
				{
						case ND_DATA:
						//big endian
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me<iPos_nb) )
							{
								//path is in right direction 
							return iPos_nb-iPos_me+1;
								
							}						
						if ( (iPos_me==iPos_nb)&&(iPos_nb!=-1) )
							return 1;
						break;
							
						case ND_REQEST:
						//all pass
						
							return 1;
						
						break;
						
						case ND_REPLY:
						//little endian
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me>iPos_nb) )
							{
								//path is in right direction 
								return  iPos_me-iPos_nb+1;
							}	
												
						if ( (iPos_me==iPos_nb)&&(iPos_nb!=-1) )
							return 1;
						
												
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me<iPos_nb) )
							{
									
								//path is in wrong direction 
								return  -1;
							}	

						return 0;
						
						break;
						
						
						
						
				
				}
		}



return iRet;

}

void gpr_send_NS_prox(int gpr_ns_dest_addr,int wanted_pk_id,int iCode)
{
Packet * pk_NS_ptr	;
//issue a NS to ping its neighbor


int neighbor_gpr_addr;
int FindBetterone;
int iBig;
int iBestOne;

iBestOne=-1;
iBig=FindBetterone=0;


	// Create the NS
	pk_NS_ptr=op_pk_create_fmt("GPR_NA");
	op_pk_nfd_set(pk_NS_ptr,"Type",NS_PACKET_TYPE);
	op_pk_nfd_set(pk_NS_ptr,"Code",iCode);

	//
	// set the DEST field
	op_pk_nfd_set(pk_NS_ptr,"DEST",GPR_BROADCAST_ADDR);	
	op_pk_nfd_set(pk_NS_ptr,"DEST_GP",-1);	
	op_pk_nfd_set(pk_NS_ptr,"SRC",my_gpr_address);	
	op_pk_nfd_set(pk_NS_ptr,"SRC_GP",my_group_id);	
	op_pk_nfd_set(pk_NS_ptr,"PKT_DEST",gpr_ns_dest_addr);	
	op_pk_nfd_set(pk_NS_ptr,"PKT_DEST_GP",-1);	
	op_pk_nfd_set(pk_NS_ptr, "packet_ID",wanted_pk_id );




	//check its neighbor list to select a better candidate to send ns
	//if neighbor in the group link , it is a better one


			//////////////////

	gpr_send_to_mac(pk_NS_ptr,GPR_BROADCAST_ADDR);
	sprintf(msg,"Send type %d ns\n",iCode);
//	GPR_message(msg,10);

if (FULL_CONNECT==1)
		op_intrpt_schedule_self(op_sim_time()+VAL_TIME_LOOP,INT_NA_RCV);	


}


void gpr_send_NS_for_route(int iType)
{


	//
//if (iType!=ND_DATA||EPIDEMIC)
		op_intrpt_schedule_self(op_sim_time(),INT_NS_TIMER);	




}


void gpr_send_NS(int gpr_ns_dest_addr,int wanted_pk_id)
{


	//set timmer, start ns repeating
	op_intrpt_schedule_self(op_sim_time(),INT_NS_TIMER);	

	//buffer it

	if ( ( IsInQueue(gpr_ns_dest_addr, & q_dest_list) ==-1 ) || 
		 (IsInQueue(wanted_pk_id, & q_pkt_list  ) ==-1 )    )
	{
	

		AddItemToQ(gpr_ns_dest_addr,& q_dest_list);
		AddItemToQ(wanted_pk_id,& q_pkt_list);
		

					
		
			
	}

}


void upper_layer_data_arrival (Packet* data_pk_ptr, int destination_gpr_address)
{
	
//encap the app data into gpr route packet


Packet * pk_ptr	;
int size_route;




 
	// Create the data packet wich is going to transport the upper layer packet, and set its Type field
	pk_ptr=op_pk_create_fmt("GPR_Data");
	op_pk_nfd_set(pk_ptr,"Type",DATA_PACKET_TYPE);

	//
	// set the DEST field of the packet with this mac address
	op_pk_nfd_set(pk_ptr,"DEST",destination_gpr_address);
	op_pk_nfd_set(pk_ptr,"SRC",my_gpr_address);
	op_pk_nfd_set(pk_ptr,"SRC_GP",my_group_id);
	// encap : insert the upper layer data in the gpr data packet
	op_pk_nfd_set (pk_ptr, "data", data_pk_ptr);
	op_pk_nfd_set (pk_ptr, "packet_ID",++g_pkt_id );
	op_pk_nfd_set (pk_ptr, "TTL",0 );
	op_pk_nfd_set (pk_ptr,"Size_Route",0); 		



	SeenPkt[0]=g_pkt_id;
	AddItemToQ(g_pkt_id,& my_SeenQueue);

	size_route=GP_route_cache[destination_gpr_address].size_route;


	GPR_insert_buffer(pk_ptr,destination_gpr_address);

	

	if (size_route!=0||EPIDEMIC|| FULL_CONNECT==1)//has route
		{
		
	

			gpr_send_NS_for_route( ND_DATA);

			
		}
	else
		{//no route yet
			//send a request for the route of sequence of groups


	
		
			//gpr_transmit_request(destination_gpr_address);	
		
		}




	


	if (1)
	{
	op_prg_odb_bkpt("ztl_down");
	}

	
}


int AddNeighbor(int neighbor_gpr_addr,int neighbor_group_id,int pkt_dest_gpr_address,int pkt_dest_group,int pk_id,int iCode,int iMetrics)
{


int i;
int iFind=0,iReturn=-1;
int iWaitValue;

iWaitValue=-1;
		


//filter the ns,if not fit the route,then ignore it

//affirm the na, verify it if suitable as the next hop
//iWaitValue = IsIn_Right_Direction_NA(pkt_dest_gpr_address,neighbor_group_id,iCode) ;   

iWaitValue=iMetrics;

if (iWaitValue<0)
	return -3;

for (i=0;i<MAX_SIZE_NODES;i++)
{

	
	if ( (list_neighbor[i].szNeighborID==neighbor_gpr_addr)&&
		(list_neighbor[i].dest_addr==pkt_dest_gpr_address) &&
		(list_neighbor[i].iCode==iCode)                )//the neighbor echo ns  
		{
			iFind=1;
			//timestamp update

			list_neighbor[i].iWaitValue=iWaitValue;

			list_neighbor[i].iContinous++;

	
			
			
			list_neighbor[i].iINTflag=1;
			
			list_neighbor[i].dest_addr=pkt_dest_gpr_address;
			list_neighbor[i].iPk_id=pk_id;
			list_neighbor[i].iCode=iCode;
			
			iReturn=i;
			
			sprintf(msg,"rcv type %d old NA echo from %d,metric is %d\n",iCode,neighbor_gpr_addr,iWaitValue);
//			GPR_message(msg,10);		


			break;
		}
	
}

if (iFind==0)
{


				
	for (i=0;i<MAX_SIZE_NODES;i++)
	{
	
		if (list_neighbor[i].szNeighborID==-1)
		{
			list_neighbor[i].szNeighborID=neighbor_gpr_addr;
			list_neighbor[i].szNeighborGroupID=neighbor_group_id;

			list_neighbor[i].iWaitValue=iWaitValue;


			list_neighbor[i].iContinous++;

			
	
			
			list_neighbor[i].iINTflag=1;
			
			list_neighbor[i].dest_addr=pkt_dest_gpr_address;
			list_neighbor[i].iPk_id=pk_id;
			list_neighbor[i].iCode=iCode;
			iReturn=i;
			sprintf(msg,"rcv type %d New NA echo from %d,metric is %d\n",iCode,neighbor_gpr_addr,iWaitValue);
//			GPR_message(msg,10);	
			

			
			break;
		}
		else
		{
			
		}
	
	}	


	
}
//if (iWaitValue!=-1)	
//		op_intrpt_schedule_self(op_sim_time(),INT_NA_RCV);	
	
		/*
if (iReturn!=-1)
{
	if (list_neighbor[iReturn].iContinous>=1)
		{
		op_intrpt_schedule_self(op_sim_time()+0.5,INT_NA_RCV);	
		list_neighbor[iReturn].iContinous=0;
		
		}
}

*/


	op_intrpt_schedule_self(op_sim_time(),INT_NA_RCV);	
	
if (iReturn==-1&&iFind==0)
	return -2;//full

return iReturn;

}


void mac_NA_arrival(Packet* pk_ptr)
{
//na arriv
	int source_gpr_address,destination_gpr_address,type,pk_id;
	int group_id,dest_gp_id,pkt_dest_gpr_address;
	int iCode;
	int i_Metrics,iRet;
	op_pk_nfd_get (pk_ptr,"SRC",&source_gpr_address);
	op_pk_nfd_get (pk_ptr,"SRC_GP",&group_id);
	op_pk_nfd_get (pk_ptr,"DEST",&destination_gpr_address);	
	op_pk_nfd_get (pk_ptr,"Type",&type);	
	op_pk_nfd_get(pk_ptr,"PKT_DEST",&pkt_dest_gpr_address);	
	op_pk_nfd_get(pk_ptr,"PKT_DEST_GP",&dest_gp_id);	
	op_pk_nfd_get(pk_ptr, "packet_ID",&pk_id );
	op_pk_nfd_get(pk_ptr,"Code",&iCode);
	op_pk_nfd_get(pk_ptr,"GP_Metrics",&i_Metrics);
	
	if ( (type==NA_PACKET_TYPE)&&(destination_gpr_address==my_gpr_address) )
	{
	//create an interupt: new neighbor INT_ROUTE_CHANGE
	//add a neighbor
	


		iRet=AddNeighbor(source_gpr_address,group_id,pkt_dest_gpr_address,dest_gp_id,pk_id,iCode,i_Metrics);
				if (iCode==1)
					{
						sprintf(msg,"Rcv NA for %d from nb %d,metric %d,add to list return %d\n",pk_id,
								source_gpr_address,i_Metrics, iRet);
							GPR_message(msg,10);	
							}
		
		
		op_pk_destroy (pk_ptr);
	
	
	}
	
	
}
void mac_NS_arrival(Packet* cp_pkptr)
{
	int source_gpr_address,destination_gpr_address,src_gp,pkt_dest_gpr_address,pk_id;
	Packet * pk_NA_ptr	;
	int dest_gp_id;

	int iCode;
	int size_route;
	int iWaitValue;
	int bSeen;
	Packet * pk_ptr;
	
	pk_ptr = op_pk_copy (cp_pkptr);
	
	//pk_ptr=cp_pkptr;
	
	bSeen=0;
	iWaitValue=-1;
	op_pk_nfd_get (pk_ptr,"SRC",&source_gpr_address);
	op_pk_nfd_get (pk_ptr,"SRC_GP",&src_gp);	
	op_pk_nfd_get (pk_ptr,"DEST",&destination_gpr_address);	
	op_pk_nfd_get(pk_ptr,"PKT_DEST",&pkt_dest_gpr_address);	
	op_pk_nfd_get(pk_ptr,"PKT_DEST_GP",&dest_gp_id);		
	op_pk_nfd_get (pk_ptr, "packet_ID",&pk_id );


	op_pk_nfd_get(pk_ptr,"Code",&iCode);

	size_route=	GP_route_cache[pkt_dest_gpr_address].size_route;
	

							if (iCode!=ND_REQEST)
							{

							sprintf(msg,"0000)Rcv mac %d_NS for %d from %d,echo a NA,metirc is %d,Seen %d?\n",iCode,pk_id,
								source_gpr_address,GP_route_cache[pkt_dest_gpr_address].iDistance,bSeen);
							GPR_message(msg,10);								

							}
	
if (destination_gpr_address==GPR_BROADCAST_ADDR||destination_gpr_address==my_gpr_address)
{


				switch (iCode)
					{
											
					case ND_DATA:
							if ( IsInQueue(pk_id, & my_SeenQueue  )!= -1 )
								bSeen=1;
								
											
					break;
					
					case ND_REQEST:
							if ( IsInQueue(pk_id, & q_request_list  )!= -1 )
								bSeen=1;					
						//printf("%s Rcv NS_request..bSeen=%d,time %.1f\n",my_name,bSeen,op_sim_time());
					break;
					
					case ND_REPLY:
										
							if ( IsInQueue(pk_id, & q_reply_list  )!= -1 )
								bSeen=1;
						//printf("%s Rcv NS_reply..bSeen=%d,time %.1f\n",my_name,bSeen,op_sim_time());
					break;
					
					
					}
				

							if (iCode!=ND_REQEST)
							{

							sprintf(msg,"11111)Rcv mac %d_NS for %d from %d,echo NA,Seen:%d,route %d\n",iCode,pk_id,
								source_gpr_address,bSeen,size_route);
							GPR_message(msg,10);								

							}
							
		//rule complaince:check if it will fwd pkt for the ns source
		if ( bSeen==0)
		{//never seen it recently