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

/* Router advertisement

 * Copyright (C) 2016 Cumulus Networks

 * Copyright (C) 2005 6WIND <jean-mickael.guerin@6wind.com>

 * Copyright (C) 1999 Kunihiro Ishiguro

 */

#include <zebra.h>

#include "memory.h"

#include "sockopt.h"

#include "frrevent.h"

#include "if.h"

#include "stream.h"

#include "log.h"

#include "prefix.h"

#include "linklist.h"

#include "command.h"

#include "privs.h"

#include "vrf.h"

#include "ns.h"

#include "lib_errors.h"

#include "zebra/interface.h"

#include "zebra/rtadv.h"

#include "zebra/debug.h"

#include "zebra/rib.h"

#include "zebra/zapi_msg.h"

#include "zebra/zebra_vrf.h"

#include "zebra/zebra_errors.h"

#include "zebra/zebra_router.h"

extern struct zebra_privs_t zserv_privs;

static uint32_t interfaces_configured_for_ra_from_bgp;

#if defined(HAVE_RTADV)

#include "zebra/rtadv_clippy.c"

DEFINE_MTYPE_STATIC(ZEBRA, RTADV_PREFIX, "Router Advertisement Prefix");

DEFINE_MTYPE_STATIC(ZEBRA, ADV_IF, "Advertised Interface");

#ifdef OPEN_BSD

#include <netinet/icmp6.h>

#endif

/* If RFC2133 definition is used. */

#ifndef IPV6_JOIN_GROUP

#define IPV6_JOIN_GROUP  IPV6_ADD_MEMBERSHIP

#endif

#ifndef IPV6_LEAVE_GROUP

#define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP

#endif

#define ALLNODE   "ff02::1"

#define ALLROUTER "ff02::2"

/* adv list node */

struct adv_if {

  char name[INTERFACE_NAMSIZ];

  struct adv_if_list_item list_item;

};

static int adv_if_cmp(const struct adv_if *a, const struct adv_if *b)

{

  return if_cmp_name_func(a->name, b->name);

}

DECLARE_SORTLIST_UNIQ(adv_if_list, struct adv_if, list_item, adv_if_cmp);

static int rtadv_prefix_cmp(const struct rtadv_prefix *a,

          const struct rtadv_prefix *b)

{

  return prefix_cmp(&a->prefix, &b->prefix);

}

DECLARE_RBTREE_UNIQ(rtadv_prefixes, struct rtadv_prefix, item,

        rtadv_prefix_cmp);

DEFINE_MTYPE_STATIC(ZEBRA, RTADV_RDNSS, "Router Advertisement RDNSS");

DEFINE_MTYPE_STATIC(ZEBRA, RTADV_DNSSL, "Router Advertisement DNSSL");

/* Order is intentional.  Matches RFC4191.  This array is also used for

   command matching, so only modify with care. */

static const char *const rtadv_pref_strs[] = {

  "medium", "high", "INVALID", "low", 0

};

enum rtadv_event {

  RTADV_START,

  RTADV_STOP,

  RTADV_TIMER,

  RTADV_TIMER_MSEC,

  RTADV_READ

};

static void rtadv_event(struct zebra_vrf *, enum rtadv_event, int);

static int if_join_all_router(int, struct interface *);

static int if_leave_all_router(int, struct interface *);

static struct zebra_vrf *rtadv_interface_get_zvrf(const struct interface *ifp)

{

  /* We use the default vrf for rtadv handling except in netns */

  if (!vrf_is_backend_netns())

    return vrf_info_lookup(VRF_DEFAULT);

  return ifp->vrf->info;

}

static int rtadv_increment_received(struct zebra_vrf *zvrf, ifindex_t *ifindex)

{

  int ret = -1;

  struct interface *iface;

  struct zebra_if *zif;

  iface = if_lookup_by_index(*ifindex, zvrf->vrf->vrf_id);

  if (iface && iface->info) {

    zif = iface->info;

    zif->ra_rcvd++;

    ret = 0;

  }

  return ret;

}

static int rtadv_recv_packet(struct zebra_vrf *zvrf, int sock, uint8_t *buf,

           int buflen, struct sockaddr_in6 *from,

           ifindex_t *ifindex, int *hoplimit)

