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 olsrd-unik.
   6  *
   7  * olsrd-unik 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  * olsrd-unik 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 olsrd-unik; 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          //entry_to_delete->prev->next = entry_to_delete->next;
  77          //entry_to_delete->next->prev = entry_to_delete->prev;
  78
  79          free(entry_to_delete);
  80        }
  81      else
  82        entry = entry->next;
  83
  84    }
  85 }
  86
  87
  88
  89 /**
  90  *Delete an entry from the two hop neighbor table.
  91  *
  92  *@param two_hop_neighbor the two hop neighbor to delete.
  93  *
  94  *@return nada
  95  */
  96 void
  97 olsr_delete_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
  98 {
  99   struct neighbor_list_entry *one_hop_list, *entry_to_delete;
 100   struct neighbor_entry      *one_hop_entry;
 101
 102   one_hop_list = two_hop_neighbor->neighbor_2_nblist.next;
 103
 104   /* Delete one hop links */
 105   while(one_hop_list != &two_hop_neighbor->neighbor_2_nblist)
 106     {
 107       one_hop_entry = one_hop_list->neighbor;
 108       olsr_delete_neighbor_2_pointer(one_hop_entry, &two_hop_neighbor->neighbor_2_addr);
 109
 110       entry_to_delete = one_hop_list;
 111
 112       one_hop_list = one_hop_list->next;
 113
 114       /* no need to dequeue */
 115
 116       free(entry_to_delete);
 117     }
 118
 119   /* dequeue */
 120   DEQUEUE_ELEM(two_hop_neighbor);
 121   //two_hop_neighbor->prev->next = two_hop_neighbor->next;
 122   //two_hop_neighbor->next->prev = two_hop_neighbor->prev;
 123
 124   free(two_hop_neighbor);
 125 }
 126
 127
 128
 129 /**
 130  *Insert a new entry to the two hop neighbor table.
 131  *
 132  *@param two_hop_neighbor the entry to insert
 133  *
 134  *@return nada
 135  */
 136 void
 137 olsr_insert_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
 138 {
 139   olsr_u32_t              hash;
 140
 141   //printf("Adding 2 hop neighbor %s\n", olsr_ip_to_string(&two_hop_neighbor->neighbor_2_addr));
 142
 143   hash = olsr_hashing(&two_hop_neighbor->neighbor_2_addr);
 144
 145   /* Queue */
 146   QUEUE_ELEM(two_hop_neighbortable[hash], two_hop_neighbor);
 147   /*
 148   two_hop_neighbortable[hash].next->prev = two_hop_neighbor;
 149   two_hop_neighbor->next = two_hop_neighbortable[hash].next;
 150   two_hop_neighbortable[hash].next = two_hop_neighbor;
 151   two_hop_neighbor->prev = &two_hop_neighbortable[hash];
 152   */
 153 }
 154
 155
 156 /**
 157  *Look up an entry in the two hop neighbor table.
 158  *
 159  *@param dest the IP address of the entry to find
 160  *
 161  *@return a pointer to a neighbor_2_entry struct
 162  *representing the two hop neighbor
 163  */
 164 struct neighbor_2_entry *
 165 olsr_lookup_two_hop_neighbor_table(union olsr_ip_addr *dest)
 166 {
 167
 168   struct neighbor_2_entry  *neighbor_2;
 169   olsr_u32_t               hash;
 170   struct addresses *adr;
 171
 172   //printf("LOOKING FOR %s\n", olsr_ip_to_string(dest));
 173   hash = olsr_hashing(dest);
 174
 175
 176   for(neighbor_2 = two_hop_neighbortable[hash].next;
 177       neighbor_2 != &two_hop_neighbortable[hash];
 178       neighbor_2 = neighbor_2->next)
 179     {
 180       //printf("Checking %s\n", olsr_ip_to_string(dest));
 181       if (COMP_IP(&neighbor_2->neighbor_2_addr, dest))
 182         return neighbor_2;
 183
 184       adr = mid_lookup_aliases(&neighbor_2->neighbor_2_addr);
 185
 186       while(adr)
 187         {
 188           if(COMP_IP(&adr->address, dest))
 189             return neighbor_2;
 190           adr = adr->next;
 191         }
 192     }
 193
 194   return NULL;
 195 }
 196
 197
 198
 199 /**
 200  *Look up an entry in the two hop neighbor table.
 201  *NO CHECK FOR MAIN ADDRESS OR ALIASES!
 202  *
 203  *@param dest the IP address of the entry to find
 204  *
 205  *@return a pointer to a neighbor_2_entry struct
 206  *representing the two hop neighbor
 207  */
 208 struct neighbor_2_entry *
 209 olsr_lookup_two_hop_neighbor_table_mid(union olsr_ip_addr *dest)
 210 {
 211   struct neighbor_2_entry  *neighbor_2;
 212   olsr_u32_t               hash;
 213
 214   //printf("LOOKING FOR %s\n", olsr_ip_to_string(dest));
 215   hash = olsr_hashing(dest);
 216
 217   for(neighbor_2 = two_hop_neighbortable[hash].next;
 218       neighbor_2 != &two_hop_neighbortable[hash];
 219       neighbor_2 = neighbor_2->next)
 220     {
 221       if (COMP_IP(&neighbor_2->neighbor_2_addr, dest))
 222         return neighbor_2;
 223     }
 224
 225   return NULL;
 226 }
 227
 228
 229
 230 /**
 231  *Print the two hop neighbor table to STDOUT.
 232  *
 233  *@return nada
 234  */
 235 void
 236 olsr_print_two_hop_neighbor_table()
 237 {
 238   olsr_u8_t                  index;
 239   struct neighbor_2_entry    *neighbor_2;
 240
 241   struct neighbor_list_entry *list_1=NULL;
 242
 243   printf("THE TWO HOP NEIGHBORS\n");
 244
 245   for(index=0;index<HASHSIZE;index++)
 246     {
 247
 248       for(neighbor_2 = two_hop_neighbortable[index].next;
 249           neighbor_2 != &two_hop_neighbortable[index];
 250           neighbor_2 = neighbor_2->next)
 251         {
 252
 253           printf("ADDRESS TWO HOP NEIGHBORS\n");
 254           printf("%s \n", olsr_ip_to_string(&neighbor_2->neighbor_2_addr));
 255           printf("---------------------\n");
 256
 257           printf("POINTED BY\n");
 258           for(list_1 = neighbor_2->neighbor_2_nblist.next;
 259               list_1 != &neighbor_2->neighbor_2_nblist;
 260               list_1 = list_1->next)
 261             {
 262               printf("%s \n", olsr_ip_to_string(&list_1->neighbor->neighbor_main_addr));
 263             }
 264           printf("---------------------\n");
 265         }
 266     }
 267 }