General cleanups in header files
[olsrd.git] / 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.14 2005/02/20 18:52:19 kattemat Exp $
40  */
41
42
43
44 #include "defs.h"
45 #include "two_hop_neighbor_table.h"
46 #include "mid_set.h"
47 #include "neighbor_table.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 mid_address *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->alias, dest))
195             return neighbor_2;
196           adr = adr->next_alias;
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 }