{

  int ret;

  struct msghdr msg;

  struct iovec iov;

  struct cmsghdr *cmsgptr;

  struct in6_addr dst;

  char adata[1024];

  /* Fill in message and iovec. */

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

  msg.msg_name = (void *)from;

  msg.msg_namelen = sizeof(struct sockaddr_in6);

  msg.msg_iov = &iov;

  msg.msg_iovlen = 1;

  msg.msg_control = (void *)adata;

  msg.msg_controllen = sizeof(adata);

  iov.iov_base = buf;

  iov.iov_len = buflen;

  /* If recvmsg fail return minus value. */

  ret = recvmsg(sock, &msg, 0);

  if (ret < 0)

    return ret;

  for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL;

       cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {

    /* I want interface index which this packet comes from. */

    if (cmsgptr->cmsg_level == IPPROTO_IPV6

        && cmsgptr->cmsg_type == IPV6_PKTINFO) {

      struct in6_pktinfo *ptr;

      ptr = (struct in6_pktinfo *)CMSG_DATA(cmsgptr);

      *ifindex = ptr->ipi6_ifindex;

      memcpy(&dst, &ptr->ipi6_addr, sizeof(ptr->ipi6_addr));

    }

    /* Incoming packet's hop limit. */

    if (cmsgptr->cmsg_level == IPPROTO_IPV6

        && cmsgptr->cmsg_type == IPV6_HOPLIMIT) {

      int *hoptr = (int *)CMSG_DATA(cmsgptr);

      *hoplimit = *hoptr;

    }

  }

  rtadv_increment_received(zvrf, ifindex);

  return ret;

}

#define RTADV_MSG_SIZE 4096

/* Send router advertisement packet. */

static void rtadv_send_packet(int sock, struct interface *ifp,

            enum ipv6_nd_suppress_ra_status stop)

{

  struct msghdr msg;

  struct iovec iov;

  struct cmsghdr *cmsgptr;

  struct in6_pktinfo *pkt;

  struct sockaddr_in6 addr;

  static void *adata = NULL;

  unsigned char buf[RTADV_MSG_SIZE];

  struct nd_router_advert *rtadv;

  int ret;

  int len = 0;

  struct zebra_if *zif;

  struct rtadv_prefix *rprefix;

  uint8_t all_nodes_addr[] = {0xff, 0x02, 0, 0, 0, 0, 0, 0,

            0,    0,    0, 0, 0, 0, 0, 1};

  struct listnode *node;

  uint16_t pkt_RouterLifetime;

  /*

   * Allocate control message bufffer.  This is dynamic because

   * CMSG_SPACE is not guaranteed not to call a function.  Note that

   * the size will be different on different architectures due to

   * differing alignment rules.

   */

  if (adata == NULL) {

    /* XXX Free on shutdown. */

    adata = calloc(1, CMSG_SPACE(sizeof(struct in6_pktinfo)));

    if (adata == NULL) {

      zlog_debug("%s: can't malloc control data", __func__);

      exit(-1);

    }

  }

  /* Logging of packet. */

  if (IS_ZEBRA_DEBUG_PACKET)

    zlog_debug("%s(%s:%u): Tx RA, socket %u", ifp->name,

         ifp->vrf->name, ifp->ifindex, sock);

  /* Fill in sockaddr_in6. */

  memset(&addr, 0, sizeof(struct sockaddr_in6));

  addr.sin6_family = AF_INET6;

#ifdef SIN6_LEN

  addr.sin6_len = sizeof(struct sockaddr_in6);

#endif /* SIN6_LEN */

  addr.sin6_port = htons(IPPROTO_ICMPV6);

  IPV6_ADDR_COPY(&addr.sin6_addr, all_nodes_addr);

  /* Fetch interface information. */

  zif = ifp->info;

  /* Make router advertisement message. */

  rtadv = (struct nd_router_advert *)buf;

  rtadv->nd_ra_type = ND_ROUTER_ADVERT;

  rtadv->nd_ra_code = 0;

  rtadv->nd_ra_cksum = 0;

  rtadv->nd_ra_curhoplimit = zif->rtadv.AdvCurHopLimit;

  /* RFC4191: Default Router Preference is 0 if Router Lifetime is 0. */

  rtadv->nd_ra_flags_reserved = zif->rtadv.AdvDefaultLifetime == 0

                ? 0

                : zif->rtadv.DefaultPreference;

  rtadv->nd_ra_flags_reserved <<= 3;

  if (zif->rtadv.AdvManagedFlag)

    rtadv->nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;

  if (zif->rtadv.AdvOtherConfigFlag)

    rtadv->nd_ra_flags_reserved |= ND_RA_FLAG_OTHER;

  if (zif->rtadv.AdvHomeAgentFlag)

