vrrp_api.c

Go to the documentation of this file.

/*
 * vrrp.c - vpp vrrp plug-in
 *
 * Copyright 2019-2020 Rubicon Communications, LLC (Netgate)
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 */
 
#include <vnet/vnet.h>
#include <vnet/plugin/plugin.h>
#include <vrrp/vrrp.h>
 
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
#include <vpp/app/version.h>
 
/* define message IDs */
#include <vnet/format_fns.h>
#include <vrrp/vrrp.api_enum.h>
#include <vrrp/vrrp.api_types.h>
 
#define REPLY_MSG_ID_BASE vrrp_main.msg_id_base
#include <vlibapi/api_helper_macros.h>
 
/* API message handlers */
static void
vl_api_vrrp_vr_add_del_t_handler (vl_api_vrrp_vr_add_del_t * mp)
{
  vl_api_vrrp_vr_add_del_reply_t *rmp;
  vrrp_vr_config_t vr_conf;
  u32 api_flags;
  ip46_address_t *addrs = 0;
  int rv;
 
  VALIDATE_SW_IF_INDEX (mp);
 
  api_flags = htonl (mp->flags);
 
  clib_memset (&vr_conf, 0, sizeof (vr_conf));
 
  vr_conf.sw_if_index = ntohl (mp->sw_if_index);
  vr_conf.vr_id = mp->vr_id;
  vr_conf.priority = mp->priority;
  vr_conf.adv_interval = ntohs (mp->interval);
 
  if (api_flags & VRRP_API_VR_PREEMPT)
    vr_conf.flags |= VRRP_VR_PREEMPT;
 
  if (api_flags & VRRP_API_VR_ACCEPT)
    vr_conf.flags |= VRRP_VR_ACCEPT;
 
  if (api_flags & VRRP_API_VR_UNICAST)
    vr_conf.flags |= VRRP_VR_UNICAST;
 
  if (api_flags & VRRP_API_VR_IPV6)
    vr_conf.flags |= VRRP_VR_IPV6;
 
  if (mp->is_add)
    {
      int i;
 
      for (i = 0; i < mp->n_addrs; i++)
        {
          ip46_address_t *addr;
          void *src, *dst;
          int len;
 
          vec_add2 (addrs, addr, 1);
 
          if (ntohl (mp->addrs[i].af) == ADDRESS_IP4)
            {
              src = &mp->addrs[i].un.ip4;
              dst = &addr->ip4;
              len = sizeof (addr->ip4);
            }
          else
            {
              src = &mp->addrs[i].un.ip6;
              dst = &addr->ip6;
              len = sizeof (addr->ip6);
            }
 
          clib_memcpy (dst, src, len);
        }
 
      vr_conf.vr_addrs = addrs;
    }
 
  if (vr_conf.priority == 0)
    {
      clib_warning ("VR priority must be > 0");
      rv = VNET_API_ERROR_INVALID_VALUE;
    }
  else if (vr_conf.adv_interval == 0)
    {
      clib_warning ("VR advertisement interval must be > 0");
      rv = VNET_API_ERROR_INVALID_VALUE;
    }
  else if (vr_conf.vr_id == 0)
    {
      clib_warning ("VR ID must be > 0");
      rv = VNET_API_ERROR_INVALID_VALUE;
    }
  else
    rv = vrrp_vr_add_del (mp->is_add, &vr_conf);
 
  vec_free (addrs);
 
  BAD_SW_IF_INDEX_LABEL;
  REPLY_MACRO (VL_API_VRRP_VR_ADD_DEL_REPLY);
}
 
static vl_api_vrrp_vr_state_t
vrrp_vr_state_encode (vrrp_vr_state_t vr_state)
{
  if (vr_state == VRRP_VR_STATE_BACKUP)
    return VRRP_API_VR_STATE_BACKUP;
  if (vr_state == VRRP_VR_STATE_MASTER)
    return VRRP_API_VR_STATE_MASTER;
  if (vr_state == VRRP_VR_STATE_INTF_DOWN)
    return VRRP_API_VR_STATE_INTF_DOWN;
 
  return VRRP_API_VR_STATE_INIT;
}
 
