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

/*

 * PIM for Quagga

 * Copyright (C) 2008  Everton da Silva Marques

 */

#include <zebra.h>

#include "log.h"

#include "memory.h"

#include "linklist.h"

#include "if.h"

#include "hash.h"

#include "jhash.h"

#include "pimd.h"

#include "pim_oil.h"

#include "pim_str.h"

#include "pim_iface.h"

#include "pim_time.h"

#include "pim_vxlan.h"

static void pim_channel_update_mute(struct channel_oil *c_oil);

char *pim_channel_oil_dump(struct channel_oil *c_oil, char *buf, size_t size)

{

  char *out;

  struct interface *ifp;

  pim_sgaddr sg;

  int i;

  sg.src = *oil_origin(c_oil);

  sg.grp = *oil_mcastgrp(c_oil);

  ifp = pim_if_find_by_vif_index(c_oil->pim, *oil_parent(c_oil));

  snprintfrr(buf, size, "%pSG IIF: %s, OIFS: ", &sg,

       ifp ? ifp->name : "(?)");

  out = buf + strlen(buf);

  for (i = 0; i < MAXVIFS; i++) {

    if (oil_if_has(c_oil, i) != 0) {

      ifp = pim_if_find_by_vif_index(c_oil->pim, i);

      snprintf(out, buf + size - out, "%s ",

         ifp ? ifp->name : "(?)");

      out += strlen(out);

    }

  }

  return buf;

}

int pim_channel_oil_compare(const struct channel_oil *cc1,

          const struct channel_oil *cc2)

{

  struct channel_oil *c1 = (struct channel_oil *)cc1;

  struct channel_oil *c2 = (struct channel_oil *)cc2;

  int rv;

  rv = pim_addr_cmp(*oil_mcastgrp(c1), *oil_mcastgrp(c2));

  if (rv)

    return rv;

  rv = pim_addr_cmp(*oil_origin(c1), *oil_origin(c2));

  if (rv)

    return rv;

  return 0;

}

void pim_oil_init(struct pim_instance *pim)

{

  rb_pim_oil_init(&pim->channel_oil_head);

}

void pim_oil_terminate(struct pim_instance *pim)

{

  struct channel_oil *c_oil;

  while ((c_oil = rb_pim_oil_pop(&pim->channel_oil_head)))

    pim_channel_oil_free(c_oil);

  rb_pim_oil_fini(&pim->channel_oil_head);

}

void pim_channel_oil_free(struct channel_oil *c_oil)

{

  XFREE(MTYPE_PIM_CHANNEL_OIL, c_oil);

}

struct channel_oil *pim_find_channel_oil(struct pim_instance *pim,

           pim_sgaddr *sg)

{

  struct channel_oil *c_oil = NULL;

  struct channel_oil lookup;

  *oil_mcastgrp(&lookup) = sg->grp;

  *oil_origin(&lookup) = sg->src;

  c_oil = rb_pim_oil_find(&pim->channel_oil_head, &lookup);

  return c_oil;

}

struct channel_oil *pim_channel_oil_add(struct pim_instance *pim,

          pim_sgaddr *sg, const char *name)

{

  struct channel_oil *c_oil;

  c_oil = pim_find_channel_oil(pim, sg);

  if (c_oil) {

    ++c_oil->oil_ref_count;

    if (!c_oil->up) {

      /* channel might be present prior to upstream */

      c_oil->up = pim_upstream_find(

          pim, sg);

      /* if the upstream entry is being anchored to an

       * already existing channel OIL we need to re-evaluate

       * the "Mute" state on AA OIFs

       */

      pim_channel_update_mute(c_oil);

    }

    /* check if the IIF has changed

     * XXX - is this really needed

     */

    pim_upstream_mroute_iif_update(c_oil, __func__);

    if (PIM_DEBUG_MROUTE)

      zlog_debug(

        "%s(%s): Existing oil for %pSG Ref Count: %d (Post Increment)",

        __func__, name, sg, c_oil->oil_ref_count);

    return c_oil;

  }

  c_oil = XCALLOC(MTYPE_PIM_CHANNEL_OIL, sizeof(*c_oil));

  *oil_mcastgrp(c_oil) = sg->grp;

  *oil_origin(c_oil) = sg->src;

  *oil_parent(c_oil) = MAXVIFS;

  c_oil->oil_ref_count = 1;

  c_oil->installed = 0;

  c_oil->up = pim_upstream_find(pim, sg);

  c_oil->pim = pim;

  rb_pim_oil_add(&pim->channel_oil_head, c_oil);

  if (PIM_DEBUG_MROUTE)

    zlog_debug("%s(%s): c_oil %pSG add", __func__, name, sg);

  return c_oil;

}

