Replaced unik-olsrd with olsr.org
[olsrd.git] / src / generate_msg.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 olsr.org.
6  *
7  * olsr.org 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  * olsr.org 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 olsr.org; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  */
22
23 #include "generate_msg.h"
24 #include "defs.h"
25 #include "scheduler.h"
26 #include "build_msg.h"
27 #include "packet.h"
28 #include "mantissa.h"
29 #include "link_set.h"
30
31 /*
32  * Infomation repositiries
33  */
34 #include "hna_set.h"
35 #include "mid_set.h"
36 #include "tc_set.h"
37 #include "mpr_selector_set.h"
38 #include "duplicate_set.h"
39 #include "neighbor_table.h"
40
41
42 /**
43  * Function that sets the HELLO emission interval and
44  * calculates all other nessecarry values such as
45  * the VTIME value to emit in messages.
46  * The message generation function is removed
47  * and re-registered
48  *
49  *@param interval the new emission interval
50  *
51  *@return negative on error
52  */
53 int
54 olsr_set_hello_interval(float interval)
55 {
56   if(interval < polling_int)
57     return -1;
58
59   /* Unregister function */
60   olsr_remove_scheduler_event(&generate_hello, hello_int, 0, NULL);
61
62   hello_int = interval;
63
64   /* Re-calculate holdingtime to announce */
65   neighbor_hold_time = hello_int * neighbor_timeout_mult;
66
67   olsr_printf(3, "Setting HELLO interval to %0.2f timeout %0.2f\n", interval, neighbor_hold_time);
68
69   hello_vtime = double_to_me(neighbor_hold_time);
70
71   htime = double_to_me(hello_int);
72
73   olsr_init_timer((olsr_u32_t) (neighbor_hold_time*1000), &hold_time_neighbor);
74
75
76   /* Reregister function */
77   olsr_register_scheduler_event(&generate_hello, hello_int, 0, NULL);
78
79   /*
80    *Jitter according to the RFC
81    */
82   max_jitter = hello_int / 4;
83
84   return 1;
85 }
86
87 /**
88  * Function that sets the HELLO emission interval 
89  * for non-wireless interfaces and
90  * calculates all other nessecarry values such as
91  * the VTIME value to emit in messages.
92  * The message generation function is removed
93  * and re-registered
94  *
95  *@param interval the new emission interval
96  *
97  *@return negative on error
98  */
99 int
100 olsr_set_hello_nw_interval(float interval)
101 {
102
103   if(interval < polling_int)
104     return -1;
105
106
107   /* Unregister function */
108   olsr_remove_scheduler_event(&generate_hello_nw, hello_int_nw, 0, NULL);
109
110   hello_int_nw = interval;
111
112   /* Re-calculate holdingtime to announce */
113   neighbor_hold_time_nw = hello_int_nw * neighbor_timeout_mult_nw;
114
115   olsr_printf(3, "Setting HELLO NW interval to %0.2f hold time %0.2f\n", interval, neighbor_hold_time_nw);
116
117   hello_nw_vtime = double_to_me(neighbor_hold_time_nw);
118
119   htime_nw = double_to_me(hello_int_nw);
120
121   olsr_init_timer((olsr_u32_t) (neighbor_hold_time_nw*1000), &hold_time_neighbor_nw);
122
123
124   /* Reregister function */
125   olsr_register_scheduler_event(&generate_hello_nw, hello_int_nw, 0, NULL);
126
127   return 1;
128 }
129
130
131 /**
132  * Function that sets the TC emission interval and
133  * calculates all other nessecarry values such as
134  * the VTIME value to emit in messages.
135  * The message generation function is removed
136  * and re-registered
137  *
138  *@param interval the new emission interval
139  *
140  *@return negative on error
141  */
142
143 int
144 olsr_set_tc_interval(float interval)
145 {
146   if(interval < polling_int)
147     return -1;
148   /* Unregister function */
149   olsr_remove_scheduler_event(&generate_tc, tc_int, 0, NULL);
150
151   tc_int = interval;
152
153   /* Re-calculate holdingtime to announce */
154   topology_hold_time = tc_int * topology_timeout_mult;
155
156   olsr_printf(3, "Setting TC interval to %0.2f timeout %0.2f\n", interval, topology_hold_time);
157
158   tc_vtime = double_to_me(topology_hold_time);
159
160   /* Reregister function */
161   olsr_register_scheduler_event(&generate_tc, tc_int, 0, &changes);
162
163   return 1;
164 }
165
166
167 /**
168  * Function that sets the MID emission interval and
169  * calculates all other nessecarry values such as
170  * the VTIME value to emit in messages.
171  * The message generation function is removed
172  * and re-registered
173  *
174  *@param interval the new emission interval
175  *
176  *@return negative on error
177  */
178
179 int
180 olsr_set_mid_interval(float interval)
181 {
182   if(interval < polling_int)
183     return -1;
184
185   if(nbinterf > 1)
186     return 0;
187
188   /* Unregister function */
189   olsr_remove_scheduler_event(&generate_mid, mid_int, 0, NULL);
190
191   mid_int = interval;
192
193   /* Re-calculate holdingtime to announce */
194   mid_hold_time = mid_int * mid_timeout_mult;
195
196   olsr_printf(3, "Setting MID interval to %0.2f timeout %0.2f\n", interval, mid_hold_time);
197
198   mid_vtime = double_to_me(mid_hold_time);
199
200   /* Reregister function */
201   olsr_register_scheduler_event(&generate_mid, mid_int, mid_int/2, NULL);
202
203   return 1;
204 }
205
206
207 /**
208  * Function that sets the HNA emission interval and
209  * calculates all other nessecarry values such as
210  * the VTIME value to emit in messages.
211  * The message generation function is removed
212  * and re-registered
213  *
214  *@param interval the new emission interval
215  *
216  *@return negative on error
217  */
218
219 int
220 olsr_set_hna_interval(float interval)
221 {
222   if(interval < polling_int)
223     return -1;
224
225   /* Unregister function */
226   olsr_remove_scheduler_event(&generate_hna, hna_int, 0, NULL);
227
228   hna_int = interval;
229
230   /* Re-calculate holdingtime to announce */
231   hna_hold_time = hna_int * hna_timeout_mult;
232
233   olsr_printf(3, "Setting HNA interval to %0.2f timeout %0.2f\n", interval, hna_hold_time);
234
235   hna_vtime = double_to_me(hna_hold_time);
236
237   olsr_register_scheduler_event(&generate_hna, hna_int, hna_int/2, NULL);
238
239   return 1;
240 }
241
242
243
244
245
246 void
247 generate_hello()
248 {
249   struct interface *ifn;
250   struct hello_message hellopacket;
251
252   /* looping trough interfaces */
253   for (ifn = ifnet; ifn ; ifn = ifn->int_next) 
254     {
255       if(!ifn->is_wireless)
256         continue;
257       
258       olsr_build_hello_packet(&hellopacket, ifn);
259       hello_build(&hellopacket, ifn);
260       
261       if(outputsize)
262         net_output(ifn);
263       
264     }
265 }
266
267 void
268 generate_hello_nw()
269 {
270   struct interface *ifn;
271   struct hello_message hellopacket;
272
273   /* looping trough interfaces */
274   for (ifn = ifnet; ifn ; ifn = ifn->int_next) 
275     {
276       if(ifn->is_wireless)
277         continue;
278       
279       olsr_build_hello_packet(&hellopacket, ifn);
280       hello_build(&hellopacket, ifn);
281       
282       if(outputsize)
283         net_output(ifn);
284       
285     }
286   return;
287 }
288
289
290
291 void
292 generate_tc()
293 {
294   struct interface *ifn;
295   struct tc_message tcpacket;
296
297   /* looping trough interfaces */
298   for (ifn = ifnet; ifn ; ifn = ifn->int_next) 
299     {
300       olsr_build_tc_packet(&tcpacket);
301       tc_build(&tcpacket, ifn);
302
303       if(outputsize)
304         net_output(ifn);
305     }
306 }
307
308
309 void
310 generate_mid()
311 {
312   struct interface *ifn;
313
314   /* looping trough interfaces */
315   for (ifn = ifnet; ifn ; ifn = ifn->int_next) 
316     {
317       //printf("\nSending MID seq: %i\n", ifn->seqnums.mid_seqnum);
318       mid_build(ifn);
319       if(outputsize)
320         net_output(ifn);
321     }
322
323 return;
324 }
325
326
327
328 void
329 generate_hna()
330 {
331   struct interface *ifn;
332
333   /* looping trough interfaces */
334   for (ifn = ifnet; ifn ; ifn = ifn->int_next) 
335     { 
336       hna_build(ifn);
337       
338       if(outputsize)
339         net_output(ifn);
340     }
341   return;
342 }
343
344
345 /**
346  *Displays various tables depending on debuglevel
347  */
348 void
349 generate_tabledisplay()
350 {
351   if(debug_level > 0) 
352     {
353       olsr_print_neighbor_table();
354       
355       if(debug_level > 1)
356         {
357           olsr_print_tc_table();
358           if(debug_level > 2) 
359             {
360               olsr_print_mprs_set();
361               olsr_print_mid_set();
362               olsr_print_duplicate_table();
363             }
364         }
365     }
366 }