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