bfdd/bfdd_nb_config.c

   1 /*
   2  * BFD daemon northbound implementation.
   3  *
   4  * Copyright (C) 2019 Network Device Education Foundation, Inc. ("NetDEF")
   5  *                    Rafael Zalamena
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301 USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "lib/log.h"
  26 #include "lib/northbound.h"
  27
  28 #include "bfd.h"
  29 #include "bfdd_nb.h"
  30
  31 /*
  32  * Helpers.
  33  */
  34 static void bfd_session_get_key(bool mhop, const struct lyd_node *dnode,
  35                                 struct bfd_key *bk)
  36 {
  37         const char *ifname = NULL, *vrfname = NULL;
  38         struct sockaddr_any psa, lsa;
  39
  40         /* Required destination parameter. */
  41         strtosa(yang_dnode_get_string(dnode, "./dest-addr"), &psa);
  42
  43         /* Get optional source address. */
  44         memset(&lsa, 0, sizeof(lsa));
  45         if (yang_dnode_exists(dnode, "./source-addr"))
  46                 strtosa(yang_dnode_get_string(dnode, "./source-addr"), &lsa);
  47
  48         ifname = yang_dnode_get_string(dnode, "./interface");
  49         vrfname = yang_dnode_get_string(dnode, "./vrf");
  50
  51         if (strcmp(ifname, "*") == 0)
  52                 ifname = NULL;
  53
  54         /* Generate the corresponding key. */
  55         gen_bfd_key(bk, &psa, &lsa, mhop, ifname, vrfname);
  56 }
  57
  58 static int bfd_session_create(struct nb_cb_create_args *args, bool mhop)
  59 {
  60         struct bfd_session *bs;
  61         const char *ifname;
  62         struct bfd_key bk;
  63         struct prefix p;
  64
  65         switch (args->event) {
  66         case NB_EV_VALIDATE:
  67                 /*
  68                  * When `dest-addr` is IPv6 and link-local we must
  69                  * require interface name, otherwise we can't figure
  70                  * which interface to use to send the packets.
  71                  */
  72                 yang_dnode_get_prefix(&p, args->dnode, "./dest-addr");
  73
  74                 ifname = yang_dnode_get_string(args->dnode, "./interface");
  75
  76                 if (p.family == AF_INET6 && IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6)
  77                     && strcmp(ifname, "*") == 0) {
  78                         snprintf(
  79                                 args->errmsg, args->errmsg_len,
  80                                 "When using link-local you must specify an interface");
  81                         return NB_ERR_VALIDATION;
  82                 }
  83                 break;
  84
  85         case NB_EV_PREPARE:
  86                 bfd_session_get_key(mhop, args->dnode, &bk);
  87                 bs = bfd_key_lookup(bk);
  88
  89                 /* This session was already configured by another daemon. */
  90                 if (bs != NULL) {
  91                         /* Now it is configured also by CLI. */
  92                         SET_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG);
  93                         bs->refcount++;
  94
  95                         args->resource->ptr = bs;
  96                         break;
  97                 }
  98
  99                 bs = bfd_session_new();
 100
 101                 /* Fill the session key. */
 102                 bfd_session_get_key(mhop, args->dnode, &bs->key);
 103
 104                 /* Set configuration flags. */
 105                 bs->refcount = 1;
 106                 SET_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG);
 107                 if (mhop)
 108                         SET_FLAG(bs->flags, BFD_SESS_FLAG_MH);
 109                 if (bs->key.family == AF_INET6)
 110                         SET_FLAG(bs->flags, BFD_SESS_FLAG_IPV6);
 111
 112                 args->resource->ptr = bs;
 113                 break;
 114
 115         case NB_EV_APPLY:
 116                 bs = args->resource->ptr;
 117
 118                 /* Only attempt to registrate if freshly allocated. */
 119                 if (bs->discrs.my_discr == 0 && bs_registrate(bs) == NULL)
 120                         return NB_ERR_RESOURCE;
 121
 122                 nb_running_set_entry(args->dnode, bs);
 123                 break;
 124
 125         case NB_EV_ABORT:
 126                 bs = args->resource->ptr;
 127                 if (bs->refcount <= 1)
 128                         bfd_session_free(bs);
 129                 break;
 130         }
 131
 132         return NB_OK;
 133 }
 134
 135 static int bfd_session_destroy(enum nb_event event,
 136                                const struct lyd_node *dnode, bool mhop)
 137 {
 138         struct bfd_session *bs;
 139         struct bfd_key bk;
 140
 141         switch (event) {
 142         case NB_EV_VALIDATE:
 143                 bfd_session_get_key(mhop, dnode, &bk);
 144                 if (bfd_key_lookup(bk) == NULL)
 145                         return NB_ERR_INCONSISTENCY;
 146                 break;
 147
 148         case NB_EV_PREPARE:
 149                 /* NOTHING */
 150                 break;
 151
 152         case NB_EV_APPLY:
 153                 bs = nb_running_unset_entry(dnode);
 154                 /* CLI is not using this session anymore. */
 155                 if (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG) == 0)
 156                         break;
 157
 158                 UNSET_FLAG(bs->flags, BFD_SESS_FLAG_CONFIG);
 159                 bs->refcount--;
 160                 /* There are still daemons using it. */
 161                 if (bs->refcount > 0)
 162                         break;
 163
 164                 bfd_session_free(bs);
 165                 break;
 166
 167         case NB_EV_ABORT:
 168                 /* NOTHING */
 169                 break;
 170         }
 171
 172         return NB_OK;
 173 }
 174
 175 /*
 176  * XPath: /frr-bfdd:bfdd/bfd
 177  */
 178 int bfdd_bfd_create(struct nb_cb_create_args *args)
 179 {
 180         /* NOTHING */
 181         return NB_OK;
 182 }
 183
 184 int bfdd_bfd_destroy(struct nb_cb_destroy_args *args)
 185 {
 186         switch (args->event) {
 187         case NB_EV_VALIDATE:
 188                 /* NOTHING */
 189                 return NB_OK;
 190
 191         case NB_EV_PREPARE:
 192                 /* NOTHING */
 193                 return NB_OK;
 194
 195         case NB_EV_APPLY:
 196                 bfd_sessions_remove_manual();
 197                 break;
 198
 199         case NB_EV_ABORT:
 200                 /* NOTHING */
 201                 return NB_OK;
 202         }
 203
 204         return NB_OK;
 205 }
 206
 207 /*
 208  * XPath: /frr-bfdd:bfdd/bfd/profile
 209  */
 210 int bfdd_bfd_profile_create(struct nb_cb_create_args *args)
 211 {
 212         struct bfd_profile *bp;
 213         const char *name;
 214
 215         if (args->event != NB_EV_APPLY)
 216                 return NB_OK;
 217
 218         name = yang_dnode_get_string(args->dnode, "./name");
 219         bp = bfd_profile_new(name);
 220         nb_running_set_entry(args->dnode, bp);
 221
 222         return NB_OK;
 223 }
 224
 225 int bfdd_bfd_profile_destroy(struct nb_cb_destroy_args *args)
 226 {
 227         struct bfd_profile *bp;
 228
 229         if (args->event != NB_EV_APPLY)
 230                 return NB_OK;
 231
 232         bp = nb_running_unset_entry(args->dnode);
 233         bfd_profile_free(bp);
 234
 235         return NB_OK;
 236 }
 237
 238 /*
 239  * XPath: /frr-bfdd:bfdd/bfd/profile/detection-multiplier
 240  */
 241 int bfdd_bfd_profile_detection_multiplier_modify(struct nb_cb_modify_args *args)
 242 {
 243         struct bfd_profile *bp;
 244
 245         if (args->event != NB_EV_APPLY)
 246                 return NB_OK;
 247
 248         bp = nb_running_get_entry(args->dnode, NULL, true);
 249         bp->detection_multiplier = yang_dnode_get_uint8(args->dnode, NULL);
 250         bfd_profile_update(bp);
 251
 252         return NB_OK;
 253 }
 254
 255 /*
 256  * XPath: /frr-bfdd:bfdd/bfd/profile/desired-transmission-interval
 257  */
 258 int bfdd_bfd_profile_desired_transmission_interval_modify(
 259         struct nb_cb_modify_args *args)
 260 {
 261         struct bfd_profile *bp;
 262         uint32_t min_tx;
 263
 264         switch (args->event) {
 265         case NB_EV_VALIDATE:
 266                 min_tx = yang_dnode_get_uint32(args->dnode, NULL);
 267                 if (min_tx < 10000 || min_tx > 60000000)
 268                         return NB_ERR_VALIDATION;
 269                 break;
 270
 271         case NB_EV_PREPARE:
 272                 /* NOTHING */
 273                 break;
 274
 275         case NB_EV_APPLY:
 276                 min_tx = yang_dnode_get_uint32(args->dnode, NULL);
 277                 bp = nb_running_get_entry(args->dnode, NULL, true);
 278                 if (bp->min_tx == min_tx)
 279                         return NB_OK;
 280
 281                 bp->min_tx = min_tx;
 282                 bfd_profile_update(bp);
 283                 break;
 284
 285         case NB_EV_ABORT:
 286                 /* NOTHING */
 287                 break;
 288         }
 289
 290         return NB_OK;
 291 }
 292
 293 /*
 294  * XPath: /frr-bfdd:bfdd/bfd/profile/required-receive-interval
 295  */
 296 int bfdd_bfd_profile_required_receive_interval_modify(
 297         struct nb_cb_modify_args *args)
 298 {
 299         struct bfd_profile *bp;
 300         uint32_t min_rx;
 301
 302         switch (args->event) {
 303         case NB_EV_VALIDATE:
 304                 min_rx = yang_dnode_get_uint32(args->dnode, NULL);
 305                 if (min_rx < 10000 || min_rx > 60000000)
 306                         return NB_ERR_VALIDATION;
 307                 break;
 308
 309         case NB_EV_PREPARE:
 310                 /* NOTHING */
 311                 break;
 312
 313         case NB_EV_APPLY:
 314                 min_rx = yang_dnode_get_uint32(args->dnode, NULL);
 315                 bp = nb_running_get_entry(args->dnode, NULL, true);
 316                 if (bp->min_rx == min_rx)
 317                         return NB_OK;
 318
 319                 bp->min_rx = min_rx;
 320                 bfd_profile_update(bp);
 321                 break;
 322
 323         case NB_EV_ABORT:
 324                 /* NOTHING */
 325                 break;
 326         }
 327
 328         return NB_OK;
 329 }
 330
 331 /*
 332  * XPath: /frr-bfdd:bfdd/bfd/profile/administrative-down
 333  */
 334 int bfdd_bfd_profile_administrative_down_modify(struct nb_cb_modify_args *args)
 335 {
 336         struct bfd_profile *bp;
 337         bool shutdown;
 338
 339         if (args->event != NB_EV_APPLY)
 340                 return NB_OK;
 341
 342         shutdown = yang_dnode_get_bool(args->dnode, NULL);
 343         bp = nb_running_get_entry(args->dnode, NULL, true);
 344         if (bp->admin_shutdown == shutdown)
 345                 return NB_OK;
 346
 347         bp->admin_shutdown = shutdown;
 348         bfd_profile_update(bp);
 349
 350         return NB_OK;
 351 }
 352
 353 /*
 354  * XPath: /frr-bfdd:bfdd/bfd/profile/passive-mode
 355  */
 356 int bfdd_bfd_profile_passive_mode_modify(struct nb_cb_modify_args *args)
 357 {
 358         struct bfd_profile *bp;
 359         bool passive;
 360
 361         if (args->event != NB_EV_APPLY)
 362                 return NB_OK;
 363
 364         passive = yang_dnode_get_bool(args->dnode, NULL);
 365         bp = nb_running_get_entry(args->dnode, NULL, true);
 366         if (bp->passive == passive)
 367                 return NB_OK;
 368
 369         bp->passive = passive;
 370         bfd_profile_update(bp);
 371
 372         return NB_OK;
 373 }
 374
 375 /*
 376  * XPath: /frr-bfdd:bfdd/bfd/profile/minimum-ttl
 377  */
 378 int bfdd_bfd_profile_minimum_ttl_modify(struct nb_cb_modify_args *args)
 379 {
 380         struct bfd_profile *bp;
 381         uint8_t minimum_ttl;
 382
 383         if (args->event != NB_EV_APPLY)
 384                 return NB_OK;
 385
 386         minimum_ttl = yang_dnode_get_uint8(args->dnode, NULL);
 387         bp = nb_running_get_entry(args->dnode, NULL, true);
 388         if (bp->minimum_ttl == minimum_ttl)
 389                 return NB_OK;
 390
 391         bp->minimum_ttl = minimum_ttl;
 392         bfd_profile_update(bp);
 393
 394         return NB_OK;
 395 }
 396
 397 int bfdd_bfd_profile_minimum_ttl_destroy(struct nb_cb_destroy_args *args)
 398 {
 399         struct bfd_profile *bp;
 400
 401         if (args->event != NB_EV_APPLY)
 402                 return NB_OK;
 403
 404         bp = nb_running_get_entry(args->dnode, NULL, true);
 405         bp->minimum_ttl = BFD_DEF_MHOP_TTL;
 406         bfd_profile_update(bp);
 407
 408         return NB_OK;
 409 }
 410
 411 /*
 412  * XPath: /frr-bfdd:bfdd/bfd/profile/echo-mode
 413  */
 414 int bfdd_bfd_profile_echo_mode_modify(struct nb_cb_modify_args *args)
 415 {
 416         struct bfd_profile *bp;
 417         bool echo;
 418
 419         if (args->event != NB_EV_APPLY)
 420                 return NB_OK;
 421
 422         echo = yang_dnode_get_bool(args->dnode, NULL);
 423         bp = nb_running_get_entry(args->dnode, NULL, true);
 424         if (bp->echo_mode == echo)
 425                 return NB_OK;
 426
 427         bp->echo_mode = echo;
 428         bfd_profile_update(bp);
 429
 430         return NB_OK;
 431 }
 432
 433 /*
 434  * XPath: /frr-bfdd:bfdd/bfd/profile/desired-echo-echo-transmission-interval
 435  */
 436 int bfdd_bfd_profile_desired_echo_transmission_interval_modify(
 437         struct nb_cb_modify_args *args)
 438 {
 439         struct bfd_profile *bp;
 440         uint32_t min_rx;
 441
 442         switch (args->event) {
 443         case NB_EV_VALIDATE:
 444                 min_rx = yang_dnode_get_uint32(args->dnode, NULL);
 445                 if (min_rx < 10000 || min_rx > 60000000)
 446                         return NB_ERR_VALIDATION;
 447                 break;
 448
 449         case NB_EV_PREPARE:
 450                 /* NOTHING */
 451                 break;
 452
 453         case NB_EV_APPLY:
 454                 min_rx = yang_dnode_get_uint32(args->dnode, NULL);
 455                 bp = nb_running_get_entry(args->dnode, NULL, true);
 456                 if (bp->min_echo_rx == min_rx)
 457                         return NB_OK;
 458
 459                 bp->min_echo_rx = min_rx;
 460                 bfd_profile_update(bp);
 461                 break;
 462
 463         case NB_EV_ABORT:
 464                 /* NOTHING */
 465                 break;
 466         }
 467
 468         return NB_OK;
 469 }
 470
 471 /*
 472  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop
 473  */
 474 int bfdd_bfd_sessions_single_hop_create(struct nb_cb_create_args *args)
 475 {
 476         return bfd_session_create(args, false);
 477 }
 478
 479 int bfdd_bfd_sessions_single_hop_destroy(struct nb_cb_destroy_args *args)
 480 {
 481         return bfd_session_destroy(args->event, args->dnode, false);
 482 }
 483
 484 /*
 485  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/source-addr
 486  */
 487 int bfdd_bfd_sessions_single_hop_source_addr_modify(
 488         struct nb_cb_modify_args *args)
 489 {
 490         return NB_OK;
 491 }
 492
 493 int bfdd_bfd_sessions_single_hop_source_addr_destroy(
 494         struct nb_cb_destroy_args *args)
 495 {
 496         return NB_OK;
 497 }
 498
 499 /*
 500  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/profile
 501  */
 502 int bfdd_bfd_sessions_single_hop_profile_modify(struct nb_cb_modify_args *args)
 503 {
 504         struct bfd_session *bs;
 505
 506         if (args->event != NB_EV_APPLY)
 507                 return NB_OK;
 508
 509         bs = nb_running_get_entry(args->dnode, NULL, true);
 510         bfd_profile_apply(yang_dnode_get_string(args->dnode, NULL), bs);
 511
 512         return NB_OK;
 513 }
 514
 515 int bfdd_bfd_sessions_single_hop_profile_destroy(
 516         struct nb_cb_destroy_args *args)
 517 {
 518         struct bfd_session *bs;
 519
 520         if (args->event != NB_EV_APPLY)
 521                 return NB_OK;
 522
 523         bs = nb_running_get_entry(args->dnode, NULL, true);
 524         bfd_profile_remove(bs);
 525
 526         return NB_OK;
 527 }
 528
 529 /*
 530  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/detection-multiplier
 531  */
 532 int bfdd_bfd_sessions_single_hop_detection_multiplier_modify(
 533         struct nb_cb_modify_args *args)
 534 {
 535         uint8_t detection_multiplier = yang_dnode_get_uint8(args->dnode, NULL);
 536         struct bfd_session *bs;
 537
 538         switch (args->event) {
 539         case NB_EV_VALIDATE:
 540                 break;
 541
 542         case NB_EV_PREPARE:
 543                 /* NOTHING */
 544                 break;
 545
 546         case NB_EV_APPLY:
 547                 bs = nb_running_get_entry(args->dnode, NULL, true);
 548                 bs->peer_profile.detection_multiplier = detection_multiplier;
 549                 bfd_session_apply(bs);
 550                 break;
 551
 552         case NB_EV_ABORT:
 553                 /* NOTHING */
 554                 break;
 555         }
 556
 557         return NB_OK;
 558 }
 559
 560 /*
 561  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/desired-transmission-interval
 562  */
 563 int bfdd_bfd_sessions_single_hop_desired_transmission_interval_modify(
 564         struct nb_cb_modify_args *args)
 565 {
 566         uint32_t tx_interval = yang_dnode_get_uint32(args->dnode, NULL);
 567         struct bfd_session *bs;
 568
 569         switch (args->event) {
 570         case NB_EV_VALIDATE:
 571                 if (tx_interval < 10000 || tx_interval > 60000000)
 572                         return NB_ERR_VALIDATION;
 573                 break;
 574
 575         case NB_EV_PREPARE:
 576                 /* NOTHING */
 577                 break;
 578
 579         case NB_EV_APPLY:
 580                 bs = nb_running_get_entry(args->dnode, NULL, true);
 581                 if (tx_interval == bs->timers.desired_min_tx)
 582                         return NB_OK;
 583
 584                 bs->peer_profile.min_tx = tx_interval;
 585                 bfd_session_apply(bs);
 586                 break;
 587
 588         case NB_EV_ABORT:
 589                 /* NOTHING */
 590                 break;
 591         }
 592
 593         return NB_OK;
 594 }
 595
 596 /*
 597  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/required-receive-interval
 598  */
 599 int bfdd_bfd_sessions_single_hop_required_receive_interval_modify(
 600         struct nb_cb_modify_args *args)
 601 {
 602         uint32_t rx_interval = yang_dnode_get_uint32(args->dnode, NULL);
 603         struct bfd_session *bs;
 604
 605         switch (args->event) {
 606         case NB_EV_VALIDATE:
 607                 if (rx_interval < 10000 || rx_interval > 60000000)
 608                         return NB_ERR_VALIDATION;
 609                 break;
 610
 611         case NB_EV_PREPARE:
 612                 /* NOTHING */
 613                 break;
 614
 615         case NB_EV_APPLY:
 616                 bs = nb_running_get_entry(args->dnode, NULL, true);
 617                 if (rx_interval == bs->timers.required_min_rx)
 618                         return NB_OK;
 619
 620                 bs->peer_profile.min_rx = rx_interval;
 621                 bfd_session_apply(bs);
 622                 break;
 623
 624         case NB_EV_ABORT:
 625                 /* NOTHING */
 626                 break;
 627         }
 628
 629         return NB_OK;
 630 }
 631
 632 /*
 633  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/administrative-down
 634  */
 635 int bfdd_bfd_sessions_single_hop_administrative_down_modify(
 636         struct nb_cb_modify_args *args)
 637 {
 638         bool shutdown = yang_dnode_get_bool(args->dnode, NULL);
 639         struct bfd_session *bs;
 640
 641         switch (args->event) {
 642         case NB_EV_VALIDATE:
 643         case NB_EV_PREPARE:
 644                 return NB_OK;
 645
 646         case NB_EV_APPLY:
 647                 break;
 648
 649         case NB_EV_ABORT:
 650                 return NB_OK;
 651         }
 652
 653         bs = nb_running_get_entry(args->dnode, NULL, true);
 654         bs->peer_profile.admin_shutdown = shutdown;
 655         bfd_session_apply(bs);
 656
 657         return NB_OK;
 658 }
 659
 660 /*
 661  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/passive-mode
 662  */
 663 int bfdd_bfd_sessions_single_hop_passive_mode_modify(
 664         struct nb_cb_modify_args *args)
 665 {
 666         struct bfd_session *bs;
 667         bool passive;
 668
 669         switch (args->event) {
 670         case NB_EV_VALIDATE:
 671         case NB_EV_PREPARE:
 672                 return NB_OK;
 673
 674         case NB_EV_APPLY:
 675                 break;
 676
 677         case NB_EV_ABORT:
 678                 return NB_OK;
 679         }
 680
 681         passive = yang_dnode_get_bool(args->dnode, NULL);
 682
 683         bs = nb_running_get_entry(args->dnode, NULL, true);
 684         bs->peer_profile.passive = passive;
 685         bfd_session_apply(bs);
 686
 687         return NB_OK;
 688 }
 689
 690 /*
 691  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/echo-mode
 692  */
 693 int bfdd_bfd_sessions_single_hop_echo_mode_modify(
 694         struct nb_cb_modify_args *args)
 695 {
 696         bool echo = yang_dnode_get_bool(args->dnode, NULL);
 697         struct bfd_session *bs;
 698
 699         switch (args->event) {
 700         case NB_EV_VALIDATE:
 701         case NB_EV_PREPARE:
 702                 return NB_OK;
 703
 704         case NB_EV_APPLY:
 705                 break;
 706
 707         case NB_EV_ABORT:
 708                 return NB_OK;
 709         }
 710
 711         bs = nb_running_get_entry(args->dnode, NULL, true);
 712         bs->peer_profile.echo_mode = echo;
 713         bfd_session_apply(bs);
 714
 715         return NB_OK;
 716 }
 717
 718 /*
 719  * XPath:
 720  * /frr-bfdd:bfdd/bfd/sessions/single-hop/desired-echo-transmission-interval
 721  */
 722 int bfdd_bfd_sessions_single_hop_desired_echo_transmission_interval_modify(
 723         struct nb_cb_modify_args *args)
 724 {
 725         uint32_t echo_interval = yang_dnode_get_uint32(args->dnode, NULL);
 726         struct bfd_session *bs;
 727
 728         switch (args->event) {
 729         case NB_EV_VALIDATE:
 730                 if (echo_interval < 10000 || echo_interval > 60000000)
 731                         return NB_ERR_VALIDATION;
 732                 break;
 733
 734         case NB_EV_PREPARE:
 735                 /* NOTHING */
 736                 break;
 737
 738         case NB_EV_APPLY:
 739                 bs = nb_running_get_entry(args->dnode, NULL, true);
 740                 if (echo_interval == bs->timers.required_min_echo)
 741                         return NB_OK;
 742
 743                 bs->peer_profile.min_echo_rx = echo_interval;
 744                 bfd_session_apply(bs);
 745                 break;
 746
 747         case NB_EV_ABORT:
 748                 /* NOTHING */
 749                 break;
 750         }
 751
 752         return NB_OK;
 753 }
 754
 755 /*
 756  * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop
 757  */
 758 int bfdd_bfd_sessions_multi_hop_create(struct nb_cb_create_args *args)
 759 {
 760         return bfd_session_create(args, true);
 761 }
 762
 763 int bfdd_bfd_sessions_multi_hop_destroy(struct nb_cb_destroy_args *args)
 764 {
 765         return bfd_session_destroy(args->event, args->dnode, true);
 766 }
 767
 768 /*
 769  * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop/minimum-ttl
 770  */
 771 int bfdd_bfd_sessions_multi_hop_minimum_ttl_modify(
 772         struct nb_cb_modify_args *args)
 773 {
 774         struct bfd_session *bs;
 775
 776         switch (args->event) {
 777         case NB_EV_VALIDATE:
 778         case NB_EV_PREPARE:
 779                 return NB_OK;
 780
 781         case NB_EV_APPLY:
 782                 break;
 783
 784         case NB_EV_ABORT:
 785                 return NB_OK;
 786         }
 787
 788         bs = nb_running_get_entry(args->dnode, NULL, true);
 789         bs->peer_profile.minimum_ttl = yang_dnode_get_uint8(args->dnode, NULL);
 790         bfd_session_apply(bs);
 791
 792         return NB_OK;
 793 }
 794
 795 int bfdd_bfd_sessions_multi_hop_minimum_ttl_destroy(
 796         struct nb_cb_destroy_args *args)
 797 {
 798         struct bfd_session *bs;
 799
 800         switch (args->event) {
 801         case NB_EV_VALIDATE:
 802         case NB_EV_PREPARE:
 803                 return NB_OK;
 804
 805         case NB_EV_APPLY:
 806                 break;
 807
 808         case NB_EV_ABORT:
 809                 return NB_OK;
 810         }
 811
 812         bs = nb_running_get_entry(args->dnode, NULL, true);
 813         bs->peer_profile.minimum_ttl = BFD_DEF_MHOP_TTL;
 814         bfd_session_apply(bs);
 815
 816         return NB_OK;
 817 }