static void
send_vrrp_vr_details (vrrp_vr_t * vr, vl_api_registration_t * reg,
                      u32 context)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_vrrp_vr_details_t *mp;
  int n_addrs, msg_size;
  ip46_address_t *addr;
  vl_api_address_t *api_addr;
  u32 api_flags = 0;
 
  n_addrs = vec_len (vr->config.vr_addrs);
  msg_size = sizeof (*mp) + n_addrs * sizeof (*api_addr);
  mp = vl_msg_api_alloc (msg_size);
  if (!mp)
    return;
  clib_memset (mp, 0, msg_size);
  mp->_vl_msg_id = htons (VL_API_VRRP_VR_DETAILS + vmp->msg_id_base);
  mp->context = context;
 
  /* config */
  mp->config.sw_if_index = htonl (vr->config.sw_if_index);
  mp->config.vr_id = vr->config.vr_id;
  mp->config.priority = vr->config.priority;
  mp->config.interval = htons (vr->config.adv_interval);
 
  if (vr->config.flags & VRRP_VR_PREEMPT)
    api_flags |= VRRP_API_VR_PREEMPT;
  if (vr->config.flags & VRRP_VR_ACCEPT)
    api_flags |= VRRP_API_VR_ACCEPT;
  if (vrrp_vr_is_unicast (vr))
    api_flags |= VRRP_API_VR_UNICAST;
  if (vrrp_vr_is_ipv6 (vr))
    api_flags |= VRRP_API_VR_IPV6;
 
  mp->config.flags = htonl (api_flags);
 
  /* runtime */
  mp->runtime.state = htonl (vrrp_vr_state_encode (vr->runtime.state));
 
  mp->runtime.master_adv_int = htons (vr->runtime.master_adv_int);
  mp->runtime.skew = htons (vr->runtime.skew);
  mp->runtime.master_down_int = htons (vr->runtime.master_down_int);
  clib_memcpy (&mp->runtime.mac, &vr->runtime.mac, sizeof (vr->runtime.mac));
 
  mp->runtime.tracking.interfaces_dec = htonl (vr->tracking.interfaces_dec);
  mp->runtime.tracking.priority = vrrp_vr_priority (vr);
 
  /* addrs */
  mp->n_addrs = vec_len (vr->config.vr_addrs);
  api_addr = mp->addrs;
  vec_foreach (addr, vr->config.vr_addrs)
  {
    void *src, *dst;
    size_t len;
 
    if (vrrp_vr_is_ipv6 (vr))
      {
        api_addr->af = ADDRESS_IP6;
        dst = &api_addr->un.ip6;
        src = &addr->ip6;
        len = sizeof (addr->ip6);
      }
    else
      {
        api_addr->af = ADDRESS_IP4;
        dst = &api_addr->un.ip4;
        src = &addr->ip4;
        len = sizeof (addr->ip4);
      }
    clib_memcpy (dst, src, len);
    api_addr++;
  }
 
  vl_api_send_msg (reg, (u8 *) mp);
}
 
static void
vl_api_vrrp_vr_dump_t_handler (vl_api_vrrp_vr_dump_t * mp)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_registration_t *reg;
  vrrp_vr_t *vr;
  u32 sw_if_index;
 
  reg = vl_api_client_index_to_registration (mp->client_index);
  if (!reg)
    return;
 
  sw_if_index = htonl (mp->sw_if_index);
 
  /* *INDENT-OFF* */
  pool_foreach (vr, vmp->vrs)  {
 
    if (sw_if_index && (sw_if_index != ~0) &&
        (sw_if_index != vr->config.sw_if_index))
      continue;
 
    send_vrrp_vr_details (vr, reg, mp->context);
  }
  /* *INDENT-ON* */
}
 
static void
vl_api_vrrp_vr_start_stop_t_handler (vl_api_vrrp_vr_start_stop_t * mp)
{
  vl_api_vrrp_vr_start_stop_reply_t *rmp;
  vrrp_vr_key_t vr_key;
  int rv;
 
  clib_memset (&vr_key, 0, sizeof (vr_key));
 
  vr_key.sw_if_index = ntohl (mp->sw_if_index);
  vr_key.vr_id = mp->vr_id;
  vr_key.is_ipv6 = (mp->is_ipv6 != 0);
 
  rv = vrrp_vr_start_stop ((mp->is_start != 0), &vr_key);
 
  REPLY_MACRO (VL_API_VRRP_VR_START_STOP_REPLY);
}
 
static void
vl_api_vrrp_vr_set_peers_t_handler (vl_api_vrrp_vr_set_peers_t * mp)
{
  vl_api_vrrp_vr_set_peers_reply_t *rmp;
  vrrp_vr_key_t vr_key;
  ip46_address_t *peer_addrs = 0;
  int i;
  int rv;
 
  clib_memset (&vr_key, 0, sizeof (vr_key));
 
  vr_key.sw_if_index = ntohl (mp->sw_if_index);
  vr_key.vr_id = mp->vr_id;
  vr_key.is_ipv6 = (mp->is_ipv6 != 0);
 
  for (i = 0; i < mp->n_addrs; i++)
    {
      ip46_address_t *peer;
 
      vec_add2 (peer_addrs, peer, 1);
 
      if (mp->is_ipv6)
        clib_memcpy (&peer->ip6, mp->addrs[i].un.ip6, 16);
      else
        clib_memcpy (&peer->ip4, mp->addrs[i].un.ip4, 4);
    }
 
  rv = vrrp_vr_set_peers (&vr_key, peer_addrs);
 
  vec_free (peer_addrs);
  REPLY_MACRO (VL_API_VRRP_VR_SET_PEERS_REPLY);
}
 
