aodv_request_table.ex.c

opnet11.5 manet dsr和aodv协议

/* aodv_request_table.ex.c */
/* C file for AODV Request Table APIs */


/****************************************/
/*		Copyright (c) 1987-2005			*/
/*		by OPNET Technologies, Inc.		*/
/*		(A Delaware Corporation)		*/
/*	7255 Woodmont Av., Suite 250  		*/
/*     Bethesda, MD 20814, U.S.A.       */
/*			All Rights Reserved.		*/
/****************************************/

/***** Includes *****/
#include <opnet.h>
#include <aodv.h>
#include <aodv_ptypes.h>
#include <ip_addr_v4.h>

/***** Prototypes *****/
static AodvT_Orig_Request_Entry*	aodv_request_table_orig_entry_mem_alloc (void);
static AodvT_Forward_Request_Entry*	aodv_request_table_forward_entry_mem_alloc (void);
extern void							aodv_rte_rreq_timer_expiry_handle (void*, int);
extern void							aodv_rte_forward_request_delete (void* addr_str, int req_id);

AodvT_Request_Table*
aodv_request_table_create (double expiry_time, int max_retries)
	{
	AodvT_Request_Table*		req_table_ptr;
	
	/** Allocates and initializes the request table	**/
	FIN (aodv_request_table_create (<args>));
	
	req_table_ptr = (AodvT_Request_Table*) op_prg_mem_alloc (sizeof (AodvT_Request_Table));
	req_table_ptr->orig_request_table = (PrgT_String_Hash_Table*) prg_string_hash_table_create (10, 10);
	req_table_ptr->forward_request_table = (PrgT_String_Hash_Table*) prg_string_hash_table_create (10, 10);
	req_table_ptr->forward_request_expiry_time = expiry_time;
	req_table_ptr->max_rreq_retries = max_retries;
	
	FRET (req_table_ptr);
	}


void
aodv_request_table_orig_rreq_insert (AodvT_Request_Table* req_table_ptr, int req_id, InetT_Address dest_address, 
										int ttl_value, double request_expiry_time, int rreq_retry)
	{
	AodvT_Orig_Request_Entry*	req_entry_ptr;
	char						temp_str [8];
	void*						old_contents_ptr;
	int*						req_id_ptr;
	
	/** Inserts a new request ID into the originating request table	**/
	FIN (aodv_request_table_orig_rreq_insert (<args>));
	
	/* Create the request ID string	*/
	sprintf (temp_str, "%d", req_id);
	
	/* Create an entry for this new request	*/
	req_entry_ptr = aodv_request_table_orig_entry_mem_alloc ();
	req_entry_ptr->target_address = inet_address_copy (dest_address);
	req_entry_ptr->request_id = req_id;
	req_entry_ptr->current_ttl_value = ttl_value;
	req_entry_ptr->insert_time = op_sim_time ();
	req_entry_ptr->current_request_expiry_time = request_expiry_time;
	req_entry_ptr->num_retries = rreq_retry;
	
	/* Allocate memory for the request ID	*/
	req_id_ptr = (int*) op_prg_mem_alloc (sizeof (int));
	*req_id_ptr = req_id;
	
	req_entry_ptr->rreq_expiry_evhandle = 
		op_intrpt_schedule_call (req_entry_ptr->insert_time + req_entry_ptr->current_request_expiry_time, 
								AODVC_ROUTE_REQUEST_EXPIRY, aodv_rte_rreq_timer_expiry_handle, req_id_ptr);
			
	/* Insert this new request into the request table	*/
	prg_string_hash_table_item_insert (req_table_ptr->orig_request_table, temp_str, 
											req_entry_ptr, &old_contents_ptr);
	
	FOUT;
	}


void
aodv_request_table_forward_rreq_insert (AodvT_Request_Table* req_table_ptr, int req_id, InetT_Address originator_addr)
	{
	List*								req_entry_lptr;
	AodvT_Forward_Request_Entry*		req_entry_ptr;
	char								orig_addr_str [INETC_ADDR_STR_LEN];
	void*								old_contents_ptr;
	char*		temp_str;
	
	/** Inserts a new route request into the request table	**/
	/** for nodes forwarding the route request packet		**/
	FIN (aodv_request_table_forward_rreq_insert (<args>));
		
	/* Create the originator address string	*/
	inet_address_print (orig_addr_str, originator_addr);
	
	/* Check if there exists an entry for this address	*/
	req_entry_lptr = (List*) prg_string_hash_table_item_get (req_table_ptr->forward_request_table, orig_addr_str);
	
	if (req_entry_lptr == OPC_NIL)
		{
		/* No entry exists for this destination	*/
		/* Create a list and insert 			*/
		req_entry_lptr = op_prg_list_create ();
		prg_string_hash_table_item_insert (req_table_ptr->forward_request_table, orig_addr_str, 
											req_entry_lptr, &old_contents_ptr);
		}
	
	/* Create an entry for this new request	*/
	req_entry_ptr = aodv_request_table_forward_entry_mem_alloc ();
	req_entry_ptr->request_id = req_id;
	req_entry_ptr->insert_time = op_sim_time ();
	
	/* Insert this new request into the request table	*/
	op_prg_list_insert (req_entry_lptr, req_entry_ptr, OPC_LISTPOS_TAIL);
	
	temp_str = (char*) op_prg_mem_alloc (sizeof (char) * (strlen (orig_addr_str) + 1));
	strcpy (temp_str, orig_addr_str);
	op_intrpt_schedule_call (op_sim_time () + req_table_ptr->forward_request_expiry_time, req_id,
		aodv_rte_forward_request_delete, temp_str);
	
	FOUT;
	}

