// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Copyright (C) 2020 VmWare

 *                    Sarita Patra

 */

#include <zebra.h>

#include "pimd.h"

#include "pim_nb.h"

#include "lib/northbound_cli.h"

#include "pim_igmpv3.h"

#include "pim_neighbor.h"

#include "pim_nht.h"

#include "pim_pim.h"

#include "pim_mlag.h"

#include "pim_bfd.h"

#include "pim_static.h"

#include "pim_ssm.h"

#include "pim_ssmpingd.h"

#include "pim_vxlan.h"

#include "pim_util.h"

#include "log.h"

#include "lib_errors.h"

#include "pim_util.h"

#include "pim6_mld.h"

#if PIM_IPV == 6

#define pim6_msdp_err(funcname, argtype)                                       \

int funcname(struct argtype *args)                                             \

{                                                                              \

  snprintf(args->errmsg, args->errmsg_len,                               \

     "Trying to configure MSDP in pim6d.  "                        \

     "MSDP does not exist for IPv6.");                             \

  return NB_ERR_VALIDATION;                                              \

}                                                                              \

MACRO_REQUIRE_SEMICOLON()

#define yang_dnode_get_pimaddr yang_dnode_get_ipv6

#else /* PIM_IPV != 6 */

#define pim6_msdp_err(funcname, argtype)                                       \

MACRO_REQUIRE_SEMICOLON()

#define yang_dnode_get_pimaddr yang_dnode_get_ipv4

#endif /* PIM_IPV != 6 */

static void pim_if_membership_clear(struct interface *ifp)

{

  struct pim_interface *pim_ifp;

  pim_ifp = ifp->info;

  assert(pim_ifp);

  if (pim_ifp->pim_enable && pim_ifp->gm_enable) {

    return;

  }

  pim_ifchannel_membership_clear(ifp);

}

/*

 * When PIM is disabled on interface, IGMPv3 local membership

 * information is not injected into PIM interface state.

 * The function pim_if_membership_refresh() fetches all IGMPv3 local

 * membership information into PIM. It is intented to be called

 * whenever PIM is enabled on the interface in order to collect missed

 * local membership information.

 */

static void pim_if_membership_refresh(struct interface *ifp)

{

  struct pim_interface *pim_ifp;

#if PIM_IPV == 4

  struct listnode *grpnode;

  struct gm_group *grp;

#else

  struct gm_if *gm_ifp;

  struct gm_sg *sg, *sg_start;

#endif

  pim_ifp = ifp->info;

  assert(pim_ifp);

  if (!pim_ifp->pim_enable)

    return;

  if (!pim_ifp->gm_enable)

    return;

#if PIM_IPV == 6

  gm_ifp = pim_ifp->mld;

  if (!gm_ifp)

    return;

#endif

  /*

   * First clear off membership from all PIM (S,G) entries on the

   * interface

   */

  pim_ifchannel_membership_clear(ifp);

#if PIM_IPV == 4

  /*

   * Then restore PIM (S,G) membership from all IGMPv3 (S,G) entries on

   * the interface

   */

  /* scan igmp groups */

  for (ALL_LIST_ELEMENTS_RO(pim_ifp->gm_group_list, grpnode, grp)) {

    struct listnode *srcnode;

    struct gm_source *src;

    /* scan group sources */

    for (ALL_LIST_ELEMENTS_RO(grp->group_source_list, srcnode,

            src)) {

      if (IGMP_SOURCE_TEST_FORWARDING(src->source_flags)) {

        pim_sgaddr sg;

        memset(&sg, 0, sizeof(sg));

        sg.src = src->source_addr;

        sg.grp = grp->group_addr;

        pim_ifchannel_local_membership_add(

          ifp, &sg, false /*is_vxlan*/);

      }

    } /* scan group sources */

  }  /* scan igmp groups */

#else

  sg_start = gm_sgs_first(gm_ifp->sgs);

  frr_each_from (gm_sgs, gm_ifp->sgs, sg, sg_start) {

    if (!in6_multicast_nofwd(&sg->sgaddr.grp)) {

      pim_ifchannel_local_membership_add(

        ifp, &sg->sgaddr, false /*is_vxlan*/);

    }

  }

#endif

  /*

   * Finally delete every PIM (S,G) entry lacking all state info

   */

  pim_ifchannel_delete_on_noinfo(ifp);

}

static int pim_cmd_interface_add(struct interface *ifp)