static void
send_vrrp_vr_peer_details (vrrp_vr_t * vr, vl_api_registration_t * reg,
                           u32 context)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_vrrp_vr_peer_details_t *mp;
  int n_addrs, msg_size;
  ip46_address_t *addr;
  vl_api_address_t *api_addr;
 
  n_addrs = vec_len (vr->config.peer_addrs);
  msg_size = sizeof (*mp) + n_addrs * sizeof (*api_addr);
  mp = vl_msg_api_alloc (msg_size);
  if (!mp)
    return;
  clib_memset (mp, 0, msg_size);
  mp->_vl_msg_id = htons (VL_API_VRRP_VR_PEER_DETAILS + vmp->msg_id_base);
  mp->context = context;
 
  mp->sw_if_index = htonl (vr->config.sw_if_index);
  mp->vr_id = vr->config.vr_id;
  mp->is_ipv6 = vrrp_vr_is_ipv6 (vr);
 
  /* addrs */
  mp->n_peer_addrs = n_addrs;
  api_addr = mp->peer_addrs;
  vec_foreach (addr, vr->config.peer_addrs)
  {
    void *src, *dst;
    size_t len;
 
    if (vrrp_vr_is_ipv6 (vr))
      {
        api_addr->af = ADDRESS_IP6;
        dst = &api_addr->un.ip6;
        src = &addr->ip6;
        len = sizeof (addr->ip6);
      }
    else
      {
        api_addr->af = ADDRESS_IP4;
        dst = &api_addr->un.ip4;
        src = &addr->ip4;
        len = sizeof (addr->ip4);
      }
    clib_memcpy (dst, src, len);
    api_addr++;
  }
 
  vl_api_send_msg (reg, (u8 *) mp);
}
 
static void
vl_api_vrrp_vr_peer_dump_t_handler (vl_api_vrrp_vr_peer_dump_t * mp)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_registration_t *reg;
  vrrp_vr_t *vr;
  vrrp_vr_key_t vr_key;
 
  reg = vl_api_client_index_to_registration (mp->client_index);
  if (!reg)
    return;
 
  vr_key.sw_if_index = ntohl (mp->sw_if_index);
 
  if (vr_key.sw_if_index && (vr_key.sw_if_index != ~0))
    {
      uword *p;
      u32 vr_index = ~0;
 
      vr_key.vr_id = mp->vr_id;
      vr_key.is_ipv6 = mp->is_ipv6;
 
      p = mhash_get (&vmp->vr_index_by_key, &vr_key);
      if (!p)
        return;
 
      vr_index = p[0];
      vr = pool_elt_at_index (vmp->vrs, vr_index);
      send_vrrp_vr_peer_details (vr, reg, mp->context);
 
      return;
    }
 
  /* *INDENT-OFF* */
  pool_foreach (vr, vmp->vrs)  {
 
    if (!vec_len (vr->config.peer_addrs))
      continue;
 
    send_vrrp_vr_details (vr, reg, mp->context);
 
  }
  /* *INDENT-ON* */
}
 
static void
  vl_api_vrrp_vr_track_if_add_del_t_handler
  (vl_api_vrrp_vr_track_if_add_del_t * mp)
{
  vl_api_vrrp_vr_track_if_add_del_reply_t *rmp;
  vrrp_vr_t *vr;
  vrrp_vr_tracking_if_t *track_if, *track_ifs = 0;
  int rv = 0, i;
 
  /* lookup VR and return error if it does not exist */
  vr =
    vrrp_vr_lookup (ntohl (mp->sw_if_index), mp->vr_id, (mp->is_ipv6 != 0));
  if (!vr)
    {
      rv = VNET_API_ERROR_INVALID_VALUE;
      goto done;
    }
 
  for (i = 0; i < mp->n_ifs; i++)
    {
      vl_api_vrrp_vr_track_if_t *api_track_if = &mp->ifs[i];
 
      vec_add2 (track_ifs, track_if, 1);
      track_if->sw_if_index = ntohl (api_track_if->sw_if_index);
      track_if->priority = api_track_if->priority;
    }
 
  rv = vrrp_vr_tracking_ifs_add_del (vr, track_ifs, mp->is_add != 0);
 
done:
  vec_free (track_ifs);
  REPLY_MACRO (VL_API_VRRP_VR_TRACK_IF_ADD_DEL_REPLY);
}
 
