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