/src/frr/lib/bfd.c

Source
// SPDX-License-Identifier: GPL-2.0-or-later
/**
 * bfd.c: BFD handling routines
 *
 * @copyright Copyright (C) 2015 Cumulus Networks, Inc.
 */

#include <zebra.h>

#include "command.h"
#include "memory.h"
#include "prefix.h"
#include "frrevent.h"
#include "stream.h"
#include "vrf.h"
#include "zclient.h"
#include "libfrr.h"
#include "table.h"
#include "vty.h"
#include "bfd.h"

DEFINE_MTYPE_STATIC(LIB, BFD_INFO, "BFD info");
DEFINE_MTYPE_STATIC(LIB, BFD_SOURCE, "BFD source cache");

/**
 * BFD protocol integration configuration.
 */

/** Events definitions. */
enum bfd_session_event {
  /** Remove the BFD session configuration. */
  BSE_UNINSTALL,
  /** Install the BFD session configuration. */
  BSE_INSTALL,
};

/**
 * BFD source selection result cache.
 *
 * This structure will keep track of the result based on the destination
 * prefix. When the result changes all related BFD sessions with automatic
 * source will be updated.
 */
struct bfd_source_cache {
  /** Address VRF belongs. */
  vrf_id_t vrf_id;
  /** Destination network address. */
  struct prefix address;
  /** Source selected. */
  struct prefix source;
  /** Is the source address valid? */
  bool valid;
  /** BFD sessions using this. */
  size_t refcount;

  SLIST_ENTRY(bfd_source_cache) entry;
};
SLIST_HEAD(bfd_source_list, bfd_source_cache);

/**
 * Data structure to do the necessary tricks to hide the BFD protocol
 * integration internals.
 */
struct bfd_session_params {
  /** Contains the session parameters and more. */
  struct bfd_session_arg args;
  /** Contains the session state. */
  struct bfd_session_status bss;
  /** Protocol implementation status update callback. */
  bsp_status_update updatecb;
  /** Protocol implementation custom data pointer. */
  void *arg;

  /**
   * Next event.
   *
   * This variable controls what action to execute when the command batch
   * finishes. Normally we'd use `event_add_event` value, however since
   * that function is going to be called multiple times and the value
   * might be different we'll use this variable to keep track of it.
   */
  enum bfd_session_event lastev;
  /**
   * BFD session configuration event.
   *
   * Multiple actions might be asked during a command batch (either via
   * configuration load or northbound batch), so we'll use this to
   * install/uninstall the BFD session parameters only once.
   */
  struct event *installev;

  /** BFD session installation state. */
  bool installed;

  /** Automatic source selection. */
  bool auto_source;
  /** Currently selected source. */
  struct bfd_source_cache *source_cache;

  /** Global BFD paramaters list. */
  TAILQ_ENTRY(bfd_session_params) entry;
};

struct bfd_sessions_global {
  /**
   * Global BFD session parameters list for (re)installation and update
   * without code duplication among daemons.
   */
  TAILQ_HEAD(bsplist, bfd_session_params) bsplist;
  /** BFD automatic source selection cache. */
  struct bfd_source_list source_list;

  /** Pointer to FRR's event manager. */
  struct event_loop *tm;
  /** Pointer to zebra client data structure. */
  struct zclient *zc;

  /** Debugging state. */
  bool debugging;
  /** Is shutting down? */
  bool shutting_down;
};

/** Global configuration variable. */
static struct bfd_sessions_global bsglobal;

/** Global empty address for IPv4/IPv6. */
static const struct in6_addr i6a_zero;

/*
 * Prototypes
 */

static void bfd_source_cache_get(struct bfd_session_params *session);
static void bfd_source_cache_put(struct bfd_session_params *session);

/*
 * bfd_get_peer_info - Extract the Peer information for which the BFD session
 *                     went down from the message sent from Zebra to clients.
 */
static struct interface *bfd_get_peer_info(struct stream *s, struct prefix *dp,
             struct prefix *sp, int *status,
             int *remote_cbit, vrf_id_t vrf_id)
{
  unsigned int ifindex;
  struct interface *ifp = NULL;
  int plen;
  int local_remote_cbit;

  /*
   * If the ifindex lookup fails the
   * rest of the data in the stream is
   * not read.  All examples of this function
   * call immediately use the dp->family which
   * is not good.  Ensure we are not using
   * random data
   */
  memset(dp, 0, sizeof(*dp));
  memset(sp, 0, sizeof(*sp));

  /* Get interface index. */
  STREAM_GETL(s, ifindex);

  /* Lookup index. */
  if (ifindex != 0) {
    ifp = if_lookup_by_index(ifindex, vrf_id);
    if (ifp == NULL) {
      if (bsglobal.debugging)
        zlog_debug(
          "%s: Can't find interface by ifindex: %d ",
          __func__, ifindex);
      return NULL;
    }
  }

  /* Fetch destination address. */
  STREAM_GETC(s, dp->family);

  plen = prefix_blen(dp);
  STREAM_GET(&dp->u.prefix, s, plen);
  STREAM_GETC(s, dp->prefixlen);

  /* Get BFD status. */
  STREAM_GETL(s, (*status));

  STREAM_GETC(s, sp->family);

  plen = prefix_blen(sp);
  STREAM_GET(&sp->u.prefix, s, plen);
  STREAM_GETC(s, sp->prefixlen);

  STREAM_GETC(s, local_remote_cbit);
  if (remote_cbit)
    *remote_cbit = local_remote_cbit;
  return ifp;

stream_failure:
  /*
   * Clean dp and sp because caller
   * will immediately check them valid or not
   */
  memset(dp, 0, sizeof(*dp));
  memset(sp, 0, sizeof(*sp));
  return NULL;
}

