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 "route_opaque.h"
  31 #include "lib/bfd.h"
  32 #include "lib_errors.h"
  33
  34 #include "ospf6_proto.h"
  35 #include "ospf6_top.h"
  36 #include "ospf6_interface.h"
  37 #include "ospf6_route.h"
  38 #include "ospf6_lsa.h"
  39 #include "ospf6_lsdb.h"
  40 #include "ospf6_asbr.h"
  41 #include "ospf6_nssa.h"
  42 #include "ospf6_zebra.h"
  43 #include "ospf6d.h"
  44 #include "ospf6_area.h"
  45 #include "ospf6_gr.h"
  46 #include "lib/json.h"
  47
  48 DEFINE_MTYPE_STATIC(OSPF6D, OSPF6_DISTANCE, "OSPF6 distance");
  49
  50 unsigned char conf_debug_ospf6_zebra = 0;
  51
  52 /* information about zebra. */
  53 struct zclient *zclient = NULL;
  54
  55 void ospf6_zebra_vrf_register(struct ospf6 *ospf6)
  56 {
  57         if (!zclient || zclient->sock < 0 || !ospf6)
  58                 return;
  59
  60         if (ospf6->vrf_id != VRF_UNKNOWN) {
  61                 if (IS_OSPF6_DEBUG_ZEBRA(RECV)) {
  62                         zlog_debug("%s: Register VRF %s id %u", __func__,
  63                                    ospf6_vrf_id_to_name(ospf6->vrf_id),
  64                                    ospf6->vrf_id);
  65                 }
  66                 zclient_send_reg_requests(zclient, ospf6->vrf_id);
  67         }
  68 }
  69
  70 void ospf6_zebra_vrf_deregister(struct ospf6 *ospf6)
  71 {
  72         if (!zclient || zclient->sock < 0 || !ospf6)
  73                 return;
  74
  75         if (ospf6->vrf_id != VRF_DEFAULT && ospf6->vrf_id != VRF_UNKNOWN) {
  76                 if (IS_OSPF6_DEBUG_ZEBRA(RECV)) {
  77                         zlog_debug("%s: De-Register VRF %s id %u to Zebra.",
  78                                    __func__,
  79                                    ospf6_vrf_id_to_name(ospf6->vrf_id),
  80                                    ospf6->vrf_id);
  81                 }
  82                 /* Deregister for router-id, interfaces,
  83                  * redistributed routes. */
  84                 zclient_send_dereg_requests(zclient, ospf6->vrf_id);
  85         }
  86 }
  87
  88 /* Router-id update message from zebra. */
  89 static int ospf6_router_id_update_zebra(ZAPI_CALLBACK_ARGS)
  90 {
  91         struct prefix router_id;
  92         struct ospf6 *o;
  93
  94         zebra_router_id_update_read(zclient->ibuf, &router_id);
  95
  96         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
  97                 zlog_debug("Zebra router-id update %pI4 vrf %s id %u",
  98                            &router_id.u.prefix4, ospf6_vrf_id_to_name(vrf_id),
  99                            vrf_id);
 100
 101         o = ospf6_lookup_by_vrf_id(vrf_id);
 102         if (o == NULL)
 103                 return 0;
 104
 105         o->router_id_zebra = router_id.u.prefix4.s_addr;
 106
 107         ospf6_router_id_update(o, false);
 108
 109         return 0;
 110 }
 111
 112 /* redistribute function */
 113 void ospf6_zebra_redistribute(int type, vrf_id_t vrf_id)
 114 {
 115         if (vrf_bitmap_check(zclient->redist[AFI_IP6][type], vrf_id))
 116                 return;
 117         vrf_bitmap_set(zclient->redist[AFI_IP6][type], vrf_id);
 118
 119         if (zclient->sock > 0)
 120                 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient,
 121                                         AFI_IP6, type, 0, vrf_id);
 122 }
 123
 124 void ospf6_zebra_no_redistribute(int type, vrf_id_t vrf_id)
 125 {
 126         if (!vrf_bitmap_check(zclient->redist[AFI_IP6][type], vrf_id))
 127                 return;
 128         vrf_bitmap_unset(zclient->redist[AFI_IP6][type], vrf_id);
 129         if (zclient->sock > 0)
 130                 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient,
 131                                         AFI_IP6, type, 0, vrf_id);
 132 }
 133
 134 void ospf6_zebra_import_default_route(struct ospf6 *ospf6, bool unreg)
 135 {
 136         struct prefix prefix = {};
 137         int command;
 138
 139         if (zclient->sock < 0) {
 140                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 141                         zlog_debug("  Not connected to Zebra");
 142                 return;
 143         }
 144
 145         prefix.family = AF_INET6;
 146         prefix.prefixlen = 0;
 147
 148         if (unreg)
 149                 command = ZEBRA_NEXTHOP_UNREGISTER;
 150         else
 151                 command = ZEBRA_NEXTHOP_REGISTER;
 152
 153         if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 154                 zlog_debug("%s: sending cmd %s for %pFX (vrf %u)", __func__,
 155                            zserv_command_string(command), &prefix,
 156                            ospf6->vrf_id);
 157
 158         if (zclient_send_rnh(zclient, command, &prefix, SAFI_UNICAST, false,
 159                              true, ospf6->vrf_id)
 160             == ZCLIENT_SEND_FAILURE)
 161                 flog_err(EC_LIB_ZAPI_SOCKET, "%s: zclient_send_rnh() failed",
 162                          __func__);
 163 }
 164
 165 static int ospf6_zebra_import_check_update(ZAPI_CALLBACK_ARGS)
 166 {
 167         struct ospf6 *ospf6;
 168         struct zapi_route nhr;
 169         struct prefix matched;
 170
 171         ospf6 = ospf6_lookup_by_vrf_id(vrf_id);
 172         if (ospf6 == NULL || !IS_OSPF6_ASBR(ospf6))
 173                 return 0;
 174
 175         if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &nhr)) {
 176                 zlog_err("%s[%u]: Failure to decode route", __func__,
 177                          ospf6->vrf_id);
 178                 return -1;
 179         }
 180
 181         if (matched.family != AF_INET6 || matched.prefixlen != 0 ||
 182             nhr.type == ZEBRA_ROUTE_OSPF6)
 183                 return 0;
 184
 185         ospf6->nssa_default_import_check.status = !!nhr.nexthop_num;
 186         ospf6_abr_nssa_type_7_defaults(ospf6);
 187
 188         return 0;
 189 }
 190
 191 static int ospf6_zebra_if_address_update_add(ZAPI_CALLBACK_ARGS)
 192 {
 193         struct connected *c;
 194
 195         c = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD,
 196                                          zclient->ibuf, vrf_id);
 197         if (c == NULL)
 198                 return 0;
 199
 200         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 201                 zlog_debug("Zebra Interface address add: %s %5s %pFX",
 202                            c->ifp->name, prefix_family_str(c->address),
 203                            c->address);
 204
 205         if (c->address->family == AF_INET6) {
 206                 ospf6_interface_state_update(c->ifp);
 207                 ospf6_interface_connected_route_update(c->ifp);
 208         }
 209         return 0;
 210 }
 211
 212 static int ospf6_zebra_if_address_update_delete(ZAPI_CALLBACK_ARGS)
 213 {
 214         struct connected *c;
 215
 216         c = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE,
 217                                          zclient->ibuf, vrf_id);
 218         if (c == NULL)
 219                 return 0;
 220
 221         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 222                 zlog_debug("Zebra Interface address delete: %s %5s %pFX",
 223                            c->ifp->name, prefix_family_str(c->address),
 224                            c->address);
 225
 226         if (c->address->family == AF_INET6) {
 227                 ospf6_interface_connected_route_update(c->ifp);
 228                 ospf6_interface_state_update(c->ifp);
 229         }
 230
 231         connected_free(&c);
 232
 233         return 0;
 234 }
 235
 236 static int ospf6_zebra_gr_update(struct ospf6 *ospf6, int command,
 237                                  uint32_t stale_time)
 238 {
 239         struct zapi_cap api;
 240
 241         if (!zclient || zclient->sock < 0 || !ospf6)
 242                 return 1;
 243
 244         memset(&api, 0, sizeof(api));
 245         api.cap = command;
 246         api.stale_removal_time = stale_time;
 247         api.vrf_id = ospf6->vrf_id;
 248
 249         (void)zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES, zclient,
 250                                         &api);
 251
 252         return 0;
 253 }
 254
 255 int ospf6_zebra_gr_enable(struct ospf6 *ospf6, uint32_t stale_time)
 256 {
 257         return ospf6_zebra_gr_update(ospf6, ZEBRA_CLIENT_GR_CAPABILITIES,
 258                                      stale_time);
 259 }
 260
 261 int ospf6_zebra_gr_disable(struct ospf6 *ospf6)
 262 {
 263         return ospf6_zebra_gr_update(ospf6, ZEBRA_CLIENT_GR_DISABLE, 0);
 264 }
 265
 266 static int ospf6_zebra_read_route(ZAPI_CALLBACK_ARGS)
 267 {
 268         struct zapi_route api;
 269         unsigned long ifindex;
 270         struct in6_addr *nexthop;
 271         struct ospf6 *ospf6;
 272         struct prefix_ipv6 p;
 273
 274         ospf6 = ospf6_lookup_by_vrf_id(vrf_id);
 275
 276         if (ospf6 == NULL)
 277                 return 0;
 278
 279         if (zapi_route_decode(zclient->ibuf, &api) < 0)
 280                 return -1;
 281
 282         /* we completely ignore srcdest routes for now. */
 283         if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
 284                 return 0;
 285
 286         if (IN6_IS_ADDR_LINKLOCAL(&api.prefix.u.prefix6))
 287                 return 0;
 288
 289         ifindex = api.nexthops[0].ifindex;
 290         nexthop = &api.nexthops[0].gate.ipv6;
 291
 292         if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 293                 zlog_debug(
 294                         "Zebra Receive route %s: %s %pFX nexthop %pI6 ifindex %ld tag %" ROUTE_TAG_PRI,
 295                         (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD ? "add"
 296                                                              : "delete"),
 297                         zebra_route_string(api.type), &api.prefix, nexthop,
 298                         ifindex, api.tag);
 299
 300         memcpy(&p, &api.prefix, sizeof(p));
 301         if (is_default_prefix6(&p))
 302                 api.type = DEFAULT_ROUTE;
 303
 304         if (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD)
 305                 ospf6_asbr_redistribute_add(api.type, ifindex, &api.prefix,
 306                                             api.nexthop_num, nexthop, api.tag,
 307                                             ospf6);
 308         else
 309                 ospf6_asbr_redistribute_remove(api.type, ifindex, &api.prefix,
 310                                                ospf6);
 311
 312         return 0;
 313 }
 314
 315 DEFUN(show_zebra,
 316       show_ospf6_zebra_cmd,
 317       "show ipv6 ospf6 zebra [json]",
 318       SHOW_STR
 319       IPV6_STR
 320       OSPF6_STR
 321       ZEBRA_STR
 322       JSON_STR)
 323 {
 324         int i;
 325         bool uj = use_json(argc, argv);
 326         json_object *json;
 327         json_object *json_zebra;
 328         json_object *json_array;
 329
 330         if (zclient == NULL) {
 331                 vty_out(vty, "Not connected to zebra\n");
 332                 return CMD_SUCCESS;
 333         }
 334
 335         if (uj) {
 336                 json = json_object_new_object();
 337                 json_zebra = json_object_new_object();
 338                 json_array = json_object_new_array();
 339
 340                 json_object_int_add(json_zebra, "fail", zclient->fail);
 341                 json_object_int_add(
 342                         json_zebra, "redistributeDefault",
 343                         vrf_bitmap_check(zclient->default_information[AFI_IP6],
 344                                          VRF_DEFAULT));
 345                 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 346                         if (vrf_bitmap_check(zclient->redist[AFI_IP6][i],
 347                                              VRF_DEFAULT))
 348                                 json_object_array_add(
 349                                         json_array,
 350                                         json_object_new_string(
 351                                                 zebra_route_string(i)));
 352                 }
 353                 json_object_object_add(json_zebra, "redistribute", json_array);
 354                 json_object_object_add(json, "zebraInformation", json_zebra);
 355
 356                 vty_json(vty, json);
 357         } else {
 358                 vty_out(vty, "Zebra Information\n");
 359                 vty_out(vty, "  fail: %d\n", zclient->fail);
 360                 vty_out(vty, "  redistribute default: %d\n",
 361                         vrf_bitmap_check(zclient->default_information[AFI_IP6],
 362                                          VRF_DEFAULT));
 363                 vty_out(vty, "  redistribute:");
 364                 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 365                         if (vrf_bitmap_check(zclient->redist[AFI_IP6][i],
 366                                              VRF_DEFAULT))
 367                                 vty_out(vty, " %s", zebra_route_string(i));
 368                 }
 369                 vty_out(vty, "\n");
 370         }
 371         return CMD_SUCCESS;
 372 }
 373
 374 static void ospf6_zebra_append_opaque_attr(struct ospf6_route *request,
 375                                            struct zapi_route *api)
 376 {
 377         struct ospf_zebra_opaque ospf_opaque = {};
 378
 379         /* OSPF path type */
 380         snprintf(ospf_opaque.path_type, sizeof(ospf_opaque.path_type), "%s",
 381                  OSPF6_PATH_TYPE_NAME(request->path.type));
 382
 383         switch (request->path.type) {
 384         case OSPF6_PATH_TYPE_INTRA:
 385         case OSPF6_PATH_TYPE_INTER:
 386                 /* OSPF area ID */
 387                 (void)inet_ntop(AF_INET, &request->path.area_id,
 388                                 ospf_opaque.area_id,
 389                                 sizeof(ospf_opaque.area_id));
 390                 break;
 391         case OSPF6_PATH_TYPE_EXTERNAL1:
 392         case OSPF6_PATH_TYPE_EXTERNAL2:
 393                 /* OSPF route tag */
 394                 snprintf(ospf_opaque.tag, sizeof(ospf_opaque.tag), "%u",
 395                          request->path.tag);
 396                 break;
 397         default:
 398                 break;
 399         }
 400
 401         SET_FLAG(api->message, ZAPI_MESSAGE_OPAQUE);
 402         api->opaque.length = sizeof(struct ospf_zebra_opaque);
 403         memcpy(api->opaque.data, &ospf_opaque, api->opaque.length);
 404 }
 405
 406 #define ADD    0
 407 #define REM    1
 408 static void ospf6_zebra_route_update(int type, struct ospf6_route *request,
 409                                      struct ospf6 *ospf6)
 410 {
 411         struct zapi_route api;
 412         int nhcount;
 413         int ret = 0;
 414         struct prefix *dest;
 415
 416         if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 417                 zlog_debug("Zebra Send %s route: %pFX",
 418                            (type == REM ? "remove" : "add"), &request->prefix);
 419
 420         if (zclient->sock < 0) {
 421                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 422                         zlog_debug("  Not connected to Zebra");
 423                 return;
 424         }
 425
 426         if (request->path.origin.adv_router == ospf6->router_id
 427             && (request->path.type == OSPF6_PATH_TYPE_EXTERNAL1
 428                 || request->path.type == OSPF6_PATH_TYPE_EXTERNAL2)) {
 429                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 430                         zlog_debug("  Ignore self-originated external route");
 431                 return;
 432         }
 433
 434         /* If removing is the best path and if there's another path,
 435          * treat this request as add the secondary path - if there are
 436          * nexthops.
 437          */
 438         if (type == REM && ospf6_route_is_best(request) && request->next &&
 439             ospf6_route_is_same(request, request->next) &&
 440             ospf6_route_num_nexthops(request->next) > 0) {
 441                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 442                         zlog_debug(
 443                                 "  Best-path removal resulted Secondary addition");
 444                 type = ADD;
 445                 request = request->next;
 446         }
 447
 448         /* Only the best path will be sent to zebra. */
 449         if (!ospf6_route_is_best(request)) {
 450                 /* this is not preferred best route, ignore */
 451                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 452                         zlog_debug("  Ignore non-best route");
 453                 return;
 454         }
 455
 456         nhcount = ospf6_route_num_nexthops(request);
 457         if (nhcount == 0) {
 458                 if (type == ADD) {
 459                         if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 460                                 zlog_debug("  No nexthop, ignore");
 461                         return;
 462                 } else if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 463                         zlog_debug("  No nexthop, rem ok");
 464         }
 465
 466         dest = &request->prefix;
 467
 468         memset(&api, 0, sizeof(api));
 469         api.vrf_id = ospf6->vrf_id;
 470         api.type = ZEBRA_ROUTE_OSPF6;
 471         api.safi = SAFI_UNICAST;
 472         api.prefix = *dest;
 473
 474         if (nhcount > ospf6->max_multipath) {
 475                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 476                         zlog_debug(
 477                                 "  Nexthop count is greater than configured maximum-path, hence ignore the extra nexthops");
 478         }
 479
 480         api.nexthop_num = MIN(nhcount, ospf6->max_multipath);
 481         if (api.nexthop_num > 0) {
 482                 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
 483                 ospf6_route_zebra_copy_nexthops(request, api.nexthops,
 484                                                 api.nexthop_num, api.vrf_id);
 485         }
 486
 487         SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
 488         api.metric = (request->path.metric_type == 2 ? request->path.u.cost_e2
 489                                                      : request->path.cost);
 490         if (request->path.tag) {
 491                 SET_FLAG(api.message, ZAPI_MESSAGE_TAG);
 492                 api.tag = request->path.tag;
 493         }
 494
 495         SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
 496         api.distance = ospf6_distance_apply((struct prefix_ipv6 *)dest, request,
 497                                             ospf6);
 498
 499         if (type == ADD
 500             && CHECK_FLAG(ospf6->config_flags, OSPF6_SEND_EXTRA_DATA_TO_ZEBRA))
 501                 ospf6_zebra_append_opaque_attr(request, &api);
 502
 503         if (type == REM)
 504                 ret = zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 505         else
 506                 ret = zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 507
 508         if (ret == ZCLIENT_SEND_FAILURE)
 509                 flog_err(EC_LIB_ZAPI_SOCKET,
 510                          "zclient_route_send() %s failed: %s",
 511                          (type == REM ? "delete" : "add"),
 512                          safe_strerror(errno));
 513
 514         return;
 515 }
 516
 517 void ospf6_zebra_route_update_add(struct ospf6_route *request,
 518                                   struct ospf6 *ospf6)
 519 {
 520         if (ospf6->gr_info.restart_in_progress
 521             || ospf6->gr_info.prepare_in_progress) {
 522                 if (IS_DEBUG_OSPF6_GR)
 523                         zlog_debug(
 524                                 "Zebra: Graceful Restart in progress -- not installing %pFX",
 525                                 &request->prefix);
 526                 return;
 527         }
 528
 529         ospf6_zebra_route_update(ADD, request, ospf6);
 530 }
 531
 532 void ospf6_zebra_route_update_remove(struct ospf6_route *request,
 533                                      struct ospf6 *ospf6)
 534 {
 535         if (ospf6->gr_info.restart_in_progress
 536             || ospf6->gr_info.prepare_in_progress) {
 537                 if (IS_DEBUG_OSPF6_GR)
 538                         zlog_debug(
 539                                 "Zebra: Graceful Restart in progress -- not uninstalling %pFX",
 540                                 &request->prefix);
 541                 return;
 542         }
 543
 544         ospf6_zebra_route_update(REM, request, ospf6);
 545 }
 546
 547 void ospf6_zebra_add_discard(struct ospf6_route *request, struct ospf6 *ospf6)
 548 {
 549         struct zapi_route api;
 550         struct prefix *dest = &request->prefix;
 551
 552         if (ospf6->gr_info.restart_in_progress
 553             || ospf6->gr_info.prepare_in_progress) {
 554                 if (IS_DEBUG_OSPF6_GR)
 555                         zlog_debug(
 556                                 "Zebra: Graceful Restart in progress -- not installing %pFX",
 557                                 &request->prefix);
 558                 return;
 559         }
 560
 561         if (!CHECK_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED)) {
 562                 memset(&api, 0, sizeof(api));
 563                 api.vrf_id = ospf6->vrf_id;
 564                 api.type = ZEBRA_ROUTE_OSPF6;
 565                 api.safi = SAFI_UNICAST;
 566                 api.prefix = *dest;
 567                 zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
 568
 569                 zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 570
 571                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 572                         zlog_debug("Zebra: Route add discard %pFX", dest);
 573
 574                 SET_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED);
 575         } else {
 576                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 577                         zlog_debug(
 578                                 "Zebra: Blackhole route present already %pFX",
 579                                 dest);
 580         }
 581 }
 582
 583 void ospf6_zebra_delete_discard(struct ospf6_route *request,
 584                                 struct ospf6 *ospf6)
 585 {
 586         struct zapi_route api;
 587         struct prefix *dest = &request->prefix;
 588
 589         if (ospf6->gr_info.restart_in_progress
 590             || ospf6->gr_info.prepare_in_progress) {
 591                 if (IS_DEBUG_OSPF6_GR)
 592                         zlog_debug(
 593                                 "Zebra: Graceful Restart in progress -- not uninstalling %pFX",
 594                                 &request->prefix);
 595                 return;
 596         }
 597
 598         if (CHECK_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED)) {
 599                 memset(&api, 0, sizeof(api));
 600                 api.vrf_id = ospf6->vrf_id;
 601                 api.type = ZEBRA_ROUTE_OSPF6;
 602                 api.safi = SAFI_UNICAST;
 603                 api.prefix = *dest;
 604                 zapi_route_set_blackhole(&api, BLACKHOLE_NULL);
 605
 606                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 607
 608                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 609                         zlog_debug("Zebra: Route delete discard %pFX", dest);
 610
 611                 UNSET_FLAG(request->flag, OSPF6_ROUTE_BLACKHOLE_ADDED);
 612         } else {
 613                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 614                         zlog_debug(
 615                                 "Zebra: Blackhole route already deleted %pFX",
 616                                 dest);
 617         }
 618 }
 619
 620 static struct ospf6_distance *ospf6_distance_new(void)
 621 {
 622         return XCALLOC(MTYPE_OSPF6_DISTANCE, sizeof(struct ospf6_distance));
 623 }
 624
 625 static void ospf6_distance_free(struct ospf6_distance *odistance)
 626 {
 627         XFREE(MTYPE_OSPF6_DISTANCE, odistance);
 628 }
 629
 630 int ospf6_distance_set(struct vty *vty, struct ospf6 *o,
 631                        const char *distance_str, const char *ip_str,
 632                        const char *access_list_str)
 633 {
 634         int ret;
 635         struct prefix_ipv6 p;
 636         uint8_t distance;
 637         struct route_node *rn;
 638         struct ospf6_distance *odistance;
 639
 640         ret = str2prefix_ipv6(ip_str, &p);
 641         if (ret == 0) {
 642                 vty_out(vty, "Malformed prefix\n");
 643                 return CMD_WARNING_CONFIG_FAILED;
 644         }
 645
 646         distance = atoi(distance_str);
 647
 648         /* Get OSPF6 distance node. */
 649         rn = route_node_get(o->distance_table, (struct prefix *)&p);
 650         if (rn->info) {
 651                 odistance = rn->info;
 652                 route_unlock_node(rn);
 653         } else {
 654                 odistance = ospf6_distance_new();
 655                 rn->info = odistance;
 656         }
 657
 658         /* Set distance value. */
 659         odistance->distance = distance;
 660
 661         /* Reset access-list configuration. */
 662         if (odistance->access_list) {
 663                 free(odistance->access_list);
 664                 odistance->access_list = NULL;
 665         }
 666         if (access_list_str)
 667                 odistance->access_list = strdup(access_list_str);
 668
 669         return CMD_SUCCESS;
 670 }
 671
 672 int ospf6_distance_unset(struct vty *vty, struct ospf6 *o,
 673                          const char *distance_str, const char *ip_str,
 674                          const char *access_list_str)
 675 {
 676         int ret;
 677         struct prefix_ipv6 p;
 678         struct route_node *rn;
 679         struct ospf6_distance *odistance;
 680
 681         ret = str2prefix_ipv6(ip_str, &p);
 682         if (ret == 0) {
 683                 vty_out(vty, "Malformed prefix\n");
 684                 return CMD_WARNING_CONFIG_FAILED;
 685         }
 686
 687         rn = route_node_lookup(o->distance_table, (struct prefix *)&p);
 688         if (!rn) {
 689                 vty_out(vty, "Cant't find specified prefix\n");
 690                 return CMD_WARNING_CONFIG_FAILED;
 691         }
 692
 693         odistance = rn->info;
 694
 695         if (odistance->access_list)
 696                 free(odistance->access_list);
 697         ospf6_distance_free(odistance);
 698
 699         rn->info = NULL;
 700         route_unlock_node(rn);
 701         route_unlock_node(rn);
 702
 703         return CMD_SUCCESS;
 704 }
 705
 706 void ospf6_distance_reset(struct ospf6 *o)
 707 {
 708         struct route_node *rn;
 709         struct ospf6_distance *odistance;
 710
 711         for (rn = route_top(o->distance_table); rn; rn = route_next(rn))
 712                 if ((odistance = rn->info) != NULL) {
 713                         if (odistance->access_list)
 714                                 free(odistance->access_list);
 715                         ospf6_distance_free(odistance);
 716                         rn->info = NULL;
 717                         route_unlock_node(rn);
 718                 }
 719 }
 720
 721 uint8_t ospf6_distance_apply(struct prefix_ipv6 *p, struct ospf6_route * or,
 722                              struct ospf6 *ospf6)
 723 {
 724         struct ospf6 *o;
 725
 726         o = ospf6;
 727         if (o == NULL)
 728                 return 0;
 729
 730         if (o->distance_intra)
 731                 if (or->path.type == OSPF6_PATH_TYPE_INTRA)
 732                         return o->distance_intra;
 733
 734         if (o->distance_inter)
 735                 if (or->path.type == OSPF6_PATH_TYPE_INTER)
 736                         return o->distance_inter;
 737
 738         if (o->distance_external)
 739                 if (or->path.type == OSPF6_PATH_TYPE_EXTERNAL1 ||
 740                     or->path.type == OSPF6_PATH_TYPE_EXTERNAL2)
 741                         return o->distance_external;
 742
 743         if (o->distance_all)
 744                 return o->distance_all;
 745
 746         return 0;
 747 }
 748
 749 static void ospf6_zebra_connected(struct zclient *zclient)
 750 {
 751         /* Send the client registration */
 752         bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER, VRF_DEFAULT);
 753
 754         zclient_send_reg_requests(zclient, VRF_DEFAULT);
 755 }
 756
 757 static zclient_handler *const ospf6_handlers[] = {
 758         [ZEBRA_ROUTER_ID_UPDATE] = ospf6_router_id_update_zebra,
 759         [ZEBRA_INTERFACE_ADDRESS_ADD] = ospf6_zebra_if_address_update_add,
 760         [ZEBRA_INTERFACE_ADDRESS_DELETE] = ospf6_zebra_if_address_update_delete,
 761         [ZEBRA_REDISTRIBUTE_ROUTE_ADD] = ospf6_zebra_read_route,
 762         [ZEBRA_REDISTRIBUTE_ROUTE_DEL] = ospf6_zebra_read_route,
 763         [ZEBRA_NEXTHOP_UPDATE] = ospf6_zebra_import_check_update,
 764 };
 765
 766 void ospf6_zebra_init(struct thread_master *master)
 767 {
 768         /* Allocate zebra structure. */
 769         zclient = zclient_new(master, &zclient_options_default, ospf6_handlers,
 770                               array_size(ospf6_handlers));
 771         zclient_init(zclient, ZEBRA_ROUTE_OSPF6, 0, &ospf6d_privs);
 772         zclient->zebra_connected = ospf6_zebra_connected;
 773
 774         /* Install command element for zebra node. */
 775         install_element(VIEW_NODE, &show_ospf6_zebra_cmd);
 776 }
 777
 778 /* Debug */
 779
 780 DEFUN (debug_ospf6_zebra_sendrecv,
 781        debug_ospf6_zebra_sendrecv_cmd,
 782        "debug ospf6 zebra [<send|recv>]",
 783        DEBUG_STR
 784        OSPF6_STR
 785        "Debug connection between zebra\n"
 786        "Debug Sending zebra\n"
 787        "Debug Receiving zebra\n"
 788       )
 789 {
 790         int idx_send_recv = 3;
 791         unsigned char level = 0;
 792
 793         if (argc == 4) {
 794                 if (strmatch(argv[idx_send_recv]->text, "send"))
 795                         level = OSPF6_DEBUG_ZEBRA_SEND;
 796                 else if (strmatch(argv[idx_send_recv]->text, "recv"))
 797                         level = OSPF6_DEBUG_ZEBRA_RECV;
 798         } else
 799                 level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
 800
 801         OSPF6_DEBUG_ZEBRA_ON(level);
 802         return CMD_SUCCESS;
 803 }
 804
 805 DEFUN (no_debug_ospf6_zebra_sendrecv,
 806        no_debug_ospf6_zebra_sendrecv_cmd,
 807        "no debug ospf6 zebra [<send|recv>]",
 808        NO_STR
 809        DEBUG_STR
 810        OSPF6_STR
 811        "Debug connection between zebra\n"
 812        "Debug Sending zebra\n"
 813        "Debug Receiving zebra\n"
 814       )
 815 {
 816         int idx_send_recv = 4;
 817         unsigned char level = 0;
 818
 819         if (argc == 5) {
 820                 if (strmatch(argv[idx_send_recv]->text, "send"))
 821                         level = OSPF6_DEBUG_ZEBRA_SEND;
 822                 else if (strmatch(argv[idx_send_recv]->text, "recv"))
 823                         level = OSPF6_DEBUG_ZEBRA_RECV;
 824         } else
 825                 level = OSPF6_DEBUG_ZEBRA_SEND | OSPF6_DEBUG_ZEBRA_RECV;
 826
 827         OSPF6_DEBUG_ZEBRA_OFF(level);
 828         return CMD_SUCCESS;
 829 }
 830
 831
 832 int config_write_ospf6_debug_zebra(struct vty *vty)
 833 {
 834         if (IS_OSPF6_DEBUG_ZEBRA(SEND) && IS_OSPF6_DEBUG_ZEBRA(RECV))
 835                 vty_out(vty, "debug ospf6 zebra\n");
 836         else {
 837                 if (IS_OSPF6_DEBUG_ZEBRA(SEND))
 838                         vty_out(vty, "debug ospf6 zebra send\n");
 839                 if (IS_OSPF6_DEBUG_ZEBRA(RECV))
 840                         vty_out(vty, "debug ospf6 zebra recv\n");
 841         }
 842         return 0;
 843 }
 844
 845 void install_element_ospf6_debug_zebra(void)
 846 {
 847         install_element(ENABLE_NODE, &debug_ospf6_zebra_sendrecv_cmd);
 848         install_element(ENABLE_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
 849         install_element(CONFIG_NODE, &debug_ospf6_zebra_sendrecv_cmd);
 850         install_element(CONFIG_NODE, &no_debug_ospf6_zebra_sendrecv_cmd);
 851 }