bgpd/bgp_bfd.c

   1 /**
   2  * bgp_bfd.c: BGP BFD handling routines
   3  *
   4  * @copyright Copyright (C) 2015 Cumulus Networks, Inc.
   5  *
   6  * This file is part of GNU Zebra.
   7  *
   8  * GNU Zebra is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * GNU Zebra is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "command.h"
  26 #include "linklist.h"
  27 #include "memory.h"
  28 #include "prefix.h"
  29 #include "thread.h"
  30 #include "buffer.h"
  31 #include "stream.h"
  32 #include "zclient.h"
  33 #include "bfd.h"
  34 #include "lib/json.h"
  35 #include "filter.h"
  36
  37 #include "bgpd/bgpd.h"
  38 #include "bgp_fsm.h"
  39 #include "bgpd/bgp_bfd.h"
  40 #include "bgpd/bgp_debug.h"
  41 #include "bgpd/bgp_vty.h"
  42
  43 extern struct zclient *zclient;
  44
  45 /*
  46  * bgp_bfd_peer_group2peer_copy - Copy the BFD information from peer group
  47  * template
  48  *                                to peer.
  49  */
  50 void bgp_bfd_peer_group2peer_copy(struct peer *conf, struct peer *peer)
  51 {
  52         struct bfd_info *bfd_info;
  53         struct bfd_info *conf_bfd_info;
  54
  55         if (!conf->bfd_info)
  56                 return;
  57
  58         conf_bfd_info = (struct bfd_info *)conf->bfd_info;
  59         if (!peer->bfd_info)
  60                 peer->bfd_info = bfd_info_create();
  61
  62         bfd_info = (struct bfd_info *)peer->bfd_info;
  63
  64         /* Copy BFD parameter values */
  65         bfd_info->required_min_rx = conf_bfd_info->required_min_rx;
  66         bfd_info->desired_min_tx = conf_bfd_info->desired_min_tx;
  67         bfd_info->detect_mult = conf_bfd_info->detect_mult;
  68         bfd_info->type = conf_bfd_info->type;
  69 }
  70
  71 /*
  72  * bgp_bfd_is_peer_multihop - returns whether BFD peer is multi-hop or single
  73  * hop.
  74  */
  75 int bgp_bfd_is_peer_multihop(struct peer *peer)
  76 {
  77         struct bfd_info *bfd_info;
  78
  79         bfd_info = (struct bfd_info *)peer->bfd_info;
  80
  81         if (!bfd_info)
  82                 return 0;
  83
  84         if ((bfd_info->type == BFD_TYPE_MULTIHOP)
  85             || ((peer->sort == BGP_PEER_IBGP) && !peer->shared_network)
  86             || is_ebgp_multihop_configured(peer))
  87                 return 1;
  88         else
  89                 return 0;
  90 }
  91
  92 /*
  93  * bgp_bfd_peer_sendmsg - Format and send a Peer register/Unregister
  94  *                        command to Zebra to be forwarded to BFD
  95  */
  96 static void bgp_bfd_peer_sendmsg(struct peer *peer, int command)
  97 {
  98         struct bfd_info *bfd_info;
  99         vrf_id_t vrf_id = VRF_DEFAULT;
 100         int multihop;
 101
 102         bfd_info = (struct bfd_info *)peer->bfd_info;
 103
 104         if (peer->bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
 105                 vrf_id = peer->bgp->vrf_id;
 106
 107         if (command == ZEBRA_BFD_DEST_DEREGISTER) {
 108                 multihop =
 109                         CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_TYPE_MULTIHOP);
 110                 UNSET_FLAG(bfd_info->flags, BFD_FLAG_BFD_TYPE_MULTIHOP);
 111         } else {
 112                 multihop = bgp_bfd_is_peer_multihop(peer);
 113                 if ((command == ZEBRA_BFD_DEST_REGISTER) && multihop)
 114                         SET_FLAG(bfd_info->flags, BFD_FLAG_BFD_TYPE_MULTIHOP);
 115         }
 116
 117         if (peer->su.sa.sa_family == AF_INET)
 118                 bfd_peer_sendmsg(
 119                         zclient, bfd_info, AF_INET, &peer->su.sin.sin_addr,
 120                         (peer->su_local) ? &peer->su_local->sin.sin_addr : NULL,
 121                         (peer->nexthop.ifp) ? peer->nexthop.ifp->name : NULL,
 122                         peer->ttl, multihop, command, 1, vrf_id);
 123         else if (peer->su.sa.sa_family == AF_INET6)
 124                 bfd_peer_sendmsg(
 125                         zclient, bfd_info, AF_INET6, &peer->su.sin6.sin6_addr,
 126                         (peer->su_local) ? &peer->su_local->sin6.sin6_addr
 127                                          : NULL,
 128                         (peer->nexthop.ifp) ? peer->nexthop.ifp->name : NULL,
 129                         peer->ttl, multihop, command, 1, vrf_id);
 130 }
 131
 132 /*
 133  * bgp_bfd_register_peer - register a peer with BFD through zebra
 134  *                         for monitoring the peer rechahability.
 135  */
 136 void bgp_bfd_register_peer(struct peer *peer)
 137 {
 138         struct bfd_info *bfd_info;
 139
 140         if (!peer->bfd_info)
 141                 return;
 142         bfd_info = (struct bfd_info *)peer->bfd_info;
 143
 144         /* Check if BFD is enabled and peer has already been registered with BFD
 145          */
 146         if (CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_REG))
 147                 return;
 148
 149         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_REGISTER);
 150 }
 151
 152 /**
 153  * bgp_bfd_deregister_peer - deregister a peer with BFD through zebra
 154  *                           for stopping the monitoring of the peer
 155  *                           rechahability.
 156  */
 157 void bgp_bfd_deregister_peer(struct peer *peer)
 158 {
 159         struct bfd_info *bfd_info;
 160
 161         if (!peer->bfd_info)
 162                 return;
 163         bfd_info = (struct bfd_info *)peer->bfd_info;
 164
 165         /* Check if BFD is eanbled and peer has not been registered */
 166         if (!CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_REG))
 167                 return;
 168
 169         bfd_info->status = BFD_STATUS_DOWN;
 170         bfd_info->last_update = bgp_clock();
 171
 172         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_DEREGISTER);
 173 }
 174
 175 /*
 176  * bgp_bfd_update_peer - update peer with BFD with new BFD paramters
 177  *                       through zebra.
 178  */
 179 static void bgp_bfd_update_peer(struct peer *peer)
 180 {
 181         struct bfd_info *bfd_info;
 182
 183         if (!peer->bfd_info)
 184                 return;
 185         bfd_info = (struct bfd_info *)peer->bfd_info;
 186
 187         /* Check if the peer has been registered with BFD*/
 188         if (!CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_REG))
 189                 return;
 190
 191         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_UPDATE);
 192 }
 193
 194 /*
 195  * bgp_bfd_update_type - update session type with BFD through zebra.
 196  */
 197 static void bgp_bfd_update_type(struct peer *peer)
 198 {
 199         struct bfd_info *bfd_info;
 200         int multihop;
 201
 202         if (!peer->bfd_info)
 203                 return;
 204         bfd_info = (struct bfd_info *)peer->bfd_info;
 205
 206         /* Check if the peer has been registered with BFD*/
 207         if (!CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_REG))
 208                 return;
 209
 210         if (bfd_info->type == BFD_TYPE_NOT_CONFIGURED) {
 211                 multihop = bgp_bfd_is_peer_multihop(peer);
 212                 if ((multihop
 213                      && !CHECK_FLAG(bfd_info->flags,
 214                                     BFD_FLAG_BFD_TYPE_MULTIHOP))
 215                     || (!multihop && CHECK_FLAG(bfd_info->flags,
 216                                                 BFD_FLAG_BFD_TYPE_MULTIHOP))) {
 217                         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_DEREGISTER);
 218                         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_REGISTER);
 219                 }
 220         } else {
 221                 if ((bfd_info->type == BFD_TYPE_MULTIHOP
 222                      && !CHECK_FLAG(bfd_info->flags,
 223                                     BFD_FLAG_BFD_TYPE_MULTIHOP))
 224                     || (bfd_info->type == BFD_TYPE_SINGLEHOP
 225                         && CHECK_FLAG(bfd_info->flags,
 226                                       BFD_FLAG_BFD_TYPE_MULTIHOP))) {
 227                         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_DEREGISTER);
 228                         bgp_bfd_peer_sendmsg(peer, ZEBRA_BFD_DEST_REGISTER);
 229                 }
 230         }
 231 }
 232
 233 /*
 234  * bgp_bfd_dest_replay - Replay all the peers that have BFD enabled
 235  *                       to zebra
 236  */
 237 static int bgp_bfd_dest_replay(int command, struct zclient *client,
 238                                zebra_size_t length, vrf_id_t vrf_id)
 239 {
 240         struct listnode *mnode, *node, *nnode;
 241         struct bgp *bgp;
 242         struct peer *peer;
 243
 244         if (BGP_DEBUG(zebra, ZEBRA))
 245                 zlog_debug("Zebra: BFD Dest replay request");
 246
 247         /* Send the client registration */
 248         bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER);
 249
 250         /* Replay the peer, if BFD is enabled in BGP */
 251
 252         for (ALL_LIST_ELEMENTS_RO(bm->bgp, mnode, bgp))
 253                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 254                         bgp_bfd_update_peer(peer);
 255                 }
 256
 257         return 0;
 258 }
 259
 260 /*
 261  * bgp_bfd_peer_status_update - Update the BFD status if it has changed. Bring
 262  *                              down the peer if the BFD session went down from
 263  * *                              up.
 264  */
 265 static void bgp_bfd_peer_status_update(struct peer *peer, int status)
 266 {
 267         struct bfd_info *bfd_info;
 268         int old_status;
 269
 270         bfd_info = (struct bfd_info *)peer->bfd_info;
 271
 272         if (bfd_info->status == status)
 273                 return;
 274
 275         old_status = bfd_info->status;
 276         bfd_info->status = status;
 277         bfd_info->last_update = bgp_clock();
 278
 279         if (status != old_status) {
 280                 if (BGP_DEBUG(neighbor_events, NEIGHBOR_EVENTS))
 281                         zlog_debug("[%s]: BFD %s", peer->host,
 282                                    bfd_get_status_str(status));
 283         }
 284         if ((status == BFD_STATUS_DOWN) && (old_status == BFD_STATUS_UP)) {
 285                 peer->last_reset = PEER_DOWN_BFD_DOWN;
 286                 BGP_EVENT_ADD(peer, BGP_Stop);
 287         }
 288         if ((status == BFD_STATUS_UP) && (old_status == BFD_STATUS_DOWN)
 289             && peer->status != Established) {
 290                 if (!BGP_PEER_START_SUPPRESSED(peer)) {
 291                         bgp_fsm_event_update(peer, 1);
 292                         BGP_EVENT_ADD(peer, BGP_Start);
 293                 }
 294         }
 295 }
 296
 297 /*
 298  * bgp_bfd_dest_update - Find the peer for which the BFD status
 299  *                       has changed and bring down the peer
 300  *                       connectivity if the BFD session went down.
 301  */
 302 static int bgp_bfd_dest_update(int command, struct zclient *zclient,
 303                                zebra_size_t length, vrf_id_t vrf_id)
 304 {
 305         struct interface *ifp;
 306         struct prefix dp;
 307         struct prefix sp;
 308         int status;
 309
 310         ifp = bfd_get_peer_info(zclient->ibuf, &dp, &sp, &status, vrf_id);
 311
 312         if (BGP_DEBUG(zebra, ZEBRA)) {
 313                 char buf[2][PREFIX2STR_BUFFER];
 314                 prefix2str(&dp, buf[0], sizeof(buf[0]));
 315                 if (ifp) {
 316                         zlog_debug(
 317                                 "Zebra: vrf %u interface %s bfd destination %s %s",
 318                                 vrf_id, ifp->name, buf[0],
 319                                 bfd_get_status_str(status));
 320                 } else {
 321                         prefix2str(&sp, buf[1], sizeof(buf[1]));
 322                         zlog_debug(
 323                                 "Zebra: vrf %u source %s bfd destination %s %s",
 324                                 vrf_id, buf[1], buf[0],
 325                                 bfd_get_status_str(status));
 326                 }
 327         }
 328
 329         /* Bring the peer down if BFD is enabled in BGP */
 330         {
 331                 struct listnode *mnode, *node, *nnode;
 332                 struct bgp *bgp;
 333                 struct peer *peer;
 334
 335                 for (ALL_LIST_ELEMENTS_RO(bm->bgp, mnode, bgp))
 336                         for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 337                                 if (!peer->bfd_info)
 338                                         continue;
 339
 340                                 if ((dp.family == AF_INET)
 341                                     && (peer->su.sa.sa_family == AF_INET)) {
 342                                         if (dp.u.prefix4.s_addr
 343                                             != peer->su.sin.sin_addr.s_addr)
 344                                                 continue;
 345                                 } else if ((dp.family == AF_INET6)
 346                                            && (peer->su.sa.sa_family
 347                                                == AF_INET6)) {
 348                                         if (memcmp(&dp.u.prefix6,
 349                                                    &peer->su.sin6.sin6_addr,
 350                                                    sizeof(struct in6_addr)))
 351                                                 continue;
 352                                 } else
 353                                         continue;
 354
 355                                 if (ifp && (ifp == peer->nexthop.ifp)) {
 356                                         bgp_bfd_peer_status_update(peer,
 357                                                                    status);
 358                                 } else {
 359                                         if (!peer->su_local)
 360                                                 continue;
 361
 362                                         if ((sp.family == AF_INET)
 363                                             && (peer->su_local->sa.sa_family
 364                                                 == AF_INET)) {
 365                                                 if (sp.u.prefix4.s_addr
 366                                                     != peer->su_local->sin
 367                                                                .sin_addr.s_addr)
 368                                                         continue;
 369                                         } else if ((sp.family == AF_INET6)
 370                                                    && (peer->su_local->sa
 371                                                                .sa_family
 372                                                        == AF_INET6)) {
 373                                                 if (memcmp(&sp.u.prefix6,
 374                                                            &peer->su_local->sin6
 375                                                                     .sin6_addr,
 376                                                            sizeof(struct
 377                                                                   in6_addr)))
 378                                                         continue;
 379                                         } else
 380                                                 continue;
 381
 382                                         if ((vrf_id != VRF_DEFAULT)
 383                                             && (peer->bgp->vrf_id != vrf_id))
 384                                                 continue;
 385
 386                                         bgp_bfd_peer_status_update(peer,
 387                                                                    status);
 388                                 }
 389                         }
 390         }
 391
 392         return 0;
 393 }
 394
 395 /*
 396  * bgp_bfd_peer_param_set - Set the configured BFD paramter values for peer.
 397  */
 398 static int bgp_bfd_peer_param_set(struct peer *peer, uint32_t min_rx,
 399                                   uint32_t min_tx, uint8_t detect_mult,
 400                                   int defaults)
 401 {
 402         struct peer_group *group;
 403         struct listnode *node, *nnode;
 404         int command = 0;
 405
 406         bfd_set_param((struct bfd_info **)&(peer->bfd_info), min_rx, min_tx,
 407                       detect_mult, defaults, &command);
 408
 409         if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
 410                 group = peer->group;
 411                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
 412                         command = 0;
 413                         bfd_set_param((struct bfd_info **)&(peer->bfd_info),
 414                                       min_rx, min_tx, detect_mult, defaults,
 415                                       &command);
 416
 417                         if ((peer->status == Established)
 418                             && (command == ZEBRA_BFD_DEST_REGISTER))
 419                                 bgp_bfd_register_peer(peer);
 420                         else if (command == ZEBRA_BFD_DEST_UPDATE)
 421                                 bgp_bfd_update_peer(peer);
 422                 }
 423         } else {
 424                 if ((peer->status == Established)
 425                     && (command == ZEBRA_BFD_DEST_REGISTER))
 426                         bgp_bfd_register_peer(peer);
 427                 else if (command == ZEBRA_BFD_DEST_UPDATE)
 428                         bgp_bfd_update_peer(peer);
 429         }
 430         return 0;
 431 }
 432
 433 /*
 434  * bgp_bfd_peer_param_unset - Delete the configured BFD paramter values for
 435  * peer.
 436  */
 437 static int bgp_bfd_peer_param_unset(struct peer *peer)
 438 {
 439         struct peer_group *group;
 440         struct listnode *node, *nnode;
 441
 442         if (!peer->bfd_info)
 443                 return 0;
 444
 445         if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
 446                 bfd_info_free(&(peer->bfd_info));
 447                 group = peer->group;
 448                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
 449                         bgp_bfd_deregister_peer(peer);
 450                         bfd_info_free(&(peer->bfd_info));
 451                 }
 452         } else {
 453                 bgp_bfd_deregister_peer(peer);
 454                 bfd_info_free(&(peer->bfd_info));
 455         }
 456         return 0;
 457 }
 458
 459 /*
 460  * bgp_bfd_peer_param_type_set - set the BFD session type (multihop or
 461  * singlehop)
 462  */
 463 static int bgp_bfd_peer_param_type_set(struct peer *peer,
 464                                        enum bfd_sess_type type)
 465 {
 466         struct peer_group *group;
 467         struct listnode *node, *nnode;
 468         int command = 0;
 469         struct bfd_info *bfd_info;
 470
 471         if (!peer->bfd_info)
 472                 bfd_set_param((struct bfd_info **)&(peer->bfd_info),
 473                               BFD_DEF_MIN_RX, BFD_DEF_MIN_TX,
 474                               BFD_DEF_DETECT_MULT, 1, &command);
 475
 476         bfd_info = (struct bfd_info *)peer->bfd_info;
 477         bfd_info->type = type;
 478
 479         if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
 480                 group = peer->group;
 481                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
 482                         command = 0;
 483                         if (!peer->bfd_info)
 484                                 bfd_set_param(
 485                                         (struct bfd_info **)&(peer->bfd_info),
 486                                         BFD_DEF_MIN_RX, BFD_DEF_MIN_TX,
 487                                         BFD_DEF_DETECT_MULT, 1, &command);
 488
 489                         bfd_info = (struct bfd_info *)peer->bfd_info;
 490                         bfd_info->type = type;
 491
 492                         if (peer->status == Established) {
 493                                 if (command == ZEBRA_BFD_DEST_REGISTER)
 494                                         bgp_bfd_register_peer(peer);
 495                                 else
 496                                         bgp_bfd_update_type(peer);
 497                         }
 498                 }
 499         } else {
 500                 if (peer->status == Established) {
 501                         if (command == ZEBRA_BFD_DEST_REGISTER)
 502                                 bgp_bfd_register_peer(peer);
 503                         else
 504                                 bgp_bfd_update_type(peer);
 505                 }
 506         }
 507
 508         return 0;
 509 }
 510
 511 /*
 512  * bgp_bfd_peer_config_write - Write the peer BFD configuration.
 513  */
 514 void bgp_bfd_peer_config_write(struct vty *vty, struct peer *peer, char *addr)
 515 {
 516         struct bfd_info *bfd_info;
 517
 518         if (!peer->bfd_info)
 519                 return;
 520
 521         bfd_info = (struct bfd_info *)peer->bfd_info;
 522
 523         if (CHECK_FLAG(bfd_info->flags, BFD_FLAG_PARAM_CFG))
 524 #if HAVE_BFDD > 0
 525                 vty_out(vty, " neighbor %s bfd\n", addr);
 526 #else
 527                 vty_out(vty, " neighbor %s bfd %d %d %d\n", addr,
 528                         bfd_info->detect_mult, bfd_info->required_min_rx,
 529                         bfd_info->desired_min_tx);
 530 #endif /* HAVE_BFDD */
 531
 532         if (bfd_info->type != BFD_TYPE_NOT_CONFIGURED)
 533                 vty_out(vty, " neighbor %s bfd %s\n", addr,
 534                         (bfd_info->type == BFD_TYPE_MULTIHOP) ? "multihop"
 535                                                               : "singlehop");
 536
 537         if (!CHECK_FLAG(bfd_info->flags, BFD_FLAG_PARAM_CFG)
 538             && (bfd_info->type == BFD_TYPE_NOT_CONFIGURED))
 539                 vty_out(vty, " neighbor %s bfd\n", addr);
 540 }
 541
 542 /*
 543  * bgp_bfd_show_info - Show the peer BFD information.
 544  */
 545 void bgp_bfd_show_info(struct vty *vty, struct peer *peer, bool use_json,
 546                        json_object *json_neigh)
 547 {
 548         bfd_show_info(vty, (struct bfd_info *)peer->bfd_info,
 549                       bgp_bfd_is_peer_multihop(peer), 0, use_json, json_neigh);
 550 }
 551
 552 DEFUN (neighbor_bfd,
 553        neighbor_bfd_cmd,
 554        "neighbor <A.B.C.D|X:X::X:X|WORD> bfd",
 555        NEIGHBOR_STR
 556        NEIGHBOR_ADDR_STR2
 557        "Enables BFD support\n")
 558 {
 559         int idx_peer = 1;
 560         struct peer *peer;
 561         int ret;
 562
 563         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
 564         if (!peer)
 565                 return CMD_WARNING_CONFIG_FAILED;
 566
 567         ret = bgp_bfd_peer_param_set(peer, BFD_DEF_MIN_RX, BFD_DEF_MIN_TX,
 568                                      BFD_DEF_DETECT_MULT, 1);
 569         if (ret != 0)
 570                 return bgp_vty_return(vty, ret);
 571
 572         return CMD_SUCCESS;
 573 }
 574
 575 #if HAVE_BFDD > 0
 576 DEFUN_HIDDEN(
 577 #else
 578 DEFUN(
 579 #endif /* HAVE_BFDD */
 580        neighbor_bfd_param,
 581        neighbor_bfd_param_cmd,
 582        "neighbor <A.B.C.D|X:X::X:X|WORD> bfd (2-255) (50-60000) (50-60000)",
 583        NEIGHBOR_STR
 584        NEIGHBOR_ADDR_STR2
 585        "Enables BFD support\n"
 586        "Detect Multiplier\n"
 587        "Required min receive interval\n"
 588        "Desired min transmit interval\n")
 589 {
 590         int idx_peer = 1;
 591         int idx_number_1 = 3;
 592         int idx_number_2 = 4;
 593         int idx_number_3 = 5;
 594         struct peer *peer;
 595         uint32_t rx_val;
 596         uint32_t tx_val;
 597         uint8_t dm_val;
 598         int ret;
 599
 600         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
 601         if (!peer)
 602                 return CMD_WARNING_CONFIG_FAILED;
 603
 604         if ((ret = bfd_validate_param(
 605                      vty, argv[idx_number_1]->arg, argv[idx_number_2]->arg,
 606                      argv[idx_number_3]->arg, &dm_val, &rx_val, &tx_val))
 607             != CMD_SUCCESS)
 608                 return ret;
 609
 610         ret = bgp_bfd_peer_param_set(peer, rx_val, tx_val, dm_val, 0);
 611         if (ret != 0)
 612                 return bgp_vty_return(vty, ret);
 613
 614         return CMD_SUCCESS;
 615 }
 616
 617 DEFUN_HIDDEN (neighbor_bfd_type,
 618        neighbor_bfd_type_cmd,
 619        "neighbor <A.B.C.D|X:X::X:X|WORD> bfd <multihop|singlehop>",
 620        NEIGHBOR_STR
 621        NEIGHBOR_ADDR_STR2
 622        "Enables BFD support\n"
 623        "Multihop session\n"
 624        "Single hop session\n")
 625 {
 626         int idx_peer = 1;
 627         int idx_hop = 3;
 628         struct peer *peer;
 629         enum bfd_sess_type type;
 630         int ret;
 631
 632         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
 633         if (!peer)
 634                 return CMD_WARNING_CONFIG_FAILED;
 635
 636         if (strmatch(argv[idx_hop]->text, "singlehop"))
 637                 type = BFD_TYPE_SINGLEHOP;
 638         else if (strmatch(argv[idx_hop]->text, "multihop"))
 639                 type = BFD_TYPE_MULTIHOP;
 640         else
 641                 return CMD_WARNING_CONFIG_FAILED;
 642
 643         ret = bgp_bfd_peer_param_type_set(peer, type);
 644         if (ret != 0)
 645                 return bgp_vty_return(vty, ret);
 646
 647         return CMD_SUCCESS;
 648 }
 649
 650 DEFUN (no_neighbor_bfd,
 651        no_neighbor_bfd_cmd,
 652 #if HAVE_BFDD > 0
 653        "no neighbor <A.B.C.D|X:X::X:X|WORD> bfd",
 654 #else
 655        "no neighbor <A.B.C.D|X:X::X:X|WORD> bfd [(2-255) (50-60000) (50-60000)]",
 656 #endif /* HAVE_BFDD */
 657        NO_STR
 658        NEIGHBOR_STR
 659        NEIGHBOR_ADDR_STR2
 660        "Disables BFD support\n"
 661 #if HAVE_BFDD == 0
 662        "Detect Multiplier\n"
 663        "Required min receive interval\n"
 664        "Desired min transmit interval\n"
 665 #endif /* !HAVE_BFDD */
 666 )
 667 {
 668         int idx_peer = 2;
 669         struct peer *peer;
 670         int ret;
 671
 672         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
 673         if (!peer)
 674                 return CMD_WARNING_CONFIG_FAILED;
 675
 676         ret = bgp_bfd_peer_param_unset(peer);
 677         if (ret != 0)
 678                 return bgp_vty_return(vty, ret);
 679
 680         return CMD_SUCCESS;
 681 }
 682
 683
 684 DEFUN_HIDDEN (no_neighbor_bfd_type,
 685        no_neighbor_bfd_type_cmd,
 686        "no neighbor <A.B.C.D|X:X::X:X|WORD> bfd <multihop|singlehop>",
 687        NO_STR
 688        NEIGHBOR_STR
 689        NEIGHBOR_ADDR_STR2
 690        "Disables BFD support\n"
 691        "Multihop session\n"
 692        "Singlehop session\n")
 693 {
 694         int idx_peer = 2;
 695         struct peer *peer;
 696         int ret;
 697
 698         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
 699         if (!peer)
 700                 return CMD_WARNING_CONFIG_FAILED;
 701
 702         if (!peer->bfd_info)
 703                 return 0;
 704
 705         ret = bgp_bfd_peer_param_type_set(peer, BFD_TYPE_NOT_CONFIGURED);
 706         if (ret != 0)
 707                 return bgp_vty_return(vty, ret);
 708
 709         return CMD_SUCCESS;
 710 }
 711
 712 void bgp_bfd_init(void)
 713 {
 714         bfd_gbl_init();
 715
 716         /* Initialize BFD client functions */
 717         zclient->interface_bfd_dest_update = bgp_bfd_dest_update;
 718         zclient->bfd_dest_replay = bgp_bfd_dest_replay;
 719
 720         /* "neighbor bfd" commands. */
 721         install_element(BGP_NODE, &neighbor_bfd_cmd);
 722         install_element(BGP_NODE, &neighbor_bfd_param_cmd);
 723         install_element(BGP_NODE, &neighbor_bfd_type_cmd);
 724         install_element(BGP_NODE, &no_neighbor_bfd_cmd);
 725         install_element(BGP_NODE, &no_neighbor_bfd_type_cmd);
 726 }