/*
 * bfd_get_status_str - Convert BFD status to a display string.
 */
const char *bfd_get_status_str(int status)
{
  switch (status) {
  case BFD_STATUS_DOWN:
    return "Down";
  case BFD_STATUS_UP:
    return "Up";
  case BFD_STATUS_ADMIN_DOWN:
    return "Admin Down";
  case BFD_STATUS_UNKNOWN:
  default:
    return "Unknown";
  }
}

/*
 * bfd_last_update - Calculate the last BFD update time and convert it
 *                   into a dd:hh:mm:ss display format.
 */
static void bfd_last_update(time_t last_update, char *buf, size_t len)
{
  time_t curr;
  time_t diff;
  struct tm tm;
  struct timeval tv;

  /* If no BFD status update has ever been received, print `never'. */
  if (last_update == 0) {
    snprintf(buf, len, "never");
    return;
  }

  /* Get current time. */
  monotime(&tv);
  curr = tv.tv_sec;
  diff = curr - last_update;
  gmtime_r(&diff, &tm);

  snprintf(buf, len, "%d:%02d:%02d:%02d", tm.tm_yday, tm.tm_hour,
     tm.tm_min, tm.tm_sec);
}

/*
 * bfd_client_sendmsg - Format and send a client register
 *                    command to Zebra to be forwarded to BFD
 */
void bfd_client_sendmsg(struct zclient *zclient, int command,
      vrf_id_t vrf_id)
{
  struct stream *s;
  enum zclient_send_status ret;

  /* Check socket. */
  if (!zclient || zclient->sock < 0) {
    if (bsglobal.debugging)
      zlog_debug(
        "%s: Can't send BFD client register, Zebra client not established",
        __func__);
    return;
  }

  s = zclient->obuf;
  stream_reset(s);
  zclient_create_header(s, command, vrf_id);

  stream_putl(s, getpid());

  stream_putw_at(s, 0, stream_get_endp(s));

  ret = zclient_send_message(zclient);

  if (ret == ZCLIENT_SEND_FAILURE) {
    if (bsglobal.debugging)
      zlog_debug(
        "%s:  %ld: zclient_send_message() failed",
        __func__, (long)getpid());
    return;
  }

  return;
}

int zclient_bfd_command(struct zclient *zc, struct bfd_session_arg *args)
{
  struct stream *s;
  size_t addrlen;

  /* Individual reg/dereg messages are suppressed during shutdown. */
  if (bsglobal.shutting_down) {
    if (bsglobal.debugging)
      zlog_debug(
        "%s: Suppressing BFD peer reg/dereg messages",
        __func__);
    return -1;
  }

  /* Check socket. */
  if (!zc || zc->sock < 0) {
    if (bsglobal.debugging)
      zlog_debug("%s: zclient unavailable", __func__);
    return -1;
  }

  s = zc->obuf;
  stream_reset(s);

  /* Create new message. */
  zclient_create_header(s, args->command, args->vrf_id);
  stream_putl(s, getpid());

  /* Encode destination address. */
  stream_putw(s, args->family);
  addrlen = (args->family == AF_INET) ? sizeof(struct in_addr)
              : sizeof(struct in6_addr);
  stream_put(s, &args->dst, addrlen);

  /*
   * For more BFD integration protocol details, see function
   * `_ptm_msg_read` in `bfdd/ptm_adapter.c`.
   */
#if HAVE_BFDD > 0
  /* Session timers. */
  stream_putl(s, args->min_rx);
  stream_putl(s, args->min_tx);
  stream_putc(s, args->detection_multiplier);

  /* Is multi hop? */
  stream_putc(s, args->mhop != 0);

  /* Source address. */
  stream_putw(s, args->family);
  stream_put(s, &args->src, addrlen);

  /* Send the expected hops. */
  stream_putc(s, args->hops);

  /* Send interface name if any. */
  if (args->mhop) {
    /* Don't send interface. */
    stream_putc(s, 0);
    if (bsglobal.debugging && args->ifnamelen)
      zlog_debug("%s: multi hop is configured, not sending interface",
           __func__);
  } else {
    stream_putc(s, args->ifnamelen);
    if (args->ifnamelen)
      stream_put(s, args->ifname, args->ifnamelen);
  }

  /* Send the C bit indicator. */
  stream_putc(s, args->cbit);

  /* Send profile name if any. */
  stream_putc(s, args->profilelen);
  if (args->profilelen)
    stream_put(s, args->profile, args->profilelen);
#else /* PTM BFD */
  /* Encode timers if this is a registration message. */
  if (args->command != ZEBRA_BFD_DEST_DEREGISTER) {
    stream_putl(s, args->min_rx);
    stream_putl(s, args->min_tx);
    stream_putc(s, args->detection_multiplier);
  }

  if (args->mhop) {
    /* Multi hop indicator. */
    stream_putc(s, 1);

    /* Multi hop always sends the source address. */
    stream_putw(s, args->family);
    stream_put(s, &args->src, addrlen);

    /* Send the expected hops. */
    stream_putc(s, args->hops);
  } else {
    /* Multi hop indicator. */
    stream_putc(s, 0);

    /* Single hop only sends the source address when IPv6. */
    if (args->family == AF_INET6) {
      stream_putw(s, args->family);
      stream_put(s, &args->src, addrlen);
    }

    /* Send interface name if any. */
    stream_putc(s, args->ifnamelen);
    if (args->ifnamelen)
      stream_put(s, args->ifname, args->ifnamelen);
  }

  /* Send the C bit indicator. */
  stream_putc(s, args->cbit);
#endif /* HAVE_BFDD */

  /* Finish the message by writing the size. */
  stream_putw_at(s, 0, stream_get_endp(s));

  /* Send message to zebra. */
  if (zclient_send_message(zc) == ZCLIENT_SEND_FAILURE) {
    if (bsglobal.debugging)
      zlog_debug("%s: zclient_send_message failed", __func__);
    return -1;
  }

  return 0;
}

