/*
 *	BIRD -- Linux Netlink Interface
 *
 *	(c) 1999--2000 Martin Mares <mj@ucw.cz>
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <errno.h>

#undef LOCAL_DEBUG

#include "nest/bird.h"
#include "nest/route.h"
#include "nest/protocol.h"
#include "nest/iface.h"
#include "lib/alloca.h"
#include "sysdep/unix/unix.h"
#include "sysdep/unix/krt.h"
#include "lib/socket.h"
#include "lib/string.h"
#include "lib/hash.h"
#include "lib/macro.h"
#include "conf/conf.h"

#include "proto/bridge/bridge.h"

#include CONFIG_INCLUDE_NLSYS_H

#define krt_ipv4(p) ((p)->af == AF_INET)

const int rt_default_ecmp = 16;

struct nl_parse_state
{
  struct krt_proto *proto;
  struct linpool *pool;
  int scan;

  u32 rta_flow;
  u32 bridge_id;
};

/*
 *	Netlink eattr definitions
 */

#define KRT_METRICS_MAX		ARRAY_SIZE(ea_krt_metrics)
#define KRT_FEATURES_MAX	4

static void krt_bitfield_format(const eattr *e, byte *buf, uint buflen);
static struct f_val krt_bitfield_empty(const struct ea_class *cls UNUSED)
{ return (struct f_val) { .type = T_INT }; }

static struct ea_class
  ea_krt_prefsrc = {
    .name = "krt_prefsrc",
    .legacy_name = "Kernel.prefsrc",
    .type = T_IP,
  },
  ea_krt_realm = {
    .name = "krt_realm",
    .legacy_name = "Kernel.realm",
    .type = T_INT,
  },
  ea_krt_scope = {
    .name = "krt_scope",
    .legacy_name = "Kernel.scope",
    .type = T_INT,
  };

static struct ea_class ea_krt_metrics[] = {
  [RTAX_LOCK] = {
    .name = "krt_lock",
    .legacy_name = "Kernel.lock",
    .type = T_INT,
    .format = krt_bitfield_format,
    .empty = krt_bitfield_empty,
  },
  [RTAX_FEATURES] = {
    .name = "krt_features",
    .legacy_name = "Kernel.features",
    .type = T_INT,
    .format = krt_bitfield_format,
    .empty = krt_bitfield_empty,
  },
  [RTAX_CC_ALGO] = {
    .name = "krt_congctl",
    .legacy_name = "Kernel.congctl",
    .type = T_STRING,
  },
#define KRT_METRIC_INT(_rtax, _name)	[_rtax] = { .name = "krt_" _name, .legacy_name = "Kernel." _name, .type = T_INT }
  KRT_METRIC_INT(RTAX_MTU, "mtu"),
  KRT_METRIC_INT(RTAX_WINDOW, "window"),
  KRT_METRIC_INT(RTAX_RTT, "rtt"),
  KRT_METRIC_INT(RTAX_RTTVAR, "rttvar"),
  KRT_METRIC_INT(RTAX_SSTHRESH, "ssthresh"),
  KRT_METRIC_INT(RTAX_CWND, "cwnd"),
  KRT_METRIC_INT(RTAX_ADVMSS, "advmss"),
  KRT_METRIC_INT(RTAX_REORDERING, "reordering"),
  KRT_METRIC_INT(RTAX_HOPLIMIT, "hoplimit"),
  KRT_METRIC_INT(RTAX_INITCWND, "initcwnd"),
  KRT_METRIC_INT(RTAX_RTO_MIN, "rto_min"),
  KRT_METRIC_INT(RTAX_INITRWND, "initrwnd"),
  KRT_METRIC_INT(RTAX_QUICKACK, "quickack"),
#ifdef RTAX_FASTOPEN_NO_COOKIE
  KRT_METRIC_INT(RTAX_FASTOPEN_NO_COOKIE, "fastopen_no_cookie"),
#else
#warning "Definition of RTAX_FASTOPEN_NO_COOKIE not found"
#endif
#undef KRT_METRIC_INT
};

static const char *krt_metrics_names[KRT_METRICS_MAX] = {
  NULL, "lock", "mtu", "window", "rtt", "rttvar", "ssthresh", "cwnd", "advmss",
  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack",
  "congctl",
#ifdef RTAX_FASTOPEN_NO_COOKIE
  "fastopen_no_cookie",
#endif
};

static const char *krt_features_names[KRT_FEATURES_MAX] = {
  "ecn", NULL, NULL, "allfrag"
};

static void
krt_bitfield_format(const eattr *a, byte *buf, uint buflen)
{
  if (a->id == ea_krt_metrics[RTAX_LOCK].id)
    ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
  else if (a->id == ea_krt_metrics[RTAX_FEATURES].id)
    ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
}

static void
nl_ea_register(void)
{
  EA_REGISTER_ALL(
      &ea_krt_prefsrc,
      &ea_krt_realm,
      &ea_krt_scope
      );

  for (uint i = 0; i < KRT_METRICS_MAX; i++)
  {
    if (!ea_krt_metrics[i].name)
      ea_krt_metrics[i] = (struct ea_class) {
	.name = mb_sprintf(&root_pool, "krt_metric_%d", i),
	.type = T_INT,
      };

    ea_register_init(&ea_krt_metrics[i]);
  }

  for (uint i = 1; i < KRT_METRICS_MAX; i++)
    ASSERT_DIE(ea_krt_metrics[i].id == ea_krt_metrics[0].id + i);
}



/*
 *	Synchronous Netlink interface
 */

struct nl_sock
{
  int fd;
  u32 seq;
  byte *rx_buffer;			/* Receive buffer */
  struct nlmsghdr *last_hdr;		/* Recently received packet */
  uint last_size;
};

#define NL_RX_SIZE 32768

#define NL_OP_DELETE	0
#define NL_OP_ADD	(NLM_F_CREATE|NLM_F_EXCL)
#define NL_OP_REPLACE	(NLM_F_CREATE|NLM_F_REPLACE)
#define NL_OP_APPEND	(NLM_F_CREATE|NLM_F_APPEND)

static linpool *nl_linpool;

static struct nl_sock nl_scan = {.fd = -1};	/* Netlink socket for synchronous scan */
static struct nl_sock nl_req  = {.fd = -1};	/* Netlink socket for requests */

static void
nl_open_sock(struct nl_sock *nl)
{
  if (nl->fd < 0)
    {
      nl->fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
      if (nl->fd < 0)
	die("Unable to open rtnetlink socket: %m");
      nl->seq = (u32) (current_time() TO_S); /* Or perhaps random_u32() ? */
      nl->rx_buffer = xmalloc(NL_RX_SIZE);
      nl->last_hdr = NULL;
      nl->last_size = 0;
    }
}

static int
nl_set_strict_dump(struct nl_sock *nl UNUSED, int strict UNUSED)
{
#ifdef SOL_NETLINK
  return setsockopt(nl->fd, SOL_NETLINK, NETLINK_GET_STRICT_CHK, &strict, sizeof(strict));
#else
  return -1;
#endif
}

static void
nl_set_rcvbuf(int fd, uint val)
{
  if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &val, sizeof(val)) < 0)
    log(L_WARN "KRT: Cannot set netlink rx buffer size to %u: %m", val);
}

static uint
nl_cfg_rx_buffer_size(struct config *cfg)
{
  uint bufsize = 0;

  struct proto_config *pc;
  WALK_LIST(pc, cfg->protos)
    if ((pc->protocol == &proto_unix_kernel) && !pc->disabled)
      bufsize = MAX(bufsize, ((struct krt_config *) pc)->sys.netlink_rx_buffer);

  return bufsize;
}


static void
nl_open(void)
{
  if ((nl_scan.fd >= 0) && (nl_req.fd >= 0))
    return;

  nl_open_sock(&nl_scan);
  nl_open_sock(&nl_req);

  if (nl_set_strict_dump(&nl_scan, 1) < 0)
  {
    log(L_WARN "KRT: Netlink strict checking failed, will scan all tables at once");
    krt_use_shared_scan();
  }
}

static void
nl_send(struct nl_sock *nl, struct nlmsghdr *nh)
{
  struct sockaddr_nl sa;

  memset(&sa, 0, sizeof(sa));
  sa.nl_family = AF_NETLINK;
  nh->nlmsg_pid = 0;
  nh->nlmsg_seq = ++(nl->seq);
  nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len);
  if (sendto(nl->fd, nh, nh->nlmsg_len, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0)
    die("rtnetlink sendto: %m");
  nl->last_hdr = NULL;
}

static void
nl_request_dump_link(int af, u32 ext_mask)
{
  struct {
    struct nlmsghdr nh;
    struct ifinfomsg ifi;
    struct rtattr rta;
    u32 ext_mask;
  } req = {
    .nh.nlmsg_type = RTM_GETLINK,
    .nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
    .nh.nlmsg_seq = ++(nl_scan.seq),
    .ifi.ifi_family = af,
  };

  if (ext_mask)
  {
    req.rta.rta_type = IFLA_EXT_MASK;
    req.rta.rta_len = RTA_LENGTH(4);
    req.ext_mask = ext_mask;
    req.nh.nlmsg_len = NLMSG_ALIGN(req.nh.nlmsg_len) + req.rta.rta_len;
  }

  send(nl_scan.fd, &req, sizeof(req), 0);
  nl_scan.last_hdr = NULL;
}

static void
nl_request_dump_addr(int af)
{
  struct {
    struct nlmsghdr nh;
    struct ifaddrmsg ifa;
  } req = {
    .nh.nlmsg_type = RTM_GETADDR,
    .nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
    .nh.nlmsg_seq = ++(nl_scan.seq),
    .ifa.ifa_family = af,
  };

  send(nl_scan.fd, &req, sizeof(req), 0);
  nl_scan.last_hdr = NULL;
}

static void
nl_request_dump_route(int af, int table_id)
{
  struct {
    struct nlmsghdr nh;
    struct rtmsg rtm;
    struct rtattr rta;
    u32 table_id;
  } req = {
    .nh.nlmsg_type = RTM_GETROUTE,
    .nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)),
    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
    .nh.nlmsg_seq = ++(nl_scan.seq),
    .rtm.rtm_family = af,
  };

  if (table_id < 256)
    req.rtm.rtm_table = table_id;
  else
  {
    req.rta.rta_type = RTA_TABLE;
    req.rta.rta_len = RTA_LENGTH(4);
    req.table_id = table_id;
    req.nh.nlmsg_len = NLMSG_ALIGN(req.nh.nlmsg_len) + req.rta.rta_len;
  }

  send(nl_scan.fd, &req, req.nh.nlmsg_len, 0);
  nl_scan.last_hdr = NULL;
}

static void
nl_request_dump_neigh(int af, int bridge_id)
{
  struct {
    struct nlmsghdr nh;
    struct ndmsg ndm;
    struct rtattr rta;
    u32 master_id;
  } req = {
    .nh.nlmsg_type = RTM_GETNEIGH,
    .nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
    .nh.nlmsg_seq = ++(nl_scan.seq),
    .ndm.ndm_family = af,
  };

  if (bridge_id)
  {
    req.rta.rta_type = NDA_MASTER;
    req.rta.rta_len = RTA_LENGTH(4);
    req.master_id = bridge_id;
    req.nh.nlmsg_len = NLMSG_ALIGN(req.nh.nlmsg_len) + req.rta.rta_len;
  }

  send(nl_scan.fd, &req, req.nh.nlmsg_len, 0);
  nl_scan.last_hdr = NULL;
}


static struct nlmsghdr *
nl_get_reply(struct nl_sock *nl)
{
  for(;;)
    {
      if (!nl->last_hdr)
	{
	  struct iovec iov = { nl->rx_buffer, NL_RX_SIZE };
	  struct sockaddr_nl sa;
	  struct msghdr m = {
	    .msg_name = &sa,
	    .msg_namelen = sizeof(sa),
	    .msg_iov = &iov,
	    .msg_iovlen = 1,
	  };
	  int x = recvmsg(nl->fd, &m, 0);
	  if (x < 0)
	    die("nl_get_reply: %m");
	  if (sa.nl_pid)		/* It isn't from the kernel */
	    {
	      DBG("Non-kernel packet\n");
	      continue;
	    }
	  nl->last_size = x;
	  nl->last_hdr = (void *) nl->rx_buffer;
	  if (m.msg_flags & MSG_TRUNC)
	    bug("nl_get_reply: got truncated reply which should be impossible");
	}
      if (NLMSG_OK(nl->last_hdr, nl->last_size))
	{
	  struct nlmsghdr *h = nl->last_hdr;
	  nl->last_hdr = NLMSG_NEXT(h, nl->last_size);
	  if (h->nlmsg_seq != nl->seq)
	    {
	      log(L_WARN "nl_get_reply: Ignoring out of sequence netlink packet (%x != %x)",
		  h->nlmsg_seq, nl->seq);
	      continue;
	    }
	  return h;
	}
      if (nl->last_size)
	log(L_WARN "nl_get_reply: Found packet remnant of size %d", nl->last_size);
      nl->last_hdr = NULL;
    }
}

