src/two_hop_neighbor_table.c

   1 /*
   2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   3  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * * Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * * Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in
  14  *   the documentation and/or other materials provided with the
  15  *   distribution.
  16  * * Neither the name of olsr.org, olsrd nor the names of its
  17  *   contributors may be used to endorse or promote products derived
  18  *   from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * Visit http://www.olsr.org for more information.
  34  *
  35  * If you find this software useful feel free to make a donation
  36  * to the project. For more information see the website or contact
  37  * the copyright holders.
  38  *
  39  * $Id: two_hop_neighbor_table.c,v 1.12 2005/01/17 20:18:22 kattemat Exp $
  40  */
  41
  42
  43
  44 #include "defs.h"
  45 #include "two_hop_neighbor_table.h"
  46 #include "mid_set.h"
  47 #include "mpr.h"
  48
  49
  50 /**
  51  *Initialize 2 hop neighbor table
  52  */
  53 int
  54 olsr_init_two_hop_table()
  55 {
  56   int index;
  57
  58   for(index=0;index<HASHSIZE;index++)
  59     {
  60       two_hop_neighbortable[index].next = &two_hop_neighbortable[index];
  61       two_hop_neighbortable[index].prev = &two_hop_neighbortable[index];
  62     }
  63   return 1;
  64 }
  65
  66
  67 /**
  68  *Remove a one hop neighbor from a two hop neighbors
  69  *one hop list.
  70  *
  71  *@param two_hop_entry the two hop neighbor to remove the
  72  *one hop neighbor from
  73  *@param address the address of the one hop neighbor to remove
  74  *
  75  *@return nada
  76  */
  77
  78 void
  79 olsr_delete_neighbor_pointer(struct neighbor_2_entry *two_hop_entry, union olsr_ip_addr *address)
  80 {
  81   struct neighbor_list_entry *entry;
  82
  83   entry = two_hop_entry->neighbor_2_nblist.next;
  84
  85
  86   while(entry != &two_hop_entry->neighbor_2_nblist)
  87     {
  88       if(COMP_IP(&entry->neighbor->neighbor_main_addr, address))
  89         {
  90           struct neighbor_list_entry *entry_to_delete = entry;
  91           entry = entry->next;
  92
  93           /* dequeue */
  94           DEQUEUE_ELEM(entry_to_delete);
  95
  96           free(entry_to_delete);
  97         }
  98       else
  99         {
 100           entry = entry->next;
 101         }
 102     }
 103 }
 104
 105
 106
 107 /**
 108  *Delete an entry from the two hop neighbor table.
 109  *
 110  *@param two_hop_neighbor the two hop neighbor to delete.
 111  *
 112  *@return nada
 113  */
 114 void
 115 olsr_delete_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
 116 {
 117   struct neighbor_list_entry *one_hop_list;
 118
 119   one_hop_list = two_hop_neighbor->neighbor_2_nblist.next;
 120
 121   /* Delete one hop links */
 122   while(one_hop_list != &two_hop_neighbor->neighbor_2_nblist)
 123     {
 124       struct neighbor_entry *one_hop_entry = one_hop_list->neighbor;
 125       struct neighbor_list_entry *entry_to_delete = one_hop_list;
 126
 127       olsr_delete_neighbor_2_pointer(one_hop_entry, &two_hop_neighbor->neighbor_2_addr);
 128       one_hop_list = one_hop_list->next;
 129       /* no need to dequeue */
 130       free(entry_to_delete);
 131     }
 132
 133   /* dequeue */
 134   DEQUEUE_ELEM(two_hop_neighbor);
 135   free(two_hop_neighbor);
 136 }
 137
 138
 139
 140 /**
 141  *Insert a new entry to the two hop neighbor table.
 142  *
 143  *@param two_hop_neighbor the entry to insert
 144  *
 145  *@return nada
 146  */
 147 void
 148 olsr_insert_two_hop_neighbor_table(struct neighbor_2_entry *two_hop_neighbor)
 149 {
 150   olsr_u32_t              hash;
 151
 152   //printf("Adding 2 hop neighbor %s\n", olsr_ip_to_string(&two_hop_neighbor->neighbor_2_addr));
 153
 154   hash = olsr_hashing(&two_hop_neighbor->neighbor_2_addr);
 155
 156   /* Queue */
 157   QUEUE_ELEM(two_hop_neighbortable[hash], two_hop_neighbor);
 158 }
 159
 160
 161 /**
 162  *Look up an entry in the two hop neighbor table.
 163  *
 164  *@param dest the IP address of the entry to find
 165  *
 166  *@return a pointer to a neighbor_2_entry struct
 167  *representing the two hop neighbor
 168  */
 169 struct neighbor_2_entry *
 170 olsr_lookup_two_hop_neighbor_table(union olsr_ip_addr *dest)
 171 {
 172
 173   struct neighbor_2_entry  *neighbor_2;
 174   olsr_u32_t               hash;
 175
 176   //printf("LOOKING FOR %s\n", olsr_ip_to_string(dest));
 177   hash = olsr_hashing(dest);
 178
 179
 180   for(neighbor_2 = two_hop_neighbortable[hash].next;
 181       neighbor_2 != &two_hop_neighbortable[hash];
 182       neighbor_2 = neighbor_2->next)
 183     {
 184       struct addresses *adr;
 185
 186       //printf("Checking %s\n", olsr_ip_to_string(dest));
 187       if (COMP_IP(&neighbor_2->neighbor_2_addr, dest))
 188         return neighbor_2;
 189
 190       adr = mid_lookup_aliases(&neighbor_2->neighbor_2_addr);
 191
 192       while(adr)
 193         {
 194           if(COMP_IP(&adr->address, dest))
 195             return neighbor_2;
 196           adr = adr->next;
 197         }
 198     }
 199
 200   return NULL;
 201 }
 202
 203
 204
 205 /**
 206  *Look up an entry in the two hop neighbor table.
 207  *NO CHECK FOR MAIN ADDRESS OR ALIASES!
 208  *
 209  *@param dest the IP address of the entry to find
 210  *
 211  *@return a pointer to a neighbor_2_entry struct
 212  *representing the two hop neighbor
 213  */
 214 struct neighbor_2_entry *
 215 olsr_lookup_two_hop_neighbor_table_mid(union olsr_ip_addr *dest)
 216 {
 217   struct neighbor_2_entry  *neighbor_2;
 218   olsr_u32_t               hash;
 219
 220   //printf("LOOKING FOR %s\n", olsr_ip_to_string(dest));
 221   hash = olsr_hashing(dest);
 222
 223   for(neighbor_2 = two_hop_neighbortable[hash].next;
 224       neighbor_2 != &two_hop_neighbortable[hash];
 225       neighbor_2 = neighbor_2->next)
 226     {
 227       if (COMP_IP(&neighbor_2->neighbor_2_addr, dest))
 228         return neighbor_2;
 229     }
 230
 231   return NULL;
 232 }
 233
 234
 235
 236 /**
 237  *Print the two hop neighbor table to STDOUT.
 238  *
 239  *@return nada
 240  */
 241 void
 242 olsr_print_two_hop_neighbor_table()
 243 {
 244   int i;
 245
 246   olsr_printf(1, "\n--- %02d:%02d:%02d -------------------------- TWO-HOP NEIGHBORS\n\n",
 247               nowtm->tm_hour,
 248               nowtm->tm_min,
 249               nowtm->tm_sec,
 250               now.tv_usec);
 251
 252   olsr_printf(1, "IP addr (2-hop)  IP addr (1-hop)  TLQ\n");
 253
 254   for (i = 0; i < HASHSIZE; i++)
 255     {
 256       struct neighbor_2_entry *neigh2;
 257       for (neigh2 = two_hop_neighbortable[i].next;
 258            neigh2 != &two_hop_neighbortable[i]; neigh2 = neigh2->next)
 259         {
 260           struct neighbor_list_entry *entry;
 261           olsr_bool first = OLSR_TRUE;
 262
 263           for (entry = neigh2->neighbor_2_nblist.next;
 264                entry != &neigh2->neighbor_2_nblist; entry = entry->next)
 265             {
 266               double total_lq;
 267               struct neighbor_entry *neigh = entry->neighbor;
 268
 269               if (first)
 270                 {
 271                   olsr_printf(1, "%-15s  ",
 272                               olsr_ip_to_string(&neigh2->neighbor_2_addr));
 273                   first = OLSR_FALSE;
 274                 }
 275
 276               else
 277                 olsr_printf(1, "                 ");
 278
 279               total_lq = entry->path_link_quality;
 280
 281               olsr_printf(1, "%-15s  %5.3f\n",
 282                           olsr_ip_to_string(&neigh->neighbor_main_addr),
 283                           total_lq);
 284             }
 285         }
 286     }
 287 }