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 along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "log.h"
  24 #include "vty.h"
  25 #include "command.h"
  26 #include "prefix.h"
  27 #include "stream.h"
  28 #include "zclient.h"
  29 #include "memory.h"
  30 #include "lib/bfd.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 DEFINE_MTYPE_STATIC(OSPF6D, OSPF6_DISTANCE, "OSPF6 distance")
  43
  44 unsigned char conf_debug_ospf6_zebra = 0;
  45
  46 /* information about zebra. */
  47 struct zclient *zclient = NULL;
  48
  49 struct in_addr router_id_zebra;
  50
  51 /* Router-id update message from zebra. */
  52 static int ospf6_router_id_update_zebra(int command, struct zclient *zclient,
  53                                         zebra_size_t length, vrf_id_t vrf_id)
  54 {
  55         struct prefix router_id;
  56         struct ospf6 *o = ospf6;
  57
  58         zebra_router_id_update_read(zclient->ibuf, &router_id);
  59         router_id_zebra = router_id.u.prefix4;
  60
  61         if (o == NULL)
  62                 return 0;
  63
  64         if (o->router_id == 0)
  65                 o->router_id = (u_int32_t)router_id_zebra.s_addr;
  66
  67         return 0;
  68 }
  69
  70 /* redistribute function */
  71 void ospf6_zebra_redistribute(int type)
  72 {
  73         if (vrf_bitmap_check(zclient->redist[AFI_IP6][type], VRF_DEFAULT))
  74                 return;
  75         vrf_bitmap_set(zclient->redist[AFI_IP6][type], VRF_DEFAULT);
  76
  77         if (zclient->sock > 0)
  78                 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient,
  79                                         AFI_IP6, type, 0, VRF_DEFAULT);
  80 }
  81
  82 void ospf6_zebra_no_redistribute(int type)
  83 {
  84         if (!vrf_bitmap_check(zclient->redist[AFI_IP6][type], VRF_DEFAULT))
  85                 return;
  86         vrf_bitmap_unset(zclient->redist[AFI_IP6][type], VRF_DEFAULT);
  87         if (zclient->sock > 0)
  88                 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient,
  89                                         AFI_IP6, type, 0, VRF_DEFAULT);
  90 }
  91
  92 /* Inteface addition message from zebra. */
  93 static int ospf6_zebra_if_add(int command, struct zclient *zclient,
  94                               zebra_size_t length, vrf_id_t vrf_id)
  95 {
  96         struct interface *ifp;
  97
  98         ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
  99         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 100                 zlog_debug("Zebra Interface add: %s index %d mtu %d", ifp->name,
 101                            ifp->ifindex, ifp->mtu6);
 102         ospf6_interface_if_add(ifp);
 103         return 0;
 104 }
 105
 106 static int ospf6_zebra_if_del(int command, struct zclient *zclient,
 107                               zebra_size_t length, vrf_id_t vrf_id)
 108 {
 109         struct interface *ifp;
 110
 111         if (!(ifp = zebra_interface_state_read(zclient->ibuf, vrf_id)))
 112                 return 0;
 113
 114         if (if_is_up(ifp))
 115                 zlog_warn("Zebra: got delete of %s, but interface is still up",
 116                           ifp->name);
 117
 118         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 119                 zlog_debug("Zebra Interface delete: %s index %d mtu %d",
 120                            ifp->name, ifp->ifindex, ifp->mtu6);
 121
 122 #if 0
 123   /* XXX: ospf6_interface_if_del is not the right way to handle this,
 124    * because among other thinkable issues, it will also clear all
 125    * settings as they are contained in the struct ospf6_interface. */
 126   ospf6_interface_if_del (ifp);
 127 #endif /*0*/
 128
 129         if_set_index(ifp, IFINDEX_INTERNAL);
 130         return 0;
 131 }
 132
 133 static int ospf6_zebra_if_state_update(int command, struct zclient *zclient,
 134                                        zebra_size_t length, vrf_id_t vrf_id)
 135 {
 136         struct interface *ifp;
 137
 138         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 139         if (ifp == NULL)
 140                 return 0;
 141
 142         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 143                 zlog_debug(
 144                         "Zebra Interface state change: "
 145                         "%s index %d flags %llx metric %d mtu %d bandwidth %d",
 146                         ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
 147                         ifp->metric, ifp->mtu6, ifp->bandwidth);
 148
 149         ospf6_interface_state_update(ifp);
 150         return 0;
 151 }
 152
 153 static int ospf6_zebra_if_address_update_add(int command,
 154                                              struct zclient *zclient,
 155                                              zebra_size_t length,
 156                                              vrf_id_t vrf_id)
 157 {
 158         struct connected *c;
 159         char buf[128];
 160
 161         c = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD,
 162                                          zclient->ibuf, vrf_id);
 163         if (c == NULL)
 164                 return 0;
 165
 166         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 167                 zlog_debug("Zebra Interface address add: %s %5s %s/%d",
 168                            c->ifp->name, prefix_family_str(c->address),
 169                            inet_ntop(c->address->family, &c->address->u.prefix,
 170                                      buf, sizeof(buf)),
 171                            c->address->prefixlen);
 172
 173         if (c->address->family == AF_INET6) {
 174                 ospf6_interface_state_update(c->ifp);
 175                 ospf6_interface_connected_route_update(c->ifp);
 176         }
 177         return 0;
 178 }
 179
 180 static int ospf6_zebra_if_address_update_delete(int command,
 181                                                 struct zclient *zclient,
 182                                                 zebra_size_t length,
 183                                                 vrf_id_t vrf_id)
 184 {
 185         struct connected *c;
 186         char buf[128];
 187
 188         c = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE,
 189                                          zclient->ibuf, vrf_id);
 190         if (c == NULL)
 191                 return 0;
 192
 193         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 194                 zlog_debug("Zebra Interface address delete: %s %5s %s/%d",
 195                            c->ifp->name, prefix_family_str(c->address),
 196                            inet_ntop(c->address->family, &c->address->u.prefix,
 197                                      buf, sizeof(buf)),
 198                            c->address->prefixlen);
 199
 200         if (c->address->family == AF_INET6) {
 201                 ospf6_interface_connected_route_update(c->ifp);
 202                 ospf6_interface_state_update(c->ifp);
 203         }
 204
 205         connected_free(c);
 206
 207         return 0;
 208 }
 209
 210 static int ospf6_zebra_read_route(int command, struct zclient *zclient,
 211                                   zebra_size_t length, vrf_id_t vrf_id)
 212 {
 213         struct zapi_route api;
 214         unsigned long ifindex;
 215         struct in6_addr *nexthop;
 216
 217         if (ospf6 == NULL)
 218                 return 0;
 219
 220         if (zapi_route_decode(zclient->ibuf, &api) < 0)
 221                 return -1;
 222
 223         /* we completely ignore srcdest routes for now. */
 224         if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
 225                 return 0;
 226
 227         ifindex = api.nexthops[0].ifindex;
 228         nexthop = &api.nexthops[0].gate.ipv6;
 229
 230         if (IS_OSPF6_DEBUG_ZEBRA(RECV)) {
 231                 char prefixstr[PREFIX2STR_BUFFER], nexthopstr[128];
 232                 prefix2str((struct prefix *)&api.prefix, prefixstr,
 233                            sizeof(prefixstr));
 234                 inet_ntop(AF_INET6, nexthop, nexthopstr, sizeof(nexthopstr));
 235
 236                 zlog_debug(
 237                         "Zebra Receive route %s: %s %s nexthop %s ifindex %ld tag %" ROUTE_TAG_PRI,
 238                         (command == ZEBRA_REDISTRIBUTE_ROUTE_ADD ? "add"
 239                                                                  : "delete"),
 240                         zebra_route_string(api.type), prefixstr, nexthopstr,
 241                         ifindex, api.tag);
 242         }
 243
 244         if (command == ZEBRA_REDISTRIBUTE_ROUTE_ADD)
 245                 ospf6_asbr_redistribute_add(api.type, ifindex, &api.prefix,
 246                                             api.nexthop_num, nexthop, api.tag);
 247         else
 248                 ospf6_asbr_redistribute_remove(api.type, ifindex, &api.prefix);
 249
 250         return 0;
 251 }
 252
 253 DEFUN (show_zebra,
 254        show_ospf6_zebra_cmd,
 255        "show ipv6 ospf6 zebra",
 256        SHOW_STR
 257        IPV6_STR
 258        OSPF6_STR
 259        ZEBRA_STR)
 260 {
 261         int i;
 262         if (zclient == NULL) {
 263                 vty_out(vty, "Not connected to zebra\n");
 264                 return CMD_SUCCESS;
 265         }
 266
 267         vty_out(vty, "Zebra Infomation\n");
 268         vty_out(vty, "  fail: %d\n", zclient->fail);
 269         vty_out(vty, "  redistribute default: %d\n",
 270                 vrf_bitmap_check(zclient->default_information, VRF_DEFAULT));
 271         vty_out(vty, "  redistribute:");
 272         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 273                 if (vrf_bitmap_check(zclient->redist[AFI_IP6][i], VRF_DEFAULT))
 274                         vty_out(vty, " %s", zebra_route_string(i));
 275         }
 276         vty_out(vty, "\n");
 277         return CMD_SUCCESS;
 278 }
 279
 280 #define ADD    0
 281 #define REM    1
 282 static void ospf6_zebra_route_update(int type, struct ospf6_route *request)
 283 {
 284         struct zapi_route api;
 285         char buf[PREFIX2STR_BUFFER];
 286         int nhcount;
 287         int ret = 0;
 288         struct prefix *dest;
 289
 290         if (IS_OSPF6_DEBUG_ZEBRA(SEND)) {
 291                 prefix2str(&request->prefix, buf, sizeof(buf));
 292                 zlog_debug("Send %s route: %s",
 293                            (type == REM ? "remove" : "add"), buf);
 294         }
 295
 296         if (zclient->sock < 0) {
 297                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 298                         zlog_debug("  Not connected to Zebra");
 299                 return;
 300         }
 301
 302         if (request->path.origin.adv_router == ospf6->router_id
 303             && (request->path.type == OSPF6_PATH_TYPE_EXTERNAL1
 304                 || request->path.type == OSPF6_PATH_TYPE_EXTERNAL2)) {
 305                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 306                         zlog_debug("  Ignore self-originated external route");
 307                 return;
 308         }
 309
 310         /* If removing is the best path and if there's another path,
 311            treat this request as add the secondary path */
 312         if (type == REM && ospf6_route_is_best(request) && request->next
 313             && ospf6_route_is_same(request, request->next)) {
 314                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 315                         zlog_debug(
 316                                 "  Best-path removal resulted Sencondary addition");
 317                 type = ADD;
 318                 request = request->next;
 319         }
 320
 321         /* Only the best path will be sent to zebra. */
 322         if (!ospf6_route_is_best(request)) {
 323                 /* this is not preferred best route, ignore */
 324                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 325                         zlog_debug("  Ignore non-best route");
 326                 return;
 327         }
 328
 329         nhcount = ospf6_route_num_nexthops(request);
 330         if (nhcount == 0) {
 331                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 332                         zlog_debug("  No nexthop, ignore");
 333                 return;
 334         }
 335
 336         dest = &request->prefix;
 337
 338         memset(&api, 0, sizeof(api));
 339         api.vrf_id = VRF_DEFAULT;
 340         api.type = ZEBRA_ROUTE_OSPF6;
 341         api.safi = SAFI_UNICAST;
 342         api.prefix = *dest;
 343         SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
 344         api.nexthop_num = MIN(nhcount, MULTIPATH_NUM);
 345         ospf6_route_zebra_copy_nexthops(request, api.nexthops, api.nexthop_num);
 346         SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
 347         api.metric = (request->path.metric_type == 2 ? request->path.u.cost_e2
 348                                                      : request->path.cost);
 349         if (request->path.tag) {
 350                 SET_FLAG(api.message, ZAPI_MESSAGE_TAG);
 351                 api.tag = request->path.tag;
 352         }
 353
 354         SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
 355         api.distance =
 356                 ospf6_distance_apply((struct prefix_ipv6 *)dest, request);
 357
 358         if (type == REM)
 359                 ret = zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 360         else
 361                 ret = zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 362
 363         if (ret < 0)
 364                 zlog_err("zclient_route_send() %s failed: %s",
 365                          (type == REM ? "delete" : "add"),
 366                          safe_strerror(errno));
 367
 368         return;
 369 }
 370
 371 void ospf6_zebra_route_update_add(struct ospf6_route *request)
 372 {
 373         ospf6_zebra_route_update(ADD, request);
 374 }
 375
 376 void ospf6_zebra_route_update_remove(struct ospf6_route *request)
 377 {
 378         ospf6_zebra_route_update(REM, request);
 379 }
 380
 381 void ospf6_zebra_add_discard(struct ospf6_route *request)
 382 {
 383         struct zapi_route api;
 384         char buf[INET6_ADDRSTRLEN];
 385         struct prefix *dest = &request->prefix;
 386
 387         if (!CHECK_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED)) {
 388                 memset(&api, 0, sizeof(api));
 389                 api.vrf_id = VRF_DEFAULT;
 390                 api.type = ZEBRA_ROUTE_OSPF6;
 391                 api.safi = SAFI_UNICAST;
 392                 api.prefix = *dest;
 393                 zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
 394
 395                 zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 396
 397                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 398                         zlog_debug("Zebra: Route add discard %s/%d",
 399                                    inet_ntop(AF_INET6, &dest->u.prefix6, buf,
 400                                              INET6_ADDRSTRLEN),
 401                                    dest->prefixlen);
 402
 403                 SET_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED);
 404         } else {
 405                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 406                         zlog_debug(
 407                                 "Zebra: Blackhole route present already %s/%d",
 408                                 inet_ntop(AF_INET6, &dest->u.prefix6, buf,
 409                                           INET6_ADDRSTRLEN),
 410                                 dest->prefixlen);
 411         }
 412 }
 413
 414 void ospf6_zebra_delete_discard(struct ospf6_route *request)
 415 {
 416         struct zapi_route api;
 417         char buf[INET6_ADDRSTRLEN];
 418         struct prefix *dest = &request->prefix;
 419
 420         if (CHECK_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED)) {
 421                 memset(&api, 0, sizeof(api));
 422                 api.vrf_id = VRF_DEFAULT;
 423                 api.type = ZEBRA_ROUTE_OSPF6;
 424                 api.safi = SAFI_UNICAST;
 425                 api.prefix = *dest;
 426                 zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
 427
 428                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 429
 430                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 431                         zlog_debug("Zebra: Route delete discard %s/%d",
 432                                    inet_ntop(AF_INET6, &dest->u.prefix6, buf,
 433                                              INET6_ADDRSTRLEN),
 434                                    dest->prefixlen);
 435
 436                 UNSET_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED);
 437         } else {
 438                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 439                         zlog_debug(
 440                                 "Zebra: Blackhole route already deleted %s/%d",
 441                                 inet_ntop(AF_INET6, &dest->u.prefix6, buf,
 442                                           INET6_ADDRSTRLEN),
 443                                 dest->prefixlen);
 444         }
 445 }
 446
 447 static struct ospf6_distance *ospf6_distance_new(void)
 448 {
 449         return XCALLOC(MTYPE_OSPF6_DISTANCE, sizeof(struct ospf6_distance));
 450 }
 451
 452 static void ospf6_distance_free(struct ospf6_distance *odistance)
 453 {
 454         XFREE(MTYPE_OSPF6_DISTANCE, odistance);
 455 }
 456
 457 int ospf6_distance_set(struct vty *vty, struct ospf6 *o,
 458                        const char *distance_str, const char *ip_str,
 459                        const char *access_list_str)
 460 {
 461         int ret;
 462         struct prefix_ipv6 p;
 463         u_char distance;
 464         struct route_node *rn;
 465         struct ospf6_distance *odistance;
 466
 467         ret = str2prefix_ipv6(ip_str, &p);
 468         if (ret == 0) {
 469                 vty_out(vty, "Malformed prefix\n");
 470                 return CMD_WARNING_CONFIG_FAILED;
 471         }
 472
 473         distance = atoi(distance_str);
 474
 475         /* Get OSPF6 distance node. */
 476         rn = route_node_get(o->distance_table, (struct prefix *)&p);
 477         if (rn->info) {
 478                 odistance = rn->info;
 479                 route_unlock_node(rn);
 480         } else {
 481                 odistance = ospf6_distance_new();
 482                 rn->info = odistance;
 483         }
 484
 485         /* Set distance value. */
 486         odistance->distance = distance;
 487
 488         /* Reset access-list configuration. */
 489         if (odistance->access_list) {
 490                 free(odistance->access_list);
 491                 odistance->access_list = NULL;
 492         }
 493         if (access_list_str)
 494                 odistance->access_list = strdup(access_list_str);
 495
 496         return CMD_SUCCESS;
 497 }
 498
 499 int ospf6_distance_unset(struct vty *vty, struct ospf6 *o,
 500                          const char *distance_str, const char *ip_str,
 501                          const char *access_list_str)
 502 {
 503         int ret;
 504         struct prefix_ipv6 p;
 505         struct route_node *rn;
 506         struct ospf6_distance *odistance;
 507
 508         ret = str2prefix_ipv6(ip_str, &p);
 509         if (ret == 0) {
 510                 vty_out(vty, "Malformed prefix\n");
 511                 return CMD_WARNING_CONFIG_FAILED;
 512         }
 513
 514         rn = route_node_lookup(o->distance_table, (struct prefix *)&p);
 515         if (!rn) {
 516                 vty_out(vty, "Cant't find specified prefix\n");
 517                 return CMD_WARNING_CONFIG_FAILED;
 518         }
 519
 520         odistance = rn->info;
 521
 522         if (odistance->access_list)
 523                 free(odistance->access_list);
 524         ospf6_distance_free(odistance);
 525
 526         rn->info = NULL;
 527         route_unlock_node(rn);
 528         route_unlock_node(rn);
 529
 530         return CMD_SUCCESS;
 531 }
 532
 533 void ospf6_distance_reset(struct ospf6 *o)
 534 {
 535         struct route_node *rn;
 536         struct ospf6_distance *odistance;
 537
 538         for (rn = route_top(o->distance_table); rn; rn = route_next(rn))
 539                 if ((odistance = rn->info) != NULL) {
 540                         if (odistance->access_list)
 541                                 free(odistance->access_list);
 542                         ospf6_distance_free(odistance);
 543                         rn->info = NULL;
 544                         route_unlock_node(rn);
 545                 }
 546 }
 547
 548 u_char ospf6_distance_apply(struct prefix_ipv6 *p, struct ospf6_route * or)
 549 {
 550         struct ospf6 *o;
 551
 552         o = ospf6;
 553         if (o == NULL)
 554                 return 0;
 555
 556         if (o->distance_intra)
 557                 if (or->path.type == OSPF6_PATH_TYPE_INTRA)
 558                         return o->distance_intra;
 559
 560         if (o->distance_inter)
 561                 if (or->path.type == OSPF6_PATH_TYPE_INTER)
 562                         return o->distance_inter;
 563
 564         if (o->distance_external)
 565                 if (or->path.type == OSPF6_PATH_TYPE_EXTERNAL1 ||
 566                     or->path.type == OSPF6_PATH_TYPE_EXTERNAL2)
 567                         return o->distance_external;
 568
 569         if (o->distance_all)
 570                 return o->distance_all;
 571
 572         return 0;
 573 }
 574
 575 static void ospf6_zebra_connected(struct zclient *zclient)
 576 {
 577         /* Send the client registration */
 578         bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER);
 579
 580         zclient_send_reg_requests(zclient, VRF_DEFAULT);
 581 }
 582
 583 void ospf6_zebra_init(struct thread_master *master)
 584 {
 585         /* Allocate zebra structure. */
 586         zclient = zclient_new_notify(master, &zclient_options_default);
 587         zclient_init(zclient, ZEBRA_ROUTE_OSPF6, 0, &ospf6d_privs);
 588         zclient->zebra_connected = ospf6_zebra_connected;
 589         zclient->router_id_update = ospf6_router_id_update_zebra;
 590         zclient->interface_add = ospf6_zebra_if_add;
 591         zclient->interface_delete = ospf6_zebra_if_del;
 592         zclient->interface_up = ospf6_zebra_if_state_update;
 593         zclient->interface_down = ospf6_zebra_if_state_update;
 594         zclient->interface_address_add = ospf6_zebra_if_address_update_add;
 595         zclient->interface_address_delete =
 596                 ospf6_zebra_if_address_update_delete;
 597         zclient->redistribute_route_add = ospf6_zebra_read_route;
 598         zclient->redistribute_route_del = ospf6_zebra_read_route;
 599
 600         /* Install command element for zebra node. */
 601         install_element(VIEW_NODE, &show_ospf6_zebra_cmd);
 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         int idx_send_recv = 3;
 617         unsigned char level = 0;
 618
 619         if (argc == 4) {
 620                 if (strmatch(argv[idx_send_recv]->text, "send"))
 621                         level = OSPF6_DEBUG_ZEBRA_SEND;
 622                 else if (strmatch(argv[idx_send_recv]->text, "recv"))
 623                         level = OSPF6_DEBUG_ZEBRA_RECV;
 624         } else
 625                 level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
 626
 627         OSPF6_DEBUG_ZEBRA_ON(level);
 628         return CMD_SUCCESS;
 629 }
 630
 631 DEFUN (no_debug_ospf6_zebra_sendrecv,
 632        no_debug_ospf6_zebra_sendrecv_cmd,
 633        "no debug ospf6 zebra [<send|recv>]",
 634        NO_STR
 635        DEBUG_STR
 636        OSPF6_STR
 637        "Debug connection between zebra\n"
 638        "Debug Sending zebra\n"
 639        "Debug Receiving zebra\n"
 640       )
 641 {
 642         int idx_send_recv = 4;
 643         unsigned char level = 0;
 644
 645         if (argc == 5) {
 646                 if (strmatch(argv[idx_send_recv]->text, "send"))
 647                         level = OSPF6_DEBUG_ZEBRA_SEND;
 648                 else if (strmatch(argv[idx_send_recv]->text, "recv"))
 649                         level = OSPF6_DEBUG_ZEBRA_RECV;
 650         } else
 651                 level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
 652
 653         OSPF6_DEBUG_ZEBRA_OFF(level);
 654         return CMD_SUCCESS;
 655 }
 656
 657
 658 int config_write_ospf6_debug_zebra(struct vty *vty)
 659 {
 660         if (IS_OSPF6_DEBUG_ZEBRA(SEND) && IS_OSPF6_DEBUG_ZEBRA(RECV))
 661                 vty_out(vty, "debug ospf6 zebra\n");
 662         else {
 663                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 664                         vty_out(vty, "debug ospf6 zebra send\n");
 665                 if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 666                         vty_out(vty, "debug ospf6 zebra recv\n");
 667         }
 668         return 0;
 669 }
 670
 671 void install_element_ospf6_debug_zebra(void)
 672 {
 673         install_element(ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
 674         install_element(ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
 675         install_element(CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
 676         install_element(CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
 677 }