static struct tbf rl_netlink_err = TBF_DEFAULT_LOG_LIMITS;

static int
nl_error(struct nlmsghdr *h, int ignore_esrch)
{
  struct nlmsgerr *e;
  int ec;

  if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
    {
      log(L_WARN "Netlink: Truncated error message received");
      return ENOBUFS;
    }
  e = (struct nlmsgerr *) NLMSG_DATA(h);
  ec = netlink_error_to_os(e->error);
  if (ec && !(ignore_esrch && (ec == ESRCH)))
    log_rl(&rl_netlink_err, L_WARN "Netlink: %s", strerror(ec));

  return ec;
}

static struct nlmsghdr *
nl_get_scan(void)
{
  struct nlmsghdr *h = nl_get_reply(&nl_scan);

  if (h->nlmsg_type == NLMSG_DONE)
    return NULL;
  if (h->nlmsg_type == NLMSG_ERROR)
    {
      nl_error(h, 0);
      return NULL;
    }
  return h;
}

static int
nl_exchange(struct nlmsghdr *pkt, int ignore_esrch)
{
  struct nlmsghdr *h;

  nl_send(&nl_req, pkt);
  for(;;)
    {
      h = nl_get_reply(&nl_req);
      if (h->nlmsg_type == NLMSG_ERROR)
	break;
      log(L_WARN "nl_exchange: Unexpected reply received");
    }
  return nl_error(h, ignore_esrch) ? -1 : 0;
}

/*
 *	Netlink attributes
 */

static int nl_attr_len;

static void *
nl_checkin(struct nlmsghdr *h, int lsize)
{
  nl_attr_len = h->nlmsg_len - NLMSG_LENGTH(lsize);
  if (nl_attr_len < 0)
    {
      log(L_ERR "nl_checkin: underrun by %d bytes", -nl_attr_len);
      return NULL;
    }
  return NLMSG_DATA(h);
}

struct nl_want_attrs {
  u8 defined:1;
  u8 checksize:1;
  u8 size;
};


#define BIRD_IFLA_MAX (IFLA_AF_SPEC+1)

static struct nl_want_attrs ifla_attr_want[BIRD_IFLA_MAX] = {
  [IFLA_IFNAME]	  = { 1, 0, 0 },
  [IFLA_MTU]	  = { 1, 1, sizeof(u32) },
  [IFLA_MASTER]	  = { 1, 1, sizeof(u32) },
  [IFLA_WIRELESS] = { 1, 0, 0 },
  [IFLA_LINKINFO] = { 1, 0, 0 },
  [IFLA_AF_SPEC]  = { 1, 0, 0 },
};

#define BIRD_INFO_MAX (IFLA_INFO_DATA+1)

static struct nl_want_attrs ifinfo_attr_want[BIRD_INFO_MAX] = {
  [IFLA_INFO_KIND]= { 1, 0, 0 },
  [IFLA_INFO_DATA]= { 1, 0, 0 },
};

#define BIRD_IFLA_BR_MAX (IFLA_BR_VLAN_FILTERING+1)

static struct nl_want_attrs ifla_br_attr_want[BIRD_IFLA_BR_MAX] = {
  [IFLA_BR_VLAN_FILTERING] = { 1, 1, sizeof(u8) },
};

#define BIRD_IFLA_VXLAN_MAX (IFLA_VXLAN_LOCAL6+1)

static struct nl_want_attrs ifla_vxlan_attr_want[BIRD_IFLA_VXLAN_MAX] = {
  [IFLA_VXLAN_ID]	= { 1, 1, sizeof(u32) },
  [IFLA_VXLAN_LEARNING]	= { 1, 1, sizeof(u8) },
  [IFLA_VXLAN_LOCAL]	= { 1, 1, sizeof(ip4_addr) },
  [IFLA_VXLAN_LOCAL6]	= { 1, 1, sizeof(ip6_addr) },
};


#define BIRD_IFBRIDGE_MAX (IFLA_BRIDGE_VLAN_TUNNEL_INFO+1)

static struct nl_want_attrs ifbridge_attr_want[BIRD_IFBRIDGE_MAX] UNUSED = {
  [IFLA_BRIDGE_VLAN_INFO] = { 1, 1, sizeof(struct bridge_vlan_info) },
  [IFLA_BRIDGE_VLAN_TUNNEL_INFO] = { 1, 0, 0 },
};

#define BIRD_IFBRIDGE_VLAN_TUNNEL_MAX (IFLA_BRIDGE_VLAN_TUNNEL_FLAGS+1)

static struct nl_want_attrs ifbridge_vlan_tunnel_attr_want[BIRD_IFBRIDGE_VLAN_TUNNEL_MAX] UNUSED = {
  [IFLA_BRIDGE_VLAN_TUNNEL_ID]		= { 1, 1, sizeof(u32) },
  [IFLA_BRIDGE_VLAN_TUNNEL_VID]		= { 1, 1, sizeof(u16) },
  [IFLA_BRIDGE_VLAN_TUNNEL_FLAGS]	= { 1, 1, sizeof(u16) },
};


#define BIRD_IFA_MAX  (IFA_FLAGS+1)

static struct nl_want_attrs ifa_attr_want4[BIRD_IFA_MAX] = {
  [IFA_ADDRESS]	  = { 1, 1, sizeof(ip4_addr) },
  [IFA_LOCAL]	  = { 1, 1, sizeof(ip4_addr) },
  [IFA_BROADCAST] = { 1, 1, sizeof(ip4_addr) },
  [IFA_FLAGS]     = { 1, 1, sizeof(u32) },
};

static struct nl_want_attrs ifa_attr_want6[BIRD_IFA_MAX] = {
  [IFA_ADDRESS]	  = { 1, 1, sizeof(ip6_addr) },
  [IFA_LOCAL]	  = { 1, 1, sizeof(ip6_addr) },
  [IFA_FLAGS]	  = { 1, 1, sizeof(u32) },
};


#define BIRD_RTA_MAX  (RTA_ENCAP+1)

static struct nl_want_attrs nexthop_attr_want4[BIRD_RTA_MAX] = {
  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip4_addr) },
  [RTA_VIA]	  = { 1, 0, 0 },
  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
  [RTA_ENCAP_TYPE]= { 1, 1, sizeof(u16) },
  [RTA_ENCAP]	  = { 1, 0, 0 },
};

static struct nl_want_attrs nexthop_attr_want6[BIRD_RTA_MAX] = {
  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip6_addr) },
  [RTA_VIA]	  = { 1, 0, 0 },
  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
  [RTA_ENCAP_TYPE]= { 1, 1, sizeof(u16) },
  [RTA_ENCAP]	  = { 1, 0, 0 },
};

#ifdef HAVE_MPLS_KERNEL
static struct nl_want_attrs nexthop_attr_want_mpls[BIRD_RTA_MAX] = {
  [RTA_VIA]	  = { 1, 0, 0 },
  [RTA_NEWDST]	  = { 1, 0, 0 },
};

static struct nl_want_attrs encap_mpls_want[BIRD_RTA_MAX] = {
  [RTA_DST]       = { 1, 0, 0 },
};
#endif

static struct nl_want_attrs rtm_attr_want4[BIRD_RTA_MAX] = {
  [RTA_DST]	  = { 1, 1, sizeof(ip4_addr) },
  [RTA_OIF]	  = { 1, 1, sizeof(u32) },
  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip4_addr) },
  [RTA_PRIORITY]  = { 1, 1, sizeof(u32) },
  [RTA_PREFSRC]	  = { 1, 1, sizeof(ip4_addr) },
  [RTA_METRICS]	  = { 1, 0, 0 },
  [RTA_MULTIPATH] = { 1, 0, 0 },
  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
  [RTA_TABLE]	  = { 1, 1, sizeof(u32) },
  [RTA_VIA]	  = { 1, 0, 0 },
  [RTA_ENCAP_TYPE]= { 1, 1, sizeof(u16) },
  [RTA_ENCAP]	  = { 1, 0, 0 },
};

static struct nl_want_attrs rtm_attr_want6[BIRD_RTA_MAX] = {
  [RTA_DST]	  = { 1, 1, sizeof(ip6_addr) },
  [RTA_SRC]	  = { 1, 1, sizeof(ip6_addr) },
  [RTA_IIF]	  = { 1, 1, sizeof(u32) },
  [RTA_OIF]	  = { 1, 1, sizeof(u32) },
  [RTA_GATEWAY]	  = { 1, 1, sizeof(ip6_addr) },
  [RTA_PRIORITY]  = { 1, 1, sizeof(u32) },
  [RTA_PREFSRC]	  = { 1, 1, sizeof(ip6_addr) },
  [RTA_METRICS]	  = { 1, 0, 0 },
  [RTA_MULTIPATH] = { 1, 0, 0 },
  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
  [RTA_TABLE]	  = { 1, 1, sizeof(u32) },
  [RTA_VIA]	  = { 1, 0, 0 },
  [RTA_ENCAP_TYPE]= { 1, 1, sizeof(u16) },
  [RTA_ENCAP]	  = { 1, 0, 0 },
};

#ifdef HAVE_MPLS_KERNEL
static struct nl_want_attrs rtm_attr_want_mpls[BIRD_RTA_MAX] = {
  [RTA_DST]	  = { 1, 1, sizeof(u32) },
  [RTA_IIF]	  = { 1, 1, sizeof(u32) },
  [RTA_OIF]	  = { 1, 1, sizeof(u32) },
  [RTA_PRIORITY]  = { 1, 1, sizeof(u32) },
  [RTA_METRICS]	  = { 1, 0, 0 },
  [RTA_MULTIPATH] = { 1, 0, 0 },
  [RTA_FLOW]	  = { 1, 1, sizeof(u32) },
  [RTA_TABLE]	  = { 1, 1, sizeof(u32) },
  [RTA_VIA]	  = { 1, 0, 0 },
  [RTA_NEWDST]	  = { 1, 0, 0 },
};
#endif


#define BIRD_NDA_MAX  (NDA_SRC_VNI+1)

static struct nl_want_attrs ndm_attr_want[BIRD_NDA_MAX] = {
  [NDA_DST]	  = { 1, 0, 0 },
  [NDA_LLADDR]	  = { 1, 1, sizeof(mac_addr) },
  [NDA_VLAN]	  = { 1, 1, sizeof(u16) },
  [NDA_VNI]	  = { 1, 1, sizeof(u32) },
  [NDA_MASTER]	  = { 1, 1, sizeof(u32) },
  [NDA_SRC_VNI]	  = { 1, 1, sizeof(u32) },
};


static int
nl_parse_attrs(struct rtattr *a, struct nl_want_attrs *want, struct rtattr **k, int ksize)
{
  int max = ksize / sizeof(struct rtattr *);
  bzero(k, ksize);

  for ( ; RTA_OK(a, nl_attr_len); a = RTA_NEXT(a, nl_attr_len))
    {
      if ((a->rta_type >= max) || !want[a->rta_type].defined)
	continue;

      if (want[a->rta_type].checksize && (RTA_PAYLOAD(a) != want[a->rta_type].size))
	{
	  log(L_ERR "nl_parse_attrs: Malformed attribute received");
	  return 0;
	}

      k[a->rta_type] = a;
    }

  if (nl_attr_len)
    {
      log(L_ERR "nl_parse_attrs: remnant of size %d", nl_attr_len);
      return 0;
    }

  return 1;
}

static inline u8 rta_get_u8(struct rtattr *a)
{ return *(u8 *) RTA_DATA(a); }

static inline u16 rta_get_u16(struct rtattr *a)
{ return *(u16 *) RTA_DATA(a); }

static inline u32 rta_get_u32(struct rtattr *a)
{ return *(u32 *) RTA_DATA(a); }

static inline const char *rta_get_str(struct rtattr *a)
{ return RTA_DATA(a); }

