zebra/zebra_nb_config.c

   1 /*
   2  * Copyright (C) 2019  Cumulus Networks, Inc.
   3  * Chirag Shah
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the Free
   7  * Software Foundation; either version 2 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; see the file COPYING; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include "lib/log.h"
  23 #include "lib/northbound.h"
  24 #include "libfrr.h"
  25 #include "lib/command.h"
  26 #include "lib/routemap.h"
  27 #include "zebra/zebra_nb.h"
  28 #include "zebra/rib.h"
  29 #include "zebra_nb.h"
  30 #include "zebra/interface.h"
  31 #include "zebra/connected.h"
  32 #include "zebra/zebra_router.h"
  33 #include "zebra/debug.h"
  34
  35 /*
  36  * XPath: /frr-zebra:zebra/mcast-rpf-lookup
  37  */
  38 int zebra_mcast_rpf_lookup_modify(struct nb_cb_modify_args *args)
  39 {
  40         switch (args->event) {
  41         case NB_EV_VALIDATE:
  42         case NB_EV_PREPARE:
  43         case NB_EV_ABORT:
  44         case NB_EV_APPLY:
  45                 /* TODO: implement me. */
  46                 break;
  47         }
  48
  49         return NB_OK;
  50 }
  51
  52 /*
  53  * XPath: /frr-zebra:zebra/ip-forwarding
  54  */
  55 int zebra_ip_forwarding_modify(struct nb_cb_modify_args *args)
  56 {
  57         switch (args->event) {
  58         case NB_EV_VALIDATE:
  59         case NB_EV_PREPARE:
  60         case NB_EV_ABORT:
  61         case NB_EV_APPLY:
  62                 /* TODO: implement me. */
  63                 break;
  64         }
  65
  66         return NB_OK;
  67 }
  68
  69 int zebra_ip_forwarding_destroy(struct nb_cb_destroy_args *args)
  70 {
  71         switch (args->event) {
  72         case NB_EV_VALIDATE:
  73         case NB_EV_PREPARE:
  74         case NB_EV_ABORT:
  75         case NB_EV_APPLY:
  76                 /* TODO: implement me. */
  77                 break;
  78         }
  79
  80         return NB_OK;
  81 }
  82
  83 /*
  84  * XPath: /frr-zebra:zebra/ipv6-forwarding
  85  */
  86 int zebra_ipv6_forwarding_modify(struct nb_cb_modify_args *args)
  87 {
  88         switch (args->event) {
  89         case NB_EV_VALIDATE:
  90         case NB_EV_PREPARE:
  91         case NB_EV_ABORT:
  92         case NB_EV_APPLY:
  93                 /* TODO: implement me. */
  94                 break;
  95         }
  96
  97         return NB_OK;
  98 }
  99
 100 int zebra_ipv6_forwarding_destroy(struct nb_cb_destroy_args *args)
 101 {
 102         switch (args->event) {
 103         case NB_EV_VALIDATE:
 104         case NB_EV_PREPARE:
 105         case NB_EV_ABORT:
 106         case NB_EV_APPLY:
 107                 /* TODO: implement me. */
 108                 break;
 109         }
 110
 111         return NB_OK;
 112 }
 113
 114 /*
 115  * XPath: /frr-zebra:zebra/workqueue-hold-timer
 116  */
 117 int zebra_workqueue_hold_timer_modify(struct nb_cb_modify_args *args)
 118 {
 119         switch (args->event) {
 120         case NB_EV_VALIDATE:
 121         case NB_EV_PREPARE:
 122         case NB_EV_ABORT:
 123         case NB_EV_APPLY:
 124                 /* TODO: implement me. */
 125                 break;
 126         }
 127
 128         return NB_OK;
 129 }
 130
 131 /*
 132  * XPath: /frr-zebra:zebra/zapi-packets
 133  */
 134 int zebra_zapi_packets_modify(struct nb_cb_modify_args *args)
 135 {
 136         switch (args->event) {
 137         case NB_EV_VALIDATE:
 138         case NB_EV_PREPARE:
 139         case NB_EV_ABORT:
 140         case NB_EV_APPLY:
 141                 /* TODO: implement me. */
 142                 break;
 143         }
 144
 145         return NB_OK;
 146 }
 147
 148 /*
 149  * XPath: /frr-zebra:zebra/import-kernel-table/table-id
 150  */
 151 int zebra_import_kernel_table_table_id_modify(struct nb_cb_modify_args *args)
 152 {
 153         switch (args->event) {
 154         case NB_EV_VALIDATE:
 155         case NB_EV_PREPARE:
 156         case NB_EV_ABORT:
 157         case NB_EV_APPLY:
 158                 /* TODO: implement me. */
 159                 break;
 160         }
 161
 162         return NB_OK;
 163 }
 164
 165 int zebra_import_kernel_table_table_id_destroy(struct nb_cb_destroy_args *args)
 166 {
 167         switch (args->event) {
 168         case NB_EV_VALIDATE:
 169         case NB_EV_PREPARE:
 170         case NB_EV_ABORT:
 171         case NB_EV_APPLY:
 172                 /* TODO: implement me. */
 173                 break;
 174         }
 175
 176         return NB_OK;
 177 }
 178
 179 /*
 180  * XPath: /frr-zebra:zebra/import-kernel-table/distance
 181  */
 182 int zebra_import_kernel_table_distance_modify(struct nb_cb_modify_args *args)
 183 {
 184         switch (args->event) {
 185         case NB_EV_VALIDATE:
 186         case NB_EV_PREPARE:
 187         case NB_EV_ABORT:
 188         case NB_EV_APPLY:
 189                 /* TODO: implement me. */
 190                 break;
 191         }
 192
 193         return NB_OK;
 194 }
 195
 196 /*
 197  * XPath: /frr-zebra:zebra/import-kernel-table/route-map
 198  */
 199 int zebra_import_kernel_table_route_map_modify(struct nb_cb_modify_args *args)
 200 {
 201         switch (args->event) {
 202         case NB_EV_VALIDATE:
 203         case NB_EV_PREPARE:
 204         case NB_EV_ABORT:
 205         case NB_EV_APPLY:
 206                 /* TODO: implement me. */
 207                 break;
 208         }
 209
 210         return NB_OK;
 211 }
 212
 213 int zebra_import_kernel_table_route_map_destroy(struct nb_cb_destroy_args *args)
 214 {
 215         switch (args->event) {
 216         case NB_EV_VALIDATE:
 217         case NB_EV_PREPARE:
 218         case NB_EV_ABORT:
 219         case NB_EV_APPLY:
 220                 /* TODO: implement me. */
 221                 break;
 222         }
 223
 224         return NB_OK;
 225 }
 226
 227 /*
 228  * XPath: /frr-zebra:zebra/allow-external-route-update
 229  */
 230 int zebra_allow_external_route_update_create(struct nb_cb_create_args *args)
 231 {
 232         switch (args->event) {
 233         case NB_EV_VALIDATE:
 234         case NB_EV_PREPARE:
 235         case NB_EV_ABORT:
 236         case NB_EV_APPLY:
 237                 /* TODO: implement me. */
 238                 break;
 239         }
 240
 241         return NB_OK;
 242 }
 243
 244 int zebra_allow_external_route_update_destroy(struct nb_cb_destroy_args *args)
 245 {
 246         switch (args->event) {
 247         case NB_EV_VALIDATE:
 248         case NB_EV_PREPARE:
 249         case NB_EV_ABORT:
 250         case NB_EV_APPLY:
 251                 /* TODO: implement me. */
 252                 break;
 253         }
 254
 255         return NB_OK;
 256 }
 257
 258 /*
 259  * XPath: /frr-zebra:zebra/dplane-queue-limit
 260  */
 261 int zebra_dplane_queue_limit_modify(struct nb_cb_modify_args *args)
 262 {
 263         switch (args->event) {
 264         case NB_EV_VALIDATE:
 265         case NB_EV_PREPARE:
 266         case NB_EV_ABORT:
 267         case NB_EV_APPLY:
 268                 /* TODO: implement me. */
 269                 break;
 270         }
 271
 272         return NB_OK;
 273 }
 274
 275 /*
 276  * XPath: /frr-zebra:zebra/vrf-vni-mapping
 277  */
 278 int zebra_vrf_vni_mapping_create(struct nb_cb_create_args *args)
 279 {
 280         switch (args->event) {
 281         case NB_EV_VALIDATE:
 282         case NB_EV_PREPARE:
 283         case NB_EV_ABORT:
 284         case NB_EV_APPLY:
 285                 /* TODO: implement me. */
 286                 break;
 287         }
 288
 289         return NB_OK;
 290 }
 291
 292 int zebra_vrf_vni_mapping_destroy(struct nb_cb_destroy_args *args)
 293 {
 294         switch (args->event) {
 295         case NB_EV_VALIDATE:
 296         case NB_EV_PREPARE:
 297         case NB_EV_ABORT:
 298         case NB_EV_APPLY:
 299                 /* TODO: implement me. */
 300                 break;
 301         }
 302
 303         return NB_OK;
 304 }
 305
 306 /*
 307  * XPath: /frr-zebra:zebra/vrf-vni-mapping/vni-id
 308  */
 309 int zebra_vrf_vni_mapping_vni_id_modify(struct nb_cb_modify_args *args)
 310 {
 311         switch (args->event) {
 312         case NB_EV_VALIDATE:
 313         case NB_EV_PREPARE:
 314         case NB_EV_ABORT:
 315         case NB_EV_APPLY:
 316                 /* TODO: implement me. */
 317                 break;
 318         }
 319
 320         return NB_OK;
 321 }
 322
 323 int zebra_vrf_vni_mapping_vni_id_destroy(struct nb_cb_destroy_args *args)
 324 {
 325         switch (args->event) {
 326         case NB_EV_VALIDATE:
 327         case NB_EV_PREPARE:
 328         case NB_EV_ABORT:
 329         case NB_EV_APPLY:
 330                 /* TODO: implement me. */
 331                 break;
 332         }
 333
 334         return NB_OK;
 335 }
 336
 337 /*
 338  * XPath: /frr-zebra:zebra/vrf-vni-mapping/prefix-only
 339  */
 340 int zebra_vrf_vni_mapping_prefix_only_create(struct nb_cb_create_args *args)
 341 {
 342         switch (args->event) {
 343         case NB_EV_VALIDATE:
 344         case NB_EV_PREPARE:
 345         case NB_EV_ABORT:
 346         case NB_EV_APPLY:
 347                 /* TODO: implement me. */
 348                 break;
 349         }
 350
 351         return NB_OK;
 352 }
 353
 354 int zebra_vrf_vni_mapping_prefix_only_destroy(struct nb_cb_destroy_args *args)
 355 {
 356         switch (args->event) {
 357         case NB_EV_VALIDATE:
 358         case NB_EV_PREPARE:
 359         case NB_EV_ABORT:
 360         case NB_EV_APPLY:
 361                 /* TODO: implement me. */
 362                 break;
 363         }
 364
 365         return NB_OK;
 366 }
 367
 368 /*
 369  * XPath: /frr-zebra:zebra/debugs/debug-events
 370  */
 371 int zebra_debugs_debug_events_modify(struct nb_cb_modify_args *args)
 372 {
 373         switch (args->event) {
 374         case NB_EV_VALIDATE:
 375         case NB_EV_PREPARE:
 376         case NB_EV_ABORT:
 377         case NB_EV_APPLY:
 378                 /* TODO: implement me. */
 379                 break;
 380         }
 381
 382         return NB_OK;
 383 }
 384
 385 int zebra_debugs_debug_events_destroy(struct nb_cb_destroy_args *args)
 386 {
 387         switch (args->event) {
 388         case NB_EV_VALIDATE:
 389         case NB_EV_PREPARE:
 390         case NB_EV_ABORT:
 391         case NB_EV_APPLY:
 392                 /* TODO: implement me. */
 393                 break;
 394         }
 395
 396         return NB_OK;
 397 }
 398
 399 /*
 400  * XPath: /frr-zebra:zebra/debugs/debug-zapi-send
 401  */
 402 int zebra_debugs_debug_zapi_send_modify(struct nb_cb_modify_args *args)
 403 {
 404         switch (args->event) {
 405         case NB_EV_VALIDATE:
 406         case NB_EV_PREPARE:
 407         case NB_EV_ABORT:
 408         case NB_EV_APPLY:
 409                 /* TODO: implement me. */
 410                 break;
 411         }
 412
 413         return NB_OK;
 414 }
 415
 416 int zebra_debugs_debug_zapi_send_destroy(struct nb_cb_destroy_args *args)
 417 {
 418         switch (args->event) {
 419         case NB_EV_VALIDATE:
 420         case NB_EV_PREPARE:
 421         case NB_EV_ABORT:
 422         case NB_EV_APPLY:
 423                 /* TODO: implement me. */
 424                 break;
 425         }
 426
 427         return NB_OK;
 428 }
 429
 430 /*
 431  * XPath: /frr-zebra:zebra/debugs/debug-zapi-recv
 432  */
 433 int zebra_debugs_debug_zapi_recv_modify(struct nb_cb_modify_args *args)
 434 {
 435         switch (args->event) {
 436         case NB_EV_VALIDATE:
 437         case NB_EV_PREPARE:
 438         case NB_EV_ABORT:
 439         case NB_EV_APPLY:
 440                 /* TODO: implement me. */
 441                 break;
 442         }
 443
 444         return NB_OK;
 445 }
 446
 447 int zebra_debugs_debug_zapi_recv_destroy(struct nb_cb_destroy_args *args)
 448 {
 449         switch (args->event) {
 450         case NB_EV_VALIDATE:
 451         case NB_EV_PREPARE:
 452         case NB_EV_ABORT:
 453         case NB_EV_APPLY:
 454                 /* TODO: implement me. */
 455                 break;
 456         }
 457
 458         return NB_OK;
 459 }
 460
 461 /*
 462  * XPath: /frr-zebra:zebra/debugs/debug-zapi-detail
 463  */
 464 int zebra_debugs_debug_zapi_detail_modify(struct nb_cb_modify_args *args)
 465 {
 466         switch (args->event) {
 467         case NB_EV_VALIDATE:
 468         case NB_EV_PREPARE:
 469         case NB_EV_ABORT:
 470         case NB_EV_APPLY:
 471                 /* TODO: implement me. */
 472                 break;
 473         }
 474
 475         return NB_OK;
 476 }
 477
 478 int zebra_debugs_debug_zapi_detail_destroy(struct nb_cb_destroy_args *args)
 479 {
 480         switch (args->event) {
 481         case NB_EV_VALIDATE:
 482         case NB_EV_PREPARE:
 483         case NB_EV_ABORT:
 484         case NB_EV_APPLY:
 485                 /* TODO: implement me. */
 486                 break;
 487         }
 488
 489         return NB_OK;
 490 }
 491
 492 /*
 493  * XPath: /frr-zebra:zebra/debugs/debug-kernel
 494  */
 495 int zebra_debugs_debug_kernel_modify(struct nb_cb_modify_args *args)
 496 {
 497         switch (args->event) {
 498         case NB_EV_VALIDATE:
 499         case NB_EV_PREPARE:
 500         case NB_EV_ABORT:
 501         case NB_EV_APPLY:
 502                 /* TODO: implement me. */
 503                 break;
 504         }
 505
 506         return NB_OK;
 507 }
 508
 509 int zebra_debugs_debug_kernel_destroy(struct nb_cb_destroy_args *args)
 510 {
 511         switch (args->event) {
 512         case NB_EV_VALIDATE:
 513         case NB_EV_PREPARE:
 514         case NB_EV_ABORT:
 515         case NB_EV_APPLY:
 516                 /* TODO: implement me. */
 517                 break;
 518         }
 519
 520         return NB_OK;
 521 }
 522
 523 /*
 524  * XPath: /frr-zebra:zebra/debugs/debug-kernel-msg-send
 525  */
 526 int zebra_debugs_debug_kernel_msg_send_modify(struct nb_cb_modify_args *args)
 527 {
 528         switch (args->event) {
 529         case NB_EV_VALIDATE:
 530         case NB_EV_PREPARE:
 531         case NB_EV_ABORT:
 532         case NB_EV_APPLY:
 533                 /* TODO: implement me. */
 534                 break;
 535         }
 536
 537         return NB_OK;
 538 }
 539
 540 int zebra_debugs_debug_kernel_msg_send_destroy(struct nb_cb_destroy_args *args)
 541 {
 542         switch (args->event) {
 543         case NB_EV_VALIDATE:
 544         case NB_EV_PREPARE:
 545         case NB_EV_ABORT:
 546         case NB_EV_APPLY:
 547                 /* TODO: implement me. */
 548                 break;
 549         }
 550
 551         return NB_OK;
 552 }
 553
 554 /*
 555  * XPath: /frr-zebra:zebra/debugs/debug-kernel-msg-recv
 556  */
 557 int zebra_debugs_debug_kernel_msg_recv_modify(struct nb_cb_modify_args *args)
 558 {
 559         switch (args->event) {
 560         case NB_EV_VALIDATE:
 561         case NB_EV_PREPARE:
 562         case NB_EV_ABORT:
 563         case NB_EV_APPLY:
 564                 /* TODO: implement me. */
 565                 break;
 566         }
 567
 568         return NB_OK;
 569 }
 570
 571 int zebra_debugs_debug_kernel_msg_recv_destroy(struct nb_cb_destroy_args *args)
 572 {
 573         switch (args->event) {
 574         case NB_EV_VALIDATE:
 575         case NB_EV_PREPARE:
 576         case NB_EV_ABORT:
 577         case NB_EV_APPLY:
 578                 /* TODO: implement me. */
 579                 break;
 580         }
 581
 582         return NB_OK;
 583 }
 584
 585 /*
 586  * XPath: /frr-zebra:zebra/debugs/debug-rib
 587  */
 588 int zebra_debugs_debug_rib_modify(struct nb_cb_modify_args *args)
 589 {
 590         switch (args->event) {
 591         case NB_EV_VALIDATE:
 592         case NB_EV_PREPARE:
 593         case NB_EV_ABORT:
 594         case NB_EV_APPLY:
 595                 /* TODO: implement me. */
 596                 break;
 597         }
 598
 599         return NB_OK;
 600 }
 601
 602 int zebra_debugs_debug_rib_destroy(struct nb_cb_destroy_args *args)
 603 {
 604         switch (args->event) {
 605         case NB_EV_VALIDATE:
 606         case NB_EV_PREPARE:
 607         case NB_EV_ABORT:
 608         case NB_EV_APPLY:
 609                 /* TODO: implement me. */
 610                 break;
 611         }
 612
 613         return NB_OK;
 614 }
 615
 616 /*
 617  * XPath: /frr-zebra:zebra/debugs/debug-rib-detail
 618  */
 619 int zebra_debugs_debug_rib_detail_modify(struct nb_cb_modify_args *args)
 620 {
 621         switch (args->event) {
 622         case NB_EV_VALIDATE:
 623         case NB_EV_PREPARE:
 624         case NB_EV_ABORT:
 625         case NB_EV_APPLY:
 626                 /* TODO: implement me. */
 627                 break;
 628         }
 629
 630         return NB_OK;
 631 }
 632
 633 int zebra_debugs_debug_rib_detail_destroy(struct nb_cb_destroy_args *args)
 634 {
 635         switch (args->event) {
 636         case NB_EV_VALIDATE:
 637         case NB_EV_PREPARE:
 638         case NB_EV_ABORT:
 639         case NB_EV_APPLY:
 640                 /* TODO: implement me. */
 641                 break;
 642         }
 643
 644         return NB_OK;
 645 }
 646
 647 /*
 648  * XPath: /frr-zebra:zebra/debugs/debug-fpm
 649  */
 650 int zebra_debugs_debug_fpm_modify(struct nb_cb_modify_args *args)
 651 {
 652         switch (args->event) {
 653         case NB_EV_VALIDATE:
 654         case NB_EV_PREPARE:
 655         case NB_EV_ABORT:
 656         case NB_EV_APPLY:
 657                 /* TODO: implement me. */
 658                 break;
 659         }
 660
 661         return NB_OK;
 662 }
 663
 664 int zebra_debugs_debug_fpm_destroy(struct nb_cb_destroy_args *args)
 665 {
 666         switch (args->event) {
 667         case NB_EV_VALIDATE:
 668         case NB_EV_PREPARE:
 669         case NB_EV_ABORT:
 670         case NB_EV_APPLY:
 671                 /* TODO: implement me. */
 672                 break;
 673         }
 674
 675         return NB_OK;
 676 }
 677
 678 /*
 679  * XPath: /frr-zebra:zebra/debugs/debug-nht
 680  */
 681 int zebra_debugs_debug_nht_modify(struct nb_cb_modify_args *args)
 682 {
 683         switch (args->event) {
 684         case NB_EV_VALIDATE:
 685         case NB_EV_PREPARE:
 686         case NB_EV_ABORT:
 687         case NB_EV_APPLY:
 688                 /* TODO: implement me. */
 689                 break;
 690         }
 691
 692         return NB_OK;
 693 }
 694
 695 int zebra_debugs_debug_nht_destroy(struct nb_cb_destroy_args *args)
 696 {
 697         switch (args->event) {
 698         case NB_EV_VALIDATE:
 699         case NB_EV_PREPARE:
 700         case NB_EV_ABORT:
 701         case NB_EV_APPLY:
 702                 /* TODO: implement me. */
 703                 break;
 704         }
 705
 706         return NB_OK;
 707 }
 708
 709 /*
 710  * XPath: /frr-zebra:zebra/debugs/debug-nht-detail
 711  */
 712 int zebra_debugs_debug_nht_detail_modify(struct nb_cb_modify_args *args)
 713 {
 714         switch (args->event) {
 715         case NB_EV_VALIDATE:
 716         case NB_EV_PREPARE:
 717         case NB_EV_ABORT:
 718         case NB_EV_APPLY:
 719                 /* TODO: implement me. */
 720                 break;
 721         }
 722
 723         return NB_OK;
 724 }
 725
 726 int zebra_debugs_debug_nht_detail_destroy(struct nb_cb_destroy_args *args)
 727 {
 728         switch (args->event) {
 729         case NB_EV_VALIDATE:
 730         case NB_EV_PREPARE:
 731         case NB_EV_ABORT:
 732         case NB_EV_APPLY:
 733                 /* TODO: implement me. */
 734                 break;
 735         }
 736
 737         return NB_OK;
 738 }
 739
 740 /*
 741  * XPath: /frr-zebra:zebra/debugs/debug-mpls
 742  */
 743 int zebra_debugs_debug_mpls_modify(struct nb_cb_modify_args *args)
 744 {
 745         switch (args->event) {
 746         case NB_EV_VALIDATE:
 747         case NB_EV_PREPARE:
 748         case NB_EV_ABORT:
 749         case NB_EV_APPLY:
 750                 /* TODO: implement me. */
 751                 break;
 752         }
 753
 754         return NB_OK;
 755 }
 756
 757 int zebra_debugs_debug_mpls_destroy(struct nb_cb_destroy_args *args)
 758 {
 759         switch (args->event) {
 760         case NB_EV_VALIDATE:
 761         case NB_EV_PREPARE:
 762         case NB_EV_ABORT:
 763         case NB_EV_APPLY:
 764                 /* TODO: implement me. */
 765                 break;
 766         }
 767
 768         return NB_OK;
 769 }
 770
 771 /*
 772  * XPath: /frr-zebra:zebra/debugs/debug-vxlan
 773  */
 774 int zebra_debugs_debug_vxlan_modify(struct nb_cb_modify_args *args)
 775 {
 776         switch (args->event) {
 777         case NB_EV_VALIDATE:
 778         case NB_EV_PREPARE:
 779         case NB_EV_ABORT:
 780         case NB_EV_APPLY:
 781                 /* TODO: implement me. */
 782                 break;
 783         }
 784
 785         return NB_OK;
 786 }
 787
 788 int zebra_debugs_debug_vxlan_destroy(struct nb_cb_destroy_args *args)
 789 {
 790         switch (args->event) {
 791         case NB_EV_VALIDATE:
 792         case NB_EV_PREPARE:
 793         case NB_EV_ABORT:
 794         case NB_EV_APPLY:
 795                 /* TODO: implement me. */
 796                 break;
 797         }
 798
 799         return NB_OK;
 800 }
 801
 802 /*
 803  * XPath: /frr-zebra:zebra/debugs/debug-pw
 804  */
 805 int zebra_debugs_debug_pw_modify(struct nb_cb_modify_args *args)
 806 {
 807         switch (args->event) {
 808         case NB_EV_VALIDATE:
 809         case NB_EV_PREPARE:
 810         case NB_EV_ABORT:
 811         case NB_EV_APPLY:
 812                 /* TODO: implement me. */
 813                 break;
 814         }
 815
 816         return NB_OK;
 817 }
 818
 819 int zebra_debugs_debug_pw_destroy(struct nb_cb_destroy_args *args)
 820 {
 821         switch (args->event) {
 822         case NB_EV_VALIDATE:
 823         case NB_EV_PREPARE:
 824         case NB_EV_ABORT:
 825         case NB_EV_APPLY:
 826                 /* TODO: implement me. */
 827                 break;
 828         }
 829
 830         return NB_OK;
 831 }
 832
 833 /*
 834  * XPath: /frr-zebra:zebra/debugs/debug-dplane
 835  */
 836 int zebra_debugs_debug_dplane_modify(struct nb_cb_modify_args *args)
 837 {
 838         switch (args->event) {
 839         case NB_EV_VALIDATE:
 840         case NB_EV_PREPARE:
 841         case NB_EV_ABORT:
 842         case NB_EV_APPLY:
 843                 /* TODO: implement me. */
 844                 break;
 845         }
 846
 847         return NB_OK;
 848 }
 849
 850 int zebra_debugs_debug_dplane_destroy(struct nb_cb_destroy_args *args)
 851 {
 852         switch (args->event) {
 853         case NB_EV_VALIDATE:
 854         case NB_EV_PREPARE:
 855         case NB_EV_ABORT:
 856         case NB_EV_APPLY:
 857                 /* TODO: implement me. */
 858                 break;
 859         }
 860
 861         return NB_OK;
 862 }
 863
 864 /*
 865  * XPath: /frr-zebra:zebra/debugs/debug-dplane-detail
 866  */
 867 int zebra_debugs_debug_dplane_detail_modify(struct nb_cb_modify_args *args)
 868 {
 869         switch (args->event) {
 870         case NB_EV_VALIDATE:
 871         case NB_EV_PREPARE:
 872         case NB_EV_ABORT:
 873         case NB_EV_APPLY:
 874                 /* TODO: implement me. */
 875                 break;
 876         }
 877
 878         return NB_OK;
 879 }
 880
 881 int zebra_debugs_debug_dplane_detail_destroy(struct nb_cb_destroy_args *args)
 882 {
 883         switch (args->event) {
 884         case NB_EV_VALIDATE:
 885         case NB_EV_PREPARE:
 886         case NB_EV_ABORT:
 887         case NB_EV_APPLY:
 888                 /* TODO: implement me. */
 889                 break;
 890         }
 891
 892         return NB_OK;
 893 }
 894
 895 /*
 896  * XPath: /frr-zebra:zebra/debugs/debug-mlag
 897  */
 898 int zebra_debugs_debug_mlag_modify(struct nb_cb_modify_args *args)
 899 {
 900         switch (args->event) {
 901         case NB_EV_VALIDATE:
 902         case NB_EV_PREPARE:
 903         case NB_EV_ABORT:
 904         case NB_EV_APPLY:
 905                 /* TODO: implement me. */
 906                 break;
 907         }
 908
 909         return NB_OK;
 910 }
 911
 912 int zebra_debugs_debug_mlag_destroy(struct nb_cb_destroy_args *args)
 913 {
 914         switch (args->event) {
 915         case NB_EV_VALIDATE:
 916         case NB_EV_PREPARE:
 917         case NB_EV_ABORT:
 918         case NB_EV_APPLY:
 919                 /* TODO: implement me. */
 920                 break;
 921         }
 922
 923         return NB_OK;
 924 }
 925
 926 /*
 927  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/ip-addrs
 928  */
 929 int lib_interface_zebra_ip_addrs_create(struct nb_cb_create_args *args)
 930 {
 931         struct interface *ifp;
 932         struct prefix prefix;
 933         char buf[PREFIX_STRLEN] = {0};
 934
 935         ifp = nb_running_get_entry(args->dnode, NULL, true);
 936         // addr_family = yang_dnode_get_enum(dnode, "./address-family");
 937         yang_dnode_get_prefix(&prefix, args->dnode, "./ip-prefix");
 938         apply_mask(&prefix);
 939
 940         switch (args->event) {
 941         case NB_EV_VALIDATE:
 942                 if (prefix.family == AF_INET
 943                     && ipv4_martian(&prefix.u.prefix4)) {
 944                         zlog_debug("invalid address %s",
 945                                    prefix2str(&prefix, buf, sizeof(buf)));
 946                         return NB_ERR_VALIDATION;
 947                 } else if (prefix.family == AF_INET6
 948                            && ipv6_martian(&prefix.u.prefix6)) {
 949                         zlog_debug("invalid address %s",
 950                                    prefix2str(&prefix, buf, sizeof(buf)));
 951                         return NB_ERR_VALIDATION;
 952                 }
 953                 break;
 954         case NB_EV_PREPARE:
 955         case NB_EV_ABORT:
 956                 break;
 957         case NB_EV_APPLY:
 958                 if (prefix.family == AF_INET)
 959                         if_ip_address_install(ifp, &prefix, NULL, NULL);
 960                 else if (prefix.family == AF_INET6)
 961                         if_ipv6_address_install(ifp, &prefix, NULL);
 962
 963                 break;
 964         }
 965
 966         return NB_OK;
 967 }
 968
 969 int lib_interface_zebra_ip_addrs_destroy(struct nb_cb_destroy_args *args)
 970 {
 971         struct interface *ifp;
 972         struct prefix prefix;
 973         struct connected *ifc;
 974
 975         ifp = nb_running_get_entry(args->dnode, NULL, true);
 976         yang_dnode_get_prefix(&prefix, args->dnode, "./ip-prefix");
 977         apply_mask(&prefix);
 978
 979         switch (args->event) {
 980         case NB_EV_VALIDATE:
 981                 if (prefix.family == AF_INET) {
 982                         /* Check current interface address. */
 983                         ifc = connected_check_ptp(ifp, &prefix, NULL);
 984                         if (!ifc) {
 985                                 zlog_debug("interface %s Can't find address\n",
 986                                            ifp->name);
 987                                 return NB_ERR_VALIDATION;
 988                         }
 989                 } else if (prefix.family == AF_INET6) {
 990                         /* Check current interface address. */
 991                         ifc = connected_check(ifp, &prefix);
 992                         if (!ifc) {
 993                                 zlog_debug("interface can't find address %s",
 994                                            ifp->name);
 995                                 return NB_ERR_VALIDATION;
 996                         }
 997                 } else
 998                         return NB_ERR_VALIDATION;
 999
1000                 /* This is not configured address. */
1001                 if (!CHECK_FLAG(ifc->conf, ZEBRA_IFC_CONFIGURED)) {
1002                         zlog_debug("interface %s not configured", ifp->name);
1003                         return NB_ERR_VALIDATION;
1004                 }
1005
1006                 /* This is not real address or interface is not active. */
1007                 if (!CHECK_FLAG(ifc->conf, ZEBRA_IFC_QUEUED)
1008                     || !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
1009                         listnode_delete(ifp->connected, ifc);
1010                         connected_free(&ifc);
1011                         return NB_ERR_VALIDATION;
1012                 }
1013                 break;
1014         case NB_EV_PREPARE:
1015         case NB_EV_ABORT:
1016                 break;
1017         case NB_EV_APPLY:
1018                 if_ip_address_uinstall(ifp, &prefix);
1019                 break;
1020         }
1021
1022         return NB_OK;
1023 }
1024
1025 /*
1026  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/ip-addrs/label
1027  */
1028 int lib_interface_zebra_ip_addrs_label_modify(struct nb_cb_modify_args *args)
1029 {
1030         switch (args->event) {
1031         case NB_EV_VALIDATE:
1032         case NB_EV_PREPARE:
1033         case NB_EV_ABORT:
1034         case NB_EV_APPLY:
1035                 /* TODO: implement me. */
1036                 break;
1037         }
1038
1039         return NB_OK;
1040 }
1041
1042 int lib_interface_zebra_ip_addrs_label_destroy(struct nb_cb_destroy_args *args)
1043 {
1044         switch (args->event) {
1045         case NB_EV_VALIDATE:
1046         case NB_EV_PREPARE:
1047         case NB_EV_ABORT:
1048         case NB_EV_APPLY:
1049                 /* TODO: implement me. */
1050                 break;
1051         }
1052
1053         return NB_OK;
1054 }
1055
1056 /*
1057  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/ip-addrs/ip4-peer
1058  */
1059 int lib_interface_zebra_ip_addrs_ip4_peer_modify(struct nb_cb_modify_args *args)
1060 {
1061         switch (args->event) {
1062         case NB_EV_VALIDATE:
1063         case NB_EV_PREPARE:
1064         case NB_EV_ABORT:
1065         case NB_EV_APPLY:
1066                 /* TODO: implement me. */
1067                 break;
1068         }
1069
1070         return NB_OK;
1071 }
1072
1073 int lib_interface_zebra_ip_addrs_ip4_peer_destroy(
1074         struct nb_cb_destroy_args *args)
1075 {
1076         switch (args->event) {
1077         case NB_EV_VALIDATE:
1078         case NB_EV_PREPARE:
1079         case NB_EV_ABORT:
1080         case NB_EV_APPLY:
1081                 /* TODO: implement me. */
1082                 break;
1083         }
1084
1085         return NB_OK;
1086 }
1087
1088 /*
1089  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/multicast
1090  */
1091 int lib_interface_zebra_multicast_modify(struct nb_cb_modify_args *args)
1092 {
1093         if (args->event != NB_EV_APPLY)
1094                 return NB_OK;
1095
1096         struct interface *ifp;
1097
1098         ifp = nb_running_get_entry(args->dnode, NULL, true);
1099
1100         if_multicast_set(ifp);
1101
1102         return NB_OK;
1103 }
1104
1105 int lib_interface_zebra_multicast_destroy(struct nb_cb_destroy_args *args)
1106 {
1107         if (args->event != NB_EV_APPLY)
1108                 return NB_OK;
1109
1110         struct interface *ifp;
1111
1112         ifp = nb_running_get_entry(args->dnode, NULL, true);
1113
1114         if_multicast_unset(ifp);
1115
1116         return NB_OK;
1117 }
1118
1119 /*
1120  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-detect
1121  */
1122 int lib_interface_zebra_link_detect_modify(struct nb_cb_modify_args *args)
1123 {
1124         if (args->event != NB_EV_APPLY)
1125                 return NB_OK;
1126
1127         struct interface *ifp;
1128         bool link_detect;
1129
1130         ifp = nb_running_get_entry(args->dnode, NULL, true);
1131         link_detect = yang_dnode_get_bool(args->dnode, "./link-detect");
1132
1133         if_linkdetect(ifp, link_detect);
1134
1135         return NB_OK;
1136 }
1137
1138 int lib_interface_zebra_link_detect_destroy(struct nb_cb_destroy_args *args)
1139 {
1140         if (args->event != NB_EV_APPLY)
1141                 return NB_OK;
1142
1143         struct interface *ifp;
1144         bool link_detect;
1145
1146         ifp = nb_running_get_entry(args->dnode, NULL, true);
1147         link_detect = yang_dnode_get_bool(args->dnode, "./link-detect");
1148
1149         if_linkdetect(ifp, link_detect);
1150
1151         return NB_OK;
1152 }
1153
1154 /*
1155  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/shutdown
1156  */
1157 int lib_interface_zebra_shutdown_modify(struct nb_cb_modify_args *args)
1158 {
1159         struct interface *ifp;
1160
1161         ifp = nb_running_get_entry(args->dnode, NULL, true);
1162
1163         if_shutdown(ifp);
1164
1165         return NB_OK;
1166 }
1167
1168 int lib_interface_zebra_shutdown_destroy(struct nb_cb_destroy_args *args)
1169 {
1170         struct interface *ifp;
1171
1172         ifp = nb_running_get_entry(args->dnode, NULL, true);
1173
1174         if_no_shutdown(ifp);
1175
1176         return NB_OK;
1177 }
1178
1179 /*
1180  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/bandwidth
1181  */
1182 int lib_interface_zebra_bandwidth_modify(struct nb_cb_modify_args *args)
1183 {
1184         if (args->event != NB_EV_APPLY)
1185                 return NB_OK;
1186
1187         struct interface *ifp;
1188         uint32_t bandwidth;
1189
1190         ifp = nb_running_get_entry(args->dnode, NULL, true);
1191         bandwidth = yang_dnode_get_uint32(args->dnode, "./bandwidth");
1192
1193         ifp->bandwidth = bandwidth;
1194
1195         /* force protocols to recalculate routes due to cost change */
1196         if (if_is_operative(ifp))
1197                 zebra_interface_up_update(ifp);
1198
1199         return NB_OK;
1200 }
1201
1202 int lib_interface_zebra_bandwidth_destroy(struct nb_cb_destroy_args *args)
1203 {
1204         if (args->event != NB_EV_APPLY)
1205                 return NB_OK;
1206
1207         struct interface *ifp;
1208
1209         ifp = nb_running_get_entry(args->dnode, NULL, true);
1210
1211         ifp->bandwidth = 0;
1212
1213         /* force protocols to recalculate routes due to cost change */
1214         if (if_is_operative(ifp))
1215                 zebra_interface_up_update(ifp);
1216
1217         return NB_OK;
1218 }
1219
1220 /*
1221  * XPath: /frr-vrf:lib/vrf/frr-zebra:zebra/ribs/rib
1222  */
1223 int lib_vrf_zebra_ribs_rib_create(struct nb_cb_create_args *args)
1224 {
1225         struct vrf *vrf;
1226         afi_t afi;
1227         safi_t safi;
1228         struct zebra_vrf *zvrf;
1229         struct zebra_router_table *zrt;
1230         uint32_t table_id;
1231         const char *afi_safi_name;
1232
1233         vrf = nb_running_get_entry(args->dnode, NULL, false);
1234         zvrf = vrf_info_lookup(vrf->vrf_id);
1235         table_id = yang_dnode_get_uint32(args->dnode, "./table-id");
1236         if (!table_id)
1237                 table_id = zvrf->table_id;
1238
1239         afi_safi_name = yang_dnode_get_string(args->dnode, "./afi-safi-name");
1240         zebra_afi_safi_identity2value(afi_safi_name, &afi, &safi);
1241
1242         zrt = zebra_router_find_zrt(zvrf, table_id, afi, safi);
1243
1244         switch (args->event) {
1245         case NB_EV_VALIDATE:
1246                 if (!zrt) {
1247                         zlog_debug("%s: vrf %s table is not found.", __func__,
1248                                    vrf->name);
1249                         return NB_ERR_VALIDATION;
1250                 }
1251                 break;
1252         case NB_EV_PREPARE:
1253         case NB_EV_ABORT:
1254                 break;
1255         case NB_EV_APPLY:
1256
1257                 nb_running_set_entry(args->dnode, zrt);
1258
1259                 break;
1260         }
1261
1262         return NB_OK;
1263 }
1264
1265 int lib_vrf_zebra_ribs_rib_destroy(struct nb_cb_destroy_args *args)
1266 {
1267         if (args->event != NB_EV_APPLY)
1268                 return NB_OK;
1269
1270         nb_running_unset_entry(args->dnode);
1271
1272         return NB_OK;
1273 }
1274
1275
1276 /*
1277  * XPath:
1278  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:ipv4-prefix-length
1279  */
1280 int lib_route_map_entry_match_condition_ipv4_prefix_length_modify(
1281         struct nb_cb_modify_args *args)
1282 {
1283         struct routemap_hook_context *rhc;
1284         const char *length;
1285         int condition, rv;
1286
1287         if (args->event != NB_EV_APPLY)
1288                 return NB_OK;
1289
1290         /* Add configuration. */
1291         rhc = nb_running_get_entry(args->dnode, NULL, true);
1292         length = yang_dnode_get_string(args->dnode, NULL);
1293         condition =
1294                 yang_dnode_get_enum(args->dnode, "../frr-route-map:condition");
1295
1296         /* Set destroy information. */
1297         switch (condition) {
1298         case 100: /* ipv4-prefix-length */
1299                 rhc->rhc_rule = "ip address prefix-len";
1300                 break;
1301
1302         case 102: /* ipv4-next-hop-prefix-length */
1303                 rhc->rhc_rule = "ip next-hop prefix-len";
1304                 break;
1305         }
1306         rhc->rhc_mhook = generic_match_delete;
1307         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1308
1309         rv = generic_match_add(NULL, rhc->rhc_rmi, rhc->rhc_rule, length,
1310                                RMAP_EVENT_MATCH_ADDED);
1311         if (rv != CMD_SUCCESS) {
1312                 rhc->rhc_mhook = NULL;
1313                 return NB_ERR_INCONSISTENCY;
1314         }
1315
1316         return NB_OK;
1317 }
1318
1319 int lib_route_map_entry_match_condition_ipv4_prefix_length_destroy(
1320         struct nb_cb_destroy_args *args)
1321 {
1322         return lib_route_map_entry_match_destroy(args);
1323 }
1324
1325 /*
1326  * XPath:
1327  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:ipv6-prefix-length
1328  */
1329 int lib_route_map_entry_match_condition_ipv6_prefix_length_modify(
1330         struct nb_cb_modify_args *args)
1331 {
1332         struct routemap_hook_context *rhc;
1333         const char *length;
1334         int rv;
1335
1336         if (args->event != NB_EV_APPLY)
1337                 return NB_OK;
1338
1339         /* Add configuration. */
1340         rhc = nb_running_get_entry(args->dnode, NULL, true);
1341         length = yang_dnode_get_string(args->dnode, NULL);
1342
1343         /* Set destroy information. */
1344         rhc->rhc_mhook = generic_match_delete;
1345         rhc->rhc_rule = "ipv6 address prefix-len";
1346         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1347
1348         rv = generic_match_add(NULL, rhc->rhc_rmi, "ipv6 address prefix-len",
1349                                length, RMAP_EVENT_MATCH_ADDED);
1350         if (rv != CMD_SUCCESS) {
1351                 rhc->rhc_mhook = NULL;
1352                 return NB_ERR_INCONSISTENCY;
1353         }
1354
1355         return NB_OK;
1356 }
1357
1358 int lib_route_map_entry_match_condition_ipv6_prefix_length_destroy(
1359         struct nb_cb_destroy_args *args)
1360 {
1361         return lib_route_map_entry_match_destroy(args);
1362 }
1363
1364 /*
1365  * XPath:
1366  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:source-protocol
1367  */
1368 int lib_route_map_entry_match_condition_source_protocol_modify(
1369         struct nb_cb_modify_args *args)
1370 {
1371         struct routemap_hook_context *rhc;
1372         const char *type;
1373         int rv;
1374
1375         switch (args->event) {
1376         case NB_EV_VALIDATE:
1377                 type = yang_dnode_get_string(args->dnode, NULL);
1378                 if (proto_name2num(type) == -1) {
1379                         zlog_warn("%s: invalid protocol: %s", __func__, type);
1380                         return NB_ERR_VALIDATION;
1381                 }
1382                 return NB_OK;
1383         case NB_EV_PREPARE:
1384         case NB_EV_ABORT:
1385                 return NB_OK;
1386         case NB_EV_APPLY:
1387                 /* NOTHING */
1388                 break;
1389         }
1390
1391         /* Add configuration. */
1392         rhc = nb_running_get_entry(args->dnode, NULL, true);
1393         type = yang_dnode_get_string(args->dnode, NULL);
1394
1395         /* Set destroy information. */
1396         rhc->rhc_mhook = generic_match_delete;
1397         rhc->rhc_rule = "source-protocol";
1398         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1399
1400         rv = generic_match_add(NULL, rhc->rhc_rmi, "source-protocol", type,
1401                                RMAP_EVENT_MATCH_ADDED);
1402         if (rv != CMD_SUCCESS) {
1403                 rhc->rhc_mhook = NULL;
1404                 return NB_ERR_INCONSISTENCY;
1405         }
1406
1407         return NB_OK;
1408 }
1409
1410 int lib_route_map_entry_match_condition_source_protocol_destroy(
1411         struct nb_cb_destroy_args *args)
1412 {
1413         return lib_route_map_entry_match_destroy(args);
1414 }
1415
1416 /*
1417  * XPath:
1418  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:source-instance
1419  */
1420 int lib_route_map_entry_match_condition_source_instance_modify(
1421         struct nb_cb_modify_args *args)
1422 {
1423         struct routemap_hook_context *rhc;
1424         const char *type;
1425         int rv;
1426
1427         if (args->event != NB_EV_APPLY)
1428                 return NB_OK;
1429
1430         /* Add configuration. */
1431         rhc = nb_running_get_entry(args->dnode, NULL, true);
1432         type = yang_dnode_get_string(args->dnode, NULL);
1433
1434         /* Set destroy information. */
1435         rhc->rhc_mhook = generic_match_delete;
1436         rhc->rhc_rule = "source-instance";
1437         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1438
1439         rv = generic_match_add(NULL, rhc->rhc_rmi, "source-instance", type,
1440                                RMAP_EVENT_MATCH_ADDED);
1441         if (rv != CMD_SUCCESS) {
1442                 rhc->rhc_mhook = NULL;
1443                 return NB_ERR_INCONSISTENCY;
1444         }
1445
1446         return NB_OK;
1447 }
1448
1449 int lib_route_map_entry_match_condition_source_instance_destroy(
1450         struct nb_cb_destroy_args *args)
1451 {
1452         return lib_route_map_entry_match_destroy(args);
1453 }
1454
1455 /*
1456  * XPath: /frr-route-map:lib/route-map/entry/set-action/frr-zebra:source-v4
1457  */
1458 int lib_route_map_entry_set_action_source_v4_modify(
1459         struct nb_cb_modify_args *args)
1460 {
1461         struct routemap_hook_context *rhc;
1462         struct interface *pif = NULL;
1463         const char *source;
1464         struct vrf *vrf;
1465         struct prefix p;
1466         int rv;
1467
1468         switch (args->event) {
1469         case NB_EV_VALIDATE:
1470                 memset(&p, 0, sizeof(p));
1471                 yang_dnode_get_ipv4p(&p, args->dnode, NULL);
1472                 if (zebra_check_addr(&p) == 0) {
1473                         zlog_warn("%s: invalid IPv4 address: %s", __func__,
1474                                   yang_dnode_get_string(args->dnode, NULL));
1475                         return NB_ERR_VALIDATION;
1476                 }
1477
1478                 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
1479                         pif = if_lookup_exact_address(&p.u.prefix4, AF_INET,
1480                                                       vrf->vrf_id);
1481                         if (pif != NULL)
1482                                 break;
1483                 }
1484                 if (pif == NULL) {
1485                         zlog_warn("%s: is not a local adddress: %s", __func__,
1486                                   yang_dnode_get_string(args->dnode, NULL));
1487                         return NB_ERR_VALIDATION;
1488                 }
1489                 return NB_OK;
1490         case NB_EV_PREPARE:
1491         case NB_EV_ABORT:
1492                 return NB_OK;
1493         case NB_EV_APPLY:
1494                 /* NOTHING */
1495                 break;
1496         }
1497
1498         /* Add configuration. */
1499         rhc = nb_running_get_entry(args->dnode, NULL, true);
1500         source = yang_dnode_get_string(args->dnode, NULL);
1501
1502         /* Set destroy information. */
1503         rhc->rhc_shook = generic_set_delete;
1504         rhc->rhc_rule = "src";
1505
1506         rv = generic_set_add(NULL, rhc->rhc_rmi, "src", source);
1507         if (rv != CMD_SUCCESS) {
1508                 rhc->rhc_shook = NULL;
1509                 return NB_ERR_INCONSISTENCY;
1510         }
1511
1512         return NB_OK;
1513 }
1514
1515 int lib_route_map_entry_set_action_source_v4_destroy(
1516         struct nb_cb_destroy_args *args)
1517 {
1518         return lib_route_map_entry_set_destroy(args);
1519 }
1520
1521 /*
1522  * XPath: /frr-route-map:lib/route-map/entry/set-action/frr-zebra:source-v6
1523  */
1524 int lib_route_map_entry_set_action_source_v6_modify(
1525         struct nb_cb_modify_args *args)
1526 {
1527         struct routemap_hook_context *rhc;
1528         struct interface *pif = NULL;
1529         const char *source;
1530         struct vrf *vrf;
1531         struct prefix p;
1532         int rv;
1533
1534         switch (args->event) {
1535         case NB_EV_VALIDATE:
1536                 memset(&p, 0, sizeof(p));
1537                 yang_dnode_get_ipv6p(&p, args->dnode, NULL);
1538                 if (zebra_check_addr(&p) == 0) {
1539                         zlog_warn("%s: invalid IPv6 address: %s", __func__,
1540                                   yang_dnode_get_string(args->dnode, NULL));
1541                         return NB_ERR_VALIDATION;
1542                 }
1543
1544                 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
1545                         pif = if_lookup_exact_address(&p.u.prefix6, AF_INET6,
1546                                                       vrf->vrf_id);
1547                         if (pif != NULL)
1548                                 break;
1549                 }
1550                 if (pif == NULL) {
1551                         zlog_warn("%s: is not a local adddress: %s", __func__,
1552                                   yang_dnode_get_string(args->dnode, NULL));
1553                         return NB_ERR_VALIDATION;
1554                 }
1555                 return NB_OK;
1556         case NB_EV_PREPARE:
1557         case NB_EV_ABORT:
1558                 return NB_OK;
1559         case NB_EV_APPLY:
1560                 /* NOTHING */
1561                 break;
1562         }
1563
1564         /* Add configuration. */
1565         rhc = nb_running_get_entry(args->dnode, NULL, true);
1566         source = yang_dnode_get_string(args->dnode, NULL);
1567
1568         /* Set destroy information. */
1569         rhc->rhc_shook = generic_set_delete;
1570         rhc->rhc_rule = "src";
1571
1572         rv = generic_set_add(NULL, rhc->rhc_rmi, "src", source);
1573         if (rv != CMD_SUCCESS) {
1574                 rhc->rhc_shook = NULL;
1575                 return NB_ERR_INCONSISTENCY;
1576         }
1577
1578         return NB_OK;
1579 }
1580
1581 int lib_route_map_entry_set_action_source_v6_destroy(
1582         struct nb_cb_destroy_args *args)
1583 {
1584         return lib_route_map_entry_set_destroy(args);
1585 }