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