    rtadv->nd_ra_flags_reserved |= ND_RA_FLAG_HOME_AGENT;

  /* Note that according to Neighbor Discovery (RFC 4861 [18]),

   * AdvDefaultLifetime is by default based on the value of

   * MaxRtrAdvInterval.  AdvDefaultLifetime is used in the Router Lifetime

   * field of Router Advertisements.  Given that this field is expressed

   * in seconds, a small MaxRtrAdvInterval value can result in a zero

   * value for this field.  To prevent this, routers SHOULD keep

   * AdvDefaultLifetime in at least one second, even if the use of

   * MaxRtrAdvInterval would result in a smaller value. -- RFC6275, 7.5 */

  pkt_RouterLifetime =

    zif->rtadv.AdvDefaultLifetime != -1

      ? zif->rtadv.AdvDefaultLifetime

      : MAX(1, 0.003 * zif->rtadv.MaxRtrAdvInterval);

  /* send RA lifetime of 0 before stopping. rfc4861/6.2.5 */

  rtadv->nd_ra_router_lifetime =

    (stop == RA_SUPPRESS) ? htons(0) : htons(pkt_RouterLifetime);

  rtadv->nd_ra_reachable = htonl(zif->rtadv.AdvReachableTime);

  rtadv->nd_ra_retransmit = htonl(zif->rtadv.AdvRetransTimer);

  len = sizeof(struct nd_router_advert);

  /* If both the Home Agent Preference and Home Agent Lifetime are set to

   * their default values specified above, this option SHOULD NOT be

   * included in the Router Advertisement messages sent by this home

   * agent. -- RFC6275, 7.4 */

  if (zif->rtadv.AdvHomeAgentFlag

      && (zif->rtadv.HomeAgentPreference

    || zif->rtadv.HomeAgentLifetime != -1)) {

    struct nd_opt_homeagent_info *ndopt_hai =

      (struct nd_opt_homeagent_info *)(buf + len);

    ndopt_hai->nd_opt_hai_type = ND_OPT_HA_INFORMATION;

    ndopt_hai->nd_opt_hai_len = 1;

    ndopt_hai->nd_opt_hai_reserved = 0;

    ndopt_hai->nd_opt_hai_preference =

      htons(zif->rtadv.HomeAgentPreference);

    /* 16-bit unsigned integer.  The lifetime associated with the

     * home

     * agent in units of seconds.  The default value is the same as

     * the

     * Router Lifetime, as specified in the main body of the Router

     * Advertisement.  The maximum value corresponds to 18.2 hours.

     * A

     * value of 0 MUST NOT be used. -- RFC6275, 7.5 */

    ndopt_hai->nd_opt_hai_lifetime =

      htons(zif->rtadv.HomeAgentLifetime != -1

              ? zif->rtadv.HomeAgentLifetime

              : MAX(1, pkt_RouterLifetime) /* 0 is OK

                      for RL,

                      but not

                      for HAL*/

            );

    len += sizeof(struct nd_opt_homeagent_info);

  }

  if (zif->rtadv.AdvIntervalOption) {

    struct nd_opt_adv_interval *ndopt_adv =

      (struct nd_opt_adv_interval *)(buf + len);

    ndopt_adv->nd_opt_ai_type = ND_OPT_ADV_INTERVAL;

    ndopt_adv->nd_opt_ai_len = 1;

    ndopt_adv->nd_opt_ai_reserved = 0;

    ndopt_adv->nd_opt_ai_interval =

      htonl(zif->rtadv.MaxRtrAdvInterval);

    len += sizeof(struct nd_opt_adv_interval);

  }

  /* Fill in prefix. */

  frr_each (rtadv_prefixes, zif->rtadv.prefixes, rprefix) {

    struct nd_opt_prefix_info *pinfo;

    pinfo = (struct nd_opt_prefix_info *)(buf + len);

    pinfo->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;

    pinfo->nd_opt_pi_len = 4;

    pinfo->nd_opt_pi_prefix_len = rprefix->prefix.prefixlen;

    pinfo->nd_opt_pi_flags_reserved = 0;

    if (rprefix->AdvOnLinkFlag)

      pinfo->nd_opt_pi_flags_reserved |=

        ND_OPT_PI_FLAG_ONLINK;

    if (rprefix->AdvAutonomousFlag)

      pinfo->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO;

    if (rprefix->AdvRouterAddressFlag)

      pinfo->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_RADDR;

    pinfo->nd_opt_pi_valid_time = htonl(rprefix->AdvValidLifetime);

    pinfo->nd_opt_pi_preferred_time =

      htonl(rprefix->AdvPreferredLifetime);

    pinfo->nd_opt_pi_reserved2 = 0;

    IPV6_ADDR_COPY(&pinfo->nd_opt_pi_prefix,

             &rprefix->prefix.prefix);

    len += sizeof(struct nd_opt_prefix_info);

  }