/*

 * Clean up mroute and channel oil created for dropping pkts from directly

 * connected source when the interface was non DR.

 */

void pim_clear_nocache_state(struct pim_interface *pim_ifp)

{

  struct channel_oil *c_oil;

  frr_each_safe (rb_pim_oil, &pim_ifp->pim->channel_oil_head, c_oil) {

    if ((!c_oil->up) ||

        !(PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(c_oil->up->flags)))

      continue;

    if (*oil_parent(c_oil) != pim_ifp->mroute_vif_index)

      continue;

    EVENT_OFF(c_oil->up->t_ka_timer);

    PIM_UPSTREAM_FLAG_UNSET_SRC_NOCACHE(c_oil->up->flags);

    PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(c_oil->up->flags);

    pim_upstream_del(pim_ifp->pim, c_oil->up, __func__);

  }

}

struct channel_oil *pim_channel_oil_del(struct channel_oil *c_oil,

          const char *name)

{

  if (PIM_DEBUG_MROUTE) {

    pim_sgaddr sg = {.src = *oil_origin(c_oil),

         .grp = *oil_mcastgrp(c_oil)};

    zlog_debug(

      "%s(%s): Del oil for %pSG, Ref Count: %d (Predecrement)",

      __func__, name, &sg, c_oil->oil_ref_count);

  }

  --c_oil->oil_ref_count;

  if (c_oil->oil_ref_count < 1) {

    /*

     * notice that listnode_delete() can't be moved

     * into pim_channel_oil_free() because the later is

     * called by list_delete_all_node()

     */

    c_oil->up = NULL;

    rb_pim_oil_del(&c_oil->pim->channel_oil_head, c_oil);

    pim_channel_oil_free(c_oil);

    return NULL;

  }

  return c_oil;

}

void pim_channel_oil_upstream_deref(struct channel_oil *c_oil)

{

  /* The upstream entry associated with a channel_oil is abt to be

   * deleted. If the channel_oil is kept around because of other

   * references we need to remove upstream based states out of it.

   */

  c_oil = pim_channel_oil_del(c_oil, __func__);

  if (c_oil) {

    /* note: here we assume that c_oil->up has already been

     * cleared

     */

    pim_channel_update_mute(c_oil);

  }

}

int pim_channel_del_oif(struct channel_oil *channel_oil, struct interface *oif,

      uint32_t proto_mask, const char *caller)

