bgpd/bgp_routemap_nb_config.c

   1 /*
   2  * Copyright (C) 2020        Vmware
   3  *                           Sarita Patra
   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/command.h"
  23 #include "lib/log.h"
  24 #include "lib/northbound.h"
  25 #include "lib/routemap.h"
  26 #include "bgpd/bgpd.h"
  27 #include "bgpd/bgp_routemap_nb.h"
  28
  29 /* Add bgp route map rule. */
  30 static int bgp_route_match_add(struct route_map_index *index,
  31                 const char *command, const char *arg,
  32                 route_map_event_t type,
  33                 char *errmsg, size_t errmsg_len)
  34 {
  35         int retval = CMD_SUCCESS;
  36         enum rmap_compile_rets ret;
  37
  38         ret = route_map_add_match(index, command, arg, type);
  39         switch (ret) {
  40         case RMAP_RULE_MISSING:
  41                 snprintf(errmsg, errmsg_len, "%% BGP Can't find rule.");
  42                 retval = CMD_WARNING_CONFIG_FAILED;
  43                 break;
  44         case RMAP_COMPILE_ERROR:
  45                 snprintf(errmsg, errmsg_len, "%% BGP Argument is malformed.");
  46                 retval = CMD_WARNING_CONFIG_FAILED;
  47                 break;
  48         case RMAP_COMPILE_SUCCESS:
  49                 /*
  50                  * Intentionally doing nothing here.
  51                  */
  52                 break;
  53         }
  54
  55         return retval;
  56 }
  57
  58 /* Delete bgp route map rule. */
  59 static int bgp_route_match_delete(struct route_map_index *index,
  60                 const char *command, const char *arg,
  61                 route_map_event_t type,
  62                 char *errmsg, size_t errmsg_len)
  63 {
  64         enum rmap_compile_rets ret;
  65         int retval = CMD_SUCCESS;
  66         char *dep_name = NULL;
  67         const char *tmpstr;
  68         char *rmap_name = NULL;
  69
  70         if (type != RMAP_EVENT_MATCH_DELETED) {
  71                 /* ignore the mundane, the types without any dependency */
  72                 if (arg == NULL) {
  73                         tmpstr = route_map_get_match_arg(index, command);
  74                         if (tmpstr != NULL)
  75                                 dep_name =
  76                                         XSTRDUP(MTYPE_ROUTE_MAP_RULE, tmpstr);
  77                 } else {
  78                         dep_name = XSTRDUP(MTYPE_ROUTE_MAP_RULE, arg);
  79                 }
  80                 rmap_name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, index->map->name);
  81         }
  82
  83         ret = route_map_delete_match(index, command, dep_name, type);
  84         switch (ret) {
  85                 case RMAP_RULE_MISSING:
  86                         snprintf(errmsg, errmsg_len, "%% BGP Can't find rule.");
  87                         retval = CMD_WARNING_CONFIG_FAILED;
  88                         break;
  89                 case RMAP_COMPILE_ERROR:
  90                         snprintf(errmsg, errmsg_len,
  91                                  "%% BGP Argument is malformed.");
  92                         retval = CMD_WARNING_CONFIG_FAILED;
  93                         break;
  94                 case RMAP_COMPILE_SUCCESS:
  95                         /*
  96                          * Nothing to do here
  97                          */
  98                         break;
  99         }
 100
 101         XFREE(MTYPE_ROUTE_MAP_RULE, dep_name);
 102         XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
 103
 104         return retval;
 105 }
 106
 107 /*
 108  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:local-preference
 109  */
 110 int
 111 lib_route_map_entry_match_condition_rmap_match_condition_local_preference_modify(
 112         struct nb_cb_modify_args *args)
 113 {
 114         struct routemap_hook_context *rhc;
 115         const char *local_pref;
 116         enum rmap_compile_rets ret;
 117
 118         switch (args->event) {
 119         case NB_EV_VALIDATE:
 120         case NB_EV_PREPARE:
 121         case NB_EV_ABORT:
 122                 break;
 123         case NB_EV_APPLY:
 124                 /* Add configuration. */
 125                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 126                 local_pref = yang_dnode_get_string(args->dnode, NULL);
 127
 128                 /* Set destroy information. */
 129                 rhc->rhc_mhook = bgp_route_match_delete;
 130                 rhc->rhc_rule = "local-preference";
 131                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 132
 133                 ret = bgp_route_match_add(rhc->rhc_rmi, "local-preference",
 134                                 local_pref, RMAP_EVENT_MATCH_ADDED,
 135                                 args->errmsg, args->errmsg_len);
 136
 137                 if (ret != RMAP_COMPILE_SUCCESS) {
 138                         rhc->rhc_mhook = NULL;
 139                         return NB_ERR_INCONSISTENCY;
 140                 }
 141         }
 142
 143                 return NB_OK;
 144 }
 145
 146 int
 147 lib_route_map_entry_match_condition_rmap_match_condition_local_preference_destroy(
 148         struct nb_cb_destroy_args *args)
 149 {
 150         switch (args->event) {
 151         case NB_EV_VALIDATE:
 152         case NB_EV_PREPARE:
 153         case NB_EV_ABORT:
 154                 break;
 155         case NB_EV_APPLY:
 156                 return lib_route_map_entry_match_destroy(args);
 157         }
 158
 159         return NB_OK;
 160 }
 161
 162 /*
 163  * XPath:
 164  * /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:alias
 165  */
 166 int lib_route_map_entry_match_condition_rmap_match_condition_alias_modify(
 167         struct nb_cb_modify_args *args)
 168 {
 169         struct routemap_hook_context *rhc;
 170         const char *alias;
 171         enum rmap_compile_rets ret;
 172
 173         switch (args->event) {
 174         case NB_EV_VALIDATE:
 175         case NB_EV_PREPARE:
 176         case NB_EV_ABORT:
 177                 break;
 178         case NB_EV_APPLY:
 179                 /* Add configuration. */
 180                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 181                 alias = yang_dnode_get_string(args->dnode, NULL);
 182
 183                 /* Set destroy information. */
 184                 rhc->rhc_mhook = bgp_route_match_delete;
 185                 rhc->rhc_rule = "alias";
 186                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 187
 188                 ret = bgp_route_match_add(rhc->rhc_rmi, "alias", alias,
 189                                           RMAP_EVENT_MATCH_ADDED, args->errmsg,
 190                                           args->errmsg_len);
 191
 192                 if (ret != RMAP_COMPILE_SUCCESS) {
 193                         rhc->rhc_mhook = NULL;
 194                         return NB_ERR_VALIDATION;
 195                 }
 196
 197                 break;
 198         }
 199
 200         return NB_OK;
 201 }
 202
 203 int lib_route_map_entry_match_condition_rmap_match_condition_alias_destroy(
 204         struct nb_cb_destroy_args *args)
 205 {
 206         switch (args->event) {
 207         case NB_EV_VALIDATE:
 208         case NB_EV_PREPARE:
 209         case NB_EV_ABORT:
 210                 break;
 211         case NB_EV_APPLY:
 212                 return lib_route_map_entry_match_destroy(args);
 213         }
 214
 215         return NB_OK;
 216 }
 217
 218 /*
 219  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:script
 220  */
 221 int
 222 lib_route_map_entry_match_condition_rmap_match_condition_script_modify(
 223         struct nb_cb_modify_args *args)
 224 {
 225         struct routemap_hook_context *rhc;
 226         const char *script;
 227         enum rmap_compile_rets ret;
 228
 229         switch (args->event) {
 230         case NB_EV_VALIDATE:
 231         case NB_EV_PREPARE:
 232         case NB_EV_ABORT:
 233                 break;
 234         case NB_EV_APPLY:
 235                 /* Add configuration. */
 236                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 237                 script = yang_dnode_get_string(args->dnode, NULL);
 238
 239                 /* Set destroy information. */
 240                 rhc->rhc_mhook = bgp_route_match_delete;
 241                 rhc->rhc_rule = "script";
 242                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 243
 244                 ret = bgp_route_match_add(rhc->rhc_rmi, "script",
 245                                 script, RMAP_EVENT_MATCH_ADDED,
 246                                 args->errmsg, args->errmsg_len);
 247
 248                 if (ret != RMAP_COMPILE_SUCCESS) {
 249                         rhc->rhc_mhook = NULL;
 250                         return NB_ERR_INCONSISTENCY;
 251                 }
 252         }
 253
 254         return NB_OK;
 255 }
 256
 257 int
 258 lib_route_map_entry_match_condition_rmap_match_condition_script_destroy(
 259         struct nb_cb_destroy_args *args)
 260 {
 261         switch (args->event) {
 262         case NB_EV_VALIDATE:
 263         case NB_EV_PREPARE:
 264         case NB_EV_ABORT:
 265                 break;
 266         case NB_EV_APPLY:
 267                 return lib_route_map_entry_match_destroy(args);
 268         }
 269
 270         return NB_OK;
 271 }
 272
 273 /*
 274  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:origin
 275  */
 276 int
 277 lib_route_map_entry_match_condition_rmap_match_condition_origin_modify(
 278         struct nb_cb_modify_args *args)
 279 {
 280         struct routemap_hook_context *rhc;
 281         const char *origin;
 282         enum rmap_compile_rets ret;
 283
 284         switch (args->event) {
 285         case NB_EV_VALIDATE:
 286         case NB_EV_PREPARE:
 287         case NB_EV_ABORT:
 288                 break;
 289         case NB_EV_APPLY:
 290                 /* Add configuration. */
 291                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 292                 origin = yang_dnode_get_string(args->dnode, NULL);
 293
 294                 /* Set destroy information. */
 295                 rhc->rhc_mhook = bgp_route_match_delete;
 296                 rhc->rhc_rule = "origin";
 297                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 298
 299                 ret = bgp_route_match_add(rhc->rhc_rmi, "origin", origin,
 300                                           RMAP_EVENT_MATCH_ADDED,
 301                                           args->errmsg, args->errmsg_len);
 302
 303                 if (ret != RMAP_COMPILE_SUCCESS) {
 304                         rhc->rhc_mhook = NULL;
 305                         return NB_ERR_INCONSISTENCY;
 306                 }
 307         }
 308
 309         return NB_OK;
 310 }
 311
 312 int
 313 lib_route_map_entry_match_condition_rmap_match_condition_origin_destroy(
 314         struct nb_cb_destroy_args *args)
 315 {
 316         switch (args->event) {
 317         case NB_EV_VALIDATE:
 318         case NB_EV_PREPARE:
 319         case NB_EV_ABORT:
 320                 break;
 321         case NB_EV_APPLY:
 322                 return lib_route_map_entry_match_destroy(args);
 323         }
 324
 325         return NB_OK;
 326 }
 327
 328 /*
 329  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:rpki
 330  */
 331 int
 332 lib_route_map_entry_match_condition_rmap_match_condition_rpki_modify(
 333         struct nb_cb_modify_args *args)
 334 {
 335         struct routemap_hook_context *rhc;
 336         const char *rpki;
 337         enum rmap_compile_rets ret;
 338
 339         switch (args->event) {
 340         case NB_EV_VALIDATE:
 341         case NB_EV_PREPARE:
 342         case NB_EV_ABORT:
 343                 break;
 344         case NB_EV_APPLY:
 345                 /* Add configuration. */
 346                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 347                 rpki = yang_dnode_get_string(args->dnode, NULL);
 348
 349                 /* Set destroy information. */
 350                 rhc->rhc_mhook = bgp_route_match_delete;
 351                 rhc->rhc_rule = "rpki";
 352                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 353
 354                 ret = bgp_route_match_add(rhc->rhc_rmi, "rpki", rpki,
 355                                 RMAP_EVENT_MATCH_ADDED,
 356                                 args->errmsg, args->errmsg_len);
 357
 358                 if (ret != RMAP_COMPILE_SUCCESS) {
 359                         rhc->rhc_mhook = NULL;
 360                         return NB_ERR_INCONSISTENCY;
 361                 }
 362         }
 363
 364         return NB_OK;
 365 }
 366
 367 int
 368 lib_route_map_entry_match_condition_rmap_match_condition_rpki_destroy(
 369         struct nb_cb_destroy_args *args)
 370 {
 371         switch (args->event) {
 372         case NB_EV_VALIDATE:
 373         case NB_EV_PREPARE:
 374         case NB_EV_ABORT:
 375                 break;
 376         case NB_EV_APPLY:
 377                 return lib_route_map_entry_match_destroy(args);
 378         }
 379
 380         return NB_OK;
 381 }
 382
 383 /*
 384  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:probability
 385  */
 386 int
 387 lib_route_map_entry_match_condition_rmap_match_condition_probability_modify(
 388         struct nb_cb_modify_args *args)
 389 {
 390         struct routemap_hook_context *rhc;
 391         const char *probability;
 392         enum rmap_compile_rets ret;
 393
 394         switch (args->event) {
 395         case NB_EV_VALIDATE:
 396         case NB_EV_PREPARE:
 397         case NB_EV_ABORT:
 398                 break;
 399         case NB_EV_APPLY:
 400                 /* Add configuration. */
 401                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 402                 probability = yang_dnode_get_string(args->dnode, NULL);
 403
 404                 /* Set destroy information. */
 405                 rhc->rhc_mhook = bgp_route_match_delete;
 406                 rhc->rhc_rule = "probability";
 407                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 408
 409                 ret = bgp_route_match_add(rhc->rhc_rmi, "probability",
 410                                           probability, RMAP_EVENT_MATCH_ADDED,
 411                                           args->errmsg, args->errmsg_len);
 412
 413                 if (ret != RMAP_COMPILE_SUCCESS) {
 414                         rhc->rhc_mhook = NULL;
 415                         return NB_ERR_INCONSISTENCY;
 416                 }
 417         }
 418
 419         return NB_OK;
 420 }
 421
 422 int
 423 lib_route_map_entry_match_condition_rmap_match_condition_probability_destroy(
 424         struct nb_cb_destroy_args *args)
 425 {
 426         switch (args->event) {
 427         case NB_EV_VALIDATE:
 428         case NB_EV_PREPARE:
 429         case NB_EV_ABORT:
 430         case NB_EV_APPLY:
 431                 return lib_route_map_entry_match_destroy(args);
 432         }
 433
 434         return NB_OK;
 435 }
 436
 437 /*
 438  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:source-vrf
 439  */
 440 int
 441 lib_route_map_entry_match_condition_rmap_match_condition_source_vrf_modify(
 442         struct nb_cb_modify_args *args)
 443 {
 444         struct routemap_hook_context *rhc;
 445         const char *vrf;
 446         enum rmap_compile_rets ret;
 447
 448         switch (args->event) {
 449         case NB_EV_VALIDATE:
 450         case NB_EV_PREPARE:
 451         case NB_EV_ABORT:
 452                 break;
 453         case NB_EV_APPLY:
 454                 /* Add configuration. */
 455                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 456                 vrf = yang_dnode_get_string(args->dnode, NULL);
 457
 458                 /* Set destroy information. */
 459                 rhc->rhc_mhook = bgp_route_match_delete;
 460                 rhc->rhc_rule = "source-vrf";
 461                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 462
 463                 ret = bgp_route_match_add(rhc->rhc_rmi, "source-vrf", vrf,
 464                                           RMAP_EVENT_MATCH_ADDED,
 465                                           args->errmsg, args->errmsg_len);
 466
 467                 if (ret != RMAP_COMPILE_SUCCESS) {
 468                         rhc->rhc_mhook = NULL;
 469                         return NB_ERR_INCONSISTENCY;
 470                 }
 471         }
 472
 473         return NB_OK;
 474 }
 475
 476 int
 477 lib_route_map_entry_match_condition_rmap_match_condition_source_vrf_destroy(
 478         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                 break;
 485         case NB_EV_APPLY:
 486                 return lib_route_map_entry_match_destroy(args);
 487         }
 488
 489         return NB_OK;
 490 }
 491
 492 /*
 493  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:peer-ipv4-address
 494  */
 495 int
 496 lib_route_map_entry_match_condition_rmap_match_condition_peer_ipv4_address_modify(
 497         struct nb_cb_modify_args *args)
 498 {
 499         struct routemap_hook_context *rhc;
 500         const char *peer;
 501         enum rmap_compile_rets ret;
 502
 503         switch (args->event) {
 504         case NB_EV_VALIDATE:
 505         case NB_EV_PREPARE:
 506         case NB_EV_ABORT:
 507                 break;
 508         case NB_EV_APPLY:
 509                 /* Add configuration. */
 510                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 511                 peer = yang_dnode_get_string(args->dnode, NULL);
 512
 513                 /* Set destroy information. */
 514                 rhc->rhc_mhook = bgp_route_match_delete;
 515                 rhc->rhc_rule = "peer";
 516                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 517
 518                 ret = bgp_route_match_add(rhc->rhc_rmi, "peer", peer,
 519                                           RMAP_EVENT_MATCH_ADDED,
 520                                           args->errmsg, args->errmsg_len);
 521
 522                 if (ret != RMAP_COMPILE_SUCCESS) {
 523                         rhc->rhc_mhook = NULL;
 524                         return NB_ERR_INCONSISTENCY;
 525                 }
 526         }
 527
 528         return NB_OK;
 529 }
 530
 531 int
 532 lib_route_map_entry_match_condition_rmap_match_condition_peer_ipv4_address_destroy(
 533         struct nb_cb_destroy_args *args)
 534 {
 535         switch (args->event) {
 536         case NB_EV_VALIDATE:
 537         case NB_EV_PREPARE:
 538         case NB_EV_ABORT:
 539                 break;
 540         case NB_EV_APPLY:
 541                 return lib_route_map_entry_match_destroy(args);
 542         }
 543
 544         return NB_OK;
 545 }
 546
 547 /*
 548  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:peer-interface
 549  */
 550 int
 551 lib_route_map_entry_match_condition_rmap_match_condition_peer_interface_modify(
 552         struct nb_cb_modify_args *args)
 553 {
 554         struct routemap_hook_context *rhc;
 555         const char *peer;
 556         enum rmap_compile_rets ret;
 557
 558         switch (args->event) {
 559         case NB_EV_VALIDATE:
 560         case NB_EV_PREPARE:
 561         case NB_EV_ABORT:
 562                 break;
 563         case NB_EV_APPLY:
 564                 /* Add configuration. */
 565                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 566                 peer = yang_dnode_get_string(args->dnode, NULL);
 567
 568                 /* Set destroy information. */
 569                 rhc->rhc_mhook = bgp_route_match_delete;
 570                 rhc->rhc_rule = "peer";
 571                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 572
 573                 ret = bgp_route_match_add(rhc->rhc_rmi, "peer", peer,
 574                                 RMAP_EVENT_MATCH_ADDED,
 575                                 args->errmsg, args->errmsg_len);
 576
 577                 if (ret != RMAP_COMPILE_SUCCESS) {
 578                         rhc->rhc_mhook = NULL;
 579                         return NB_ERR_INCONSISTENCY;
 580                 }
 581         }
 582
 583         return NB_OK;
 584 }
 585
 586 int
 587 lib_route_map_entry_match_condition_rmap_match_condition_peer_interface_destroy(
 588         struct nb_cb_destroy_args *args)
 589 {
 590         switch (args->event) {
 591         case NB_EV_VALIDATE:
 592         case NB_EV_PREPARE:
 593         case NB_EV_ABORT:
 594                 break;
 595         case NB_EV_APPLY:
 596                 return lib_route_map_entry_match_destroy(args);
 597         }
 598
 599         return NB_OK;
 600 }
 601
 602 /*
 603  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:peer-ipv6-address
 604  */
 605 int
 606 lib_route_map_entry_match_condition_rmap_match_condition_peer_ipv6_address_modify(
 607         struct nb_cb_modify_args *args)
 608 {
 609         struct routemap_hook_context *rhc;
 610         const char *peer;
 611         enum rmap_compile_rets ret;
 612
 613         switch (args->event) {
 614         case NB_EV_VALIDATE:
 615         case NB_EV_PREPARE:
 616         case NB_EV_ABORT:
 617                 break;
 618         case NB_EV_APPLY:
 619                 /* Add configuration. */
 620                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 621                 peer = yang_dnode_get_string(args->dnode, NULL);
 622
 623                 /* Set destroy information. */
 624                 rhc->rhc_mhook = bgp_route_match_delete;
 625                 rhc->rhc_rule = "peer";
 626                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 627
 628                 ret = bgp_route_match_add(rhc->rhc_rmi, "peer", peer,
 629                                 RMAP_EVENT_MATCH_ADDED,
 630                                 args->errmsg, args->errmsg_len);
 631
 632                 if (ret != RMAP_COMPILE_SUCCESS) {
 633                         rhc->rhc_mhook = NULL;
 634                         return NB_ERR_INCONSISTENCY;
 635                 }
 636         }
 637
 638         return NB_OK;
 639 }
 640
 641 int
 642 lib_route_map_entry_match_condition_rmap_match_condition_peer_ipv6_address_destroy(
 643         struct nb_cb_destroy_args *args)
 644 {
 645         switch (args->event) {
 646         case NB_EV_VALIDATE:
 647         case NB_EV_PREPARE:
 648         case NB_EV_ABORT:
 649                 break;
 650         case NB_EV_APPLY:
 651                 return lib_route_map_entry_match_destroy(args);
 652         }
 653
 654         return NB_OK;
 655 }
 656
 657 /*
 658  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:peer-local
 659  */
 660 int
 661 lib_route_map_entry_match_condition_rmap_match_condition_peer_local_modify(
 662         struct nb_cb_modify_args *args)
 663 {
 664         struct routemap_hook_context *rhc;
 665         bool value;
 666         enum rmap_compile_rets ret;
 667
 668         switch (args->event) {
 669         case NB_EV_VALIDATE:
 670         case NB_EV_PREPARE:
 671         case NB_EV_ABORT:
 672                 break;
 673         case NB_EV_APPLY:
 674                 /* Add configuration. */
 675                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 676                 value = yang_dnode_get_bool(args->dnode, NULL);
 677
 678                 /* Set destroy information. */
 679                 rhc->rhc_mhook = bgp_route_match_delete;
 680                 rhc->rhc_rule = "peer";
 681                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 682
 683                 if (value) {
 684                         ret = bgp_route_match_add(rhc->rhc_rmi, "peer",
 685                                                 "local",
 686                                                 RMAP_EVENT_MATCH_ADDED,
 687                                                 args->errmsg, args->errmsg_len);
 688
 689                         if (ret != RMAP_COMPILE_SUCCESS) {
 690                                 rhc->rhc_mhook = NULL;
 691                                 return NB_ERR_INCONSISTENCY;
 692                         }
 693                 }
 694         }
 695
 696         return NB_OK;
 697 }
 698
 699 int
 700 lib_route_map_entry_match_condition_rmap_match_condition_peer_local_destroy(
 701         struct nb_cb_destroy_args *args)
 702 {
 703         switch (args->event) {
 704         case NB_EV_VALIDATE:
 705         case NB_EV_PREPARE:
 706         case NB_EV_ABORT:
 707                 break;
 708         case NB_EV_APPLY:
 709                 return lib_route_map_entry_match_destroy(args);
 710         }
 711
 712         return NB_OK;
 713 }
 714
 715 /*
 716  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:list-name
 717  */
 718 int
 719 lib_route_map_entry_match_condition_rmap_match_condition_list_name_modify(
 720         struct nb_cb_modify_args *args)
 721 {
 722         struct routemap_hook_context *rhc;
 723         const char *list_name;
 724         enum rmap_compile_rets ret = RMAP_COMPILE_SUCCESS;
 725         const char *condition;
 726
 727         switch (args->event) {
 728         case NB_EV_VALIDATE:
 729         case NB_EV_PREPARE:
 730         case NB_EV_ABORT:
 731                 break;
 732         case NB_EV_APPLY:
 733                 /* Add configuration. */
 734                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 735                 list_name = yang_dnode_get_string(args->dnode, NULL);
 736                 condition = yang_dnode_get_string(args->dnode,
 737                                 "../../frr-route-map:condition");
 738
 739                 if (IS_MATCH_AS_LIST(condition)) {
 740                         /* Set destroy information. */
 741                         rhc->rhc_mhook = bgp_route_match_delete;
 742                         rhc->rhc_rule = "as-path";
 743                         rhc->rhc_event = RMAP_EVENT_ASLIST_DELETED;
 744
 745                         ret = bgp_route_match_add(rhc->rhc_rmi, "as-path",
 746                                         list_name, RMAP_EVENT_ASLIST_ADDED,
 747                                         args->errmsg, args->errmsg_len);
 748                 } else if (IS_MATCH_MAC_LIST(condition)) {
 749                         /* Set destroy information. */
 750                         rhc->rhc_mhook = bgp_route_match_delete;
 751                         rhc->rhc_rule = "mac address";
 752                         rhc->rhc_event = RMAP_EVENT_FILTER_DELETED;
 753
 754                         ret = bgp_route_match_add(rhc->rhc_rmi,
 755                                                   "mac address",
 756                                                   list_name,
 757                                                   RMAP_EVENT_FILTER_ADDED,
 758                                                   args->errmsg, args->errmsg_len);
 759                 } else if (IS_MATCH_ROUTE_SRC(condition)) {
 760                         /* Set destroy information. */
 761                         rhc->rhc_mhook = bgp_route_match_delete;
 762                         rhc->rhc_rule = "ip route-source";
 763                         rhc->rhc_event = RMAP_EVENT_FILTER_DELETED;
 764
 765                         ret = bgp_route_match_add(rhc->rhc_rmi,
 766                                         "ip route-source",
 767                                         list_name, RMAP_EVENT_FILTER_ADDED,
 768                                         args->errmsg, args->errmsg_len);
 769                 } else if (IS_MATCH_ROUTE_SRC_PL(condition)) {
 770                         /* Set destroy information. */
 771                         rhc->rhc_mhook = bgp_route_match_delete;
 772                         rhc->rhc_rule = "ip route-source prefix-list";
 773                         rhc->rhc_event = RMAP_EVENT_PLIST_DELETED;
 774
 775                         ret = bgp_route_match_add(rhc->rhc_rmi,
 776                                         "ip route-source prefix-list",
 777                                         list_name, RMAP_EVENT_PLIST_ADDED,
 778                                         args->errmsg, args->errmsg_len);
 779                 }
 780
 781                 if (ret != RMAP_COMPILE_SUCCESS) {
 782                         rhc->rhc_mhook = NULL;
 783                         return NB_ERR_INCONSISTENCY;
 784                 }
 785         }
 786
 787         return NB_OK;
 788 }
 789
 790 int
 791 lib_route_map_entry_match_condition_rmap_match_condition_list_name_destroy(
 792         struct nb_cb_destroy_args *args)
 793 {
 794         switch (args->event) {
 795         case NB_EV_VALIDATE:
 796         case NB_EV_PREPARE:
 797         case NB_EV_ABORT:
 798                 break;
 799         case NB_EV_APPLY:
 800                 return lib_route_map_entry_match_destroy(args);
 801         }
 802
 803         return NB_OK;
 804 }
 805
 806 /*
 807  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:evpn-default-route
 808  */
 809 int
 810 lib_route_map_entry_match_condition_rmap_match_condition_evpn_default_route_create(
 811         struct nb_cb_create_args *args)
 812 {
 813         struct routemap_hook_context *rhc;
 814         enum rmap_compile_rets ret;
 815
 816         switch (args->event) {
 817         case NB_EV_VALIDATE:
 818         case NB_EV_PREPARE:
 819         case NB_EV_ABORT:
 820                 break;
 821         case NB_EV_APPLY:
 822                 /* Add configuration. */
 823                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 824
 825                 /* Set destroy information. */
 826                 rhc->rhc_mhook = bgp_route_match_delete;
 827                 rhc->rhc_rule = "evpn default-route";
 828                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 829
 830                 ret = bgp_route_match_add(rhc->rhc_rmi, "evpn default-route",
 831                                           NULL, RMAP_EVENT_MATCH_ADDED,
 832                                           args->errmsg, args->errmsg_len);
 833
 834                 if (ret != RMAP_COMPILE_SUCCESS) {
 835                         rhc->rhc_mhook = NULL;
 836                         return NB_ERR_INCONSISTENCY;
 837                 }
 838         }
 839
 840         return NB_OK;
 841 }
 842
 843 int
 844 lib_route_map_entry_match_condition_rmap_match_condition_evpn_default_route_destroy(
 845         struct nb_cb_destroy_args *args)
 846 {
 847         switch (args->event) {
 848         case NB_EV_VALIDATE:
 849         case NB_EV_PREPARE:
 850         case NB_EV_ABORT:
 851                 break;
 852         case NB_EV_APPLY:
 853                 return lib_route_map_entry_match_destroy(args);
 854         }
 855
 856         return NB_OK;
 857 }
 858
 859 /*
 860  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:evpn-vni
 861  */
 862 int
 863 lib_route_map_entry_match_condition_rmap_match_condition_evpn_vni_modify(
 864         struct nb_cb_modify_args *args)
 865 {
 866         struct routemap_hook_context *rhc;
 867         const char *vni;
 868         enum rmap_compile_rets ret;
 869
 870         switch (args->event) {
 871         case NB_EV_VALIDATE:
 872         case NB_EV_PREPARE:
 873         case NB_EV_ABORT:
 874                 break;
 875         case NB_EV_APPLY:
 876                 /* Add configuration. */
 877                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 878                 vni = yang_dnode_get_string(args->dnode, NULL);
 879
 880                 /* Set destroy information. */
 881                 rhc->rhc_mhook = bgp_route_match_delete;
 882                 rhc->rhc_rule = "evpn vni";
 883                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 884
 885                 ret = bgp_route_match_add(rhc->rhc_rmi, "evpn vni", vni,
 886                                 RMAP_EVENT_MATCH_ADDED,
 887                                 args->errmsg, args->errmsg_len);
 888
 889                 if (ret != RMAP_COMPILE_SUCCESS) {
 890                         rhc->rhc_mhook = NULL;
 891                         return NB_ERR_INCONSISTENCY;
 892                 }
 893         }
 894
 895         return NB_OK;
 896 }
 897
 898 int
 899 lib_route_map_entry_match_condition_rmap_match_condition_evpn_vni_destroy(
 900         struct nb_cb_destroy_args *args)
 901 {
 902         switch (args->event) {
 903         case NB_EV_VALIDATE:
 904         case NB_EV_PREPARE:
 905         case NB_EV_ABORT:
 906                 break;
 907         case NB_EV_APPLY:
 908                 return lib_route_map_entry_match_destroy(args);
 909         }
 910
 911         return NB_OK;
 912 }
 913
 914 /*
 915  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:evpn-route-type
 916  */
 917 int
 918 lib_route_map_entry_match_condition_rmap_match_condition_evpn_route_type_modify(
 919         struct nb_cb_modify_args *args)
 920 {
 921         struct routemap_hook_context *rhc;
 922         const char *type;
 923         enum rmap_compile_rets ret;
 924
 925         switch (args->event) {
 926         case NB_EV_VALIDATE:
 927         case NB_EV_PREPARE:
 928         case NB_EV_ABORT:
 929                 break;
 930         case NB_EV_APPLY:
 931                 /* Add configuration. */
 932                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 933                 type = yang_dnode_get_string(args->dnode, NULL);
 934
 935                 /* Set destroy information. */
 936                 rhc->rhc_mhook = bgp_route_match_delete;
 937                 rhc->rhc_rule = "evpn route-type";
 938                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 939
 940                 ret = bgp_route_match_add(rhc->rhc_rmi, "evpn route-type",
 941                                           type,
 942                                           RMAP_EVENT_MATCH_ADDED,
 943                                           args->errmsg, args->errmsg_len);
 944
 945                 if (ret != RMAP_COMPILE_SUCCESS) {
 946                         rhc->rhc_mhook = NULL;
 947                         return NB_ERR_INCONSISTENCY;
 948                 }
 949         }
 950
 951         return NB_OK;
 952 }
 953
 954 int
 955 lib_route_map_entry_match_condition_rmap_match_condition_evpn_route_type_destroy(
 956         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                 break;
 963         case NB_EV_APPLY:
 964                 return lib_route_map_entry_match_destroy(args);
 965         }
 966
 967         return NB_OK;
 968 }
 969
 970 /*
 971  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:route-distinguisher
 972  */
 973 int
 974 lib_route_map_entry_match_condition_rmap_match_condition_route_distinguisher_modify(
 975         struct nb_cb_modify_args *args)
 976 {
 977         struct routemap_hook_context *rhc;
 978         const char *rd;
 979         enum rmap_compile_rets ret;
 980
 981         switch (args->event) {
 982         case NB_EV_VALIDATE:
 983         case NB_EV_PREPARE:
 984         case NB_EV_ABORT:
 985                 break;
 986         case NB_EV_APPLY:
 987                 /* Add configuration. */
 988                 rhc = nb_running_get_entry(args->dnode, NULL, true);
 989                 rd = yang_dnode_get_string(args->dnode, NULL);
 990
 991                 /* Set destroy information. */
 992                 rhc->rhc_mhook = bgp_route_match_delete;
 993                 rhc->rhc_rule = "evpn rd";
 994                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
 995
 996                 ret = bgp_route_match_add(rhc->rhc_rmi, "evpn rd", rd,
 997                                 RMAP_EVENT_MATCH_ADDED,
 998                                 args->errmsg, args->errmsg_len);
 999
1000                 if (ret != RMAP_COMPILE_SUCCESS) {
1001                         rhc->rhc_mhook = NULL;
1002                         return NB_ERR_INCONSISTENCY;
1003                 }
1004         }
1005
1006         return NB_OK;
1007 }
1008
1009 int
1010 lib_route_map_entry_match_condition_rmap_match_condition_route_distinguisher_destroy(
1011         struct nb_cb_destroy_args *args)
1012 {
1013         switch (args->event) {
1014         case NB_EV_VALIDATE:
1015         case NB_EV_PREPARE:
1016         case NB_EV_ABORT:
1017                 break;
1018         case NB_EV_APPLY:
1019                 return lib_route_map_entry_match_destroy(args);
1020         }
1021
1022         return NB_OK;
1023 }
1024
1025 /*
1026  * XPath = /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:comm-list
1027  */
1028 void
1029 lib_route_map_entry_match_condition_rmap_match_condition_comm_list_finish(
1030         struct nb_cb_apply_finish_args *args)
1031 {
1032         struct routemap_hook_context *rhc;
1033         const char *value;
1034         bool exact_match = false;
1035         char *argstr;
1036         const char *condition;
1037         route_map_event_t event;
1038
1039         /* Add configuration. */
1040         rhc = nb_running_get_entry(args->dnode, NULL, true);
1041         value = yang_dnode_get_string(args->dnode, "./comm-list-name");
1042
1043         if (yang_dnode_exists(args->dnode, "./comm-list-name-exact-match"))
1044                 exact_match = yang_dnode_get_bool(
1045                         args->dnode, "./comm-list-name-exact-match");
1046
1047         if (exact_match) {
1048                 argstr = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
1049                                  strlen(value) + strlen("exact-match") + 2);
1050
1051                 snprintf(argstr, (strlen(value) + strlen("exact-match") + 2),
1052                          "%s exact-match", value);
1053         } else
1054                 argstr = (char *)value;
1055
1056         /* Set destroy information. */
1057         rhc->rhc_mhook = bgp_route_match_delete;
1058
1059         condition = yang_dnode_get_string(args->dnode,
1060                                           "../../frr-route-map:condition");
1061         if (IS_MATCH_COMMUNITY(condition)) {
1062                 rhc->rhc_rule = "community";
1063                 event = RMAP_EVENT_CLIST_ADDED;
1064                 rhc->rhc_event = RMAP_EVENT_CLIST_DELETED;
1065         } else if (IS_MATCH_LCOMMUNITY(condition)) {
1066                 rhc->rhc_rule = "large-community";
1067                 event = RMAP_EVENT_LLIST_ADDED;
1068                 rhc->rhc_event = RMAP_EVENT_LLIST_DELETED;
1069         } else {
1070                 rhc->rhc_rule = "extcommunity";
1071                 event = RMAP_EVENT_ECLIST_ADDED;
1072                 rhc->rhc_event = RMAP_EVENT_ECLIST_DELETED;
1073         }
1074
1075         bgp_route_match_add(rhc->rhc_rmi, rhc->rhc_rule, argstr, event,
1076                             args->errmsg, args->errmsg_len);
1077
1078         if (argstr != value)
1079                 XFREE(MTYPE_ROUTE_MAP_COMPILED, argstr);
1080 }
1081
1082 /*
1083  * XPath:
1084  * /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name
1085  */
1086 int
1087 lib_route_map_entry_match_condition_rmap_match_condition_comm_list_comm_list_name_modify(
1088         struct nb_cb_modify_args *args)
1089 {
1090         switch (args->event) {
1091         case NB_EV_VALIDATE:
1092         case NB_EV_PREPARE:
1093         case NB_EV_ABORT:
1094         case NB_EV_APPLY:
1095                 break;
1096         }
1097
1098         return NB_OK;
1099 }
1100
1101 int
1102 lib_route_map_entry_match_condition_rmap_match_condition_comm_list_comm_list_name_destroy(
1103         struct nb_cb_destroy_args *args)
1104 {
1105         switch (args->event) {
1106         case NB_EV_VALIDATE:
1107         case NB_EV_PREPARE:
1108         case NB_EV_ABORT:
1109                 break;
1110         case NB_EV_APPLY:
1111                 return lib_route_map_entry_match_destroy(args);
1112         }
1113
1114         return NB_OK;
1115
1116 }
1117
1118 /*
1119  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name-exact-match
1120  */
1121 int
1122 lib_route_map_entry_match_condition_rmap_match_condition_comm_list_comm_list_name_exact_match_modify(
1123         struct nb_cb_modify_args *args)
1124 {
1125         switch (args->event) {
1126         case NB_EV_VALIDATE:
1127         case NB_EV_PREPARE:
1128         case NB_EV_ABORT:
1129         case NB_EV_APPLY:
1130                 break;
1131         }
1132
1133         return NB_OK;
1134 }
1135
1136 int
1137 lib_route_map_entry_match_condition_rmap_match_condition_comm_list_comm_list_name_exact_match_destroy(
1138         struct nb_cb_destroy_args *args)
1139 {
1140         switch (args->event) {
1141         case NB_EV_VALIDATE:
1142         case NB_EV_PREPARE:
1143         case NB_EV_ABORT:
1144                 break;
1145         case NB_EV_APPLY:
1146                 return lib_route_map_entry_match_destroy(args);
1147         }
1148
1149         return NB_OK;
1150 }
1151
1152 /*
1153  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:ipv4-address
1154  */
1155 int
1156 lib_route_map_entry_match_condition_rmap_match_condition_ipv4_address_modify(
1157         struct nb_cb_modify_args *args)
1158 {
1159         struct routemap_hook_context *rhc;
1160         const char *peer;
1161         enum rmap_compile_rets ret;
1162
1163         switch (args->event) {
1164         case NB_EV_VALIDATE:
1165         case NB_EV_PREPARE:
1166         case NB_EV_ABORT:
1167                 break;
1168         case NB_EV_APPLY:
1169                 /* Add configuration. */
1170                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1171                 peer = yang_dnode_get_string(args->dnode, NULL);
1172
1173                 /* Set destroy information. */
1174                 rhc->rhc_mhook = bgp_route_match_delete;
1175                 rhc->rhc_rule = "ip next-hop address";
1176                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1177
1178                 ret = bgp_route_match_add(rhc->rhc_rmi, rhc->rhc_rule,
1179                                           peer, RMAP_EVENT_MATCH_ADDED,
1180                                           args->errmsg, args->errmsg_len);
1181
1182                 if (ret != RMAP_COMPILE_SUCCESS) {
1183                         rhc->rhc_mhook = NULL;
1184                         return NB_ERR_INCONSISTENCY;
1185                 }
1186         }
1187
1188         return NB_OK;
1189 }
1190
1191 int
1192 lib_route_map_entry_match_condition_rmap_match_condition_ipv4_address_destroy(
1193         struct nb_cb_destroy_args *args)
1194 {
1195         switch (args->event) {
1196         case NB_EV_VALIDATE:
1197         case NB_EV_PREPARE:
1198         case NB_EV_ABORT:
1199                 break;
1200         case NB_EV_APPLY:
1201                 return lib_route_map_entry_match_destroy(args);
1202         }
1203
1204         return NB_OK;
1205 }
1206
1207 /*
1208  * XPath: /frr-route-map:lib/route-map/entry/match-condition/rmap-match-condition/frr-bgp-route-map:ipv6-address
1209  */
1210 int
1211 lib_route_map_entry_match_condition_rmap_match_condition_ipv6_address_modify(
1212         struct nb_cb_modify_args *args)
1213 {
1214         struct routemap_hook_context *rhc;
1215         const char *peer;
1216         enum rmap_compile_rets ret;
1217
1218         switch (args->event) {
1219         case NB_EV_VALIDATE:
1220         case NB_EV_PREPARE:
1221         case NB_EV_ABORT:
1222                 break;
1223         case NB_EV_APPLY:
1224                 /* Add configuration. */
1225                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1226                 peer = yang_dnode_get_string(args->dnode, NULL);
1227
1228                 /* Set destroy information. */
1229                 rhc->rhc_mhook = bgp_route_match_delete;
1230                 rhc->rhc_rule = "ipv6 next-hop";
1231                 rhc->rhc_event = RMAP_EVENT_MATCH_DELETED;
1232
1233                 ret = bgp_route_match_add(rhc->rhc_rmi, rhc->rhc_rule,
1234                                           peer, RMAP_EVENT_MATCH_ADDED,
1235                                           args->errmsg, args->errmsg_len);
1236
1237                 if (ret != RMAP_COMPILE_SUCCESS) {
1238                         rhc->rhc_mhook = NULL;
1239                         return NB_ERR_INCONSISTENCY;
1240                 }
1241         }
1242
1243         return NB_OK;
1244 }
1245
1246 int
1247 lib_route_map_entry_match_condition_rmap_match_condition_ipv6_address_destroy(
1248         struct nb_cb_destroy_args *args)
1249 {
1250         switch (args->event) {
1251         case NB_EV_VALIDATE:
1252         case NB_EV_PREPARE:
1253         case NB_EV_ABORT:
1254                 break;
1255         case NB_EV_APPLY:
1256                 return lib_route_map_entry_match_destroy(args);
1257         }
1258
1259         return NB_OK;
1260 }
1261
1262 /*
1263  * XPath:
1264  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:distance
1265  */
1266 int lib_route_map_entry_set_action_rmap_set_action_distance_modify(
1267         struct nb_cb_modify_args *args)
1268 {
1269         struct routemap_hook_context *rhc;
1270         const char *type;
1271         int rv;
1272
1273         switch (args->event) {
1274         case NB_EV_VALIDATE:
1275         case NB_EV_PREPARE:
1276         case NB_EV_ABORT:
1277                 break;
1278         case NB_EV_APPLY:
1279                 /* Add configuration. */
1280                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1281                 type = yang_dnode_get_string(args->dnode, NULL);
1282
1283                 /* Set destroy information. */
1284                 rhc->rhc_shook = generic_set_delete;
1285                 rhc->rhc_rule = "distance";
1286                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1287
1288                 rv = generic_set_add(rhc->rhc_rmi, "distance", type,
1289                                      args->errmsg, args->errmsg_len);
1290                 if (rv != CMD_SUCCESS) {
1291                         rhc->rhc_shook = NULL;
1292                         return NB_ERR_INCONSISTENCY;
1293                 }
1294         }
1295
1296         return NB_OK;
1297 }
1298
1299 int lib_route_map_entry_set_action_rmap_set_action_distance_destroy(
1300         struct nb_cb_destroy_args *args)
1301 {
1302         switch (args->event) {
1303         case NB_EV_VALIDATE:
1304         case NB_EV_PREPARE:
1305         case NB_EV_ABORT:
1306                 break;
1307         case NB_EV_APPLY:
1308                 return lib_route_map_entry_match_destroy(args);
1309         }
1310
1311         return NB_OK;
1312 }
1313
1314 /*
1315  * XPath:
1316  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:extcommunity-rt
1317  */
1318 int
1319 lib_route_map_entry_set_action_rmap_set_action_extcommunity_rt_modify(
1320         struct nb_cb_modify_args *args)
1321 {
1322         struct routemap_hook_context *rhc;
1323         const char *type;
1324         int rv;
1325
1326         switch (args->event) {
1327         case NB_EV_VALIDATE:
1328         case NB_EV_PREPARE:
1329         case NB_EV_ABORT:
1330                 break;
1331         case NB_EV_APPLY:
1332                 /* Add configuration. */
1333                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1334                 type = yang_dnode_get_string(args->dnode, NULL);
1335
1336                 /* Set destroy information. */
1337                 rhc->rhc_shook = generic_set_delete;
1338                 rhc->rhc_rule = "extcommunity rt";
1339                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1340
1341                 rv = generic_set_add(rhc->rhc_rmi, "extcommunity rt", type,
1342                                      args->errmsg, args->errmsg_len);
1343                 if (rv != CMD_SUCCESS) {
1344                         rhc->rhc_shook = NULL;
1345                         return NB_ERR_INCONSISTENCY;
1346                 }
1347         }
1348
1349         return NB_OK;
1350 }
1351
1352 int
1353 lib_route_map_entry_set_action_rmap_set_action_extcommunity_rt_destroy(
1354         struct nb_cb_destroy_args *args)
1355 {
1356         switch (args->event) {
1357         case NB_EV_VALIDATE:
1358         case NB_EV_PREPARE:
1359         case NB_EV_ABORT:
1360                 break;
1361         case NB_EV_APPLY:
1362                 return lib_route_map_entry_match_destroy(args);
1363         }
1364
1365         return NB_OK;
1366 }
1367
1368 /*
1369  * XPath:
1370  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:extcommunity-soo
1371  */
1372 int
1373 lib_route_map_entry_set_action_rmap_set_action_extcommunity_soo_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         case NB_EV_PREPARE:
1383         case NB_EV_ABORT:
1384                 break;
1385         case NB_EV_APPLY:
1386                 /* Add configuration. */
1387                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1388                 type = yang_dnode_get_string(args->dnode, NULL);
1389
1390                 /* Set destroy information. */
1391                 rhc->rhc_shook = generic_set_delete;
1392                 rhc->rhc_rule = "extcommunity soo";
1393                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1394
1395                 rv = generic_set_add(rhc->rhc_rmi, "extcommunity soo",
1396                                      type,
1397                                      args->errmsg, args->errmsg_len);
1398                 if (rv != CMD_SUCCESS) {
1399                         rhc->rhc_shook = NULL;
1400                         return NB_ERR_INCONSISTENCY;
1401                 }
1402         }
1403
1404         return NB_OK;
1405 }
1406
1407 int
1408 lib_route_map_entry_set_action_rmap_set_action_extcommunity_soo_destroy(
1409         struct nb_cb_destroy_args *args)
1410 {
1411         switch (args->event) {
1412         case NB_EV_VALIDATE:
1413         case NB_EV_PREPARE:
1414         case NB_EV_ABORT:
1415                 break;
1416         case NB_EV_APPLY:
1417                 return lib_route_map_entry_match_destroy(args);
1418         }
1419
1420         return NB_OK;
1421 }
1422
1423 /*
1424  * XPath:
1425  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:ipv4-address
1426  */
1427 int lib_route_map_entry_set_action_rmap_set_action_ipv4_address_modify(
1428         struct nb_cb_modify_args *args)
1429 {
1430         struct routemap_hook_context *rhc;
1431         const char *addr;
1432         int rv = CMD_SUCCESS;
1433
1434         switch (args->event) {
1435         case NB_EV_VALIDATE:
1436         case NB_EV_PREPARE:
1437         case NB_EV_ABORT:
1438                 break;
1439         case NB_EV_APPLY:
1440                 /* Add configuration. */
1441                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1442                 addr = yang_dnode_get_string(args->dnode, NULL);
1443
1444                 rhc->rhc_shook = generic_set_delete;
1445                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1446                 rhc->rhc_rule = "ipv4 vpn next-hop";
1447
1448                 rv = generic_set_add(rhc->rhc_rmi, rhc->rhc_rule, addr,
1449                                      args->errmsg, args->errmsg_len);
1450
1451                 if (rv != CMD_SUCCESS) {
1452                         rhc->rhc_shook = NULL;
1453                         return NB_ERR_INCONSISTENCY;
1454                 }
1455         }
1456
1457         return NB_OK;
1458 }
1459
1460 int lib_route_map_entry_set_action_rmap_set_action_ipv4_address_destroy(
1461         struct nb_cb_destroy_args *args)
1462 {
1463         switch (args->event) {
1464         case NB_EV_VALIDATE:
1465         case NB_EV_PREPARE:
1466         case NB_EV_ABORT:
1467                 break;
1468         case NB_EV_APPLY:
1469                 return lib_route_map_entry_set_destroy(args);
1470         }
1471
1472         return NB_OK;
1473 }
1474
1475 /*
1476  * XPath:
1477  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:ipv4-nexthop
1478  */
1479 int lib_route_map_entry_set_action_rmap_set_action_ipv4_nexthop_modify(
1480         struct nb_cb_modify_args *args)
1481 {
1482         struct routemap_hook_context *rhc;
1483         const char *type;
1484         int rv;
1485
1486         switch (args->event) {
1487         case NB_EV_VALIDATE:
1488         case NB_EV_PREPARE:
1489         case NB_EV_ABORT:
1490                 break;
1491         case NB_EV_APPLY:
1492                 /* Add configuration. */
1493                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1494                 type = yang_dnode_get_string(args->dnode, NULL);
1495
1496                 /* Set destroy information. */
1497                 rhc->rhc_shook = generic_set_delete;
1498                 rhc->rhc_rule = "ip next-hop";
1499                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1500
1501                 rv = generic_set_add(rhc->rhc_rmi, rhc->rhc_rule, type,
1502                                     args->errmsg, args->errmsg_len);
1503
1504                 if (rv != CMD_SUCCESS) {
1505                         rhc->rhc_shook = NULL;
1506                         return NB_ERR_INCONSISTENCY;
1507                 }
1508         }
1509
1510         return NB_OK;
1511 }
1512
1513 int lib_route_map_entry_set_action_rmap_set_action_ipv4_nexthop_destroy(
1514         struct nb_cb_destroy_args *args)
1515 {
1516         switch (args->event) {
1517         case NB_EV_VALIDATE:
1518         case NB_EV_PREPARE:
1519         case NB_EV_ABORT:
1520                 break;
1521         case NB_EV_APPLY:
1522                 return lib_route_map_entry_set_destroy(args);
1523         }
1524
1525         return NB_OK;
1526 }
1527
1528 /*
1529  * XPath:
1530  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:ipv6-address
1531  */
1532 int lib_route_map_entry_set_action_rmap_set_action_ipv6_address_modify(
1533         struct nb_cb_modify_args *args)
1534 {
1535         struct routemap_hook_context *rhc;
1536         const char *addr;
1537         int rv = CMD_SUCCESS;
1538         const char *action = NULL;
1539         struct in6_addr i6a;
1540
1541         action = yang_dnode_get_string(args->dnode,
1542                                        "../../frr-route-map:action");
1543         switch (args->event) {
1544         case NB_EV_VALIDATE:
1545                 if (action && IS_SET_IPV6_NH_GLOBAL(action)) {
1546                         yang_dnode_get_ipv6(&i6a, args->dnode, NULL);
1547                         if (IN6_IS_ADDR_UNSPECIFIED(&i6a)
1548                             || IN6_IS_ADDR_LOOPBACK(&i6a)
1549                             || IN6_IS_ADDR_MULTICAST(&i6a)
1550                             || IN6_IS_ADDR_LINKLOCAL(&i6a))
1551                                 return NB_ERR_VALIDATION;
1552                 }
1553         /* FALLTHROUGH */
1554         case NB_EV_PREPARE:
1555         case NB_EV_ABORT:
1556                 return NB_OK;
1557         case NB_EV_APPLY:
1558                 break;
1559         }
1560
1561         /* Add configuration. */
1562         rhc = nb_running_get_entry(args->dnode, NULL, true);
1563         addr = yang_dnode_get_string(args->dnode, NULL);
1564
1565         rhc->rhc_shook = generic_set_delete;
1566         rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1567
1568         if (IS_SET_IPV6_NH_GLOBAL(action))
1569                 /* Set destroy information. */
1570                 rhc->rhc_rule = "ipv6 next-hop global";
1571         else
1572                 rhc->rhc_rule = "ipv6 vpn next-hop";
1573
1574         rv = generic_set_add(rhc->rhc_rmi, rhc->rhc_rule, addr,
1575                              args->errmsg, args->errmsg_len);
1576
1577         if (rv != CMD_SUCCESS) {
1578                 rhc->rhc_shook = NULL;
1579                 return NB_ERR_INCONSISTENCY;
1580         }
1581
1582         return NB_OK;
1583 }
1584
1585 int lib_route_map_entry_set_action_rmap_set_action_ipv6_address_destroy(
1586         struct nb_cb_destroy_args *args)
1587 {
1588         switch (args->event) {
1589         case NB_EV_VALIDATE:
1590         case NB_EV_PREPARE:
1591         case NB_EV_ABORT:
1592                 break;
1593         case NB_EV_APPLY:
1594                 return lib_route_map_entry_set_destroy(args);
1595         }
1596
1597         return NB_OK;
1598 }
1599
1600 /*
1601  * XPath:
1602  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:preference
1603  */
1604 int lib_route_map_entry_set_action_rmap_set_action_preference_modify(
1605         struct nb_cb_modify_args *args)
1606 {
1607         struct routemap_hook_context *rhc;
1608         int rv = CMD_SUCCESS;
1609         const char *action = NULL;
1610         bool value;
1611
1612         switch (args->event) {
1613         case NB_EV_VALIDATE:
1614         case NB_EV_PREPARE:
1615         case NB_EV_ABORT:
1616                 break;
1617         case NB_EV_APPLY:
1618                 /* Add configuration. */
1619                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1620                 value = yang_dnode_get_bool(args->dnode, NULL);
1621
1622                 rhc->rhc_shook = generic_set_delete;
1623                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1624
1625                 action = yang_dnode_get_string(args->dnode,
1626                                 "../../frr-route-map:action");
1627
1628                 if (value) {
1629                         if (IS_SET_IPV6_PEER_ADDR(action))
1630                                 /* Set destroy information. */
1631                                 rhc->rhc_rule = "ipv6 next-hop peer-address";
1632                         else
1633                                 rhc->rhc_rule = "ipv6 next-hop prefer-global";
1634
1635                         rv = generic_set_add(rhc->rhc_rmi, rhc->rhc_rule,
1636                                              NULL,
1637                                              args->errmsg, args->errmsg_len);
1638                 }
1639
1640                 if (rv != CMD_SUCCESS) {
1641                         rhc->rhc_shook = NULL;
1642                         return NB_ERR_INCONSISTENCY;
1643                 }
1644         }
1645
1646         return NB_OK;
1647 }
1648
1649 int lib_route_map_entry_set_action_rmap_set_action_preference_destroy(
1650         struct nb_cb_destroy_args *args)
1651 {
1652         switch (args->event) {
1653         case NB_EV_VALIDATE:
1654         case NB_EV_PREPARE:
1655         case NB_EV_ABORT:
1656                 break;
1657         case NB_EV_APPLY:
1658                 return lib_route_map_entry_set_destroy(args);
1659         }
1660
1661         return NB_OK;
1662 }
1663
1664 /*
1665  * XPath:
1666  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:label-index
1667  */
1668 int lib_route_map_entry_set_action_rmap_set_action_label_index_modify(
1669         struct nb_cb_modify_args *args)
1670 {
1671         struct routemap_hook_context *rhc;
1672         const char *type;
1673         int rv;
1674
1675         switch (args->event) {
1676         case NB_EV_VALIDATE:
1677         case NB_EV_PREPARE:
1678         case NB_EV_ABORT:
1679                 break;
1680         case NB_EV_APPLY:
1681                 /* Add configuration. */
1682                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1683                 type = yang_dnode_get_string(args->dnode, NULL);
1684
1685                 /* Set destroy information. */
1686                 rhc->rhc_shook = generic_set_delete;
1687                 rhc->rhc_rule = "label-index";
1688                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1689
1690                 rv = generic_set_add(rhc->rhc_rmi, "label-index", type,
1691                                      args->errmsg, args->errmsg_len);
1692                 if (rv != CMD_SUCCESS) {
1693                         rhc->rhc_shook = NULL;
1694                         return NB_ERR_INCONSISTENCY;
1695                 }
1696         }
1697
1698         return NB_OK;
1699 }
1700
1701 int lib_route_map_entry_set_action_rmap_set_action_label_index_destroy(
1702         struct nb_cb_destroy_args *args)
1703 {
1704         switch (args->event) {
1705         case NB_EV_VALIDATE:
1706         case NB_EV_PREPARE:
1707         case NB_EV_ABORT:
1708                 break;
1709         case NB_EV_APPLY:
1710                 return lib_route_map_entry_set_destroy(args);
1711         }
1712
1713         return NB_OK;
1714 }
1715
1716 /*
1717  * XPath:
1718  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:local-pref
1719  */
1720 int lib_route_map_entry_set_action_rmap_set_action_local_pref_modify(
1721         struct nb_cb_modify_args *args)
1722 {
1723         struct routemap_hook_context *rhc;
1724         const char *type;
1725         int rv;
1726
1727         switch (args->event) {
1728         case NB_EV_VALIDATE:
1729         case NB_EV_PREPARE:
1730         case NB_EV_ABORT:
1731                 break;
1732         case NB_EV_APPLY:
1733                 /* Add configuration. */
1734                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1735                 type = yang_dnode_get_string(args->dnode, NULL);
1736
1737                 /* Set destroy information. */
1738                 rhc->rhc_shook = generic_set_delete;
1739                 rhc->rhc_rule = "local-preference";
1740                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1741
1742                 rv = generic_set_add(rhc->rhc_rmi, "local-preference",
1743                                      type,
1744                                      args->errmsg, args->errmsg_len);
1745                 if (rv != CMD_SUCCESS) {
1746                         rhc->rhc_shook = NULL;
1747                         return NB_ERR_INCONSISTENCY;
1748                 }
1749         }
1750
1751         return NB_OK;
1752 }
1753
1754 int lib_route_map_entry_set_action_rmap_set_action_local_pref_destroy(
1755         struct nb_cb_destroy_args *args)
1756 {
1757         switch (args->event) {
1758         case NB_EV_VALIDATE:
1759         case NB_EV_PREPARE:
1760         case NB_EV_ABORT:
1761                 break;
1762         case NB_EV_APPLY:
1763                 return lib_route_map_entry_set_destroy(args);
1764         }
1765
1766         return NB_OK;
1767 }
1768
1769 /*
1770  * XPath:
1771  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:weight
1772  */
1773 int lib_route_map_entry_set_action_rmap_set_action_weight_modify(
1774         struct nb_cb_modify_args *args)
1775 {
1776         struct routemap_hook_context *rhc;
1777         const char *type;
1778         int rv;
1779
1780         switch (args->event) {
1781         case NB_EV_VALIDATE:
1782         case NB_EV_PREPARE:
1783         case NB_EV_ABORT:
1784                 break;
1785         case NB_EV_APPLY:
1786                 /* Add configuration. */
1787                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1788                 type = yang_dnode_get_string(args->dnode, NULL);
1789
1790                 /* Set destroy information. */
1791                 rhc->rhc_shook = generic_set_delete;
1792                 rhc->rhc_rule = "weight";
1793                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1794
1795                 rv = generic_set_add(rhc->rhc_rmi, "weight", type,
1796                                      args->errmsg, args->errmsg_len);
1797                 if (rv != CMD_SUCCESS) {
1798                         rhc->rhc_shook = NULL;
1799                         return NB_ERR_INCONSISTENCY;
1800                 }
1801         }
1802
1803         return NB_OK;
1804 }
1805
1806 int lib_route_map_entry_set_action_rmap_set_action_weight_destroy(
1807         struct nb_cb_destroy_args *args)
1808 {
1809         switch (args->event) {
1810         case NB_EV_VALIDATE:
1811         case NB_EV_PREPARE:
1812         case NB_EV_ABORT:
1813                 break;
1814         case NB_EV_APPLY:
1815                 return lib_route_map_entry_set_destroy(args);
1816         }
1817
1818         return NB_OK;
1819 }
1820
1821 /*
1822  * XPath:
1823  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:origin
1824  */
1825 int lib_route_map_entry_set_action_rmap_set_action_origin_modify(
1826         struct nb_cb_modify_args *args)
1827 {
1828         struct routemap_hook_context *rhc;
1829         const char *type;
1830         int rv;
1831
1832         switch (args->event) {
1833         case NB_EV_VALIDATE:
1834         case NB_EV_PREPARE:
1835         case NB_EV_ABORT:
1836                 break;
1837         case NB_EV_APPLY:
1838                 /* Add configuration. */
1839                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1840                 type = yang_dnode_get_string(args->dnode, NULL);
1841
1842                 /* Set destroy information. */
1843                 rhc->rhc_shook = generic_set_delete;
1844                 rhc->rhc_rule = "origin";
1845                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1846
1847                 rv = generic_set_add(rhc->rhc_rmi, "origin", type,
1848                                      args->errmsg, args->errmsg_len);
1849                 if (rv != CMD_SUCCESS) {
1850                         rhc->rhc_shook = NULL;
1851                         return NB_ERR_INCONSISTENCY;
1852                 }
1853         }
1854
1855         return NB_OK;
1856 }
1857
1858 int lib_route_map_entry_set_action_rmap_set_action_origin_destroy(
1859         struct nb_cb_destroy_args *args)
1860 {
1861         switch (args->event) {
1862         case NB_EV_VALIDATE:
1863         case NB_EV_PREPARE:
1864         case NB_EV_ABORT:
1865                 break;
1866         case NB_EV_APPLY:
1867                 return lib_route_map_entry_set_destroy(args);
1868
1869         }
1870
1871         return NB_OK;
1872 }
1873
1874 /*
1875  * XPath:
1876  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:originator-id
1877  */
1878 int lib_route_map_entry_set_action_rmap_set_action_originator_id_modify(
1879         struct nb_cb_modify_args *args)
1880 {
1881         struct routemap_hook_context *rhc;
1882         const char *type;
1883         int rv;
1884
1885         switch (args->event) {
1886         case NB_EV_VALIDATE:
1887         case NB_EV_PREPARE:
1888         case NB_EV_ABORT:
1889                 break;
1890         case NB_EV_APPLY:
1891                 /* Add configuration. */
1892                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1893                 type = yang_dnode_get_string(args->dnode, NULL);
1894
1895                 /* Set destroy information. */
1896                 rhc->rhc_shook = generic_set_delete;
1897                 rhc->rhc_rule = "originator-id";
1898                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1899
1900                 rv = generic_set_add(rhc->rhc_rmi, "originator-id", type,
1901                                      args->errmsg, args->errmsg_len);
1902                 if (rv != CMD_SUCCESS) {
1903                         rhc->rhc_shook = NULL;
1904                         return NB_ERR_INCONSISTENCY;
1905                 }
1906         }
1907
1908         return NB_OK;
1909 }
1910
1911 int lib_route_map_entry_set_action_rmap_set_action_originator_id_destroy(
1912         struct nb_cb_destroy_args *args)
1913 {
1914         switch (args->event) {
1915         case NB_EV_VALIDATE:
1916         case NB_EV_PREPARE:
1917         case NB_EV_ABORT:
1918                 break;
1919         case NB_EV_APPLY:
1920                 return lib_route_map_entry_set_destroy(args);
1921         }
1922
1923         return NB_OK;
1924 }
1925
1926 /*
1927  * XPath:
1928  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:table
1929  */
1930 int lib_route_map_entry_set_action_rmap_set_action_table_modify(
1931         struct nb_cb_modify_args *args)
1932 {
1933         struct routemap_hook_context *rhc;
1934         const char *type;
1935         int rv;
1936
1937         switch (args->event) {
1938         case NB_EV_VALIDATE:
1939         case NB_EV_PREPARE:
1940         case NB_EV_ABORT:
1941                 break;
1942         case NB_EV_APPLY:
1943                 /* Add configuration. */
1944                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1945                 type = yang_dnode_get_string(args->dnode, NULL);
1946
1947                 /* Set destroy information. */
1948                 rhc->rhc_shook = generic_set_delete;
1949                 rhc->rhc_rule = "table";
1950                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
1951
1952                 rv = generic_set_add(rhc->rhc_rmi, "table", type,
1953                                      args->errmsg, args->errmsg_len);
1954                 if (rv != CMD_SUCCESS) {
1955                         rhc->rhc_shook = NULL;
1956                         return NB_ERR_INCONSISTENCY;
1957                 }
1958         }
1959
1960         return NB_OK;
1961 }
1962
1963 int lib_route_map_entry_set_action_rmap_set_action_table_destroy(
1964         struct nb_cb_destroy_args *args)
1965 {
1966         switch (args->event) {
1967         case NB_EV_VALIDATE:
1968         case NB_EV_PREPARE:
1969         case NB_EV_ABORT:
1970                 break;
1971         case NB_EV_APPLY:
1972                 return lib_route_map_entry_set_destroy(args);
1973         }
1974
1975         return NB_OK;
1976 }
1977
1978 /*
1979  * XPath:
1980  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:atomic-aggregate
1981  */
1982 int
1983 lib_route_map_entry_set_action_rmap_set_action_atomic_aggregate_create(
1984         struct nb_cb_create_args *args)
1985 {
1986         struct routemap_hook_context *rhc;
1987         int rv;
1988
1989         switch (args->event) {
1990         case NB_EV_VALIDATE:
1991         case NB_EV_PREPARE:
1992         case NB_EV_ABORT:
1993                 break;
1994         case NB_EV_APPLY:
1995                 /* Add configuration. */
1996                 rhc = nb_running_get_entry(args->dnode, NULL, true);
1997
1998                 /* Set destroy information. */
1999                 rhc->rhc_shook = generic_set_delete;
2000                 rhc->rhc_rule = "atomic-aggregate";
2001                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2002
2003                 rv = generic_set_add(rhc->rhc_rmi, rhc->rhc_rule, NULL,
2004                                      args->errmsg, args->errmsg_len);
2005                 if (rv != CMD_SUCCESS) {
2006                         rhc->rhc_shook = NULL;
2007                         return NB_ERR_INCONSISTENCY;
2008                 }
2009         }
2010
2011         return NB_OK;
2012 }
2013
2014 int
2015 lib_route_map_entry_set_action_rmap_set_action_atomic_aggregate_destroy(
2016         struct nb_cb_destroy_args *args)
2017 {
2018         switch (args->event) {
2019         case NB_EV_VALIDATE:
2020         case NB_EV_PREPARE:
2021         case NB_EV_ABORT:
2022                 break;
2023         case NB_EV_APPLY:
2024                 return lib_route_map_entry_set_destroy(args);
2025         }
2026
2027         return NB_OK;
2028 }
2029
2030 /*
2031  * XPath:
2032  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:prepend-as-path
2033  */
2034 int
2035 lib_route_map_entry_set_action_rmap_set_action_prepend_as_path_modify(
2036         struct nb_cb_modify_args *args)
2037 {
2038         struct routemap_hook_context *rhc;
2039         const char *type;
2040         int rv;
2041
2042         switch (args->event) {
2043         case NB_EV_VALIDATE:
2044         case NB_EV_PREPARE:
2045         case NB_EV_ABORT:
2046                 break;
2047         case NB_EV_APPLY:
2048                 /* Add configuration. */
2049                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2050                 type = yang_dnode_get_string(args->dnode, NULL);
2051
2052                 /* Set destroy information. */
2053                 rhc->rhc_shook = generic_set_delete;
2054                 rhc->rhc_rule = "as-path prepend";
2055                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2056
2057                 rv = generic_set_add(rhc->rhc_rmi, "as-path prepend",
2058                                      type,
2059                                      args->errmsg, args->errmsg_len);
2060                 if (rv != CMD_SUCCESS) {
2061                         rhc->rhc_shook = NULL;
2062                         return NB_ERR_INCONSISTENCY;
2063                 }
2064         }
2065
2066         return NB_OK;
2067 }
2068
2069 int
2070 lib_route_map_entry_set_action_rmap_set_action_prepend_as_path_destroy(
2071         struct nb_cb_destroy_args *args)
2072 {
2073         switch (args->event) {
2074         case NB_EV_VALIDATE:
2075         case NB_EV_PREPARE:
2076         case NB_EV_ABORT:
2077                 break;
2078         case NB_EV_APPLY:
2079                 return lib_route_map_entry_set_destroy(args);
2080         }
2081
2082         return NB_OK;
2083 }
2084
2085 /*
2086  * XPath:
2087  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:last-as
2088  */
2089 int lib_route_map_entry_set_action_rmap_set_action_last_as_modify(
2090         struct nb_cb_modify_args *args)
2091 {
2092         struct routemap_hook_context *rhc;
2093         const char *value;
2094         char *argstr;
2095         int rv;
2096
2097         switch (args->event) {
2098         case NB_EV_VALIDATE:
2099         case NB_EV_PREPARE:
2100         case NB_EV_ABORT:
2101                 break;
2102         case NB_EV_APPLY:
2103                 /* Add configuration. */
2104                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2105                 value = yang_dnode_get_string(args->dnode, NULL);
2106
2107                 /* Set destroy information. */
2108                 rhc->rhc_shook = generic_set_delete;
2109                 rhc->rhc_rule = "as-path prepend";
2110                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2111
2112                 argstr = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
2113                                 strlen(value) + strlen("last-as") + 2);
2114
2115                 snprintf(argstr, (strlen(value) + strlen("last-as") + 2),
2116                          "last-as %s", value);
2117
2118                 rv = generic_set_add(rhc->rhc_rmi, "as-path prepend",
2119                                      argstr,
2120                                      args->errmsg, args->errmsg_len);
2121                 if (rv != CMD_SUCCESS) {
2122                         rhc->rhc_shook = NULL;
2123                         XFREE(MTYPE_ROUTE_MAP_COMPILED, argstr);
2124                         return NB_ERR_INCONSISTENCY;
2125                 }
2126
2127                 XFREE(MTYPE_ROUTE_MAP_COMPILED, argstr);
2128         }
2129
2130         return NB_OK;
2131 }
2132
2133 int lib_route_map_entry_set_action_rmap_set_action_last_as_destroy(
2134         struct nb_cb_destroy_args *args)
2135 {
2136         switch (args->event) {
2137         case NB_EV_VALIDATE:
2138         case NB_EV_PREPARE:
2139         case NB_EV_ABORT:
2140                 break;
2141         case NB_EV_APPLY:
2142                 return lib_route_map_entry_set_destroy(args);
2143         }
2144
2145         return NB_OK;
2146 }
2147
2148 /*
2149  * XPath:
2150  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:exclude-as-path
2151  */
2152 int
2153 lib_route_map_entry_set_action_rmap_set_action_exclude_as_path_modify(
2154         struct nb_cb_modify_args *args)
2155 {
2156         struct routemap_hook_context *rhc;
2157         const char *type;
2158         int rv;
2159
2160         switch (args->event) {
2161         case NB_EV_VALIDATE:
2162         case NB_EV_PREPARE:
2163         case NB_EV_ABORT:
2164                 break;
2165         case NB_EV_APPLY:
2166                 /* Add configuration. */
2167                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2168                 type = yang_dnode_get_string(args->dnode, NULL);
2169
2170                 /* Set destroy information. */
2171                 rhc->rhc_shook = generic_set_delete;
2172                 rhc->rhc_rule = "as-path exclude";
2173                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2174
2175                 rv = generic_set_add(rhc->rhc_rmi, "as-path exclude",
2176                                      type,
2177                                      args->errmsg, args->errmsg_len);
2178                 if (rv != CMD_SUCCESS) {
2179                         rhc->rhc_shook = NULL;
2180                         return NB_ERR_INCONSISTENCY;
2181                 }
2182         }
2183
2184         return NB_OK;
2185 }
2186
2187 int
2188 lib_route_map_entry_set_action_rmap_set_action_exclude_as_path_destroy(
2189         struct nb_cb_destroy_args *args)
2190 {
2191         switch (args->event) {
2192         case NB_EV_VALIDATE:
2193         case NB_EV_PREPARE:
2194         case NB_EV_ABORT:
2195                 break;
2196         case NB_EV_APPLY:
2197                 return lib_route_map_entry_set_destroy(args);
2198         }
2199
2200         return NB_OK;
2201 }
2202
2203 /*
2204  * XPath:
2205  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:community-none
2206  */
2207 int lib_route_map_entry_set_action_rmap_set_action_community_none_modify(
2208         struct nb_cb_modify_args *args)
2209 {
2210         struct routemap_hook_context *rhc;
2211         bool none = false;
2212         int rv;
2213
2214         switch (args->event) {
2215         case NB_EV_VALIDATE:
2216         case NB_EV_PREPARE:
2217         case NB_EV_ABORT:
2218                 break;
2219         case NB_EV_APPLY:
2220                 /* Add configuration. */
2221                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2222                 none = yang_dnode_get_bool(args->dnode, NULL);
2223
2224                 /* Set destroy information. */
2225                 rhc->rhc_shook = generic_set_delete;
2226                 rhc->rhc_rule = "community";
2227                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2228
2229                 if (none) {
2230                         rv = generic_set_add(rhc->rhc_rmi, "community",
2231                                              "none",
2232                                              args->errmsg, args->errmsg_len);
2233                         if (rv != CMD_SUCCESS) {
2234                                 rhc->rhc_shook = NULL;
2235                                 return NB_ERR_INCONSISTENCY;
2236                         }
2237                         return NB_OK;
2238                 }
2239
2240                 return NB_ERR_INCONSISTENCY;
2241         }
2242
2243         return NB_OK;
2244 }
2245
2246 int
2247 lib_route_map_entry_set_action_rmap_set_action_community_none_destroy(
2248         struct nb_cb_destroy_args *args)
2249 {
2250         switch (args->event) {
2251         case NB_EV_VALIDATE:
2252         case NB_EV_PREPARE:
2253         case NB_EV_ABORT:
2254                 break;
2255         case NB_EV_APPLY:
2256                 return lib_route_map_entry_set_destroy(args);
2257         }
2258
2259         return NB_OK;
2260 }
2261
2262 /*
2263  * XPath:
2264  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:community-string
2265  */
2266 int
2267 lib_route_map_entry_set_action_rmap_set_action_community_string_modify(
2268         struct nb_cb_modify_args *args)
2269 {
2270         struct routemap_hook_context *rhc;
2271         const char *type;
2272         int rv;
2273
2274         switch (args->event) {
2275         case NB_EV_VALIDATE:
2276         case NB_EV_PREPARE:
2277         case NB_EV_ABORT:
2278                 break;
2279         case NB_EV_APPLY:
2280                 /* Add configuration. */
2281                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2282                 type = yang_dnode_get_string(args->dnode, NULL);
2283
2284                 /* Set destroy information. */
2285                 rhc->rhc_shook = generic_set_delete;
2286                 rhc->rhc_rule = "community";
2287                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2288
2289                 rv = generic_set_add(rhc->rhc_rmi, "community", type,
2290                                      args->errmsg, args->errmsg_len);
2291                 if (rv != CMD_SUCCESS) {
2292                         rhc->rhc_shook = NULL;
2293                         return NB_ERR_INCONSISTENCY;
2294                 }
2295         }
2296
2297         return NB_OK;
2298 }
2299
2300 int
2301 lib_route_map_entry_set_action_rmap_set_action_community_string_destroy(
2302         struct nb_cb_destroy_args *args)
2303 {
2304         switch (args->event) {
2305         case NB_EV_VALIDATE:
2306         case NB_EV_PREPARE:
2307         case NB_EV_ABORT:
2308                 break;
2309         case NB_EV_APPLY:
2310                 return lib_route_map_entry_set_destroy(args);
2311         }
2312
2313         return NB_OK;
2314 }
2315
2316 /*
2317  * XPath:
2318  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:large-community-none
2319  */
2320 int
2321 lib_route_map_entry_set_action_rmap_set_action_large_community_none_modify(
2322         struct nb_cb_modify_args *args)
2323 {
2324         struct routemap_hook_context *rhc;
2325         bool none = false;
2326         int rv;
2327
2328         switch (args->event) {
2329         case NB_EV_VALIDATE:
2330         case NB_EV_PREPARE:
2331         case NB_EV_ABORT:
2332                 break;
2333         case NB_EV_APPLY:
2334                 /* Add configuration. */
2335                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2336                 none = yang_dnode_get_bool(args->dnode, NULL);
2337
2338                 /* Set destroy information. */
2339                 rhc->rhc_shook = generic_set_delete;
2340                 rhc->rhc_rule = "large-community";
2341                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2342
2343                 if (none) {
2344                         rv = generic_set_add(rhc->rhc_rmi,
2345                                              "large-community",
2346                                              "none",
2347                                               args->errmsg, args->errmsg_len);
2348                         if (rv != CMD_SUCCESS) {
2349                                 rhc->rhc_shook = NULL;
2350                                 return NB_ERR_INCONSISTENCY;
2351                         }
2352                 return NB_OK;
2353                 }
2354
2355                 return NB_ERR_INCONSISTENCY;
2356         }
2357
2358         return NB_OK;
2359 }
2360
2361 int
2362 lib_route_map_entry_set_action_rmap_set_action_large_community_none_destroy(
2363         struct nb_cb_destroy_args *args)
2364 {
2365         switch (args->event) {
2366         case NB_EV_VALIDATE:
2367         case NB_EV_PREPARE:
2368         case NB_EV_ABORT:
2369                 break;
2370         case NB_EV_APPLY:
2371                 return lib_route_map_entry_set_destroy(args);
2372         }
2373
2374         return NB_OK;
2375 }
2376
2377 /*
2378  * XPath:
2379  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:large-community-string
2380  */
2381 int
2382 lib_route_map_entry_set_action_rmap_set_action_large_community_string_modify(
2383         struct nb_cb_modify_args *args)
2384 {
2385         struct routemap_hook_context *rhc;
2386         const char *type;
2387         int rv;
2388
2389         switch (args->event) {
2390         case NB_EV_VALIDATE:
2391         case NB_EV_PREPARE:
2392         case NB_EV_ABORT:
2393                 break;
2394         case NB_EV_APPLY:
2395                 /* Add configuration. */
2396                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2397                 type = yang_dnode_get_string(args->dnode, NULL);
2398
2399                 /* Set destroy information. */
2400                 rhc->rhc_shook = generic_set_delete;
2401                 rhc->rhc_rule = "large-community";
2402                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2403
2404                 rv = generic_set_add(rhc->rhc_rmi, "large-community",
2405                                      type,
2406                                      args->errmsg, args->errmsg_len);
2407                 if (rv != CMD_SUCCESS) {
2408                         rhc->rhc_shook = NULL;
2409                         return NB_ERR_INCONSISTENCY;
2410                 }
2411         }
2412
2413         return NB_OK;
2414 }
2415
2416 int
2417 lib_route_map_entry_set_action_rmap_set_action_large_community_string_destroy(
2418         struct nb_cb_destroy_args *args)
2419 {
2420         switch (args->event) {
2421         case NB_EV_VALIDATE:
2422         case NB_EV_PREPARE:
2423         case NB_EV_ABORT:
2424                 break;
2425         case NB_EV_APPLY:
2426                 return lib_route_map_entry_set_destroy(args);
2427         }
2428
2429         return NB_OK;
2430 }
2431
2432 /*
2433  * xpath =
2434  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:aggregator
2435  */
2436 void lib_route_map_entry_set_action_rmap_set_action_aggregator_finish(
2437         struct nb_cb_apply_finish_args *args)
2438 {
2439         struct routemap_hook_context *rhc;
2440         const char *asn;
2441         const char *addr;
2442         char *argstr;
2443
2444         /* Add configuration. */
2445         rhc = nb_running_get_entry(args->dnode, NULL, true);
2446         asn = yang_dnode_get_string(args->dnode, "./aggregator-asn");
2447         addr = yang_dnode_get_string(args->dnode, "./aggregator-address");
2448
2449         argstr = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
2450                          strlen(asn) + strlen(addr) + 2);
2451
2452         snprintf(argstr, (strlen(asn) + strlen(addr) + 2), "%s %s", asn, addr);
2453
2454         /* Set destroy information. */
2455         rhc->rhc_shook = generic_set_delete;
2456         rhc->rhc_rule = "aggregator as";
2457         rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2458
2459         generic_set_add(rhc->rhc_rmi, rhc->rhc_rule, argstr,
2460                         args->errmsg, args->errmsg_len);
2461         XFREE(MTYPE_ROUTE_MAP_COMPILED, argstr);
2462 }
2463 /*
2464  * XPath:
2465  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:aggregator/aggregator-asn
2466  */
2467 int
2468 lib_route_map_entry_set_action_rmap_set_action_aggregator_aggregator_asn_modify(
2469         struct nb_cb_modify_args *args)
2470 {
2471         switch (args->event) {
2472         case NB_EV_VALIDATE:
2473         case NB_EV_PREPARE:
2474         case NB_EV_ABORT:
2475         case NB_EV_APPLY:
2476                 break;
2477         }
2478
2479         return NB_OK;
2480 }
2481
2482 int
2483 lib_route_map_entry_set_action_rmap_set_action_aggregator_aggregator_asn_destroy(
2484         struct nb_cb_destroy_args *args)
2485 {
2486         switch (args->event) {
2487         case NB_EV_VALIDATE:
2488         case NB_EV_PREPARE:
2489         case NB_EV_ABORT:
2490                 break;
2491         case NB_EV_APPLY:
2492                 return lib_route_map_entry_set_destroy(args);
2493         }
2494
2495         return NB_OK;
2496 }
2497
2498 /*
2499  * XPath:
2500  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:aggregator/aggregator-address
2501  */
2502 int
2503 lib_route_map_entry_set_action_rmap_set_action_aggregator_aggregator_address_modify(
2504         struct nb_cb_modify_args *args)
2505 {
2506         switch (args->event) {
2507         case NB_EV_VALIDATE:
2508         case NB_EV_PREPARE:
2509         case NB_EV_ABORT:
2510         case NB_EV_APPLY:
2511                 break;
2512         }
2513
2514         return NB_OK;
2515 }
2516
2517 int
2518 lib_route_map_entry_set_action_rmap_set_action_aggregator_aggregator_address_destroy(
2519         struct nb_cb_destroy_args *args)
2520 {
2521         switch (args->event) {
2522         case NB_EV_VALIDATE:
2523         case NB_EV_PREPARE:
2524         case NB_EV_ABORT:
2525                 break;
2526         case NB_EV_APPLY:
2527                 return lib_route_map_entry_set_destroy(args);
2528         }
2529
2530         return NB_OK;
2531 }
2532
2533 /*
2534  * XPath:
2535  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:comm-list-name
2536  */
2537 int lib_route_map_entry_set_action_rmap_set_action_comm_list_name_modify(
2538         struct nb_cb_modify_args *args)
2539 {
2540         struct routemap_hook_context *rhc;
2541         const char *value;
2542         const char *action;
2543         int rv = CMD_SUCCESS;
2544
2545         switch (args->event) {
2546         case NB_EV_VALIDATE:
2547         case NB_EV_PREPARE:
2548         case NB_EV_ABORT:
2549                 break;
2550         case NB_EV_APPLY:
2551                 /* Add configuration. */
2552                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2553                 value = yang_dnode_get_string(args->dnode, NULL);
2554
2555                 /* Set destroy information. */
2556                 rhc->rhc_shook = generic_set_delete;
2557
2558                 action = yang_dnode_get_string(args->dnode,
2559                                 "../../frr-route-map:action");
2560                 if (IS_SET_COMM_LIST_DEL(action))
2561                         rhc->rhc_rule = "comm-list";
2562                 else
2563                         rhc->rhc_rule = "large-comm-list";
2564
2565                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2566
2567                 rv = generic_set_add(rhc->rhc_rmi, rhc->rhc_rule, value,
2568                                      args->errmsg, args->errmsg_len);
2569
2570                 if (rv != CMD_SUCCESS) {
2571                         rhc->rhc_shook = NULL;
2572                         return NB_ERR_INCONSISTENCY;
2573                 }
2574         }
2575
2576         return NB_OK;
2577 }
2578
2579 int
2580 lib_route_map_entry_set_action_rmap_set_action_comm_list_name_destroy(
2581         struct nb_cb_destroy_args *args)
2582 {
2583         switch (args->event) {
2584         case NB_EV_VALIDATE:
2585         case NB_EV_PREPARE:
2586         case NB_EV_ABORT:
2587                 break;
2588         case NB_EV_APPLY:
2589                 return lib_route_map_entry_set_destroy(args);
2590         }
2591
2592         return NB_OK;
2593 }
2594
2595 /*
2596  * XPath:
2597  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:extcommunity-lb
2598  */
2599 void
2600 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_finish(
2601         struct nb_cb_apply_finish_args *args)
2602 {
2603         struct routemap_hook_context *rhc;
2604         enum ecommunity_lb_type lb_type;
2605         char str[VTY_BUFSIZ];
2606         uint16_t bandwidth;
2607
2608         /* Add configuration. */
2609         rhc = nb_running_get_entry(args->dnode, NULL, true);
2610         lb_type = yang_dnode_get_enum(args->dnode, "./lb-type");
2611
2612         /* Set destroy information. */
2613         rhc->rhc_shook = generic_set_delete;
2614         rhc->rhc_rule = "extcommunity bandwidth";
2615         rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2616
2617         switch (lb_type) {
2618         case EXPLICIT_BANDWIDTH:
2619                 bandwidth = yang_dnode_get_uint16(args->dnode, "./bandwidth");
2620                 snprintf(str, sizeof(str), "%d", bandwidth);
2621                 break;
2622         case CUMULATIVE_BANDWIDTH:
2623                 snprintf(str, sizeof(str), "%s", "cumulative");
2624                 break;
2625         case COMPUTED_BANDWIDTH:
2626                 snprintf(str, sizeof(str), "%s", "num-multipaths");
2627         }
2628
2629         if (yang_dnode_get_bool(args->dnode, "./two-octet-as-specific"))
2630                 strlcat(str, " non-transitive", sizeof(str));
2631
2632         generic_set_add(rhc->rhc_rmi,
2633                         "extcommunity bandwidth", str,
2634                         args->errmsg, args->errmsg_len);
2635 }
2636
2637 /*
2638  * XPath:
2639  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:extcommunity-lb/lb-type
2640  */
2641 int
2642 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_lb_type_modify(
2643                 struct nb_cb_modify_args *args)
2644 {
2645         return NB_OK;
2646 }
2647
2648 int
2649 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_lb_type_destroy(
2650                 struct nb_cb_destroy_args *args)
2651 {
2652         return lib_route_map_entry_set_destroy(args);
2653 }
2654
2655 /*
2656  * XPath:
2657  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:extcommunity-lb/bandwidth
2658  */
2659 int
2660 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_bandwidth_modify(
2661                 struct nb_cb_modify_args *args)
2662 {
2663         return NB_OK;
2664 }
2665
2666 int
2667 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_bandwidth_destroy(
2668                 struct nb_cb_destroy_args *args)
2669 {
2670         return lib_route_map_entry_set_destroy(args);
2671 }
2672
2673 /*
2674  * XPath:
2675  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:extcommunity-lb/two-octet-as-specific
2676  */
2677 int
2678 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_two_octet_as_specific_modify(
2679         struct nb_cb_modify_args *args)
2680 {
2681         return NB_OK;
2682 }
2683
2684 int
2685 lib_route_map_entry_set_action_rmap_set_action_extcommunity_lb_two_octet_as_specific_destroy(
2686         struct nb_cb_destroy_args *args)
2687 {
2688         return lib_route_map_entry_set_destroy(args);
2689 }
2690
2691 /*
2692  * XPath:
2693  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:evpn-gateway-ip-ipv4
2694  */
2695 int lib_route_map_entry_set_action_rmap_set_action_evpn_gateway_ip_ipv4_modify(
2696         struct nb_cb_modify_args *args)
2697 {
2698         struct routemap_hook_context *rhc;
2699         const char *type;
2700         int rv;
2701
2702         switch (args->event) {
2703         case NB_EV_VALIDATE:
2704         case NB_EV_PREPARE:
2705         case NB_EV_ABORT:
2706                 break;
2707         case NB_EV_APPLY:
2708                 /* Add configuration. */
2709                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2710                 type = yang_dnode_get_string(args->dnode, NULL);
2711
2712                 /* Set destroy information. */
2713                 rhc->rhc_shook = generic_set_delete;
2714                 rhc->rhc_rule = "evpn gateway-ip ipv4";
2715                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2716
2717                 rv = generic_set_add(rhc->rhc_rmi, "evpn gateway-ip ipv4", type,
2718                                      args->errmsg, args->errmsg_len);
2719                 if (rv != CMD_SUCCESS) {
2720                         rhc->rhc_shook = NULL;
2721                         return NB_ERR_INCONSISTENCY;
2722                 }
2723         }
2724
2725         return NB_OK;
2726 }
2727
2728 int lib_route_map_entry_set_action_rmap_set_action_evpn_gateway_ip_ipv4_destroy(
2729         struct nb_cb_destroy_args *args)
2730 {
2731         switch (args->event) {
2732         case NB_EV_VALIDATE:
2733         case NB_EV_PREPARE:
2734         case NB_EV_ABORT:
2735                 break;
2736         case NB_EV_APPLY:
2737                 return lib_route_map_entry_set_destroy(args);
2738         }
2739
2740         return NB_OK;
2741 }
2742
2743 /*
2744  * XPath:
2745  * /frr-route-map:lib/route-map/entry/set-action/rmap-set-action/frr-bgp-route-map:evpn-gateway-ip-ipv6
2746  */
2747 int lib_route_map_entry_set_action_rmap_set_action_evpn_gateway_ip_ipv6_modify(
2748         struct nb_cb_modify_args *args)
2749 {
2750         struct routemap_hook_context *rhc;
2751         const char *type;
2752         int rv;
2753
2754         switch (args->event) {
2755         case NB_EV_VALIDATE:
2756         case NB_EV_PREPARE:
2757         case NB_EV_ABORT:
2758                 break;
2759         case NB_EV_APPLY:
2760                 /* Add configuration. */
2761                 rhc = nb_running_get_entry(args->dnode, NULL, true);
2762                 type = yang_dnode_get_string(args->dnode, NULL);
2763
2764                 /* Set destroy information. */
2765                 rhc->rhc_shook = generic_set_delete;
2766                 rhc->rhc_rule = "evpn gateway-ip ipv6";
2767                 rhc->rhc_event = RMAP_EVENT_SET_DELETED;
2768
2769                 rv = generic_set_add(rhc->rhc_rmi, "evpn gateway-ip ipv6", type,
2770                                      args->errmsg, args->errmsg_len);
2771                 if (rv != CMD_SUCCESS) {
2772                         rhc->rhc_shook = NULL;
2773                         return NB_ERR_INCONSISTENCY;
2774                 }
2775         }
2776
2777         return NB_OK;
2778 }
2779
2780 int lib_route_map_entry_set_action_rmap_set_action_evpn_gateway_ip_ipv6_destroy(
2781         struct nb_cb_destroy_args *args)
2782 {
2783         switch (args->event) {
2784         case NB_EV_VALIDATE:
2785         case NB_EV_PREPARE:
2786         case NB_EV_ABORT:
2787                 break;
2788         case NB_EV_APPLY:
2789                 return lib_route_map_entry_set_destroy(args);
2790         }
2791
2792         return NB_OK;
2793 }