Initial import
[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          //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 }