2 Copyright 2011 by Matthieu Boutier and Juliusz Chroboczek
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "distribute.h"
32 #include "lib_errors.h"
34 #include "babel_main.h"
39 #include "babel_interface.h"
40 #include "neighbour.h"
44 #include "babel_filter.h"
45 #include "babel_zebra.h"
46 #include "babel_errors.h"
48 DEFINE_MGROUP(BABELD
, "babeld")
49 DEFINE_MTYPE_STATIC(BABELD
, BABEL
, "Babel Structure")
51 static int babel_init_routing_process(struct thread
*thread
);
52 static void babel_get_myid(void);
53 static void babel_initial_noise(void);
54 static int babel_read_protocol (struct thread
*thread
);
55 static int babel_main_loop(struct thread
*thread
);
56 static void babel_set_timer(struct timeval
*timeout
);
57 static void babel_fill_with_next_timeout(struct timeval
*tv
);
59 babel_distribute_update (struct distribute_ctx
*ctx
, struct distribute
*dist
);
61 /* Informations relative to the babel running daemon. */
62 static struct babel
*babel_routing_process
= NULL
;
63 static unsigned char *receive_buffer
= NULL
;
64 static int receive_buffer_size
= 0;
67 struct timeval check_neighbours_timeout
;
68 static time_t expiry_time
;
69 static time_t source_expiry_time
;
71 /* Babel node structure. */
72 static struct cmd_node cmd_babel_node
=
75 .prompt
= "%s(config-router)# ",
79 /* print current babel configuration on vty */
81 babel_config_write (struct vty
*vty
)
87 /* list enabled debug modes */
88 lines
+= debug_babel_config_write (vty
);
90 if (!babel_routing_process
)
92 vty_out (vty
, "router babel\n");
93 if (diversity_kind
!= DIVERSITY_NONE
)
95 vty_out (vty
, " babel diversity\n");
98 if (diversity_factor
!= BABEL_DEFAULT_DIVERSITY_FACTOR
)
100 vty_out (vty
, " babel diversity-factor %d\n",diversity_factor
);
103 if (resend_delay
!= BABEL_DEFAULT_RESEND_DELAY
)
105 vty_out (vty
, " babel resend-delay %u\n", resend_delay
);
108 if (smoothing_half_life
!= BABEL_DEFAULT_SMOOTHING_HALF_LIFE
)
110 vty_out (vty
, " babel smoothing-half-life %u\n",
111 smoothing_half_life
);
114 /* list enabled interfaces */
115 lines
= 1 + babel_enable_if_config_write (vty
);
116 /* list redistributed protocols */
117 for (afi
= AFI_IP
; afi
<= AFI_IP6
; afi
++) {
118 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
119 if (i
!= zclient
->redist_default
&&
120 vrf_bitmap_check (zclient
->redist
[afi
][i
], VRF_DEFAULT
)) {
121 vty_out (vty
, " redistribute %s %s\n",
122 (afi
== AFI_IP
) ? "ipv4" : "ipv6",
123 zebra_route_string(i
));
129 lines
+= config_write_distribute (vty
, babel_routing_process
->distribute_ctx
);
136 babel_create_routing_process (void)
138 assert (babel_routing_process
== NULL
);
140 /* Allocaste Babel instance. */
141 babel_routing_process
= XCALLOC (MTYPE_BABEL
, sizeof (struct babel
));
143 /* Initialize timeouts */
145 expiry_time
= babel_now
.tv_sec
+ roughly(30);
146 source_expiry_time
= babel_now
.tv_sec
+ roughly(300);
148 /* Make socket for Babel protocol. */
149 protocol_socket
= babel_socket(protocol_port
);
150 if (protocol_socket
< 0) {
151 flog_err_sys(EC_LIB_SOCKET
, "Couldn't create link local socket: %s",
152 safe_strerror(errno
));
157 thread_add_read(master
, &babel_read_protocol
, NULL
, protocol_socket
, &babel_routing_process
->t_read
);
158 /* wait a little: zebra will announce interfaces, addresses, routes... */
159 thread_add_timer_msec(master
, babel_init_routing_process
, NULL
, 200L, &babel_routing_process
->t_update
);
161 /* Distribute list install. */
162 babel_routing_process
->distribute_ctx
= distribute_list_ctx_create (vrf_lookup_by_id(VRF_DEFAULT
));
163 distribute_list_add_hook (babel_routing_process
->distribute_ctx
, babel_distribute_update
);
164 distribute_list_delete_hook (babel_routing_process
->distribute_ctx
, babel_distribute_update
);
167 XFREE(MTYPE_BABEL
, babel_routing_process
);
168 babel_routing_process
= NULL
;
172 /* thread reading entries form others babel daemons */
174 babel_read_protocol (struct thread
*thread
)
177 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
178 struct interface
*ifp
= NULL
;
179 struct sockaddr_in6 sin6
;
181 assert(babel_routing_process
!= NULL
);
182 assert(protocol_socket
>= 0);
184 rc
= babel_recv(protocol_socket
,
185 receive_buffer
, receive_buffer_size
,
186 (struct sockaddr
*)&sin6
, sizeof(sin6
));
188 if(errno
!= EAGAIN
&& errno
!= EINTR
) {
189 flog_err_sys(EC_LIB_SOCKET
, "recv: %s", safe_strerror(errno
));
192 FOR_ALL_INTERFACES(vrf
, ifp
) {
195 if(ifp
->ifindex
== (ifindex_t
)sin6
.sin6_scope_id
) {
196 parse_packet((unsigned char*)&sin6
.sin6_addr
, ifp
,
204 thread_add_read(master
, &babel_read_protocol
, NULL
, protocol_socket
, &babel_routing_process
->t_read
);
208 /* Zebra will give some information, especially about interfaces. This function
209 must be call with a litte timeout wich may give zebra the time to do his job,
210 making these inits have sense. */
212 babel_init_routing_process(struct thread
*thread
)
214 myseqno
= (random() & 0xFFFF);
216 babel_load_state_file();
217 debugf(BABEL_DEBUG_COMMON
, "My ID is : %s.", format_eui64(myid
));
218 babel_initial_noise();
219 babel_main_loop(thread
);/* this function self-add to the t_update thread */
223 /* fill "myid" with an unique id (only if myid != {0}). */
227 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
228 struct interface
*ifp
= NULL
;
232 /* if we already have an id (from state file), we return. */
233 if (memcmp(myid
, zeroes
, 8) != 0) {
237 FOR_ALL_INTERFACES(vrf
, ifp
) {
238 /* ifp->ifindex is not necessarily valid at this point */
239 int ifindex
= if_nametoindex(ifp
->name
);
241 unsigned char eui
[8];
242 rc
= if_eui64(ifindex
, eui
);
245 memcpy(myid
, eui
, 8);
250 /* We failed to get a global EUI64 from the interfaces we were given.
251 Let's try to find an interface with a MAC address. */
252 for(i
= 1; i
< 256; i
++) {
253 char buf
[IF_NAMESIZE
], *ifname
;
254 unsigned char eui
[8];
255 ifname
= if_indextoname(i
, buf
);
258 rc
= if_eui64(i
, eui
);
261 memcpy(myid
, eui
, 8);
265 flog_err(EC_BABEL_CONFIG
,
266 "Warning: couldn't find router id -- using random value.");
268 rc
= read_random_bytes(myid
, 8);
270 flog_err(EC_BABEL_CONFIG
, "read(random): %s (cannot assign an ID)",
271 safe_strerror(errno
));
274 /* Clear group and global bits */
278 /* Make some noise so that others notice us, and send retractions in
279 case we were restarted recently */
281 babel_initial_noise(void)
283 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
284 struct interface
*ifp
= NULL
;
286 FOR_ALL_INTERFACES(vrf
, ifp
) {
289 /* Apply jitter before we send the first message. */
290 usleep(roughly(10000));
293 send_wildcard_retraction(ifp
);
296 FOR_ALL_INTERFACES(vrf
, ifp
) {
299 usleep(roughly(10000));
302 send_wildcard_retraction(ifp
);
303 send_self_update(ifp
);
304 send_request(ifp
, NULL
, 0);
310 /* Delete all the added babel routes, make babeld only speak to zebra. */
312 babel_clean_routing_process(void)
315 babel_interface_close_all();
318 if (babel_routing_process
->t_read
!= NULL
) {
319 thread_cancel(babel_routing_process
->t_read
);
321 if (babel_routing_process
->t_update
!= NULL
) {
322 thread_cancel(babel_routing_process
->t_update
);
325 distribute_list_delete(&babel_routing_process
->distribute_ctx
);
326 XFREE(MTYPE_BABEL
, babel_routing_process
);
327 babel_routing_process
= NULL
;
330 /* Function used with timeout. */
332 babel_main_loop(struct thread
*thread
)
335 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
336 struct interface
*ifp
= NULL
;
341 /* timeouts --------------------------------------------------------- */
342 /* get the next timeout */
343 babel_fill_with_next_timeout(&tv
);
344 /* if there is no timeout, we must wait. */
345 if(timeval_compare(&tv
, &babel_now
) > 0) {
346 timeval_minus(&tv
, &tv
, &babel_now
);
347 debugf(BABEL_DEBUG_TIMEOUT
, "babel main loop : timeout: %lld msecs",
348 (long long)tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000);
349 /* it happens often to have less than 1 ms, it's bad. */
350 timeval_add_msec(&tv
, &tv
, 300);
351 babel_set_timer(&tv
);
357 /* update database -------------------------------------------------- */
358 if(timeval_compare(&check_neighbours_timeout
, &babel_now
) < 0) {
360 msecs
= check_neighbours();
361 /* Multiply by 3/2 to allow neighbours to expire. */
362 msecs
= MAX(3 * msecs
/ 2, 10);
363 schedule_neighbours_check(msecs
, 1);
366 if(babel_now
.tv_sec
>= expiry_time
) {
369 expiry_time
= babel_now
.tv_sec
+ roughly(30);
372 if(babel_now
.tv_sec
>= source_expiry_time
) {
374 source_expiry_time
= babel_now
.tv_sec
+ roughly(300);
377 FOR_ALL_INTERFACES(vrf
, ifp
) {
378 babel_interface_nfo
*babel_ifp
= NULL
;
381 babel_ifp
= babel_get_if_nfo(ifp
);
382 if(timeval_compare(&babel_now
, &babel_ifp
->hello_timeout
) >= 0)
384 if(timeval_compare(&babel_now
, &babel_ifp
->update_timeout
) >= 0)
385 send_update(ifp
, 0, NULL
, 0);
386 if(timeval_compare(&babel_now
,
387 &babel_ifp
->update_flush_timeout
) >= 0)
391 if(resend_time
.tv_sec
!= 0) {
392 if(timeval_compare(&babel_now
, &resend_time
) >= 0)
396 if(unicast_flush_timeout
.tv_sec
!= 0) {
397 if(timeval_compare(&babel_now
, &unicast_flush_timeout
) >= 0)
401 FOR_ALL_INTERFACES(vrf
, ifp
) {
402 babel_interface_nfo
*babel_ifp
= NULL
;
405 babel_ifp
= babel_get_if_nfo(ifp
);
406 if(babel_ifp
->flush_timeout
.tv_sec
!= 0) {
407 if(timeval_compare(&babel_now
, &babel_ifp
->flush_timeout
) >= 0)
413 assert(0); /* this line should never be reach */
417 printIfMin(struct timeval
*tv
, int cmd
, const char *tag
, const char *ifname
)
419 static struct timeval curr_tv
;
420 static char buffer
[200];
421 static const char *curr_tag
= NULL
;
424 case 0: /* reset timeval */
427 snprintf(buffer
, 200L, "interface: %s; %s", ifname
, tag
);
433 case 1: /* take the min */
434 if (tv
->tv_sec
== 0 && tv
->tv_usec
== 0) { /* if (tv == ∞) */
437 if (tv
->tv_sec
< curr_tv
.tv_sec
||(tv
->tv_sec
== curr_tv
.tv_sec
&&
438 tv
->tv_usec
< curr_tv
.tv_usec
)) {
441 snprintf(buffer
, 200L, "interface: %s; %s", ifname
, tag
);
448 case 2: /* print message */
449 debugf(BABEL_DEBUG_TIMEOUT
, "next timeout due to: %s", curr_tag
);
457 babel_fill_with_next_timeout(struct timeval
*tv
)
459 #if (defined NO_DEBUG)
460 #define printIfMin(a,b,c,d)
462 #define printIfMin(a,b,c,d) \
463 if (UNLIKELY(debug & BABEL_DEBUG_TIMEOUT)) {printIfMin(a,b,c,d);}
465 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
466 struct interface
*ifp
= NULL
;
468 *tv
= check_neighbours_timeout
;
469 printIfMin(tv
, 0, "check_neighbours_timeout", NULL
);
470 timeval_min_sec(tv
, expiry_time
);
471 printIfMin(tv
, 1, "expiry_time", NULL
);
472 timeval_min_sec(tv
, source_expiry_time
);
473 printIfMin(tv
, 1, "source_expiry_time", NULL
);
474 timeval_min(tv
, &resend_time
);
475 printIfMin(tv
, 1, "resend_time", NULL
);
476 FOR_ALL_INTERFACES(vrf
, ifp
) {
477 babel_interface_nfo
*babel_ifp
= NULL
;
480 babel_ifp
= babel_get_if_nfo(ifp
);
481 timeval_min(tv
, &babel_ifp
->flush_timeout
);
482 printIfMin(tv
, 1, "flush_timeout", ifp
->name
);
483 timeval_min(tv
, &babel_ifp
->hello_timeout
);
484 printIfMin(tv
, 1, "hello_timeout", ifp
->name
);
485 timeval_min(tv
, &babel_ifp
->update_timeout
);
486 printIfMin(tv
, 1, "update_timeout", ifp
->name
);
487 timeval_min(tv
, &babel_ifp
->update_flush_timeout
);
488 printIfMin(tv
, 1, "update_flush_timeout",ifp
->name
);
490 timeval_min(tv
, &unicast_flush_timeout
);
491 printIfMin(tv
, 1, "unicast_flush_timeout", NULL
);
492 printIfMin(tv
, 2, NULL
, NULL
);
497 /* set the t_update thread of the babel routing process to be launch in
498 'timeout' (approximate at the milisecond) */
500 babel_set_timer(struct timeval
*timeout
)
502 long msecs
= timeout
->tv_sec
* 1000 + timeout
->tv_usec
/ 1000;
503 if (babel_routing_process
->t_update
!= NULL
) {
504 thread_cancel(babel_routing_process
->t_update
);
506 thread_add_timer_msec(master
, babel_main_loop
, NULL
, msecs
, &babel_routing_process
->t_update
);
510 schedule_neighbours_check(int msecs
, int override
)
512 struct timeval timeout
;
514 timeval_add_msec(&timeout
, &babel_now
, msecs
);
516 check_neighbours_timeout
= timeout
;
518 timeval_min(&check_neighbours_timeout
, &timeout
);
522 resize_receive_buffer(int size
)
524 if(size
<= receive_buffer_size
)
527 if(receive_buffer
== NULL
) {
528 receive_buffer
= malloc(size
);
529 if(receive_buffer
== NULL
) {
530 flog_err(EC_BABEL_MEMORY
, "malloc(receive_buffer): %s",
531 safe_strerror(errno
));
534 receive_buffer_size
= size
;
537 new = realloc(receive_buffer
, size
);
539 flog_err(EC_BABEL_MEMORY
, "realloc(receive_buffer): %s",
540 safe_strerror(errno
));
543 receive_buffer
= new;
544 receive_buffer_size
= size
;
550 babel_distribute_update (struct distribute_ctx
*ctx
, struct distribute
*dist
)
552 struct interface
*ifp
;
553 babel_interface_nfo
*babel_ifp
;
560 ifp
= if_lookup_by_name (dist
->ifname
, VRF_DEFAULT
);
564 babel_ifp
= babel_get_if_nfo(ifp
);
566 for (type
= 0; type
< DISTRIBUTE_MAX
; type
++) {
567 family
= type
== DISTRIBUTE_V4_IN
|| type
== DISTRIBUTE_V4_OUT
?
569 if (dist
->list
[type
])
570 babel_ifp
->list
[type
] = access_list_lookup (family
,
573 babel_ifp
->list
[type
] = NULL
;
574 if (dist
->prefix
[type
])
575 babel_ifp
->prefix
[type
] = prefix_list_lookup (family
,
578 babel_ifp
->prefix
[type
] = NULL
;
583 babel_distribute_update_interface (struct interface
*ifp
)
585 struct distribute
*dist
= NULL
;
587 if (babel_routing_process
)
588 dist
= distribute_lookup(babel_routing_process
->distribute_ctx
, ifp
->name
);
590 babel_distribute_update (babel_routing_process
->distribute_ctx
, dist
);
593 /* Update all interface's distribute list. */
595 babel_distribute_update_all (struct prefix_list
*notused
)
597 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
598 struct interface
*ifp
;
600 FOR_ALL_INTERFACES (vrf
, ifp
)
601 babel_distribute_update_interface (ifp
);
605 babel_distribute_update_all_wrapper (struct access_list
*notused
)
607 babel_distribute_update_all(NULL
);
612 DEFUN_NOSH (router_babel
,
615 "Enable a routing process\n"
616 "Make Babel instance command\n")
620 vty
->node
= BABEL_NODE
;
622 if (!babel_routing_process
) {
623 ret
= babel_create_routing_process ();
625 /* Notice to user we couldn't create Babel. */
627 zlog_warn ("can't create Babel");
636 DEFUN (no_router_babel
,
640 "Disable a routing process\n"
641 "Remove Babel instance command\n")
643 if(babel_routing_process
)
644 babel_clean_routing_process();
648 /* [Babel Command] */
649 DEFUN (babel_diversity
,
653 "Enable diversity-aware routing.\n")
655 diversity_kind
= DIVERSITY_CHANNEL
;
659 /* [Babel Command] */
660 DEFUN (no_babel_diversity
,
661 no_babel_diversity_cmd
,
662 "no babel diversity",
665 "Disable diversity-aware routing.\n")
667 diversity_kind
= DIVERSITY_NONE
;
671 /* [Babel Command] */
672 DEFUN (babel_diversity_factor
,
673 babel_diversity_factor_cmd
,
674 "babel diversity-factor (1-256)",
676 "Set the diversity factor.\n"
677 "Factor in units of 1/256.\n")
681 factor
= strtoul(argv
[2]->arg
, NULL
, 10);
683 diversity_factor
= factor
;
687 /* [Babel Command] */
688 DEFUN (babel_set_resend_delay
,
689 babel_set_resend_delay_cmd
,
690 "babel resend-delay (20-655340)",
692 "Time before resending a message\n"
697 interval
= strtoul(argv
[2]->arg
, NULL
, 10);
699 resend_delay
= interval
;
703 /* [Babel Command] */
704 DEFUN (babel_set_smoothing_half_life
,
705 babel_set_smoothing_half_life_cmd
,
706 "babel smoothing-half-life (0-65534)",
708 "Smoothing half-life\n"
709 "Seconds (0 to disable)\n")
713 seconds
= strtoul(argv
[2]->arg
, NULL
, 10);
715 change_smoothing_half_life(seconds
);
720 babeld_quagga_init(void)
723 install_node(&cmd_babel_node
, &babel_config_write
);
725 install_element(CONFIG_NODE
, &router_babel_cmd
);
726 install_element(CONFIG_NODE
, &no_router_babel_cmd
);
728 install_default(BABEL_NODE
);
729 install_element(BABEL_NODE
, &babel_diversity_cmd
);
730 install_element(BABEL_NODE
, &no_babel_diversity_cmd
);
731 install_element(BABEL_NODE
, &babel_diversity_factor_cmd
);
732 install_element(BABEL_NODE
, &babel_set_resend_delay_cmd
);
733 install_element(BABEL_NODE
, &babel_set_smoothing_half_life_cmd
);
737 /* Access list install. */
739 access_list_add_hook (babel_distribute_update_all_wrapper
);
740 access_list_delete_hook (babel_distribute_update_all_wrapper
);
742 /* Prefix list initialize.*/
744 prefix_list_add_hook (babel_distribute_update_all
);
745 prefix_list_delete_hook (babel_distribute_update_all
);
747 /* Distribute list install. */
748 distribute_list_init(BABEL_NODE
);
751 /* Stubs to adapt Babel's filtering calls to Quagga's infrastructure. */
754 input_filter(const unsigned char *id
,
755 const unsigned char *prefix
, unsigned short plen
,
756 const unsigned char *neigh
, unsigned int ifindex
)
758 return babel_filter(0, prefix
, plen
, ifindex
);
762 output_filter(const unsigned char *id
, const unsigned char *prefix
,
763 unsigned short plen
, unsigned int ifindex
)
765 return babel_filter(1, prefix
, plen
, ifindex
);
768 /* There's no redistribute filter in Quagga -- the zebra daemon does its
771 redistribute_filter(const unsigned char *prefix
, unsigned short plen
,
772 unsigned int ifindex
, int proto
)
777 struct babel
*babel_lookup(void)
779 return babel_routing_process
;