static void
send_vrrp_vr_track_if_details (vrrp_vr_t * vr, vl_api_registration_t * reg,
                               u32 context)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_vrrp_vr_track_if_details_t *mp;
  int n_ifs, msg_size;
  vl_api_vrrp_vr_track_if_t *api_track_if;
  vrrp_vr_tracking_if_t *track_if;
 
  if (!vr)
    return;
 
  n_ifs = vec_len (vr->tracking.interfaces);
  msg_size = sizeof (*mp) + n_ifs * sizeof (*api_track_if);
  mp = vl_msg_api_alloc (msg_size);
  if (!mp)
    return;
  clib_memset (mp, 0, msg_size);
  mp->_vl_msg_id = htons (VL_API_VRRP_VR_TRACK_IF_DETAILS + vmp->msg_id_base);
  mp->context = context;
 
  mp->sw_if_index = htonl (vr->config.sw_if_index);
  mp->vr_id = vr->config.vr_id;
  mp->is_ipv6 = vrrp_vr_is_ipv6 (vr);
 
  /* tracked interfaces */
  mp->n_ifs = n_ifs;
  api_track_if = mp->ifs;
  vec_foreach (track_if, vr->tracking.interfaces)
  {
    api_track_if->sw_if_index = htonl (track_if->sw_if_index);
    api_track_if->priority = track_if->priority;
    api_track_if += 1;
  }
 
  vl_api_send_msg (reg, (u8 *) mp);
}
 
static void
vl_api_vrrp_vr_track_if_dump_t_handler (vl_api_vrrp_vr_track_if_dump_t * mp)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_registration_t *reg;
  vrrp_vr_t *vr;
 
  reg = vl_api_client_index_to_registration (mp->client_index);
  if (!reg)
    return;
 
  if (!mp->dump_all)
    {
      vr = vrrp_vr_lookup (ntohl (mp->sw_if_index), mp->vr_id, mp->is_ipv6);
      send_vrrp_vr_track_if_details (vr, reg, mp->context);
 
      return;
    }
 
  /* *INDENT-OFF* */
  pool_foreach (vr, vmp->vrs)  {
 
    if (!vec_len (vr->tracking.interfaces))
      continue;
 
    send_vrrp_vr_track_if_details (vr, reg, mp->context);
 
  }
  /* *INDENT-ON* */
}
 
static void
send_vrrp_vr_event (vpe_client_registration_t * reg,
                    vl_api_registration_t * vl_reg,
                    vrrp_vr_t * vr, vrrp_vr_state_t new_state)
{
  vrrp_main_t *vmp = &vrrp_main;
  vl_api_vrrp_vr_event_t *mp;
 
  mp = vl_msg_api_alloc (sizeof (*mp));
 
  clib_memset (mp, 0, sizeof (*mp));
  mp->_vl_msg_id = ntohs (VL_API_VRRP_VR_EVENT + vmp->msg_id_base);
  mp->client_index = reg->client_index;
  mp->pid = reg->client_pid;
  mp->vr.sw_if_index = ntohl (vr->config.sw_if_index);
  mp->vr.vr_id = vr->config.vr_id;
  mp->vr.is_ipv6 = ((vr->config.flags & VRRP_VR_IPV6) != 0);
 
  mp->old_state = htonl (vrrp_vr_state_encode (vr->runtime.state));
  mp->new_state = htonl (vrrp_vr_state_encode (new_state));
 
  vl_api_send_msg (vl_reg, (u8 *) mp);
}
 
void
vrrp_vr_event (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
{
  vpe_api_main_t *vam = &vpe_api_main;
  vpe_client_registration_t *reg;
  vl_api_registration_t *vl_reg;
 
  /* *INDENT-OFF* */
  pool_foreach (reg, vam->vrrp_vr_events_registrations)
   {
    vl_reg = vl_api_client_index_to_registration (reg->client_index);
    if (vl_reg)
      send_vrrp_vr_event (reg, vl_reg, vr, new_state);
  }
  /* *INDENT-ON* */
}
 
pub_sub_handler (vrrp_vr_events, VRRP_VR_EVENTS);
 
/* Set up the API message handling tables */
#include <vrrp/vrrp.api.c>
clib_error_t *
vrrp_plugin_api_hookup (vlib_main_t * vm)
{
  vrrp_main_t *vmp = &vrrp_main;
 
  /* Ask for a correctly-sized block of API message decode slots */
  vmp->msg_id_base = setup_message_id_table ();
 
  return 0;
}
 
/* *INDENT-ON* */
 
/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */