// 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 "if.h"

#include "pimd.h"

#include "pim_instance.h"

#include "pim_pim.h"

#include "pim_str.h"

#include "pim_tlv.h"

#include "pim_util.h"

#include "pim_hello.h"

#include "pim_iface.h"

#include "pim_neighbor.h"

#include "pim_upstream.h"

#include "pim_bsm.h"

static void on_trace(const char *label, struct interface *ifp, pim_addr src)

{

  if (PIM_DEBUG_PIM_TRACE)

    zlog_debug("%s: from %pPAs on %s", label, &src, ifp->name);

}

static void tlv_trace_bool(const char *label, const char *tlv_name,

         const char *ifname, pim_addr src_addr, int isset,

         int value)

{

  if (isset)

    zlog_debug(

      "%s: PIM hello option from %pPAs on interface %s: %s=%d",

      label, &src_addr, ifname, tlv_name, value);

}

static void tlv_trace_uint16(const char *label, const char *tlv_name,

           const char *ifname, pim_addr src_addr, int isset,

           uint16_t value)

{

  if (isset)

    zlog_debug(

      "%s: PIM hello option from %pPAs on interface %s: %s=%u",

      label, &src_addr, ifname, tlv_name, value);

}

static void tlv_trace_uint32(const char *label, const char *tlv_name,

           const char *ifname, pim_addr src_addr, int isset,

           uint32_t value)

{

  if (isset)

    zlog_debug(

      "%s: PIM hello option from %pPAs on interface %s: %s=%u",

      label, &src_addr, ifname, tlv_name, value);

}

static void tlv_trace_uint32_hex(const char *label, const char *tlv_name,

         const char *ifname, pim_addr src_addr,

         int isset, uint32_t value)

{

  if (isset)

    zlog_debug(

      "%s: PIM hello option from %pPAs on interface %s: %s=%08x",

      label, &src_addr, ifname, tlv_name, value);

}

static void tlv_trace_list(const char *label, const char *tlv_name,

         const char *ifname, pim_addr src_addr, int isset,

         struct list *addr_list)

{

  if (isset)

    zlog_debug(

      "%s: PIM hello option from %pPAs on interface %s: %s size=%d list=%p",

      label, &src_addr, ifname, tlv_name,

      addr_list ? ((int)listcount(addr_list)) : -1,

      (void *)addr_list);

}

#define FREE_ADDR_LIST                                                         \

  if (hello_option_addr_list) {                                          \

    list_delete(&hello_option_addr_list);                          \

  }

#define FREE_ADDR_LIST_THEN_RETURN(code)                                       \

  {                                                                      \

    FREE_ADDR_LIST                                                 \

    return (code);                                                 \

  }

int pim_hello_recv(struct interface *ifp, pim_addr src_addr, uint8_t *tlv_buf,

       int tlv_buf_size)