struct bfd_session_params *bfd_sess_new(bsp_status_update updatecb, void *arg)
{
  struct bfd_session_params *bsp;

  bsp = XCALLOC(MTYPE_BFD_INFO, sizeof(*bsp));

  /* Save application data. */
  bsp->updatecb = updatecb;
  bsp->arg = arg;

  /* Set defaults. */
  bsp->args.detection_multiplier = BFD_DEF_DETECT_MULT;
  bsp->args.hops = 1;
  bsp->args.min_rx = BFD_DEF_MIN_RX;
  bsp->args.min_tx = BFD_DEF_MIN_TX;
  bsp->args.vrf_id = VRF_DEFAULT;

  /* Register in global list. */
  TAILQ_INSERT_TAIL(&bsglobal.bsplist, bsp, entry);

  return bsp;
}

static bool _bfd_sess_valid(const struct bfd_session_params *bsp)
{
  /* Peer/local address not configured. */
  if (bsp->args.family == 0)
    return false;

  /* Address configured but invalid. */
  if (bsp->args.family != AF_INET && bsp->args.family != AF_INET6) {
    if (bsglobal.debugging)
      zlog_debug("%s: invalid session family: %d", __func__,
           bsp->args.family);
    return false;
  }

  /* Invalid address. */
  if (memcmp(&bsp->args.dst, &i6a_zero, sizeof(i6a_zero)) == 0) {
    if (bsglobal.debugging) {
      if (bsp->args.family == AF_INET)
        zlog_debug("%s: invalid address: %pI4",
             __func__,
             (struct in_addr *)&bsp->args.dst);
      else
        zlog_debug("%s: invalid address: %pI6",
             __func__, &bsp->args.dst);
    }
    return false;
  }

  /* Multi hop requires local address. */
  if (bsp->args.mhop
      && memcmp(&i6a_zero, &bsp->args.src, sizeof(i6a_zero)) == 0) {
    if (bsglobal.debugging)
      zlog_debug(
        "%s: multi hop but no local address provided",
        __func__);
    return false;
  }

  /* Check VRF ID. */
  if (bsp->args.vrf_id == VRF_UNKNOWN) {
    if (bsglobal.debugging)
      zlog_debug("%s: asked for unknown VRF", __func__);
    return false;
  }

  return true;
}