Boolean
aodv_route_request_forward_entry_exists (AodvT_Request_Table* req_table_ptr, int req_id,
	InetT_Address originator_addr)
    {
    AodvT_Forward_Request_Entry*    req_entry_ptr;
    List*                           req_entry_lptr;
    int                             size, count;
    char                            orig_addr_str [INETC_ADDR_STR_LEN];
   
    /** Checks if a specific request ID exists  **/
    /** in the route request table              **/
    FIN (aodv_route_request_forward_entry_exists (<args>));
   
	/* Create the originator address string */
    inet_address_print (orig_addr_str, originator_addr);

    /* Check if there exists an entry for this address  */
    req_entry_lptr = (List*) prg_string_hash_table_item_get (req_table_ptr->forward_request_table,
		orig_addr_str);

    /* Error Check  */
    if ((req_entry_lptr == OPC_NIL))
        FRET (OPC_FALSE);

    size = op_prg_list_size (req_entry_lptr);

    for (count = 0; count < size; count++)
        {
        req_entry_ptr = (AodvT_Forward_Request_Entry*) op_prg_list_access (req_entry_lptr, count);

        if (req_entry_ptr->request_id == req_id)
            FRET (OPC_TRUE);
        }
			
	if (prg_list_size (req_entry_lptr) == 0)
		{
		prg_string_hash_table_item_remove (req_table_ptr->forward_request_table, orig_addr_str);
		
		prg_mem_free (req_entry_lptr);
		}
		

    FRET (OPC_FALSE);
    }


Boolean
aodv_request_table_orig_rreq_exists (AodvT_Request_Table* req_table_ptr, InetT_Address dest_address)
	{
	AodvT_Orig_Request_Entry*	req_entry_ptr;
	List*						keys_lptr;
	char*						key_ptr;
	int							num_keys, count;
	Boolean						retval = OPC_FALSE;
	
	/** Checks if an entry exists in the originating	**/
	/** table with the specified target address			**/
	FIN (aodv_request_table_orig_rreq_exists (<args>));
	
	/* Get the keys	*/
	keys_lptr = (List*) prg_string_hash_table_keys_get (req_table_ptr->orig_request_table);
	num_keys = op_prg_list_size (keys_lptr);
	
	for (count = 0; count < num_keys; count++)
		{
		/* Get each key	*/
		key_ptr = (char*) op_prg_list_access (keys_lptr, count);
		
		req_entry_ptr = (AodvT_Orig_Request_Entry*) prg_string_hash_table_item_get (req_table_ptr->orig_request_table, key_ptr);
		
		if (inet_address_equal (req_entry_ptr->target_address, dest_address))
			{
			/* An entry exists for this target address	**/
			retval = OPC_TRUE;
			break;
			}
		}
	
	/* Free the keys	*/
	op_prg_list_free (keys_lptr);
	op_prg_mem_free (keys_lptr);
	
	FRET (retval);
	}


AodvT_Orig_Request_Entry*
aodv_route_request_orig_entry_get (AodvT_Request_Table* req_table_ptr, int req_id, Boolean remove)
	{
	AodvT_Orig_Request_Entry*	req_entry_ptr = OPC_NIL;
	char						temp_str [8];
	
	/** Checks if a specific request ID exists	**/
	/** in the route request table				**/
	FIN (aodv_route_request_orig_entry_get (<args>));
	
	/* Create the originator address string	*/
	sprintf (temp_str, "%d", req_id);
	
	if (remove)
		req_entry_ptr = (AodvT_Orig_Request_Entry*) prg_string_hash_table_item_remove (req_table_ptr->orig_request_table, temp_str);
	else
		req_entry_ptr = (AodvT_Orig_Request_Entry*) prg_string_hash_table_item_get (req_table_ptr->orig_request_table, temp_str);
	
	FRET (req_entry_ptr);
	}


