ospf6d/ospf6_zebra.c

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