static void _bfd_sess_send(struct event *t)
{
  struct bfd_session_params *bsp = EVENT_ARG(t);
  int rv;

  /* Validate configuration before trying to send bogus data. */
  if (!_bfd_sess_valid(bsp))
    return;

  if (bsp->lastev == BSE_INSTALL) {
    bsp->args.command = bsp->installed ? ZEBRA_BFD_DEST_UPDATE
               : ZEBRA_BFD_DEST_REGISTER;
  } else
    bsp->args.command = ZEBRA_BFD_DEST_DEREGISTER;

  /* If not installed and asked for uninstall, do nothing. */
  if (!bsp->installed && bsp->args.command == ZEBRA_BFD_DEST_DEREGISTER)
    return;

  rv = zclient_bfd_command(bsglobal.zc, &bsp->args);
  /* Command was sent successfully. */
  if (rv == 0) {
    /* Update installation status. */
    if (bsp->args.command == ZEBRA_BFD_DEST_DEREGISTER)
      bsp->installed = false;
    else if (bsp->args.command == ZEBRA_BFD_DEST_REGISTER)
      bsp->installed = true;
  } else {
    struct ipaddr src, dst;

    src.ipa_type = bsp->args.family;
    src.ipaddr_v6 = bsp->args.src;
    dst.ipa_type = bsp->args.family;
    dst.ipaddr_v6 = bsp->args.dst;

    zlog_err(
      "%s: BFD session %pIA -> %pIA interface %s VRF %s(%u) was not %s",
      __func__, &src, &dst,
      bsp->args.ifnamelen ? bsp->args.ifname : "*",
      vrf_id_to_name(bsp->args.vrf_id), bsp->args.vrf_id,
      bsp->lastev == BSE_INSTALL ? "installed"
               : "uninstalled");
  }
}

static void _bfd_sess_remove(struct bfd_session_params *bsp)
{
  /* Cancel any pending installation request. */
  EVENT_OFF(bsp->installev);

  /* Not installed, nothing to do. */
  if (!bsp->installed)
    return;

  /* Send request to remove any session. */
  bsp->lastev = BSE_UNINSTALL;
  event_execute(bsglobal.tm, _bfd_sess_send, bsp, 0);
}

void bfd_sess_free(struct bfd_session_params **bsp)
{
  if (*bsp == NULL)
    return;

  /* Remove any installed session. */
  _bfd_sess_remove(*bsp);

  /* Remove from global list. */
  TAILQ_REMOVE(&bsglobal.bsplist, (*bsp), entry);

  bfd_source_cache_put(*bsp);

  /* Free the memory and point to NULL. */
  XFREE(MTYPE_BFD_INFO, (*bsp));
}

static bool bfd_sess_address_changed(const struct bfd_session_params *bsp,
             uint32_t family,
             const struct in6_addr *src,
             const struct in6_addr *dst)
{
  size_t addrlen;

  if (bsp->args.family != family)
    return true;

  addrlen = (family == AF_INET) ? sizeof(struct in_addr)
              : sizeof(struct in6_addr);
  if ((src == NULL && memcmp(&bsp->args.src, &i6a_zero, addrlen))
      || (src && memcmp(src, &bsp->args.src, addrlen))
      || memcmp(dst, &bsp->args.dst, addrlen))
    return true;

  return false;
}

void bfd_sess_set_ipv4_addrs(struct bfd_session_params *bsp,
           const struct in_addr *src,
           const struct in_addr *dst)
{
  if (!bfd_sess_address_changed(bsp, AF_INET, (struct in6_addr *)src,
              (struct in6_addr *)dst))
    return;

  /* If already installed, remove the old setting. */
  _bfd_sess_remove(bsp);
  /* Address changed so we must reapply auto source. */
  bfd_source_cache_put(bsp);

  bsp->args.family = AF_INET;

  /* Clean memory, set zero value and avoid static analyser warnings. */
  memset(&bsp->args.src, 0, sizeof(bsp->args.src));
  memset(&bsp->args.dst, 0, sizeof(bsp->args.dst));

  /* Copy the equivalent of IPv4 to arguments structure. */
  if (src)
    memcpy(&bsp->args.src, src, sizeof(struct in_addr));

  assert(dst);
  memcpy(&bsp->args.dst, dst, sizeof(struct in_addr));

  if (bsp->auto_source)
    bfd_source_cache_get(bsp);
}

void bfd_sess_set_ipv6_addrs(struct bfd_session_params *bsp,
           const struct in6_addr *src,
           const struct in6_addr *dst)
{
  if (!bfd_sess_address_changed(bsp, AF_INET6, src, dst))
    return;

  /* If already installed, remove the old setting. */
  _bfd_sess_remove(bsp);
  /* Address changed so we must reapply auto source. */
  bfd_source_cache_put(bsp);

  bsp->args.family = AF_INET6;

  /* Clean memory, set zero value and avoid static analyser warnings. */
  memset(&bsp->args.src, 0, sizeof(bsp->args.src));

  if (src)
    bsp->args.src = *src;

  assert(dst);
  bsp->args.dst = *dst;

  if (bsp->auto_source)
    bfd_source_cache_get(bsp);
}

void bfd_sess_set_interface(struct bfd_session_params *bsp, const char *ifname)
{
  if ((ifname == NULL && bsp->args.ifnamelen == 0)
      || (ifname && strcmp(bsp->args.ifname, ifname) == 0))
    return;

  /* If already installed, remove the old setting. */
  _bfd_sess_remove(bsp);

  if (ifname == NULL) {
    bsp->args.ifname[0] = 0;
    bsp->args.ifnamelen = 0;
    return;
  }

  if (strlcpy(bsp->args.ifname, ifname, sizeof(bsp->args.ifname))
      > sizeof(bsp->args.ifname))
    zlog_warn("%s: interface name truncated: %s", __func__, ifname);

  bsp->args.ifnamelen = strlen(bsp->args.ifname);
}