  /* Hardware address. */

  if (ifp->hw_addr_len != 0) {

    buf[len++] = ND_OPT_SOURCE_LINKADDR;

    /* Option length should be rounded up to next octet if

       the link address does not end on an octet boundary. */

    buf[len++] = (ifp->hw_addr_len + 9) >> 3;

    memcpy(buf + len, ifp->hw_addr, ifp->hw_addr_len);

    len += ifp->hw_addr_len;

    /* Pad option to end on an octet boundary. */

    memset(buf + len, 0, -(ifp->hw_addr_len + 2) & 0x7);

    len += -(ifp->hw_addr_len + 2) & 0x7;

  }

  /* MTU */

  if (zif->rtadv.AdvLinkMTU) {

    struct nd_opt_mtu *opt = (struct nd_opt_mtu *)(buf + len);

    opt->nd_opt_mtu_type = ND_OPT_MTU;

    opt->nd_opt_mtu_len = 1;

    opt->nd_opt_mtu_reserved = 0;

    opt->nd_opt_mtu_mtu = htonl(zif->rtadv.AdvLinkMTU);

    len += sizeof(struct nd_opt_mtu);

  }

  /*

   * There is no limit on the number of configurable recursive DNS

   * servers or search list entries. We don't want the RA message

   * to exceed the link's MTU (risking fragmentation) or even

   * blow the stack buffer allocated for it.

   */

  size_t max_len = MIN(ifp->mtu6 - 40, sizeof(buf));

  /* Recursive DNS servers */

  struct rtadv_rdnss *rdnss;

  for (ALL_LIST_ELEMENTS_RO(zif->rtadv.AdvRDNSSList, node, rdnss)) {

    size_t opt_len =

      sizeof(struct nd_opt_rdnss) + sizeof(struct in6_addr);

    if (len + opt_len > max_len) {

      zlog_warn(

        "%s(%s:%u): Tx RA: RDNSS option would exceed MTU, omitting it",

        ifp->name, ifp->vrf->name, ifp->ifindex);

      goto no_more_opts;

    }

    struct nd_opt_rdnss *opt = (struct nd_opt_rdnss *)(buf + len);

    opt->nd_opt_rdnss_type = ND_OPT_RDNSS;

    opt->nd_opt_rdnss_len = opt_len / 8;

    opt->nd_opt_rdnss_reserved = 0;

    opt->nd_opt_rdnss_lifetime = htonl(

      rdnss->lifetime_set

        ? rdnss->lifetime

        : MAX(1, 0.003 * zif->rtadv.MaxRtrAdvInterval));

    len += sizeof(struct nd_opt_rdnss);

    IPV6_ADDR_COPY(buf + len, &rdnss->addr);

    len += sizeof(struct in6_addr);

  }

  /* DNS search list */

  struct rtadv_dnssl *dnssl;

  for (ALL_LIST_ELEMENTS_RO(zif->rtadv.AdvDNSSLList, node, dnssl)) {

    size_t opt_len = sizeof(struct nd_opt_dnssl)

         + ((dnssl->encoded_len + 7) & ~7);

    if (len + opt_len > max_len) {

      zlog_warn(

        "%s(%u): Tx RA: DNSSL option would exceed MTU, omitting it",

        ifp->name, ifp->ifindex);

      goto no_more_opts;

    }

    struct nd_opt_dnssl *opt = (struct nd_opt_dnssl *)(buf + len);

    opt->nd_opt_dnssl_type = ND_OPT_DNSSL;

    opt->nd_opt_dnssl_len = opt_len / 8;

    opt->nd_opt_dnssl_reserved = 0;

    opt->nd_opt_dnssl_lifetime = htonl(

      dnssl->lifetime_set

        ? dnssl->lifetime

        : MAX(1, 0.003 * zif->rtadv.MaxRtrAdvInterval));

    len += sizeof(struct nd_opt_dnssl);

    memcpy(buf + len, dnssl->encoded_name, dnssl->encoded_len);

    len += dnssl->encoded_len;

    /* Zero-pad to 8-octet boundary */

    while (len % 8)

      buf[len++] = '\0';

  }

no_more_opts:

  msg.msg_name = (void *)&addr;

