1: /*
2: * This file is free software: you may copy, redistribute and/or modify it
3: * under the terms of the GNU General Public License as published by the
4: * Free Software Foundation, either version 2 of the License, or (at your
5: * option) any later version.
6: *
7: * This file is distributed in the hope that it will be useful, but
8: * WITHOUT ANY WARRANTY; without even the implied warranty of
9: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10: * General Public License for more details.
11: *
12: * You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: *
15: * This file incorporates work covered by the following copyright and
16: * permission notice:
17: *
18:
19: Copyright 2011 by Matthieu Boutier and Juliusz Chroboczek
20:
21: Permission is hereby granted, free of charge, to any person obtaining a copy
22: of this software and associated documentation files (the "Software"), to deal
23: in the Software without restriction, including without limitation the rights
24: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
25: copies of the Software, and to permit persons to whom the Software is
26: furnished to do so, subject to the following conditions:
27:
28: The above copyright notice and this permission notice shall be included in
29: all copies or substantial portions of the Software.
30:
31: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
32: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
33: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
34: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
35: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
36: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
37: THE SOFTWARE.
38: */
39:
40: #include <zebra.h>
41: #include "command.h"
42: #include "prefix.h"
43: #include "memory.h"
44: #include "memtypes.h"
45: #include "table.h"
46: #include "distribute.h"
47: #include "prefix.h"
48: #include "filter.h"
49: #include "plist.h"
50:
51: #include "babel_main.h"
52: #include "babeld.h"
53: #include "util.h"
54: #include "net.h"
55: #include "kernel.h"
56: #include "babel_interface.h"
57: #include "neighbour.h"
58: #include "route.h"
59: #include "message.h"
60: #include "resend.h"
61: #include "babel_filter.h"
62: #include "babel_zebra.h"
63:
64:
65: static int babel_init_routing_process(struct thread *thread);
66: static void babel_get_myid(void);
67: static void babel_initial_noise(void);
68: static int babel_read_protocol (struct thread *thread);
69: static int babel_main_loop(struct thread *thread);
70: static void babel_set_timer(struct timeval *timeout);
71: static void babel_fill_with_next_timeout(struct timeval *tv);
72:
73:
74: /* Informations relative to the babel running daemon. */
75: static struct babel *babel_routing_process = NULL;
76: static unsigned char *receive_buffer = NULL;
77: static int receive_buffer_size = 0;
78:
79: /* timeouts */
80: struct timeval check_neighbours_timeout;
81: static time_t expiry_time;
82: static time_t source_expiry_time;
83:
84: /* Babel node structure. */
85: static struct cmd_node cmd_babel_node =
86: {
87: .node = BABEL_NODE,
88: .prompt = "%s(config-router)# ",
89: .vtysh = 1,
90: };
91:
92: /* print current babel configuration on vty */
93: static int
94: babel_config_write (struct vty *vty)
95: {
96: int lines = 0;
97: int i;
98:
99: /* list enabled debug modes */
100: lines += debug_babel_config_write (vty);
101:
102: if (!babel_routing_process)
103: return lines;
104: vty_out (vty, "router babel%s", VTY_NEWLINE);
105: if (resend_delay != BABEL_DEFAULT_RESEND_DELAY)
106: {
107: vty_out (vty, " babel resend-delay %u%s", resend_delay, VTY_NEWLINE);
108: lines++;
109: }
110: /* list enabled interfaces */
111: lines = 1 + babel_enable_if_config_write (vty);
112: /* list redistributed protocols */
113: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
114: if (i != zclient->redist_default && zclient->redist[i])
115: {
116: vty_out (vty, " redistribute %s%s", zebra_route_string (i), VTY_NEWLINE);
117: lines++;
118: }
119:
120: return lines;
121: }
122:
123:
124: static int
125: babel_create_routing_process (void)
126: {
127: assert (babel_routing_process == NULL);
128:
129: /* Allocaste Babel instance. */
130: babel_routing_process = XCALLOC (MTYPE_BABEL, sizeof (struct babel));
131:
132: /* Initialize timeouts */
133: gettime(&babel_now);
134: expiry_time = babel_now.tv_sec + roughly(30);
135: source_expiry_time = babel_now.tv_sec + roughly(300);
136:
137: /* Make socket for Babel protocol. */
138: protocol_socket = babel_socket(protocol_port);
139: if (protocol_socket < 0) {
140: zlog_err("Couldn't create link local socket: %s", safe_strerror(errno));
141: goto fail;
142: }
143:
144: /* Threads. */
145: babel_routing_process->t_read =
146: thread_add_read(master, &babel_read_protocol, NULL, protocol_socket);
147: /* wait a little: zebra will announce interfaces, addresses, routes... */
148: babel_routing_process->t_update =
149: thread_add_timer_msec(master, &babel_init_routing_process, NULL, 200L);
150: return 0;
151:
152: fail:
153: XFREE(MTYPE_BABEL, babel_routing_process);
154: babel_routing_process = NULL;
155: return -1;
156: }
157:
158: /* thread reading entries form others babel daemons */
159: static int
160: babel_read_protocol (struct thread *thread)
161: {
162: int rc;
163: struct interface *ifp = NULL;
164: struct sockaddr_in6 sin6;
165: struct listnode *linklist_node = NULL;
166:
167: assert(babel_routing_process != NULL);
168: assert(protocol_socket >= 0);
169:
170: rc = babel_recv(protocol_socket,
171: receive_buffer, receive_buffer_size,
172: (struct sockaddr*)&sin6, sizeof(sin6));
173: if(rc < 0) {
174: if(errno != EAGAIN && errno != EINTR) {
175: zlog_err("recv: %s", safe_strerror(errno));
176: }
177: } else {
178: FOR_ALL_INTERFACES(ifp, linklist_node) {
179: if(!if_up(ifp))
180: continue;
181: if(ifp->ifindex == sin6.sin6_scope_id) {
182: parse_packet((unsigned char*)&sin6.sin6_addr, ifp,
183: receive_buffer, rc);
184: break;
185: }
186: }
187: }
188:
189: /* re-add thread */
190: babel_routing_process->t_read =
191: thread_add_read(master, &babel_read_protocol, NULL, protocol_socket);
192: return 0;
193: }
194:
195: /* Zebra will give some information, especially about interfaces. This function
196: must be call with a litte timeout wich may give zebra the time to do his job,
197: making these inits have sense. */
198: static int
199: babel_init_routing_process(struct thread *thread)
200: {
201: myseqno = (random() & 0xFFFF);
202: babel_get_myid();
203: babel_load_state_file();
204: debugf(BABEL_DEBUG_COMMON, "My ID is : %s.", format_eui64(myid));
205: babel_initial_noise();
206: babel_main_loop(thread);/* this function self-add to the t_update thread */
207: return 0;
208: }
209:
210: /* fill "myid" with an unique id (only if myid != {0}). */
211: static void
212: babel_get_myid(void)
213: {
214: struct interface *ifp = NULL;
215: struct listnode *linklist_node = NULL;
216: int rc;
217: int i;
218:
219: /* if we already have an id (from state file), we return. */
220: if (memcmp(myid, zeroes, 8) != 0) {
221: return;
222: }
223:
224: FOR_ALL_INTERFACES(ifp, linklist_node) {
225: /* ifp->ifindex is not necessarily valid at this point */
226: int ifindex = if_nametoindex(ifp->name);
227: if(ifindex > 0) {
228: unsigned char eui[8];
229: rc = if_eui64(ifp->name, ifindex, eui);
230: if(rc < 0)
231: continue;
232: memcpy(myid, eui, 8);
233: return;
234: }
235: }
236:
237: /* We failed to get a global EUI64 from the interfaces we were given.
238: Let's try to find an interface with a MAC address. */
239: for(i = 1; i < 256; i++) {
240: char buf[IF_NAMESIZE], *ifname;
241: unsigned char eui[8];
242: ifname = if_indextoname(i, buf);
243: if(ifname == NULL)
244: continue;
245: rc = if_eui64(ifname, i, eui);
246: if(rc < 0)
247: continue;
248: memcpy(myid, eui, 8);
249: return;
250: }
251:
252: zlog_err("Warning: couldn't find router id -- using random value.");
253:
254: rc = read_random_bytes(myid, 8);
255: if(rc < 0) {
256: zlog_err("read(random): %s (cannot assign an ID)",safe_strerror(errno));
257: exit(1);
258: }
259: /* Clear group and global bits */
260: myid[0] &= ~3;
261: }
262:
263: /* Make some noise so that others notice us, and send retractions in
264: case we were restarted recently */
265: static void
266: babel_initial_noise(void)
267: {
268: struct interface *ifp = NULL;
269: struct listnode *linklist_node = NULL;
270:
271: FOR_ALL_INTERFACES(ifp, linklist_node) {
272: if(!if_up(ifp))
273: continue;
274: /* Apply jitter before we send the first message. */
275: usleep(roughly(10000));
276: gettime(&babel_now);
277: send_hello(ifp);
278: send_wildcard_retraction(ifp);
279: }
280:
281: FOR_ALL_INTERFACES(ifp, linklist_node) {
282: if(!if_up(ifp))
283: continue;
284: usleep(roughly(10000));
285: gettime(&babel_now);
286: send_hello(ifp);
287: send_wildcard_retraction(ifp);
288: send_self_update(ifp);
289: send_request(ifp, NULL, 0);
290: flushupdates(ifp);
291: flushbuf(ifp);
292: }
293: }
294:
295: /* Delete all the added babel routes, make babeld only speak to zebra. */
296: static void
297: babel_clean_routing_process()
298: {
299: flush_all_routes();
300: babel_interface_close_all();
301:
302: /* cancel threads */
303: if (babel_routing_process->t_read != NULL) {
304: thread_cancel(babel_routing_process->t_read);
305: }
306: if (babel_routing_process->t_update != NULL) {
307: thread_cancel(babel_routing_process->t_update);
308: }
309:
310: XFREE(MTYPE_BABEL, babel_routing_process);
311: babel_routing_process = NULL;
312: }
313:
314: /* Function used with timeout. */
315: static int
316: babel_main_loop(struct thread *thread)
317: {
318: struct timeval tv;
319: struct interface *ifp = NULL;
320: struct listnode *linklist_node = NULL;
321:
322: while(1) {
323: gettime(&babel_now);
324:
325: /* timeouts --------------------------------------------------------- */
326: /* get the next timeout */
327: babel_fill_with_next_timeout(&tv);
328: /* if there is no timeout, we must wait. */
329: if(timeval_compare(&tv, &babel_now) > 0) {
330: timeval_minus(&tv, &tv, &babel_now);
331: debugf(BABEL_DEBUG_TIMEOUT, "babel main loop : timeout: %ld msecs",
332: tv.tv_sec * 1000 + tv.tv_usec / 1000);
333: /* it happens often to have less than 1 ms, it's bad. */
334: timeval_add_msec(&tv, &tv, 300);
335: babel_set_timer(&tv);
336: return 0;
337: }
338:
339: gettime(&babel_now);
340:
341: /* update database -------------------------------------------------- */
342: if(timeval_compare(&check_neighbours_timeout, &babel_now) < 0) {
343: int msecs;
344: msecs = check_neighbours();
345: msecs = MAX(msecs, 10);
346: schedule_neighbours_check(msecs, 1);
347: }
348:
349: if(babel_now.tv_sec >= expiry_time) {
350: expire_routes();
351: expire_resend();
352: expiry_time = babel_now.tv_sec + roughly(30);
353: }
354:
355: if(babel_now.tv_sec >= source_expiry_time) {
356: expire_sources();
357: source_expiry_time = babel_now.tv_sec + roughly(300);
358: }
359:
360: FOR_ALL_INTERFACES(ifp, linklist_node) {
361: babel_interface_nfo *babel_ifp = NULL;
362: if(!if_up(ifp))
363: continue;
364: babel_ifp = babel_get_if_nfo(ifp);
365: if(timeval_compare(&babel_now, &babel_ifp->hello_timeout) >= 0)
366: send_hello(ifp);
367: if(timeval_compare(&babel_now, &babel_ifp->update_timeout) >= 0)
368: send_update(ifp, 0, NULL, 0);
369: if(timeval_compare(&babel_now,
370: &babel_ifp->update_flush_timeout) >= 0)
371: flushupdates(ifp);
372: }
373:
374: if(resend_time.tv_sec != 0) {
375: if(timeval_compare(&babel_now, &resend_time) >= 0)
376: do_resend();
377: }
378:
379: if(unicast_flush_timeout.tv_sec != 0) {
380: if(timeval_compare(&babel_now, &unicast_flush_timeout) >= 0)
381: flush_unicast(1);
382: }
383:
384: FOR_ALL_INTERFACES(ifp, linklist_node) {
385: babel_interface_nfo *babel_ifp = NULL;
386: if(!if_up(ifp))
387: continue;
388: babel_ifp = babel_get_if_nfo(ifp);
389: if(babel_ifp->flush_timeout.tv_sec != 0) {
390: if(timeval_compare(&babel_now, &babel_ifp->flush_timeout) >= 0)
391: flushbuf(ifp);
392: }
393: }
394: }
395:
396: assert(0); /* this line should never be reach */
397: }
398:
399: static void
400: printIfMin(struct timeval *tv, int cmd, const char *tag, const char *ifname)
401: {
402: static struct timeval curr_tv;
403: static char buffer[200];
404: static const char *curr_tag = NULL;
405:
406: switch (cmd) {
407: case 0: /* reset timeval */
408: curr_tv = *tv;
409: if(ifname != NULL) {
410: snprintf(buffer, 200L, "interface: %s; %s", ifname, tag);
411: curr_tag = buffer;
412: } else {
413: curr_tag = tag;
414: }
415: break;
416: case 1: /* take the min */
417: if (tv->tv_sec == 0 && tv->tv_usec == 0) { /* if (tv == ∞) */
418: break;
419: }
420: if (tv->tv_sec < curr_tv.tv_sec ||(tv->tv_sec == curr_tv.tv_sec &&
421: tv->tv_usec < curr_tv.tv_usec)) {
422: curr_tv = *tv;
423: if(ifname != NULL) {
424: snprintf(buffer, 200L, "interface: %s; %s", ifname, tag);
425: curr_tag = buffer;
426: } else {
427: curr_tag = tag;
428: }
429: }
430: break;
431: case 2: /* print message */
432: debugf(BABEL_DEBUG_TIMEOUT, "next timeout due to: %s", curr_tag);
433: break;
434: default:
435: break;
436: }
437: }
438:
439: static void
440: babel_fill_with_next_timeout(struct timeval *tv)
441: {
442: #if (defined NO_DEBUG)
443: #define printIfMin(a,b,c,d)
444: #else
445: #define printIfMin(a,b,c,d) \
446: if (UNLIKELY(debug & BABEL_DEBUG_TIMEOUT)) {printIfMin(a,b,c,d);}
447:
448: struct interface *ifp = NULL;
449: struct listnode *linklist_node = NULL;
450:
451: *tv = check_neighbours_timeout;
452: printIfMin(tv, 0, "check_neighbours_timeout", NULL);
453: timeval_min_sec(tv, expiry_time);
454: printIfMin(tv, 1, "expiry_time", NULL);
455: timeval_min_sec(tv, source_expiry_time);
456: printIfMin(tv, 1, "source_expiry_time", NULL);
457: timeval_min(tv, &resend_time);
458: printIfMin(tv, 1, "resend_time", NULL);
459: FOR_ALL_INTERFACES(ifp, linklist_node) {
460: babel_interface_nfo *babel_ifp = NULL;
461: if(!if_up(ifp))
462: continue;
463: babel_ifp = babel_get_if_nfo(ifp);
464: timeval_min(tv, &babel_ifp->flush_timeout);
465: printIfMin(tv, 1, "flush_timeout", ifp->name);
466: timeval_min(tv, &babel_ifp->hello_timeout);
467: printIfMin(tv, 1, "hello_timeout", ifp->name);
468: timeval_min(tv, &babel_ifp->update_timeout);
469: printIfMin(tv, 1, "update_timeout", ifp->name);
470: timeval_min(tv, &babel_ifp->update_flush_timeout);
471: printIfMin(tv, 1, "update_flush_timeout",ifp->name);
472: }
473: timeval_min(tv, &unicast_flush_timeout);
474: printIfMin(tv, 1, "unicast_flush_timeout", NULL);
475: printIfMin(tv, 2, NULL, NULL);
476: #undef printIfMin
477: #endif
478: }
479:
480: /* set the t_update thread of the babel routing process to be launch in
481: 'timeout' (approximate at the milisecond) */
482: static void
483: babel_set_timer(struct timeval *timeout)
484: {
485: long msecs = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
486: if (babel_routing_process->t_update != NULL) {
487: thread_cancel(babel_routing_process->t_update);
488: }
489: babel_routing_process->t_update =
490: thread_add_timer_msec(master, &babel_main_loop, NULL, msecs);
491: }
492:
493: /* Schedule a neighbours check after roughly 3/2 times msecs have elapsed. */
494: void
495: schedule_neighbours_check(int msecs, int override)
496: {
497: struct timeval timeout;
498:
499: timeval_add_msec(&timeout, &babel_now, roughly(msecs * 3 / 2));
500: if(override)
501: check_neighbours_timeout = timeout;
502: else
503: timeval_min(&check_neighbours_timeout, &timeout);
504: }
505:
506: int
507: resize_receive_buffer(int size)
508: {
509: if(size <= receive_buffer_size)
510: return 0;
511:
512: if(receive_buffer == NULL) {
513: receive_buffer = malloc(size);
514: if(receive_buffer == NULL) {
515: zlog_err("malloc(receive_buffer): %s", safe_strerror(errno));
516: return -1;
517: }
518: receive_buffer_size = size;
519: } else {
520: unsigned char *new;
521: new = realloc(receive_buffer, size);
522: if(new == NULL) {
523: zlog_err("realloc(receive_buffer): %s", safe_strerror(errno));
524: return -1;
525: }
526: receive_buffer = new;
527: receive_buffer_size = size;
528: }
529: return 1;
530: }
531:
532: static void
533: babel_distribute_update (struct distribute *dist)
534: {
535: struct interface *ifp;
536: babel_interface_nfo *babel_ifp;
537: struct access_list *alist;
538: struct prefix_list *plist;
539:
540: if (! dist->ifname)
541: return;
542:
543: ifp = if_lookup_by_name (dist->ifname);
544: if (ifp == NULL)
545: return;
546:
547: babel_ifp = babel_get_if_nfo(ifp);
548:
549: if (dist->list[DISTRIBUTE_IN]) {
550: alist = access_list_lookup (AFI_IP6, dist->list[DISTRIBUTE_IN]);
551: if (alist)
552: babel_ifp->list[BABEL_FILTER_IN] = alist;
553: else
554: babel_ifp->list[BABEL_FILTER_IN] = NULL;
555: } else {
556: babel_ifp->list[BABEL_FILTER_IN] = NULL;
557: }
558:
559: if (dist->list[DISTRIBUTE_OUT]) {
560: alist = access_list_lookup (AFI_IP6, dist->list[DISTRIBUTE_OUT]);
561: if (alist)
562: babel_ifp->list[BABEL_FILTER_OUT] = alist;
563: else
564: babel_ifp->list[BABEL_FILTER_OUT] = NULL;
565: } else {
566: babel_ifp->list[BABEL_FILTER_OUT] = NULL;
567: }
568:
569: if (dist->prefix[DISTRIBUTE_IN]) {
570: plist = prefix_list_lookup (AFI_IP6, dist->prefix[DISTRIBUTE_IN]);
571: if (plist)
572: babel_ifp->prefix[BABEL_FILTER_IN] = plist;
573: else
574: babel_ifp->prefix[BABEL_FILTER_IN] = NULL;
575: } else {
576: babel_ifp->prefix[BABEL_FILTER_IN] = NULL;
577: }
578:
579: if (dist->prefix[DISTRIBUTE_OUT]) {
580: plist = prefix_list_lookup (AFI_IP6, dist->prefix[DISTRIBUTE_OUT]);
581: if (plist)
582: babel_ifp->prefix[BABEL_FILTER_OUT] = plist;
583: else
584: babel_ifp->prefix[BABEL_FILTER_OUT] = NULL;
585: } else {
586: babel_ifp->prefix[BABEL_FILTER_OUT] = NULL;
587: }
588: }
589:
590: static void
591: babel_distribute_update_interface (struct interface *ifp)
592: {
593: struct distribute *dist;
594:
595: dist = distribute_lookup (ifp->name);
596: if (dist)
597: babel_distribute_update (dist);
598: }
599:
600: /* Update all interface's distribute list. */
601: static void
602: babel_distribute_update_all (struct prefix_list *notused)
603: {
604: struct interface *ifp;
605: struct listnode *node;
606:
607: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
608: babel_distribute_update_interface (ifp);
609: }
610:
611: static void
612: babel_distribute_update_all_wrapper (struct access_list *notused)
613: {
614: babel_distribute_update_all(NULL);
615: }
616:
617:
618: /* [Command] */
619: DEFUN (router_babel,
620: router_babel_cmd,
621: "router babel",
622: "Enable a routing process\n"
623: "Make Babel instance command\n"
624: "No attributes\n")
625: {
626: int ret;
627:
628: vty->node = BABEL_NODE;
629:
630: if (!babel_routing_process) {
631: ret = babel_create_routing_process ();
632:
633: /* Notice to user we couldn't create Babel. */
634: if (ret < 0) {
635: zlog_warn ("can't create Babel");
636: return CMD_WARNING;
637: }
638: }
639:
640: return CMD_SUCCESS;
641: }
642:
643: /* [Command] */
644: DEFUN (no_router_babel,
645: no_router_babel_cmd,
646: "no router babel",
647: NO_STR
648: "Disable a routing process\n"
649: "Remove Babel instance command\n"
650: "No attributes\n")
651: {
652: if(babel_routing_process)
653: babel_clean_routing_process();
654: return CMD_SUCCESS;
655: }
656:
657: /* [Babel Command] */
658: DEFUN (babel_set_resend_delay,
659: babel_set_resend_delay_cmd,
660: "babel resend-delay <20-655340>",
661: "Babel commands\n"
662: "Time before resending a message\n"
663: "Milliseconds\n")
664: {
665: int interval;
666:
667: VTY_GET_INTEGER_RANGE("milliseconds", interval, argv[0], 20, 10 * 0xFFFE);
668:
669: resend_delay = interval;
670: return CMD_SUCCESS;
671: }
672:
673: void
674: babeld_quagga_init(void)
675: {
676:
677: install_node(&cmd_babel_node, &babel_config_write);
678:
679: install_element(CONFIG_NODE, &router_babel_cmd);
680: install_element(CONFIG_NODE, &no_router_babel_cmd);
681:
682: install_default(BABEL_NODE);
683: install_element(BABEL_NODE, &babel_set_resend_delay_cmd);
684:
685: babel_if_init();
686:
687: /* Access list install. */
688: access_list_init ();
689: access_list_add_hook (babel_distribute_update_all_wrapper);
690: access_list_delete_hook (babel_distribute_update_all_wrapper);
691:
692: /* Prefix list initialize.*/
693: prefix_list_init ();
694: prefix_list_add_hook (babel_distribute_update_all);
695: prefix_list_delete_hook (babel_distribute_update_all);
696:
697: /* Distribute list install. */
698: distribute_list_init (BABEL_NODE);
699: distribute_list_add_hook (babel_distribute_update);
700: distribute_list_delete_hook (babel_distribute_update);
701: }
702:
703: /* Stubs to adapt Babel's filtering calls to Quagga's infrastructure. */
704:
705: int
706: input_filter(const unsigned char *id,
707: const unsigned char *prefix, unsigned short plen,
708: const unsigned char *neigh, unsigned int ifindex)
709: {
710: return babel_filter(0, prefix, plen, ifindex);
711: }
712:
713: int
714: output_filter(const unsigned char *id, const unsigned char *prefix,
715: unsigned short plen, unsigned int ifindex)
716: {
717: return babel_filter(1, prefix, plen, ifindex);
718: }
719:
720: /* There's no redistribute filter in Quagga -- the zebra daemon does its
721: own filtering. */
722: int
723: redistribute_filter(const unsigned char *prefix, unsigned short plen,
724: unsigned int ifindex, int proto)
725: {
726: return 0;
727: }
728:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to babeld.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / babeld