src/two_hop_neighbor_table.c

   1 /*
   2  * OLSR ad-hoc routing table management protocol
   3  * Copyright (C) 2003 Andreas Tønnesen (andreto@ifi.uio.no)
   4  *
   5  * This file is part of olsr.org.
   6  *
   7  * olsr.org is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * olsr.org is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with olsr.org; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23
  24
  25 #include "defs.h"
  26 #include "two_hop_neighbor_table.h"
  27 #include "mid_set.h"
  28 #include "mpr.h"
  29
  30
  31 /**
  32  *Initialize 2 hop neighbor table
  33  */
  34 int
  35 olsr_init_two_hop_table()
  36 {
  37   int index;
  38
  39   for(index=0;index<HASHSIZE;index++)
  40     {
  41       two_hop_neighbortable[index].next = &two_hop_neighbortable[index];
  42       two_hop_neighbortable[index].prev = &two_hop_neighbortable[index];
  43     }
  44   return 1;
  45 }
  46
  47
  48 /**
  49  *Remove a one hop neighbor from a two hop neighbors
  50  *one hop list.
  51  *
  52  *@param two_hop_entry the two hop neighbor to remove the
  53  *one hop neighbor from
  54  *@param address the address of the one hop neighbor to remove
  55  *
  56  *@return nada
  57  */
  58
  59 void
  60 olsr_delete_neighbor_pointer(struct neighbor_2_entry *two_hop_entry, union olsr_ip_addr *address)
  61 {
  62  struct neighbor_list_entry *entry, *entry_to_delete;
  63
  64  entry = two_hop_entry->neighbor_2_nblist.next;
  65
  66
  67  while(entry != &two_hop_entry->neighbor_2_nblist)
  68    {
  69      if(COMP_IP(&entry->neighbor->neighbor_main_addr, address))
  70        {
  71          entry_to_delete = entry;
  72          entry = entry->next;
  73
  74          /* dequeue */
  75          DEQUEUE_ELEM(entry_to_delete);
  76
  77          free(entry_to_delete);
  78        }
  79      else
  80        entry = entry->next;
  81
  82    }
  83 }
  84
  85
  86
  87 /**
  88  *Delete an entry from the two hop neighbor table.
  89  *
  90  *@param two_hop_neighbor the two hop neighbor to delete.
  91  *
  92  *@return nada
  93  */
  94 void
  95 olsr_delete_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
  96 {
  97   struct neighbor_list_entry *one_hop_list, *entry_to_delete;
  98   struct neighbor_entry      *one_hop_entry;
  99
 100   one_hop_list = two_hop_neighbor->neighbor_2_nblist.next;
 101
 102   /* Delete one hop links */
 103   while(one_hop_list != &two_hop_neighbor->neighbor_2_nblist)
 104     {
 105       one_hop_entry = one_hop_list->neighbor;
 106       olsr_delete_neighbor_2_pointer(one_hop_entry, &two_hop_neighbor->neighbor_2_addr);
 107
 108       entry_to_delete = one_hop_list;
 109
 110       one_hop_list = one_hop_list->next;
 111
 112       /* no need to dequeue */
 113
 114       free(entry_to_delete);
 115     }
 116
 117   /* dequeue */
 118   DEQUEUE_ELEM(two_hop_neighbor);
 119
 120   free(two_hop_neighbor);
 121 }
 122
 123
 124
 125 /**
 126  *Insert a new entry to the two hop neighbor table.
 127  *
 128  *@param two_hop_neighbor the entry to insert
 129  *
 130  *@return nada
 131  */
 132 void
 133 olsr_insert_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
 134 {
 135   olsr_u32_t              hash;
 136
 137   //printf("Adding 2 hop neighbor %s\n", olsr_ip_to_string(&two_hop_neighbor->neighbor_2_addr));
 138
 139   hash = olsr_hashing(&two_hop_neighbor->neighbor_2_addr);
 140
 141   /* Queue */
 142   QUEUE_ELEM(two_hop_neighbortable[hash], two_hop_neighbor);
 143 }
 144
 145
 146 /**
 147  *Look up an entry in the two hop neighbor table.
 148  *
 149  *@param dest the IP address of the entry to find
 150  *
 151  *@return a pointer to a neighbor_2_entry struct
 152  *representing the two hop neighbor
 153  */
 154 struct neighbor_2_entry *
 155 olsr_lookup_two_hop_neighbor_table(union olsr_ip_addr *dest)
 156 {
 157
 158   struct neighbor_2_entry  *neighbor_2;
 159   olsr_u32_t               hash;
 160   struct addresses *adr;
 161
 162   //printf("LOOKING FOR %s\n", olsr_ip_to_string(dest));
 163   hash = olsr_hashing(dest);
 164
 165
 166   for(neighbor_2 = two_hop_neighbortable[hash].next;
 167       neighbor_2 != &two_hop_neighbortable[hash];
 168       neighbor_2 = neighbor_2->next)
 169     {
 170       //printf("Checking %s\n", olsr_ip_to_string(dest));
 171       if (COMP_IP(&neighbor_2->neighbor_2_addr, dest))
 172         return neighbor_2;
 173
 174       adr = mid_lookup_aliases(&neighbor_2->neighbor_2_addr);
 175
 176       while(adr)
 177         {
 178           if(COMP_IP(&adr->address, dest))
 179             return neighbor_2;
 180           adr = adr->next;
 181         }
 182     }
 183
 184   return NULL;
 185 }
 186
 187
 188
 189 /**
 190  *Look up an entry in the two hop neighbor table.
 191  *NO CHECK FOR MAIN ADDRESS OR ALIASES!
 192  *
 193  *@param dest the IP address of the entry to find
 194  *
 195  *@return a pointer to a neighbor_2_entry struct
 196  *representing the two hop neighbor
 197  */
 198 struct neighbor_2_entry *
 199 olsr_lookup_two_hop_neighbor_table_mid(union olsr_ip_addr *dest)
 200 {
 201   struct neighbor_2_entry  *neighbor_2;
 202   olsr_u32_t               hash;
 203
 204   //printf("LOOKING FOR %s\n", olsr_ip_to_string(dest));
 205   hash = olsr_hashing(dest);
 206
 207   for(neighbor_2 = two_hop_neighbortable[hash].next;
 208       neighbor_2 != &two_hop_neighbortable[hash];
 209       neighbor_2 = neighbor_2->next)
 210     {
 211       if (COMP_IP(&neighbor_2->neighbor_2_addr, dest))
 212         return neighbor_2;
 213     }
 214
 215   return NULL;
 216 }
 217
 218
 219
 220 /**
 221  *Print the two hop neighbor table to STDOUT.
 222  *
 223  *@return nada
 224  */
 225 void
 226 olsr_print_two_hop_neighbor_table()
 227 {
 228   olsr_u8_t                  index;
 229   struct neighbor_2_entry    *neighbor_2;
 230
 231   struct neighbor_list_entry *list_1=NULL;
 232
 233   printf("THE TWO HOP NEIGHBORS\n");
 234
 235   for(index=0;index<HASHSIZE;index++)
 236     {
 237
 238       for(neighbor_2 = two_hop_neighbortable[index].next;
 239           neighbor_2 != &two_hop_neighbortable[index];
 240           neighbor_2 = neighbor_2->next)
 241         {
 242
 243           printf("ADDRESS TWO HOP NEIGHBORS\n");
 244           printf("%s \n", olsr_ip_to_string(&neighbor_2->neighbor_2_addr));
 245           printf("---------------------\n");
 246
 247           printf("POINTED BY\n");
 248           for(list_1 = neighbor_2->neighbor_2_nblist.next;
 249               list_1 != &neighbor_2->neighbor_2_nblist;
 250               list_1 = list_1->next)
 251             {
 252               printf("%s \n", olsr_ip_to_string(&list_1->neighbor->neighbor_main_addr));
 253             }
 254           printf("---------------------\n");
 255         }
 256     }
 257 }