{

  struct pim_interface *pim_ifp;

  assert(channel_oil);

  assert(oif);

  pim_ifp = oif->info;

  assertf(pim_ifp->mroute_vif_index >= 0,

    "trying to del OIF %s with VIF (%d)", oif->name,

    pim_ifp->mroute_vif_index);

  /*

   * Don't do anything if we've been asked to remove a source

   * that is not actually on it.

   */

  if (!(channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask)) {

    if (PIM_DEBUG_MROUTE) {

      zlog_debug(

        "%s %s: no existing protocol mask %u(%u) for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",

        __FILE__, __func__, proto_mask,

        channel_oil

          ->oif_flags[pim_ifp->mroute_vif_index],

        oif->name, pim_ifp->mroute_vif_index,

        oil_if_has(channel_oil, pim_ifp->mroute_vif_index),

        oil_origin(channel_oil),

        oil_mcastgrp(channel_oil));

    }

    return 0;

  }

  channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~proto_mask;

  if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] &

      PIM_OIF_FLAG_PROTO_ANY) {

    if (PIM_DEBUG_MROUTE) {

      zlog_debug(

        "%s %s: other protocol masks remain for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",

        __FILE__, __func__, oif->name,

        pim_ifp->mroute_vif_index,

        oil_if_has(channel_oil, pim_ifp->mroute_vif_index),

        oil_origin(channel_oil),

        oil_mcastgrp(channel_oil));

    }

    return 0;

  }

  oil_if_set(channel_oil, pim_ifp->mroute_vif_index, 0);

  /* clear mute; will be re-evaluated when the OIF becomes valid again */

  channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~PIM_OIF_FLAG_MUTE;

  if (pim_upstream_mroute_add(channel_oil, __func__)) {

    if (PIM_DEBUG_MROUTE) {

      zlog_debug(

        "%s %s: could not remove output interface %s (vif_index=%d) for channel (S,G)=(%pPAs,%pPAs)",

        __FILE__, __func__, oif->name,

        pim_ifp->mroute_vif_index,

        oil_origin(channel_oil),

        oil_mcastgrp(channel_oil));

    }

    return -1;

  }

  --channel_oil->oil_size;

  if (PIM_DEBUG_MROUTE) {

    zlog_debug(

      "%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u IIF:%d OIF=%s vif_index=%d",

      __func__, caller, oil_origin(channel_oil),

      oil_mcastgrp(channel_oil),

      proto_mask,

      *oil_parent(channel_oil), oif->name,

      pim_ifp->mroute_vif_index);

  }

  return 0;

}

void pim_channel_del_inherited_oif(struct channel_oil *c_oil,

    struct interface *oif, const char *caller)

{

  struct pim_upstream *up = c_oil->up;

  pim_channel_del_oif(c_oil, oif, PIM_OIF_FLAG_PROTO_STAR,

      caller);

  /* if an inherited OIF is being removed join-desired can change

   * if the inherited OIL is now empty and KAT is running

   */

  if (up && !pim_addr_is_any(up->sg.src) &&

      pim_upstream_empty_inherited_olist(up))

    pim_upstream_update_join_desired(up->pim, up);

}

static bool pim_channel_eval_oif_mute(struct channel_oil *c_oil,

    struct pim_interface *pim_ifp)

{

  struct pim_interface *pim_reg_ifp;

  struct pim_interface *vxlan_ifp;

  bool do_mute = false;

  struct pim_instance *pim = c_oil->pim;

  if (!c_oil->up)

    return do_mute;

  pim_reg_ifp = pim->regiface->info;

  if (pim_ifp == pim_reg_ifp) {

    /* suppress pimreg in the OIL if the mroute is not supposed to

     * trigger register encapsulated data

     */

    if (PIM_UPSTREAM_FLAG_TEST_NO_PIMREG_DATA(c_oil->up->flags))

      do_mute = true;

    return do_mute;

  }

  vxlan_ifp = pim_vxlan_get_term_ifp(pim);

  if (pim_ifp == vxlan_ifp) {

    /* 1. vxlan termination device must never be added to the

     * origination mroute (and that can actually happen because

     * of XG inheritance from the termination mroute) otherwise

     * traffic will end up looping.

     * PS: This check has also been extended to non-orig mroutes

     * that have a local SIP as such mroutes can move back and

     * forth between orig<=>non-orig type.

     * 2. vxlan termination device should be removed from the non-DF

     * to prevent duplicates to the overlay rxer

     */

    if (PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_ORIG(c_oil->up->flags) ||

      PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(c_oil->up->flags) ||

      pim_vxlan_is_local_sip(c_oil->up))

      do_mute = true;

    return do_mute;

  }

  if (PIM_I_am_DualActive(pim_ifp)) {

    struct pim_upstream *starup = c_oil->up->parent;

    if (PIM_UPSTREAM_FLAG_TEST_MLAG_INTERFACE(c_oil->up->flags)

        && (PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(c_oil->up->flags)))

      do_mute = true;

    /* In case entry is (S,G), Negotiation happens at (*.G) */

    if (starup

        && PIM_UPSTREAM_FLAG_TEST_MLAG_INTERFACE(starup->flags)

        && (PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(starup->flags)))

      do_mute = true;

    return do_mute;

  }

  return do_mute;

}

void pim_channel_update_oif_mute(struct channel_oil *c_oil,

    struct pim_interface *pim_ifp)

{

  bool old_mute;

  bool new_mute;

  /* If pim_ifp is not a part of the OIL there is nothing to do */

  if (!oil_if_has(c_oil, pim_ifp->mroute_vif_index))

    return;

  old_mute = !!(c_oil->oif_flags[pim_ifp->mroute_vif_index] &

      PIM_OIF_FLAG_MUTE);

  new_mute = pim_channel_eval_oif_mute(c_oil, pim_ifp);

  if (old_mute == new_mute)

    return;

  if (new_mute)

    c_oil->oif_flags[pim_ifp->mroute_vif_index] |=

      PIM_OIF_FLAG_MUTE;

  else

    c_oil->oif_flags[pim_ifp->mroute_vif_index] &=

      ~PIM_OIF_FLAG_MUTE;

  pim_upstream_mroute_add(c_oil, __func__);

}

/* pim_upstream has been set or cleared on the c_oil. re-eval mute state

 * on all existing OIFs

 */

static void pim_channel_update_mute(struct channel_oil *c_oil)

{

  struct pim_interface *pim_reg_ifp;

  struct pim_interface *vxlan_ifp;

  if (c_oil->pim->regiface) {

    pim_reg_ifp = c_oil->pim->regiface->info;

    if (pim_reg_ifp)

      pim_channel_update_oif_mute(c_oil, pim_reg_ifp);

  }

  vxlan_ifp = pim_vxlan_get_term_ifp(c_oil->pim);

  if (vxlan_ifp)

    pim_channel_update_oif_mute(c_oil, vxlan_ifp);

}

int pim_channel_add_oif(struct channel_oil *channel_oil, struct interface *oif,

      uint32_t proto_mask, const char *caller)

{

  struct pim_interface *pim_ifp;

  int old_ttl;

  /*

   * If we've gotten here we've gone bad, but let's

   * not take down pim

   */

  if (!channel_oil) {

    zlog_warn("Attempt to Add OIF for non-existent channel oil");

    return -1;

  }

  pim_ifp = oif->info;

  assertf(pim_ifp->mroute_vif_index >= 0,

    "trying to add OIF %s with VIF (%d)", oif->name,

    pim_ifp->mroute_vif_index);

  /* Prevent single protocol from subscribing same interface to

     channel (S,G) multiple times */

  if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask) {

    channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;

    if (PIM_DEBUG_MROUTE) {

      zlog_debug(

        "%s %s: existing protocol mask %u requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",

        __FILE__, __func__, proto_mask, oif->name,

        pim_ifp->mroute_vif_index,

        oil_if_has(channel_oil, pim_ifp->mroute_vif_index),

        oil_origin(channel_oil),

        oil_mcastgrp(channel_oil));

    }

    return -3;

  }

  /* Allow other protocol to request subscription of same interface to

   * channel (S,G), we need to note this information

   */

  if (channel_oil->oif_flags[pim_ifp->mroute_vif_index]

      & PIM_OIF_FLAG_PROTO_ANY) {

    /* Updating time here is not required as this time has to

     * indicate when the interface is added

     */

    channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;

    /* Check the OIF really exists before returning, and only log

       warning otherwise */

    if (oil_if_has(channel_oil, pim_ifp->mroute_vif_index) < 1) {

      zlog_warn(

        "%s %s: new protocol mask %u requested nonexistent OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",

        __FILE__, __func__, proto_mask, oif->name,

        pim_ifp->mroute_vif_index,

        oil_if_has(channel_oil, pim_ifp->mroute_vif_index),

        oil_origin(channel_oil),

        oil_mcastgrp(channel_oil));

    }

    if (PIM_DEBUG_MROUTE) {

      zlog_debug(

        "%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u OIF=%s vif_index=%d added to 0x%x",

        __func__, caller, oil_origin(channel_oil),

        oil_mcastgrp(channel_oil),

        proto_mask, oif->name,

        pim_ifp->mroute_vif_index,

        channel_oil

          ->oif_flags[pim_ifp->mroute_vif_index]);

    }

    return 0;

  }

  old_ttl = oil_if_has(channel_oil, pim_ifp->mroute_vif_index);

  if (old_ttl > 0) {

    if (PIM_DEBUG_MROUTE) {

      zlog_debug(

        "%s %s: interface %s (vif_index=%d) is existing output for channel (S,G)=(%pPAs,%pPAs)",

        __FILE__, __func__, oif->name,

        pim_ifp->mroute_vif_index,

        oil_origin(channel_oil),

        oil_mcastgrp(channel_oil));

    }

    return -4;

  }

  oil_if_set(channel_oil, pim_ifp->mroute_vif_index, PIM_MROUTE_MIN_TTL);

  /* Some OIFs are held in a muted state i.e. the PIM state machine

   * decided to include the OIF but additional status check such as

   * MLAG DF role prevent it from being activated for traffic

   * forwarding.

   */

  if (pim_channel_eval_oif_mute(channel_oil, pim_ifp))

    channel_oil->oif_flags[pim_ifp->mroute_vif_index] |=

      PIM_OIF_FLAG_MUTE;

  else

    channel_oil->oif_flags[pim_ifp->mroute_vif_index] &=

      ~PIM_OIF_FLAG_MUTE;

  /* channel_oil->oil.mfcc_parent != MAXVIFS indicate this entry is not

   * valid to get installed in kernel.

   */

  if (*oil_parent(channel_oil) != MAXVIFS) {

    if (pim_upstream_mroute_add(channel_oil, __func__)) {

      if (PIM_DEBUG_MROUTE) {

        zlog_debug(

          "%s %s: could not add output interface %s (vif_index=%d) for channel (S,G)=(%pPAs,%pPAs)",

          __FILE__, __func__, oif->name,

          pim_ifp->mroute_vif_index,

          oil_origin(channel_oil),

          oil_mcastgrp(channel_oil));

      }

      oil_if_set(channel_oil, pim_ifp->mroute_vif_index,

           old_ttl);

      return -5;

    }

  }

  channel_oil->oif_creation[pim_ifp->mroute_vif_index] =

    pim_time_monotonic_sec();

  ++channel_oil->oil_size;

  channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;

  if (PIM_DEBUG_MROUTE) {

    zlog_debug(

      "%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u OIF=%s vif_index=%d: DONE",

      __func__, caller, oil_origin(channel_oil),

      oil_mcastgrp(channel_oil),

      proto_mask,

      oif->name, pim_ifp->mroute_vif_index);

  }

  return 0;

}

int pim_channel_oil_empty(struct channel_oil *c_oil)

{

  static struct channel_oil null_oil;

  if (!c_oil)

    return 1;

  /* exclude pimreg from the OIL when checking if the inherited_oil is

   * non-NULL.

   * pimreg device (in all vrfs) uses a vifi of

   * 0 (PIM_OIF_PIM_REGISTER_VIF) so we simply mfcc_ttls[0] */

  if (oil_if_has(c_oil, 0))

    oil_if_set(&null_oil, 0, 1);

  else

    oil_if_set(&null_oil, 0, 0);

  return !oil_if_cmp(&c_oil->oil, &null_oil.oil);

}