Annotation of embedaddon/quagga/ospf6d/ospf6_zebra.c, revision 1.1.1.2
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;
1.1.1.2 ! misho 454: api.safi = SAFI_UNICAST;
1.1 misho 455: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
456: api.nexthop_num = nhcount;
457: api.nexthop = nexthops;
458: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
459: api.ifindex_num = nhcount;
460: api.ifindex = ifindexes;
461: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
462: api.metric = (request->path.metric_type == 2 ?
463: request->path.cost_e2 : request->path.cost);
464:
465: dest = (struct prefix_ipv6 *) &request->prefix;
466: if (type == REM)
467: ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api);
468: else
469: ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api);
470:
471: if (ret < 0)
472: zlog_err ("zapi_ipv6_route() %s failed: %s",
473: (type == REM ? "delete" : "add"), safe_strerror (errno));
474:
475: XFREE (MTYPE_OSPF6_OTHER, nexthops);
476: XFREE (MTYPE_OSPF6_OTHER, ifindexes);
477:
478: return;
479: }
480:
481: void
482: ospf6_zebra_route_update_add (struct ospf6_route *request)
483: {
484: if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
485: {
486: ospf6->route_table->hook_add = NULL;
487: ospf6->route_table->hook_remove = NULL;
488: return;
489: }
490: ospf6_zebra_route_update (ADD, request);
491: }
492:
493: void
494: ospf6_zebra_route_update_remove (struct ospf6_route *request)
495: {
496: if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
497: {
498: ospf6->route_table->hook_add = NULL;
499: ospf6->route_table->hook_remove = NULL;
500: return;
501: }
502: ospf6_zebra_route_update (REM, request);
503: }
504:
505: DEFUN (redistribute_ospf6,
506: redistribute_ospf6_cmd,
507: "redistribute ospf6",
508: "Redistribute control\n"
509: "OSPF6 route\n")
510: {
511: struct ospf6_route *route;
512:
513: if (zclient->redist[ZEBRA_ROUTE_OSPF6])
514: return CMD_SUCCESS;
515:
516: zclient->redist[ZEBRA_ROUTE_OSPF6] = 1;
517:
518: if (ospf6 == NULL)
519: return CMD_SUCCESS;
520:
521: /* send ospf6 route to zebra route table */
522: for (route = ospf6_route_head (ospf6->route_table); route;
523: route = ospf6_route_next (route))
524: ospf6_zebra_route_update_add (route);
525:
526: ospf6->route_table->hook_add = ospf6_zebra_route_update_add;
527: ospf6->route_table->hook_remove = ospf6_zebra_route_update_remove;
528:
529: return CMD_SUCCESS;
530: }
531:
532: DEFUN (no_redistribute_ospf6,
533: no_redistribute_ospf6_cmd,
534: "no redistribute ospf6",
535: NO_STR
536: "Redistribute control\n"
537: "OSPF6 route\n")
538: {
539: struct ospf6_route *route;
540:
541: if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
542: return CMD_SUCCESS;
543:
544: zclient->redist[ZEBRA_ROUTE_OSPF6] = 0;
545:
546: if (ospf6 == NULL)
547: return CMD_SUCCESS;
548:
549: ospf6->route_table->hook_add = NULL;
550: ospf6->route_table->hook_remove = NULL;
551:
552: /* withdraw ospf6 route from zebra route table */
553: for (route = ospf6_route_head (ospf6->route_table); route;
554: route = ospf6_route_next (route))
555: ospf6_zebra_route_update_remove (route);
556:
557: return CMD_SUCCESS;
558: }
559:
560: void
561: ospf6_zebra_init (void)
562: {
563: /* Allocate zebra structure. */
564: zclient = zclient_new ();
565: zclient_init (zclient, ZEBRA_ROUTE_OSPF6);
566: zclient->router_id_update = ospf6_router_id_update_zebra;
567: zclient->interface_add = ospf6_zebra_if_add;
568: zclient->interface_delete = ospf6_zebra_if_del;
569: zclient->interface_up = ospf6_zebra_if_state_update;
570: zclient->interface_down = ospf6_zebra_if_state_update;
571: zclient->interface_address_add = ospf6_zebra_if_address_update_add;
572: zclient->interface_address_delete = ospf6_zebra_if_address_update_delete;
573: zclient->ipv4_route_add = NULL;
574: zclient->ipv4_route_delete = NULL;
575: zclient->ipv6_route_add = ospf6_zebra_read_ipv6;
576: zclient->ipv6_route_delete = ospf6_zebra_read_ipv6;
577:
578: /* redistribute connected route by default */
579: /* ospf6_zebra_redistribute (ZEBRA_ROUTE_CONNECT); */
580:
581: /* Install zebra node. */
582: install_node (&zebra_node, config_write_ospf6_zebra);
583:
584: /* Install command element for zebra node. */
585: install_element (VIEW_NODE, &show_zebra_cmd);
586: install_element (ENABLE_NODE, &show_zebra_cmd);
587: install_element (CONFIG_NODE, &router_zebra_cmd);
588: install_element (CONFIG_NODE, &no_router_zebra_cmd);
589:
590: install_default (ZEBRA_NODE);
591: install_element (ZEBRA_NODE, &redistribute_ospf6_cmd);
592: install_element (ZEBRA_NODE, &no_redistribute_ospf6_cmd);
593:
594: return;
595: }
596:
597: /* Debug */
598:
599: DEFUN (debug_ospf6_zebra_sendrecv,
600: debug_ospf6_zebra_sendrecv_cmd,
601: "debug ospf6 zebra (send|recv)",
602: DEBUG_STR
603: OSPF6_STR
604: "Debug connection between zebra\n"
605: "Debug Sending zebra\n"
606: "Debug Receiving zebra\n"
607: )
608: {
609: unsigned char level = 0;
610:
611: if (argc)
612: {
613: if (! strncmp (argv[0], "s", 1))
614: level = OSPF6_DEBUG_ZEBRA_SEND;
615: else if (! strncmp (argv[0], "r", 1))
616: level = OSPF6_DEBUG_ZEBRA_RECV;
617: }
618: else
619: level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
620:
621: OSPF6_DEBUG_ZEBRA_ON (level);
622: return CMD_SUCCESS;
623: }
624:
625: ALIAS (debug_ospf6_zebra_sendrecv,
626: debug_ospf6_zebra_cmd,
627: "debug ospf6 zebra",
628: DEBUG_STR
629: OSPF6_STR
630: "Debug connection between zebra\n"
631: )
632:
633:
634: DEFUN (no_debug_ospf6_zebra_sendrecv,
635: no_debug_ospf6_zebra_sendrecv_cmd,
636: "no debug ospf6 zebra (send|recv)",
637: NO_STR
638: DEBUG_STR
639: OSPF6_STR
640: "Debug connection between zebra\n"
641: "Debug Sending zebra\n"
642: "Debug Receiving zebra\n"
643: )
644: {
645: unsigned char level = 0;
646:
647: if (argc)
648: {
649: if (! strncmp (argv[0], "s", 1))
650: level = OSPF6_DEBUG_ZEBRA_SEND;
651: else if (! strncmp (argv[0], "r", 1))
652: level = OSPF6_DEBUG_ZEBRA_RECV;
653: }
654: else
655: level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
656:
657: OSPF6_DEBUG_ZEBRA_OFF (level);
658: return CMD_SUCCESS;
659: }
660:
661: ALIAS (no_debug_ospf6_zebra_sendrecv,
662: no_debug_ospf6_zebra_cmd,
663: "no debug ospf6 zebra",
664: NO_STR
665: DEBUG_STR
666: OSPF6_STR
667: "Debug connection between zebra\n"
668: )
669:
670: int
671: config_write_ospf6_debug_zebra (struct vty *vty)
672: {
673: if (IS_OSPF6_DEBUG_ZEBRA (SEND) && IS_OSPF6_DEBUG_ZEBRA (RECV))
674: vty_out (vty, "debug ospf6 zebra%s", VNL);
675: else
676: {
677: if (IS_OSPF6_DEBUG_ZEBRA (SEND))
678: vty_out (vty, "debug ospf6 zebra send%s", VNL);
679: if (IS_OSPF6_DEBUG_ZEBRA (RECV))
680: vty_out (vty, "debug ospf6 zebra recv%s", VNL);
681: }
682: return 0;
683: }
684:
685: void
686: install_element_ospf6_debug_zebra (void)
687: {
688: install_element (ENABLE_NODE, &debug_ospf6_zebra_cmd);
689: install_element (ENABLE_NODE, &no_debug_ospf6_zebra_cmd);
690: install_element (ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
691: install_element (ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
692: install_element (CONFIG_NODE, &debug_ospf6_zebra_cmd);
693: install_element (CONFIG_NODE, &no_debug_ospf6_zebra_cmd);
694: install_element (CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
695: install_element (CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
696: }
697:
698:
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