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"
35 #include "babel_main.h"
40 #include "babel_interface.h"
41 #include "neighbour.h"
45 #include "babel_filter.h"
46 #include "babel_zebra.h"
47 #include "babel_errors.h"
49 DEFINE_MGROUP(BABELD
, "babeld")
50 DEFINE_MTYPE_STATIC(BABELD
, BABEL
, "Babel Structure")
52 static int babel_init_routing_process(struct thread
*thread
);
53 static void babel_get_myid(void);
54 static void babel_initial_noise(void);
55 static int babel_read_protocol (struct thread
*thread
);
56 static int babel_main_loop(struct thread
*thread
);
57 static void babel_set_timer(struct timeval
*timeout
);
58 static void babel_fill_with_next_timeout(struct timeval
*tv
);
60 babel_distribute_update (struct distribute_ctx
*ctx
, struct distribute
*dist
);
62 /* Informations relative to the babel running daemon. */
63 static struct babel
*babel_routing_process
= NULL
;
64 static unsigned char *receive_buffer
= NULL
;
65 static int receive_buffer_size
= 0;
68 struct timeval check_neighbours_timeout
;
69 static time_t expiry_time
;
70 static time_t source_expiry_time
;
72 /* Babel node structure. */
73 static int babel_config_write (struct vty
*vty
);
74 static struct cmd_node cmd_babel_node
=
78 .parent_node
= CONFIG_NODE
,
79 .prompt
= "%s(config-router)# ",
80 .config_write
= babel_config_write
,
83 /* print current babel configuration on vty */
85 babel_config_write (struct vty
*vty
)
91 /* list enabled debug modes */
92 lines
+= debug_babel_config_write (vty
);
94 if (!babel_routing_process
)
96 vty_out (vty
, "router babel\n");
97 if (diversity_kind
!= DIVERSITY_NONE
)
99 vty_out (vty
, " babel diversity\n");
102 if (diversity_factor
!= BABEL_DEFAULT_DIVERSITY_FACTOR
)
104 vty_out (vty
, " babel diversity-factor %d\n",diversity_factor
);
107 if (resend_delay
!= BABEL_DEFAULT_RESEND_DELAY
)
109 vty_out (vty
, " babel resend-delay %u\n", resend_delay
);
112 if (smoothing_half_life
!= BABEL_DEFAULT_SMOOTHING_HALF_LIFE
)
114 vty_out (vty
, " babel smoothing-half-life %u\n",
115 smoothing_half_life
);
118 /* list enabled interfaces */
119 lines
= 1 + babel_enable_if_config_write (vty
);
120 /* list redistributed protocols */
121 for (afi
= AFI_IP
; afi
<= AFI_IP6
; afi
++) {
122 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
123 if (i
!= zclient
->redist_default
&&
124 vrf_bitmap_check (zclient
->redist
[afi
][i
], VRF_DEFAULT
)) {
125 vty_out (vty
, " redistribute %s %s\n",
126 (afi
== AFI_IP
) ? "ipv4" : "ipv6",
127 zebra_route_string(i
));
133 lines
+= config_write_distribute (vty
, babel_routing_process
->distribute_ctx
);
140 babel_create_routing_process (void)
142 assert (babel_routing_process
== NULL
);
144 /* Allocaste Babel instance. */
145 babel_routing_process
= XCALLOC(MTYPE_BABEL
, sizeof(struct babel
));
147 /* Initialize timeouts */
149 expiry_time
= babel_now
.tv_sec
+ roughly(30);
150 source_expiry_time
= babel_now
.tv_sec
+ roughly(300);
152 /* Make socket for Babel protocol. */
153 protocol_socket
= babel_socket(protocol_port
);
154 if (protocol_socket
< 0) {
155 flog_err_sys(EC_LIB_SOCKET
, "Couldn't create link local socket: %s",
156 safe_strerror(errno
));
161 thread_add_read(master
, &babel_read_protocol
, NULL
, protocol_socket
, &babel_routing_process
->t_read
);
162 /* wait a little: zebra will announce interfaces, addresses, routes... */
163 thread_add_timer_msec(master
, babel_init_routing_process
, NULL
, 200L, &babel_routing_process
->t_update
);
165 /* Distribute list install. */
166 babel_routing_process
->distribute_ctx
= distribute_list_ctx_create (vrf_lookup_by_id(VRF_DEFAULT
));
167 distribute_list_add_hook (babel_routing_process
->distribute_ctx
, babel_distribute_update
);
168 distribute_list_delete_hook (babel_routing_process
->distribute_ctx
, babel_distribute_update
);
171 XFREE(MTYPE_BABEL
, babel_routing_process
);
175 /* thread reading entries form others babel daemons */
177 babel_read_protocol (struct thread
*thread
)
180 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
181 struct interface
*ifp
= NULL
;
182 struct sockaddr_in6 sin6
;
184 assert(babel_routing_process
!= NULL
);
185 assert(protocol_socket
>= 0);
187 rc
= babel_recv(protocol_socket
,
188 receive_buffer
, receive_buffer_size
,
189 (struct sockaddr
*)&sin6
, sizeof(sin6
));
191 if(errno
!= EAGAIN
&& errno
!= EINTR
) {
192 flog_err_sys(EC_LIB_SOCKET
, "recv: %s", safe_strerror(errno
));
195 FOR_ALL_INTERFACES(vrf
, ifp
) {
198 if(ifp
->ifindex
== (ifindex_t
)sin6
.sin6_scope_id
) {
199 parse_packet((unsigned char*)&sin6
.sin6_addr
, ifp
,
207 thread_add_read(master
, &babel_read_protocol
, NULL
, protocol_socket
, &babel_routing_process
->t_read
);
211 /* Zebra will give some information, especially about interfaces. This function
212 must be call with a litte timeout wich may give zebra the time to do his job,
213 making these inits have sense. */
215 babel_init_routing_process(struct thread
*thread
)
217 myseqno
= (frr_weak_random() & 0xFFFF);
219 babel_load_state_file();
220 debugf(BABEL_DEBUG_COMMON
, "My ID is : %s.", format_eui64(myid
));
221 babel_initial_noise();
222 babel_main_loop(thread
);/* this function self-add to the t_update thread */
226 /* fill "myid" with an unique id (only if myid != {0}). */
230 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
231 struct interface
*ifp
= NULL
;
235 /* if we already have an id (from state file), we return. */
236 if (memcmp(myid
, zeroes
, 8) != 0) {
240 FOR_ALL_INTERFACES(vrf
, ifp
) {
241 /* ifp->ifindex is not necessarily valid at this point */
242 int ifindex
= if_nametoindex(ifp
->name
);
244 unsigned char eui
[8];
245 rc
= if_eui64(ifindex
, eui
);
248 memcpy(myid
, eui
, 8);
253 /* We failed to get a global EUI64 from the interfaces we were given.
254 Let's try to find an interface with a MAC address. */
255 for(i
= 1; i
< 256; i
++) {
256 char buf
[IF_NAMESIZE
], *ifname
;
257 unsigned char eui
[8];
258 ifname
= if_indextoname(i
, buf
);
261 rc
= if_eui64(i
, eui
);
264 memcpy(myid
, eui
, 8);
268 flog_err(EC_BABEL_CONFIG
,
269 "Warning: couldn't find router id -- using random value.");
271 rc
= read_random_bytes(myid
, 8);
273 flog_err(EC_BABEL_CONFIG
, "read(random): %s (cannot assign an ID)",
274 safe_strerror(errno
));
277 /* Clear group and global bits */
281 /* Make some noise so that others notice us, and send retractions in
282 case we were restarted recently */
284 babel_initial_noise(void)
286 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
287 struct interface
*ifp
= NULL
;
289 FOR_ALL_INTERFACES(vrf
, ifp
) {
292 /* Apply jitter before we send the first message. */
293 usleep(roughly(10000));
296 send_wildcard_retraction(ifp
);
299 FOR_ALL_INTERFACES(vrf
, ifp
) {
302 usleep(roughly(10000));
305 send_wildcard_retraction(ifp
);
306 send_self_update(ifp
);
307 send_request(ifp
, NULL
, 0);
313 /* Delete all the added babel routes, make babeld only speak to zebra. */
315 babel_clean_routing_process(void)
318 babel_interface_close_all();
321 if (babel_routing_process
->t_read
!= NULL
) {
322 thread_cancel(babel_routing_process
->t_read
);
324 if (babel_routing_process
->t_update
!= NULL
) {
325 thread_cancel(babel_routing_process
->t_update
);
328 distribute_list_delete(&babel_routing_process
->distribute_ctx
);
329 XFREE(MTYPE_BABEL
, babel_routing_process
);
332 /* Function used with timeout. */
334 babel_main_loop(struct thread
*thread
)
337 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
338 struct interface
*ifp
= NULL
;
343 /* timeouts --------------------------------------------------------- */
344 /* get the next timeout */
345 babel_fill_with_next_timeout(&tv
);
346 /* if there is no timeout, we must wait. */
347 if(timeval_compare(&tv
, &babel_now
) > 0) {
348 timeval_minus(&tv
, &tv
, &babel_now
);
349 debugf(BABEL_DEBUG_TIMEOUT
, "babel main loop : timeout: %lld msecs",
350 (long long)tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000);
351 /* it happens often to have less than 1 ms, it's bad. */
352 timeval_add_msec(&tv
, &tv
, 300);
353 babel_set_timer(&tv
);
359 /* update database -------------------------------------------------- */
360 if(timeval_compare(&check_neighbours_timeout
, &babel_now
) < 0) {
362 msecs
= check_neighbours();
363 /* Multiply by 3/2 to allow neighbours to expire. */
364 msecs
= MAX(3 * msecs
/ 2, 10);
365 schedule_neighbours_check(msecs
, 1);
368 if(babel_now
.tv_sec
>= expiry_time
) {
371 expiry_time
= babel_now
.tv_sec
+ roughly(30);
374 if(babel_now
.tv_sec
>= source_expiry_time
) {
376 source_expiry_time
= babel_now
.tv_sec
+ roughly(300);
379 FOR_ALL_INTERFACES(vrf
, ifp
) {
380 babel_interface_nfo
*babel_ifp
= NULL
;
383 babel_ifp
= babel_get_if_nfo(ifp
);
384 if(timeval_compare(&babel_now
, &babel_ifp
->hello_timeout
) >= 0)
386 if(timeval_compare(&babel_now
, &babel_ifp
->update_timeout
) >= 0)
387 send_update(ifp
, 0, NULL
, 0);
388 if(timeval_compare(&babel_now
,
389 &babel_ifp
->update_flush_timeout
) >= 0)
393 if(resend_time
.tv_sec
!= 0) {
394 if(timeval_compare(&babel_now
, &resend_time
) >= 0)
398 if(unicast_flush_timeout
.tv_sec
!= 0) {
399 if(timeval_compare(&babel_now
, &unicast_flush_timeout
) >= 0)
403 FOR_ALL_INTERFACES(vrf
, ifp
) {
404 babel_interface_nfo
*babel_ifp
= NULL
;
407 babel_ifp
= babel_get_if_nfo(ifp
);
408 if(babel_ifp
->flush_timeout
.tv_sec
!= 0) {
409 if(timeval_compare(&babel_now
, &babel_ifp
->flush_timeout
) >= 0)
415 assert(0); /* this line should never be reach */
420 printIfMin(struct timeval
*tv
, int cmd
, const char *tag
, const char *ifname
)
422 static struct timeval curr_tv
;
423 static char buffer
[200];
424 static const char *curr_tag
= NULL
;
427 case 0: /* reset timeval */
430 snprintf(buffer
, 200L, "interface: %s; %s", ifname
, tag
);
436 case 1: /* take the min */
437 if (tv
->tv_sec
== 0 && tv
->tv_usec
== 0) { /* if (tv == ∞) */
440 if (tv
->tv_sec
< curr_tv
.tv_sec
||(tv
->tv_sec
== curr_tv
.tv_sec
&&
441 tv
->tv_usec
< curr_tv
.tv_usec
)) {
444 snprintf(buffer
, 200L, "interface: %s; %s", ifname
, tag
);
451 case 2: /* print message */
452 debugf(BABEL_DEBUG_TIMEOUT
, "next timeout due to: %s", curr_tag
);
460 babel_fill_with_next_timeout(struct timeval
*tv
)
462 #if (defined NO_DEBUG)
463 #define printIfMin(a,b,c,d)
465 #define printIfMin(a,b,c,d) \
466 if (UNLIKELY(debug & BABEL_DEBUG_TIMEOUT)) {printIfMin(a,b,c,d);}
468 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
469 struct interface
*ifp
= NULL
;
471 *tv
= check_neighbours_timeout
;
472 printIfMin(tv
, 0, "check_neighbours_timeout", NULL
);
473 timeval_min_sec(tv
, expiry_time
);
474 printIfMin(tv
, 1, "expiry_time", NULL
);
475 timeval_min_sec(tv
, source_expiry_time
);
476 printIfMin(tv
, 1, "source_expiry_time", NULL
);
477 timeval_min(tv
, &resend_time
);
478 printIfMin(tv
, 1, "resend_time", NULL
);
479 FOR_ALL_INTERFACES(vrf
, ifp
) {
480 babel_interface_nfo
*babel_ifp
= NULL
;
483 babel_ifp
= babel_get_if_nfo(ifp
);
484 timeval_min(tv
, &babel_ifp
->flush_timeout
);
485 printIfMin(tv
, 1, "flush_timeout", ifp
->name
);
486 timeval_min(tv
, &babel_ifp
->hello_timeout
);
487 printIfMin(tv
, 1, "hello_timeout", ifp
->name
);
488 timeval_min(tv
, &babel_ifp
->update_timeout
);
489 printIfMin(tv
, 1, "update_timeout", ifp
->name
);
490 timeval_min(tv
, &babel_ifp
->update_flush_timeout
);
491 printIfMin(tv
, 1, "update_flush_timeout",ifp
->name
);
493 timeval_min(tv
, &unicast_flush_timeout
);
494 printIfMin(tv
, 1, "unicast_flush_timeout", NULL
);
495 printIfMin(tv
, 2, NULL
, NULL
);
500 /* set the t_update thread of the babel routing process to be launch in
501 'timeout' (approximate at the milisecond) */
503 babel_set_timer(struct timeval
*timeout
)
505 long msecs
= timeout
->tv_sec
* 1000 + timeout
->tv_usec
/ 1000;
506 if (babel_routing_process
->t_update
!= NULL
) {
507 thread_cancel(babel_routing_process
->t_update
);
509 thread_add_timer_msec(master
, babel_main_loop
, NULL
, msecs
, &babel_routing_process
->t_update
);
513 schedule_neighbours_check(int msecs
, int override
)
515 struct timeval timeout
;
517 timeval_add_msec(&timeout
, &babel_now
, msecs
);
519 check_neighbours_timeout
= timeout
;
521 timeval_min(&check_neighbours_timeout
, &timeout
);
525 resize_receive_buffer(int size
)
527 if(size
<= receive_buffer_size
)
530 if(receive_buffer
== NULL
) {
531 receive_buffer
= malloc(size
);
532 if(receive_buffer
== NULL
) {
533 flog_err(EC_BABEL_MEMORY
, "malloc(receive_buffer): %s",
534 safe_strerror(errno
));
537 receive_buffer_size
= size
;
540 new = realloc(receive_buffer
, size
);
542 flog_err(EC_BABEL_MEMORY
, "realloc(receive_buffer): %s",
543 safe_strerror(errno
));
546 receive_buffer
= new;
547 receive_buffer_size
= size
;
553 babel_distribute_update (struct distribute_ctx
*ctx
, struct distribute
*dist
)
555 struct interface
*ifp
;
556 babel_interface_nfo
*babel_ifp
;
563 ifp
= if_lookup_by_name (dist
->ifname
, VRF_DEFAULT
);
567 babel_ifp
= babel_get_if_nfo(ifp
);
569 for (type
= 0; type
< DISTRIBUTE_MAX
; type
++) {
570 family
= type
== DISTRIBUTE_V4_IN
|| type
== DISTRIBUTE_V4_OUT
?
572 if (dist
->list
[type
])
573 babel_ifp
->list
[type
] = access_list_lookup (family
,
576 babel_ifp
->list
[type
] = NULL
;
577 if (dist
->prefix
[type
])
578 babel_ifp
->prefix
[type
] = prefix_list_lookup (family
,
581 babel_ifp
->prefix
[type
] = NULL
;
586 babel_distribute_update_interface (struct interface
*ifp
)
588 struct distribute
*dist
= NULL
;
590 if (babel_routing_process
)
591 dist
= distribute_lookup(babel_routing_process
->distribute_ctx
, ifp
->name
);
593 babel_distribute_update (babel_routing_process
->distribute_ctx
, dist
);
596 /* Update all interface's distribute list. */
598 babel_distribute_update_all (struct prefix_list
*notused
)
600 struct vrf
*vrf
= vrf_lookup_by_id(VRF_DEFAULT
);
601 struct interface
*ifp
;
603 FOR_ALL_INTERFACES (vrf
, ifp
)
604 babel_distribute_update_interface (ifp
);
608 babel_distribute_update_all_wrapper (struct access_list
*notused
)
610 babel_distribute_update_all(NULL
);
615 DEFUN_NOSH (router_babel
,
618 "Enable a routing process\n"
619 "Make Babel instance command\n")
623 vty
->node
= BABEL_NODE
;
625 if (!babel_routing_process
) {
626 ret
= babel_create_routing_process ();
628 /* Notice to user we couldn't create Babel. */
630 zlog_warn ("can't create Babel");
639 DEFUN (no_router_babel
,
643 "Disable a routing process\n"
644 "Remove Babel instance command\n")
646 if(babel_routing_process
)
647 babel_clean_routing_process();
651 /* [Babel Command] */
652 DEFUN (babel_diversity
,
656 "Enable diversity-aware routing.\n")
658 diversity_kind
= DIVERSITY_CHANNEL
;
662 /* [Babel Command] */
663 DEFUN (no_babel_diversity
,
664 no_babel_diversity_cmd
,
665 "no babel diversity",
668 "Disable diversity-aware routing.\n")
670 diversity_kind
= DIVERSITY_NONE
;
674 /* [Babel Command] */
675 DEFUN (babel_diversity_factor
,
676 babel_diversity_factor_cmd
,
677 "babel diversity-factor (1-256)",
679 "Set the diversity factor.\n"
680 "Factor in units of 1/256.\n")
684 factor
= strtoul(argv
[2]->arg
, NULL
, 10);
686 diversity_factor
= factor
;
690 /* [Babel Command] */
691 DEFUN (babel_set_resend_delay
,
692 babel_set_resend_delay_cmd
,
693 "babel resend-delay (20-655340)",
695 "Time before resending a message\n"
700 interval
= strtoul(argv
[2]->arg
, NULL
, 10);
702 resend_delay
= interval
;
706 /* [Babel Command] */
707 DEFUN (babel_set_smoothing_half_life
,
708 babel_set_smoothing_half_life_cmd
,
709 "babel smoothing-half-life (0-65534)",
711 "Smoothing half-life\n"
712 "Seconds (0 to disable)\n")
716 seconds
= strtoul(argv
[2]->arg
, NULL
, 10);
718 change_smoothing_half_life(seconds
);
723 babeld_quagga_init(void)
726 install_node(&cmd_babel_node
);
728 install_element(CONFIG_NODE
, &router_babel_cmd
);
729 install_element(CONFIG_NODE
, &no_router_babel_cmd
);
731 install_default(BABEL_NODE
);
732 install_element(BABEL_NODE
, &babel_diversity_cmd
);
733 install_element(BABEL_NODE
, &no_babel_diversity_cmd
);
734 install_element(BABEL_NODE
, &babel_diversity_factor_cmd
);
735 install_element(BABEL_NODE
, &babel_set_resend_delay_cmd
);
736 install_element(BABEL_NODE
, &babel_set_smoothing_half_life_cmd
);
740 /* Access list install. */
742 access_list_add_hook (babel_distribute_update_all_wrapper
);
743 access_list_delete_hook (babel_distribute_update_all_wrapper
);
745 /* Prefix list initialize.*/
747 prefix_list_add_hook (babel_distribute_update_all
);
748 prefix_list_delete_hook (babel_distribute_update_all
);
750 /* Distribute list install. */
751 distribute_list_init(BABEL_NODE
);
754 /* Stubs to adapt Babel's filtering calls to Quagga's infrastructure. */
757 input_filter(const unsigned char *id
,
758 const unsigned char *prefix
, unsigned short plen
,
759 const unsigned char *neigh
, unsigned int ifindex
)
761 return babel_filter(0, prefix
, plen
, ifindex
);
765 output_filter(const unsigned char *id
, const unsigned char *prefix
,
766 unsigned short plen
, unsigned int ifindex
)
768 return babel_filter(1, prefix
, plen
, ifindex
);
771 /* There's no redistribute filter in Quagga -- the zebra daemon does its
774 redistribute_filter(const unsigned char *prefix
, unsigned short plen
,
775 unsigned int ifindex
, int proto
)
780 struct babel
*babel_lookup(void)
782 return babel_routing_process
;