Code cleanups
[olsrd.git] / 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
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 }