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