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                         snprintf(args->errmsg, args->errmsg_len,
 945                                  "invalid address %s",
 946                                  prefix2str(&prefix, buf, sizeof(buf)));
 947                         return NB_ERR_VALIDATION;
 948                 } else if (prefix.family == AF_INET6
 949                            && ipv6_martian(&prefix.u.prefix6)) {
 950                         snprintf(args->errmsg, args->errmsg_len,
 951                                  "invalid address %s",
 952                                  prefix2str(&prefix, buf, sizeof(buf)));
 953                         return NB_ERR_VALIDATION;
 954                 }
 955                 break;
 956         case NB_EV_PREPARE:
 957         case NB_EV_ABORT:
 958                 break;
 959         case NB_EV_APPLY:
 960                 if (prefix.family == AF_INET)
 961                         if_ip_address_install(ifp, &prefix, NULL, NULL);
 962                 else if (prefix.family == AF_INET6)
 963                         if_ipv6_address_install(ifp, &prefix, NULL);
 964
 965                 break;
 966         }
 967
 968         return NB_OK;
 969 }
 970
 971 int lib_interface_zebra_ip_addrs_destroy(struct nb_cb_destroy_args *args)
 972 {
 973         struct interface *ifp;
 974         struct prefix prefix;
 975         struct connected *ifc;
 976
 977         ifp = nb_running_get_entry(args->dnode, NULL, true);
 978         yang_dnode_get_prefix(&prefix, args->dnode, "./ip-prefix");
 979         apply_mask(&prefix);
 980
 981         switch (args->event) {
 982         case NB_EV_VALIDATE:
 983                 if (prefix.family == AF_INET) {
 984                         /* Check current interface address. */
 985                         ifc = connected_check_ptp(ifp, &prefix, NULL);
 986                         if (!ifc) {
 987                                 snprintf(args->errmsg, args->errmsg_len,
 988                                          "interface %s Can't find address\n",
 989                                          ifp->name);
 990                                 return NB_ERR_VALIDATION;
 991                         }
 992                 } else if (prefix.family == AF_INET6) {
 993                         /* Check current interface address. */
 994                         ifc = connected_check(ifp, &prefix);
 995                         if (!ifc) {
 996                                 snprintf(args->errmsg, args->errmsg_len,
 997                                          "interface can't find address %s",
 998                                          ifp->name);
 999                                 return NB_ERR_VALIDATION;
1000                         }
1001                 } else
1002                         return NB_ERR_VALIDATION;
1003
1004                 /* This is not configured address. */
1005                 if (!CHECK_FLAG(ifc->conf, ZEBRA_IFC_CONFIGURED)) {
1006                         snprintf(args->errmsg, args->errmsg_len,
1007                                  "interface %s not configured", ifp->name);
1008                         return NB_ERR_VALIDATION;
1009                 }
1010
1011                 /* This is not real address or interface is not active. */
1012                 if (!CHECK_FLAG(ifc->conf, ZEBRA_IFC_QUEUED)
1013                     || !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
1014                         listnode_delete(ifp->connected, ifc);
1015                         connected_free(&ifc);
1016                         return NB_ERR_VALIDATION;
1017                 }
1018                 break;
1019         case NB_EV_PREPARE:
1020         case NB_EV_ABORT:
1021                 break;
1022         case NB_EV_APPLY:
1023                 if_ip_address_uinstall(ifp, &prefix);
1024                 break;
1025         }
1026
1027         return NB_OK;
1028 }
1029
1030 /*
1031  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/ip-addrs/label
1032  */
1033 int lib_interface_zebra_ip_addrs_label_modify(struct nb_cb_modify_args *args)
1034 {
1035         switch (args->event) {
1036         case NB_EV_VALIDATE:
1037         case NB_EV_PREPARE:
1038         case NB_EV_ABORT:
1039         case NB_EV_APPLY:
1040                 /* TODO: implement me. */
1041                 break;
1042         }
1043
1044         return NB_OK;
1045 }
1046
1047 int lib_interface_zebra_ip_addrs_label_destroy(struct nb_cb_destroy_args *args)
1048 {
1049         switch (args->event) {
1050         case NB_EV_VALIDATE:
1051         case NB_EV_PREPARE:
1052         case NB_EV_ABORT:
1053         case NB_EV_APPLY:
1054                 /* TODO: implement me. */
1055                 break;
1056         }
1057
1058         return NB_OK;
1059 }
1060
1061 /*
1062  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/ip-addrs/ip4-peer
1063  */
1064 int lib_interface_zebra_ip_addrs_ip4_peer_modify(struct nb_cb_modify_args *args)
1065 {
1066         switch (args->event) {
1067         case NB_EV_VALIDATE:
1068         case NB_EV_PREPARE:
1069         case NB_EV_ABORT:
1070         case NB_EV_APPLY:
1071                 /* TODO: implement me. */
1072                 break;
1073         }
1074
1075         return NB_OK;
1076 }
1077
1078 int lib_interface_zebra_ip_addrs_ip4_peer_destroy(
1079         struct nb_cb_destroy_args *args)
1080 {
1081         switch (args->event) {
1082         case NB_EV_VALIDATE:
1083         case NB_EV_PREPARE:
1084         case NB_EV_ABORT:
1085         case NB_EV_APPLY:
1086                 /* TODO: implement me. */
1087                 break;
1088         }
1089
1090         return NB_OK;
1091 }
1092
1093 /*
1094  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/multicast
1095  */
1096 int lib_interface_zebra_multicast_modify(struct nb_cb_modify_args *args)
1097 {
1098         if (args->event != NB_EV_APPLY)
1099                 return NB_OK;
1100
1101         struct interface *ifp;
1102
1103         ifp = nb_running_get_entry(args->dnode, NULL, true);
1104
1105         if_multicast_set(ifp);
1106
1107         return NB_OK;
1108 }
1109
1110 int lib_interface_zebra_multicast_destroy(struct nb_cb_destroy_args *args)
1111 {
1112         if (args->event != NB_EV_APPLY)
1113                 return NB_OK;
1114
1115         struct interface *ifp;
1116
1117         ifp = nb_running_get_entry(args->dnode, NULL, true);
1118
1119         if_multicast_unset(ifp);
1120
1121         return NB_OK;
1122 }
1123
1124 /*
1125  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/link-detect
1126  */
1127 int lib_interface_zebra_link_detect_modify(struct nb_cb_modify_args *args)
1128 {
1129         if (args->event != NB_EV_APPLY)
1130                 return NB_OK;
1131
1132         struct interface *ifp;
1133         bool link_detect;
1134
1135         ifp = nb_running_get_entry(args->dnode, NULL, true);
1136         link_detect = yang_dnode_get_bool(args->dnode, "./link-detect");
1137
1138         if_linkdetect(ifp, link_detect);
1139
1140         return NB_OK;
1141 }
1142
1143 int lib_interface_zebra_link_detect_destroy(struct nb_cb_destroy_args *args)
1144 {
1145         if (args->event != NB_EV_APPLY)
1146                 return NB_OK;
1147
1148         struct interface *ifp;
1149         bool link_detect;
1150
1151         ifp = nb_running_get_entry(args->dnode, NULL, true);
1152         link_detect = yang_dnode_get_bool(args->dnode, "./link-detect");
1153
1154         if_linkdetect(ifp, link_detect);
1155
1156         return NB_OK;
1157 }
1158
1159 /*
1160  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/shutdown
1161  */
1162 int lib_interface_zebra_shutdown_modify(struct nb_cb_modify_args *args)
1163 {
1164         struct interface *ifp;
1165
1166         ifp = nb_running_get_entry(args->dnode, NULL, true);
1167
1168         if_shutdown(ifp);
1169
1170         return NB_OK;
1171 }
1172
1173 int lib_interface_zebra_shutdown_destroy(struct nb_cb_destroy_args *args)
1174 {
1175         struct interface *ifp;
1176
1177         ifp = nb_running_get_entry(args->dnode, NULL, true);
1178
1179         if_no_shutdown(ifp);
1180
1181         return NB_OK;
1182 }
1183
1184 /*
1185  * XPath: /frr-interface:lib/interface/frr-zebra:zebra/bandwidth
1186  */
1187 int lib_interface_zebra_bandwidth_modify(struct nb_cb_modify_args *args)
1188 {
1189         if (args->event != NB_EV_APPLY)
1190                 return NB_OK;
1191
1192         struct interface *ifp;
1193         uint32_t bandwidth;
1194
1195         ifp = nb_running_get_entry(args->dnode, NULL, true);
1196         bandwidth = yang_dnode_get_uint32(args->dnode, "./bandwidth");
1197
1198         ifp->bandwidth = bandwidth;
1199
1200         /* force protocols to recalculate routes due to cost change */
1201         if (if_is_operative(ifp))
1202                 zebra_interface_up_update(ifp);
1203
1204         return NB_OK;
1205 }
1206
1207 int lib_interface_zebra_bandwidth_destroy(struct nb_cb_destroy_args *args)
1208 {
1209         if (args->event != NB_EV_APPLY)
1210                 return NB_OK;
1211
1212         struct interface *ifp;
1213
1214         ifp = nb_running_get_entry(args->dnode, NULL, true);
1215
1216         ifp->bandwidth = 0;
1217
1218         /* force protocols to recalculate routes due to cost change */
1219         if (if_is_operative(ifp))
1220                 zebra_interface_up_update(ifp);
1221
1222         return NB_OK;
1223 }
1224
1225 /*
1226  * XPath: /frr-vrf:lib/vrf/frr-zebra:zebra/ribs/rib
1227  */
1228 int lib_vrf_zebra_ribs_rib_create(struct nb_cb_create_args *args)
1229 {
1230         struct vrf *vrf;
1231         afi_t afi;
1232         safi_t safi;
1233         struct zebra_vrf *zvrf;
1234         struct zebra_router_table *zrt;
1235         uint32_t table_id;
1236         const char *afi_safi_name;
1237
1238         vrf = nb_running_get_entry(args->dnode, NULL, false);
1239         zvrf = vrf_info_lookup(vrf->vrf_id);
1240         table_id = yang_dnode_get_uint32(args->dnode, "./table-id");
1241         if (!table_id)
1242                 table_id = zvrf->table_id;
1243
1244         afi_safi_name = yang_dnode_get_string(args->dnode, "./afi-safi-name");
1245         zebra_afi_safi_identity2value(afi_safi_name, &afi, &safi);
1246
1247         zrt = zebra_router_find_zrt(zvrf, table_id, afi, safi);
1248
1249         switch (args->event) {
1250         case NB_EV_VALIDATE:
1251                 if (!zrt) {
1252                         snprintf(args->errmsg, args->errmsg_len,
1253                                  "vrf %s table is not found.", vrf->name);
1254                         return NB_ERR_VALIDATION;
1255                 }
1256                 break;
1257         case NB_EV_PREPARE:
1258         case NB_EV_ABORT:
1259                 break;
1260         case NB_EV_APPLY:
1261
1262                 nb_running_set_entry(args->dnode, zrt);
1263
1264                 break;
1265         }
1266
1267         return NB_OK;
1268 }
1269
1270 int lib_vrf_zebra_ribs_rib_destroy(struct nb_cb_destroy_args *args)
1271 {
1272         if (args->event != NB_EV_APPLY)
1273                 return NB_OK;
1274
1275         nb_running_unset_entry(args->dnode);
1276
1277         return NB_OK;
1278 }
1279
1280
1281 /*
1282  * XPath:
1283  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:ipv4-prefix-length
1284  */
1285 int lib_route_map_entry_match_condition_ipv4_prefix_length_modify(
1286         struct nb_cb_modify_args *args)
1287 {
1288         struct routemap_hook_context *rhc;
1289         const char *length;
1290         int condition, rv;
1291
1292         if (args->event != NB_EV_APPLY)
1293                 return NB_OK;
1294
1295         /* Add configuration. */
1296         rhc = nb_running_get_entry(args->dnode, NULL, true);
1297         length = yang_dnode_get_string(args->dnode, NULL);
1298         condition =
1299                 yang_dnode_get_enum(args->dnode, "../frr-route-map:condition");
1300
1301         /* Set destroy information. */
1302         switch (condition) {
1303         case 100: /* ipv4-prefix-length */
1304                 rhc->rhc_rule = "ip address prefix-len";
1305                 break;
1306
1307         case 102: /* ipv4-next-hop-prefix-length */
1308                 rhc->rhc_rule = "ip next-hop prefix-len";
1309                 break;
1310         }
1311         rhc->rhc_mhook = generic_match_delete;
1312         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1313
1314         rv = generic_match_add(NULL, rhc->rhc_rmi, rhc->rhc_rule, length,
1315                                RMAP_EVENT_MATCH_ADDED);
1316         if (rv != CMD_SUCCESS) {
1317                 rhc->rhc_mhook = NULL;
1318                 return NB_ERR_INCONSISTENCY;
1319         }
1320
1321         return NB_OK;
1322 }
1323
1324 int lib_route_map_entry_match_condition_ipv4_prefix_length_destroy(
1325         struct nb_cb_destroy_args *args)
1326 {
1327         return lib_route_map_entry_match_destroy(args);
1328 }
1329
1330 /*
1331  * XPath:
1332  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:ipv6-prefix-length
1333  */
1334 int lib_route_map_entry_match_condition_ipv6_prefix_length_modify(
1335         struct nb_cb_modify_args *args)
1336 {
1337         struct routemap_hook_context *rhc;
1338         const char *length;
1339         int rv;
1340
1341         if (args->event != NB_EV_APPLY)
1342                 return NB_OK;
1343
1344         /* Add configuration. */
1345         rhc = nb_running_get_entry(args->dnode, NULL, true);
1346         length = yang_dnode_get_string(args->dnode, NULL);
1347
1348         /* Set destroy information. */
1349         rhc->rhc_mhook = generic_match_delete;
1350         rhc->rhc_rule = "ipv6 address prefix-len";
1351         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1352
1353         rv = generic_match_add(NULL, rhc->rhc_rmi, "ipv6 address prefix-len",
1354                                length, RMAP_EVENT_MATCH_ADDED);
1355         if (rv != CMD_SUCCESS) {
1356                 rhc->rhc_mhook = NULL;
1357                 return NB_ERR_INCONSISTENCY;
1358         }
1359
1360         return NB_OK;
1361 }
1362
1363 int lib_route_map_entry_match_condition_ipv6_prefix_length_destroy(
1364         struct nb_cb_destroy_args *args)
1365 {
1366         return lib_route_map_entry_match_destroy(args);
1367 }
1368
1369 /*
1370  * XPath:
1371  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:source-protocol
1372  */
1373 int lib_route_map_entry_match_condition_source_protocol_modify(
1374         struct nb_cb_modify_args *args)
1375 {
1376         struct routemap_hook_context *rhc;
1377         const char *type;
1378         int rv;
1379
1380         switch (args->event) {
1381         case NB_EV_VALIDATE:
1382                 type = yang_dnode_get_string(args->dnode, NULL);
1383                 if (proto_name2num(type) == -1) {
1384                         snprintf(args->errmsg, args->errmsg_len,
1385                                  "invalid protocol: %s", type);
1386                         return NB_ERR_VALIDATION;
1387                 }
1388                 return NB_OK;
1389         case NB_EV_PREPARE:
1390         case NB_EV_ABORT:
1391                 return NB_OK;
1392         case NB_EV_APPLY:
1393                 /* NOTHING */
1394                 break;
1395         }
1396
1397         /* Add configuration. */
1398         rhc = nb_running_get_entry(args->dnode, NULL, true);
1399         type = yang_dnode_get_string(args->dnode, NULL);
1400
1401         /* Set destroy information. */
1402         rhc->rhc_mhook = generic_match_delete;
1403         rhc->rhc_rule = "source-protocol";
1404         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1405
1406         rv = generic_match_add(NULL, rhc->rhc_rmi, "source-protocol", type,
1407                                RMAP_EVENT_MATCH_ADDED);
1408         if (rv != CMD_SUCCESS) {
1409                 rhc->rhc_mhook = NULL;
1410                 return NB_ERR_INCONSISTENCY;
1411         }
1412
1413         return NB_OK;
1414 }
1415
1416 int lib_route_map_entry_match_condition_source_protocol_destroy(
1417         struct nb_cb_destroy_args *args)
1418 {
1419         return lib_route_map_entry_match_destroy(args);
1420 }
1421
1422 /*
1423  * XPath:
1424  * /frr-route-map:lib/route-map/entry/match-condition/frr-zebra:source-instance
1425  */
1426 int lib_route_map_entry_match_condition_source_instance_modify(
1427         struct nb_cb_modify_args *args)
1428 {
1429         struct routemap_hook_context *rhc;
1430         const char *type;
1431         int rv;
1432
1433         if (args->event != NB_EV_APPLY)
1434                 return NB_OK;
1435
1436         /* Add configuration. */
1437         rhc = nb_running_get_entry(args->dnode, NULL, true);
1438         type = yang_dnode_get_string(args->dnode, NULL);
1439
1440         /* Set destroy information. */
1441         rhc->rhc_mhook = generic_match_delete;
1442         rhc->rhc_rule = "source-instance";
1443         rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1444
1445         rv = generic_match_add(NULL, rhc->rhc_rmi, "source-instance", type,
1446                                RMAP_EVENT_MATCH_ADDED);
1447         if (rv != CMD_SUCCESS) {
1448                 rhc->rhc_mhook = NULL;
1449                 return NB_ERR_INCONSISTENCY;
1450         }
1451
1452         return NB_OK;
1453 }
1454
1455 int lib_route_map_entry_match_condition_source_instance_destroy(
1456         struct nb_cb_destroy_args *args)
1457 {
1458         return lib_route_map_entry_match_destroy(args);
1459 }
1460
1461 /*
1462  * XPath: /frr-route-map:lib/route-map/entry/set-action/frr-zebra:source-v4
1463  */
1464 int lib_route_map_entry_set_action_source_v4_modify(
1465         struct nb_cb_modify_args *args)
1466 {
1467         struct routemap_hook_context *rhc;
1468         struct interface *pif = NULL;
1469         const char *source;
1470         struct vrf *vrf;
1471         struct prefix p;
1472         int rv;
1473
1474         switch (args->event) {
1475         case NB_EV_VALIDATE:
1476                 memset(&p, 0, sizeof(p));
1477                 yang_dnode_get_ipv4p(&p, args->dnode, NULL);
1478                 if (zebra_check_addr(&p) == 0) {
1479                         snprintf(args->errmsg, args->errmsg_len,
1480                                  "invalid IPv4 address: %s",
1481                                  yang_dnode_get_string(args->dnode, NULL));
1482                         return NB_ERR_VALIDATION;
1483                 }
1484
1485                 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
1486                         pif = if_lookup_exact_address(&p.u.prefix4, AF_INET,
1487                                                       vrf->vrf_id);
1488                         if (pif != NULL)
1489                                 break;
1490                 }
1491                 if (pif == NULL) {
1492                         snprintf(args->errmsg, args->errmsg_len,
1493                                  "is not a local adddress: %s",
1494                                  yang_dnode_get_string(args->dnode, NULL));
1495                         return NB_ERR_VALIDATION;
1496                 }
1497                 return NB_OK;
1498         case NB_EV_PREPARE:
1499         case NB_EV_ABORT:
1500                 return NB_OK;
1501         case NB_EV_APPLY:
1502                 /* NOTHING */
1503                 break;
1504         }
1505
1506         /* Add configuration. */
1507         rhc = nb_running_get_entry(args->dnode, NULL, true);
1508         source = yang_dnode_get_string(args->dnode, NULL);
1509
1510         /* Set destroy information. */
1511         rhc->rhc_shook = generic_set_delete;
1512         rhc->rhc_rule = "src";
1513
1514         rv = generic_set_add(NULL, rhc->rhc_rmi, "src", source);
1515         if (rv != CMD_SUCCESS) {
1516                 rhc->rhc_shook = NULL;
1517                 return NB_ERR_INCONSISTENCY;
1518         }
1519
1520         return NB_OK;
1521 }
1522
1523 int lib_route_map_entry_set_action_source_v4_destroy(
1524         struct nb_cb_destroy_args *args)
1525 {
1526         return lib_route_map_entry_set_destroy(args);
1527 }
1528
1529 /*
1530  * XPath: /frr-route-map:lib/route-map/entry/set-action/frr-zebra:source-v6
1531  */
1532 int lib_route_map_entry_set_action_source_v6_modify(
1533         struct nb_cb_modify_args *args)
1534 {
1535         struct routemap_hook_context *rhc;
1536         struct interface *pif = NULL;
1537         const char *source;
1538         struct vrf *vrf;
1539         struct prefix p;
1540         int rv;
1541
1542         switch (args->event) {
1543         case NB_EV_VALIDATE:
1544                 memset(&p, 0, sizeof(p));
1545                 yang_dnode_get_ipv6p(&p, args->dnode, NULL);
1546                 if (zebra_check_addr(&p) == 0) {
1547                         snprintf(args->errmsg, args->errmsg_len,
1548                                  "invalid IPv6 address: %s",
1549                                  yang_dnode_get_string(args->dnode, NULL));
1550                         return NB_ERR_VALIDATION;
1551                 }
1552
1553                 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
1554                         pif = if_lookup_exact_address(&p.u.prefix6, AF_INET6,
1555                                                       vrf->vrf_id);
1556                         if (pif != NULL)
1557                                 break;
1558                 }
1559                 if (pif == NULL) {
1560                         snprintf(args->errmsg, args->errmsg_len,
1561                                  "is not a local adddress: %s",
1562                                  yang_dnode_get_string(args->dnode, NULL));
1563                         return NB_ERR_VALIDATION;
1564                 }
1565                 return NB_OK;
1566         case NB_EV_PREPARE:
1567         case NB_EV_ABORT:
1568                 return NB_OK;
1569         case NB_EV_APPLY:
1570                 /* NOTHING */
1571                 break;
1572         }
1573
1574         /* Add configuration. */
1575         rhc = nb_running_get_entry(args->dnode, NULL, true);
1576         source = yang_dnode_get_string(args->dnode, NULL);
1577
1578         /* Set destroy information. */
1579         rhc->rhc_shook = generic_set_delete;
1580         rhc->rhc_rule = "src";
1581
1582         rv = generic_set_add(NULL, rhc->rhc_rmi, "src", source);
1583         if (rv != CMD_SUCCESS) {
1584                 rhc->rhc_shook = NULL;
1585                 return NB_ERR_INCONSISTENCY;
1586         }
1587
1588         return NB_OK;
1589 }
1590
1591 int lib_route_map_entry_set_action_source_v6_destroy(
1592         struct nb_cb_destroy_args *args)
1593 {
1594         return lib_route_map_entry_set_destroy(args);
1595 }