void bfd_sess_set_profile(struct bfd_session_params *bsp, const char *profile)
{
  if (profile == NULL) {
    bsp->args.profile[0] = 0;
    bsp->args.profilelen = 0;
    return;
  }

  if (strlcpy(bsp->args.profile, profile, sizeof(bsp->args.profile))
      > sizeof(bsp->args.profile))
    zlog_warn("%s: profile name truncated: %s", __func__, profile);

  bsp->args.profilelen = strlen(bsp->args.profile);
}

void bfd_sess_set_vrf(struct bfd_session_params *bsp, vrf_id_t vrf_id)
{
  if (bsp->args.vrf_id == vrf_id)
    return;

  /* If already installed, remove the old setting. */
  _bfd_sess_remove(bsp);
  /* Address changed so we must reapply auto source. */
  bfd_source_cache_put(bsp);

  bsp->args.vrf_id = vrf_id;

  if (bsp->auto_source)
    bfd_source_cache_get(bsp);
}

void bfd_sess_set_hop_count(struct bfd_session_params *bsp, uint8_t hops)
{
  if (bsp->args.hops == hops)
    return;

  /* If already installed, remove the old setting. */
  _bfd_sess_remove(bsp);

  bsp->args.hops = hops;
  bsp->args.mhop = (hops > 1);
}


void bfd_sess_set_cbit(struct bfd_session_params *bsp, bool enable)
{
  bsp->args.cbit = enable;
}

void bfd_sess_set_timers(struct bfd_session_params *bsp,
       uint8_t detection_multiplier, uint32_t min_rx,
       uint32_t min_tx)
{
  bsp->args.detection_multiplier = detection_multiplier;
  bsp->args.min_rx = min_rx;
  bsp->args.min_tx = min_tx;
}

void bfd_sess_set_auto_source(struct bfd_session_params *bsp, bool enable)
{
  if (bsp->auto_source == enable)
    return;

  bsp->auto_source = enable;
  if (enable)
    bfd_source_cache_get(bsp);
  else
    bfd_source_cache_put(bsp);
}

void bfd_sess_install(struct bfd_session_params *bsp)
{
  bsp->lastev = BSE_INSTALL;
  event_add_event(bsglobal.tm, _bfd_sess_send, bsp, 0, &bsp->installev);
}

void bfd_sess_uninstall(struct bfd_session_params *bsp)
{
  bsp->lastev = BSE_UNINSTALL;
  event_add_event(bsglobal.tm, _bfd_sess_send, bsp, 0, &bsp->installev);
}

enum bfd_session_state bfd_sess_status(const struct bfd_session_params *bsp)
{
  return bsp->bss.state;
}

uint8_t bfd_sess_hop_count(const struct bfd_session_params *bsp)
{
  return bsp->args.hops;
}

const char *bfd_sess_profile(const struct bfd_session_params *bsp)
{
  return bsp->args.profilelen ? bsp->args.profile : NULL;
}

void bfd_sess_addresses(const struct bfd_session_params *bsp, int *family,
      struct in6_addr *src, struct in6_addr *dst)
{
  *family = bsp->args.family;
  if (src)
    *src = bsp->args.src;
  if (dst)
    *dst = bsp->args.dst;
}

const char *bfd_sess_interface(const struct bfd_session_params *bsp)
{
  if (bsp->args.ifnamelen)
    return bsp->args.ifname;

  return NULL;
}

const char *bfd_sess_vrf(const struct bfd_session_params *bsp)
{
  return vrf_id_to_name(bsp->args.vrf_id);
}

vrf_id_t bfd_sess_vrf_id(const struct bfd_session_params *bsp)
{
  return bsp->args.vrf_id;
}

bool bfd_sess_cbit(const struct bfd_session_params *bsp)
{
  return bsp->args.cbit;
}

void bfd_sess_timers(const struct bfd_session_params *bsp,
         uint8_t *detection_multiplier, uint32_t *min_rx,
         uint32_t *min_tx)
{
  *detection_multiplier = bsp->args.detection_multiplier;
  *min_rx = bsp->args.min_rx;
  *min_tx = bsp->args.min_tx;
}

bool bfd_sess_auto_source(const struct bfd_session_params *bsp)
{
  return bsp->auto_source;
}

void bfd_sess_show(struct vty *vty, struct json_object *json,
       struct bfd_session_params *bsp)
{
  json_object *json_bfd = NULL;
  char time_buf[64];

  if (!bsp)
    return;

  /* Show type. */
  if (json) {
    json_bfd = json_object_new_object();
    if (bsp->args.mhop)
      json_object_string_add(json_bfd, "type", "multi hop");
    else
      json_object_string_add(json_bfd, "type", "single hop");
  } else
    vty_out(vty, "  BFD: Type: %s\n",
      bsp->args.mhop ? "multi hop" : "single hop");

