bird/sysdep/unix/mkrt.c

/*
 *  BIRD -- Multicast routing kernel
 *
 *  (c) 2016 Ondrej Hlavaty <aearsis@eideo.cz>
 *
 *  Can be freely distributed and used under the terms of the GNU GPL.
 */

/*
 * DOC: Multicast route kernel synchronization
 *
 * This protocol is the BIRD's interface to the kernel part of multicast
 * routing. It assignes the VIF indices to interfaces, forwards the IGMP
 * packets to SK_IGMP sockets and, of course, adds MFC entries to the kernel.
 *
 * Multicast in current kernel is a bit tricky. There must be exactly one
 * socket on which setsockopt MRT_INIT is called, then multicast forwarding is
 * enabled. Every multicast routing table update must be done through this
 * protocol.
 *
 * Also, that socket is the only one that receives IGMP packets on non-joined
 * groups. These packets IGMP protocol needs to receive, so we forward them
 * internally. To simulate sane behavior, protocol can open socket with type
 * SK_IGMP, which is almost as a SK_IP, IPPROTO_IGMP socket but receives copy
 * of all packets.
 *
 * As always with system-dependent code, prepare for everything. Because the
 * BSD kernel knows nothing apart from (S,G) routes, and Linux even blocked the
 * (*,G) routes for something not being a regular (*,G) routes, we must add the
 * routes in reaction to missed packets. This is very bad, but probably the
 * only solution, until someone rewrites the kernel part.
 *
 * Part of the protocol is global and "static", without the need to configure.
 * Another part is a usual proto instance.
 */

#include "nest/bird.h"
#include "nest/iface.h"
#include "lib/socket.h"
#include "sysdep/unix/unix.h"
#include "sysdep/unix/mkrt.h"

#define HASH_I_KEY(n)	n->iface->index
#define HASH_I_NEXT(n)	n->next
#define HASH_I_EQ(a,b)	(a == b)
#define HASH_I_FN(n)	n

#define HASH_MFC_KEY(n)		n->ga
#define HASH_MFC_NEXT(n)	n->next
#define HASH_MFC_EQ(a,b)	ipa_equal(a, b)
#define HASH_MFC_FN(k)		ipa_hash(k)

static struct mkrt_config *mkrt_cf;

/* Global code for SK_IGMP sockets */

struct mkrt_iface {
  struct mkrt_iface *next;
  struct iface *iface;
  list sockets;
};

static struct mkrt_global {
  pool *pool;
  list sockets;
  HASH(struct mkrt_iface) ifaces;
} mkrt_global;

void
mkrt_io_init(void)
{
  mkrt_global.pool = rp_new(&root_pool, "Multicast kernel Syncer");
  HASH_INIT(mkrt_global.ifaces, mkrt_global.pool, 6);
  init_list(&mkrt_global.sockets);
}

static struct mkrt_iface *
mkrt_iface_find(struct mkrt_proto *p, unsigned ifindex)
{
  return HASH_FIND(mkrt_global.ifaces, HASH_I, ifindex);
}

static struct mkrt_iface *
mkrt_iface_get(unsigned ifindex)
{
  struct mkrt_iface *ifa = HASH_FIND(mkrt_global.ifaces, HASH_I, ifindex);
  if (ifa)
    return ifa;

  ifa = mb_allocz(mkrt_global.pool, sizeof(struct mkrt_iface));
  init_list(&ifa->sockets);
  ifa->iface = if_find_by_index(ifindex);

  HASH_INSERT(mkrt_global.ifaces, HASH_I, ifa);
  return ifa;
}

/*
 * Add the socket into the list of sockets that are passed a copy of every IGMP
 * packet received on the control socket.
 */
void
mkrt_listen(sock *s)
{
  ASSERT(s->type == SK_IGMP);

  if (s->iface)
    {
      struct mkrt_iface *i = mkrt_iface_get(s->iface->index);
      add_tail(&i->sockets, &s->n);
    }
  else
    add_tail(&mkrt_global.sockets, &s->n);

  log(L_INFO "Socket fd %i getting IGMP", s->fd);
}

/*
 * Forward a packet from one socket to another. Emulates the receiving routine.
 * Socket is in exactly the same state as if it received the packet itself, but
 * must not modify it to preserve it for others.
 */
static inline void
mkrt_rx_forward(sock *from, sock *to, int len)
{
  if (!to->rx_hook)
    return;

  to->faddr = from->faddr;
  if (to->flags & SKF_LADDR_RX)
    {
      to->laddr = from->laddr;
      to->lifindex = from->lifindex;
    }

  to->rbuf = from->rbuf;
  to->rpos = from->rpos;
  to->rbsize = from->rbsize;

  to->rx_hook(to, len);

  to->faddr = to->laddr = IPA_NONE;
  to->lifindex = 0;
  to->rbuf = to->rpos = NULL;
  to->rbsize = 0;
}

/*
 * Forward a packet to all sockets on a list.
 */
static inline void
mkrt_rx_forward_all(list *sockets, sock *sk, int len)
{
  node *n, *next;

  WALK_LIST_DELSAFE(n, next, *sockets)
    mkrt_rx_forward(sk, SKIP_BACK(sock, n, n), len);
}

/***************
  Mkernel proto
 ***************/

/*
 * Call a setsockopt with a MRT_ option.
 */
static inline int
mkrt_call(struct mkrt_proto *mkrt, int option_name, const void *val, socklen_t len)
{
  return setsockopt(mkrt->igmp_sock->fd, IPPROTO_IP, option_name, val, len);
}

static inline vifi_t
mkrt_alloc_vifi(struct mkrt_proto *p, struct iface *iface)
{
  if (p->vif_count >= MAXVIFS)
    {
      log(L_ERR "Maximum number of interfaces for multicast routing reached.");
      return -1;
    }

  for (vifi_t i = 0; ; i = (i + 1) % MAXVIFS)
    if (p->vif_map[i] == NULL)
      {
	p->vif_map[i] = iface;
	iface->vifi = i;
	p->vif_count++;
	return i;
      }
}

static inline void
mkrt_free_vifi(struct mkrt_proto *p, vifi_t vifi)
{
  p->vif_count -= p->vif_map[vifi] != NULL;
  p->vif_map[vifi] = NULL;
}

static void
mkrt_add_vif(struct mkrt_proto *p, struct iface *i)
{
  int err;

  if (i->flags & IF_VIFI_ASSIGNED)
    return;

  mkrt_alloc_vifi(p, i);

  struct vifctl vc = {0};
  vc.vifc_vifi = i->vifi;
  vc.vifc_flags = VIFF_USE_IFINDEX;
  vc.vifc_lcl_ifindex = i->index;

  if ((err = mkrt_call(p, MRT_ADD_VIF, &vc, sizeof(vc))) < 0)
    goto err;

  TRACE(D_EVENTS, "Iface %s (%i) assigned VIF %i", i->name, i->index, i->vifi);

  i->flags |= IF_VIFI_ASSIGNED;
  return;

err:
  log(L_ERR "Error while assigning %s VIF %i: %m", i->name, i->vifi, err);
  mkrt_free_vifi(p, i->vifi);
}

static int
mkrt_del_vif(struct mkrt_proto *p, struct iface *i)
{
  int err;

  if (!i->flags & IF_VIFI_ASSIGNED)
    return 0;

  struct vifctl vc = {0};
  vc.vifc_vifi = i->vifi;

  if ((err = mkrt_call(p, MRT_DEL_VIF, &vc, sizeof(vc))) < 0)
    goto err;

  mkrt_free_vifi(p, i->vifi);
  i->flags &= ~IF_VIFI_ASSIGNED;
  return 0;
err:
  log(L_ERR "Error while unassigning %s VIF %i: %m", i->name, i->vifi, err);
  return err;
}

static struct mkrt_mfc_group *
mkrt_mfc_get(struct mkrt_proto *p, ip_addr ga)
{
  struct mkrt_mfc_group *mg = HASH_FIND(p->mfc_groups, HASH_MFC, ga);
  if (mg)
    return mg;

  mg = mb_allocz(p->p.pool, sizeof(struct mkrt_mfc_group));
  mg->ga = ga;
  init_list(&mg->sources);
  HASH_INSERT(p->mfc_groups, HASH_MFC, mg);
  return mg;
}

/*
 * Add a MFC entry for (S, G) with parent vifi, according to the route.
 */
static int
mkrt_mfc_update(struct mkrt_proto *p, ip_addr group, ip_addr source, int vifi, struct rte *rte)
{
  struct mfcctl mc = {0};
  int err;

  mc.mfcc_origin = ipa_to_in4(source);
  mc.mfcc_mcastgrp = ipa_to_in4(group);
  mc.mfcc_parent = vifi;

  if (rte && RTE_MGRP_ISSET(p->vif_map[vifi], rte->u.mkrt.iifs))
    for (int i = 0; i < MAXVIFS; i++)
      if (RTE_MGRP_ISSET(p->vif_map[i], rte->u.mkrt.oifs))
	mc.mfcc_ttls[i] = 1;

  TRACE(D_EVENTS, "%s MFC entry for (%I, %I)", (vifi > 0) ? "Add" : "Delete", source, group);
  if ((err = mkrt_call(p, (vifi > 0) ? MRT_ADD_MFC : MRT_DEL_MFC, &mc, sizeof(mc)) < 0))
    log(L_WARN "Mkernel: failed to %s MFC entry: %m", (vifi > 0) ? "add" : "delete", err);

  return err;
}

struct mfc_request {
  ip_addr *group, *source;
  vifi_t vifi;
  u32 iifs, oifs;
};

/*
 * Expand the attributes from the struct mfc_request and call mkrt_mfc_update,
 * and pass back the result.
 */
static void
mkrt_mfc_call_update(struct proto *p, void *data, rte *rte)
{
  struct mfc_request *req = data;
  mkrt_mfc_update((struct mkrt_proto *) p, *req->group, *req->source, req->vifi, rte);
  if (rte)
    {
      req->iifs = rte->u.mkrt.iifs;
      req->oifs = rte->u.mkrt.oifs;
    }
}

/*
 * Resolve the MFC miss by adding a MFC entry. If no matching entry in the
 * routing table exists, add an empty one to satisfy the kernel.
 */
static void
mkrt_mfc_resolve(struct mkrt_proto *p, ip_addr group, ip_addr source, vifi_t vifi)
{
  struct iface *iface = p->vif_map[vifi];

  TRACE(D_EVENTS, "MFC miss for (%I, %I, %s)", source, group, iface ? iface->name : "??");

  net_addr_mgrp4 n0 = NET_ADDR_MGRP4(ipa_to_ip4(group));

  struct mfc_request req = { &group, &source, vifi };
  if (!rt_route(p->p.main_channel, (net_addr *) &n0, mkrt_mfc_call_update, &req))
    mkrt_mfc_call_update((struct proto *) p, &req, NULL);

  struct mkrt_mfc_group *grp = mkrt_mfc_get(p, group);
  struct mkrt_mfc_source *src = mb_alloc(p->p.pool, sizeof(struct mkrt_mfc_source));
  src->addr = source;
  src->vifi = vifi;
  src->iifs = req.iifs;
  src->oifs = req.oifs;
  add_tail(&grp->sources, NODE src);
}

/*
 * Because a route in the internal table has changed, all the corresponding MFC
 * entries are now wrong. Instead of correcting them, flush the cache.
 */
static void
mkrt_mfc_clean(struct mkrt_proto *p, struct mkrt_mfc_group *mg)
{
  struct mkrt_mfc_source *n, *next;
  WALK_LIST_DELSAFE(n, next, mg->sources)
    {
      mkrt_mfc_update(p, mg->ga, n->addr, -1, NULL);
      rem_node(NODE n);
      mb_free(n);
    }
}

static void
mkrt_mfc_free(struct mkrt_proto *p, struct mkrt_mfc_group *mg)
{
  mkrt_mfc_clean(p, mg);
  HASH_REMOVE(p->mfc_groups, HASH_MFC, mg);
  mb_free(mg);
}

/*
 * An IGMP message received on the socket can be not only a packet received
 * from the network, but also a so-called upcall from the kernel. We must process them here.
 */
static int
mkrt_control_message(struct mkrt_proto *p, sock *sk, int len)
{
  struct igmpmsg *msg = (struct igmpmsg *) sk->rbuf;
  u8 igmp_type = * (u8 *) sk_rx_buffer(sk, &len);

  switch (igmp_type)
    {
    case IGMPMSG_NOCACHE:
      mkrt_mfc_resolve(p, ipa_from_in4(msg->im_dst), ipa_from_in4(msg->im_src), msg->im_vif);
      return 1;

    case IGMPMSG_WRONGVIF:
    case IGMPMSG_WHOLEPKT:
      /* Neither should ever happen. IGMPMSG_WRONGVIF is a common situation,
       * and this upcall is called only when switching to (S,G) tree in other
       * PIM variants.
       *
       * Similarly, the WHOLEPKT should be called only when we add the register
       * VIF and ask kernel for giving us whole packets
       */
      return 1;

    default:
      return 0;
    }
}

static int
mkrt_rx_hook(sock *sk, int len)
{
  struct mkrt_proto *p = sk->data;

  /* Do not forward upcalls, IGMP cannot parse them */
  if (mkrt_control_message(p, sk, len))
    return 1;

  mkrt_rx_forward_all(&mkrt_global.sockets, sk, len);

  struct mkrt_iface *ifa = mkrt_iface_find(p, sk->lifindex);
  if (ifa)
    mkrt_rx_forward_all(&ifa->sockets, sk, len);

  return 1;
}

static void
mkrt_err_hook(sock *sk, int err)
{
  log(L_TRACE "IGMP error: %m", err);
}

static void
mkrt_preconfig(struct protocol *P UNUSED, struct config *c UNUSED)
{
  mkrt_cf = NULL;
}