  msg.msg_namelen = sizeof(struct sockaddr_in6);

  msg.msg_iov = &iov;

  msg.msg_iovlen = 1;

  msg.msg_control = (void *)adata;

  msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));

  msg.msg_flags = 0;

  iov.iov_base = buf;

  iov.iov_len = len;

  cmsgptr = CMSG_FIRSTHDR(&msg);

  cmsgptr->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));

  cmsgptr->cmsg_level = IPPROTO_IPV6;

  cmsgptr->cmsg_type = IPV6_PKTINFO;

  pkt = (struct in6_pktinfo *)CMSG_DATA(cmsgptr);

  memset(&pkt->ipi6_addr, 0, sizeof(struct in6_addr));

  pkt->ipi6_ifindex = ifp->ifindex;

  ret = sendmsg(sock, &msg, 0);

  if (ret < 0) {

    flog_err_sys(EC_LIB_SOCKET,

           "%s(%u): Tx RA failed, socket %u error %d (%s)",

           ifp->name, ifp->ifindex, sock, errno,

           safe_strerror(errno));

  } else

    zif->ra_sent++;

}

static void rtadv_timer(struct event *thread)

{

  struct zebra_vrf *zvrf = EVENT_ARG(thread);

  struct vrf *vrf;

  struct interface *ifp;

  struct zebra_if *zif;

  int period;

  zvrf->rtadv.ra_timer = NULL;

  if (adv_if_list_count(&zvrf->rtadv.adv_msec_if) == 0) {

    period = 1000; /* 1 s */

    rtadv_event(zvrf, RTADV_TIMER, 1 /* 1 s */);

  } else {

    period = 10; /* 10 ms */

    rtadv_event(zvrf, RTADV_TIMER_MSEC, 10 /* 10 ms */);

  }

  RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)

    FOR_ALL_INTERFACES (vrf, ifp) {

      if (if_is_loopback(ifp) || !if_is_operative(ifp) ||

          IS_ZEBRA_IF_BRIDGE_SLAVE(ifp) ||

          !connected_get_linklocal(ifp) ||

          (vrf_is_backend_netns() &&

           ifp->vrf->vrf_id != zvrf->vrf->vrf_id))

        continue;

      zif = ifp->info;

      if (zif->rtadv.AdvSendAdvertisements) {

        if (zif->rtadv.inFastRexmit

            && zif->rtadv.UseFastRexmit) {

          /* We assume we fast rexmit every sec so

           * no

           * additional vars */

          if (--zif->rtadv.NumFastReXmitsRemain

              <= 0)

            zif->rtadv.inFastRexmit = 0;

          if (IS_ZEBRA_DEBUG_SEND)

            zlog_debug(

              "Fast RA Rexmit on interface %s(%s:%u)",

              ifp->name,

              ifp->vrf->name,

              ifp->ifindex);

          rtadv_send_packet(zvrf->rtadv.sock, ifp,

                RA_ENABLE);

        } else {

          zif->rtadv.AdvIntervalTimer -= period;

          if (zif->rtadv.AdvIntervalTimer <= 0) {

            /* FIXME: using

               MaxRtrAdvInterval each

               time isn't what section

               6.2.4 of RFC4861 tells to do.

               */

            zif->rtadv.AdvIntervalTimer =

              zif->rtadv

                .MaxRtrAdvInterval;

            rtadv_send_packet(

              zvrf->rtadv.sock, ifp,

              RA_ENABLE);

          }

        }

      }

    }

}

static void rtadv_process_solicit(struct interface *ifp)

{

  struct zebra_vrf *zvrf;

  struct zebra_if *zif;

  zvrf = rtadv_interface_get_zvrf(ifp);

  assert(zvrf);

  zif = ifp->info;

  /*

   * If FastRetransmit is enabled, send the RA immediately.

   * If not enabled but it has been more than MIN_DELAY_BETWEEN_RAS

   * (3 seconds) since the last RA was sent, send it now and reset

   * the timer to start at the max (configured) again.

   * If not enabled and it is less than 3 seconds since the last

   * RA packet was sent, set the timer for 3 seconds so the next

   * one will be sent with a minimum of 3 seconds between RAs.

   * RFC4861 sec 6.2.6

   */

  if ((zif->rtadv.UseFastRexmit)

      || (zif->rtadv.AdvIntervalTimer <=

    (zif->rtadv.MaxRtrAdvInterval - MIN_DELAY_BETWEEN_RAS))) {

    rtadv_send_packet(zvrf->rtadv.sock, ifp, RA_ENABLE);

    zif->rtadv.AdvIntervalTimer = zif->rtadv.MaxRtrAdvInterval;

  } else

    zif->rtadv.AdvIntervalTimer = MIN_DELAY_BETWEEN_RAS;

}