  /* Show configuration. */
  if (json) {
    json_object_int_add(json_bfd, "detectMultiplier",
            bsp->args.detection_multiplier);
    json_object_int_add(json_bfd, "rxMinInterval",
            bsp->args.min_rx);
    json_object_int_add(json_bfd, "txMinInterval",
            bsp->args.min_tx);
  } else {
    vty_out(vty,
      "  Detect Multiplier: %d, Min Rx interval: %d, Min Tx interval: %d\n",
      bsp->args.detection_multiplier, bsp->args.min_rx,
      bsp->args.min_tx);
  }

  bfd_last_update(bsp->bss.last_event, time_buf, sizeof(time_buf));
  if (json) {
    json_object_string_add(json_bfd, "status",
               bfd_get_status_str(bsp->bss.state));
    json_object_string_add(json_bfd, "lastUpdate", time_buf);
  } else
    vty_out(vty, "  Status: %s, Last update: %s\n",
      bfd_get_status_str(bsp->bss.state), time_buf);

  if (json)
    json_object_object_add(json, "peerBfdInfo", json_bfd);
  else
    vty_out(vty, "\n");
}

/*
 * Zebra communication related.
 */

/**
 * Callback for reinstallation of all registered BFD sessions.
 *
 * Use this as `zclient` `bfd_dest_replay` callback.
 */
int zclient_bfd_session_replay(ZAPI_CALLBACK_ARGS)
{
  struct bfd_session_params *bsp;

  if (!zclient->bfd_integration)
    return 0;

  /* Do nothing when shutting down. */
  if (bsglobal.shutting_down)
    return 0;

  if (bsglobal.debugging)
    zlog_debug("%s: sending all sessions registered", __func__);

  /* Send the client registration */
  bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER, vrf_id);

  /* Replay all activated peers. */
  TAILQ_FOREACH (bsp, &bsglobal.bsplist, entry) {
    /* Skip not installed sessions. */
    if (!bsp->installed)
      continue;

    /* We are reconnecting, so we must send installation. */
    bsp->installed = false;

    /* Cancel any pending installation request. */
    EVENT_OFF(bsp->installev);

    /* Ask for installation. */
    bsp->lastev = BSE_INSTALL;
    event_execute(bsglobal.tm, _bfd_sess_send, bsp, 0);
  }

  return 0;
}

int zclient_bfd_session_update(ZAPI_CALLBACK_ARGS)
{
  struct bfd_session_params *bsp, *bspn;
  size_t sessions_updated = 0;
  struct interface *ifp;
  int remote_cbit = false;
  int state = BFD_STATUS_UNKNOWN;
  time_t now;
  size_t addrlen;
  struct prefix dp;
  struct prefix sp;
  char ifstr[128], cbitstr[32];

  if (!zclient->bfd_integration)
    return 0;

  /* Do nothing when shutting down. */
  if (bsglobal.shutting_down)
    return 0;

  ifp = bfd_get_peer_info(zclient->ibuf, &dp, &sp, &state, &remote_cbit,
        vrf_id);
  /*
   * When interface lookup fails or an invalid stream is read, we must
   * not proceed otherwise it will trigger an assertion while checking
   * family type below.
   */
  if (dp.family == 0 || sp.family == 0)
    return 0;

  if (bsglobal.debugging) {
    ifstr[0] = 0;
    if (ifp)
      snprintf(ifstr, sizeof(ifstr), " (interface %s)",
         ifp->name);

    snprintf(cbitstr, sizeof(cbitstr), " (CPI bit %s)",
       remote_cbit ? "yes" : "no");

    zlog_debug("%s: %pFX -> %pFX%s VRF %s(%u)%s: %s", __func__, &sp,
         &dp, ifstr, vrf_id_to_name(vrf_id), vrf_id, cbitstr,
         bfd_get_status_str(state));
  }

  switch (dp.family) {
  case AF_INET:
    addrlen = sizeof(struct in_addr);
    break;
  case AF_INET6:
    addrlen = sizeof(struct in6_addr);
    break;

  default:
    /* Unexpected value. */
    assert(0);
    break;
  }

  /* Cache current time to avoid multiple monotime clock calls. */
  now = monotime(NULL);

  /* Notify all matching sessions about update. */
  TAILQ_FOREACH_SAFE (bsp, &bsglobal.bsplist, entry, bspn) {
    /* Skip not installed entries. */
    if (!bsp->installed)
      continue;
    /* Skip different VRFs. */
    if (bsp->args.vrf_id != vrf_id)
      continue;
    /* Skip different families. */
    if (bsp->args.family != dp.family)
      continue;
    /* Skip different interface. */
    if (bsp->args.ifnamelen && ifp
        && strcmp(bsp->args.ifname, ifp->name) != 0)
      continue;
    /* Skip non matching destination addresses. */
    if (memcmp(&bsp->args.dst, &dp.u, addrlen) != 0)
      continue;
    /*
     * Source comparison test:
     * We will only compare source if BFD daemon provided the
     * source address and the protocol set a source address in
     * the configuration otherwise we'll just skip it.
     */
    if (sp.family && memcmp(&bsp->args.src, &i6a_zero, addrlen) != 0
        && memcmp(&sp.u, &i6a_zero, addrlen) != 0
        && memcmp(&bsp->args.src, &sp.u, addrlen) != 0)
      continue;
    /* No session state change. */
    if ((int)bsp->bss.state == state)
      continue;

    bsp->bss.last_event = now;
    bsp->bss.previous_state = bsp->bss.state;
    bsp->bss.state = state;
    bsp->bss.remote_cbit = remote_cbit;
    bsp->updatecb(bsp, &bsp->bss, bsp->arg);
    sessions_updated++;
  }

  if (bsglobal.debugging)
    zlog_debug("%s:   sessions updated: %zu", __func__,
         sessions_updated);

  return 0;
}