{

  struct pim_interface *pim_ifp;

  struct pim_neighbor *neigh;

  uint8_t *tlv_curr;

  uint8_t *tlv_pastend;

  pim_hello_options hello_options =

    0; /* bit array recording options found */

  uint16_t hello_option_holdtime = 0;

  uint16_t hello_option_propagation_delay = 0;

  uint16_t hello_option_override_interval = 0;

  uint32_t hello_option_dr_priority = 0;

  uint32_t hello_option_generation_id = 0;

  struct list *hello_option_addr_list = 0;

  if (PIM_DEBUG_PIM_HELLO)

    on_trace(__func__, ifp, src_addr);

  pim_ifp = ifp->info;

  assert(pim_ifp);

  if (pim_ifp->pim_passive_enable) {

    if (PIM_DEBUG_PIM_PACKETS)

      zlog_debug(

        "skip receiving PIM message on passive interface %s",

        ifp->name);

    return 0;

  }

  ++pim_ifp->pim_ifstat_hello_recv;

  /*

    Parse PIM hello TLVs

   */

  assert(tlv_buf_size >= 0);

  tlv_curr = tlv_buf;

  tlv_pastend = tlv_buf + tlv_buf_size;

  while (tlv_curr < tlv_pastend) {

    uint16_t option_type;

    uint16_t option_len;

    int remain = tlv_pastend - tlv_curr;

    if (remain < PIM_TLV_MIN_SIZE) {

      if (PIM_DEBUG_PIM_HELLO)

        zlog_debug(

          "%s: short PIM hello TLV size=%d < min=%d from %pPAs on interface %s",

          __func__, remain, PIM_TLV_MIN_SIZE,

          &src_addr, ifp->name);

      FREE_ADDR_LIST_THEN_RETURN(-1);

    }

    option_type = PIM_TLV_GET_TYPE(tlv_curr);

    tlv_curr += PIM_TLV_TYPE_SIZE;

    option_len = PIM_TLV_GET_LENGTH(tlv_curr);

    tlv_curr += PIM_TLV_LENGTH_SIZE;

    if ((tlv_curr + option_len) > tlv_pastend) {

      if (PIM_DEBUG_PIM_HELLO)

        zlog_debug(

          "%s: long PIM hello TLV type=%d length=%d > left=%td from %pPAs on interface %s",

          __func__, option_type, option_len,

          tlv_pastend - tlv_curr, &src_addr,

          ifp->name);

      FREE_ADDR_LIST_THEN_RETURN(-2);

    }

    if (PIM_DEBUG_PIM_HELLO)

      zlog_debug(

        "%s: parse left_size=%d: PIM hello TLV type=%d length=%d from %pPAs on %s",

        __func__, remain, option_type, option_len,

        &src_addr, ifp->name);

    switch (option_type) {

    case PIM_MSG_OPTION_TYPE_HOLDTIME:

      if (pim_tlv_parse_holdtime(ifp->name, src_addr,

               &hello_options,

               &hello_option_holdtime,

               option_len, tlv_curr)) {

        FREE_ADDR_LIST_THEN_RETURN(-3);

      }

      break;

    case PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY:

      if (pim_tlv_parse_lan_prune_delay(

            ifp->name, src_addr, &hello_options,

            &hello_option_propagation_delay,

            &hello_option_override_interval, option_len,

            tlv_curr)) {

        FREE_ADDR_LIST_THEN_RETURN(-4);

      }

      break;

    case PIM_MSG_OPTION_TYPE_DR_PRIORITY:

      if (pim_tlv_parse_dr_priority(ifp->name, src_addr,

                  &hello_options,

                  &hello_option_dr_priority,

                  option_len, tlv_curr)) {

        FREE_ADDR_LIST_THEN_RETURN(-5);

      }

      break;

    case PIM_MSG_OPTION_TYPE_GENERATION_ID:

      if (pim_tlv_parse_generation_id(

            ifp->name, src_addr, &hello_options,

            &hello_option_generation_id, option_len,

            tlv_curr)) {

        FREE_ADDR_LIST_THEN_RETURN(-6);

      }

      break;

    case PIM_MSG_OPTION_TYPE_ADDRESS_LIST:

      if (pim_tlv_parse_addr_list(ifp->name, src_addr,

                &hello_options,

                &hello_option_addr_list,

                option_len, tlv_curr)) {

        return -7;

      }

      break;

    case PIM_MSG_OPTION_TYPE_DM_STATE_REFRESH:

      if (PIM_DEBUG_PIM_HELLO)

        zlog_debug(

          "%s: ignoring PIM hello dense-mode state refresh TLV option type=%d length=%d from %pPAs on interface %s",

          __func__, option_type, option_len,

          &src_addr, ifp->name);

      break;

    default:

      if (PIM_DEBUG_PIM_HELLO)

        zlog_debug(

          "%s: ignoring unknown PIM hello TLV type=%d length=%d from %pPAs on interface %s",

          __func__, option_type, option_len,

          &src_addr, ifp->name);

    }

    tlv_curr += option_len;

  }

  /*

    Check received PIM hello options

  */

  if (PIM_DEBUG_PIM_HELLO) {

    tlv_trace_uint16(__func__, "holdtime", ifp->name, src_addr,

         PIM_OPTION_IS_SET(hello_options,

               PIM_OPTION_MASK_HOLDTIME),

         hello_option_holdtime);

    tlv_trace_uint16(

      __func__, "propagation_delay", ifp->name, src_addr,

      PIM_OPTION_IS_SET(hello_options,

            PIM_OPTION_MASK_LAN_PRUNE_DELAY),

      hello_option_propagation_delay);

    tlv_trace_uint16(

      __func__, "override_interval", ifp->name, src_addr,

      PIM_OPTION_IS_SET(hello_options,

            PIM_OPTION_MASK_LAN_PRUNE_DELAY),

      hello_option_override_interval);

    tlv_trace_bool(

      __func__, "can_disable_join_suppression", ifp->name,

      src_addr,

      PIM_OPTION_IS_SET(hello_options,

            PIM_OPTION_MASK_LAN_PRUNE_DELAY),

      PIM_OPTION_IS_SET(

        hello_options,

        PIM_OPTION_MASK_CAN_DISABLE_JOIN_SUPPRESSION));

    tlv_trace_uint32(__func__, "dr_priority", ifp->name, src_addr,

         PIM_OPTION_IS_SET(hello_options,

               PIM_OPTION_MASK_DR_PRIORITY),

         hello_option_dr_priority);

    tlv_trace_uint32_hex(

      __func__, "generation_id", ifp->name, src_addr,

      PIM_OPTION_IS_SET(hello_options,

            PIM_OPTION_MASK_GENERATION_ID),

      hello_option_generation_id);

    tlv_trace_list(__func__, "address_list", ifp->name, src_addr,

             PIM_OPTION_IS_SET(hello_options,

             PIM_OPTION_MASK_ADDRESS_LIST),

             hello_option_addr_list);

  }

  if (!PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME)) {

    if (PIM_DEBUG_PIM_HELLO)

      zlog_debug(

        "%s: PIM hello missing holdtime from %pPAs on interface %s",

        __func__, &src_addr, ifp->name);

  }

  /*

    New neighbor?

  */

  neigh = pim_neighbor_find(ifp, src_addr, false);

  if (!neigh) {

    /* Add as new neighbor */

    neigh = pim_neighbor_add(

      ifp, src_addr, hello_options, hello_option_holdtime,

      hello_option_propagation_delay,

      hello_option_override_interval,

      hello_option_dr_priority, hello_option_generation_id,

      hello_option_addr_list, PIM_NEIGHBOR_SEND_DELAY);

    if (!neigh) {

      if (PIM_DEBUG_PIM_HELLO)

        zlog_warn(

          "%s: failure creating PIM neighbor %pPAs on interface %s",

          __func__, &src_addr, ifp->name);

      FREE_ADDR_LIST_THEN_RETURN(-8);

    }

    /* Forward BSM if required */

    if (!pim_bsm_new_nbr_fwd(neigh, ifp)) {

      if (PIM_DEBUG_PIM_HELLO)

        zlog_debug(

          "%s: forwarding bsm to new nbr failed",

          __func__);

    }

    /* actual addr list has been saved under neighbor */

    return 0;

  }

  /*

    Received generation ID ?

  */

  if (PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID)) {

    /* GenID mismatch ? */

    if (!PIM_OPTION_IS_SET(neigh->hello_options,

               PIM_OPTION_MASK_GENERATION_ID)

        || (hello_option_generation_id != neigh->generation_id)) {

      /* GenID mismatch, then replace neighbor */

      if (PIM_DEBUG_PIM_HELLO)

        zlog_debug(

          "%s: GenId mismatch new=%08x old=%08x: replacing neighbor %pPAs on %s",

          __func__, hello_option_generation_id,

          neigh->generation_id, &src_addr,

          ifp->name);

      pim_upstream_rpf_genid_changed(pim_ifp->pim,

                   neigh->source_addr);

      pim_neighbor_delete(ifp, neigh, "GenID mismatch");

      neigh = pim_neighbor_add(ifp, src_addr, hello_options,

             hello_option_holdtime,

             hello_option_propagation_delay,

             hello_option_override_interval,

             hello_option_dr_priority,

             hello_option_generation_id,

             hello_option_addr_list,

             PIM_NEIGHBOR_SEND_NOW);

      if (!neigh) {

        if (PIM_DEBUG_PIM_HELLO)

          zlog_debug(

            "%s: failure re-creating PIM neighbor %pPAs on interface %s",

            __func__, &src_addr, ifp->name);

        FREE_ADDR_LIST_THEN_RETURN(-9);

      }

      /* Forward BSM if required */

      if (!pim_bsm_new_nbr_fwd(neigh, ifp)) {

        if (PIM_DEBUG_PIM_HELLO)

          zlog_debug(

            "%s: forwarding bsm to new nbr failed",

            __func__);

      }

      /* actual addr list is saved under neighbor */

      return 0;

    } /* GenId mismatch: replace neighbor */

  } /* GenId received */

  /*

    Update existing neighbor

  */

  pim_neighbor_update(neigh, hello_options, hello_option_holdtime,

          hello_option_dr_priority, hello_option_addr_list);

  /* actual addr list is saved under neighbor */

  return 0;

}

int pim_hello_build_tlv(struct interface *ifp, uint8_t *tlv_buf,

      int tlv_buf_size, uint16_t holdtime,

      uint32_t dr_priority, uint32_t generation_id,

      uint16_t propagation_delay, uint16_t override_interval,

      int can_disable_join_suppression)

{

  uint8_t *curr = tlv_buf;

  uint8_t *pastend = tlv_buf + tlv_buf_size;

  uint8_t *tmp;

#if PIM_IPV == 4

  struct pim_interface *pim_ifp = ifp->info;

  struct pim_instance *pim = pim_ifp->pim;

#endif

  /*

   * Append options

   */

  /* Holdtime */

  curr = pim_tlv_append_uint16(curr, pastend,

             PIM_MSG_OPTION_TYPE_HOLDTIME, holdtime);

  if (!curr) {

    if (PIM_DEBUG_PIM_HELLO) {

      zlog_debug(

        "%s: could not set PIM hello Holdtime option for interface %s",

        __func__, ifp->name);

    }

    return -1;

  }

  /* LAN Prune Delay */

  tmp = pim_tlv_append_2uint16(curr, pastend,

             PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY,

             propagation_delay, override_interval);

  if (!tmp) {

    if (PIM_DEBUG_PIM_HELLO) {

      zlog_debug(

        "%s: could not set PIM LAN Prune Delay option for interface %s",

        __func__, ifp->name);

    }

    return -1;

  }

  if (can_disable_join_suppression) {

    *(curr + 4) |= 0x80; /* enable T bit */

  }

  curr = tmp;

  /* DR Priority */

  curr = pim_tlv_append_uint32(

    curr, pastend, PIM_MSG_OPTION_TYPE_DR_PRIORITY, dr_priority);

  if (!curr) {

    if (PIM_DEBUG_PIM_HELLO) {

      zlog_debug(

        "%s: could not set PIM hello DR Priority option for interface %s",

        __func__, ifp->name);

    }

    return -2;

  }

  /* Generation ID */

  curr = pim_tlv_append_uint32(curr, pastend,

             PIM_MSG_OPTION_TYPE_GENERATION_ID,

             generation_id);

  if (!curr) {

    if (PIM_DEBUG_PIM_HELLO) {

      zlog_debug(

        "%s: could not set PIM hello Generation ID option for interface %s",

        __func__, ifp->name);

    }

    return -3;

  }

  /* Secondary Address List */

  if (ifp->connected->count) {

    curr = pim_tlv_append_addrlist_ucast(curr, pastend, ifp,

                 PIM_AF);

    if (!curr) {

      if (PIM_DEBUG_PIM_HELLO) {

        zlog_debug(

          "%s: could not set PIM hello %s Secondary Address List option for interface %s",

          __func__, PIM_AF_NAME, ifp->name);

      }

      return -4;

    }

#if PIM_IPV == 4

    if (pim->send_v6_secondary) {

      curr = pim_tlv_append_addrlist_ucast(curr, pastend, ifp,

                   AF_INET6);

      if (!curr) {

        if (PIM_DEBUG_PIM_HELLO) {

          zlog_debug(

            "%s: could not sent PIM hello v6 secondary Address List option for interface %s",

            __func__, ifp->name);

        }

        return -4;

      }

    }

#endif

  }

  return curr - tlv_buf;

}

/*

  RFC 4601: 4.3.1.  Sending Hello Messages

  Thus, if a router needs to send a Join/Prune or Assert message on an

  interface on which it has not yet sent a Hello message with the

  currently configured IP address, then it MUST immediately send the

  relevant Hello message without waiting for the Hello Timer to

  expire, followed by the Join/Prune or Assert message.

*/

void pim_hello_require(struct interface *ifp)

{

  struct pim_interface *pim_ifp;

  assert(ifp);

  pim_ifp = ifp->info;

  assert(pim_ifp);

  if (PIM_IF_FLAG_TEST_HELLO_SENT(pim_ifp->flags))

    return;

  pim_hello_restart_now(ifp); /* Send hello and restart timer */

}