main_addr_neigh_table.c

OLSR Implementation for XORP

/*
 * Copyright (c) 2004 Ying Ge, Communication Research Center Canada.
 *
 * Copyright (c) 2002, 2003 Maoyu Wang, Communication Research Center Canada.
 *
 * By Ying Ge:
 * 1. Change the OLSR packet format and message processing procedure based 
 *    on the OLSR RFC.
 * 2. Add support of multiple interfaces to OLSR, including MID message 
 *    creating and processing procedure as specified in the OLSR RFC.
 * 3. Add QoS Support to OLSR
 *
 * By Maoyu Wang:
 * 1. Ported OLSR from IPv4 to IPv6.
 * 2. Added the Host and Network Association (HNA) functionality into OLSR.
 * 3. Added the default gateway functionality into OLSR by extending the HNA 
 *    message usage. The default gateway functionality supported the mobility
 *	  by cooperating with Mobile IPv6 for a mobile node as well as supported 
 * 	  Internet access for MANET nodes. 
 *
 * DISTRIBUTED WITH NO WARRANTY, EXPRESS OR IMPLIED.
 * See the GNU Library General Public License (file COPYING in the distribution)
 * for conditions of use and redistribution
 */
/**************** the file is added by Y.Ge **************/

/*
 * Routing table management daemon.
 */

char main_addr_neigh_table_rcsid[] = 
  "$Id: main_addr_neigh_table.c,v 1.2 2000/12/06 10:36:11 prima Exp $";

#include "defs.h"


struct main_addr_neighhash             mainaddrneightable[HASHSIZE];

