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 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 = ospf6_route_num_nexthops (request);
 412   if (nhcount == 0)
 413     {
 414       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
 415         zlog_debug ("  No nexthop, ignore");
 416       return;
 417     }
 418
 419   /* allocate memory for nexthop_list */
 420   nexthops = XCALLOC (MTYPE_OSPF6_OTHER,
 421                       nhcount * sizeof (struct in6_addr *));
 422   if (nexthops == NULL)
 423     {
 424       zlog_warn ("Can't send route to zebra: malloc failed");
 425       return;
 426     }
 427
 428   /* allocate memory for ifindex_list */
 429   ifindexes = XCALLOC (MTYPE_OSPF6_OTHER,
 430                        nhcount * sizeof (unsigned int));
 431   if (ifindexes == NULL)
 432     {
 433       zlog_warn ("Can't send route to zebra: malloc failed");
 434       XFREE (MTYPE_OSPF6_OTHER, nexthops);
 435       return;
 436     }
 437
 438   ospf6_route_zebra_copy_nexthops (request, ifindexes, nexthops, nhcount);
 439
 440   api.type = ZEBRA_ROUTE_OSPF6;
 441   api.flags = 0;
 442   api.message = 0;
 443   api.safi = SAFI_UNICAST;
 444   SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 445   api.nexthop_num = nhcount;
 446   api.nexthop = nexthops;
 447   SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
 448   api.ifindex_num = nhcount;
 449   api.ifindex = ifindexes;
 450   SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
 451   api.metric = (request->path.metric_type == 2 ?
 452                 request->path.u.cost_e2 : request->path.cost);
 453
 454   dest = (struct prefix_ipv6 *) &request->prefix;
 455   if (type == REM)
 456     ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api);
 457   else
 458     ret = zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api);
 459
 460   if (ret < 0)
 461     zlog_err ("zapi_ipv6_route() %s failed: %s",
 462               (type == REM ? "delete" : "add"), safe_strerror (errno));
 463
 464   XFREE (MTYPE_OSPF6_OTHER, nexthops);
 465   XFREE (MTYPE_OSPF6_OTHER, ifindexes);
 466
 467   return;
 468 }
 469
 470 void
 471 ospf6_zebra_route_update_add (struct ospf6_route *request)
 472 {
 473   if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
 474     {
 475       ospf6->route_table->hook_add = NULL;
 476       ospf6->route_table->hook_remove = NULL;
 477       return;
 478     }
 479   ospf6_zebra_route_update (ADD, request);
 480 }
 481
 482 void
 483 ospf6_zebra_route_update_remove (struct ospf6_route *request)
 484 {
 485   if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
 486     {
 487       ospf6->route_table->hook_add = NULL;
 488       ospf6->route_table->hook_remove = NULL;
 489       return;
 490     }
 491   ospf6_zebra_route_update (REM, request);
 492 }
 493
 494 void
 495 ospf6_zebra_add_discard (struct ospf6_route *request)
 496 {
 497   struct zapi_ipv6 api;
 498   char buf[INET6_ADDRSTRLEN];
 499   struct prefix_ipv6 *dest;
 500
 501   if (zclient->redist[ZEBRA_ROUTE_OSPF6])
 502     {
 503       if (!CHECK_FLAG (request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED))
 504         {
 505           api.type = ZEBRA_ROUTE_OSPF6;
 506           api.flags = ZEBRA_FLAG_BLACKHOLE;
 507           api.message = 0;
 508           api.safi = SAFI_UNICAST;
 509           SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 510           api.nexthop_num = 0;
 511           api.ifindex_num = 0;
 512
 513           dest = (struct prefix_ipv6 *) &request->prefix;
 514
 515           zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, dest, &api);
 516
 517           if (IS_OSPF6_DEBUG_ZEBRA (SEND))
 518             zlog_debug ("Zebra: Route add discard %s/%d",
 519                         inet_ntop (AF_INET6, &dest->prefix,
 520                                    buf, INET6_ADDRSTRLEN),
 521                         dest->prefixlen);
 522           SET_FLAG (request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED);
 523         }
 524       else
 525         {
 526           dest = (struct prefix_ipv6 *) &request->prefix;
 527
 528           if (IS_OSPF6_DEBUG_ZEBRA (SEND))
 529             zlog_debug ("Zebra: Blackhole route present already %s/%d",
 530                         inet_ntop (AF_INET6, &dest->prefix,
 531                                    buf, INET6_ADDRSTRLEN),
 532                         dest->prefixlen);
 533         }
 534     }
 535 }
 536
 537 void
 538 ospf6_zebra_delete_discard (struct ospf6_route *request)
 539 {
 540   struct zapi_ipv6 api;
 541   char buf[INET6_ADDRSTRLEN];
 542   struct prefix_ipv6 *dest;
 543
 544   if (zclient->redist[ZEBRA_ROUTE_OSPF6])
 545     {
 546       if (CHECK_FLAG (request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED))
 547         {
 548
 549           api.type = ZEBRA_ROUTE_OSPF6;
 550           api.flags = ZEBRA_FLAG_BLACKHOLE;
 551           api.message = 0;
 552           api.safi = SAFI_UNICAST;
 553           SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 554           api.nexthop_num = 0;
 555           api.ifindex_num = 0;
 556
 557           dest = (struct prefix_ipv6 *) &request->prefix;
 558
 559           zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, dest, &api);
 560
 561           if (IS_OSPF6_DEBUG_ZEBRA (SEND))
 562             zlog_debug ("Zebra: Route delete discard %s/%d",
 563                         inet_ntop (AF_INET6, &dest->prefix, buf,
 564                                    INET6_ADDRSTRLEN), dest->prefixlen);
 565           UNSET_FLAG (request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED);
 566         }
 567       else
 568         {
 569           dest = (struct prefix_ipv6 *) &request->prefix;
 570           if (IS_OSPF6_DEBUG_ZEBRA (SEND))
 571             zlog_debug ("Zebra: Blackhole route already deleted %s/%d",
 572                         inet_ntop (AF_INET6, &dest->prefix, buf,
 573                                    INET6_ADDRSTRLEN), dest->prefixlen);
 574         }
 575     }
 576 }
 577
 578 DEFUN (redistribute_ospf6,
 579        redistribute_ospf6_cmd,
 580        "redistribute ospf6",
 581        "Redistribute control\n"
 582        "OSPF6 route\n")
 583 {
 584   struct ospf6_route *route;
 585
 586   if (zclient->redist[ZEBRA_ROUTE_OSPF6])
 587     return CMD_SUCCESS;
 588
 589   zclient->redist[ZEBRA_ROUTE_OSPF6] = 1;
 590
 591   if (ospf6 == NULL)
 592     return CMD_SUCCESS;
 593
 594   /* send ospf6 route to zebra route table */
 595   for (route = ospf6_route_head (ospf6->route_table); route;
 596        route = ospf6_route_next (route))
 597     ospf6_zebra_route_update_add (route);
 598
 599   ospf6->route_table->hook_add = ospf6_zebra_route_update_add;
 600   ospf6->route_table->hook_remove = ospf6_zebra_route_update_remove;
 601
 602   return CMD_SUCCESS;
 603 }
 604
 605 DEFUN (no_redistribute_ospf6,
 606        no_redistribute_ospf6_cmd,
 607        "no redistribute ospf6",
 608        NO_STR
 609        "Redistribute control\n"
 610        "OSPF6 route\n")
 611 {
 612   struct ospf6_route *route;
 613
 614   if (! zclient->redist[ZEBRA_ROUTE_OSPF6])
 615     return CMD_SUCCESS;
 616
 617   zclient->redist[ZEBRA_ROUTE_OSPF6] = 0;
 618
 619   if (ospf6 == NULL)
 620     return CMD_SUCCESS;
 621
 622   ospf6->route_table->hook_add = NULL;
 623   ospf6->route_table->hook_remove = NULL;
 624
 625   /* withdraw ospf6 route from zebra route table */
 626   for (route = ospf6_route_head (ospf6->route_table); route;
 627        route = ospf6_route_next (route))
 628     ospf6_zebra_route_update_remove (route);
 629
 630   return CMD_SUCCESS;
 631 }
 632
 633 void
 634 ospf6_zebra_init (void)
 635 {
 636   /* Allocate zebra structure. */
 637   zclient = zclient_new ();
 638   zclient_init (zclient, ZEBRA_ROUTE_OSPF6);
 639   zclient->router_id_update = ospf6_router_id_update_zebra;
 640   zclient->interface_add = ospf6_zebra_if_add;
 641   zclient->interface_delete = ospf6_zebra_if_del;
 642   zclient->interface_up = ospf6_zebra_if_state_update;
 643   zclient->interface_down = ospf6_zebra_if_state_update;
 644   zclient->interface_address_add = ospf6_zebra_if_address_update_add;
 645   zclient->interface_address_delete = ospf6_zebra_if_address_update_delete;
 646   zclient->ipv4_route_add = NULL;
 647   zclient->ipv4_route_delete = NULL;
 648   zclient->ipv6_route_add = ospf6_zebra_read_ipv6;
 649   zclient->ipv6_route_delete = ospf6_zebra_read_ipv6;
 650
 651   /* redistribute connected route by default */
 652   /* ospf6_zebra_redistribute (ZEBRA_ROUTE_CONNECT); */
 653
 654   /* Install zebra node. */
 655   install_node (&zebra_node, config_write_ospf6_zebra);
 656
 657   /* Install command element for zebra node. */
 658   install_element (VIEW_NODE, &show_zebra_cmd);
 659   install_element (ENABLE_NODE, &show_zebra_cmd);
 660   install_element (CONFIG_NODE, &router_zebra_cmd);
 661   install_element (CONFIG_NODE, &no_router_zebra_cmd);
 662
 663   install_default (ZEBRA_NODE);
 664   install_element (ZEBRA_NODE, &redistribute_ospf6_cmd);
 665   install_element (ZEBRA_NODE, &no_redistribute_ospf6_cmd);
 666
 667   return;
 668 }
 669
 670 /* Debug */
 671
 672 DEFUN (debug_ospf6_zebra_sendrecv,
 673        debug_ospf6_zebra_sendrecv_cmd,
 674        "debug ospf6 zebra (send|recv)",
 675        DEBUG_STR
 676        OSPF6_STR
 677        "Debug connection between zebra\n"
 678        "Debug Sending zebra\n"
 679        "Debug Receiving zebra\n"
 680       )
 681 {
 682   unsigned char level = 0;
 683
 684   if (argc)
 685     {
 686       if (! strncmp (argv[0], "s", 1))
 687         level = OSPF6_DEBUG_ZEBRA_SEND;
 688       else if (! strncmp (argv[0], "r", 1))
 689         level = OSPF6_DEBUG_ZEBRA_RECV;
 690     }
 691   else
 692     level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
 693
 694   OSPF6_DEBUG_ZEBRA_ON (level);
 695   return CMD_SUCCESS;
 696 }
 697
 698 ALIAS (debug_ospf6_zebra_sendrecv,
 699        debug_ospf6_zebra_cmd,
 700        "debug ospf6 zebra",
 701        DEBUG_STR
 702        OSPF6_STR
 703        "Debug connection between zebra\n"
 704       )
 705
 706
 707 DEFUN (no_debug_ospf6_zebra_sendrecv,
 708        no_debug_ospf6_zebra_sendrecv_cmd,
 709        "no debug ospf6 zebra (send|recv)",
 710        NO_STR
 711        DEBUG_STR
 712        OSPF6_STR
 713        "Debug connection between zebra\n"
 714        "Debug Sending zebra\n"
 715        "Debug Receiving zebra\n"
 716       )
 717 {
 718   unsigned char level = 0;
 719
 720   if (argc)
 721     {
 722       if (! strncmp (argv[0], "s", 1))
 723         level = OSPF6_DEBUG_ZEBRA_SEND;
 724       else if (! strncmp (argv[0], "r", 1))
 725         level = OSPF6_DEBUG_ZEBRA_RECV;
 726     }
 727   else
 728     level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
 729
 730   OSPF6_DEBUG_ZEBRA_OFF (level);
 731   return CMD_SUCCESS;
 732 }
 733
 734 ALIAS (no_debug_ospf6_zebra_sendrecv,
 735        no_debug_ospf6_zebra_cmd,
 736        "no debug ospf6 zebra",
 737        NO_STR
 738        DEBUG_STR
 739        OSPF6_STR
 740        "Debug connection between zebra\n"
 741       )
 742
 743 int
 744 config_write_ospf6_debug_zebra (struct vty *vty)
 745 {
 746   if (IS_OSPF6_DEBUG_ZEBRA (SEND) && IS_OSPF6_DEBUG_ZEBRA (RECV))
 747     vty_out (vty, "debug ospf6 zebra%s", VNL);
 748   else
 749     {
 750       if (IS_OSPF6_DEBUG_ZEBRA (SEND))
 751         vty_out (vty, "debug ospf6 zebra send%s", VNL);
 752       if (IS_OSPF6_DEBUG_ZEBRA (RECV))
 753         vty_out (vty, "debug ospf6 zebra recv%s", VNL);
 754     }
 755   return 0;
 756 }
 757
 758 void
 759 install_element_ospf6_debug_zebra (void)
 760 {
 761   install_element (ENABLE_NODE, &debug_ospf6_zebra_cmd);
 762   install_element (ENABLE_NODE, &no_debug_ospf6_zebra_cmd);
 763   install_element (ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
 764   install_element (ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
 765   install_element (CONFIG_NODE, &debug_ospf6_zebra_cmd);
 766   install_element (CONFIG_NODE, &no_debug_ospf6_zebra_cmd);
 767   install_element (CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
 768   install_element (CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
 769 }
 770
 771