if (!EPIDEMIC)
																{
				//filter the ns,if not fit the route,then ignore it


				iWaitValue=IsIn_Right_Direction_NS(pkt_dest_gpr_address,src_gp,iCode);

					

				
																  }
																	else 
																		{
																		iWaitValue=1;
																		}
																	
							
																	
				
							

							if (iCode!=ND_REQEST)
							{

							sprintf(msg,"33333)Rcv mac %d_NS for %d from %d,echo a NA,metirc is %d\n",iCode,pk_id,
								source_gpr_address,iWaitValue);
						GPR_message(msg,10);								

							}
					
		
							if (EPIDEMIC)
								iWaitValue =1;							
				
				if (iWaitValue>-1)
					{

				// Create the NA echo
				pk_NA_ptr=op_pk_create_fmt("GPR_NA");
				op_pk_nfd_set(pk_NA_ptr,"Type",NA_PACKET_TYPE);
				op_pk_nfd_set(pk_NA_ptr,"Code",iCode);
		
				// set the DEST field

				op_pk_nfd_set(pk_NA_ptr,"DEST",source_gpr_address);		
				op_pk_nfd_set(pk_NA_ptr,"DEST_GP",src_gp);	
				op_pk_nfd_set(pk_NA_ptr,"SRC",my_gpr_address);		
				op_pk_nfd_set(pk_NA_ptr,"SRC_GP",my_group_id);	

				op_pk_nfd_set(pk_NA_ptr,"PKT_DEST",pkt_dest_gpr_address);	
				op_pk_nfd_set(pk_NA_ptr,"PKT_DEST_GP",dest_gp_id);					
				op_pk_nfd_set(pk_NA_ptr,"packet_ID",pk_id);	
				

				
				op_pk_nfd_set(pk_NA_ptr,"GP_Metrics",iWaitValue);

				gpr_send_to_mac(pk_NA_ptr,source_gpr_address);



				}
				
				
	}
		else //has seen it
			{
				if (iCode==1)
					{
				sprintf(msg,"mac rcv type %d NS for %d from %d,I have seen it ....................................\n",iCode,pk_id,source_gpr_address);
				//GPR_message(msg,10);
				}	
				}
			

		
		}
	

	//op_pk_destroy (pk_ptr);
	
	
}


void mac_data_arrival(Packet* pk_ptr)
{


//dencap the app data from gpr route packet

int source_gpr_address,destination_gpr_address,pk_id;
int pk_TTL;
Packet * data_pk_ptr;
int size_route,i;
int bAppear,iGP_id;
char field[10];
int iRelay,iNext_hop;




	// extract some usefull information from the data 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, "packet_ID",&pk_id );
	op_pk_nfd_get (pk_ptr, "TTL",&pk_TTL );
	op_pk_nfd_get(pk_ptr,"RELAY",&iRelay);
	op_pk_nfd_get(pk_ptr,"Next_hop",&iNext_hop);




if (my_gpr_address==0&&iRelay==40)
	printf("back flow of a data\n");

//	if (pk_id==SeenPkt[0])
		if ( IsInQueue(pk_id, & my_SeenQueue)!=-1   )
		{

	   	op_pk_destroy(pk_ptr);

	sprintf(msg,"drop a data %d from %d,has seen it\n",pk_id,source_gpr_address);
	GPR_message(msg,10);	
		
		
		return;
		}
	else 
		{
		SeenPkt[0]=pk_id;
		AddItemToQ(pk_id,& my_SeenQueue);
		if (pk_id==0)
			{

			}
		
		}
	



	// if the current node is the destination and the final relay of the packet
	if (my_gpr_address==destination_gpr_address|| destination_gpr_address==GPR_BROADCAST_ADDR )
	{
			
		//decapulate the app data
		op_pk_nfd_get (pk_ptr, "data", &data_pk_ptr);
		op_pk_send( data_pk_ptr,TO_UPPER_LAYER_STRM);
		
		op_stat_write (stat_hop_per_pkt,pk_TTL);
		op_stat_write(stat_total_data_successfully_transmitted,++total_data_successfully_transmitted);

		
		


		
	}
	else//foreward data
	{
		// insert to buffer as its own spawned data . send ns
		//if never seen it

		//set the data flag
		op_ima_obj_attr_set(my_node_id,"Conceived",1);
	
		op_pk_nfd_get (pk_ptr,"Size_Route",&size_route); 	
		if (size_route>0)
		{
		//check if data carry route info
		//route 1
		gpr_update_route(pk_ptr,source_gpr_address);
		//route 2
		gpr_update_route(pk_ptr,destination_gpr_address);
	
		//then check if i was in the group link of the data packect

					bAppear=0;


					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 not within the same group,add the group ,if within,then just fwd without midify
					if (bAppear==0)
						{
						//out of scope, need not fwd it
							sprintf(msg,"drop a data %d from %d,on the wrong way\n",pk_id,source_gpr_address);
							GPR_message(msg,10);		
						   op_pk_destroy(pk_ptr);
						   
						}
					else
						{
	
							//fwd it
	sprintf(msg,"got a data %d from %d,distance %d,histroy %d\n",pk_id,iRelay,
		GP_route_cache[destination_gpr_address].iDistance ,GP_route_cache[destination_gpr_address].iHistory);
	//GPR_message(msg,10);
								op_pk_nfd_set (pk_ptr, "TTL",pk_TTL+1 );	
								GPR_insert_buffer(pk_ptr,destination_gpr_address);
								//send a ns for this pack
								gpr_send_NS_for_route( ND_DATA);
						}

			
			
			
			
			}
		else
			{
			//no route yet
								//buffer it
	sprintf(msg,"got a data %d from %d,no route\n",pk_id,source_gpr_address);
	GPR_message(msg,10);
								op_pk_nfd_set (pk_ptr, "TTL",pk_TTL+1 );	
								GPR_insert_buffer(pk_ptr,destination_gpr_address);
								//send a ns for this pack
								gpr_send_NS_for_route( ND_DATA);
			
								}
	

		
	
		}




}

/*************************************************************/
/*                  Node BUFFER  operation                   */ 
/*************************************************************/
/* This function inserts a data packet waiting to be transmitted
/* in the node buffer (queue) corresponding to its destination
/* 		Packet* pk_ptr: a pointer to the data packet to store 
/* in the buffer
/* 		int destination_GPR_address: the gpr address of the data 
/* packet destination
/*************************************************************/
void GPR_insert_buffer(Packet* pk_ptr, int destination_GPR_address)
{
// enqueue packet in the destination subqueue
if (op_subq_pk_insert(destination_GPR_address,pk_ptr,OPC_QPOS_TAIL)!=OPC_QINS_OK)
	{
	// if there is an error the packet is destroyed
	GPR_message("Error, Can not insert packet in subqueue \n",0);
	op_pk_destroy(pk_ptr);
	}
else
	{
	



	}
}

void GPR_restore_buffer(Packet* pk_ptr, int destination_GPR_address)
{
// enqueue packet in the destination subqueue
if (op_subq_pk_insert(destination_GPR_address,pk_ptr,OPC_QPOS_HEAD)!=OPC_QINS_OK)
	{
	// if there is an error the packet is destroyed
	GPR_message("Error, Can not insert packet in subqueue \n",0);
	op_pk_destroy(pk_ptr);
	}
else
	{
	



	}
}


Packet* gpr_extract_buffer(int destination_gpr_address)
{
Packet* pk_ptr;
// if there is at list one packet in the destination suqueue 
if (op_subq_empty(destination_gpr_address)==OPC_FALSE)
	{
	// extract the first packet from this queue
		GPR_message("extract a pack",1);

	pk_ptr=op_subq_pk_remove(destination_gpr_address,OPC_QPOS_HEAD);

	}
// if there is no packet in the destination subqueue
else
	{
	// will return OPC_NIL
	pk_ptr=OPC_NIL;
	}
// return the packet pointer
return(pk_ptr);
}

int gpr_buffer_empty(int destination_gpr_address)
{
return (op_subq_empty(destination_gpr_address));
}





void GPR_message(const char* message,int iType)
{
	switch (iType)
		{
		case 27:
			if (op_prg_odb_ltrace_active ("debugfwd") == OPC_TRUE)
				{
					printf("%s: ",my_name);
					printf(message);
					printf("\n");
				}		
		break;
		case 10:
			if (op_prg_odb_ltrace_active ("rr") == OPC_TRUE)
				{
					printf("%s: ",my_name);
					printf(message);
					printf("\n");		
				}
		
			break;
		case 2:
			if (op_prg_odb_ltrace_active ("ns") == OPC_TRUE)
				{
					printf("%s: ",my_name);
					printf(message);
					printf("\n");
				}				
		break;
		
		case 3:
			if (op_prg_odb_ltrace_active ("stat") == OPC_TRUE)
				{
					printf("%s: ",my_name);
					printf(message);
					printf("\n");
				}				
		break;
		
		case 4:
			if (op_prg_odb_ltrace_active ("data") == OPC_TRUE)
				{
					printf("%s: ",my_name);
					printf(message);
					printf("\n");
					
				}				
		break;		
		
		case 5:
			if (op_prg_odb_ltrace_active ("request") == OPC_TRUE)
				{
					printf("%s,group %d: ",my_name,my_group_id);
					printf(message);
					printf("\n");
				
				}				
		break;				
		}
	
		
		

}

void gpr_forward_request(Packet* pk_ptr)
{
	
int size_route;
char field[10];
int  bAppear;
int  iGP_id,i;
int destination_gpr_address,pk_id;
sPkBuff iItem;
int iNext_hop,iTTL;
int iPos;

bAppear=0;
iPos=-1;

// read the Size_Route and Seg_Left fields from the request packet
	op_pk_nfd_get (pk_ptr,"Size_Route",&size_route); 
	op_pk_nfd_get(pk_ptr,"DEST",&destination_gpr_address);
	op_pk_nfd_get(pk_ptr,"Seq_number",&pk_id);
	op_pk_nfd_get(pk_ptr,"Next_hop",&iNext_hop);
	op_pk_nfd_get(pk_ptr,"TTL",&iTTL);

// the current node insert its own gorup id to the group link

//check if it appear in the sequence of groups
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;
				iPos=i;
				break;
			}
	
	}

//if not within .the same group,add the group ,if within,then just fwd without midify
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);		
			}



	 }
else
	{
	
	if (iPos<size_route-1)
		return;
	}


	
	//queue the request
	iItem.pkt_id=pk_id;
	iItem.pkt=pk_ptr;
	iItem.iStale=0;
   if ( (iPos=Pkt_Fulsh_Depul_Queue_by_dest(iItem,destination_gpr_address,&q_pkt_req_list) )!=-1 )
		{
		q_pkt_req_list.queue[iPos]=iItem;
		}
	else
		{
		
			Pkt_AddItemToQ(iItem,&q_pkt_req_list);
		}
	
	
	//send ns for the request
	if (iNext_hop==my_gpr_address)
		gpr_send_NS_for_route(ND_REQEST);	
	
	
	

}

void gpr_handle_request(Packet * pk_ptr)
{
int source_gpr_address;
int destination_gpr_address;
int size_route;
int iSequ;
int iPos,iTimeStamp;
Packet * cp_pkptr;
int iNext_hop,iTTL;


// 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,"Seq_number",&iSequ);
op_pk_nfd_get(pk_ptr,"Next_hop",&iNext_hop);
op_pk_nfd_get(pk_ptr,"TTL",&iTTL);

	cp_pkptr = op_pk_copy (pk_ptr);

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

	



	if (my_gpr_address==destination_gpr_address)
		{
			//send a reply

			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

			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;
		
					}
					
			gpr_send_reply(cp_pkptr);
				
		
		}
	else
		{
		

				
					
			//gpr_update_route(pk_ptr,source_gpr_address);	



			size_route=GP_route_cache[destination_gpr_address].size_route;
			iTimeStamp=GP_route_cache[destination_gpr_address].iTimeStamp;
			if (size_route!=0)//has route to the dest then reply proxyly
				{
				//if (op_sim_time()-iTimeStamp<VAL_ROUTE_STALE_TIME)
					gpr_send_reply_proxy(cp_pkptr);
				
				}
			else
				{
					//lable the gp in the request and fwd the request
			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 request %d,current TTL(%d) to %d \n",iSequ,GP_route_cache[source_gpr_address].iDistance,source_gpr_address);
			GPR_message(msg,10);
											
					gpr_forward_request(cp_pkptr);

					
				}
		
		}
	
	
	
	
	
}

void gpr_transmit_request(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;