static inline ip4_addr rta_get_ip4(struct rtattr *a)
{ return ip4_ntoh(*(ip4_addr *) RTA_DATA(a)); }

static inline ip6_addr rta_get_ip6(struct rtattr *a)
{ return ip6_ntoh(*(ip6_addr *) RTA_DATA(a)); }

static inline ip_addr rta_get_ipa(struct rtattr *a)
{
  if (RTA_PAYLOAD(a) == sizeof(ip4_addr))
    return ipa_from_ip4(rta_get_ip4(a));
  else if (RTA_PAYLOAD(a) == sizeof(ip6_addr))
    return ipa_from_ip6(rta_get_ip6(a));
  else
    return IPA_NONE;
}

static inline mac_addr rta_get_mac(struct rtattr *a)
{ return *(mac_addr *) RTA_DATA(a); }

static inline ip_addr rta_get_via(struct rtattr *a)
{
  struct rtvia *v = RTA_DATA(a);
  switch(v->rtvia_family) {
    case AF_INET:  return ipa_from_ip4(ip4_ntoh(*(ip4_addr *) v->rtvia_addr));
    case AF_INET6: return ipa_from_ip6(ip6_ntoh(*(ip6_addr *) v->rtvia_addr));
  }
  return IPA_NONE;
}

#ifdef HAVE_MPLS_KERNEL
static u32 rta_mpls_stack[MPLS_MAX_LABEL_STACK];
static inline int rta_get_mpls(struct rtattr *a, u32 *stack)
{
  if (!a)
    return 0;

  if (RTA_PAYLOAD(a) % 4)
    log(L_WARN "KRT: Strange length of received MPLS stack: %u", RTA_PAYLOAD(a));

  int labels = mpls_get(RTA_DATA(a), RTA_PAYLOAD(a) & ~0x3, stack);

  if (labels < 0)
  {
    log(L_WARN "KRT: Too long MPLS stack received, ignoring");
    labels = 0;
  }

  return labels;
}
#endif

struct rtattr *
nl_add_attr(struct nlmsghdr *h, uint bufsize, uint code, const void *data, uint dlen)
{
  uint pos = NLMSG_ALIGN(h->nlmsg_len);
  uint len = RTA_LENGTH(dlen);

  if (pos + len > bufsize)
    bug("nl_add_attr: packet buffer overflow");

  struct rtattr *a = (struct rtattr *)((char *)h + pos);
  a->rta_type = code;
  a->rta_len = len;
  h->nlmsg_len = pos + len;

  if (dlen > 0)
    memcpy(RTA_DATA(a), data, dlen);

  return a;
}

static inline struct rtattr *
nl_open_attr(struct nlmsghdr *h, uint bufsize, uint code)
{
  return nl_add_attr(h, bufsize, code, NULL, 0);
}

static inline void
nl_close_attr(struct nlmsghdr *h, struct rtattr *a)
{
  a->rta_len = (void *)h + NLMSG_ALIGN(h->nlmsg_len) - (void *)a;
}

static inline void
nl_add_attr_u16(struct nlmsghdr *h, uint bufsize, int code, u16 data)
{
  nl_add_attr(h, bufsize, code, &data, 2);
}

static inline void
nl_add_attr_u32(struct nlmsghdr *h, uint bufsize, int code, u32 data)
{
  nl_add_attr(h, bufsize, code, &data, 4);
}

static inline void
nl_add_attr_str(struct nlmsghdr *h, unsigned bufsize, int code, const char *str)
{
  nl_add_attr(h, bufsize, code, str, strlen(str) + 1);
}

static inline void
nl_add_attr_ip4(struct nlmsghdr *h, uint bufsize, int code, ip4_addr ip4)
{
  ip4 = ip4_hton(ip4);
  nl_add_attr(h, bufsize, code, &ip4, sizeof(ip4));
}

static inline void
nl_add_attr_ip6(struct nlmsghdr *h, uint bufsize, int code, ip6_addr ip6)
{
  ip6 = ip6_hton(ip6);
  nl_add_attr(h, bufsize, code, &ip6, sizeof(ip6));
}

static inline void
nl_add_attr_ipa(struct nlmsghdr *h, uint bufsize, int code, ip_addr ipa)
{
  if (ipa_is_ip4(ipa))
    nl_add_attr_ip4(h, bufsize, code, ipa_to_ip4(ipa));
  else
    nl_add_attr_ip6(h, bufsize, code, ipa_to_ip6(ipa));
}

#ifdef HAVE_MPLS_KERNEL
static inline void
nl_add_attr_mpls(struct nlmsghdr *h, uint bufsize, int code, int len, u32 *stack)
{
  char buf[len*4];
  mpls_put(buf, len, stack);
  nl_add_attr(h, bufsize, code, buf, len*4);
}

static inline void
nl_add_attr_mpls_encap(struct nlmsghdr *h, uint bufsize, int len, u32 *stack)
{
  nl_add_attr_u16(h, bufsize, RTA_ENCAP_TYPE, LWTUNNEL_ENCAP_MPLS);

  struct rtattr *nest = nl_open_attr(h, bufsize, RTA_ENCAP);
  nl_add_attr_mpls(h, bufsize, RTA_DST, len, stack);
  nl_close_attr(h, nest);
}

static inline void
nl_add_attr_via(struct nlmsghdr *h, uint bufsize, ip_addr ipa)
{
  struct rtvia *via = alloca(sizeof(struct rtvia) + 16);

  if (ipa_is_ip4(ipa))
  {
    via->rtvia_family = AF_INET;
    put_ip4(via->rtvia_addr, ipa_to_ip4(ipa));
    nl_add_attr(h, bufsize, RTA_VIA, via, sizeof(struct rtvia) + 4);
  }
  else
  {
    via->rtvia_family = AF_INET6;
    put_ip6(via->rtvia_addr, ipa_to_ip6(ipa));
    nl_add_attr(h, bufsize, RTA_VIA, via, sizeof(struct rtvia) + 16);
  }
}
#endif

static inline struct rtnexthop *
nl_open_nexthop(struct nlmsghdr *h, uint bufsize)
{
  uint pos = NLMSG_ALIGN(h->nlmsg_len);
  uint len = RTNH_LENGTH(0);

  if (pos + len > bufsize)
    bug("nl_open_nexthop: packet buffer overflow");

  h->nlmsg_len = pos + len;

  return (void *)h + pos;
}

static inline void
nl_close_nexthop(struct nlmsghdr *h, struct rtnexthop *nh)
{
  nh->rtnh_len = (void *)h + NLMSG_ALIGN(h->nlmsg_len) - (void *)nh;
}

static inline void
nl_add_nexthop(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af UNUSED)
{
#ifdef HAVE_MPLS_KERNEL
  if (nh->labels > 0)
    if (af == AF_MPLS)
      nl_add_attr_mpls(h, bufsize, RTA_NEWDST, nh->labels, nh->label);
    else
      nl_add_attr_mpls_encap(h, bufsize, nh->labels, nh->label);

  if (ipa_nonzero(nh->gw))
  {
    if (af == (ipa_is_ip4(nh->gw) ? AF_INET : AF_INET6))
      nl_add_attr_ipa(h, bufsize, RTA_GATEWAY, nh->gw);
    else
      nl_add_attr_via(h, bufsize, nh->gw);
  }
#else

  if (ipa_nonzero(nh->gw))
    nl_add_attr_ipa(h, bufsize, RTA_GATEWAY, nh->gw);
#endif
}

static void
nl_add_multipath(struct nlmsghdr *h, uint bufsize, struct nexthop_adata *nhad, int af, ea_list *eattrs)
{
  struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
  eattr *flow = ea_find(eattrs, &ea_krt_realm);

  NEXTHOP_WALK(nh, nhad)
  {
    struct rtnexthop *rtnh = nl_open_nexthop(h, bufsize);

    rtnh->rtnh_flags = 0;
    rtnh->rtnh_hops = nh->weight;
    rtnh->rtnh_ifindex = nh->iface->index;

    nl_add_nexthop(h, bufsize, nh, af);

    if (nh->flags & RNF_ONLINK)
      rtnh->rtnh_flags |= RTNH_F_ONLINK;

    /* Our KRT_REALM is per-route, but kernel RTA_FLOW is per-nexthop.
       Therefore, we need to attach the same attribute to each nexthop. */
    if (flow)
      nl_add_attr_u32(h, bufsize, RTA_FLOW, flow->u.data);

    nl_close_nexthop(h, rtnh);
  }

  nl_close_attr(h, a);
}

static struct nexthop_adata *
nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, const net_addr *n, struct rtattr *ra, int af, int krt_src)
{
  struct rtattr *a[BIRD_RTA_MAX];
  struct rtnexthop *nh, *orig_nh = RTA_DATA(ra);
  unsigned len, orig_len = RTA_PAYLOAD(ra);
  uint cnt = 0;

  /* First count the nexthops */
  for (len = orig_len, nh = orig_nh; len; len -= NLMSG_ALIGN(nh->rtnh_len), nh = RTNH_NEXT(nh))
    {
      /* Use RTNH_OK(nh,len) ?? */
      if ((len < sizeof(*nh)) || (len < nh->rtnh_len))
	goto err;

      if ((nh->rtnh_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
	;
      else
	cnt++;
    }

  struct nexthop_adata *nhad = lp_allocz(s->pool, cnt * NEXTHOP_MAX_SIZE + sizeof *nhad);
  struct nexthop *rv = &nhad->nh;

  for (len = orig_len, nh = orig_nh; len; len -= NLMSG_ALIGN(nh->rtnh_len), nh = RTNH_NEXT(nh))
    {
      /* Use RTNH_OK(nh,len) ?? */
      if ((len < sizeof(*nh)) || (len < nh->rtnh_len))
	goto err;

      if ((nh->rtnh_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
	continue;

      *rv = (struct nexthop) {
	.weight = nh->rtnh_hops,
	.iface = if_find_by_index(nh->rtnh_ifindex),
      };

      if (!rv->iface)
	{
	  log(L_ERR "KRT: Received route %N with unknown ifindex %u", n, nh->rtnh_ifindex);
	  return NULL;
	}

      /* Nonexistent RTNH_PAYLOAD ?? */
      nl_attr_len = nh->rtnh_len - RTNH_LENGTH(0);
      switch (af)
        {
	case AF_INET:
	  if (!nl_parse_attrs(RTNH_DATA(nh), nexthop_attr_want4, a, sizeof(a)))
	    goto err;
	  break;

	case AF_INET6:
	  if (!nl_parse_attrs(RTNH_DATA(nh), nexthop_attr_want6, a, sizeof(a)))
	    goto err;
	  break;

#ifdef HAVE_MPLS_KERNEL
	case AF_MPLS:
	  if (!nl_parse_attrs(RTNH_DATA(nh), nexthop_attr_want_mpls, a, sizeof(a)))
	    goto err;

	  if (a[RTA_NEWDST])
	    rv->labels = rta_get_mpls(a[RTA_NEWDST], rv->label);

	  break;
#endif

	default:
	  goto err;
	}

      if (a[RTA_GATEWAY])
	rv->gw = rta_get_ipa(a[RTA_GATEWAY]);

      if (a[RTA_FLOW])
	s->rta_flow = rta_get_u32(a[RTA_FLOW]);

      if (a[RTA_VIA])
	rv->gw = rta_get_via(a[RTA_VIA]);

      if (nh->rtnh_flags & RTNH_F_ONLINK)
	rv->flags |= RNF_ONLINK;

      if (ipa_nonzero(rv->gw))
	{
#ifdef CONFIG_ASSUME_ONLINK
	  if (krt_assume_onlink(rv->iface, ipa_is_ip6(rv->gw)))
	    rv->flags |= RNF_ONLINK;
#endif

	  neighbor *nbr;
	  nbr = neigh_find(&p->p, rv->gw, rv->iface,
			   (rv->flags & RNF_ONLINK) ? NEF_ONLINK : 0);
	  if (!nbr || (nbr->scope == SCOPE_HOST))
	    {
	        log(L_ERR "KRT: Received route %N with strange next-hop %I", n, rv->gw);
	        return NULL;
	    }
	}

#ifdef HAVE_MPLS_KERNEL
      if (a[RTA_ENCAP] && a[RTA_ENCAP_TYPE])
      {
	if (rta_get_u16(a[RTA_ENCAP_TYPE]) != LWTUNNEL_ENCAP_MPLS)
	{
	  log(L_WARN "KRT: Received route %N with unknown encapsulation method %d",
	      n, rta_get_u16(a[RTA_ENCAP_TYPE]));
	  return NULL;
	}

	struct rtattr *enca[BIRD_RTA_MAX];
	nl_attr_len = RTA_PAYLOAD(a[RTA_ENCAP]);
	nl_parse_attrs(RTA_DATA(a[RTA_ENCAP]), encap_mpls_want, enca, sizeof(enca));
	rv->labels = rta_get_mpls(enca[RTA_DST], rv->label);
      }
#endif

      rv = NEXTHOP_NEXT(rv);
    }

  /* Store final length */
  nhad->ad.length = (void *) rv - (void *) nhad->ad.data;

  /* Ensure nexthops are sorted to satisfy nest invariant */
  return nexthop_is_sorted(nhad) ? nhad : nexthop_sort(nhad, s->pool);

err:
  log(L_ERR "KRT: Received strange multipath route %N", n);
  return NULL;
}

static void
nl_add_metrics(struct nlmsghdr *h, uint bufsize, u32 *metrics, const char *cc_algo, int max)
{
  struct rtattr *a = nl_open_attr(h, bufsize, RTA_METRICS);
  int t;

  for (t = 1; t < max; t++)
    if (metrics[0] & (1 << t))
      if (t == RTAX_CC_ALGO)
        nl_add_attr_str(h, bufsize, t, cc_algo);
      else
        nl_add_attr_u32(h, bufsize, t, metrics[t]);

  nl_close_attr(h, a);
}

static int
nl_parse_metrics(struct rtattr *hdr, u32 *metrics, const char **cc_algo, int max)
{
  struct rtattr *a = RTA_DATA(hdr);
  int len = RTA_PAYLOAD(hdr);

  metrics[0] = 0;
  for (; RTA_OK(a, len); a = RTA_NEXT(a, len))
  {
    if (a->rta_type == RTAX_UNSPEC)
      continue;

    if (a->rta_type >= max)
      continue;

    if (a->rta_type == RTAX_CC_ALGO)
    {
      *cc_algo = rta_get_str(a);
      int slen = RTA_PAYLOAD(a);

      if (!slen || ((*cc_algo)[slen - 1] != 0))
	return -1;

      metrics[0] |= 1 << a->rta_type;
      metrics[a->rta_type] = 0;
    }
    else
    {
      if (RTA_PAYLOAD(a) != 4)
	return -1;

      metrics[0] |= 1 << a->rta_type;
      metrics[a->rta_type] = rta_get_u32(a);
    }
  }

  if (len > 0)
    return -1;

  return 0;
}


/*
 *	Scanning of interfaces
 */

static void
nl_parse_link(struct nlmsghdr *h, int scan)
{
  struct ifinfomsg *i;
  struct rtattr *a[BIRD_IFLA_MAX];
  int new = h->nlmsg_type == RTM_NEWLINK;
  struct iface f = {};
  struct iface *ifi;
  const char *name, *kind = NULL;
  u32 mtu, master = 0;
  uint fl;

  if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(IFLA_RTA(i), ifla_attr_want, a, sizeof(a)))
    return;
  if (!a[IFLA_IFNAME] || (RTA_PAYLOAD(a[IFLA_IFNAME]) < 2) || !a[IFLA_MTU])
    {
      /*
       * IFLA_IFNAME and IFLA_MTU are required, in fact, but there may also come
       * a message with IFLA_WIRELESS set, where (e.g.) no IFLA_IFNAME exists.
       * We simply ignore all such messages with IFLA_WIRELESS without notice.
       */

      if (a[IFLA_WIRELESS])
	return;

      log(L_ERR "KIF: Malformed message received");
      return;
    }

  name = RTA_DATA(a[IFLA_IFNAME]);
  mtu = rta_get_u32(a[IFLA_MTU]);

  if (a[IFLA_MASTER])
    master = rta_get_u32(a[IFLA_MASTER]);

  if (a[IFLA_LINKINFO])
  {
    struct rtattr *li[BIRD_INFO_MAX];
    nl_attr_len = RTA_PAYLOAD(a[IFLA_LINKINFO]);
    nl_parse_attrs(RTA_DATA(a[IFLA_LINKINFO]), ifinfo_attr_want, li, sizeof(li));

    if (li[IFLA_INFO_KIND])
      kind = RTA_DATA(li[IFLA_INFO_KIND]);

    if (!bstrcmp(kind, "bridge") && li[IFLA_INFO_DATA])
    {
      ea_set_attr_u32(&f.attrs, &ea_iface_type, 0, IF_TYPE_BRIDGE);

      struct rtattr *data[BIRD_IFLA_BR_MAX];
      nl_attr_len = RTA_PAYLOAD(li[IFLA_INFO_DATA]);
      nl_parse_attrs(RTA_DATA(li[IFLA_INFO_DATA]), ifla_br_attr_want, data, sizeof(data));

      if (data[IFLA_BR_VLAN_FILTERING])
      {
	u8 vlan_filtering = rta_get_u32(data[IFLA_BR_VLAN_FILTERING]);
	ea_set_attr_u32(&f.attrs, &ea_iface_bridge_vlan_filtering, 0, vlan_filtering);
      }
    }
    else if (!bstrcmp(kind, "vxlan") && li[IFLA_INFO_DATA])
    {
      ea_set_attr_u32(&f.attrs, &ea_iface_type, 0, IF_TYPE_VXLAN);

      struct rtattr *data[BIRD_IFLA_VXLAN_MAX];
      nl_attr_len = RTA_PAYLOAD(li[IFLA_INFO_DATA]);
      nl_parse_attrs(RTA_DATA(li[IFLA_INFO_DATA]), ifla_vxlan_attr_want, data, sizeof(data));

      if (data[IFLA_VXLAN_ID])
      {
	u32 id = rta_get_u32(data[IFLA_VXLAN_ID]);
	ea_set_attr_u32(&f.attrs, &ea_iface_vxlan_id, 0, id);
      }

      if (data[IFLA_VXLAN_LEARNING])
      {
	u8 learning = rta_get_u8(data[IFLA_VXLAN_LEARNING]);
	ea_set_attr_u32(&f.attrs, &ea_iface_vxlan_learning, 0, learning);
      }

      if (data[IFLA_VXLAN_LOCAL] || data[IFLA_VXLAN_LOCAL6])
      {
	struct rtattr *attr = data[IFLA_VXLAN_LOCAL] ? data[IFLA_VXLAN_LOCAL] : data[IFLA_VXLAN_LOCAL6];
	ip_addr addr = rta_get_ipa(attr);
	ea_set_attr_data(&f.attrs, &ea_iface_vxlan_ip_addr, 0, &addr, sizeof(addr));
      }
    }
  }

  ifi = if_find_by_index(i->ifi_index);
  if (!new)
    {
      DBG("KIF: IF%d(%s) goes down\n", i->ifi_index, name);
      if (!ifi)
	return;

      if_delete(ifi);
    }
  else
    {
      DBG("KIF: IF%d(%s) goes up (mtu=%d,flg=%x)\n", i->ifi_index, name, mtu, i->ifi_flags);
      if (ifi && strncmp(ifi->name, name, sizeof(ifi->name)-1))
	if_delete(ifi);

      strncpy(f.name, name, sizeof(f.name)-1);
      f.index = i->ifi_index;
      f.mtu = mtu;

      f.master_index = master;
      f.master = if_find_by_index(master);

      fl = i->ifi_flags;
      if (fl & IFF_UP)
	f.flags |= IF_ADMIN_UP;
      if (fl & IFF_LOWER_UP)
	f.flags |= IF_LINK_UP;
      if (fl & IFF_LOOPBACK)		/* Loopback */
	f.flags |= IF_MULTIACCESS | IF_LOOPBACK | IF_IGNORE;
      else if (fl & IFF_POINTOPOINT)	/* PtP */
	f.flags |= IF_MULTICAST;
      else if (fl & IFF_BROADCAST)	/* Broadcast */
	f.flags |= IF_MULTIACCESS | IF_BROADCAST | IF_MULTICAST;
      else
	f.flags |= IF_MULTIACCESS;	/* NBMA */

      if (fl & IFF_MULTICAST)
	f.flags |= IF_MULTICAST;

      if (kind && !strcmp(kind, "vrf"))
	f.flags |= IF_VRF;

      ifi = if_update(&f);

      if (!scan)
	if_end_partial_update(ifi);
    }
}

static void
nl_parse_addr4(struct ifaddrmsg *i, int scan, int new)
{
  struct rtattr *a[BIRD_IFA_MAX];
  struct iface *ifi;
  u32 ifa_flags;
  int scope;

  if (!nl_parse_attrs(IFA_RTA(i), ifa_attr_want4, a, sizeof(a)))
    return;

  if (!a[IFA_LOCAL])
    {
      log(L_ERR "KIF: Malformed message received (missing IFA_LOCAL)");
      return;
    }
  if (!a[IFA_ADDRESS])
    {
      log(L_ERR "KIF: Malformed message received (missing IFA_ADDRESS)");
      return;
    }

  ifi = if_find_by_index(i->ifa_index);
  if (!ifi)
    {
      log(L_ERR "KIF: Received address message for unknown interface %d", i->ifa_index);
      return;
    }

  if (a[IFA_FLAGS])
    ifa_flags = rta_get_u32(a[IFA_FLAGS]);
  else
    ifa_flags = i->ifa_flags;

  struct ifa ifa;
  bzero(&ifa, sizeof(ifa));
  ifa.iface = ifi;
  if (ifa_flags & IFA_F_SECONDARY)
    ifa.flags |= IA_SECONDARY;

  ifa.ip = rta_get_ipa(a[IFA_LOCAL]);

  if (i->ifa_prefixlen > IP4_MAX_PREFIX_LENGTH)
    {
      log(L_ERR "KIF: Invalid prefix length for interface %s: %d", ifi->name, i->ifa_prefixlen);
      new = 0;
    }
  if (i->ifa_prefixlen == IP4_MAX_PREFIX_LENGTH)
    {
      ifa.brd = rta_get_ipa(a[IFA_ADDRESS]);
      net_fill_ip4(&ifa.prefix, rta_get_ip4(a[IFA_ADDRESS]), i->ifa_prefixlen);

      /* It is either a host address or a peer address */
      if (ipa_equal(ifa.ip, ifa.brd))
	ifa.flags |= IA_HOST;
      else
	{
	  ifa.flags |= IA_PEER;
	  ifa.opposite = ifa.brd;
	}
    }
  else
    {
      net_fill_ip4(&ifa.prefix, ipa_to_ip4(ifa.ip), i->ifa_prefixlen);
      net_normalize(&ifa.prefix);

      if (i->ifa_prefixlen == IP4_MAX_PREFIX_LENGTH - 1)
	ifa.opposite = ipa_opposite_m1(ifa.ip);

      if (i->ifa_prefixlen == IP4_MAX_PREFIX_LENGTH - 2)
	ifa.opposite = ipa_opposite_m2(ifa.ip);

      if (ifi->flags & IF_BROADCAST)
        {
	  /* If kernel offers us a broadcast address, we trust it */
	  if (a[IFA_BROADCAST])
	    ifa.brd = ipa_from_ip4(rta_get_ip4(a[IFA_BROADCAST]));
	  /* Otherwise we create one (except for /31) */
	  else if (i->ifa_prefixlen < (IP4_MAX_PREFIX_LENGTH - 1))
	    ifa.brd = ipa_from_ip4(ip4_or(ipa_to_ip4(ifa.ip),
					  ip4_not(ip4_mkmask(i->ifa_prefixlen))));
	}
    }

  scope = ipa_classify(ifa.ip);
  if (scope < 0)
    {
      log(L_ERR "KIF: Invalid interface address %I for %s", ifa.ip, ifi->name);
      return;
    }
  ifa.scope = scope & IADDR_SCOPE_MASK;

  DBG("KIF: IF%d(%s): %s IPA %I, flg %x, net %N, brd %I, opp %I\n",
      ifi->index, ifi->name,
      new ? "added" : "removed",
      ifa.ip, ifa.flags, &ifa.prefix, ifa.brd, ifa.opposite);

  if (new)
    ifa_update(&ifa);
  else
    ifa_delete(&ifa);

  if (!scan)
    if_end_partial_update(ifi);
}

static void
nl_parse_addr6(struct ifaddrmsg *i, int scan, int new)
{
  struct rtattr *a[BIRD_IFA_MAX];
  struct iface *ifi;
  u32 ifa_flags;
  int scope;

  if (!nl_parse_attrs(IFA_RTA(i), ifa_attr_want6, a, sizeof(a)))
    return;

  if (!a[IFA_ADDRESS])
    {
      log(L_ERR "KIF: Malformed message received (missing IFA_ADDRESS)");
      return;
    }

  ifi = if_find_by_index(i->ifa_index);
  if (!ifi)
    {
      log(L_ERR "KIF: Received address message for unknown interface %d", i->ifa_index);
      return;
    }

  if (a[IFA_FLAGS])
    ifa_flags = rta_get_u32(a[IFA_FLAGS]);
  else
    ifa_flags = i->ifa_flags;

  struct ifa ifa;
  bzero(&ifa, sizeof(ifa));
  ifa.iface = ifi;
  if (ifa_flags & IFA_F_SECONDARY)
    ifa.flags |= IA_SECONDARY;

  /* Ignore tentative addresses silently */
  if (ifa_flags & IFA_F_TENTATIVE)
    return;

  /* IFA_LOCAL can be unset for IPv6 interfaces */
  ifa.ip = rta_get_ipa(a[IFA_LOCAL] ? : a[IFA_ADDRESS]);

  if (i->ifa_prefixlen > IP6_MAX_PREFIX_LENGTH)
    {
      log(L_ERR "KIF: Invalid prefix length for interface %s: %d", ifi->name, i->ifa_prefixlen);
      new = 0;
    }
  if (i->ifa_prefixlen == IP6_MAX_PREFIX_LENGTH)
    {
      ifa.brd = rta_get_ipa(a[IFA_ADDRESS]);
      net_fill_ip6(&ifa.prefix, rta_get_ip6(a[IFA_ADDRESS]), i->ifa_prefixlen);

      /* It is either a host address or a peer address */
      if (ipa_equal(ifa.ip, ifa.brd))
	ifa.flags |= IA_HOST;
      else
	{
	  ifa.flags |= IA_PEER;
	  ifa.opposite = ifa.brd;
	}
    }
  else
    {
      net_fill_ip6(&ifa.prefix, ipa_to_ip6(ifa.ip), i->ifa_prefixlen);
      net_normalize(&ifa.prefix);

      if (i->ifa_prefixlen == IP6_MAX_PREFIX_LENGTH - 1)
	ifa.opposite = ipa_opposite_m1(ifa.ip);
    }

  scope = ipa_classify(ifa.ip);
  if (scope < 0)
    {
      log(L_ERR "KIF: Invalid interface address %I for %s", ifa.ip, ifi->name);
      return;
    }
  ifa.scope = scope & IADDR_SCOPE_MASK;

  DBG("KIF: IF%d(%s): %s IPA %I, flg %x, net %N, brd %I, opp %I\n",
      ifi->index, ifi->name,
      new ? "added" : "removed",
      ifa.ip, ifa.flags, &ifa.prefix, ifa.brd, ifa.opposite);

  if (new)
    ifa_update(&ifa);
  else
    ifa_delete(&ifa);

  if (!scan)
    if_end_partial_update(ifi);
}

static void
nl_parse_addr(struct nlmsghdr *h, int scan)
{
  struct ifaddrmsg *i;

  if (!(i = nl_checkin(h, sizeof(*i))))
    return;

  int new = (h->nlmsg_type == RTM_NEWADDR);

  switch (i->ifa_family)
    {
      case AF_INET:
	return nl_parse_addr4(i, scan, new);

      case AF_INET6:
	return nl_parse_addr6(i, scan, new);
    }
}

void
kif_do_scan(struct kif_proto *p UNUSED)
{
  struct nlmsghdr *h;

  if_start_update();

  nl_request_dump_link(AF_UNSPEC, 0);
  while (h = nl_get_scan())
    if (h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)
      nl_parse_link(h, 1);
    else
      log(L_DEBUG "nl_scan_ifaces: Unknown packet received (type=%d)", h->nlmsg_type);

  /* Re-resolve master interface for slaves */
  IFACE_WALK(i)
    if (i->master_index)
    {
      struct iface f = {
	.flags = i->flags,
	.mtu = i->mtu,
	.index = i->index,
	.master_index = i->master_index,
	.master = if_find_by_index_locked(i->master_index)
      };

      if (f.master != i->master)
      {
	memcpy(f.name, i->name, sizeof(f.name));
	if_update_locked(&f);
      }
    }

  nl_request_dump_addr(AF_INET);
  while (h = nl_get_scan())
    if (h->nlmsg_type == RTM_NEWADDR || h->nlmsg_type == RTM_DELADDR)
      nl_parse_addr(h, 1);
    else
      log(L_DEBUG "nl_scan_ifaces: Unknown packet received (type=%d)", h->nlmsg_type);

  nl_request_dump_addr(AF_INET6);
  while (h = nl_get_scan())
    if (h->nlmsg_type == RTM_NEWADDR || h->nlmsg_type == RTM_DELADDR)
      nl_parse_addr(h, 1);
    else
      log(L_DEBUG "nl_scan_ifaces: Unknown packet received (type=%d)", h->nlmsg_type);

  if_end_update();
}


/*
 *	Routes
 */

static inline u32
krt_table_id(struct krt_proto *p)
{
  return KRT_CF->sys.table_id;
}

static HASH(struct krt_proto) nl_table_map;

#define RTH_KEY(p)		p->af, krt_table_id(p)
#define RTH_NEXT(p)		p->sys.hash_next
#define RTH_EQ(a1,i1,a2,i2)	a1 == a2 && i1 == i2
#define RTH_FN(a,i)		a ^ u32_hash(i)

#define RTH_REHASH		rth_rehash
#define RTH_PARAMS		/8, *1, 2, 2, 4, 20

HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)

int
krt_capable(rte *e)
{
  eattr *ea = ea_find(e->attrs, &ea_gen_nexthop);
  if (!ea)
    return 0;

  struct nexthop_adata *nhad = (void *) ea->u.ptr;
  if (NEXTHOP_IS_REACHABLE(nhad))
    return 1;

  switch (nhad->dest)
  {
    case RTD_BLACKHOLE:
    case RTD_UNREACHABLE:
    case RTD_PROHIBIT:
      return 1;

    default:
      return 0;
  }
}

static inline int
nh_bufsize(struct nexthop_adata *nhad)
{
  int rv = 0;
  NEXTHOP_WALK(nh, nhad)
    rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
  return rv;
}

static int
nl_send_route(struct krt_proto *p, const rte *e, int op)
{
  eattr *ea;
  ea_list *eattrs = e->attrs;
  eattr *nhea = ea_find(eattrs, &ea_gen_nexthop);
  struct nexthop_adata *nh = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
  int dest = nhea_dest(nhea);

  int bufsize = 128 + KRT_METRICS_MAX*8 + (nh ? nh_bufsize(nh) : 0);
  u32 priority = 0;

  struct {
    struct nlmsghdr h;
    struct rtmsg r;
    char buf[0];
  } *r;

  int rsize = sizeof(*r) + bufsize;
  r = alloca(rsize);

  DBG("nl_send_route(%N,op=%x)\n", e->net, op);

  bzero(&r->h, sizeof(r->h));
  bzero(&r->r, sizeof(r->r));
  r->h.nlmsg_type = op ? RTM_NEWROUTE : RTM_DELROUTE;
  r->h.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
  r->h.nlmsg_flags = op | NLM_F_REQUEST | NLM_F_ACK;

  r->r.rtm_family = p->af;
  r->r.rtm_dst_len = net_pxlen(e->net);
  r->r.rtm_protocol = RTPROT_BIRD;
  r->r.rtm_scope = RT_SCOPE_NOWHERE;
#ifdef HAVE_MPLS_KERNEL
  if (p->af == AF_MPLS)
  {
    /*
     * Kernel MPLS code is a bit picky. We must:
     * 1) Always set RT_SCOPE_UNIVERSE and RTN_UNICAST (even for RTM_DELROUTE)
     * 2) Never use RTA_PRIORITY
     */

    u32 label = net_mpls(e->net);
    nl_add_attr_mpls(&r->h, rsize, RTA_DST, 1, &label);
    r->r.rtm_scope = RT_SCOPE_UNIVERSE;
    r->r.rtm_type = RTN_UNICAST;
  }
  else
#endif
  {
    nl_add_attr_ipa(&r->h, rsize, RTA_DST, net_prefix(e->net));

    /* Add source address for IPv6 SADR routes */
    if (e->net->type == NET_IP6_SADR)
    {
      net_addr_ip6_sadr *a = TYPE_CAST(net_addr *, net_addr_ip6_sadr *, e->net);
      nl_add_attr_ip6(&r->h, rsize, RTA_SRC, a->src_prefix);
      r->r.rtm_src_len = a->src_pxlen;
    }
  }

  /*
   * Strange behavior for RTM_DELROUTE:
   * 1) rtm_family is ignored in IPv6, works for IPv4
   * 2) not setting RTA_PRIORITY is different from setting default value (on IPv6)
   * 3) not setting RTA_PRIORITY is equivalent to setting 0, which is wildcard
   */

  if (krt_table_id(p) < 256)
    r->r.rtm_table = krt_table_id(p);
  else
    nl_add_attr_u32(&r->h, rsize, RTA_TABLE, krt_table_id(p));

  if (p->af == AF_MPLS)
    priority = 0;
  else if (KRT_CF->sys.metric)
    priority = KRT_CF->sys.metric;
  else if ((op != NL_OP_DELETE) && (ea = ea_find(eattrs, &ea_krt_metric)))
    priority = ea->u.data;

  if (priority)
    nl_add_attr_u32(&r->h, rsize, RTA_PRIORITY, priority);

  /* For route delete, we do not specify remaining route attributes */
  if (op == NL_OP_DELETE)
    goto done;

  /* Default scope is LINK for device routes, UNIVERSE otherwise */
  if (p->af == AF_MPLS)
    r->r.rtm_scope = RT_SCOPE_UNIVERSE;
  else if (ea = ea_find(eattrs, &ea_krt_scope))
    r->r.rtm_scope = ea->u.data;
  else if (dest == RTD_UNICAST && ipa_zero(nh->nh.gw))
    r->r.rtm_scope = RT_SCOPE_LINK;
  else
    r->r.rtm_scope = RT_SCOPE_UNIVERSE;

  if (ea = ea_find(eattrs, &ea_krt_prefsrc))
    nl_add_attr_ipa(&r->h, rsize, RTA_PREFSRC, *(ip_addr *)ea->u.ptr->data);

  if (ea = ea_find(eattrs, &ea_krt_realm))
    nl_add_attr_u32(&r->h, rsize, RTA_FLOW, ea->u.data);


  u32 metrics[KRT_METRICS_MAX];
  const char *cc_algo = NULL;
  metrics[0] = 0;

  struct ea_walk_state ews = { .eattrs = eattrs };
  while (ea = ea_walk(&ews, ea_krt_metrics[0].id, KRT_METRICS_MAX))
  {
    int id = ea->id - ea_krt_metrics[0].id;
    metrics[0] |= 1 << id;

    if (id == RTAX_CC_ALGO)
      cc_algo = ea->u.ptr->data;
    else
      metrics[id] = ea->u.data;
  }

  if (metrics[0])
    nl_add_metrics(&r->h, rsize, metrics, cc_algo, KRT_METRICS_MAX);

  switch (dest)
    {
    case RTD_UNICAST:
      r->r.rtm_type = RTN_UNICAST;
      if (!NEXTHOP_ONE(nh))
	nl_add_multipath(&r->h, rsize, nh, p->af, eattrs);
      else
      {
	nl_add_attr_u32(&r->h, rsize, RTA_OIF, nh->nh.iface->index);
	nl_add_nexthop(&r->h, rsize, &nh->nh, p->af);

	if (nh->nh.flags & RNF_ONLINK)
	  r->r.rtm_flags |= RTNH_F_ONLINK;
      }
      break;
    case RTD_BLACKHOLE:
      r->r.rtm_type = RTN_BLACKHOLE;
      break;
    case RTD_UNREACHABLE:
      r->r.rtm_type = RTN_UNREACHABLE;
      break;
    case RTD_PROHIBIT:
      r->r.rtm_type = RTN_PROHIBIT;
      break;
    case RTD_NONE:
      break;
    default:
      bug("krt_capable inconsistent with nl_send_route");
    }

done:
  /* Ignore missing for DELETE */
  return nl_exchange(&r->h, (op == NL_OP_DELETE));
}

static inline int
nl_allow_replace(struct krt_proto *p, const rte *new, const rte *old)
{
  /*
   * In kernel routing tables, (net, metric) is the primary key. Therefore, we
   * can use NL_OP_REPLACE only if the new and and the old route have the same
   * kernel metric, otherwise the replace would just add the new route while
   * keep the old one.
   */

  if ((p->af != AF_MPLS) && (KRT_CF->sys.metric == 0))
  {
    uint new_metric = ea_get_int(new->attrs, &ea_krt_metric, 0);
    uint old_metric = ea_get_int(old->attrs, &ea_krt_metric, 0);

    if (new_metric != old_metric)
      return 0;
  }

  /*
   * We use NL_OP_REPLACE for IPv4, it has an issue with not checking for
   * matching rtm_protocol, but that is OK when dedicated priority is used.
   *
   * For IPv6, the NL_OP_REPLACE is still broken even in Linux 4.19 LTS
   * (although it seems to be fixed in Linux 5.10 LTS) for sequence:
   *
   * ip route add 2001:db8::/32 via fe80::1 dev eth0
   * ip route replace 2001:db8::/32 dev eth0
   *
   * (it ends with two routes instead of replacing the first by the second one)
   *
   * Replacing with direct and special type (e.g. unreachable) routes does not
   * work, but replacing with regular routes work reliably
   */

  if (krt_ipv4(p))
    return 1;

  eattr *nhea = ea_find(new->attrs, &ea_gen_nexthop);
  struct nexthop_adata *nh = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
  int dest = nhea_dest(nhea);

  return (dest == RTD_UNICAST) && ipa_nonzero(nh->nh.gw);
}

void
krt_replace_rte(struct krt_proto *p, const net_addr *n UNUSED, rte *new, const rte *old)
{
  int err = 0;

  if (old && new && nl_allow_replace(p, new, old))
  {
    err = nl_send_route(p, new, NL_OP_REPLACE);
  }
  else
  {
    if (old)
      nl_send_route(p, old, NL_OP_DELETE);

    if (new)
      err = nl_send_route(p, new, NL_OP_ADD);
  }

  if (new)
  {
    if (err < 0)
      bmap_clear(&p->sync_map, new->id);
    else
      bmap_set(&p->sync_map, new->id);
  }
}


#define SKIP0(ARG, ...) do { DBG("KRT: Ignoring route - " ARG, ##__VA_ARGS__); return; } while(0)
#define SKIP(ARG, ...)  do { DBG("KRT: Ignoring route %N - " ARG, &dst, ##__VA_ARGS__); return; } while(0)

static void
nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
{
  struct krt_proto *p;
  struct rtmsg *i;
  struct rtattr *a[BIRD_RTA_MAX];
  int new = h->nlmsg_type == RTM_NEWROUTE;

  net_addr dst, src = {};
  u32 oif = ~0;
  u32 table_id;
  u32 priority = 0;
  u32 def_scope = RT_SCOPE_UNIVERSE;
  int krt_src;

  if (!(i = nl_checkin(h, sizeof(*i))))
    return;

  switch (i->rtm_family)
    {
    case AF_INET:
      if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want4, a, sizeof(a)))
	return;

      if (a[RTA_DST])
	net_fill_ip4(&dst, rta_get_ip4(a[RTA_DST]), i->rtm_dst_len);
      else
	net_fill_ip4(&dst, IP4_NONE, 0);
      break;

    case AF_INET6:
      if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want6, a, sizeof(a)))
	return;

      if (a[RTA_DST])
	net_fill_ip6(&dst, rta_get_ip6(a[RTA_DST]), i->rtm_dst_len);
      else
	net_fill_ip6(&dst, IP6_NONE, 0);

      if (a[RTA_SRC])
	net_fill_ip6(&src, rta_get_ip6(a[RTA_SRC]), i->rtm_src_len);
      else
	net_fill_ip6(&src, IP6_NONE, 0);
      break;

#ifdef HAVE_MPLS_KERNEL
    case AF_MPLS:
      if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want_mpls, a, sizeof(a)))
	return;

      if (!a[RTA_DST])
	SKIP0("MPLS route without RTA_DST\n");

      if (rta_get_mpls(a[RTA_DST], rta_mpls_stack) != 1)
	SKIP0("MPLS route with multi-label RTA_DST\n");

      net_fill_mpls(&dst, rta_mpls_stack[0]);
      break;
#endif

    default:
      return;
    }

  if (a[RTA_OIF])
    oif = rta_get_u32(a[RTA_OIF]);

  if (a[RTA_TABLE])
    table_id = rta_get_u32(a[RTA_TABLE]);
  else
    table_id = i->rtm_table;

  if (i->rtm_flags & RTM_F_CLONED)
    SKIP("cloned\n");

  /* Do we know this table? */
  p = HASH_FIND(nl_table_map, RTH, i->rtm_family, table_id);
  if (!p)
    SKIP("unknown table %u\n", table_id);

  if (a[RTA_SRC] && (p->p.net_type != NET_IP6_SADR))
    SKIP("src prefix for non-SADR channel\n");

  if (a[RTA_IIF])
    SKIP("IIF set\n");

  if (i->rtm_tos != 0)			/* We don't support TOS */
    SKIP("TOS %02x\n", i->rtm_tos);

  if (s->scan && !new)
    SKIP("RTM_DELROUTE in scan\n");

  if (a[RTA_PRIORITY])
    priority = rta_get_u32(a[RTA_PRIORITY]);

  int c = net_classify(&dst);
  if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
    SKIP("strange class/scope\n");

  switch (i->rtm_protocol)
    {
    case RTPROT_UNSPEC:
      SKIP("proto unspec\n");

    case RTPROT_REDIRECT:
      krt_src = KRT_SRC_REDIRECT;
      break;

    case RTPROT_KERNEL:
      krt_src = KRT_SRC_KERNEL;
      break;

    case RTPROT_BIRD:
      if (!s->scan)
	SKIP("echo\n");
      krt_src = KRT_SRC_BIRD;
      break;

    case RTPROT_BOOT:
    default:
      krt_src = KRT_SRC_ALIEN;
    }

  net_addr *net = &dst;
  if (p->p.net_type == NET_IP6_SADR)
  {
    net = alloca(sizeof(net_addr_ip6_sadr));
    net_fill_ip6_sadr(net, net6_prefix(&dst), net6_pxlen(&dst),
		      net6_prefix(&src), net6_pxlen(&src));
  }

  ea_list *ra = NULL;
  ea_set_attr_u32(&ra, &ea_gen_source, 0, RTS_INHERIT);
  ea_set_attr_u32(&ra, &ea_krt_source, 0, i->rtm_protocol);
  ea_set_attr_u32(&ra, &ea_krt_metric, 0, priority);

  if (a[RTA_FLOW])
    s->rta_flow = rta_get_u32(a[RTA_FLOW]);
  else
    s->rta_flow = 0;

  union {
    struct {
      struct adata ad;
      struct nexthop nh;
      u32 labels[MPLS_MAX_LABEL_STACK];
    };
    struct nexthop_adata nhad;
  } nhad = {};

  switch (i->rtm_type)
    {
    case RTN_UNICAST:
      if (a[RTA_MULTIPATH])
        {
	  struct nexthop_adata *nh = nl_parse_multipath(s, p, net, a[RTA_MULTIPATH], i->rtm_family, krt_src);
	  if (!nh)
	    SKIP("strange RTA_MULTIPATH\n");

	  ea_set_attr(&ra, EA_LITERAL_DIRECT_ADATA(
		&ea_gen_nexthop, 0, &nh->ad));
	  break;
	}

      if ((i->rtm_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
	SKIP("ignore RTNH_F_DEAD\n");

      nhad.nh.iface = if_find_by_index(oif);
      if (!nhad.nh.iface)
	{
	  log(L_ERR "KRT: Received route %N with unknown ifindex %u", net, oif);
	  return;
	}

      if (a[RTA_GATEWAY])
	nhad.nh.gw = rta_get_ipa(a[RTA_GATEWAY]);

      if (a[RTA_VIA])
	nhad.nh.gw = rta_get_via(a[RTA_VIA]);

      if (i->rtm_flags & RTNH_F_ONLINK)
	nhad.nh.flags |= RNF_ONLINK;

      if (ipa_nonzero(nhad.nh.gw))
	{
	  /* Silently skip strange 6to4 routes */
	  const net_addr_ip6 sit = NET_ADDR_IP6(IP6_NONE, 96);
	  if ((i->rtm_family == AF_INET6) && ipa_in_netX(nhad.nh.gw, (net_addr *) &sit))
	    return;

#ifdef CONFIG_ASSUME_ONLINK
	  if (krt_assume_onlink(nhad.nh.iface, ipa_is_ip6(nhad.nh.gw)))
	    nhad.nh.flags |= RNF_ONLINK;
#endif

	  neighbor *nbr;
	  nbr = neigh_find(&p->p, nhad.nh.gw, nhad.nh.iface,
			   (nhad.nh.flags & RNF_ONLINK) ? NEF_ONLINK : 0);
	  if (!nbr || (nbr->scope == SCOPE_HOST))
	    {
	      log(L_ERR "KRT: Received route %N with strange next-hop %I", net,
                  nhad.nh.gw);
	      return;
	    }
	}

#ifdef HAVE_MPLS_KERNEL
      if ((i->rtm_family == AF_MPLS) && a[RTA_NEWDST] && !a[RTA_MULTIPATH])
	nhad.nh.labels = rta_get_mpls(a[RTA_NEWDST], nhad.nh.label);

      if (a[RTA_ENCAP] && a[RTA_ENCAP_TYPE] && !a[RTA_MULTIPATH])
	{
	  switch (rta_get_u16(a[RTA_ENCAP_TYPE]))
	    {
	      case LWTUNNEL_ENCAP_MPLS:
		{
		  struct rtattr *enca[BIRD_RTA_MAX];
		  nl_attr_len = RTA_PAYLOAD(a[RTA_ENCAP]);
		  nl_parse_attrs(RTA_DATA(a[RTA_ENCAP]), encap_mpls_want, enca, sizeof(enca));
		  nhad.nh.labels = rta_get_mpls(enca[RTA_DST], nhad.nh.label);
		  break;
		}
	      default:
		SKIP("unknown encapsulation method %d\n", rta_get_u16(a[RTA_ENCAP_TYPE]));
		break;
	    }
	}
#endif

      /* Finalize the nexthop */
      nhad.ad.length = (void *) NEXTHOP_NEXT(&nhad.nh) - (void *) nhad.ad.data;
      break;
    case RTN_BLACKHOLE:
      nhad.nhad = NEXTHOP_DEST_LITERAL(RTD_BLACKHOLE);
      break;
    case RTN_UNREACHABLE:
      nhad.nhad = NEXTHOP_DEST_LITERAL(RTD_UNREACHABLE);
      break;
    case RTN_PROHIBIT:
      nhad.nhad = NEXTHOP_DEST_LITERAL(RTD_PROHIBIT);
      break;
    /* FIXME: What about RTN_THROW? */
    default:
      SKIP("type %d\n", i->rtm_type);
      return;
    }

  if (nhad.ad.length)
    ea_set_attr(&ra, EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nhad.ad));

  if (i->rtm_scope != def_scope)
    ea_set_attr(&ra,
	EA_LITERAL_EMBEDDED(&ea_krt_scope, 0, i->rtm_scope));

  if (a[RTA_PREFSRC])
  {
    ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);

    ea_set_attr(&ra,
	EA_LITERAL_STORE_ADATA(&ea_krt_prefsrc, 0, &ps, sizeof(ps)));
  }

  /* Can be set per-route or per-nexthop */
  if (s->rta_flow)
    ea_set_attr(&ra,
	EA_LITERAL_EMBEDDED(&ea_krt_realm, 0, s->rta_flow));

  if (a[RTA_METRICS])
    {
      u32 metrics[KRT_METRICS_MAX];
      const char *cc_algo = NULL;

      if (nl_parse_metrics(a[RTA_METRICS], metrics, &cc_algo, ARRAY_SIZE(metrics)) < 0)
        {
	  log(L_ERR "KRT: Received route %N with strange RTA_METRICS attribute", net);
	  return;
	}

      for (uint t = 1; t < KRT_METRICS_MAX; t++)
	if (metrics[0] & (1 << t))
	  if (t == RTAX_CC_ALGO)
	    ea_set_attr(&ra, EA_LITERAL_STORE_ADATA(&ea_krt_metrics[t], 0, cc_algo, strlen(cc_algo) + 1));
	  else
	    ea_set_attr(&ra, EA_LITERAL_EMBEDDED(&ea_krt_metrics[t], 0, metrics[t]));
    }

  rte e0 = {
    .net = net,
    .attrs = ra,
  };

  if (s->scan)
    krt_got_route(p, &e0, krt_src);
  else
    krt_got_route_async(p, &e0, new, krt_src);

  lp_flush(s->pool);
}

void
krt_do_scan(struct krt_proto *p)
{
  struct nl_parse_state s = {
    .proto = p,
    .pool = nl_linpool,
    .scan = 1,
  };

  /* Table-specific scan or shared scan */
  if (p)
    nl_request_dump_route(p->af, krt_table_id(p));
  else
    nl_request_dump_route(AF_UNSPEC, 0);

  struct nlmsghdr *h;
  while (h = nl_get_scan())
  {
    if (h->nlmsg_type == RTM_NEWROUTE || h->nlmsg_type == RTM_DELROUTE)
      nl_parse_route(&s, h);
    else
      log(L_DEBUG "nl_scan_fire: Unknown packet received (type=%d)", h->nlmsg_type);
  }
}


#ifdef CONFIG_BRIDGE

/*
 *	FDB entries
 */

static inline u32
kbr_bridge_id(struct kbr_proto *p)
{
  return p->bridge_dev->index;
}

static HASH(struct kbr_proto) nl_bridge_map;

#define BRH_KEY(p)		kbr_bridge_id(p)
#define BRH_NEXT(p)		p->hash_next
#define BRH_EQ(i1,i2)		i1 == i2
#define BRH_FN(i)		u32_hash(i)

#define BRH_REHASH		brh_rehash
#define BRH_PARAMS		/8, *1, 2, 2, 4, 20

HASH_DEFINE_REHASH_FN(BRH, struct kbr_proto);

static int
nl_send_fdb(const net_addr *n0, const rte *e, int op, int tunnel)
{
  const net_addr_eth *n = (void *) n0;

  struct {
    struct nlmsghdr h;
    struct ndmsg n;
    char buf[0];
  } *r;

  int rsize = sizeof(*r) + 256;
  r = alloca(rsize);

  memset(&r->h, 0, sizeof(r->h));
  memset(&r->n, 0, sizeof(r->n));
  r->h.nlmsg_type = op ? RTM_NEWNEIGH : RTM_DELNEIGH;
  r->h.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
  r->h.nlmsg_flags = op | NLM_F_REQUEST | NLM_F_ACK;

  r->n.ndm_family = AF_BRIDGE;
  r->n.ndm_state = NUD_NOARP;
  r->n.ndm_flags = (tunnel ? NTF_SELF : NTF_MASTER) | NTF_EXT_LEARNED;

  nl_add_attr(&r->h, rsize, NDA_LLADDR, n->mac.addr, 6);

  if (n->vid)
    nl_add_attr_u16(&r->h, rsize, NDA_VLAN, n->vid);

  struct nexthop_adata *nhad = rte_get_nexthops(e);
  ASSERT_DIE(NEXTHOP_ONE(nhad));
  struct nexthop *nh = &nhad->nh;
  r->n.ndm_ifindex = nh->iface->index;

  if (tunnel)
  {
    ASSERT(ipa_nonzero(nh->gw));
    nl_add_attr_ipa(&r->h, rsize, NDA_DST, nh->gw);

    if (nh->labels)
      nl_add_attr_u32(&r->h, rsize, NDA_VNI, nh->label[0]);

    eattr *ea = ea_find(e->attrs, &ea_gen_mpls_label);
    if (ea)
      nl_add_attr_u32(&r->h, rsize, NDA_SRC_VNI, ea->u.data);

    r->n.ndm_state |= NUD_PERMANENT;
  }

  /* Ignore missing for DELETE */
  return nl_exchange(&r->h, (op == NL_OP_DELETE));
}

void
kbr_replace_fdb(struct kbr_proto *p, const net_addr *n, rte *new, const rte *old, int tunnel)
{
  int err = 0;

  if (old && new)
  {
    err = nl_send_fdb(n, new, NL_OP_REPLACE, tunnel);
  }
  else
  {
    if (old)
      nl_send_fdb(n, old, NL_OP_DELETE, tunnel);

    if (new)
      err = nl_send_fdb(n, new, NL_OP_ADD, tunnel);
  }

  if (new)
  {
    if (err < 0)
      bmap_clear(&p->sync_map[tunnel], new->id);
    else
      bmap_set(&p->sync_map[tunnel], new->id);
  }

  if (err < 0)
    log(L_WARN "NL error %m");
}

void
kbr_update_fdb(struct kbr_proto *p, const net_addr *n, rte *new, const rte *old, int tunnel)
{
  int err = 0;

  if (old)
    nl_send_fdb(n, old, NL_OP_DELETE, tunnel);

  if (new)
  {
    err = nl_send_fdb(n, new, NL_OP_APPEND, tunnel);

    if (err < 0)
      bmap_clear(&p->sync_map[tunnel], new->id);
    else
      bmap_set(&p->sync_map[tunnel], new->id);
  }

  if (err < 0)
    log(L_WARN "NL error %m");
}

#ifndef NDM_RTA
#define NDM_RTA(n) (struct rtattr *)(((char *) n) + NLMSG_ALIGN(sizeof(struct ndmsg)))
#endif

static void
nl_parse_fdb(struct nl_parse_state *s, struct nlmsghdr *h)
{
  struct ndmsg *nd;
  struct rtattr *a[BIRD_NDA_MAX];
  int new = (h->nlmsg_type == RTM_NEWNEIGH);

  if (!(nd = nl_checkin(h, sizeof(*nd))))
    return;

  if (nd->ndm_family != AF_BRIDGE)
    return;

  if (!nl_parse_attrs(NDM_RTA(nd), ndm_attr_want, a, sizeof(a)))
    return;

  if (!a[NDA_LLADDR])
    return;

  mac_addr mac = rta_get_mac(a[NDA_LLADDR]);
  uint vid = a[NDA_VLAN] ? rta_get_u16(a[NDA_VLAN]) : 0;

  net_addr n;
  net_fill_eth(&n, mac, vid);

  /* Ignore multicast entries */
  if (!mac_is_unicast(mac))
    return;

  struct iface *oif = if_find_by_index(nd->ndm_ifindex);
  if (!oif)
    return;

  /* NDA_MASTER is not present on 'self' entries */
  u32 bridge_id = oif->master_index;

  /* Should be filtered by kernel */
  if (s->bridge_id && (bridge_id != s->bridge_id))
    return;

  /* When NDA_MASTER is reported, it should be the same */
  if (a[NDA_MASTER] && (bridge_id != rta_get_u32(a[NDA_MASTER])))
    return;

  /* Do we know this bridge? */
  struct kbr_proto *p = HASH_FIND(nl_bridge_map, BRH, bridge_id);
  if (!p)
    return;

  rte e0 = {
    .src = p->p.main_source,
  };

  ea_set_attr_u32(&e0.attrs, &ea_gen_source, 0, RTS_BRIDGE);

  struct nexthop_adata *nhad = tmp_allocz(NEXTHOP_MAX_SIZE + sizeof *nhad);
  struct nexthop *nh = &nhad->nh;
  nh->iface = oif;

  bool tunnel = false;

  /* FDB entries from port devices */
  if (nd->ndm_flags & NTF_SELF)
  {
    /* FDB entries from VXLAN devices */
    u32 type = ea_get_int(oif->attrs, &ea_iface_type, IF_TYPE_UNDEF);
    if (type != IF_TYPE_VXLAN)
      return;

    if (a[NDA_DST])
      nh->gw = rta_get_ipa(a[NDA_DST]);

    if (a[NDA_VNI])
    {
      nh->labels = 1;
      nh->label[0] = rta_get_u32(a[NDA_VNI]);
    }

    if (a[NDA_SRC_VNI])
    {
      struct kbr_vlan *vlan = kbr_find_vlan_by_vni(p, oif->index, rta_get_u32(a[NDA_SRC_VNI]));
      if (!vlan)
      {
	log(L_TRACE "%s: FDB %N unkown vni %u", p->p.name, &n, rta_get_u32(a[NDA_SRC_VNI]));
	return;
      }

      ((net_addr_eth *) &n)->vid = vid = vlan->vid;
    }

    tunnel = true;
  }

  /* Accept VLAN-tagged entries when vlan filtering is enabled */
  if (!vid != !p->vlan_filtering)
    return;

  int src;
  if (nd->ndm_flags & NTF_EXT_LEARNED)
    src = KBR_SRC_BIRD;
  else if (nd->ndm_state & NUD_PERMANENT)
    src = KBR_SRC_LOCAL;
  else if (nd->ndm_state & NUD_NOARP)
    src = KBR_SRC_STATIC;
  else
    src = KBR_SRC_DYNAMIC;

  ea_set_attr_u32(&e0.attrs, &ea_kbr_source, 0, src);
  ea_set_attr_data(&e0.attrs, &ea_gen_nexthop, 0, nhad->ad.data, nhad->ad.length = ((void *) NEXTHOP_NEXT(nh) - (void *) nhad->ad.data));

  DBG("FDB %s %N dev %s [%x %x %x] %d %d %d\n", (new ? "add" : "del"), &n, oif->name, nd->ndm_state, nd->ndm_flags, nd->ndm_type, (int) src, (int) s->scan, (int) tunnel);
  kbr_got_fdb(p, &n, new ? &e0 : NULL, nhad, src, s->scan, tunnel);
}

void
kbr_do_fdb_scan(struct kbr_proto *p)
{
  struct nl_parse_state s = {
    .pool = nl_linpool,
    .scan = 1,
    .bridge_id = kbr_bridge_id(p),
  };

  struct nlmsghdr *h;

  nl_request_dump_neigh(AF_BRIDGE, kbr_bridge_id(p));
  while (h = nl_get_scan())
  {
    if (h->nlmsg_type == RTM_NEWNEIGH || h->nlmsg_type == RTM_DELNEIGH)
      nl_parse_fdb(&s, h);
  }
}


/*
 *	VLANs
 */

static int
nl_send_vlan(struct iface *i, uint vid, uint tid, uint flags, int op, int tunnel)
{
  struct {
    struct nlmsghdr h;
    struct ifinfomsg i;
    char buf[0];
  } *r;

  int rsize = sizeof(*r) + 256;
  r = alloca(rsize);

  memset(&r->h, 0, sizeof(r->h));
  memset(&r->i, 0, sizeof(r->i));
  r->h.nlmsg_type = op ? RTM_SETLINK : RTM_DELLINK;
  r->h.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
  r->h.nlmsg_flags = op | NLM_F_REQUEST | NLM_F_ACK;

  r->i.ifi_family = AF_BRIDGE;
  r->i.ifi_index = i->index;

  struct rtattr *afspec = nl_open_attr(&r->h, rsize, IFLA_AF_SPEC);

  if (!tunnel)
  {
    struct bridge_vlan_info vinfo = { .flags = flags, .vid = vid, };
    nl_add_attr(&r->h, rsize, IFLA_BRIDGE_VLAN_INFO, &vinfo, sizeof(vinfo));
  }
  else
  {
    struct rtattr *tinfo = nl_open_attr(&r->h, rsize, IFLA_BRIDGE_VLAN_TUNNEL_INFO);
    nl_add_attr_u32(&r->h, rsize, IFLA_BRIDGE_VLAN_TUNNEL_ID, tid);
    nl_add_attr_u16(&r->h, rsize, IFLA_BRIDGE_VLAN_TUNNEL_VID, vid);
    nl_add_attr_u16(&r->h, rsize, IFLA_BRIDGE_VLAN_TUNNEL_FLAGS, flags);
    nl_close_attr(&r->h, tinfo);
  }

  nl_close_attr(&r->h, afspec);

  /* Ignore missing for DELETE */
  return nl_exchange(&r->h, (op == NL_OP_DELETE));
}

void
kbr_update_vlan(struct iface *i, uint vid, bool new, bool old, bool new_tunnel, bool old_tunnel, uint new_vni, uint old_vni)
{
  int err = 0;

  if ((old && new) && (old_tunnel == new_tunnel) && (old_vni == new_vni))
    return;

  if (old_tunnel)
    nl_send_vlan(i, vid, old_vni, 0, NL_OP_DELETE, 1);

  if (old && !new)
    nl_send_vlan(i, vid, 0, 0, NL_OP_DELETE, 0);

  if (new && !old)
    err = nl_send_vlan(i, vid, 0, 0, NL_OP_ADD, 0);

  if (new_tunnel && !err)
    err = nl_send_vlan(i, vid, new_vni, 0, NL_OP_ADD, 1);

  if (err < 0)
    log(L_WARN "NL error %m");
}


static void
nl_parse_vlan(struct nl_parse_state *s, struct nlmsghdr *h)
{
  struct ifinfomsg *i;
  struct rtattr *a[BIRD_IFLA_MAX];
  // int new = (h->nlmsg_type == RTM_NEWLINK);

  if (!(i = nl_checkin(h, sizeof(*i))))
    return;

  struct iface *oif = if_find_by_index(i->ifi_index);
  if (!oif)
    return;

  if (i->ifi_family != AF_BRIDGE)
    return;

  if (!nl_parse_attrs(IFLA_RTA(i), ifla_attr_want, a, sizeof(a)))
    return;

  if (!a[IFLA_AF_SPEC] || !a[IFLA_MASTER])
    return;

  u32 bridge_id = rta_get_u32(a[IFLA_MASTER]);

  /* Should be filtered by kernel */
  if (s->bridge_id && (bridge_id != s->bridge_id))
    return;

  /* Do we know this bridge? */
  struct kbr_proto *p = HASH_FIND(nl_bridge_map, BRH, bridge_id);
  if (!p)
    return;

  /* Accept VLANs when vlan filtering is enabled */
  if (!p->vlan_filtering)
    return;

  struct rtattr *list = a[IFLA_AF_SPEC];
  uint rem = RTA_PAYLOAD(list);

  /* We have to iterate over rtattrs to handle multiple instances of VLAN info attributes */
  for (struct rtattr *vi = RTA_DATA(list); RTA_OK(vi, rem); vi = RTA_NEXT(vi, rem))
  {
    if (vi->rta_type == IFLA_BRIDGE_VLAN_INFO)
    {
      if (RTA_PAYLOAD(vi) != sizeof(struct bridge_vlan_info))
      {
	log(L_ERR "nl_parse_attrs: Malformed attribute received");
	continue;
      }

      struct bridge_vlan_info *info = RTA_DATA(vi);

      DBG("VLAN %u dev %s flags %x\n", info->vid, oif->name, info->flags);
      kbr_got_vlan(p, oif, info->vid, info->flags);
    }

    if (vi->rta_type == IFLA_BRIDGE_VLAN_TUNNEL_INFO)
    {
      struct rtattr *a0[BIRD_IFBRIDGE_VLAN_TUNNEL_MAX];

      nl_attr_len = RTA_PAYLOAD(vi);
      if (!nl_parse_attrs(RTA_DATA(vi), ifbridge_vlan_tunnel_attr_want, a0, sizeof(a0)))
	continue;

      uint tid = a0[IFLA_BRIDGE_VLAN_TUNNEL_ID] ? rta_get_u32(a0[IFLA_BRIDGE_VLAN_TUNNEL_ID]) : 0;
      uint vid = a0[IFLA_BRIDGE_VLAN_TUNNEL_VID] ? rta_get_u16(a0[IFLA_BRIDGE_VLAN_TUNNEL_VID]) : 0;
      uint flags = a0[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS] ? rta_get_u16(a0[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS]) : 0;

      DBG("VLANtun %u dev %s tunnel-id %u flags %x\n", vid, oif->name, tid, flags);
      kbr_got_vlan_tunnel(p, oif, vid, tid, flags);
    }
  }
}

void
kbr_do_vlan_scan(struct kbr_proto *p)
{
  struct nl_parse_state s = {
    .pool = nl_linpool,
    .scan = 1,
    .bridge_id = kbr_bridge_id(p),
  };

  struct nlmsghdr *h;

  nl_request_dump_link(AF_BRIDGE, RTEXT_FILTER_BRVLAN);
  while (h = nl_get_scan())
  {
    if (h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)
      nl_parse_vlan(&s, h);
  }
}

#else /* CONFIG_BRIDGE */

static inline void nl_parse_fdb(struct nl_parse_state *s UNUSED, struct nlmsghdr *h UNUSED) { }

#endif /* CONFIG_BRIDGE */


/*
 *	Asynchronous Netlink interface
 */

static sock *nl_async_sk;		/* BIRD socket for asynchronous notifications */
static byte *nl_async_rx_buffer;	/* Receive buffer */
static uint nl_async_bufsize;		/* Kernel rx buffer size for the netlink socket */

static void
nl_async_msg(struct nlmsghdr *h)
{
  struct nl_parse_state s = {
    .proto = NULL,
    .pool = nl_linpool,
    .scan = 0,
  };

  switch (h->nlmsg_type)
    {
    case RTM_NEWROUTE:
    case RTM_DELROUTE:
      DBG("KRT: Received async route notification (%d)\n", h->nlmsg_type);
      nl_parse_route(&s, h);
      break;

    case RTM_NEWLINK:
    case RTM_DELLINK:
      DBG("KRT: Received async link notification (%d)\n", h->nlmsg_type);
      if (kif_proto)
	nl_parse_link(h, 0);
      break;

    case RTM_NEWADDR:
    case RTM_DELADDR:
      DBG("KRT: Received async address notification (%d)\n", h->nlmsg_type);
      if (kif_proto)
	nl_parse_addr(h, 0);
      break;

    case RTM_NEWNEIGH:
    case RTM_DELNEIGH:
      DBG("KRT: Received async neighbor notification (%d)\n", h->nlmsg_type);
      nl_parse_fdb(&s, h);
      break;

    default:
      DBG("KRT: Received unknown async notification (%d)\n", h->nlmsg_type);
    }
}

static int
nl_async_hook(sock *sk, uint size UNUSED)
{
  struct iovec iov = { nl_async_rx_buffer, NL_RX_SIZE };
  struct sockaddr_nl sa;
  struct msghdr m = {
    .msg_name = &sa,
    .msg_namelen = sizeof(sa),
    .msg_iov = &iov,
    .msg_iovlen = 1,
  };
  struct nlmsghdr *h;
  int x;
  uint len;

  x = recvmsg(sk->fd, &m, 0);
  if (x < 0)
    {
      if (errno == ENOBUFS)
	{
	  /*
	   *  Netlink reports some packets have been thrown away.
	   *  One day we might react to it by asking for route table
	   *  scan in near future.
	   */
	  log(L_WARN "Kernel dropped some netlink messages, will resync on next scan.");
	  return 1;	/* More data are likely to be ready */
	}
      else if (errno != EWOULDBLOCK)
	log(L_ERR "Netlink recvmsg: %m");
      return 0;
    }
  if (sa.nl_pid)		/* It isn't from the kernel */
    {
      DBG("Non-kernel packet\n");
      return 1;
    }
  h = (void *) nl_async_rx_buffer;
  len = x;
  if (m.msg_flags & MSG_TRUNC)
    {
      log(L_WARN "Netlink got truncated asynchronous message");
      return 1;
    }
  while (NLMSG_OK(h, len))
    {
      nl_async_msg(h);
      h = NLMSG_NEXT(h, len);
    }
  if (len)
    log(L_WARN "nl_async_hook: Found packet remnant of size %d", len);
  return 1;
}

static void
nl_async_err_hook(sock *sk, int e UNUSED)
{
  nl_async_hook(sk, 0);
}

static void
nl_open_async(void)
{
  sock *sk;
  struct sockaddr_nl sa;
  int fd;

  if (nl_async_sk)
    return;

  DBG("KRT: Opening async netlink socket\n");

  fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (fd < 0)
    {
      log(L_ERR "Unable to open asynchronous rtnetlink socket: %m");
      return;
    }

  bzero(&sa, sizeof(sa));
  sa.nl_family = AF_NETLINK;
  sa.nl_groups = RTMGRP_LINK | RTMGRP_NEIGH |
    RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE |
    RTMGRP_IPV6_IFADDR | RTMGRP_IPV6_ROUTE;

  if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0)
    {
      log(L_ERR "Unable to bind asynchronous rtnetlink socket: %m");
      close(fd);
      return;
    }

  nl_async_rx_buffer = xmalloc(NL_RX_SIZE);

  sk = nl_async_sk = sk_new(krt_pool);
  sk->type = SK_MAGIC;
  sk->rx_hook = nl_async_hook;
  sk->err_hook = nl_async_err_hook;
  sk->fd = fd;
  if (sk_open(sk, &main_birdloop) < 0)
    bug("Netlink: sk_open failed");
}

static void
nl_update_async_bufsize(void)
{
  /* No async socket */
  if (!nl_async_sk)
    return;

  /* For tracking changes to nl_async_bufsize, just a pointer storage */
  static struct config *nl_last_config;

  /* Get current config. This is a bit sketchy but we now
   * simply expect that we're running in the mainloop.
   * When moving kernel protocol to proper loops,
   * this may need to change to avoid funny races.
   */
  struct config *cur = OBSREF_GET(config);
  ASSERT_DIE(birdloop_inside(&main_birdloop));

  /* Already reconfigured */
  if (nl_last_config == cur)
    return;

  /* Update netlink buffer size */
  uint bufsize = nl_cfg_rx_buffer_size(cur);
  if (bufsize && (bufsize != nl_async_bufsize))
  {
    /* Log message for reconfigurations only */
    if (nl_last_config)
      log(L_INFO "KRT: Changing netlink rx buffer size to %u", bufsize);

    nl_set_rcvbuf(nl_async_sk->fd, bufsize);
    nl_async_bufsize = bufsize;
  }

  nl_last_config = cur;
}


/*
 *	Interface to the UNIX krt module
 */

void
krt_sys_io_init(void)
{
  nl_linpool = lp_new_default(krt_pool);
  HASH_INIT(nl_table_map, krt_pool, 4);

#ifdef CONFIG_BRIDGE
  HASH_INIT(nl_bridge_map, krt_pool, 4);
#endif

  nl_ea_register();
}

int
krt_sys_start(struct krt_proto *p)
{
  struct krt_proto *old = HASH_FIND(nl_table_map, RTH, p->af, krt_table_id(p));

  if (old)
    {
      log(L_ERR "%s: Kernel table %u already registered by %s",
	  p->p.name, krt_table_id(p), old->p.name);
      return 0;
    }

  HASH_INSERT2(nl_table_map, RTH, krt_pool, p);

  nl_open();
  nl_open_async();
  nl_update_async_bufsize();

  return 1;
}

void
krt_sys_shutdown(struct krt_proto *p)
{
  nl_update_async_bufsize();

  HASH_REMOVE2(nl_table_map, RTH, krt_pool, p);
}

int
krt_sys_reconfigure(struct krt_proto *p UNUSED, struct krt_config *n, struct krt_config *o)
{
  nl_update_async_bufsize();

  return (n->sys.table_id == o->sys.table_id) && (n->sys.metric == o->sys.metric);
}

void
krt_sys_init_config(struct krt_config *cf)
{
  cf->sys.table_id = RT_TABLE_MAIN;
  cf->sys.metric = 32;
}

void
krt_sys_copy_config(struct krt_config *d, struct krt_config *s)
{
  d->sys.table_id = s->sys.table_id;
  d->sys.metric = s->sys.metric;
}

#ifdef CONFIG_BRIDGE

int
kbr_sys_start(struct kbr_proto *p)
{
  struct kbr_proto *old = HASH_FIND(nl_bridge_map, BRH, kbr_bridge_id(p));

  if (old)
  {
    log(L_ERR "%s: Bridge device %s already registered by %s",
       p->p.name, p->bridge_dev->name, old->p.name);
    return 0;
  }

  HASH_INSERT2(nl_bridge_map, BRH, krt_pool, p);

  nl_open();
  nl_open_async();

  return 1;
}

void
kbr_sys_shutdown(struct kbr_proto *p)
{
  HASH_REMOVE2(nl_bridge_map, BRH, krt_pool, p);
}

#endif /* CONFIG_BRIDGE */



void
kif_sys_start(struct kif_proto *p UNUSED)
{
  nl_open();
  nl_open_async();
}

void
kif_sys_shutdown(struct kif_proto *p UNUSED)
{
}

int
kif_update_sysdep_addr(struct iface *i UNUSED)
{
  return 0;
}