static const char *rtadv_optionalhdr2str(uint8_t opt_type)

{

  switch (opt_type) {

  case ND_OPT_SOURCE_LINKADDR:

    return "Optional Source Link Address";

  case ND_OPT_TARGET_LINKADDR:

    return "Optional Target Link Address";

  case ND_OPT_PREFIX_INFORMATION:

    return "Optional Prefix Information";

  case ND_OPT_REDIRECTED_HEADER:

    return "Optional Redirected Header";

  case ND_OPT_MTU:

    return "Optional MTU";

  case ND_OPT_RTR_ADV_INTERVAL:

    return "Optional Advertisement Interval";

  case ND_OPT_HOME_AGENT_INFO:

    return "Optional Home Agent Information";

  }

  return "Unknown Optional Type";

}

/*

 * This function processes optional attributes off of

 * end of a RA packet received.  At this point in

 * time we only care about this in one situation

 * which is when a interface does not have a LL

 * v6 address.  We still need to be able to install

 * the mac address for v4 to v6 resolution

 */

static void rtadv_process_optional(uint8_t *optional, unsigned int len,

           struct interface *ifp,

           struct sockaddr_in6 *addr)

{

  char *mac;

  while (len > 0) {

    struct nd_opt_hdr *opt_hdr = (struct nd_opt_hdr *)optional;

    switch(opt_hdr->nd_opt_type) {

    case ND_OPT_SOURCE_LINKADDR:

      mac = (char *)(optional+2);

      if_nbr_mac_to_ipv4ll_neigh_update(ifp, mac,

                &addr->sin6_addr, 1);

      break;

    default:

      if (IS_ZEBRA_DEBUG_PACKET)

        zlog_debug(

          "%s:Received Packet with optional Header type %s(%u) that is being ignored",

          __func__,

          rtadv_optionalhdr2str(

            opt_hdr->nd_opt_type),

          opt_hdr->nd_opt_type);

      break;

    }

    len -= 8 * opt_hdr->nd_opt_len;

    optional += 8 * opt_hdr->nd_opt_len;

  }

}

static void rtadv_process_advert(uint8_t *msg, unsigned int len,

         struct interface *ifp,

         struct sockaddr_in6 *addr)

{

  struct nd_router_advert *radvert;

  char addr_str[INET6_ADDRSTRLEN];

  struct zebra_if *zif;

  struct prefix p;

  zif = ifp->info;

  inet_ntop(AF_INET6, &addr->sin6_addr, addr_str, INET6_ADDRSTRLEN);

  if (len < sizeof(struct nd_router_advert)) {

    if (IS_ZEBRA_DEBUG_PACKET)

      zlog_debug(

        "%s(%s:%u): Rx RA with invalid length %d from %s",

        ifp->name, ifp->vrf->name, ifp->ifindex, len,

        addr_str);

    return;

  }

  if (!IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {

    rtadv_process_optional(msg + sizeof(struct nd_router_advert),

               len - sizeof(struct nd_router_advert),

               ifp, addr);

    if (IS_ZEBRA_DEBUG_PACKET)

      zlog_debug(

        "%s(%s:%u): Rx RA with non-linklocal source address from %s",

        ifp->name, ifp->vrf->name, ifp->ifindex,

        addr_str);

    return;

  }

  radvert = (struct nd_router_advert *)msg;

#define SIXHOUR2USEC (int64_t)6 * 60 * 60 * 1000000

  if ((radvert->nd_ra_curhoplimit && zif->rtadv.AdvCurHopLimit) &&

      (radvert->nd_ra_curhoplimit != zif->rtadv.AdvCurHopLimit) &&

      (monotime_since(&zif->rtadv.lastadvcurhoplimit, NULL) >

         SIXHOUR2USEC ||

       zif->rtadv.lastadvcurhoplimit.tv_sec == 0)) {

    flog_warn(

      EC_ZEBRA_RA_PARAM_MISMATCH,

      "%s(%u): Rx RA - our AdvCurHopLimit (%u) doesn't agree with %s (%u)",

      ifp->name, ifp->ifindex, zif->rtadv.AdvCurHopLimit,

      addr_str, radvert->nd_ra_curhoplimit);

    monotime(&zif->rtadv.lastadvcurhoplimit);

  }

  if ((radvert->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) &&

      !zif->rtadv.AdvManagedFlag &&

      (monotime_since(&zif->rtadv.lastadvmanagedflag, NULL) >

         SIXHOUR2USEC ||

       zif->rtadv.lastadvmanagedflag.tv_sec == 0)) {

    flog_warn(

      EC_ZEBRA_RA_PARAM_MISMATCH,

      "%s(%u): Rx RA - our AdvManagedFlag (%u) doesn't agree with %s (%u)",

      ifp->name, ifp->ifindex, zif->rtadv.AdvManagedFlag,

      addr_str,

      !!CHECK_FLAG(radvert->nd_ra_flags_reserved,

             ND_RA_FLAG_MANAGED));

    monotime(&zif->rtadv.lastadvmanagedflag);

  }

  if ((radvert->nd_ra_flags_reserved & ND_RA_FLAG_OTHER) &&

      !zif->rtadv.AdvOtherConfigFlag &&

      (monotime_since(&zif->rtadv.lastadvotherconfigflag, NULL) >

         SIXHOUR2USEC ||

       zif->rtadv.lastadvotherconfigflag.tv_sec == 0)) {

    flog_warn(

      EC_ZEBRA_RA_PARAM_MISMATCH,

      "%s(%u): Rx RA - our AdvOtherConfigFlag (%u) doesn't agree with %s (%u)",

      ifp->name, ifp->ifindex, zif->rtadv.AdvOtherConfigFlag,

      addr_str,

      !!CHECK_FLAG(radvert->nd_ra_flags_reserved,

             ND_RA_FLAG_OTHER));

    monotime(&zif->rtadv.lastadvotherconfigflag);

  }

  if ((radvert->nd_ra_reachable && zif->rtadv.AdvReachableTime) &&

      (ntohl(radvert->nd_ra_reachable) != zif->rtadv.AdvReachableTime) &&

      (monotime_since(&zif->rtadv.lastadvreachabletime, NULL) >

         SIXHOUR2USEC ||

       zif->rtadv.lastadvreachabletime.tv_sec == 0)) {

    flog_warn(

      EC_ZEBRA_RA_PARAM_MISMATCH,

      "%s(%u): Rx RA - our AdvReachableTime (%u) doesn't agree with %s (%u)",

      ifp->name, ifp->ifindex, zif->rtadv.AdvReachableTime,

      addr_str, ntohl(radvert->nd_ra_reachable));

    monotime(&zif->rtadv.lastadvreachabletime);

  }

  if ((radvert->nd_ra_retransmit && zif->rtadv.AdvRetransTimer) &&

      (ntohl(radvert->nd_ra_retransmit) !=

       (unsigned int)zif->rtadv.AdvRetransTimer) &&

      (monotime_since(&zif->rtadv.lastadvretranstimer, NULL) >

         SIXHOUR2USEC ||

       zif->rtadv.lastadvretranstimer.tv_sec == 0)) {

    flog_warn(

      EC_ZEBRA_RA_PARAM_MISMATCH,

      "%s(%u): Rx RA - our AdvRetransTimer (%u) doesn't agree with %s (%u)",

      ifp->name, ifp->ifindex, zif->rtadv.AdvRetransTimer,

      addr_str, ntohl(radvert->nd_ra_retransmit));

    monotime(&zif->rtadv.lastadvretranstimer);

  }

  /* Create entry for neighbor if not known. */

  p.family = AF_INET6;

  IPV6_ADDR_COPY(&p.u.prefix6, &addr->sin6_addr);

  p.prefixlen = IPV6_MAX_BITLEN;

  if (!nbr_connected_check(ifp, &p))

    nbr_connected_add_ipv6(ifp, &addr->sin6_addr);

}

static void rtadv_process_packet(uint8_t *buf, unsigned int len,

         ifindex_t ifindex, int hoplimit,

         struct sockaddr_in6 *from,

         struct zebra_vrf *zvrf)

{

  struct icmp6_hdr *icmph;

  struct interface *ifp;

  struct zebra_if *zif;

  char addr_str[INET6_ADDRSTRLEN];

  inet_ntop(AF_INET6, &from->sin6_addr, addr_str, INET6_ADDRSTRLEN);

  /* Interface search. */

  ifp = if_lookup_by_index(ifindex, zvrf->vrf->vrf_id);

  if (ifp == NULL) {

    flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE,

        "RA/RS received on unknown IF %u from %s", ifindex,

        addr_str);

    return;

  }

  if (IS_ZEBRA_DEBUG_PACKET)