{

  struct pim_interface *pim_ifp = ifp->info;

  if (!pim_ifp)

    pim_ifp = pim_if_new(ifp, false, true, false, false);

  else

    pim_ifp->pim_enable = true;

  pim_if_addr_add_all(ifp);

  pim_upstream_nh_if_update(pim_ifp->pim, ifp);

  pim_if_membership_refresh(ifp);

  pim_if_create_pimreg(pim_ifp->pim);

  return 1;

}

static int pim_cmd_interface_delete(struct interface *ifp)

{

  struct pim_interface *pim_ifp = ifp->info;

  if (!pim_ifp)

    return 1;

  pim_ifp->pim_enable = false;

  pim_if_membership_clear(ifp);

  /*

   * pim_sock_delete() removes all neighbors from

   * pim_ifp->pim_neighbor_list.

   */

  pim_sock_delete(ifp, "pim unconfigured on interface");

  pim_upstream_nh_if_update(pim_ifp->pim, ifp);

  if (!pim_ifp->gm_enable) {

    pim_if_addr_del_all(ifp);

    pim_if_delete(ifp);

  }

  return 1;

}

static int interface_pim_use_src_cmd_worker(struct interface *ifp,

    pim_addr source_addr, char *errmsg, size_t errmsg_len)

{

  int result;

  int ret = NB_OK;

  result = pim_update_source_set(ifp, source_addr);

  switch (result) {

  case PIM_SUCCESS:

    break;

  case PIM_IFACE_NOT_FOUND:

    ret = NB_ERR;

    snprintf(errmsg, errmsg_len,

       "Pim not enabled on this interface %s",

       ifp->name);

      break;

  case PIM_UPDATE_SOURCE_DUP:

    ret = NB_ERR;

    snprintf(errmsg, errmsg_len, "Source already set");

    break;

  default:

    ret = NB_ERR;

    snprintf(errmsg, errmsg_len, "Source set failed");

  }

  return ret;

}

static int pim_cmd_spt_switchover(struct pim_instance *pim,

    enum pim_spt_switchover spt,

    const char *plist)

{

  pim->spt.switchover = spt;

  switch (pim->spt.switchover) {

  case PIM_SPT_IMMEDIATE:

    XFREE(MTYPE_PIM_PLIST_NAME, pim->spt.plist);

    pim_upstream_add_lhr_star_pimreg(pim);

    break;

  case PIM_SPT_INFINITY:

    pim_upstream_remove_lhr_star_pimreg(pim, plist);

    XFREE(MTYPE_PIM_PLIST_NAME, pim->spt.plist);

    if (plist)

      pim->spt.plist = XSTRDUP(MTYPE_PIM_PLIST_NAME, plist);

    break;

  }

  return NB_OK;

}

static int pim_ssm_cmd_worker(struct pim_instance *pim, const char *plist,

    char *errmsg, size_t errmsg_len)

{

  int result = pim_ssm_range_set(pim, pim->vrf->vrf_id, plist);

  int ret = NB_ERR;

  if (result == PIM_SSM_ERR_NONE)

    return NB_OK;

  switch (result) {

  case PIM_SSM_ERR_NO_VRF:

    snprintf(errmsg, errmsg_len,

       "VRF doesn't exist");

    break;

  case PIM_SSM_ERR_DUP:

    snprintf(errmsg, errmsg_len,

       "duplicate config");

    break;

  default:

    snprintf(errmsg, errmsg_len,

       "ssm range config failed");

  }

  return ret;

}

static int pim_rp_cmd_worker(struct pim_instance *pim, pim_addr rp_addr,

           struct prefix group, const char *plist,

           char *errmsg, size_t errmsg_len)

{

  int result;

  result = pim_rp_new(pim, rp_addr, group, plist, RP_SRC_STATIC);

  if (result == PIM_RP_NO_PATH) {

    snprintfrr(errmsg, errmsg_len,

         "No Path to RP address specified: %pPA", &rp_addr);

    return NB_ERR_INCONSISTENCY;

  }

  if (result == PIM_GROUP_OVERLAP) {

    snprintf(errmsg, errmsg_len,

       "Group range specified cannot exact match another");

    return NB_ERR_INCONSISTENCY;

  }

  if (result == PIM_GROUP_PFXLIST_OVERLAP) {

    snprintf(errmsg, errmsg_len,

       "This group is already covered by a RP prefix-list");

    return NB_ERR_INCONSISTENCY;

  }

  if (result == PIM_RP_PFXLIST_IN_USE) {

    snprintf(errmsg, errmsg_len,

       "The same prefix-list cannot be applied to multiple RPs");

    return NB_ERR_INCONSISTENCY;

  }

  return NB_OK;

}

static int pim_no_rp_cmd_worker(struct pim_instance *pim, pim_addr rp_addr,

        struct prefix group, const char *plist,

        char *errmsg, size_t errmsg_len)

{

  char group_str[PREFIX2STR_BUFFER];

  int result;

  prefix2str(&group, group_str, sizeof(group_str));

  result = pim_rp_del(pim, rp_addr, group, plist, RP_SRC_STATIC);

  if (result == PIM_GROUP_BAD_ADDRESS) {

    snprintf(errmsg, errmsg_len,

       "Bad group address specified: %s", group_str);

    return NB_ERR_INCONSISTENCY;

  }

  if (result == PIM_RP_BAD_ADDRESS) {

    snprintfrr(errmsg, errmsg_len, "Bad RP address specified: %pPA",

         &rp_addr);

    return NB_ERR_INCONSISTENCY;

  }

  if (result == PIM_RP_NOT_FOUND) {

    snprintf(errmsg, errmsg_len,

       "Unable to find specified RP");

    return NB_ERR_INCONSISTENCY;

  }

  return NB_OK;

}

static bool is_pim_interface(const struct lyd_node *dnode)

{

  char if_xpath[XPATH_MAXLEN];

  const struct lyd_node *pim_enable_dnode;

  const struct lyd_node *igmp_enable_dnode;

  yang_dnode_get_path(dnode, if_xpath, sizeof(if_xpath));

  pim_enable_dnode =

    yang_dnode_getf(dnode,

        "%s/frr-pim:pim/address-family[address-family='%s']/pim-enable",

        if_xpath, FRR_PIM_AF_XPATH_VAL);

  igmp_enable_dnode = yang_dnode_getf(dnode,

      "%s/frr-gmp:gmp/address-family[address-family='%s']/enable",

      if_xpath, FRR_PIM_AF_XPATH_VAL);

  if (((pim_enable_dnode) &&

       (yang_dnode_get_bool(pim_enable_dnode, "."))) ||

       ((igmp_enable_dnode) &&

       (yang_dnode_get_bool(igmp_enable_dnode, "."))))

    return true;

  return false;

}

static int pim_cmd_gm_start(struct interface *ifp)

{

  struct pim_interface *pim_ifp;

  uint8_t need_startup = 0;

  pim_ifp = ifp->info;

  if (!pim_ifp) {

    pim_ifp = pim_if_new(ifp, true, false, false, false);

    need_startup = 1;

  } else {

    if (!pim_ifp->gm_enable) {

      pim_ifp->gm_enable = true;

      need_startup = 1;

    }

  }

  pim_if_create_pimreg(pim_ifp->pim);

  /* 'ip igmp' executed multiple times, with need_startup

   * avoid multiple if add all and membership refresh

   */

  if (need_startup) {

    pim_if_addr_add_all(ifp);

    pim_if_membership_refresh(ifp);

  }

  return NB_OK;

}

/*

 * CLI reconfiguration affects the interface level (struct pim_interface).

 * This function propagates the reconfiguration to every active socket

 * for that interface.

 */

#if PIM_IPV == 4

static void igmp_sock_query_interval_reconfig(struct gm_sock *igmp)

{

  struct interface *ifp;

  struct pim_interface *pim_ifp;

  assert(igmp);

  assert(igmp->interface);

  assert(igmp->interface->info);

  ifp = igmp->interface;

  pim_ifp = ifp->info;

  if (PIM_DEBUG_GM_TRACE)

    zlog_debug("%s: Querier %pPAs on %s reconfig query_interval=%d",

         __func__, &igmp->ifaddr, ifp->name,

         pim_ifp->gm_default_query_interval);

  /*

   * igmp_startup_mode_on() will reset QQI:

   * igmp->querier_query_interval = pim_ifp->gm_default_query_interval;

   */

  igmp_startup_mode_on(igmp);

}

static void igmp_sock_query_reschedule(struct gm_sock *igmp)