void
aodv_route_request_orig_entry_delete (AodvT_Request_Table* req_table_ptr, InetT_Address dest_addr)
	{
	AodvT_Orig_Request_Entry*	req_entry_ptr;
	int							num_keys, count;
	char*						key_ptr;
	List*						keys_lptr;
	int*						req_id_ptr;
		
	/** Deletes all route requests that have the target address	**/
	FIN (aodv_route_request_orig_entry_delete (<args>));
	
	/* Get the keys	*/
	keys_lptr = prg_string_hash_table_keys_get (req_table_ptr->orig_request_table);
	
	num_keys = op_prg_list_size (keys_lptr);
	
	for (count = 0; count < num_keys; count++)
		{
		/* Get each key	*/
		key_ptr = (char*) op_prg_list_access (keys_lptr, count);
		
		/* Check if there exists an entry for this address	*/
		req_entry_ptr = (AodvT_Orig_Request_Entry*) prg_string_hash_table_item_get (req_table_ptr->orig_request_table, key_ptr);
	
		if (req_entry_ptr == OPC_NIL)
			continue;
		
		if (inet_address_equal (req_entry_ptr->target_address, dest_addr))
			{
			req_entry_ptr = (AodvT_Orig_Request_Entry*) prg_string_hash_table_item_remove (req_table_ptr->orig_request_table, key_ptr);
		
			/* Cancel the previously scheduled event	*/
			if (op_ev_valid (req_entry_ptr->rreq_expiry_evhandle) 
				&& op_ev_pending (req_entry_ptr->rreq_expiry_evhandle))
				{
				req_id_ptr = (int *) op_ev_state (req_entry_ptr->rreq_expiry_evhandle);
				op_prg_mem_free (req_id_ptr);
				op_ev_cancel (req_entry_ptr->rreq_expiry_evhandle);
				}
	
			/* Free the request entry	*/
			aodv_request_table_orig_entry_mem_free (req_entry_ptr);
			}
		}
	
	/* Free the keys	*/
	op_prg_list_free (keys_lptr);
	op_prg_mem_free (keys_lptr);
	
	FOUT;
	}


void
aodv_request_table_orig_entry_mem_free (AodvT_Orig_Request_Entry* request_entry_ptr)
	{
	/** Frees the memory associated with the	**/
	/** request table entry						**/
	FIN (aodv_request_table_orig_entry_mem_free (<args>));
	
	/* Destroy the IP address	*/
	inet_address_destroy (request_entry_ptr->target_address);
	
	/* Cancel the timer if shceduled	*/
	if (op_ev_valid (request_entry_ptr->rreq_expiry_evhandle) && op_ev_pending (request_entry_ptr->rreq_expiry_evhandle))
		op_ev_cancel (request_entry_ptr->rreq_expiry_evhandle);
	
	/* Free the memory	*/
	op_prg_mem_free (request_entry_ptr);
	
	FOUT;
	}


/*** Internally callable functions	***/

static AodvT_Orig_Request_Entry*
aodv_request_table_orig_entry_mem_alloc (void)
	{
	static Pmohandle			orig_request_entry_pmh;
	AodvT_Orig_Request_Entry*	request_entry_ptr = OPC_NIL;
	static Boolean				orig_request_entry_pmh_defined = OPC_FALSE;
	
	/** Allocates pooled memory for every request	**/
	/** entry in the route request table			**/
	FIN (aodv_request_table_orig_entry_mem_alloc (void));
	
	if (orig_request_entry_pmh_defined == OPC_FALSE)
		{
		/* Define the pool memory handle for route table entry	*/
		orig_request_entry_pmh = op_prg_pmo_define ("Originating Route Request Entry", sizeof (AodvT_Orig_Request_Entry), 32);
		orig_request_entry_pmh_defined = OPC_TRUE;
		}
	
	/* Allocate the route table entry from the pooled memory	*/
	request_entry_ptr = (AodvT_Orig_Request_Entry*) op_prg_pmo_alloc (orig_request_entry_pmh);
	
	FRET (request_entry_ptr);
	}


static AodvT_Forward_Request_Entry*
aodv_request_table_forward_entry_mem_alloc (void)
	{
	static Pmohandle				fwd_request_entry_pmh;
	AodvT_Forward_Request_Entry*	request_entry_ptr = OPC_NIL;
	static Boolean					fwd_request_entry_pmh_defined = OPC_FALSE;
	
	/** Allocates pooled memory for every request	**/
	/** entry in the route request table			**/
	FIN (aodv_request_table_forward_entry_mem_alloc (void));
	
	if (fwd_request_entry_pmh_defined == OPC_FALSE)
		{
		/* Define the pool memory handle for route table entry	*/
		fwd_request_entry_pmh = op_prg_pmo_define ("Forwarding Route Request Entry", sizeof (AodvT_Forward_Request_Entry), 32);
		fwd_request_entry_pmh_defined = OPC_TRUE;
		}
	
	/* Allocate the route table entry from the pooled memory	*/
	request_entry_ptr = (AodvT_Forward_Request_Entry*) op_prg_pmo_alloc (fwd_request_entry_pmh);
	
	FRET (request_entry_ptr);
	}