Annotation of embedaddon/quagga/ospf6d/ospf6_zebra.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2003 Yasuhiro Ohara
3: *
4: * This file is part of GNU Zebra.
5: *
6: * GNU Zebra is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2, or (at your option) any
9: * later version.
10: *
11: * GNU Zebra is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of
13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: * General Public License for more details.
15: *
16: * You should have received a copy of the GNU General Public License
17: * along with GNU Zebra; see the file COPYING. If not, write to the
18: * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19: * Boston, MA 02111-1307, USA.
20: */
21:
22: #include <zebra.h>
23:
24: #include "log.h"
25: #include "vty.h"
26: #include "command.h"
27: #include "prefix.h"
28: #include "stream.h"
29: #include "zclient.h"
30: #include "memory.h"
31:
32: #include "ospf6_proto.h"
33: #include "ospf6_top.h"
34: #include "ospf6_interface.h"
35: #include "ospf6_route.h"
36: #include "ospf6_lsa.h"
37: #include "ospf6_lsdb.h"
38: #include "ospf6_asbr.h"
39: #include "ospf6_zebra.h"
40: #include "ospf6d.h"
41:
42: unsigned char conf_debug_ospf6_zebra = 0;
43:
44: /* information about zebra. */
45: struct zclient *zclient = NULL;
46:
47: struct in_addr router_id_zebra;
48:
49: /* Router-id update message from zebra. */
50: static int
51: ospf6_router_id_update_zebra (int command, struct zclient *zclient,
52: zebra_size_t length)
53: {
54: struct prefix router_id;
55: struct ospf6 *o = ospf6;
56:
57: zebra_router_id_update_read(zclient->ibuf,&router_id);
58: router_id_zebra = router_id.u.prefix4;
59:
60: if (o == NULL)
61: return 0;
62:
63: if (o->router_id == 0)
64: o->router_id = (u_int32_t) router_id_zebra.s_addr;
65:
66: return 0;
67: }
68:
69: /* redistribute function */
70: void
71: ospf6_zebra_redistribute (int type)
72: {
73: if (zclient->redist[type])
74: return;
75: zclient->redist[type] = 1;
76: if (zclient->sock > 0)
77: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
78: }
79:
80: void
81: ospf6_zebra_no_redistribute (int type)
82: {
83: if (! zclient->redist[type])
84: return;
85: zclient->redist[type] = 0;
86: if (zclient->sock > 0)
87: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
88: }
89:
90: /* Inteface addition message from zebra. */
91: static int
92: ospf6_zebra_if_add (int command, struct zclient *zclient, zebra_size_t length)
93: {
94: struct interface *ifp;
95:
96: ifp = zebra_interface_add_read (zclient->ibuf);
97: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
98: zlog_debug ("Zebra Interface add: %s index %d mtu %d",
99: ifp->name, ifp->ifindex, ifp->mtu6);
100: ospf6_interface_if_add (ifp);
101: return 0;
102: }
103:
104: static int
105: ospf6_zebra_if_del (int command, struct zclient *zclient, zebra_size_t length)
106: {
107: struct interface *ifp;
108:
109: if (!(ifp = zebra_interface_state_read(zclient->ibuf)))
110: return 0;
111:
112: if (if_is_up (ifp))
113: zlog_warn ("Zebra: got delete of %s, but interface is still up", ifp->name);
114:
115: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
116: zlog_debug ("Zebra Interface delete: %s index %d mtu %d",
117: ifp->name, ifp->ifindex, ifp->mtu6);
118:
119: #if 0
120: /* Why is this commented out? */
121: ospf6_interface_if_del (ifp);
122: #endif /*0*/
123:
124: ifp->ifindex = IFINDEX_INTERNAL;
125: return 0;
126: }
127:
128: static int
129: ospf6_zebra_if_state_update (int command, struct zclient *zclient,
130: zebra_size_t length)
131: {
132: struct interface *ifp;
133:
134: ifp = zebra_interface_state_read (zclient->ibuf);
135: if (ifp == NULL)
136: return 0;
137:
138: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
139: zlog_debug ("Zebra Interface state change: "
140: "%s index %d flags %llx metric %d mtu %d",
141: ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
142: ifp->metric, ifp->mtu6);
143:
144: ospf6_interface_state_update (ifp);
145: return 0;
146: }
147:
148: static int
149: ospf6_zebra_if_address_update_add (int command, struct zclient *zclient,
150: zebra_size_t length)
151: {
152: struct connected *c;
153: char buf[128];
154:
155: c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD, zclient->ibuf);
156: if (c == NULL)
157: return 0;
158:
159: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
160: zlog_debug ("Zebra Interface address add: %s %5s %s/%d",
161: c->ifp->name, prefix_family_str (c->address),
162: inet_ntop (c->address->family, &c->address->u.prefix,
163: buf, sizeof (buf)), c->address->prefixlen);
164:
165: if (c->address->family == AF_INET6)
166: ospf6_interface_connected_route_update (c->ifp);
167:
168: return 0;
169: }
170:
171: static int
172: ospf6_zebra_if_address_update_delete (int command, struct zclient *zclient,
173: zebra_size_t length)
174: {
175: struct connected *c;
176: char buf[128];
177:
178: c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE, zclient->ibuf);
179: if (c == NULL)
180: return 0;
181:
182: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
183: zlog_debug ("Zebra Interface address delete: %s %5s %s/%d",
184: c->ifp->name, prefix_family_str (c->address),
185: inet_ntop (c->address->family, &c->address->u.prefix,
186: buf, sizeof (buf)), c->address->prefixlen);
187:
188: if (c->address->family == AF_INET6)
189: ospf6_interface_connected_route_update (c->ifp);
190:
191: return 0;
192: }
193:
194: static int
195: ospf6_zebra_read_ipv6 (int command, struct zclient *zclient,
196: zebra_size_t length)
197: {
198: struct stream *s;
199: struct zapi_ipv6 api;
200: unsigned long ifindex;
201: struct prefix_ipv6 p;
202: struct in6_addr *nexthop;
203:
204: s = zclient->ibuf;
205: ifindex = 0;
206: nexthop = NULL;
207: memset (&api, 0, sizeof (api));
208:
209: /* Type, flags, message. */
210: api.type = stream_getc (s);
211: api.flags = stream_getc (s);
212: api.message = stream_getc (s);
213:
214: /* IPv6 prefix. */
215: memset (&p, 0, sizeof (struct prefix_ipv6));
216: p.family = AF_INET6;
217: p.prefixlen = stream_getc (s);
218: stream_get (&p.prefix, s, PSIZE (p.prefixlen));
219:
220: /* Nexthop, ifindex, distance, metric. */
221: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
222: {
223: api.nexthop_num = stream_getc (s);
224: nexthop = (struct in6_addr *)
225: malloc (api.nexthop_num * sizeof (struct in6_addr));
226: stream_get (nexthop, s, api.nexthop_num * sizeof (struct in6_addr));
227: }
228: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
229: {
230: api.ifindex_num = stream_getc (s);
231: ifindex = stream_getl (s);
232: }
233: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
234: api.distance = stream_getc (s);
235: else
236: api.distance = 0;
237: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
238: api.metric = stream_getl (s);
239: else
240: api.metric = 0;
241:
242: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
243: {
244: char prefixstr[128], nexthopstr[128];
245: prefix2str ((struct prefix *)&p, prefixstr, sizeof (prefixstr));
246: if (nexthop)
247: inet_ntop (AF_INET6, nexthop, nexthopstr, sizeof (nexthopstr));
248: else
249: snprintf (nexthopstr, sizeof (nexthopstr), "::");
250:
251: zlog_debug ("Zebra Receive route %s: %s %s nexthop %s ifindex %ld",
252: (command == ZEBRA_IPV6_ROUTE_ADD ? "add" : "delete"),
253: zebra_route_string(api.type), prefixstr, nexthopstr, ifindex);
254: }
255:
256: if (command == ZEBRA_IPV6_ROUTE_ADD)
257: ospf6_asbr_redistribute_add (api.type, ifindex, (struct prefix *) &p,
258: api.nexthop_num, nexthop);
259: else
260: ospf6_asbr_redistribute_remove (api.type, ifindex, (struct prefix *) &p);
261:
262: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
263: free (nexthop);
264:
265: return 0;
266: }
267:
268:
269:
270:
271: DEFUN (show_zebra,
272: show_zebra_cmd,
273: "show zebra",
274: SHOW_STR
275: "Zebra information\n")
276: {
277: int i;
278: if (zclient == NULL)
279: {
280: vty_out (vty, "Not connected to zebra%s", VNL);
281: return CMD_SUCCESS;
282: }
283:
284: vty_out (vty, "Zebra Infomation%s", VNL);
285: vty_out (vty, " enable: %d fail: %d%s",
286: zclient->enable, zclient->fail, VNL);
287: vty_out (vty, " redistribute default: %d%s", zclient->redist_default,
288: VNL);
289: vty_out (vty, " redistribute:");
290: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
291: {
292: if (zclient->redist[i])
293: vty_out (vty, " %s", zebra_route_string(i));
294: }
295: vty_out (vty, "%s", VNL);
296: return CMD_SUCCESS;
297: }
298:
299: DEFUN (router_zebra,
300: router_zebra_cmd,
301: "router zebra",
302: "Enable a routing process\n"
303: "Make connection to zebra daemon\n")
304: {
305: vty->node = ZEBRA_NODE;
306: zclient->enable = 1;
307: zclient_start (zclient);
308: return CMD_SUCCESS;
309: }
310:
311: DEFUN (no_router_zebra,
312: no_router_zebra_cmd,
313: "no router zebra",
314: NO_STR
315: "Configure routing process\n"
316: "Disable connection to zebra daemon\n")
317: {
318: zclient->enable = 0;
319: zclient_stop (zclient);
320: return CMD_SUCCESS;
321: }
322:
323: /* Zebra configuration write function. */
324: static int
325: config_write_ospf6_zebra (struct vty *vty)
326: {
327: if (! zclient->enable)
328: {
329: vty_out (vty, "no router zebra%s", VNL);
330: vty_out (vty, "!%s", VNL);
331: }
332: else if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
333: {
334: vty_out (vty, "router zebra%s", VNL);
335: vty_out (vty, " no redistribute ospf6%s", VNL);
336: vty_out (vty, "!%s", VNL);
337: }
338: return 0;
339: }
340:
341: /* Zebra node structure. */
342: static struct cmd_node zebra_node =
343: {
344: ZEBRA_NODE,
345: "%s(config-zebra)# ",
346: };
347:
348: #define ADD 0
349: #define REM 1
350: static void
351: ospf6_zebra_route_update (int type, struct ospf6_route *request)
352: {
353: struct zapi_ipv6 api;
354: char buf[64];
355: int nhcount;
356: struct in6_addr **nexthops;
357: unsigned int *ifindexes;
358: int i, ret = 0;
359: struct prefix_ipv6 *dest;
360:
361: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
362: {
363: prefix2str (&request->prefix, buf, sizeof (buf));
364: zlog_debug ("Send %s route: %s",
365: (type == REM ? "remove" : "add"), buf);
366: }
367:
368: if (zclient->sock < 0)
369: {
370: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
371: zlog_debug (" Not connected to Zebra");
372: return;
373: }
374:
375: if (request->path.origin.adv_router == ospf6->router_id &&
376: (request->path.type == OSPF6_PATH_TYPE_EXTERNAL1 ||
377: request->path.type == OSPF6_PATH_TYPE_EXTERNAL2))
378: {
379: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
380: zlog_debug (" Ignore self-originated external route");
381: return;
382: }
383:
384: /* If removing is the best path and if there's another path,
385: treat this request as add the secondary path */
386: if (type == REM && ospf6_route_is_best (request) &&
387: request->next && ospf6_route_is_same (request, request->next))
388: {
389: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
390: zlog_debug (" Best-path removal resulted Sencondary addition");
391: type = ADD;
392: request = request->next;
393: }
394:
395: /* Only the best path will be sent to zebra. */
396: if (! ospf6_route_is_best (request))
397: {
398: /* this is not preferred best route, ignore */
399: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
400: zlog_debug (" Ignore non-best route");
401: return;
402: }
403:
404: nhcount = 0;
405: for (i = 0; i < OSPF6_MULTI_PATH_LIMIT; i++)
406: if (ospf6_nexthop_is_set (&request->nexthop[i]))
407: nhcount++;
408:
409: if (nhcount == 0)
410: {
411: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
412: zlog_debug (" No nexthop, ignore");
413: return;
414: }
415:
416: /* allocate memory for nexthop_list */
417: nexthops = XCALLOC (MTYPE_OSPF6_OTHER,
418: nhcount * sizeof (struct in6_addr *));
419: if (nexthops == NULL)
420: {
421: zlog_warn ("Can't send route to zebra: malloc failed");
422: return;
423: }
424:
425: /* allocate memory for ifindex_list */
426: ifindexes = XCALLOC (MTYPE_OSPF6_OTHER,
427: nhcount * sizeof (unsigned int));
428: if (ifindexes == NULL)
429: {
430: zlog_warn ("Can't send route to zebra: malloc failed");
431: XFREE (MTYPE_OSPF6_OTHER, nexthops);
432: return;
433: }
434:
435: for (i = 0; i < nhcount; i++)
436: {
437: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
438: {
439: char ifname[IFNAMSIZ];
440: inet_ntop (AF_INET6, &request->nexthop[i].address,
441: buf, sizeof (buf));
442: if (!if_indextoname(request->nexthop[i].ifindex, ifname))
443: strlcpy(ifname, "unknown", sizeof(ifname));
444: zlog_debug (" nexthop: %s%%%.*s(%d)", buf, IFNAMSIZ, ifname,
445: request->nexthop[i].ifindex);
446: }
447: nexthops[i] = &request->nexthop[i].address;
448: ifindexes[i] = request->nexthop[i].ifindex;
449: }
450:
451: api.type = ZEBRA_ROUTE_OSPF6;
452: api.flags = 0;
453: api.message = 0;
454: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
455: api.nexthop_num = nhcount;
456: api.nexthop = nexthops;
457: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
458: api.ifindex_num = nhcount;
459: api.ifindex = ifindexes;
460: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
461: api.metric = (request->path.metric_type == 2 ?
462: request->path.cost_e2 : request->path.cost);
463:
464: dest = (struct prefix_ipv6 *) &request->prefix;
465: if (type == REM)
466: ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api);
467: else
468: ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api);
469:
470: if (ret < 0)
471: zlog_err ("zapi_ipv6_route() %s failed: %s",
472: (type == REM ? "delete" : "add"), safe_strerror (errno));
473:
474: XFREE (MTYPE_OSPF6_OTHER, nexthops);
475: XFREE (MTYPE_OSPF6_OTHER, ifindexes);
476:
477: return;
478: }
479:
480: void
481: ospf6_zebra_route_update_add (struct ospf6_route *request)
482: {
483: if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
484: {
485: ospf6->route_table->hook_add = NULL;
486: ospf6->route_table->hook_remove = NULL;
487: return;
488: }
489: ospf6_zebra_route_update (ADD, request);
490: }
491:
492: void
493: ospf6_zebra_route_update_remove (struct ospf6_route *request)
494: {
495: if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
496: {
497: ospf6->route_table->hook_add = NULL;
498: ospf6->route_table->hook_remove = NULL;
499: return;
500: }
501: ospf6_zebra_route_update (REM, request);
502: }
503:
504: DEFUN (redistribute_ospf6,
505: redistribute_ospf6_cmd,
506: "redistribute ospf6",
507: "Redistribute control\n"
508: "OSPF6 route\n")
509: {
510: struct ospf6_route *route;
511:
512: if (zclient->redist[ZEBRA_ROUTE_OSPF6])
513: return CMD_SUCCESS;
514:
515: zclient->redist[ZEBRA_ROUTE_OSPF6] = 1;
516:
517: if (ospf6 == NULL)
518: return CMD_SUCCESS;
519:
520: /* send ospf6 route to zebra route table */
521: for (route = ospf6_route_head (ospf6->route_table); route;
522: route = ospf6_route_next (route))
523: ospf6_zebra_route_update_add (route);
524:
525: ospf6->route_table->hook_add = ospf6_zebra_route_update_add;
526: ospf6->route_table->hook_remove = ospf6_zebra_route_update_remove;
527:
528: return CMD_SUCCESS;
529: }
530:
531: DEFUN (no_redistribute_ospf6,
532: no_redistribute_ospf6_cmd,
533: "no redistribute ospf6",
534: NO_STR
535: "Redistribute control\n"
536: "OSPF6 route\n")
537: {
538: struct ospf6_route *route;
539:
540: if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
541: return CMD_SUCCESS;
542:
543: zclient->redist[ZEBRA_ROUTE_OSPF6] = 0;
544:
545: if (ospf6 == NULL)
546: return CMD_SUCCESS;
547:
548: ospf6->route_table->hook_add = NULL;
549: ospf6->route_table->hook_remove = NULL;
550:
551: /* withdraw ospf6 route from zebra route table */
552: for (route = ospf6_route_head (ospf6->route_table); route;
553: route = ospf6_route_next (route))
554: ospf6_zebra_route_update_remove (route);
555:
556: return CMD_SUCCESS;
557: }
558:
559: void
560: ospf6_zebra_init (void)
561: {
562: /* Allocate zebra structure. */
563: zclient = zclient_new ();
564: zclient_init (zclient, ZEBRA_ROUTE_OSPF6);
565: zclient->router_id_update = ospf6_router_id_update_zebra;
566: zclient->interface_add = ospf6_zebra_if_add;
567: zclient->interface_delete = ospf6_zebra_if_del;
568: zclient->interface_up = ospf6_zebra_if_state_update;
569: zclient->interface_down = ospf6_zebra_if_state_update;
570: zclient->interface_address_add = ospf6_zebra_if_address_update_add;
571: zclient->interface_address_delete = ospf6_zebra_if_address_update_delete;
572: zclient->ipv4_route_add = NULL;
573: zclient->ipv4_route_delete = NULL;
574: zclient->ipv6_route_add = ospf6_zebra_read_ipv6;
575: zclient->ipv6_route_delete = ospf6_zebra_read_ipv6;
576:
577: /* redistribute connected route by default */
578: /* ospf6_zebra_redistribute (ZEBRA_ROUTE_CONNECT); */
579:
580: /* Install zebra node. */
581: install_node (&zebra_node, config_write_ospf6_zebra);
582:
583: /* Install command element for zebra node. */
584: install_element (VIEW_NODE, &show_zebra_cmd);
585: install_element (ENABLE_NODE, &show_zebra_cmd);
586: install_element (CONFIG_NODE, &router_zebra_cmd);
587: install_element (CONFIG_NODE, &no_router_zebra_cmd);
588:
589: install_default (ZEBRA_NODE);
590: install_element (ZEBRA_NODE, &redistribute_ospf6_cmd);
591: install_element (ZEBRA_NODE, &no_redistribute_ospf6_cmd);
592:
593: return;
594: }
595:
596: /* Debug */
597:
598: DEFUN (debug_ospf6_zebra_sendrecv,
599: debug_ospf6_zebra_sendrecv_cmd,
600: "debug ospf6 zebra (send|recv)",
601: DEBUG_STR
602: OSPF6_STR
603: "Debug connection between zebra\n"
604: "Debug Sending zebra\n"
605: "Debug Receiving zebra\n"
606: )
607: {
608: unsigned char level = 0;
609:
610: if (argc)
611: {
612: if (! strncmp (argv[0], "s", 1))
613: level = OSPF6_DEBUG_ZEBRA_SEND;
614: else if (! strncmp (argv[0], "r", 1))
615: level = OSPF6_DEBUG_ZEBRA_RECV;
616: }
617: else
618: level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
619:
620: OSPF6_DEBUG_ZEBRA_ON (level);
621: return CMD_SUCCESS;
622: }
623:
624: ALIAS (debug_ospf6_zebra_sendrecv,
625: debug_ospf6_zebra_cmd,
626: "debug ospf6 zebra",
627: DEBUG_STR
628: OSPF6_STR
629: "Debug connection between zebra\n"
630: )
631:
632:
633: DEFUN (no_debug_ospf6_zebra_sendrecv,
634: no_debug_ospf6_zebra_sendrecv_cmd,
635: "no debug ospf6 zebra (send|recv)",
636: NO_STR
637: DEBUG_STR
638: OSPF6_STR
639: "Debug connection between zebra\n"
640: "Debug Sending zebra\n"
641: "Debug Receiving zebra\n"
642: )
643: {
644: unsigned char level = 0;
645:
646: if (argc)
647: {
648: if (! strncmp (argv[0], "s", 1))
649: level = OSPF6_DEBUG_ZEBRA_SEND;
650: else if (! strncmp (argv[0], "r", 1))
651: level = OSPF6_DEBUG_ZEBRA_RECV;
652: }
653: else
654: level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
655:
656: OSPF6_DEBUG_ZEBRA_OFF (level);
657: return CMD_SUCCESS;
658: }
659:
660: ALIAS (no_debug_ospf6_zebra_sendrecv,
661: no_debug_ospf6_zebra_cmd,
662: "no debug ospf6 zebra",
663: NO_STR
664: DEBUG_STR
665: OSPF6_STR
666: "Debug connection between zebra\n"
667: )
668:
669: int
670: config_write_ospf6_debug_zebra (struct vty *vty)
671: {
672: if (IS_OSPF6_DEBUG_ZEBRA (SEND) && IS_OSPF6_DEBUG_ZEBRA (RECV))
673: vty_out (vty, "debug ospf6 zebra%s", VNL);
674: else
675: {
676: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
677: vty_out (vty, "debug ospf6 zebra send%s", VNL);
678: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
679: vty_out (vty, "debug ospf6 zebra recv%s", VNL);
680: }
681: return 0;
682: }
683:
684: void
685: install_element_ospf6_debug_zebra (void)
686: {
687: install_element (ENABLE_NODE, &debug_ospf6_zebra_cmd);
688: install_element (ENABLE_NODE, &no_debug_ospf6_zebra_cmd);
689: install_element (ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
690: install_element (ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
691: install_element (CONFIG_NODE, &debug_ospf6_zebra_cmd);
692: install_element (CONFIG_NODE, &no_debug_ospf6_zebra_cmd);
693: install_element (CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
694: install_element (CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
695: }
696:
697:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf6_zebra.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 / ospf6d