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 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   /* 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
 130 static int
 131 ospf6_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
 150 static int
 151 ospf6_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
 175 static int
 176 ospf6_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
 201 static int
 202 ospf6_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
 278 DEFUN (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
 306 DEFUN (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
 318 DEFUN (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. */
 331 static int
 332 config_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. */
 349 static struct cmd_node zebra_node =
 350 {
 351   ZEBRA_NODE,
 352   "%s(config-zebra)# ",
 353 };
 354
 355 #define ADD    0
 356 #define REM    1
 357 static void
 358 ospf6_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
 488 void
 489 ospf6_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
 500 void
 501 ospf6_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
 512 DEFUN (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
 539 DEFUN (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
 567 void
 568 ospf6_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
 606 DEFUN (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
 632 ALIAS (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
 641 DEFUN (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
 668 ALIAS (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
 677 int
 678 config_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
 692 void
 693 install_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