vrrpd/vrrp_northbound.c

   1 /*
   2  * VRRP northbound bindings.
   3  * Copyright (C) 2019  Cumulus Networks, Inc.
   4  * Quentin Young
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "if.h"
  24 #include "log.h"
  25 #include "prefix.h"
  26 #include "table.h"
  27 #include "command.h"
  28 #include "northbound.h"
  29 #include "libfrr.h"
  30 #include "vrrp.h"
  31 #include "vrrp_vty.h"
  32
  33 /*
  34  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group
  35  */
  36 static int lib_interface_vrrp_vrrp_group_create(enum nb_event event,
  37                                                 const struct lyd_node *dnode,
  38                                                 union nb_resource *resource)
  39 {
  40         struct interface *ifp;
  41         uint8_t vrid;
  42         uint8_t version = 3;
  43         struct vrrp_vrouter *vr;
  44
  45         if (event != NB_EV_APPLY)
  46                 return NB_OK;
  47
  48         ifp = nb_running_get_entry(dnode, NULL, true);
  49         vrid = yang_dnode_get_uint8(dnode, "./virtual-router-id");
  50         version = yang_dnode_get_enum(dnode, "./version");
  51         vr = vrrp_vrouter_create(ifp, vrid, version);
  52         nb_running_set_entry(dnode, vr);
  53
  54         return NB_OK;
  55 }
  56
  57 static int lib_interface_vrrp_vrrp_group_destroy(enum nb_event event,
  58                                                  const struct lyd_node *dnode)
  59 {
  60         struct vrrp_vrouter *vr;
  61
  62         if (event != NB_EV_APPLY)
  63                 return NB_OK;
  64
  65         vr = nb_running_unset_entry(dnode);
  66         vrrp_vrouter_destroy(vr);
  67
  68         return NB_OK;
  69 }
  70
  71 static const void *
  72 lib_interface_vrrp_vrrp_group_get_next(const void *parent_list_entry,
  73                                        const void *list_entry)
  74 {
  75         struct list *l = hash_to_list(vrrp_vrouters_hash);
  76         struct listnode *ln;
  77         const struct vrrp_vrouter *vr, *prev, *curr;
  78         const struct interface *ifp = parent_list_entry;
  79
  80         prev = curr = NULL;
  81         vr = list_entry;
  82
  83         /*
  84          * If list_entry is null, we return the first vrrp instance with a
  85          * matching interface
  86          */
  87         bool nextone = list_entry ? false : true;
  88
  89         for (ALL_LIST_ELEMENTS_RO(l, ln, curr)) {
  90                 if (curr == list_entry) {
  91                         nextone = true;
  92                         continue;
  93                 }
  94
  95                 if (nextone && curr->ifp == ifp)
  96                         goto done;
  97
  98                 prev = curr;
  99         }
 100
 101         curr = NULL;
 102
 103 done:
 104         list_delete(&l);
 105         return curr;
 106 }
 107
 108 static int lib_interface_vrrp_vrrp_group_get_keys(const void *list_entry,
 109                                                   struct yang_list_keys *keys)
 110 {
 111         const struct vrrp_vrouter *vr = list_entry;
 112
 113         keys->num = 1;
 114         snprintf(keys->key[0], sizeof(keys->key[0]), "%" PRIu32, vr->vrid);
 115
 116         return NB_OK;
 117 }
 118
 119 static const void *
 120 lib_interface_vrrp_vrrp_group_lookup_entry(const void *parent_list_entry,
 121                                            const struct yang_list_keys *keys)
 122 {
 123         uint32_t vrid = strtoul(keys->key[0], NULL, 10);
 124         const struct interface *ifp = parent_list_entry;
 125
 126         vrrp_lookup(ifp, vrid);
 127
 128         return NULL;
 129 }
 130
 131 /*
 132  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/version
 133  */
 134 static int
 135 lib_interface_vrrp_vrrp_group_version_modify(enum nb_event event,
 136                                              const struct lyd_node *dnode,
 137                                              union nb_resource *resource)
 138 {
 139         if (event != NB_EV_APPLY)
 140                 return NB_OK;
 141
 142         struct vrrp_vrouter *vr;
 143         uint8_t version;
 144
 145         vr = nb_running_get_entry(dnode, NULL, true);
 146         vrrp_event(vr->v4, VRRP_EVENT_SHUTDOWN);
 147         vrrp_event(vr->v6, VRRP_EVENT_SHUTDOWN);
 148         version = yang_dnode_get_enum(dnode, NULL);
 149         vr->version = version;
 150
 151         vrrp_check_start(vr);
 152
 153         return NB_OK;
 154 }
 155
 156 static void vrrp_yang_add_del_virtual_address(const struct lyd_node *dnode,
 157                                               bool add)
 158 {
 159         struct vrrp_vrouter *vr;
 160         struct ipaddr ip;
 161
 162         vr = nb_running_get_entry(dnode, NULL, true);
 163         yang_dnode_get_ip(&ip, dnode, NULL);
 164         if (add)
 165                 vrrp_add_ip(vr, &ip);
 166         else
 167                 vrrp_del_ip(vr, &ip);
 168
 169         vrrp_check_start(vr);
 170 }
 171
 172
 173 //-----------
 174
 175 /*
 176  * XPath:
 177  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/virtual-address
 178  */
 179 static int lib_interface_vrrp_vrrp_group_v4_virtual_address_create(
 180         enum nb_event event, const struct lyd_node *dnode,
 181         union nb_resource *resource)
 182 {
 183         if (event != NB_EV_APPLY)
 184                 return NB_OK;
 185
 186         vrrp_yang_add_del_virtual_address(dnode, true);
 187
 188         return NB_OK;
 189 }
 190
 191 static int lib_interface_vrrp_vrrp_group_v4_virtual_address_destroy(
 192         enum nb_event event, const struct lyd_node *dnode)
 193 {
 194         if (event != NB_EV_APPLY)
 195                 return NB_OK;
 196
 197         vrrp_yang_add_del_virtual_address(dnode, false);
 198
 199         return NB_OK;
 200 }
 201
 202 /*
 203  * XPath:
 204  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/current-priority
 205  */
 206 static struct yang_data *
 207 lib_interface_vrrp_vrrp_group_v4_current_priority_get_elem(
 208         const char *xpath, const void *list_entry)
 209 {
 210         const struct vrrp_vrouter *vr = list_entry;
 211
 212         return yang_data_new_uint8(xpath, vr->v4->priority);
 213 }
 214
 215 /*
 216  * XPath:
 217  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/vrrp-interface
 218  */
 219 static struct yang_data *
 220 lib_interface_vrrp_vrrp_group_v4_vrrp_interface_get_elem(const char *xpath,
 221                                                          const void *list_entry)
 222 {
 223         const struct vrrp_vrouter *vr = list_entry;
 224
 225         struct yang_data *val = NULL;
 226
 227         if (vr->v4->mvl_ifp)
 228                 val = yang_data_new_string(xpath, vr->v4->mvl_ifp->name);
 229
 230         return val;
 231 }
 232
 233 /*
 234  * XPath:
 235  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/source-address
 236  */
 237 static struct yang_data *
 238 lib_interface_vrrp_vrrp_group_v4_source_address_get_elem(const char *xpath,
 239                                                          const void *list_entry)
 240 {
 241         const struct vrrp_vrouter *vr = list_entry;
 242         struct yang_data *val = NULL;
 243         struct ipaddr ip;
 244
 245         memset(&ip, 0x00, sizeof(ip));
 246
 247         if (memcmp(&vr->v4->src.ipaddr_v4, &ip.ipaddr_v4, sizeof(ip.ipaddr_v4)))
 248                 val = yang_data_new_ip(xpath, &vr->v4->src);
 249
 250         return val;
 251 }
 252
 253 /*
 254  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/state
 255  */
 256 static struct yang_data *
 257 lib_interface_vrrp_vrrp_group_v4_state_get_elem(const char *xpath,
 258                                                 const void *list_entry)
 259 {
 260         const struct vrrp_vrouter *vr = list_entry;
 261
 262         return yang_data_new_enum(xpath, vr->v4->fsm.state);
 263 }
 264
 265 /*
 266  * XPath:
 267  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/master-advertisement-interval
 268  */
 269 static struct yang_data *
 270 lib_interface_vrrp_vrrp_group_v4_master_advertisement_interval_get_elem(
 271         const char *xpath, const void *list_entry)
 272 {
 273         const struct vrrp_vrouter *vr = list_entry;
 274
 275         return yang_data_new_uint16(xpath, vr->v4->master_adver_interval);
 276 }
 277
 278 /*
 279  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/skew-time
 280  */
 281 static struct yang_data *
 282 lib_interface_vrrp_vrrp_group_v4_skew_time_get_elem(const char *xpath,
 283                                                     const void *list_entry)
 284 {
 285         const struct vrrp_vrouter *vr = list_entry;
 286
 287         return yang_data_new_uint16(xpath, vr->v4->skew_time);
 288 }
 289
 290 /*
 291  * XPath:
 292  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/state-transition
 293  */
 294 static struct yang_data *
 295 lib_interface_vrrp_vrrp_group_v4_counter_state_transition_get_elem(
 296         const char *xpath, const void *list_entry)
 297 {
 298         const struct vrrp_vrouter *vr = list_entry;
 299
 300         return yang_data_new_uint32(xpath, vr->v4->stats.trans_cnt);
 301 }
 302
 303 /*
 304  * XPath:
 305  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/tx/advertisement
 306  */
 307 static struct yang_data *
 308 lib_interface_vrrp_vrrp_group_v4_counter_tx_advertisement_get_elem(
 309         const char *xpath, const void *list_entry)
 310 {
 311         const struct vrrp_vrouter *vr = list_entry;
 312
 313         return yang_data_new_uint32(xpath, vr->v4->stats.adver_tx_cnt);
 314 }
 315
 316 /*
 317  * XPath:
 318  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/tx/gratuitous-arp
 319  */
 320 static struct yang_data *
 321 lib_interface_vrrp_vrrp_group_v4_counter_tx_gratuitous_arp_get_elem(
 322         const char *xpath, const void *list_entry)
 323 {
 324         const struct vrrp_vrouter *vr = list_entry;
 325
 326         return yang_data_new_uint32(xpath, vr->v4->stats.garp_tx_cnt);
 327 }
 328
 329 /*
 330  * XPath:
 331  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/rx/advertisement
 332  */
 333 static struct yang_data *
 334 lib_interface_vrrp_vrrp_group_v4_counter_rx_advertisement_get_elem(
 335         const char *xpath, const void *list_entry)
 336 {
 337         const struct vrrp_vrouter *vr = list_entry;
 338
 339         return yang_data_new_uint32(xpath, vr->v4->stats.adver_rx_cnt);
 340 }
 341
 342 /*
 343  * XPath:
 344  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/virtual-address
 345  */
 346 static int lib_interface_vrrp_vrrp_group_v6_virtual_address_create(
 347         enum nb_event event, const struct lyd_node *dnode,
 348         union nb_resource *resource)
 349 {
 350         if (event != NB_EV_APPLY)
 351                 return NB_OK;
 352
 353         vrrp_yang_add_del_virtual_address(dnode, true);
 354
 355         return NB_OK;
 356 }
 357
 358 static int lib_interface_vrrp_vrrp_group_v6_virtual_address_destroy(
 359         enum nb_event event, const struct lyd_node *dnode)
 360 {
 361         if (event != NB_EV_APPLY)
 362                 return NB_OK;
 363
 364         vrrp_yang_add_del_virtual_address(dnode, false);
 365
 366         return NB_OK;
 367 }
 368
 369 /*
 370  * XPath:
 371  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/current-priority
 372  */
 373 static struct yang_data *
 374 lib_interface_vrrp_vrrp_group_v6_current_priority_get_elem(
 375         const char *xpath, const void *list_entry)
 376 {
 377         const struct vrrp_vrouter *vr = list_entry;
 378
 379         return yang_data_new_uint8(xpath, vr->v6->priority);
 380 }
 381
 382 /*
 383  * XPath:
 384  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/vrrp-interface
 385  */
 386 static struct yang_data *
 387 lib_interface_vrrp_vrrp_group_v6_vrrp_interface_get_elem(const char *xpath,
 388                                                          const void *list_entry)
 389 {
 390         const struct vrrp_vrouter *vr = list_entry;
 391         struct yang_data *val = NULL;
 392
 393         if (vr->v6->mvl_ifp)
 394                 val = yang_data_new_string(xpath, vr->v6->mvl_ifp->name);
 395
 396         return val;
 397 }
 398
 399 /*
 400  * XPath:
 401  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/source-address
 402  */
 403 static struct yang_data *
 404 lib_interface_vrrp_vrrp_group_v6_source_address_get_elem(const char *xpath,
 405                                                          const void *list_entry)
 406 {
 407         const struct vrrp_vrouter *vr = list_entry;
 408         struct yang_data *val = NULL;
 409         struct ipaddr ip;
 410
 411         memset(&ip, 0x00, sizeof(ip));
 412
 413         if (memcmp(&vr->v6->src.ipaddr_v6, &ip.ipaddr_v6, sizeof(ip.ipaddr_v6)))
 414                 val = yang_data_new_ip(xpath, &vr->v6->src);
 415
 416         return val;
 417 }
 418
 419 /*
 420  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/state
 421  */
 422 static struct yang_data *
 423 lib_interface_vrrp_vrrp_group_v6_state_get_elem(const char *xpath,
 424                                                 const void *list_entry)
 425 {
 426         const struct vrrp_vrouter *vr = list_entry;
 427
 428         return yang_data_new_enum(xpath, vr->v6->fsm.state);
 429 }
 430
 431 /*
 432  * XPath:
 433  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/master-advertisement-interval
 434  */
 435 static struct yang_data *
 436 lib_interface_vrrp_vrrp_group_v6_master_advertisement_interval_get_elem(
 437         const char *xpath, const void *list_entry)
 438 {
 439         const struct vrrp_vrouter *vr = list_entry;
 440
 441         return yang_data_new_uint16(xpath, vr->v6->master_adver_interval);
 442 }
 443
 444 /*
 445  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/skew-time
 446  */
 447 static struct yang_data *
 448 lib_interface_vrrp_vrrp_group_v6_skew_time_get_elem(const char *xpath,
 449                                                     const void *list_entry)
 450 {
 451         const struct vrrp_vrouter *vr = list_entry;
 452
 453         return yang_data_new_uint16(xpath, vr->v6->skew_time);
 454 }
 455
 456 /*
 457  * XPath:
 458  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/state-transition
 459  */
 460 static struct yang_data *
 461 lib_interface_vrrp_vrrp_group_v6_counter_state_transition_get_elem(
 462         const char *xpath, const void *list_entry)
 463 {
 464         const struct vrrp_vrouter *vr = list_entry;
 465
 466         return yang_data_new_uint32(xpath, vr->v6->stats.trans_cnt);
 467 }
 468
 469 /*
 470  * XPath:
 471  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/tx/advertisement
 472  */
 473 static struct yang_data *
 474 lib_interface_vrrp_vrrp_group_v6_counter_tx_advertisement_get_elem(
 475         const char *xpath, const void *list_entry)
 476 {
 477         const struct vrrp_vrouter *vr = list_entry;
 478
 479         return yang_data_new_uint32(xpath, vr->v6->stats.adver_tx_cnt);
 480 }
 481
 482 /*
 483  * XPath:
 484  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/tx/neighbor-advertisement
 485  */
 486 static struct yang_data *
 487 lib_interface_vrrp_vrrp_group_v6_counter_tx_neighbor_advertisement_get_elem(
 488         const char *xpath, const void *list_entry)
 489 {
 490         /* TODO: implement me. */
 491         return NULL;
 492 }
 493
 494 /*
 495  * XPath:
 496  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/rx/advertisement
 497  */
 498 static struct yang_data *
 499 lib_interface_vrrp_vrrp_group_v6_counter_rx_advertisement_get_elem(
 500         const char *xpath, const void *list_entry)
 501 {
 502         /* TODO: implement me. */
 503         return NULL;
 504 }
 505
 506 /*
 507  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/priority
 508  */
 509 static int
 510 lib_interface_vrrp_vrrp_group_priority_modify(enum nb_event event,
 511                                               const struct lyd_node *dnode,
 512                                               union nb_resource *resource)
 513 {
 514         if (event != NB_EV_APPLY)
 515                 return NB_OK;
 516
 517         struct vrrp_vrouter *vr;
 518         uint8_t priority;
 519
 520         vr = nb_running_get_entry(dnode, NULL, true);
 521         priority = yang_dnode_get_uint8(dnode, NULL);
 522         vrrp_set_priority(vr, priority);
 523
 524         return NB_OK;
 525 }
 526
 527 /*
 528  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/preempt
 529  */
 530 static int
 531 lib_interface_vrrp_vrrp_group_preempt_modify(enum nb_event event,
 532                                              const struct lyd_node *dnode,
 533                                              union nb_resource *resource)
 534 {
 535         if (event != NB_EV_APPLY)
 536                 return NB_OK;
 537
 538         struct vrrp_vrouter *vr;
 539         bool preempt;
 540
 541         vr = nb_running_get_entry(dnode, NULL, true);
 542         preempt = yang_dnode_get_bool(dnode, NULL);
 543         vr->preempt_mode = preempt;
 544
 545         return NB_OK;
 546 }
 547
 548 /*
 549  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/accept-mode
 550  */
 551 static int
 552 lib_interface_vrrp_vrrp_group_accept_mode_modify(enum nb_event event,
 553                                                  const struct lyd_node *dnode,
 554                                                  union nb_resource *resource)
 555 {
 556         if (event != NB_EV_APPLY)
 557                 return NB_OK;
 558
 559         struct vrrp_vrouter *vr;
 560         bool accept;
 561
 562         vr = nb_running_get_entry(dnode, NULL, true);
 563         accept = yang_dnode_get_bool(dnode, NULL);
 564         vr->accept_mode = accept;
 565
 566         return NB_OK;
 567 }
 568
 569 /*
 570  * XPath:
 571  * /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/advertisement-interval
 572  */
 573 static int lib_interface_vrrp_vrrp_group_advertisement_interval_modify(
 574         enum nb_event event, const struct lyd_node *dnode,
 575         union nb_resource *resource)
 576 {
 577         if (event != NB_EV_APPLY)
 578                 return NB_OK;
 579
 580         struct vrrp_vrouter *vr;
 581         uint16_t advert_int;
 582
 583         vr = nb_running_get_entry(dnode, NULL, true);
 584         advert_int = yang_dnode_get_uint16(dnode, NULL);
 585         vrrp_set_advertisement_interval(vr, advert_int);
 586
 587         return NB_OK;
 588 }
 589
 590 /*
 591  * XPath: /frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/shutdown
 592  */
 593 static int
 594 lib_interface_vrrp_vrrp_group_shutdown_modify(enum nb_event event,
 595                                               const struct lyd_node *dnode,
 596                                               union nb_resource *resource)
 597 {
 598         if (event != NB_EV_APPLY)
 599                 return NB_OK;
 600
 601         struct vrrp_vrouter *vr;
 602         bool shutdown;
 603
 604         vr = nb_running_get_entry(dnode, NULL, true);
 605         shutdown = yang_dnode_get_bool(dnode, NULL);
 606
 607         vr->shutdown = shutdown;
 608
 609         if (shutdown) {
 610                 vrrp_event(vr->v4, VRRP_EVENT_SHUTDOWN);
 611                 vrrp_event(vr->v6, VRRP_EVENT_SHUTDOWN);
 612         } else {
 613                 vrrp_check_start(vr);
 614         }
 615
 616         return NB_OK;
 617 }
 618
 619 /* clang-format off */
 620 const struct frr_yang_module_info frr_vrrpd_info = {
 621         .name = "frr-vrrpd",
 622         .nodes = {
 623                 {
 624                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group",
 625                         .cbs = {
 626                                 .create = lib_interface_vrrp_vrrp_group_create,
 627                                 .destroy = lib_interface_vrrp_vrrp_group_destroy,
 628                                 .get_next = lib_interface_vrrp_vrrp_group_get_next,
 629                                 .get_keys = lib_interface_vrrp_vrrp_group_get_keys,
 630                                 .lookup_entry = lib_interface_vrrp_vrrp_group_lookup_entry,
 631                                 .cli_show = cli_show_vrrp,
 632                         }
 633                 },
 634                 {
 635                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/version",
 636                         .cbs = {
 637                                 .modify = lib_interface_vrrp_vrrp_group_version_modify,
 638                         }
 639                 },
 640                 {
 641                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/priority",
 642                         .cbs = {
 643                                 .modify = lib_interface_vrrp_vrrp_group_priority_modify,
 644                                 .cli_show = cli_show_priority,
 645                         }
 646                 },
 647                 {
 648                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/preempt",
 649                         .cbs = {
 650                                 .modify = lib_interface_vrrp_vrrp_group_preempt_modify,
 651                                 .cli_show = cli_show_preempt,
 652                         }
 653                 },
 654                 {
 655                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/accept-mode",
 656                         .cbs = {
 657                                 .modify = lib_interface_vrrp_vrrp_group_accept_mode_modify,
 658                         }
 659                 },
 660                 {
 661                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/advertisement-interval",
 662                         .cbs = {
 663                                 .modify = lib_interface_vrrp_vrrp_group_advertisement_interval_modify,
 664                                 .cli_show = cli_show_advertisement_interval,
 665                         }
 666                 },
 667                 {
 668                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/shutdown",
 669                         .cbs = {
 670                                 .modify = lib_interface_vrrp_vrrp_group_shutdown_modify,
 671                                 .cli_show = cli_show_shutdown,
 672                         }
 673                 },
 674                 {
 675                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/virtual-address",
 676                         .cbs = {
 677                                 .create = lib_interface_vrrp_vrrp_group_v4_virtual_address_create,
 678                                 .destroy = lib_interface_vrrp_vrrp_group_v4_virtual_address_destroy,
 679                                 .cli_show = cli_show_ip,
 680                         }
 681                 },
 682                 {
 683                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/current-priority",
 684                         .cbs = {
 685                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_current_priority_get_elem,
 686                         }
 687                 },
 688                 {
 689                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/vrrp-interface",
 690                         .cbs = {
 691                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_vrrp_interface_get_elem,
 692                         }
 693                 },
 694                 {
 695                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/source-address",
 696                         .cbs = {
 697                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_source_address_get_elem,
 698                         }
 699                 },
 700                 {
 701                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/state",
 702                         .cbs = {
 703                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_state_get_elem,
 704                         }
 705                 },
 706                 {
 707                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/master-advertisement-interval",
 708                         .cbs = {
 709                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_master_advertisement_interval_get_elem,
 710                         }
 711                 },
 712                 {
 713                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/skew-time",
 714                         .cbs = {
 715                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_skew_time_get_elem,
 716                         }
 717                 },
 718                 {
 719                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/state-transition",
 720                         .cbs = {
 721                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_counter_state_transition_get_elem,
 722                         }
 723                 },
 724                 {
 725                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/tx/advertisement",
 726                         .cbs = {
 727                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_counter_tx_advertisement_get_elem,
 728                         }
 729                 },
 730                 {
 731                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/tx/gratuitous-arp",
 732                         .cbs = {
 733                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_counter_tx_gratuitous_arp_get_elem,
 734                         }
 735                 },
 736                 {
 737                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v4/counter/rx/advertisement",
 738                         .cbs = {
 739                                 .get_elem = lib_interface_vrrp_vrrp_group_v4_counter_rx_advertisement_get_elem,
 740                         }
 741                 },
 742                 {
 743                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/virtual-address",
 744                         .cbs = {
 745                                 .create = lib_interface_vrrp_vrrp_group_v6_virtual_address_create,
 746                                 .destroy = lib_interface_vrrp_vrrp_group_v6_virtual_address_destroy,
 747                                 .cli_show = cli_show_ipv6,
 748                         }
 749                 },
 750                 {
 751                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/current-priority",
 752                         .cbs = {
 753                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_current_priority_get_elem,
 754                         }
 755                 },
 756                 {
 757                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/vrrp-interface",
 758                         .cbs = {
 759                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_vrrp_interface_get_elem,
 760                         }
 761                 },
 762                 {
 763                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/source-address",
 764                         .cbs = {
 765                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_source_address_get_elem,
 766                         }
 767                 },
 768                 {
 769                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/state",
 770                         .cbs = {
 771                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_state_get_elem,
 772                         }
 773                 },
 774                 {
 775                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/master-advertisement-interval",
 776                         .cbs = {
 777                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_master_advertisement_interval_get_elem,
 778                         }
 779                 },
 780                 {
 781                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/skew-time",
 782                         .cbs = {
 783                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_skew_time_get_elem,
 784                         }
 785                 },
 786                 {
 787                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/state-transition",
 788                         .cbs = {
 789                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_counter_state_transition_get_elem,
 790                         }
 791                 },
 792                 {
 793                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/tx/advertisement",
 794                         .cbs = {
 795                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_counter_tx_advertisement_get_elem,
 796                         }
 797                 },
 798                 {
 799                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/tx/neighbor-advertisement",
 800                         .cbs = {
 801                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_counter_tx_neighbor_advertisement_get_elem,
 802                         }
 803                 },
 804                 {
 805                         .xpath = "/frr-interface:lib/interface/frr-vrrpd:vrrp/vrrp-group/v6/counter/rx/advertisement",
 806                         .cbs = {
 807                                 .get_elem = lib_interface_vrrp_vrrp_group_v6_counter_rx_advertisement_get_elem,
 808                         }
 809                 },
 810                 {
 811                         .xpath = NULL,
 812                 },
 813         }
 814 };