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 42unsigned char conf_debug_ospf6_zebra = 0; 43 44/* information about zebra. */ 45struct zclient *zclient = NULL; 46 47struct in_addr router_id_zebra; 48 49/* Router-id update message from zebra. */ 50static int 51ospf6_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 */ 70void 71ospf6_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 80void 81ospf6_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. */ 91static int 92ospf6_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 104static int 105ospf6_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 /* XXX: ospf6_interface_if_del is not the right way to handle this, 121 * because among other thinkable issues, it will also clear all 122 * settings as they are contained in the struct ospf6_interface. */ 123 ospf6_interface_if_del (ifp); 124#endif /*0*/ 125 126 ifp->ifindex = IFINDEX_INTERNAL; 127 return 0; 128} 129 130static int 131ospf6_zebra_if_state_update (int command, struct zclient *zclient, 132 zebra_size_t length) 133{ 134 struct interface *ifp; 135 136 ifp = zebra_interface_state_read (zclient->ibuf); 137 if (ifp == NULL) 138 return 0; 139 140 if (IS_OSPF6_DEBUG_ZEBRA (RECV)) 141 zlog_debug ("Zebra Interface state change: " 142 "%s index %d flags %llx metric %d mtu %d bandwidth %d", 143 ifp->name, ifp->ifindex, (unsigned long long)ifp->flags, 144 ifp->metric, ifp->mtu6, ifp->bandwidth); 145 146 ospf6_interface_state_update (ifp); 147 return 0; 148} 149 150static int 151ospf6_zebra_if_address_update_add (int command, struct zclient *zclient, 152 zebra_size_t length) 153{ 154 struct connected *c; 155 char buf[128]; 156 157 c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD, zclient->ibuf); 158 if (c == NULL) 159 return 0; 160 161 if (IS_OSPF6_DEBUG_ZEBRA (RECV)) 162 zlog_debug ("Zebra Interface address add: %s %5s %s/%d", 163 c->ifp->name, prefix_family_str (c->address), 164 inet_ntop (c->address->family, &c->address->u.prefix, 165 buf, sizeof (buf)), c->address->prefixlen); 166 167 if (c->address->family == AF_INET6) 168 { 169 ospf6_interface_state_update (c->ifp); 170 ospf6_interface_connected_route_update (c->ifp); 171 } 172 return 0; 173} 174 175static int 176ospf6_zebra_if_address_update_delete (int command, struct zclient *zclient, 177 zebra_size_t length) 178{ 179 struct connected *c; 180 char buf[128]; 181 182 c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE, zclient->ibuf); 183 if (c == NULL) 184 return 0; 185 186 if (IS_OSPF6_DEBUG_ZEBRA (RECV)) 187 zlog_debug ("Zebra Interface address delete: %s %5s %s/%d", 188 c->ifp->name, prefix_family_str (c->address), 189 inet_ntop (c->address->family, &c->address->u.prefix, 190 buf, sizeof (buf)), c->address->prefixlen); 191 192 if (c->address->family == AF_INET6) 193 { 194 ospf6_interface_connected_route_update (c->ifp); 195 ospf6_interface_state_update (c->ifp); 196 } 197 198 return 0; 199} 200 201static int 202ospf6_zebra_read_ipv6 (int command, struct zclient *zclient, 203 zebra_size_t length) 204{ 205 struct stream *s; 206 struct zapi_ipv6 api; 207 unsigned long ifindex; 208 struct prefix_ipv6 p; 209 struct in6_addr *nexthop; 210 211 s = zclient->ibuf; 212 ifindex = 0; 213 nexthop = NULL; 214 memset (&api, 0, sizeof (api)); 215 216 /* Type, flags, message. */ 217 api.type = stream_getc (s); 218 api.flags = stream_getc (s); 219 api.message = stream_getc (s); 220 221 /* IPv6 prefix. */ 222 memset (&p, 0, sizeof (struct prefix_ipv6)); 223 p.family = AF_INET6; 224 p.prefixlen = stream_getc (s); 225 stream_get (&p.prefix, s, PSIZE (p.prefixlen)); 226 227 /* Nexthop, ifindex, distance, metric. */ 228 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP)) 229 { 230 api.nexthop_num = stream_getc (s); 231 nexthop = (struct in6_addr *) 232 malloc (api.nexthop_num * sizeof (struct in6_addr)); 233 stream_get (nexthop, s, api.nexthop_num * sizeof (struct in6_addr)); 234 } 235 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX)) 236 { 237 api.ifindex_num = stream_getc (s); 238 ifindex = stream_getl (s); 239 } 240 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE)) 241 api.distance = stream_getc (s); 242 else 243 api.distance = 0; 244 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC)) 245 api.metric = stream_getl (s); 246 else 247 api.metric = 0; 248 249 if (IS_OSPF6_DEBUG_ZEBRA (RECV)) 250 { 251 char prefixstr[128], nexthopstr[128]; 252 prefix2str ((struct prefix *)&p, prefixstr, sizeof (prefixstr)); 253 if (nexthop) 254 inet_ntop (AF_INET6, nexthop, nexthopstr, sizeof (nexthopstr)); 255 else 256 snprintf (nexthopstr, sizeof (nexthopstr), "::"); 257 258 zlog_debug ("Zebra Receive route %s: %s %s nexthop %s ifindex %ld", 259 (command == ZEBRA_IPV6_ROUTE_ADD ? "add" : "delete"), 260 zebra_route_string(api.type), prefixstr, nexthopstr, ifindex); 261 } 262 263 if (command == ZEBRA_IPV6_ROUTE_ADD) 264 ospf6_asbr_redistribute_add (api.type, ifindex, (struct prefix *) &p, 265 api.nexthop_num, nexthop); 266 else 267 ospf6_asbr_redistribute_remove (api.type, ifindex, (struct prefix *) &p); 268 269 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP)) 270 free (nexthop); 271 272 return 0; 273} 274 275 276 277 278DEFUN (show_zebra, 279 show_zebra_cmd, 280 "show zebra", 281 SHOW_STR 282 "Zebra information\n") 283{ 284 int i; 285 if (zclient == NULL) 286 { 287 vty_out (vty, "Not connected to zebra%s", VNL); 288 return CMD_SUCCESS; 289 } 290 291 vty_out (vty, "Zebra Infomation%s", VNL); 292 vty_out (vty, " enable: %d fail: %d%s", 293 zclient->enable, zclient->fail, VNL); 294 vty_out (vty, " redistribute default: %d%s", zclient->redist_default, 295 VNL); 296 vty_out (vty, " redistribute:"); 297 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) 298 { 299 if (zclient->redist[i]) 300 vty_out (vty, " %s", zebra_route_string(i)); 301 } 302 vty_out (vty, "%s", VNL); 303 return CMD_SUCCESS; 304} 305 306DEFUN (router_zebra, 307 router_zebra_cmd, 308 "router zebra", 309 "Enable a routing process\n" 310 "Make connection to zebra daemon\n") 311{ 312 vty->node = ZEBRA_NODE; 313 zclient->enable = 1; 314 zclient_start (zclient); 315 return CMD_SUCCESS; 316} 317 318DEFUN (no_router_zebra, 319 no_router_zebra_cmd, 320 "no router zebra", 321 NO_STR 322 "Configure routing process\n" 323 "Disable connection to zebra daemon\n") 324{ 325 zclient->enable = 0; 326 zclient_stop (zclient); 327 return CMD_SUCCESS; 328} 329 330/* Zebra configuration write function. */ 331static int 332config_write_ospf6_zebra (struct vty *vty) 333{ 334 if (! zclient->enable) 335 { 336 vty_out (vty, "no router zebra%s", VNL); 337 vty_out (vty, "!%s", VNL); 338 } 339 else if (! zclient->redist[ZEBRA_ROUTE_OSPF6]) 340 { 341 vty_out (vty, "router zebra%s", VNL); 342 vty_out (vty, " no redistribute ospf6%s", VNL); 343 vty_out (vty, "!%s", VNL); 344 } 345 return 0; 346} 347 348/* Zebra node structure. */ 349static struct cmd_node zebra_node = 350{ 351 ZEBRA_NODE, 352 "%s(config-zebra)# ", 353}; 354 355#define ADD 0 356#define REM 1 357static void 358ospf6_zebra_route_update (int type, struct ospf6_route *request) 359{ 360 struct zapi_ipv6 api; 361 char buf[64]; 362 int nhcount; 363 struct in6_addr **nexthops; 364 unsigned int *ifindexes; 365 int i, ret = 0; 366 struct prefix_ipv6 *dest; 367 368 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 369 { 370 prefix2str (&request->prefix, buf, sizeof (buf)); 371 zlog_debug ("Send %s route: %s", 372 (type == REM ? "remove" : "add"), buf); 373 } 374 375 if (zclient->sock < 0) 376 { 377 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 378 zlog_debug (" Not connected to Zebra"); 379 return; 380 } 381 382 if (request->path.origin.adv_router == ospf6->router_id && 383 (request->path.type == OSPF6_PATH_TYPE_EXTERNAL1 || 384 request->path.type == OSPF6_PATH_TYPE_EXTERNAL2)) 385 { 386 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 387 zlog_debug (" Ignore self-originated external route"); 388 return; 389 } 390 391 /* If removing is the best path and if there's another path, 392 treat this request as add the secondary path */ 393 if (type == REM && ospf6_route_is_best (request) && 394 request->next && ospf6_route_is_same (request, request->next)) 395 { 396 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 397 zlog_debug (" Best-path removal resulted Sencondary addition"); 398 type = ADD; 399 request = request->next; 400 } 401 402 /* Only the best path will be sent to zebra. */ 403 if (! ospf6_route_is_best (request)) 404 { 405 /* this is not preferred best route, ignore */ 406 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 407 zlog_debug (" Ignore non-best route"); 408 return; 409 } 410 411 nhcount = 0; 412 for (i = 0; i < OSPF6_MULTI_PATH_LIMIT; i++) 413 if (ospf6_nexthop_is_set (&request->nexthop[i])) 414 nhcount++; 415 416 if (nhcount == 0) 417 { 418 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 419 zlog_debug (" No nexthop, ignore"); 420 return; 421 } 422 423 /* allocate memory for nexthop_list */ 424 nexthops = XCALLOC (MTYPE_OSPF6_OTHER, 425 nhcount * sizeof (struct in6_addr *)); 426 if (nexthops == NULL) 427 { 428 zlog_warn ("Can't send route to zebra: malloc failed"); 429 return; 430 } 431 432 /* allocate memory for ifindex_list */ 433 ifindexes = XCALLOC (MTYPE_OSPF6_OTHER, 434 nhcount * sizeof (unsigned int)); 435 if (ifindexes == NULL) 436 { 437 zlog_warn ("Can't send route to zebra: malloc failed"); 438 XFREE (MTYPE_OSPF6_OTHER, nexthops); 439 return; 440 } 441 442 for (i = 0; i < nhcount; i++) 443 { 444 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 445 { 446 char ifname[IFNAMSIZ]; 447 inet_ntop (AF_INET6, &request->nexthop[i].address, 448 buf, sizeof (buf)); 449 if (!if_indextoname(request->nexthop[i].ifindex, ifname)) 450 strlcpy(ifname, "unknown", sizeof(ifname)); 451 zlog_debug (" nexthop: %s%%%.*s(%d)", buf, IFNAMSIZ, ifname, 452 request->nexthop[i].ifindex); 453 } 454 nexthops[i] = &request->nexthop[i].address; 455 ifindexes[i] = request->nexthop[i].ifindex; 456 } 457 458 api.type = ZEBRA_ROUTE_OSPF6; 459 api.flags = 0; 460 api.message = 0; 461 api.safi = SAFI_UNICAST; 462 SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP); 463 api.nexthop_num = nhcount; 464 api.nexthop = nexthops; 465 SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX); 466 api.ifindex_num = nhcount; 467 api.ifindex = ifindexes; 468 SET_FLAG (api.message, ZAPI_MESSAGE_METRIC); 469 api.metric = (request->path.metric_type == 2 ? 470 request->path.cost_e2 : request->path.cost); 471 472 dest = (struct prefix_ipv6 *) &request->prefix; 473 if (type == REM) 474 ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api); 475 else 476 ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api); 477 478 if (ret < 0) 479 zlog_err ("zapi_ipv6_route() %s failed: %s", 480 (type == REM ? "delete" : "add"), safe_strerror (errno)); 481 482 XFREE (MTYPE_OSPF6_OTHER, nexthops); 483 XFREE (MTYPE_OSPF6_OTHER, ifindexes); 484 485 return; 486} 487 488void 489ospf6_zebra_route_update_add (struct ospf6_route *request) 490{ 491 if (! zclient->redist[ZEBRA_ROUTE_OSPF6]) 492 { 493 ospf6->route_table->hook_add = NULL; 494 ospf6->route_table->hook_remove = NULL; 495 return; 496 } 497 ospf6_zebra_route_update (ADD, request); 498} 499 500void 501ospf6_zebra_route_update_remove (struct ospf6_route *request) 502{ 503 if (! zclient->redist[ZEBRA_ROUTE_OSPF6]) 504 { 505 ospf6->route_table->hook_add = NULL; 506 ospf6->route_table->hook_remove = NULL; 507 return; 508 } 509 ospf6_zebra_route_update (REM, request); 510} 511 512DEFUN (redistribute_ospf6, 513 redistribute_ospf6_cmd, 514 "redistribute ospf6", 515 "Redistribute control\n" 516 "OSPF6 route\n") 517{ 518 struct ospf6_route *route; 519 520 if (zclient->redist[ZEBRA_ROUTE_OSPF6]) 521 return CMD_SUCCESS; 522 523 zclient->redist[ZEBRA_ROUTE_OSPF6] = 1; 524 525 if (ospf6 == NULL) 526 return CMD_SUCCESS; 527 528 /* send ospf6 route to zebra route table */ 529 for (route = ospf6_route_head (ospf6->route_table); route; 530 route = ospf6_route_next (route)) 531 ospf6_zebra_route_update_add (route); 532 533 ospf6->route_table->hook_add = ospf6_zebra_route_update_add; 534 ospf6->route_table->hook_remove = ospf6_zebra_route_update_remove; 535 536 return CMD_SUCCESS; 537} 538 539DEFUN (no_redistribute_ospf6, 540 no_redistribute_ospf6_cmd, 541 "no redistribute ospf6", 542 NO_STR 543 "Redistribute control\n" 544 "OSPF6 route\n") 545{ 546 struct ospf6_route *route; 547 548 if (! zclient->redist[ZEBRA_ROUTE_OSPF6]) 549 return CMD_SUCCESS; 550 551 zclient->redist[ZEBRA_ROUTE_OSPF6] = 0; 552 553 if (ospf6 == NULL) 554 return CMD_SUCCESS; 555 556 ospf6->route_table->hook_add = NULL; 557 ospf6->route_table->hook_remove = NULL; 558 559 /* withdraw ospf6 route from zebra route table */ 560 for (route = ospf6_route_head (ospf6->route_table); route; 561 route = ospf6_route_next (route)) 562 ospf6_zebra_route_update_remove (route); 563 564 return CMD_SUCCESS; 565} 566 567void 568ospf6_zebra_init (void) 569{ 570 /* Allocate zebra structure. */ 571 zclient = zclient_new (); 572 zclient_init (zclient, ZEBRA_ROUTE_OSPF6); 573 zclient->router_id_update = ospf6_router_id_update_zebra; 574 zclient->interface_add = ospf6_zebra_if_add; 575 zclient->interface_delete = ospf6_zebra_if_del; 576 zclient->interface_up = ospf6_zebra_if_state_update; 577 zclient->interface_down = ospf6_zebra_if_state_update; 578 zclient->interface_address_add = ospf6_zebra_if_address_update_add; 579 zclient->interface_address_delete = ospf6_zebra_if_address_update_delete; 580 zclient->ipv4_route_add = NULL; 581 zclient->ipv4_route_delete = NULL; 582 zclient->ipv6_route_add = ospf6_zebra_read_ipv6; 583 zclient->ipv6_route_delete = ospf6_zebra_read_ipv6; 584 585 /* redistribute connected route by default */ 586 /* ospf6_zebra_redistribute (ZEBRA_ROUTE_CONNECT); */ 587 588 /* Install zebra node. */ 589 install_node (&zebra_node, config_write_ospf6_zebra); 590 591 /* Install command element for zebra node. */ 592 install_element (VIEW_NODE, &show_zebra_cmd); 593 install_element (ENABLE_NODE, &show_zebra_cmd); 594 install_element (CONFIG_NODE, &router_zebra_cmd); 595 install_element (CONFIG_NODE, &no_router_zebra_cmd); 596 597 install_default (ZEBRA_NODE); 598 install_element (ZEBRA_NODE, &redistribute_ospf6_cmd); 599 install_element (ZEBRA_NODE, &no_redistribute_ospf6_cmd); 600 601 return; 602} 603 604/* Debug */ 605 606DEFUN (debug_ospf6_zebra_sendrecv, 607 debug_ospf6_zebra_sendrecv_cmd, 608 "debug ospf6 zebra (send|recv)", 609 DEBUG_STR 610 OSPF6_STR 611 "Debug connection between zebra\n" 612 "Debug Sending zebra\n" 613 "Debug Receiving zebra\n" 614 ) 615{ 616 unsigned char level = 0; 617 618 if (argc) 619 { 620 if (! strncmp (argv[0], "s", 1)) 621 level = OSPF6_DEBUG_ZEBRA_SEND; 622 else if (! strncmp (argv[0], "r", 1)) 623 level = OSPF6_DEBUG_ZEBRA_RECV; 624 } 625 else 626 level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV; 627 628 OSPF6_DEBUG_ZEBRA_ON (level); 629 return CMD_SUCCESS; 630} 631 632ALIAS (debug_ospf6_zebra_sendrecv, 633 debug_ospf6_zebra_cmd, 634 "debug ospf6 zebra", 635 DEBUG_STR 636 OSPF6_STR 637 "Debug connection between zebra\n" 638 ) 639 640 641DEFUN (no_debug_ospf6_zebra_sendrecv, 642 no_debug_ospf6_zebra_sendrecv_cmd, 643 "no debug ospf6 zebra (send|recv)", 644 NO_STR 645 DEBUG_STR 646 OSPF6_STR 647 "Debug connection between zebra\n" 648 "Debug Sending zebra\n" 649 "Debug Receiving zebra\n" 650 ) 651{ 652 unsigned char level = 0; 653 654 if (argc) 655 { 656 if (! strncmp (argv[0], "s", 1)) 657 level = OSPF6_DEBUG_ZEBRA_SEND; 658 else if (! strncmp (argv[0], "r", 1)) 659 level = OSPF6_DEBUG_ZEBRA_RECV; 660 } 661 else 662 level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV; 663 664 OSPF6_DEBUG_ZEBRA_OFF (level); 665 return CMD_SUCCESS; 666} 667 668ALIAS (no_debug_ospf6_zebra_sendrecv, 669 no_debug_ospf6_zebra_cmd, 670 "no debug ospf6 zebra", 671 NO_STR 672 DEBUG_STR 673 OSPF6_STR 674 "Debug connection between zebra\n" 675 ) 676 677int 678config_write_ospf6_debug_zebra (struct vty *vty) 679{ 680 if (IS_OSPF6_DEBUG_ZEBRA (SEND) && IS_OSPF6_DEBUG_ZEBRA (RECV)) 681 vty_out (vty, "debug ospf6 zebra%s", VNL); 682 else 683 { 684 if (IS_OSPF6_DEBUG_ZEBRA (SEND)) 685 vty_out (vty, "debug ospf6 zebra send%s", VNL); 686 if (IS_OSPF6_DEBUG_ZEBRA (RECV)) 687 vty_out (vty, "debug ospf6 zebra recv%s", VNL); 688 } 689 return 0; 690} 691 692void 693install_element_ospf6_debug_zebra (void) 694{ 695 install_element (ENABLE_NODE, &debug_ospf6_zebra_cmd); 696 install_element (ENABLE_NODE, &no_debug_ospf6_zebra_cmd); 697 install_element (ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd); 698 install_element (ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd); 699 install_element (CONFIG_NODE, &debug_ospf6_zebra_cmd); 700 install_element (CONFIG_NODE, &no_debug_ospf6_zebra_cmd); 701 install_element (CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd); 702 install_element (CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd); 703} 704 705 706