{

  if (igmp->mtrace_only)

    return;

  if (igmp->t_igmp_query_timer) {

    /* other querier present */

    assert(igmp->t_igmp_query_timer);

    assert(!igmp->t_other_querier_timer);

    pim_igmp_general_query_off(igmp);

    pim_igmp_general_query_on(igmp);

    assert(igmp->t_igmp_query_timer);

    assert(!igmp->t_other_querier_timer);

  } else {

    /* this is the querier */

    assert(!igmp->t_igmp_query_timer);

    assert(igmp->t_other_querier_timer);

    pim_igmp_other_querier_timer_off(igmp);

    pim_igmp_other_querier_timer_on(igmp);

    assert(!igmp->t_igmp_query_timer);

    assert(igmp->t_other_querier_timer);

  }

}

#endif /* PIM_IPV == 4 */

#if PIM_IPV == 4

static void change_query_interval(struct pim_interface *pim_ifp,

    int query_interval)

{

  struct listnode *sock_node;

  struct gm_sock *igmp;

  pim_ifp->gm_default_query_interval = query_interval;

  for (ALL_LIST_ELEMENTS_RO(pim_ifp->gm_socket_list, sock_node, igmp)) {

    igmp_sock_query_interval_reconfig(igmp);

    igmp_sock_query_reschedule(igmp);

  }

}

#endif

static void change_query_max_response_time(struct interface *ifp,

             int query_max_response_time_dsec)

{

#if PIM_IPV == 4

  struct listnode *sock_node;

  struct gm_sock *igmp;

  struct listnode *grp_node;

  struct gm_group *grp;

#endif

  struct pim_interface *pim_ifp = ifp->info;

  if (pim_ifp->gm_query_max_response_time_dsec ==

      query_max_response_time_dsec)

    return;

  pim_ifp->gm_query_max_response_time_dsec = query_max_response_time_dsec;

#if PIM_IPV == 6

  gm_ifp_update(ifp);

#else

  /*

   * Below we modify socket/group/source timers in order to quickly

   * reflect the change. Otherwise, those timers would args->eventually

   * catch up.

   */

  /* scan all sockets */

  for (ALL_LIST_ELEMENTS_RO(pim_ifp->gm_socket_list, sock_node, igmp)) {

    /* reschedule socket general query */

    igmp_sock_query_reschedule(igmp);

  }

  /* scan socket groups */

  for (ALL_LIST_ELEMENTS_RO(pim_ifp->gm_group_list, grp_node, grp)) {

    struct listnode *src_node;

    struct gm_source *src;

    /* reset group timers for groups in EXCLUDE mode */

    if (grp->group_filtermode_isexcl)

      igmp_group_reset_gmi(grp);

    /* scan group sources */

    for (ALL_LIST_ELEMENTS_RO(grp->group_source_list, src_node,

            src)) {

      /* reset source timers for sources with running

       * timers

       */

      if (src->t_source_timer)

        igmp_source_reset_gmi(grp, src);

    }

  }

#endif /* PIM_IPV == 4 */

}

int routing_control_plane_protocols_name_validate(

  struct nb_cb_create_args *args)

{

  const char *name;

  name = yang_dnode_get_string(args->dnode, "./name");

  if (!strmatch(name, "pim")) {

    snprintf(args->errmsg, args->errmsg_len,

        "pim supports only one instance with name pimd");

    return NB_ERR_VALIDATION;

  }

  return NB_OK;

}

/*

 * XPath: /frr-pim:pim/address-family

 */

int pim_address_family_create(struct nb_cb_create_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

int pim_address_family_destroy(struct nb_cb_destroy_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-pim:pim/address-family/packets

 */

int pim_address_family_packets_modify(struct nb_cb_modify_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    router->packet_process = yang_dnode_get_uint8(args->dnode,

        NULL);

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-pim:pim/address-family/join-prune-interval

 */

int pim_address_family_join_prune_interval_modify(

  struct nb_cb_modify_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    router->t_periodic = yang_dnode_get_uint16(args->dnode, NULL);

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-pim:pim/address-family/register-suppress-time

 */

int pim_address_family_register_suppress_time_modify(

  struct nb_cb_modify_args *args)

{

  uint16_t value;

  switch (args->event) {

  case NB_EV_VALIDATE:

    value = yang_dnode_get_uint16(args->dnode, NULL);

    /*

     * As soon as this is non-constant it needs to be replaced with

     * a yang_dnode_get to lookup the candidate value, *not* the

     * operational value. Since the code has a field assigned and

     * used for this value it should have YANG/CLI to set it too,

     * otherwise just use the #define!

     */

    /* RFC7761: 4.11.  Timer Values */

    if (value <= router->register_probe_time * 2) {

      snprintf(

        args->errmsg, args->errmsg_len,

        "Register suppress time (%u) must be more than "

        "twice the register probe time (%u).",

        value, router->register_probe_time);

      return NB_ERR_VALIDATION;

    }

    break;

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    pim_update_suppress_timers(

      yang_dnode_get_uint16(args->dnode, NULL));

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/ecmp

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_ecmp_modify(

  struct nb_cb_modify_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    vrf = nb_running_get_entry(args->dnode, NULL, true);

    pim = vrf->info;

    pim->ecmp_enable = yang_dnode_get_bool(args->dnode, NULL);

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/ecmp-rebalance

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_ecmp_rebalance_modify(

  struct nb_cb_modify_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    vrf = nb_running_get_entry(args->dnode, NULL, true);

    pim = vrf->info;

    pim->ecmp_rebalance_enable =

      yang_dnode_get_bool(args->dnode, NULL);

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/keep-alive-timer

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_keep_alive_timer_modify(

  struct nb_cb_modify_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    vrf = nb_running_get_entry(args->dnode, NULL, true);

    pim = vrf->info;

    pim->keep_alive_time = yang_dnode_get_uint16(args->dnode, NULL);

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/rp-keep-alive-timer

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_rp_keep_alive_timer_modify(

  struct nb_cb_modify_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    vrf = nb_running_get_entry(args->dnode, NULL, true);

    pim = vrf->info;

    pim->rp_keep_alive_time = yang_dnode_get_uint16(args->dnode,

        NULL);

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_create(

  struct nb_cb_create_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_destroy(

  struct nb_cb_destroy_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/send-v6-secondary

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_send_v6_secondary_modify(

  struct nb_cb_modify_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    vrf = nb_running_get_entry(args->dnode, NULL, true);

    pim = vrf->info;

    pim->send_v6_secondary = yang_dnode_get_bool(args->dnode, NULL);

    break;

  }

  return NB_OK;

}

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_send_v6_secondary_destroy(

  struct nb_cb_destroy_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

/*

 * XPath:

 * /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/spt-switchover

 */

void routing_control_plane_protocols_control_plane_protocol_pim_address_family_spt_switchover_apply_finish(

  struct nb_cb_apply_finish_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  int spt_switch_action;

  const char *prefix_list = NULL;

  vrf = nb_running_get_entry(args->dnode, NULL, true);

  pim = vrf->info;

  spt_switch_action = yang_dnode_get_enum(args->dnode, "./spt-action");

  switch (spt_switch_action) {

  case PIM_SPT_INFINITY:

    if (yang_dnode_exists(args->dnode,

              "./spt-infinity-prefix-list"))

      prefix_list = yang_dnode_get_string(

        args->dnode, "./spt-infinity-prefix-list");

    pim_cmd_spt_switchover(pim, PIM_SPT_INFINITY,

          prefix_list);

    break;

  case PIM_SPT_IMMEDIATE:

    pim_cmd_spt_switchover(pim, PIM_SPT_IMMEDIATE, NULL);

  }

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/spt-switchover/spt-action

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_spt_switchover_spt_action_modify(

  struct nb_cb_modify_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/spt-switchover/spt-infinity-prefix-list

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_spt_switchover_spt_infinity_prefix_list_modify(

  struct nb_cb_modify_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_spt_switchover_spt_infinity_prefix_list_destroy(

  struct nb_cb_destroy_args *args)

{

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

  case NB_EV_APPLY:

    break;

  }

  return NB_OK;

}

/*

 * XPath: /frr-routing:routing/control-plane-protocols/control-plane-protocol/frr-pim:pim/address-family/ssm-prefix-list

 */

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_ssm_prefix_list_modify(

  struct nb_cb_modify_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  const char *plist_name;

  int result;

  switch (args->event) {

  case NB_EV_VALIDATE:

  case NB_EV_PREPARE:

  case NB_EV_ABORT:

    break;

  case NB_EV_APPLY:

    vrf = nb_running_get_entry(args->dnode, NULL, true);

    pim = vrf->info;

    plist_name = yang_dnode_get_string(args->dnode, NULL);

    result = pim_ssm_cmd_worker(pim, plist_name, args->errmsg,

        args->errmsg_len);

    if (result)

      return NB_ERR_INCONSISTENCY;

    break;

  }

  return NB_OK;

}

int routing_control_plane_protocols_control_plane_protocol_pim_address_family_ssm_prefix_list_destroy(

  struct nb_cb_destroy_args *args)

{

  struct vrf *vrf;

  struct pim_instance *pim;

  int result;

  switch (args->event) {