struct proto_config *
mkrt_config_init(int class)
{
  if (mkrt_cf)
    cf_error("Kernel multicast route syncer already defined");

  mkrt_cf = (struct mkrt_config *) proto_config_new(&proto_mkrt, class);
  return (struct proto_config *) mkrt_cf;
}

void
mkrt_config_finish(struct proto_config *pc)
{
  struct channel_config *cc = proto_cf_main_channel(pc);

  if (!cc)
    cc = channel_config_new(NULL, NET_MGRP4, pc);

  cc->ra_mode = RA_OPTIMAL;
}

static int
mkrt_init_sock(struct mkrt_proto *p)
{
  sock *sk;

  if (!(sk = sk_new(p->p.pool)))
    goto err;

  sk->type = SK_IP;
  sk->subtype = SK_IPV4;
  sk->dport = IPPROTO_IGMP;
  sk->flags = SKF_LADDR_RX;

  sk->data = p;
  sk->ttl = 1;
  sk->rx_hook = mkrt_rx_hook;
  sk->err_hook = mkrt_err_hook;

  sk->rbsize = 4096;
  sk->tbsize = 0;

  if (sk_open(sk) < 0)
    goto err_sk;

  p->igmp_sock = sk;

  int v = 1;
  if (mkrt_call(p, MRT_INIT, &v, sizeof(v)) < 0)
    {
      if (errno == EADDRINUSE)
	log(L_ERR "Mkernel: Another multicast routing daemon is running");
      else
	log(L_ERR "Mkernel: Cannot enable multicast features in kernel: %m", errno);
      goto err_sk;
    }

  log(L_DEBUG "Multicast control socket open with fd %i", sk->fd);
  return 0;

err_sk:
  rfree(sk);
  p->igmp_sock = NULL;
err:
  return -1;
}

void
mkrt_rt_notify(struct proto *P, struct channel *c, net *net, rte *new, rte *old, ea_list *attrs)
{
  struct mkrt_proto *p = (struct mkrt_proto *) P;
  net_addr *n = net->n.addr;
  struct mkrt_mfc_group *mg = mkrt_mfc_get(p, net_prefix(n));

  /* Drop all MFC entries (possibly along with the state information) for a group */
  if (new)
      mkrt_mfc_clean(p, mg);
  else
      mkrt_mfc_free(p, mg);
}

static void
mkrt_if_notify(struct proto *P, uint flags, struct iface *iface)
{
  struct mkrt_proto *p = (struct mkrt_proto *) P;

  if (iface->flags & IF_IGNORE)
    return;

  if (flags & IF_CHANGE_UP)
    mkrt_add_vif(p, iface);

  if (flags & IF_CHANGE_DOWN)
    mkrt_del_vif(p, iface);
}

static struct proto *
mkrt_init(struct proto_config *c)
{
  struct mkrt_proto *p = proto_new(c);

  p->p.main_channel = proto_add_channel(&p->p, proto_cf_main_channel(c));

  p->p.rt_notify = mkrt_rt_notify;
  p->p.if_notify = mkrt_if_notify;

  return &p->p;
}

static int
mkrt_start(struct proto *P)
{
  struct mkrt_proto *p = (struct mkrt_proto *) P;

  p->vif_count = 0;

  HASH_INIT(p->mfc_groups, p->p.pool, 6);

  if (mkrt_init_sock(p) < 0)
    return PS_DOWN;

  return PS_UP;
}

static int
mkrt_shutdown(struct proto *P)
{
  struct mkrt_proto *p = (struct mkrt_proto *) P;
  mkrt_call(p, MRT_DONE, NULL, 0);
  rfree(p->igmp_sock);
  return PS_DOWN;
}

static void
mkrt_dump(struct proto *P)
{
  struct mkrt_proto *p = (struct mkrt_proto *) P;
  struct mkrt_mfc_source *s;

  debug("\tVIFs as in bitmaps:\n\t\t");
  for (int i = MAXVIFS; i >= 0; i--)
    if (p->vif_map[i])
      debug("%s ", p->vif_map[i]->name);
  debug("\n\t(S,G) entries in MFC in kernel:\n");
  HASH_WALK(p->mfc_groups, next, group)
    {
      WALK_LIST(s, group->sources)
	debug("\t\t(%I, %I, %s) -> %b %b\n", s->addr, group->ga, p->vif_map[s->vifi]->name, s->iifs, s->oifs);
    }
  HASH_WALK_END;
}

struct protocol proto_mkrt = {
    .name = "mkernel",
    .template = "mkernel%d",
    .proto_size = sizeof(struct mkrt_proto),
    .config_size = sizeof(struct proto_config),
    .channel_mask = NB_MGRP,
    .preconfig = mkrt_preconfig,
    .init = mkrt_init,
    .start = mkrt_start,
    .shutdown = mkrt_shutdown,
    .dump = mkrt_dump,
};