    zlog_debug("%s(%s:%u): Rx RA/RS len %d from %s", ifp->name,

         ifp->vrf->name, ifp->ifindex, len, addr_str);

  if (if_is_loopback(ifp))

    return;

  /* Check interface configuration. */

  zif = ifp->info;

  if (!zif->rtadv.AdvSendAdvertisements)

    return;

  /* ICMP message length check. */

  if (len < sizeof(struct icmp6_hdr)) {

    zlog_debug(

      "%s(%s:%u): Rx RA with Invalid ICMPV6 packet length %d",

      ifp->name, ifp->vrf->name, ifp->ifindex, len);

    return;

  }

  icmph = (struct icmp6_hdr *)buf;

  /* ICMP message type check. */

  if (icmph->icmp6_type != ND_ROUTER_SOLICIT

      && icmph->icmp6_type != ND_ROUTER_ADVERT) {

    zlog_debug("%s(%s:%u): Rx RA - Unwanted ICMPV6 message type %d",

         ifp->name, ifp->vrf->name, ifp->ifindex,

         icmph->icmp6_type);

    return;

  }

  /* Hoplimit check. */

  if (hoplimit >= 0 && hoplimit != 255) {

    zlog_debug("%s(%s:%u): Rx RA - Invalid hoplimit %d", ifp->name,

         ifp->vrf->name, ifp->ifindex, hoplimit);

    return;

  }

  /* Check ICMP message type. */

  if (icmph->icmp6_type == ND_ROUTER_SOLICIT)

    rtadv_process_solicit(ifp);

  else if (icmph->icmp6_type == ND_ROUTER_ADVERT)

    rtadv_process_advert(buf, len, ifp, from);

  return;

}

static void rtadv_read(struct event *thread)

{

  int sock;

  int len;

  uint8_t buf[RTADV_MSG_SIZE];

  struct sockaddr_in6 from;

  ifindex_t ifindex = 0;

  int hoplimit = -1;

  struct zebra_vrf *zvrf = EVENT_ARG(thread);

  sock = EVENT_FD(thread);

  zvrf->rtadv.ra_read = NULL;

  /* Register myself. */

  rtadv_event(zvrf, RTADV_READ, 0);

  len = rtadv_recv_packet(zvrf, sock, buf, sizeof(buf), &from, &ifindex,

        &hoplimit);

  if (len < 0) {

    flog_err_sys(EC_LIB_SOCKET,

           "RA/RS recv failed, socket %u error %s", sock,

           safe_strerror(errno));

    return;

  }

  rtadv_process_packet(buf, (unsigned)len, ifindex, hoplimit, &from, zvrf);

}

static int rtadv_make_socket(ns_id_t ns_id)

{

  int sock = -1;

  int ret = 0;

  struct icmp6_filter filter;

  int error;

  frr_with_privs(&zserv_privs) {

    sock = ns_socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6, ns_id);

    /*

     * with privs might set errno too if it fails save

     * to the side

     */

    error = errno;

  }

  if (sock < 0) {

    zlog_warn("RTADV socket for ns: %u failure to create: %s(%u)",

        ns_id, safe_strerror(error), error);

    return -1;

  }

  ret = setsockopt_ipv6_pktinfo(sock, 1);

  if (ret < 0) {

    zlog_warn("RTADV failure to set Packet Information");

    close(sock);

    return ret;

  }

  ret = setsockopt_ipv6_multicast_loop(sock, 0);

  if (ret < 0) {

    zlog_warn("RTADV failure to set multicast Loop detection");

    close(sock);

    return ret;

  }

  ret = setsockopt_ipv6_unicast_hops(sock, 255);

  if (ret < 0) {

    zlog_warn("RTADV failure to set maximum unicast hops");

    close(sock);

    return ret;

  }

  ret = setsockopt_ipv6_multicast_hops(sock, 255);

  if (ret < 0) {

    zlog_warn("RTADV failure to set maximum multicast hops");

    close(sock);

    return ret;

  }

  ret = setsockopt_ipv6_hoplimit(sock, 1);

  if (ret < 0) {

    zlog_warn("RTADV failure to set maximum incoming hop limit");

    close(sock);

    return ret;

  }

  ICMP6_FILTER_SETBLOCKALL(&filter);

  ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filter);

  ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);

  ret = setsockopt(sock, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,

       sizeof(struct icmp6_filter));

  if (ret < 0) {

    zlog_info("ICMP6_FILTER set fail: %s", safe_strerror(errno));

    close(sock);

    return ret;

  }