/*------------------------------------------------------------------------*/
void
olsr_delete_iface_neighbor_pointer(struct main_addr_neigh_entry *main_addr_neigh, struct olsr_ip_addr *address)
{
	/*
	  This procedure deletes the pointer to this addr from the list contained
	  in the main_addr_neighbor entry;
	*/ 
	struct iface_addr_list_entry	*list_of_iface;
	struct iface_addr_list_entry	*list_of_iface_tmp;

	list_of_iface = main_addr_neigh->neigh_iface_list;
	main_addr_neigh->neigh_iface_list = NULL;

	while (list_of_iface)
	{
		if (0 == memcmp(&list_of_iface->neighbor_iface->neighbor_addr, address, sizeof (struct olsr_ip_addr)))
		{
			list_of_iface_tmp = list_of_iface;
			list_of_iface = list_of_iface->iface_addr_next;
			free (list_of_iface_tmp);
		}
		else
		{
			list_of_iface_tmp = list_of_iface;
			list_of_iface = list_of_iface->iface_addr_next;
			list_of_iface_tmp ->iface_addr_next = main_addr_neigh->neigh_iface_list;
			main_addr_neigh->neigh_iface_list = list_of_iface_tmp;
		}
	}
} 
void
olsr_delete_main_addr_neigh_table(struct main_addr_neigh_entry *main_addr_neigh)
{
	/*
	 * delete main_addr_neigh_table results in delete all its related interfce links!
	 */

	struct iface_addr_list_entry	*list_of_iface, *list_of_iface_tmp;
	struct neighbor_entry       	*neighbor_iface_entry;

	list_of_iface = main_addr_neigh->neigh_iface_list;

	while (list_of_iface != NULL)
	{
		neighbor_iface_entry = list_of_iface->neighbor_iface;
		olsr_delete_main_neighbor_pointer(neighbor_iface_entry);
		main_addr_neigh->neigh_iface_list = list_of_iface->iface_addr_next;
		free (list_of_iface);
		list_of_iface = main_addr_neigh->neigh_iface_list;
	}
		
	olsr_remque((struct olsr_qelem *)main_addr_neigh);
	free((void *)main_addr_neigh);
  
}
/*------------------------------------------------------------------------*/
void
olsr_release_main_addr_neigh_table()
{ 
	struct main_addr_neigh_entry	*main_addr_neigh;
	struct main_addr_neigh_entry	*main_addr_neigh_tmp;
	struct main_addr_neighhash 	*main_addr_neighhash;
	olsr_u8_t        	index;

	for(index=0;index<HASHSIZE;index++)
	{
		main_addr_neighhash=&mainaddrneightable[index];

		main_addr_neigh=main_addr_neighhash->mainaddrneigh_forw;
		while(main_addr_neigh!=(struct main_addr_neigh_entry *)main_addr_neighhash)
		{
			main_addr_neigh_tmp=main_addr_neigh;
			main_addr_neigh = main_addr_neigh->main_addr_neigh_forw;
			olsr_delete_main_addr_neigh_table(main_addr_neigh_tmp);
		}
	}
}
/*------------------------------------------------------------------------*/
void
olsr_clear_main_addr_neigh_table_mpr_status()
{ 
	struct main_addr_neigh_entry	*main_addr_neigh;
	struct main_addr_neigh_entry	*main_addr_neigh_tmp;
	struct main_addr_neighhash 	*main_addr_neighhash;
	olsr_u8_t        	index;

	for(index=0;index<HASHSIZE;index++)
	{
		main_addr_neighhash=&mainaddrneightable[index];
		for(main_addr_neigh=main_addr_neighhash->mainaddrneigh_forw;main_addr_neigh!=(struct main_addr_neigh_entry *)main_addr_neighhash;main_addr_neigh=main_addr_neigh->main_addr_neigh_forw)
		{
			if (main_addr_neigh->main_addr_neigh_status == MPR_NEIGH)
				main_addr_neigh->main_addr_neigh_status = SYM_NEIGH;
		}
	}
}
/*------------------------------------------------------------------------*/
void
olsr_clear_main_addr_neigh_table_covered()
{ 
	struct main_addr_neigh_entry	*main_addr_neigh;
	struct main_addr_neigh_entry	*main_addr_neigh_tmp;
	struct main_addr_neighhash 	*main_addr_neighhash;
	olsr_u8_t        	index;

	for(index=0;index<HASHSIZE;index++)
	{
		main_addr_neighhash=&mainaddrneightable[index];
		for(main_addr_neigh=main_addr_neighhash->mainaddrneigh_forw;main_addr_neigh!=(struct main_addr_neigh_entry *)main_addr_neighhash;main_addr_neigh=main_addr_neigh->main_addr_neigh_forw)
		{
			main_addr_neigh->covered_in_hello = 0;
		}
	}
}
/*------------------------------------------------------------------------*/
void
olsr_clear_main_addr_neigh_table_covered_in_routing()
{ 
	struct main_addr_neigh_entry	*main_addr_neigh;
	struct main_addr_neigh_entry	*main_addr_neigh_tmp;
	struct main_addr_neighhash 	*main_addr_neighhash;
	olsr_u8_t        	index;

	for(index=0;index<HASHSIZE;index++)
	{
		main_addr_neighhash=&mainaddrneightable[index];
		for(main_addr_neigh=main_addr_neighhash->mainaddrneigh_forw;main_addr_neigh!=(struct main_addr_neigh_entry *)main_addr_neighhash;main_addr_neigh=main_addr_neigh->main_addr_neigh_forw)
		{
			main_addr_neigh->covered_in_routing = 0;
		}
	}
}
/*------------------------------------------------------------------------*/
struct main_addr_neigh_entry
*olsr_lookup_main_addr_neigh_table(struct olsr_ip_addr *n_main_addr)
{
	struct main_addr_neigh_entry	*main_addr_neigh;
	struct main_addr_neighhash  	*main_addr_neighhash;
	olsr_u32_t       	hash;
  
	olsr_hashing(n_main_addr,&hash);
	main_addr_neighhash=&mainaddrneightable[hash & HASHMASK];
  
	for(main_addr_neigh=main_addr_neighhash->mainaddrneigh_forw; main_addr_neigh!=(struct main_addr_neigh_entry *)main_addr_neighhash;main_addr_neigh=main_addr_neigh->main_addr_neigh_forw)
	{
		if(main_addr_neigh->main_addr_neigh_hash!=hash)
			continue;
		if (0==memcmp(&main_addr_neigh->main_addr_neigh_addr,n_main_addr,sizeof(struct olsr_ip_addr)))
			return(main_addr_neigh);
    }
	return(NULL);
}
/*------------------------------------------------------------------------*/
void
olsr_insert_main_addr_neigh_table(struct main_addr_neigh_entry *main_addr_neigh)
{

	olsr_u32_t  hash;
	struct main_addr_neighhash  *main_addr_neighhash;
  
	olsr_hashing(&main_addr_neigh->main_addr_neigh_addr,&hash);
	main_addr_neigh->main_addr_neigh_hash=hash;
	main_addr_neighhash=&mainaddrneightable[hash & HASHMASK];
	olsr_insque((struct olsr_qelem *)main_addr_neigh, (struct olsr_qelem *)main_addr_neighhash); 
}

/*------------------------------------------------------------------------*/
struct iface_addr_list_entry
*olsr_lookup_iface_neighbor(struct main_addr_neigh_entry *main_neighbor,struct olsr_ip_addr *iface_address)
{
	struct iface_addr_list_entry	*iface_list;

	/*if (debug_level>3)
	{
		printf ("--------- in olsr lookup iface neighbor ----------\n");
		printf ("the input value is: \n");
		printf ("---main addr neighbor: %s\n", convert_address_to_string(&main_neighbor->main_addr_neigh_addr));
		printf ("   with iface addrress:\n");
		iface_list = main_neighbor->neigh_iface_list;

		while (iface_list!=NULL)
		{
			printf ("%s   ", convert_address_to_string(&iface_list->neighbor_iface->neighbor_addr));
			iface_list = iface_list->iface_addr_next;
		}
		printf ("\n---the input iface address: %s\n", convert_address_to_string (iface_address));
	}*/	
	
	iface_list = main_neighbor->neigh_iface_list;

	while(iface_list !=NULL)
	{
		if (0==memcmp (&iface_list->neighbor_iface->neighbor_addr, iface_address, sizeof (struct olsr_ip_addr)))
			return (iface_list);
		
		iface_list = iface_list->iface_addr_next;
	}
	return (NULL);
}
/*------------------------------------------------------------------------*/
void
olsr_print_main_addr_neigh_table()
{
	olsr_u8_t                	index;
	struct main_addr_neigh_entry	*main_neighbor;
	struct main_addr_neighhash  	*hash_main_neighbor;

	struct iface_addr_list_entry 	*iface_list = NULL;
	char str[46];

	printf ("\n\nTHE MAIN NEIGHBOR TABLE:\n");
	
	for (index=0; index<HASHSIZE; index++)
	{
		hash_main_neighbor = &mainaddrneightable[index];
		for(main_neighbor = hash_main_neighbor->mainaddrneigh_forw; main_neighbor!=(struct main_addr_neigh_entry *)hash_main_neighbor; main_neighbor = main_neighbor->main_addr_neigh_forw)
		{
			printf (".....NEIGHBOR MAIN ADDRESS\n");
			printf ("     address:%s, willingness: %d, neighbor_status: %d\n", 
				inet_ntop(AF_INET6, (&main_neighbor->main_addr_neigh_addr),str, 46),
				main_neighbor->main_addr_neigh_willingness, main_neighbor->main_addr_neigh_status);
			printf ("-------------------------\n");

			iface_list = main_neighbor->neigh_iface_list;
			printf ("its iface list:\n");
			if (iface_list == NULL)
			{
				printf (" XXXXXXXXXXXXXXXXXXX something wrong with  the main_address neighbor table XXXXXXXXXX\n");
				exit(1);
			}
			while (iface_list!=NULL)
			{
				printf ("%s\n", inet_ntop(AF_INET6, &(iface_list->neighbor_iface->neighbor_addr), str, 46));
				iface_list = iface_list->iface_addr_next;
			}
			printf ("-------------------------\n");
		}
	}
}
/*------------------------------------------------------------------------*/
void
olsr_print_trace_main_addr_neigh_table()
{
	olsr_u8_t                	index;
	struct main_addr_neigh_entry	*main_neighbor;
	struct main_addr_neighhash  	*hash_main_neighbor;

	struct iface_addr_list_entry 	*iface_list = NULL;
	char str[46];

	fprintf (y_file,"\n\nTHE MAIN NEIGHBOR TABLE:\n");
	
	for (index=0; index<HASHSIZE; index++)
	{
		hash_main_neighbor = &mainaddrneightable[index];
		for(main_neighbor = hash_main_neighbor->mainaddrneigh_forw; main_neighbor!=(struct main_addr_neigh_entry *)hash_main_neighbor; main_neighbor = main_neighbor->main_addr_neigh_forw)
		{
			fprintf (y_file,".....NEIGHBOR MAIN ADDRESS\n");
			fprintf (y_file,"     address:%s, willingness: %d, neighbor_status: %d\n", 
				inet_ntop(AF_INET6, (&main_neighbor->main_addr_neigh_addr),str, 46),
				main_neighbor->main_addr_neigh_willingness, main_neighbor->main_addr_neigh_status);
			fprintf (y_file,"-------------------------\n");

			iface_list = main_neighbor->neigh_iface_list;
			fprintf (y_file,"its iface list:\n");
			if (iface_list == NULL)
			{
				fprintf (y_file," XXXXXXXXXXXXXXXXXXX something wrong with  the main_address neighbor table XXXXXXXXXX\n");
				exit(1);
			}
			while (iface_list!=NULL)
			{
				fprintf (y_file,"%s\n", inet_ntop(AF_INET6, &(iface_list->neighbor_iface->neighbor_addr), str, 46));
				iface_list = iface_list->iface_addr_next;
			}
			fprintf (y_file,"-------------------------\n");
		}
	}
}
/*------------------------------------------------------------------------*/
void
olsr_update_main_addr_neigh_status(struct main_addr_neigh_entry *main_neighbor)
{	
	struct iface_addr_list_entry 	*iface_list = NULL;
	int	have_sym_link = 0;

	/*printf ("------------ in update main address neighbor status! ----------------\n");
	printf ("currently, neighbor status is: %d\n", main_neighbor->main_addr_neigh_status);*/
		
	iface_list = main_neighbor->neigh_iface_list;

	while (iface_list != NULL)
	{
		if (iface_list->neighbor_iface->neighbor_status == SYM_LINK)
		{
			have_sym_link = 1;
		}
		iface_list = iface_list->iface_addr_next;
	}
		
	if (have_sym_link)
	{
		if (main_neighbor->main_addr_neigh_status == MPR_NEIGH)
			main_neighbor->main_addr_neigh_status = MPR_NEIGH; //neighbor status unchanged
		else
			main_neighbor->main_addr_neigh_status = SYM_NEIGH;			
	}
	else
		main_neighbor->main_addr_neigh_status = NOT_NEIGH;

		
	//printf ("after updating, neighbor status is: %d\n", main_neighbor->main_addr_neigh_status);
	
}
/*------------------------------------------------------------------------*/
void
olsr_update_main_addr_neigh_table_status ()
{
	olsr_u8_t                	index;
	struct main_addr_neigh_entry	*main_neighbor;
	struct main_addr_neighhash  	*hash_main_neighbor;

	struct iface_addr_list_entry 	*iface_list = NULL;
	char str[46];
	
	for (index=0; index<HASHSIZE; index++)
	{
		hash_main_neighbor = &mainaddrneightable[index];
		for(main_neighbor = hash_main_neighbor->mainaddrneigh_forw; main_neighbor!=(struct main_addr_neigh_entry *)hash_main_neighbor; main_neighbor = main_neighbor->main_addr_neigh_forw)
		{
			olsr_update_main_addr_neigh_status(main_neighbor);
			
		}
	}
}