/**
 * Frees all allocated resources and stops any activity.
 *
 * Must be called after every BFD session has been successfully
 * unconfigured otherwise this function will `free()` any available
 * session causing existing pointers to dangle.
 *
 * This is just a comment, in practice it will be called by the FRR
 * library late finish hook. \see `bfd_protocol_integration_init`.
 */
static int bfd_protocol_integration_finish(void)
{
  if (bsglobal.zc == NULL)
    return 0;

  while (!TAILQ_EMPTY(&bsglobal.bsplist)) {
    struct bfd_session_params *session =
      TAILQ_FIRST(&bsglobal.bsplist);
    bfd_sess_free(&session);
  }

  /*
   * BFD source cache is linked to sessions, if all sessions are gone
   * then the source cache must be empty.
   */
  if (!SLIST_EMPTY(&bsglobal.source_list))
    zlog_warn("BFD integration source cache not empty");

  return 0;
}

void bfd_protocol_integration_init(struct zclient *zc, struct event_loop *tm)
{
  /* Initialize data structure. */
  TAILQ_INIT(&bsglobal.bsplist);
  SLIST_INIT(&bsglobal.source_list);

  /* Copy pointers. */
  bsglobal.zc = zc;
  bsglobal.tm = tm;

  /* Enable BFD callbacks. */
  zc->bfd_integration = true;

  /* Send the client registration */
  bfd_client_sendmsg(zc, ZEBRA_BFD_CLIENT_REGISTER, VRF_DEFAULT);

  hook_register(frr_fini, bfd_protocol_integration_finish);
}

void bfd_protocol_integration_set_debug(bool enable)
{
  bsglobal.debugging = enable;
}

void bfd_protocol_integration_set_shutdown(bool enable)
{
  bsglobal.shutting_down = enable;
}

bool bfd_protocol_integration_debug(void)
{
  return bsglobal.debugging;
}

bool bfd_protocol_integration_shutting_down(void)
{
  return bsglobal.shutting_down;
}

/*
 * BFD automatic source selection
 *
 * This feature will use the next hop tracking (NHT) provided by zebra
 * to find out the source address by looking at the output interface.
 *
 * When the interface address / routing table change we'll be notified
 * and be able to update the source address accordingly.
 *
 *     <daemon>                 zebra
 *         |
 * +-----------------+
 * | BFD session set |
 * | to auto source  |
 * +-----------------+
 *         |
 *         \                 +-----------------+
 *          -------------->  | Resolves        |
 *                           | destination     |
 *                           | address         |
 *                           +-----------------+
 *                                |
 * +-----------------+            /
 * | Sets resolved   | <----------
 * | source address  |
 * +-----------------+
 */
static bool
bfd_source_cache_session_match(const struct bfd_source_cache *source,
             const struct bfd_session_params *session)
{
  const struct in_addr *address;
  const struct in6_addr *address_v6;

  if (session->args.vrf_id != source->vrf_id)
    return false;
  if (session->args.family != source->address.family)
    return false;

  switch (session->args.family) {
  case AF_INET:
    address = (const struct in_addr *)&session->args.dst;
    if (address->s_addr != source->address.u.prefix4.s_addr)
      return false;
    break;
  case AF_INET6:
    address_v6 = &session->args.dst;
    if (memcmp(address_v6, &source->address.u.prefix6,
         sizeof(struct in6_addr)))
      return false;
    break;
  default:
    return false;
  }

  return true;
}

static struct bfd_source_cache *
bfd_source_cache_find(vrf_id_t vrf_id, const struct prefix *prefix)
{
  struct bfd_source_cache *source;

  SLIST_FOREACH (source, &bsglobal.source_list, entry) {
    if (source->vrf_id != vrf_id)
      continue;
    if (!prefix_same(&source->address, prefix))
      continue;

    return source;
  }

  return NULL;
}

static void bfd_source_cache_get(struct bfd_session_params *session)
{
  struct bfd_source_cache *source;
  struct prefix target = {};

  switch (session->args.family) {
  case AF_INET:
    target.family = AF_INET;
    target.prefixlen = IPV4_MAX_BITLEN;
    memcpy(&target.u.prefix4, &session->args.dst,
           sizeof(struct in_addr));
    break;
  case AF_INET6:
    target.family = AF_INET6;
    target.prefixlen = IPV6_MAX_BITLEN;
    memcpy(&target.u.prefix6, &session->args.dst,
           sizeof(struct in6_addr));
    break;
  default:
    return;
  }

  source = bfd_source_cache_find(session->args.vrf_id, &target);
  if (source) {
    if (session->source_cache == source)
      return;

    bfd_source_cache_put(session);
    session->source_cache = source;
    source->refcount++;
    return;
  }

  source = XCALLOC(MTYPE_BFD_SOURCE, sizeof(*source));
  prefix_copy(&source->address, &target);
  source->vrf_id = session->args.vrf_id;
  SLIST_INSERT_HEAD(&bsglobal.source_list, source, entry);

  bfd_source_cache_put(session);
  session->source_cache = source;
  source->refcount = 1;

  return;
}

static void bfd_source_cache_put(struct bfd_session_params *session)
{
  if (session->source_cache == NULL)
    return;

  session->source_cache->refcount--;
  if (session->source_cache->refcount > 0) {
    session->source_cache = NULL;
    return;
  }

  SLIST_REMOVE(&bsglobal.source_list, session->source_cache,
         bfd_source_cache, entry);
  XFREE(MTYPE_BFD_SOURCE, session->source_cache);
}

/** Updates BFD running session if source address has changed. */
static void
bfd_source_cache_update_session(const struct bfd_source_cache *source,
        struct bfd_session_params *session)
{
  const struct in_addr *address;
  const struct in6_addr *address_v6;

  switch (session->args.family) {
  case AF_INET:
    address = (const struct in_addr *)&session->args.src;
    if (memcmp(address, &source->source.u.prefix4,
         sizeof(struct in_addr)) == 0)
      return;

    _bfd_sess_remove(session);
    memcpy(&session->args.src, &source->source.u.prefix4,
           sizeof(struct in_addr));
    break;
  case AF_INET6:
    address_v6 = &session->args.src;
    if (memcmp(address_v6, &source->source.u.prefix6,
         sizeof(struct in6_addr)) == 0)
      return;

    _bfd_sess_remove(session);
    memcpy(&session->args.src, &source->source.u.prefix6,
           sizeof(struct in6_addr));
    break;
  default:
    return;
  }

  bfd_sess_install(session);
}

static void
bfd_source_cache_update_sessions(const struct bfd_source_cache *source)
{
  struct bfd_session_params *session;

  if (!source->valid)
    return;

  TAILQ_FOREACH (session, &bsglobal.bsplist, entry) {
    if (!session->auto_source)
      continue;
    if (!bfd_source_cache_session_match(source, session))
      continue;

    bfd_source_cache_update_session(source, session);
  }
}

/**
 * Try to translate next hop information into source address.
 *
 * \returns `true` if source changed otherwise `false`.
 */
static bool bfd_source_cache_update(struct bfd_source_cache *source,
            const struct zapi_route *route)
{
  size_t nh_index;

  for (nh_index = 0; nh_index < route->nexthop_num; nh_index++) {
    const struct zapi_nexthop *nh = &route->nexthops[nh_index];
    const struct interface *interface;
    const struct connected *connected;
    const struct listnode *node;

    interface = if_lookup_by_index(nh->ifindex, nh->vrf_id);
    if (interface == NULL) {
      zlog_err("next hop interface not found (index %d)",
         nh->ifindex);
      continue;
    }

    for (ALL_LIST_ELEMENTS_RO(interface->connected, node,
            connected)) {
      if (source->address.family !=
          connected->address->family)
        continue;
      if (prefix_same(connected->address, &source->source))
        return false;
      /*
       * Skip link-local as it is only useful for single hop
       * and in that case no source is specified usually.
       */
      if (source->address.family == AF_INET6 &&
          IN6_IS_ADDR_LINKLOCAL(
            &connected->address->u.prefix6))
        continue;

      prefix_copy(&source->source, connected->address);
      source->valid = true;
      return true;
    }
  }

  memset(&source->source, 0, sizeof(source->source));
  source->valid = false;
  return false;
}

int bfd_nht_update(const struct prefix *match, const struct zapi_route *route)
{
  struct bfd_source_cache *source;

  if (bsglobal.debugging)
    zlog_debug("BFD NHT update for %pFX", &route->prefix);

  SLIST_FOREACH (source, &bsglobal.source_list, entry) {
    if (source->vrf_id != route->vrf_id)
      continue;
    if (!prefix_same(match, &source->address))
      continue;
    if (bfd_source_cache_update(source, route))
      bfd_source_cache_update_sessions(source);
  }

  return 0;
}

Coverage Report

Created: 2025-10-23 06:55