From 77d032c71f62e44293a10ccc22f8c157442df179 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 5 Jan 2022 18:46:41 +0100
Subject: Netlink: Improve multipath parsing errors

Function nl_parse_multipath() should handle errors internally.
---
 sysdep/linux/netlink.c | 41 +++++++++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 16 deletions(-)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index fdf3f2db..1293df4d 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -681,7 +681,7 @@ nl_add_multipath(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af, e
 }
 
 static struct nexthop *
-nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr *ra, int af)
+nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, const net_addr *n, struct rtattr *ra, int af)
 {
   struct rtattr *a[BIRD_RTA_MAX];
   struct rtnexthop *nh = RTA_DATA(ra);
@@ -695,7 +695,7 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr
     {
       /* Use RTNH_OK(nh,len) ?? */
       if ((len < sizeof(*nh)) || (len < nh->rtnh_len))
-	return NULL;
+	goto err;
 
       if (nh->rtnh_flags & RTNH_F_DEAD)
 	goto next;
@@ -706,7 +706,10 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr
       rv->weight = nh->rtnh_hops;
       rv->iface = if_find_by_index(nh->rtnh_ifindex);
       if (!rv->iface)
-	return NULL;
+	{
+	  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);
@@ -714,18 +717,18 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr
         {
 	case AF_INET:
 	  if (!nl_parse_attrs(RTNH_DATA(nh), nexthop_attr_want4, a, sizeof(a)))
-	    return NULL;
+	    goto err;
 	  break;
 
 	case AF_INET6:
 	  if (!nl_parse_attrs(RTNH_DATA(nh), nexthop_attr_want6, a, sizeof(a)))
-	    return NULL;
+	    goto err;
 	  break;
 
 #ifdef HAVE_MPLS_KERNEL
 	case AF_MPLS:
 	  if (!nl_parse_attrs(RTNH_DATA(nh), nexthop_attr_want_mpls, a, sizeof(a)))
-	    return NULL;
+	    goto err;
 
 	  if (a[RTA_NEWDST])
 	    rv->labels = rta_get_mpls(a[RTA_NEWDST], rv->label);
@@ -734,7 +737,7 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr
 #endif
 
 	default:
-	  return NULL;
+	  goto err;
 	}
 
       if (a[RTA_GATEWAY])
@@ -757,14 +760,19 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr
 	  nbr = neigh_find(&p->p, rv->gw, rv->iface,
 			   (rv->flags & RNF_ONLINK) ? NEF_ONLINK : 0);
 	  if (!nbr || (nbr->scope == SCOPE_HOST))
-	    return NULL;
+	    {
+	        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: Unknown encapsulation method %d in multipath", rta_get_u16(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;
 	}
 
@@ -785,6 +793,10 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, struct rtattr
     first = nexthop_sort(first);
 
   return first;
+
+err:
+  log(L_ERR "KRT: Received strange multipath route %N", n);
+  return NULL;
 }
 
 static void
@@ -1675,19 +1687,16 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 
       if (a[RTA_MULTIPATH])
         {
-	  struct nexthop *nh = nl_parse_multipath(s, p, a[RTA_MULTIPATH], i->rtm_family);
+	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family);
 	  if (!nh)
-	    {
-	      log(L_ERR "KRT: Received strange multipath route %N", net->n.addr);
-	      return;
-	    }
+	    SKIP("strange RTA_MULTIPATH\n");
 
 	  nexthop_link(ra, nh);
 	  break;
 	}
 
       if (i->rtm_flags & RTNH_F_DEAD)
-	return;
+	SKIP("ignore RTNH_F_DEAD\n");
 
       ra->nh.iface = if_find_by_index(oif);
       if (!ra->nh.iface)
-- 
cgit v1.2.3


From f5c8fb5fba959d356ce1ea0fb5879223f76137f7 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 5 Jan 2022 19:25:42 +0100
Subject: Netlink: Do not ignore dead routes from BIRD

Currently, BIRD ignores dead routes to consider them absent. But it also
ignores its own routes and thus it can not correctly manage such routes
in some cases. This patch makes an exception for routes with proto bird
when ignoring dead routes, so they can be properly updated or removed.

Thanks to Alexander Zubkov for the original patch.
---
 sysdep/linux/netlink.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 1293df4d..e127052a 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -681,7 +681,7 @@ nl_add_multipath(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af, e
 }
 
 static struct nexthop *
-nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, const net_addr *n, struct rtattr *ra, int af)
+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 = RTA_DATA(ra);
@@ -697,7 +697,7 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, const net_addr
       if ((len < sizeof(*nh)) || (len < nh->rtnh_len))
 	goto err;
 
-      if (nh->rtnh_flags & RTNH_F_DEAD)
+      if ((nh->rtnh_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
 	goto next;
 
       *last = rv = lp_allocz(s->pool, NEXTHOP_MAX_SIZE);
@@ -1687,7 +1687,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 
       if (a[RTA_MULTIPATH])
         {
-	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family);
+	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
 	  if (!nh)
 	    SKIP("strange RTA_MULTIPATH\n");
 
@@ -1695,7 +1695,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	  break;
 	}
 
-      if (i->rtm_flags & RTNH_F_DEAD)
+      if ((i->rtm_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
 	SKIP("ignore RTNH_F_DEAD\n");
 
       ra->nh.iface = if_find_by_index(oif);
-- 
cgit v1.2.3


From 87a02489f3880689a4e2ad72b0b981649dad2154 Mon Sep 17 00:00:00 2001
From: Alexander Zubkov <green@qrator.net>
Date: Sat, 8 Jan 2022 18:31:56 +0100
Subject: IO: Support nonlocal bind in socket interface

Add option to socket interface for nonlocal binding, i.e. binding to an
IP address that is not present on interfaces. This behaviour is enabled
when SKF_FREEBIND socket flag is set. For Linux systems, it is
implemented by IP_FREEBIND socket flag.

Minor changes done by commiter.
---
 lib/socket.h         |  1 +
 sysdep/bsd/sysio.h   |  6 ++++++
 sysdep/linux/sysio.h | 19 +++++++++++++++++++
 sysdep/unix/io.c     |  4 ++++
 4 files changed, 30 insertions(+)

(limited to 'sysdep/linux')

diff --git a/lib/socket.h b/lib/socket.h
index 96fedeeb..0b6ac589 100644
--- a/lib/socket.h
+++ b/lib/socket.h
@@ -123,6 +123,7 @@ extern int sk_priority_control;		/* Suggested priority for control traffic, shou
 #define SKF_TTL_RX	0x08	/* Report TTL / Hop Limit for RX packets */
 #define SKF_BIND	0x10	/* Bind datagram socket to given source address */
 #define SKF_HIGH_PORT	0x20	/* Choose port from high range if possible */
+#define SKF_FREEBIND	0x40	/* Allow socket to bind to a nonlocal address */
 
 #define SKF_THREAD	0x100	/* Socked used in thread, Do not add to main loop */
 #define SKF_TRUNCATED	0x200	/* Received packet was truncated, set by IO layer */
diff --git a/sysdep/bsd/sysio.h b/sysdep/bsd/sysio.h
index c757960a..f1887fb4 100644
--- a/sysdep/bsd/sysio.h
+++ b/sysdep/bsd/sysio.h
@@ -271,3 +271,9 @@ sk_set_priority(sock *s, int prio UNUSED)
 {
   ERR_MSG("Socket priority not supported");
 }
+
+static inline int
+sk_set_freebind(sock *s)
+{
+  ERR_MSG("Freebind is not supported");
+}
diff --git a/sysdep/linux/sysio.h b/sysdep/linux/sysio.h
index e21ff487..f13eda7c 100644
--- a/sysdep/linux/sysio.h
+++ b/sysdep/linux/sysio.h
@@ -10,6 +10,10 @@
 #define IPV6_MINHOPCOUNT 73
 #endif
 
+#ifndef IPV6_FREEBIND
+#define IPV6_FREEBIND 78
+#endif
+
 #ifndef TCP_MD5SIG_EXT
 #define TCP_MD5SIG_EXT 32
 #endif
@@ -266,3 +270,18 @@ sk_set_priority(sock *s, int prio)
   return 0;
 }
 
+static inline int
+sk_set_freebind(sock *s)
+{
+  int y = 1;
+
+  if (sk_is_ipv4(s))
+    if (setsockopt(s->fd, SOL_IP, IP_FREEBIND, &y, sizeof(y)) < 0)
+      ERR("IP_FREEBIND");
+
+  if (sk_is_ipv6(s))
+    if (setsockopt(s->fd, SOL_IPV6, IPV6_FREEBIND, &y, sizeof(y)) < 0)
+      ERR("IPV6_FREEBIND");
+
+  return 0;
+}
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 3d67d0a7..4fd77453 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -1436,6 +1436,10 @@ sk_open(sock *s)
 	if (sk_set_high_port(s) < 0)
 	  log(L_WARN "Socket error: %s%#m", s->err);
 
+    if (s->flags & SKF_FREEBIND)
+      if (sk_set_freebind(s) < 0)
+        log(L_WARN "Socket error: %s%#m", s->err);
+
     sockaddr_fill(&sa, s->af, bind_addr, s->iface, bind_port);
     if (bind(fd, &sa.sa, SA_LEN(sa)) < 0)
       ERR2("bind");
-- 
cgit v1.2.3


From d0dd1d20cd40e75e417d58569fac3ff0bf1db41a Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 14 Jan 2022 19:07:57 +0100
Subject: Netlink: Explicitly skip received cloned routes

Kernel uses cloned routes to keep route cache entries, but reports them
together with regular routes. They were skipped implicitly as they
do not have rtm_protocol filled. Add explicit check for cloned flag
and skip such routes explicitly.

Also, improve debug logs of skipped routes.
---
 sysdep/linux/netlink.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index e127052a..7cea5322 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1535,7 +1535,8 @@ nl_parse_end(struct nl_parse_state *s)
 }
 
 
-#define SKIP(ARG...) do { DBG("KRT: Ignoring route - " ARG); return; } while(0)
+#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)
@@ -1588,10 +1589,10 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	return;
 
       if (!a[RTA_DST])
-	SKIP("MPLS route without RTA_DST");
+	SKIP0("MPLS route without RTA_DST\n");
 
       if (rta_get_mpls(a[RTA_DST], rta_mpls_stack) != 1)
-	SKIP("MPLS route with multi-label RTA_DST");
+	SKIP0("MPLS route with multi-label RTA_DST\n");
 
       net_fill_mpls(&dst, rta_mpls_stack[0]);
       break;
@@ -1609,6 +1610,9 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   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)
-- 
cgit v1.2.3


From e818f16448e918ed07633480291283f3449dd9e4 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 14 Jan 2022 21:53:40 +0100
Subject: Netlink: Enable strict checking for KRT dumps

Add strict checking for netlink KRT dumps to avoid PMTU cache records
from FNHE table dump along with KRT.

Linux Kernel added FNHE table dump to the netlink API in patch:

https://patchwork.ozlabs.org/project/netdev/patch/8d3b68cd37fb5fddc470904cdd6793fcf480c6c1.1561131177.git.sbrivio@redhat.com/

Therefore, since Linux 5.3 these route cache entries are dumped together
with regular routes during periodic KRT scans, which in some cases may be
huge amount of useless data. This can be avoided by using strict checking
for netlink dumps:

https://lore.kernel.org/netdev/20181008031644.15989-1-dsahern@kernel.org/

The patch mitigates the risk of receiving unknown and potentially large
number of FNHE records that would block BIRD I/O in each sync. There is a
known issue caused by the GRE tunnels on Linux that seems to be creating
one FNHE record for each destination IP address that is routed through
the tunnel, even when the PMTU equals to GRE interface MTU.

Thanks to Tomas Hlavacek for the original patch.
---
 sysdep/linux/netlink.c | 70 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 59 insertions(+), 11 deletions(-)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 7cea5322..71b290fd 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -130,7 +130,7 @@ struct nl_sock
   uint last_size;
 };
 
-#define NL_RX_SIZE 8192
+#define NL_RX_SIZE 32768
 
 #define NL_OP_DELETE	0
 #define NL_OP_ADD	(NLM_F_CREATE|NLM_F_EXCL)
@@ -157,11 +157,19 @@ nl_open_sock(struct nl_sock *nl)
     }
 }
 
+static void
+nl_set_strict_dump(struct nl_sock *nl, int strict)
+{
+  setsockopt(nl->fd, SOL_NETLINK, NETLINK_GET_STRICT_CHK, &strict, sizeof(strict));
+}
+
 static void
 nl_open(void)
 {
   nl_open_sock(&nl_scan);
   nl_open_sock(&nl_req);
+
+  nl_set_strict_dump(&nl_scan, 1);
 }
 
 static void
@@ -180,20 +188,60 @@ nl_send(struct nl_sock *nl, struct nlmsghdr *nh)
 }
 
 static void
-nl_request_dump(int af, int cmd)
+nl_request_dump_link(void)
 {
   struct {
     struct nlmsghdr nh;
-    struct rtgenmsg g;
+    struct ifinfomsg ifi;
   } req = {
-    .nh.nlmsg_type = cmd,
-    .nh.nlmsg_len = sizeof(req),
+    .nh.nlmsg_type = RTM_GETLINK,
+    .nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
     .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
-    .g.rtgen_family = af
+    .nh.nlmsg_seq = ++(nl_scan.seq),
+    .ifi.ifi_family = AF_UNSPEC,
   };
-  nl_send(&nl_scan, &req.nh);
+
+  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)
+{
+  struct {
+    struct nlmsghdr nh;
+    struct rtmsg rtm;
+  } 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,
+  };
+
+  send(nl_scan.fd, &req, sizeof(req), 0);
+  nl_scan.last_hdr = NULL;
+}
+
+
 static struct nlmsghdr *
 nl_get_reply(struct nl_sock *nl)
 {
@@ -1151,7 +1199,7 @@ kif_do_scan(struct kif_proto *p UNUSED)
 
   if_start_update();
 
-  nl_request_dump(AF_UNSPEC, RTM_GETLINK);
+  nl_request_dump_link();
   while (h = nl_get_scan())
     if (h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)
       nl_parse_link(h, 1);
@@ -1178,14 +1226,14 @@ kif_do_scan(struct kif_proto *p UNUSED)
       }
     }
 
-  nl_request_dump(AF_INET, RTM_GETADDR);
+  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(AF_INET6, RTM_GETADDR);
+  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);
@@ -1902,7 +1950,7 @@ krt_do_scan(struct krt_proto *p UNUSED)	/* CONFIG_ALL_TABLES_AT_ONCE => p is NUL
   struct nl_parse_state s;
 
   nl_parse_begin(&s, 1);
-  nl_request_dump(AF_UNSPEC, RTM_GETROUTE);
+  nl_request_dump_route(AF_UNSPEC);
   while (h = nl_get_scan())
     if (h->nlmsg_type == RTM_NEWROUTE || h->nlmsg_type == RTM_DELROUTE)
       nl_parse_route(&s, h);
-- 
cgit v1.2.3


From 8988264a64dc9985303332568832b108dba3acd3 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Fri, 14 Jan 2022 23:15:05 +0100
Subject: Netlink: Add workaround for older kernel headers

---
 sysdep/linux/netlink.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 71b290fd..27b1a617 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -69,6 +69,10 @@
 #define RTA_ENCAP  22
 #endif
 
+#ifndef NETLINK_GET_STRICT_CHK
+#define NETLINK_GET_STRICT_CHK 12
+#endif
+
 #define krt_ipv4(p) ((p)->af == AF_INET)
 #define krt_ecmp6(p) ((p)->af == AF_INET6)
 
-- 
cgit v1.2.3


From bbc33f6ec310d98b9100fb883a2b8908ede1b5a8 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Sat, 15 Jan 2022 22:39:40 +0100
Subject: Netlink: Add another workaround for older kernel headers

Unfortunately, SOL_NETLINK is both recently added and arch-dependent,
so we cannot just define it.
---
 sysdep/linux/netlink.c | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 27b1a617..ccd62f26 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -164,7 +164,14 @@ nl_open_sock(struct nl_sock *nl)
 static void
 nl_set_strict_dump(struct nl_sock *nl, int strict)
 {
+  /*
+   * Strict checking is not necessary, it improves behavior on newer kernels.
+   * If it is not available (missing SOL_NETLINK compile-time, or ENOPROTOOPT
+   * run-time), we can just ignore it.
+   */
+#ifdef SOL_NETLINK
   setsockopt(nl->fd, SOL_NETLINK, NETLINK_GET_STRICT_CHK, &strict, sizeof(strict));
+#endif
 }
 
 static void
-- 
cgit v1.2.3


From 81ee6cda2e60bbd3d97ab63da30657a54b09feda Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Mon, 17 Jan 2022 05:11:29 +0100
Subject: Netlink: Add option to specify netlink socket receive buffer size

Add option 'netlink rx buffer' to specify netlink socket receive buffer
size. Uses SO_RCVBUFFORCE, so it can override rmem_max limit.

Thanks to Trisha Biswas and Michal for the original patches.
---
 doc/bird.sgml               |    6 +
 sysdep/linux/krt-sys.h      |    1 +
 sysdep/linux/netlink.Y      |    4 +-
 sysdep/linux/netlink.c      |   54 ++
 sysdep/linux/netlink.c.orig | 2179 +++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 2243 insertions(+), 1 deletion(-)
 create mode 100644 sysdep/linux/netlink.c.orig

(limited to 'sysdep/linux')

diff --git a/doc/bird.sgml b/doc/bird.sgml
index 0112622e..f10b15e2 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -3248,6 +3248,12 @@ channels.
 	allows to specify a limit on maximal number of nexthops in one route. By
 	default, multipath merging is disabled. If enabled, default value of the
 	limit is 16.
+
+	<tag><label id="krt-netlink-rx-buffer">netlink rx buffer <m/number/</tag> (Linux)
+	Set kernel receive buffer size (in bytes) for the netlink socket. The default
+	value is OS-dependent (from the <file>/proc/sys/net/core/rmem_default</file>
+	file), If you get some "Kernel dropped some netlink message ..." warnings,
+	you may increase this value.
 </descrip>
 
 <sect1>Attributes
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index a8af4c95..8897f889 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -69,6 +69,7 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i UNUSED) { return N
 struct krt_params {
   u32 table_id;				/* Kernel table ID we sync with */
   u32 metric;				/* Kernel metric used for all routes */
+  uint netlink_rx_buffer;		/* Rx buffer size for the netlink socket */
 };
 
 struct krt_state {
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index 7097f577..487ad1d8 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -10,7 +10,8 @@ CF_HDR
 
 CF_DECLS
 
-CF_KEYWORDS(KERNEL, TABLE, METRIC, KRT_PREFSRC, KRT_REALM, KRT_SCOPE, KRT_MTU, KRT_WINDOW,
+CF_KEYWORDS(KERNEL, TABLE, METRIC, NETLINK, RX, BUFFER,
+	    KRT_PREFSRC, KRT_REALM, KRT_SCOPE, KRT_MTU, KRT_WINDOW,
 	    KRT_RTT, KRT_RTTVAR, KRT_SSTRESH, KRT_CWND, KRT_ADVMSS, KRT_REORDERING,
 	    KRT_HOPLIMIT, KRT_INITCWND, KRT_RTO_MIN, KRT_INITRWND, KRT_QUICKACK,
 	    KRT_LOCK_MTU, KRT_LOCK_WINDOW, KRT_LOCK_RTT, KRT_LOCK_RTTVAR,
@@ -24,6 +25,7 @@ kern_proto: kern_proto kern_sys_item ';' ;
 kern_sys_item:
    KERNEL TABLE expr { THIS_KRT->sys.table_id = $3; }
  | METRIC expr { THIS_KRT->sys.metric = $2; }
+ | NETLINK RX BUFFER expr { THIS_KRT->sys.netlink_rx_buffer = $4; }
  ;
 
 dynamic_attr: KRT_PREFSRC	{ $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_KRT_PREFSRC); } ;
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index ccd62f26..f662301d 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -174,6 +174,27 @@ nl_set_strict_dump(struct nl_sock *nl, int strict)
 #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)
 {
@@ -1976,6 +1997,8 @@ krt_do_scan(struct krt_proto *p UNUSED)	/* CONFIG_ALL_TABLES_AT_ONCE => p is NUL
 
 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 struct config *nl_last_config;	/* For tracking changes to nl_async_bufsize */
 
 static void
 nl_async_msg(struct nlmsghdr *h)
@@ -2111,6 +2134,32 @@ nl_open_async(void)
     bug("Netlink: sk_open failed");
 }
 
+static void
+nl_update_async_bufsize(void)
+{
+  /* No async socket */
+  if (!nl_async_sk)
+    return;
+
+  /* Already reconfigured */
+  if (nl_last_config == config)
+    return;
+
+  /* Update netlink buffer size */
+  uint bufsize = nl_cfg_rx_buffer_size(config);
+  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 = config;
+}
+
 
 /*
  *	Interface to the UNIX krt module
@@ -2139,6 +2188,7 @@ krt_sys_start(struct krt_proto *p)
 
   nl_open();
   nl_open_async();
+  nl_update_async_bufsize();
 
   return 1;
 }
@@ -2146,12 +2196,16 @@ krt_sys_start(struct krt_proto *p)
 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);
 }
 
diff --git a/sysdep/linux/netlink.c.orig b/sysdep/linux/netlink.c.orig
new file mode 100644
index 00000000..7cea5322
--- /dev/null
+++ b/sysdep/linux/netlink.c.orig
@@ -0,0 +1,2179 @@
+/*
+ *	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 <alloca.h>
+#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 "conf/conf.h"
+
+#include <asm/types.h>
+#include <linux/if.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+#ifdef HAVE_MPLS_KERNEL
+#include <linux/lwtunnel.h>
+#endif
+
+#ifndef MSG_TRUNC			/* Hack: Several versions of glibc miss this one :( */
+#define MSG_TRUNC 0x20
+#endif
+
+#ifndef IFA_FLAGS
+#define IFA_FLAGS 8
+#endif
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+#ifndef RTA_TABLE
+#define RTA_TABLE  15
+#endif
+
+#ifndef RTA_VIA
+#define RTA_VIA	 18
+#endif
+
+#ifndef RTA_NEWDST
+#define RTA_NEWDST  19
+#endif
+
+#ifndef RTA_ENCAP_TYPE
+#define RTA_ENCAP_TYPE	21
+#endif
+
+#ifndef RTA_ENCAP
+#define RTA_ENCAP  22
+#endif
+
+#define krt_ipv4(p) ((p)->af == AF_INET)
+#define krt_ecmp6(p) ((p)->af == AF_INET6)
+
+const int rt_default_ecmp = 16;
+
+/*
+ * Structure nl_parse_state keeps state of received route processing. Ideally,
+ * we could just independently parse received Netlink messages and immediately
+ * propagate received routes to the rest of BIRD, but older Linux kernel (before
+ * version 4.11) represents and announces IPv6 ECMP routes not as one route with
+ * multiple next hops (like RTA_MULTIPATH in IPv4 ECMP), but as a sequence of
+ * routes with the same prefix. More recent kernels work as with IPv4.
+ *
+ * Therefore, BIRD keeps currently processed route in nl_parse_state structure
+ * and postpones its propagation until we expect it to be final; i.e., when
+ * non-matching route is received or when the scan ends. When another matching
+ * route is received, it is merged with the already processed route to form an
+ * ECMP route. Note that merging is done only for IPv6 (merge == 1), but the
+ * postponing is done in both cases (for simplicity). All IPv4 routes or IPv6
+ * routes with RTA_MULTIPATH set are just considered non-matching.
+ *
+ * This is ignored for asynchronous notifications (every notification is handled
+ * as a separate route). It is not an issue for our routes, as we ignore such
+ * notifications anyways. But importing alien IPv6 ECMP routes does not work
+ * properly with older kernels.
+ *
+ * Whatever the kernel version is, IPv6 ECMP routes are sent as multiple routes
+ * for the same prefix.
+ */
+
+struct nl_parse_state
+{
+  struct linpool *pool;
+  int scan;
+  int merge;
+
+  net *net;
+  rta *attrs;
+  struct krt_proto *proto;
+  s8 new;
+  s8 krt_src;
+  u8 krt_type;
+  u8 krt_proto;
+  u32 krt_metric;
+
+  u32 rta_flow;		/* Used during parsing */
+};
+
+/*
+ *	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 8192
+
+#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 void
+nl_open(void)
+{
+  nl_open_sock(&nl_scan);
+  nl_open_sock(&nl_req);
+}
+
+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(int af, int cmd)
+{
+  struct {
+    struct nlmsghdr nh;
+    struct rtgenmsg g;
+  } req = {
+    .nh.nlmsg_type = cmd,
+    .nh.nlmsg_len = sizeof(req),
+    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
+    .g.rtgen_family = af
+  };
+  nl_send(&nl_scan, &req.nh);
+}
+
+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 = -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_WIRELESS+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 },
+};
+
+
+#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
+
+
+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 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 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
+    return ipa_from_ip6(rta_get_ip6(a));
+}
+
+#ifdef HAVE_MPLS_KERNEL
+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;
+}
+
+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_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 *nh, int af, ea_list *eattrs)
+{
+  struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
+  eattr *flow = ea_find(eattrs, EA_KRT_REALM);
+
+  for (; nh; nh = nh->next)
+  {
+    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 *
+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 = RTA_DATA(ra);
+  struct nexthop *rv, *first, **last;
+  unsigned len = RTA_PAYLOAD(ra);
+
+  first = NULL;
+  last = &first;
+
+  while (len)
+    {
+      /* 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))
+	goto next;
+
+      *last = rv = lp_allocz(s->pool, NEXTHOP_MAX_SIZE);
+      last = &(rv->next);
+
+      rv->weight = nh->rtnh_hops;
+      rv->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]);
+
+#ifdef HAVE_MPLS_KERNEL
+      if (a[RTA_VIA])
+	rv->gw = rta_get_via(a[RTA_VIA]);
+#endif
+
+      if (ipa_nonzero(rv->gw))
+	{
+	  if (nh->rtnh_flags & RTNH_F_ONLINK)
+	    rv->flags |= RNF_ONLINK;
+
+	  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
+
+    next:
+      len -= NLMSG_ALIGN(nh->rtnh_len);
+      nh = RTNH_NEXT(nh);
+    }
+
+  /* Ensure nexthops are sorted to satisfy nest invariant */
+  if (!nexthop_is_sorted(first))
+    first = nexthop_sort(first);
+
+  return first;
+
+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, 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))
+      nl_add_attr_u32(h, bufsize, t, metrics[t]);
+
+  nl_close_attr(h, a);
+}
+
+static int
+nl_parse_metrics(struct rtattr *hdr, u32 *metrics, 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 == RTA_UNSPEC)
+      continue;
+
+    if (a->rta_type >= max)
+      continue;
+
+    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;
+  char *name;
+  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]);
+
+  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;
+
+      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(AF_UNSPEC, RTM_GETLINK);
+  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 */
+  struct iface *i;
+  WALK_LIST(i, iface_list)
+    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(i->master_index)
+      };
+
+      if (f.master != i->master)
+      {
+	memcpy(f.name, i->name, sizeof(f.name));
+	if_update(&f);
+      }
+    }
+
+  nl_request_dump(AF_INET, RTM_GETADDR);
+  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(AF_INET6, RTM_GETADDR);
+  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, *2, 2, 2, 6, 20
+
+HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
+
+int
+krt_capable(rte *e)
+{
+  rta *a = e->attrs;
+
+  switch (a->dest)
+  {
+    case RTD_UNICAST:
+    case RTD_BLACKHOLE:
+    case RTD_UNREACHABLE:
+    case RTD_PROHIBIT:
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+
+static inline int
+nh_bufsize(struct nexthop *nh)
+{
+  int rv = 0;
+  for (; nh != NULL; nh = nh->next)
+    rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
+  return rv;
+}
+
+static int
+nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
+{
+  eattr *ea;
+  net *net = e->net;
+  rta *a = e->attrs;
+  ea_list *eattrs = a->eattrs;
+  int bufsize = 128 + KRT_METRICS_MAX*8 + nh_bufsize(&(a->nh));
+  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", net->n.addr, 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(net->n.addr);
+  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(net->n.addr);
+    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(net->n.addr));
+
+    /* Add source address for IPv6 SADR routes */
+    if (net->n.addr->type == NET_IP6_SADR)
+    {
+      net_addr_ip6_sadr *a = (void *) &net->n.addr;
+      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 (a->source == RTS_DUMMY)
+    priority = e->u.krt.metric;
+  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 dest;
+
+  /* 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
+    r->r.rtm_scope = (dest == RTD_UNICAST && ipa_zero(nh->gw)) ? RT_SCOPE_LINK : 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];
+  metrics[0] = 0;
+
+  struct ea_walk_state ews = { .eattrs = eattrs };
+  while (ea = ea_walk(&ews, EA_KRT_METRICS, KRT_METRICS_MAX))
+  {
+    int id = ea->id - EA_KRT_METRICS;
+    metrics[0] |= 1 << id;
+    metrics[id] = ea->u.data;
+  }
+
+  if (metrics[0])
+    nl_add_metrics(&r->h, rsize, metrics, KRT_METRICS_MAX);
+
+
+dest:
+  switch (dest)
+    {
+    case RTD_UNICAST:
+      r->r.rtm_type = RTN_UNICAST;
+      if (nh->next && !krt_ecmp6(p))
+	nl_add_multipath(&r->h, rsize, nh, p->af, eattrs);
+      else
+      {
+	nl_add_attr_u32(&r->h, rsize, RTA_OIF, nh->iface->index);
+	nl_add_nexthop(&r->h, rsize, nh, p->af);
+
+	if (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");
+    }
+
+  /* Ignore missing for DELETE */
+  return nl_exchange(&r->h, (op == NL_OP_DELETE));
+}
+
+static inline int
+nl_add_rte(struct krt_proto *p, rte *e)
+{
+  rta *a = e->attrs;
+  int err = 0;
+
+  if (krt_ecmp6(p) && a->nh.next)
+  {
+    struct nexthop *nh = &(a->nh);
+
+    err = nl_send_route(p, e, NL_OP_ADD, RTD_UNICAST, nh);
+    if (err < 0)
+      return err;
+
+    for (nh = nh->next; nh; nh = nh->next)
+      err += nl_send_route(p, e, NL_OP_APPEND, RTD_UNICAST, nh);
+
+    return err;
+  }
+
+  return nl_send_route(p, e, NL_OP_ADD, a->dest, &(a->nh));
+}
+
+static inline int
+nl_delete_rte(struct krt_proto *p, rte *e)
+{
+  int err = 0;
+
+  /* For IPv6, we just repeatedly request DELETE until we get error */
+  do
+    err = nl_send_route(p, e, NL_OP_DELETE, RTD_NONE, NULL);
+  while (krt_ecmp6(p) && !err);
+
+  return err;
+}
+
+static inline int
+nl_replace_rte(struct krt_proto *p, rte *e)
+{
+  rta *a = e->attrs;
+  return nl_send_route(p, e, NL_OP_REPLACE, a->dest, &(a->nh));
+}
+
+
+void
+krt_replace_rte(struct krt_proto *p, net *n UNUSED, rte *new, rte *old)
+{
+  int err = 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.
+   *
+   * We do not use NL_OP_REPLACE for IPv6, as it has broken semantics for ECMP
+   * and with some kernel versions ECMP replace crashes kernel. Would need more
+   * testing and checks for kernel versions.
+   *
+   * For IPv6, we use NL_OP_DELETE and then NL_OP_ADD. We also do not trust the
+   * old route value, so we do not try to optimize IPv6 ECMP reconfigurations.
+   */
+
+  if (krt_ipv4(p) && old && new)
+  {
+    err = nl_replace_rte(p, new);
+  }
+  else
+  {
+    if (old)
+      nl_delete_rte(p, old);
+
+    if (new)
+      err = nl_add_rte(p, new);
+  }
+
+  if (new)
+  {
+    if (err < 0)
+      bmap_clear(&p->sync_map, new->id);
+    else
+      bmap_set(&p->sync_map, new->id);
+  }
+}
+
+static int
+nl_mergable_route(struct nl_parse_state *s, net *net, struct krt_proto *p, uint priority, uint krt_type, uint rtm_family)
+{
+  /* Route merging is used for IPv6 scans */
+  if (!s->scan || (rtm_family != AF_INET6))
+    return 0;
+
+  /* Saved and new route must have same network, proto/table, and priority */
+  if ((s->net != net) || (s->proto != p) || (s->krt_metric != priority))
+    return 0;
+
+  /* Both must be regular unicast routes */
+  if ((s->krt_type != RTN_UNICAST) || (krt_type != RTN_UNICAST))
+    return 0;
+
+  return 1;
+}
+
+static void
+nl_announce_route(struct nl_parse_state *s)
+{
+  rte *e = rte_get_temp(s->attrs);
+  e->net = s->net;
+  e->u.krt.src = s->krt_src;
+  e->u.krt.proto = s->krt_proto;
+  e->u.krt.seen = 0;
+  e->u.krt.best = 0;
+  e->u.krt.metric = s->krt_metric;
+
+  if (s->scan)
+    krt_got_route(s->proto, e);
+  else
+    krt_got_route_async(s->proto, e, s->new);
+
+  s->net = NULL;
+  s->attrs = NULL;
+  s->proto = NULL;
+  lp_flush(s->pool);
+}
+
+static inline void
+nl_parse_begin(struct nl_parse_state *s, int scan)
+{
+  memset(s, 0, sizeof (struct nl_parse_state));
+  s->pool = nl_linpool;
+  s->scan = scan;
+}
+
+static inline void
+nl_parse_end(struct nl_parse_state *s)
+{
+  if (s->net)
+    nl_announce_route(s);
+}
+
+
+#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;
+      return;
+
+    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 *n = &dst;
+  if (p->p.net_type == NET_IP6_SADR)
+  {
+    n = alloca(sizeof(net_addr_ip6_sadr));
+    net_fill_ip6_sadr(n, net6_prefix(&dst), net6_pxlen(&dst),
+		      net6_prefix(&src), net6_pxlen(&src));
+  }
+
+  net *net = net_get(p->p.main_channel->table, n);
+
+  if (s->net && !nl_mergable_route(s, net, p, priority, i->rtm_type, i->rtm_family))
+    nl_announce_route(s);
+
+  rta *ra = lp_allocz(s->pool, RTA_MAX_SIZE);
+  ra->src = p->p.main_source;
+  ra->source = RTS_INHERIT;
+  ra->scope = SCOPE_UNIVERSE;
+
+  if (a[RTA_FLOW])
+    s->rta_flow = rta_get_u32(a[RTA_FLOW]);
+  else
+    s->rta_flow = 0;
+
+  switch (i->rtm_type)
+    {
+    case RTN_UNICAST:
+      ra->dest = RTD_UNICAST;
+
+      if (a[RTA_MULTIPATH])
+        {
+	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
+	  if (!nh)
+	    SKIP("strange RTA_MULTIPATH\n");
+
+	  nexthop_link(ra, nh);
+	  break;
+	}
+
+      if ((i->rtm_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
+	SKIP("ignore RTNH_F_DEAD\n");
+
+      ra->nh.iface = if_find_by_index(oif);
+      if (!ra->nh.iface)
+	{
+	  log(L_ERR "KRT: Received route %N with unknown ifindex %u", net->n.addr, oif);
+	  return;
+	}
+
+      if (a[RTA_GATEWAY])
+	ra->nh.gw = rta_get_ipa(a[RTA_GATEWAY]);
+
+#ifdef HAVE_MPLS_KERNEL
+      if (a[RTA_VIA])
+	ra->nh.gw = rta_get_via(a[RTA_VIA]);
+#endif
+
+      if (ipa_nonzero(ra->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(ra->nh.gw, (net_addr *) &sit))
+	    return;
+
+	  if (i->rtm_flags & RTNH_F_ONLINK)
+	    ra->nh.flags |= RNF_ONLINK;
+
+	  neighbor *nbr;
+	  nbr = neigh_find(&p->p, ra->nh.gw, ra->nh.iface,
+			   (ra->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->n.addr,
+                  ra->nh.gw);
+	      return;
+	    }
+	}
+
+      break;
+    case RTN_BLACKHOLE:
+      ra->dest = RTD_BLACKHOLE;
+      break;
+    case RTN_UNREACHABLE:
+      ra->dest = RTD_UNREACHABLE;
+      break;
+    case RTN_PROHIBIT:
+      ra->dest = RTD_PROHIBIT;
+      break;
+    /* FIXME: What about RTN_THROW? */
+    default:
+      SKIP("type %d\n", i->rtm_type);
+      return;
+    }
+
+#ifdef HAVE_MPLS_KERNEL
+  if ((i->rtm_family == AF_MPLS) && a[RTA_NEWDST] && !ra->nh.next)
+    ra->nh.labels = rta_get_mpls(a[RTA_NEWDST], ra->nh.label);
+
+  if (a[RTA_ENCAP] && a[RTA_ENCAP_TYPE] && !ra->nh.next)
+    {
+      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));
+	      ra->nh.labels = rta_get_mpls(enca[RTA_DST], ra->nh.label);
+	      break;
+	    }
+	  default:
+	    SKIP("unknown encapsulation method %d\n", rta_get_u16(a[RTA_ENCAP_TYPE]));
+	    break;
+	}
+    }
+#endif
+
+  if (i->rtm_scope != def_scope)
+    {
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
+      ea->next = ra->eattrs;
+      ra->eattrs = ea;
+      ea->flags = EALF_SORTED;
+      ea->count = 1;
+      ea->attrs[0].id = EA_KRT_SCOPE;
+      ea->attrs[0].flags = 0;
+      ea->attrs[0].type = EAF_TYPE_INT;
+      ea->attrs[0].u.data = i->rtm_scope;
+    }
+
+  if (a[RTA_PREFSRC])
+    {
+      ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);
+
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
+      ea->next = ra->eattrs;
+      ra->eattrs = ea;
+      ea->flags = EALF_SORTED;
+      ea->count = 1;
+      ea->attrs[0].id = EA_KRT_PREFSRC;
+      ea->attrs[0].flags = 0;
+      ea->attrs[0].type = EAF_TYPE_IP_ADDRESS;
+
+      struct adata *ad = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
+      ad->length = sizeof(ps);
+      memcpy(ad->data, &ps, sizeof(ps));
+
+      ea->attrs[0].u.ptr = ad;
+    }
+
+  /* Can be set per-route or per-nexthop */
+  if (s->rta_flow)
+    {
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
+      ea->next = ra->eattrs;
+      ra->eattrs = ea;
+      ea->flags = EALF_SORTED;
+      ea->count = 1;
+      ea->attrs[0].id = EA_KRT_REALM;
+      ea->attrs[0].flags = 0;
+      ea->attrs[0].type = EAF_TYPE_INT;
+      ea->attrs[0].u.data = s->rta_flow;
+    }
+
+  if (a[RTA_METRICS])
+    {
+      u32 metrics[KRT_METRICS_MAX];
+      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
+      int t, n = 0;
+
+      if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
+        {
+	  log(L_ERR "KRT: Received route %N with strange RTA_METRICS attribute", net->n.addr);
+	  return;
+	}
+
+      for (t = 1; t < KRT_METRICS_MAX; t++)
+	if (metrics[0] & (1 << t))
+	  {
+	    ea->attrs[n].id = EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t);
+	    ea->attrs[n].flags = 0;
+	    ea->attrs[n].type = EAF_TYPE_INT; /* FIXME: Some are EAF_TYPE_BITFIELD */
+	    ea->attrs[n].u.data = metrics[t];
+	    n++;
+	  }
+
+      if (n > 0)
+        {
+	  ea->next = ra->eattrs;
+	  ea->flags = EALF_SORTED;
+	  ea->count = n;
+	  ra->eattrs = ea;
+	}
+    }
+
+  /*
+   * Ideally, now we would send the received route to the rest of kernel code.
+   * But IPv6 ECMP routes before 4.11 are sent as a sequence of routes, so we
+   * postpone it and merge next hops until the end of the sequence. Note that
+   * when doing merging of next hops, we expect the new route to be unipath.
+   * Otherwise, we ignore additional next hops in nexthop_insert().
+   */
+
+  if (!s->net)
+  {
+    /* Store the new route */
+    s->net = net;
+    s->attrs = ra;
+    s->proto = p;
+    s->new = new;
+    s->krt_src = krt_src;
+    s->krt_type = i->rtm_type;
+    s->krt_proto = i->rtm_protocol;
+    s->krt_metric = priority;
+  }
+  else
+  {
+    /* Merge next hops with the stored route */
+    rta *oa = s->attrs;
+
+    struct nexthop *nhs = &oa->nh;
+    nexthop_insert(&nhs, &ra->nh);
+
+    /* Perhaps new nexthop is inserted at the first position */
+    if (nhs == &ra->nh)
+    {
+      /* Swap rtas */
+      s->attrs = ra;
+
+      /* Keep old eattrs */
+      ra->eattrs = oa->eattrs;
+    }
+  }
+}
+
+void
+krt_do_scan(struct krt_proto *p UNUSED)	/* CONFIG_ALL_TABLES_AT_ONCE => p is NULL */
+{
+  struct nlmsghdr *h;
+  struct nl_parse_state s;
+
+  nl_parse_begin(&s, 1);
+  nl_request_dump(AF_UNSPEC, RTM_GETROUTE);
+  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);
+  nl_parse_end(&s);
+}
+
+/*
+ *	Asynchronous Netlink interface
+ */
+
+static sock *nl_async_sk;		/* BIRD socket for asynchronous notifications */
+static byte *nl_async_rx_buffer;	/* Receive buffer */
+
+static void
+nl_async_msg(struct nlmsghdr *h)
+{
+  struct nl_parse_state s;
+
+  switch (h->nlmsg_type)
+    {
+    case RTM_NEWROUTE:
+    case RTM_DELROUTE:
+      DBG("KRT: Received async route notification (%d)\n", h->nlmsg_type);
+      nl_parse_begin(&s, 0);
+      nl_parse_route(&s, h);
+      nl_parse_end(&s);
+      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;
+    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_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) < 0)
+    bug("Netlink: sk_open failed");
+}
+
+
+/*
+ *	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, 6);
+}
+
+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();
+
+  return 1;
+}
+
+void
+krt_sys_shutdown(struct krt_proto *p)
+{
+  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)
+{
+  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;
+}
+
+static const char *krt_metrics_names[KRT_METRICS_MAX] = {
+  NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
+  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
+};
+
+static const char *krt_features_names[KRT_FEATURES_MAX] = {
+  "ecn", NULL, NULL, "allfrag"
+};
+
+int
+krt_sys_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
+{
+  switch (a->id)
+  {
+  case EA_KRT_PREFSRC:
+    bsprintf(buf, "prefsrc");
+    return GA_NAME;
+
+  case EA_KRT_REALM:
+    bsprintf(buf, "realm");
+    return GA_NAME;
+
+  case EA_KRT_SCOPE:
+    bsprintf(buf, "scope");
+    return GA_NAME;
+
+  case EA_KRT_LOCK:
+    buf += bsprintf(buf, "lock:");
+    ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
+    return GA_FULL;
+
+  case EA_KRT_FEATURES:
+    buf += bsprintf(buf, "features:");
+    ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
+    return GA_FULL;
+
+  default:;
+    int id = (int)EA_ID(a->id) - KRT_METRICS_OFFSET;
+    if (id > 0 && id < KRT_METRICS_MAX)
+    {
+      bsprintf(buf, "%s", krt_metrics_names[id]);
+      return GA_NAME;
+    }
+
+    return GA_UNKNOWN;
+  }
+}
+
+
+
+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;
+}
-- 
cgit v1.2.3


From ef614f29843ab2bdfb0ff5ed5da0a989eeaa33a6 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Tue, 8 Feb 2022 22:21:08 +0100
Subject: Netlink: Minor cleanup

---
 sysdep/linux/netlink.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index f662301d..29b744cb 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -162,7 +162,7 @@ nl_open_sock(struct nl_sock *nl)
 }
 
 static void
-nl_set_strict_dump(struct nl_sock *nl, int strict)
+nl_set_strict_dump(struct nl_sock *nl UNUSED, int strict UNUSED)
 {
   /*
    * Strict checking is not necessary, it improves behavior on newer kernels.
-- 
cgit v1.2.3


From 4b1aa37f931888febfd768309d5e2ef36f5e7194 Mon Sep 17 00:00:00 2001
From: "Ondrej Zajicek (work)" <santiago@crfreenet.org>
Date: Wed, 16 Mar 2022 23:16:26 +0100
Subject: Netlink: Remove superfluous sysdep/linux/netlink.c.orig

Thanks to Vincent Bernat for notice.
---
 sysdep/linux/netlink.c.orig | 2179 -------------------------------------------
 1 file changed, 2179 deletions(-)
 delete mode 100644 sysdep/linux/netlink.c.orig

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c.orig b/sysdep/linux/netlink.c.orig
deleted file mode 100644
index 7cea5322..00000000
--- a/sysdep/linux/netlink.c.orig
+++ /dev/null
@@ -1,2179 +0,0 @@
-/*
- *	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 <alloca.h>
-#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 "conf/conf.h"
-
-#include <asm/types.h>
-#include <linux/if.h>
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-
-#ifdef HAVE_MPLS_KERNEL
-#include <linux/lwtunnel.h>
-#endif
-
-#ifndef MSG_TRUNC			/* Hack: Several versions of glibc miss this one :( */
-#define MSG_TRUNC 0x20
-#endif
-
-#ifndef IFA_FLAGS
-#define IFA_FLAGS 8
-#endif
-
-#ifndef IFF_LOWER_UP
-#define IFF_LOWER_UP 0x10000
-#endif
-
-#ifndef RTA_TABLE
-#define RTA_TABLE  15
-#endif
-
-#ifndef RTA_VIA
-#define RTA_VIA	 18
-#endif
-
-#ifndef RTA_NEWDST
-#define RTA_NEWDST  19
-#endif
-
-#ifndef RTA_ENCAP_TYPE
-#define RTA_ENCAP_TYPE	21
-#endif
-
-#ifndef RTA_ENCAP
-#define RTA_ENCAP  22
-#endif
-
-#define krt_ipv4(p) ((p)->af == AF_INET)
-#define krt_ecmp6(p) ((p)->af == AF_INET6)
-
-const int rt_default_ecmp = 16;
-
-/*
- * Structure nl_parse_state keeps state of received route processing. Ideally,
- * we could just independently parse received Netlink messages and immediately
- * propagate received routes to the rest of BIRD, but older Linux kernel (before
- * version 4.11) represents and announces IPv6 ECMP routes not as one route with
- * multiple next hops (like RTA_MULTIPATH in IPv4 ECMP), but as a sequence of
- * routes with the same prefix. More recent kernels work as with IPv4.
- *
- * Therefore, BIRD keeps currently processed route in nl_parse_state structure
- * and postpones its propagation until we expect it to be final; i.e., when
- * non-matching route is received or when the scan ends. When another matching
- * route is received, it is merged with the already processed route to form an
- * ECMP route. Note that merging is done only for IPv6 (merge == 1), but the
- * postponing is done in both cases (for simplicity). All IPv4 routes or IPv6
- * routes with RTA_MULTIPATH set are just considered non-matching.
- *
- * This is ignored for asynchronous notifications (every notification is handled
- * as a separate route). It is not an issue for our routes, as we ignore such
- * notifications anyways. But importing alien IPv6 ECMP routes does not work
- * properly with older kernels.
- *
- * Whatever the kernel version is, IPv6 ECMP routes are sent as multiple routes
- * for the same prefix.
- */
-
-struct nl_parse_state
-{
-  struct linpool *pool;
-  int scan;
-  int merge;
-
-  net *net;
-  rta *attrs;
-  struct krt_proto *proto;
-  s8 new;
-  s8 krt_src;
-  u8 krt_type;
-  u8 krt_proto;
-  u32 krt_metric;
-
-  u32 rta_flow;		/* Used during parsing */
-};
-
-/*
- *	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 8192
-
-#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 void
-nl_open(void)
-{
-  nl_open_sock(&nl_scan);
-  nl_open_sock(&nl_req);
-}
-
-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(int af, int cmd)
-{
-  struct {
-    struct nlmsghdr nh;
-    struct rtgenmsg g;
-  } req = {
-    .nh.nlmsg_type = cmd,
-    .nh.nlmsg_len = sizeof(req),
-    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
-    .g.rtgen_family = af
-  };
-  nl_send(&nl_scan, &req.nh);
-}
-
-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 = -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_WIRELESS+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 },
-};
-
-
-#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
-
-
-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 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 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
-    return ipa_from_ip6(rta_get_ip6(a));
-}
-
-#ifdef HAVE_MPLS_KERNEL
-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;
-}
-
-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_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 *nh, int af, ea_list *eattrs)
-{
-  struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
-  eattr *flow = ea_find(eattrs, EA_KRT_REALM);
-
-  for (; nh; nh = nh->next)
-  {
-    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 *
-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 = RTA_DATA(ra);
-  struct nexthop *rv, *first, **last;
-  unsigned len = RTA_PAYLOAD(ra);
-
-  first = NULL;
-  last = &first;
-
-  while (len)
-    {
-      /* 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))
-	goto next;
-
-      *last = rv = lp_allocz(s->pool, NEXTHOP_MAX_SIZE);
-      last = &(rv->next);
-
-      rv->weight = nh->rtnh_hops;
-      rv->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]);
-
-#ifdef HAVE_MPLS_KERNEL
-      if (a[RTA_VIA])
-	rv->gw = rta_get_via(a[RTA_VIA]);
-#endif
-
-      if (ipa_nonzero(rv->gw))
-	{
-	  if (nh->rtnh_flags & RTNH_F_ONLINK)
-	    rv->flags |= RNF_ONLINK;
-
-	  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
-
-    next:
-      len -= NLMSG_ALIGN(nh->rtnh_len);
-      nh = RTNH_NEXT(nh);
-    }
-
-  /* Ensure nexthops are sorted to satisfy nest invariant */
-  if (!nexthop_is_sorted(first))
-    first = nexthop_sort(first);
-
-  return first;
-
-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, 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))
-      nl_add_attr_u32(h, bufsize, t, metrics[t]);
-
-  nl_close_attr(h, a);
-}
-
-static int
-nl_parse_metrics(struct rtattr *hdr, u32 *metrics, 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 == RTA_UNSPEC)
-      continue;
-
-    if (a->rta_type >= max)
-      continue;
-
-    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;
-  char *name;
-  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]);
-
-  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;
-
-      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(AF_UNSPEC, RTM_GETLINK);
-  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 */
-  struct iface *i;
-  WALK_LIST(i, iface_list)
-    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(i->master_index)
-      };
-
-      if (f.master != i->master)
-      {
-	memcpy(f.name, i->name, sizeof(f.name));
-	if_update(&f);
-      }
-    }
-
-  nl_request_dump(AF_INET, RTM_GETADDR);
-  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(AF_INET6, RTM_GETADDR);
-  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, *2, 2, 2, 6, 20
-
-HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
-
-int
-krt_capable(rte *e)
-{
-  rta *a = e->attrs;
-
-  switch (a->dest)
-  {
-    case RTD_UNICAST:
-    case RTD_BLACKHOLE:
-    case RTD_UNREACHABLE:
-    case RTD_PROHIBIT:
-      return 1;
-
-    default:
-      return 0;
-  }
-}
-
-static inline int
-nh_bufsize(struct nexthop *nh)
-{
-  int rv = 0;
-  for (; nh != NULL; nh = nh->next)
-    rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
-  return rv;
-}
-
-static int
-nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
-{
-  eattr *ea;
-  net *net = e->net;
-  rta *a = e->attrs;
-  ea_list *eattrs = a->eattrs;
-  int bufsize = 128 + KRT_METRICS_MAX*8 + nh_bufsize(&(a->nh));
-  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", net->n.addr, 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(net->n.addr);
-  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(net->n.addr);
-    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(net->n.addr));
-
-    /* Add source address for IPv6 SADR routes */
-    if (net->n.addr->type == NET_IP6_SADR)
-    {
-      net_addr_ip6_sadr *a = (void *) &net->n.addr;
-      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 (a->source == RTS_DUMMY)
-    priority = e->u.krt.metric;
-  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 dest;
-
-  /* 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
-    r->r.rtm_scope = (dest == RTD_UNICAST && ipa_zero(nh->gw)) ? RT_SCOPE_LINK : 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];
-  metrics[0] = 0;
-
-  struct ea_walk_state ews = { .eattrs = eattrs };
-  while (ea = ea_walk(&ews, EA_KRT_METRICS, KRT_METRICS_MAX))
-  {
-    int id = ea->id - EA_KRT_METRICS;
-    metrics[0] |= 1 << id;
-    metrics[id] = ea->u.data;
-  }
-
-  if (metrics[0])
-    nl_add_metrics(&r->h, rsize, metrics, KRT_METRICS_MAX);
-
-
-dest:
-  switch (dest)
-    {
-    case RTD_UNICAST:
-      r->r.rtm_type = RTN_UNICAST;
-      if (nh->next && !krt_ecmp6(p))
-	nl_add_multipath(&r->h, rsize, nh, p->af, eattrs);
-      else
-      {
-	nl_add_attr_u32(&r->h, rsize, RTA_OIF, nh->iface->index);
-	nl_add_nexthop(&r->h, rsize, nh, p->af);
-
-	if (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");
-    }
-
-  /* Ignore missing for DELETE */
-  return nl_exchange(&r->h, (op == NL_OP_DELETE));
-}
-
-static inline int
-nl_add_rte(struct krt_proto *p, rte *e)
-{
-  rta *a = e->attrs;
-  int err = 0;
-
-  if (krt_ecmp6(p) && a->nh.next)
-  {
-    struct nexthop *nh = &(a->nh);
-
-    err = nl_send_route(p, e, NL_OP_ADD, RTD_UNICAST, nh);
-    if (err < 0)
-      return err;
-
-    for (nh = nh->next; nh; nh = nh->next)
-      err += nl_send_route(p, e, NL_OP_APPEND, RTD_UNICAST, nh);
-
-    return err;
-  }
-
-  return nl_send_route(p, e, NL_OP_ADD, a->dest, &(a->nh));
-}
-
-static inline int
-nl_delete_rte(struct krt_proto *p, rte *e)
-{
-  int err = 0;
-
-  /* For IPv6, we just repeatedly request DELETE until we get error */
-  do
-    err = nl_send_route(p, e, NL_OP_DELETE, RTD_NONE, NULL);
-  while (krt_ecmp6(p) && !err);
-
-  return err;
-}
-
-static inline int
-nl_replace_rte(struct krt_proto *p, rte *e)
-{
-  rta *a = e->attrs;
-  return nl_send_route(p, e, NL_OP_REPLACE, a->dest, &(a->nh));
-}
-
-
-void
-krt_replace_rte(struct krt_proto *p, net *n UNUSED, rte *new, rte *old)
-{
-  int err = 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.
-   *
-   * We do not use NL_OP_REPLACE for IPv6, as it has broken semantics for ECMP
-   * and with some kernel versions ECMP replace crashes kernel. Would need more
-   * testing and checks for kernel versions.
-   *
-   * For IPv6, we use NL_OP_DELETE and then NL_OP_ADD. We also do not trust the
-   * old route value, so we do not try to optimize IPv6 ECMP reconfigurations.
-   */
-
-  if (krt_ipv4(p) && old && new)
-  {
-    err = nl_replace_rte(p, new);
-  }
-  else
-  {
-    if (old)
-      nl_delete_rte(p, old);
-
-    if (new)
-      err = nl_add_rte(p, new);
-  }
-
-  if (new)
-  {
-    if (err < 0)
-      bmap_clear(&p->sync_map, new->id);
-    else
-      bmap_set(&p->sync_map, new->id);
-  }
-}
-
-static int
-nl_mergable_route(struct nl_parse_state *s, net *net, struct krt_proto *p, uint priority, uint krt_type, uint rtm_family)
-{
-  /* Route merging is used for IPv6 scans */
-  if (!s->scan || (rtm_family != AF_INET6))
-    return 0;
-
-  /* Saved and new route must have same network, proto/table, and priority */
-  if ((s->net != net) || (s->proto != p) || (s->krt_metric != priority))
-    return 0;
-
-  /* Both must be regular unicast routes */
-  if ((s->krt_type != RTN_UNICAST) || (krt_type != RTN_UNICAST))
-    return 0;
-
-  return 1;
-}
-
-static void
-nl_announce_route(struct nl_parse_state *s)
-{
-  rte *e = rte_get_temp(s->attrs);
-  e->net = s->net;
-  e->u.krt.src = s->krt_src;
-  e->u.krt.proto = s->krt_proto;
-  e->u.krt.seen = 0;
-  e->u.krt.best = 0;
-  e->u.krt.metric = s->krt_metric;
-
-  if (s->scan)
-    krt_got_route(s->proto, e);
-  else
-    krt_got_route_async(s->proto, e, s->new);
-
-  s->net = NULL;
-  s->attrs = NULL;
-  s->proto = NULL;
-  lp_flush(s->pool);
-}
-
-static inline void
-nl_parse_begin(struct nl_parse_state *s, int scan)
-{
-  memset(s, 0, sizeof (struct nl_parse_state));
-  s->pool = nl_linpool;
-  s->scan = scan;
-}
-
-static inline void
-nl_parse_end(struct nl_parse_state *s)
-{
-  if (s->net)
-    nl_announce_route(s);
-}
-
-
-#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;
-      return;
-
-    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 *n = &dst;
-  if (p->p.net_type == NET_IP6_SADR)
-  {
-    n = alloca(sizeof(net_addr_ip6_sadr));
-    net_fill_ip6_sadr(n, net6_prefix(&dst), net6_pxlen(&dst),
-		      net6_prefix(&src), net6_pxlen(&src));
-  }
-
-  net *net = net_get(p->p.main_channel->table, n);
-
-  if (s->net && !nl_mergable_route(s, net, p, priority, i->rtm_type, i->rtm_family))
-    nl_announce_route(s);
-
-  rta *ra = lp_allocz(s->pool, RTA_MAX_SIZE);
-  ra->src = p->p.main_source;
-  ra->source = RTS_INHERIT;
-  ra->scope = SCOPE_UNIVERSE;
-
-  if (a[RTA_FLOW])
-    s->rta_flow = rta_get_u32(a[RTA_FLOW]);
-  else
-    s->rta_flow = 0;
-
-  switch (i->rtm_type)
-    {
-    case RTN_UNICAST:
-      ra->dest = RTD_UNICAST;
-
-      if (a[RTA_MULTIPATH])
-        {
-	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
-	  if (!nh)
-	    SKIP("strange RTA_MULTIPATH\n");
-
-	  nexthop_link(ra, nh);
-	  break;
-	}
-
-      if ((i->rtm_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
-	SKIP("ignore RTNH_F_DEAD\n");
-
-      ra->nh.iface = if_find_by_index(oif);
-      if (!ra->nh.iface)
-	{
-	  log(L_ERR "KRT: Received route %N with unknown ifindex %u", net->n.addr, oif);
-	  return;
-	}
-
-      if (a[RTA_GATEWAY])
-	ra->nh.gw = rta_get_ipa(a[RTA_GATEWAY]);
-
-#ifdef HAVE_MPLS_KERNEL
-      if (a[RTA_VIA])
-	ra->nh.gw = rta_get_via(a[RTA_VIA]);
-#endif
-
-      if (ipa_nonzero(ra->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(ra->nh.gw, (net_addr *) &sit))
-	    return;
-
-	  if (i->rtm_flags & RTNH_F_ONLINK)
-	    ra->nh.flags |= RNF_ONLINK;
-
-	  neighbor *nbr;
-	  nbr = neigh_find(&p->p, ra->nh.gw, ra->nh.iface,
-			   (ra->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->n.addr,
-                  ra->nh.gw);
-	      return;
-	    }
-	}
-
-      break;
-    case RTN_BLACKHOLE:
-      ra->dest = RTD_BLACKHOLE;
-      break;
-    case RTN_UNREACHABLE:
-      ra->dest = RTD_UNREACHABLE;
-      break;
-    case RTN_PROHIBIT:
-      ra->dest = RTD_PROHIBIT;
-      break;
-    /* FIXME: What about RTN_THROW? */
-    default:
-      SKIP("type %d\n", i->rtm_type);
-      return;
-    }
-
-#ifdef HAVE_MPLS_KERNEL
-  if ((i->rtm_family == AF_MPLS) && a[RTA_NEWDST] && !ra->nh.next)
-    ra->nh.labels = rta_get_mpls(a[RTA_NEWDST], ra->nh.label);
-
-  if (a[RTA_ENCAP] && a[RTA_ENCAP_TYPE] && !ra->nh.next)
-    {
-      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));
-	      ra->nh.labels = rta_get_mpls(enca[RTA_DST], ra->nh.label);
-	      break;
-	    }
-	  default:
-	    SKIP("unknown encapsulation method %d\n", rta_get_u16(a[RTA_ENCAP_TYPE]));
-	    break;
-	}
-    }
-#endif
-
-  if (i->rtm_scope != def_scope)
-    {
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_SCOPE;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_INT;
-      ea->attrs[0].u.data = i->rtm_scope;
-    }
-
-  if (a[RTA_PREFSRC])
-    {
-      ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);
-
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_PREFSRC;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_IP_ADDRESS;
-
-      struct adata *ad = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
-      ad->length = sizeof(ps);
-      memcpy(ad->data, &ps, sizeof(ps));
-
-      ea->attrs[0].u.ptr = ad;
-    }
-
-  /* Can be set per-route or per-nexthop */
-  if (s->rta_flow)
-    {
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_REALM;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_INT;
-      ea->attrs[0].u.data = s->rta_flow;
-    }
-
-  if (a[RTA_METRICS])
-    {
-      u32 metrics[KRT_METRICS_MAX];
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
-      int t, n = 0;
-
-      if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
-        {
-	  log(L_ERR "KRT: Received route %N with strange RTA_METRICS attribute", net->n.addr);
-	  return;
-	}
-
-      for (t = 1; t < KRT_METRICS_MAX; t++)
-	if (metrics[0] & (1 << t))
-	  {
-	    ea->attrs[n].id = EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t);
-	    ea->attrs[n].flags = 0;
-	    ea->attrs[n].type = EAF_TYPE_INT; /* FIXME: Some are EAF_TYPE_BITFIELD */
-	    ea->attrs[n].u.data = metrics[t];
-	    n++;
-	  }
-
-      if (n > 0)
-        {
-	  ea->next = ra->eattrs;
-	  ea->flags = EALF_SORTED;
-	  ea->count = n;
-	  ra->eattrs = ea;
-	}
-    }
-
-  /*
-   * Ideally, now we would send the received route to the rest of kernel code.
-   * But IPv6 ECMP routes before 4.11 are sent as a sequence of routes, so we
-   * postpone it and merge next hops until the end of the sequence. Note that
-   * when doing merging of next hops, we expect the new route to be unipath.
-   * Otherwise, we ignore additional next hops in nexthop_insert().
-   */
-
-  if (!s->net)
-  {
-    /* Store the new route */
-    s->net = net;
-    s->attrs = ra;
-    s->proto = p;
-    s->new = new;
-    s->krt_src = krt_src;
-    s->krt_type = i->rtm_type;
-    s->krt_proto = i->rtm_protocol;
-    s->krt_metric = priority;
-  }
-  else
-  {
-    /* Merge next hops with the stored route */
-    rta *oa = s->attrs;
-
-    struct nexthop *nhs = &oa->nh;
-    nexthop_insert(&nhs, &ra->nh);
-
-    /* Perhaps new nexthop is inserted at the first position */
-    if (nhs == &ra->nh)
-    {
-      /* Swap rtas */
-      s->attrs = ra;
-
-      /* Keep old eattrs */
-      ra->eattrs = oa->eattrs;
-    }
-  }
-}
-
-void
-krt_do_scan(struct krt_proto *p UNUSED)	/* CONFIG_ALL_TABLES_AT_ONCE => p is NULL */
-{
-  struct nlmsghdr *h;
-  struct nl_parse_state s;
-
-  nl_parse_begin(&s, 1);
-  nl_request_dump(AF_UNSPEC, RTM_GETROUTE);
-  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);
-  nl_parse_end(&s);
-}
-
-/*
- *	Asynchronous Netlink interface
- */
-
-static sock *nl_async_sk;		/* BIRD socket for asynchronous notifications */
-static byte *nl_async_rx_buffer;	/* Receive buffer */
-
-static void
-nl_async_msg(struct nlmsghdr *h)
-{
-  struct nl_parse_state s;
-
-  switch (h->nlmsg_type)
-    {
-    case RTM_NEWROUTE:
-    case RTM_DELROUTE:
-      DBG("KRT: Received async route notification (%d)\n", h->nlmsg_type);
-      nl_parse_begin(&s, 0);
-      nl_parse_route(&s, h);
-      nl_parse_end(&s);
-      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;
-    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_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) < 0)
-    bug("Netlink: sk_open failed");
-}
-
-
-/*
- *	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, 6);
-}
-
-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();
-
-  return 1;
-}
-
-void
-krt_sys_shutdown(struct krt_proto *p)
-{
-  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)
-{
-  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;
-}
-
-static const char *krt_metrics_names[KRT_METRICS_MAX] = {
-  NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
-  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
-};
-
-static const char *krt_features_names[KRT_FEATURES_MAX] = {
-  "ecn", NULL, NULL, "allfrag"
-};
-
-int
-krt_sys_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
-{
-  switch (a->id)
-  {
-  case EA_KRT_PREFSRC:
-    bsprintf(buf, "prefsrc");
-    return GA_NAME;
-
-  case EA_KRT_REALM:
-    bsprintf(buf, "realm");
-    return GA_NAME;
-
-  case EA_KRT_SCOPE:
-    bsprintf(buf, "scope");
-    return GA_NAME;
-
-  case EA_KRT_LOCK:
-    buf += bsprintf(buf, "lock:");
-    ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
-    return GA_FULL;
-
-  case EA_KRT_FEATURES:
-    buf += bsprintf(buf, "features:");
-    ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
-    return GA_FULL;
-
-  default:;
-    int id = (int)EA_ID(a->id) - KRT_METRICS_OFFSET;
-    if (id > 0 && id < KRT_METRICS_MAX)
-    {
-      bsprintf(buf, "%s", krt_metrics_names[id]);
-      return GA_NAME;
-    }
-
-    return GA_UNKNOWN;
-  }
-}
-
-
-
-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;
-}
-- 
cgit v1.2.3


From bc17fee1bfdbd330f5a4377bf40f6de0681afa5c Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Fri, 25 Mar 2022 19:51:35 +0100
Subject: Filter: Bitfield eattrs reading / writing moved to filter code

Before this change, fetch-update-write and bitmasking was hardcoded in
attribute access code cased by the attribute type. Several filter
instructions are used to do it instead.

As this is certainly going to be a little bit slower than before, the
switch block in attribute access code should be completely removed in
near future, helping with both performance and code cleanliness.

The user interface should have stayed intact.
---
 filter/config.Y        | 14 +++++++++++++-
 filter/f-inst.c        | 16 ----------------
 filter/f-inst.h        |  4 ++--
 filter/test.conf       |  4 ++++
 nest/route.h           |  1 -
 nest/rt-attr.c         |  3 ---
 sysdep/linux/netlink.Y | 24 ++++++++++++------------
 sysdep/linux/netlink.c |  2 +-
 8 files changed, 32 insertions(+), 36 deletions(-)

(limited to 'sysdep/linux')

diff --git a/filter/config.Y b/filter/config.Y
index dabe4781..67bd04b4 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -308,7 +308,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 
 %type <xp> cmds_int cmd_prep
 %type <x> term block cmd cmds constant constructor print_list var_list function_call symbol_value bgp_path_expr bgp_path bgp_path_tail
-%type <fda> dynamic_attr
+%type <fda> dynamic_attr attr_bit
 %type <fsa> static_attr
 %type <f> filter where_filter
 %type <fl> filter_body function_body
@@ -802,6 +802,10 @@ term:
  | static_attr { $$ = f_new_inst(FI_RTA_GET, $1); }
 
  | dynamic_attr { $$ = f_new_inst(FI_EA_GET, $1); }
+ | attr_bit {
+    struct f_inst *c = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = (1U << $1.bit)});
+    $$ = f_new_inst(FI_EQ, c, f_new_inst(FI_BITAND, f_new_inst(FI_EA_GET, $1), c));
+  }
 
  | term '.' IS_V4 { $$ = f_new_inst(FI_IS_V4, $1); }
  | term '.' TYPE { $$ = f_new_inst(FI_TYPE, $1); }
@@ -899,6 +903,14 @@ cmd:
  | UNSET '(' dynamic_attr ')' ';' {
      $$ = f_new_inst(FI_EA_UNSET, $3);
    }
+ | attr_bit '=' term ';' {
+     $$ = f_new_inst(FI_CONDITION, $3,
+	f_generate_complex(FI_BITOR, $1,
+	      f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = (1U << $1.bit)})),
+	f_generate_complex(FI_BITAND, $1,
+	      f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = ~(1U << $1.bit)}))
+     );
+   }
  | break_command print_list ';' {
     struct f_inst *breaker = f_new_inst(FI_DIE, $1);
     if ($2) {
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 0050c237..8bfec479 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -712,9 +712,6 @@
       case EAF_TYPE_AS_PATH:
 	RESULT_(T_PATH, ad, e->u.ptr);
 	break;
-      case EAF_TYPE_BITFIELD:
-	RESULT_(T_BOOL, i, !!(e->u.data & (1u << da.bit)));
-	break;
       case EAF_TYPE_INT_SET:
 	RESULT_(T_CLIST, ad, e->u.ptr);
 	break;
@@ -774,19 +771,6 @@
 	l->attrs[0].u.ptr = v1.val.ad;
 	break;
 
-      case EAF_TYPE_BITFIELD:
-	{
-	  /* First, we have to find the old value */
-	  eattr *e = ea_find(*fs->eattrs, da.ea_code);
-	  u32 data = e ? e->u.data : 0;
-
-	  if (v1.val.i)
-	    l->attrs[0].u.data = data | (1u << da.bit);
-	  else
-	    l->attrs[0].u.data = data & ~(1u << da.bit);
-	}
-	break;
-
       default:
 	bug("Unknown dynamic attribute type");
       }
diff --git a/filter/f-inst.h b/filter/f-inst.h
index df45f88e..9265ecec 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -89,8 +89,8 @@ void f_add_lines(const struct f_line_item *what, struct filter_iterator *fit);
 struct filter *f_new_where(struct f_inst *);
 static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, enum f_type f_type, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
 { return (struct f_dynamic_attr) { .type = type, .f_type = f_type, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */
-static inline struct f_dynamic_attr f_new_dynamic_attr_bit(u8 bit, enum f_type f_type, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
-{ return (struct f_dynamic_attr) { .type = EAF_TYPE_BITFIELD, .bit = bit, .f_type = f_type, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */
+static inline struct f_dynamic_attr f_new_dynamic_attr_bit(u8 bit, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
+{ return (struct f_dynamic_attr) { .type = EAF_TYPE_INT, .bit = bit, .f_type = T_INT, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */
 static inline struct f_static_attr f_new_static_attr(int f_type, int code, int readonly)
 { return (struct f_static_attr) { .f_type = f_type, .sa_code = code, .readonly = readonly }; }
 struct f_inst *f_generate_complex(enum f_instruction_code fi_code, struct f_dynamic_attr da, struct f_inst *argument);
diff --git a/filter/test.conf b/filter/test.conf
index 1058d34e..ee2f5be4 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -1342,6 +1342,10 @@ int j;
 	rip_metric = 14;
 	unset(rip_metric);
 
+#	krt_lock_mtu = false;
+#	krt_lock_window = true;
+#	krt_lock_rtt = krt_lock_rttvar && krt_lock_sstresh || krt_lock_cwnd;
+
 	accept "ok I take that";
 }
 
diff --git a/nest/route.h b/nest/route.h
index 80c53ba6..a4af0edc 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -536,7 +536,6 @@ const char *ea_custom_name(uint ea);
 #define EAF_TYPE_IP_ADDRESS 0x04	/* IP address */
 #define EAF_TYPE_ROUTER_ID 0x05		/* Router ID (IPv4 address) */
 #define EAF_TYPE_AS_PATH 0x06		/* BGP AS path (encoding per RFC 1771:4.3) */
-#define EAF_TYPE_BITFIELD 0x09		/* 32-bit embedded bitfield */
 #define EAF_TYPE_INT_SET 0x0a		/* Set of u32's (e.g., a community list) */
 #define EAF_TYPE_EC_SET 0x0e		/* Set of pairs of u32's - ext. community list */
 #define EAF_TYPE_LC_SET 0x12		/* Set of triplets of u32's - large community list */
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 22b45db9..abda5d82 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -965,9 +965,6 @@ ea_show(struct cli *c, const eattr *e)
 	case EAF_TYPE_AS_PATH:
 	  as_path_format(ad, pos, end - pos);
 	  break;
-	case EAF_TYPE_BITFIELD:
-	  bsprintf(pos, "%08x", e->u.data);
-	  break;
 	case EAF_TYPE_INT_SET:
 	  ea_show_int_set(c, ad, 1, pos, buf, end);
 	  return;
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index 487ad1d8..7390be73 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -48,19 +48,19 @@ dynamic_attr: KRT_QUICKACK	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT
 
 /* Bits of EA_KRT_LOCK, based on RTAX_* constants */
 
-dynamic_attr: KRT_LOCK_MTU	{ $$ = f_new_dynamic_attr_bit(2, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_WINDOW	{ $$ = f_new_dynamic_attr_bit(3, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_RTT	{ $$ = f_new_dynamic_attr_bit(4, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_RTTVAR	{ $$ = f_new_dynamic_attr_bit(5, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_SSTRESH	{ $$ = f_new_dynamic_attr_bit(6, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_CWND	{ $$ = f_new_dynamic_attr_bit(7, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_ADVMSS	{ $$ = f_new_dynamic_attr_bit(8, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_REORDERING { $$ = f_new_dynamic_attr_bit(9, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_HOPLIMIT { $$ = f_new_dynamic_attr_bit(10, T_BOOL, EA_KRT_LOCK); } ;
-dynamic_attr: KRT_LOCK_RTO_MIN { $$ = f_new_dynamic_attr_bit(13, T_BOOL, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_MTU	{ $$ = f_new_dynamic_attr_bit(2, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_WINDOW	{ $$ = f_new_dynamic_attr_bit(3, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_RTT	{ $$ = f_new_dynamic_attr_bit(4, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_RTTVAR	{ $$ = f_new_dynamic_attr_bit(5, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_SSTRESH	{ $$ = f_new_dynamic_attr_bit(6, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_CWND	{ $$ = f_new_dynamic_attr_bit(7, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_ADVMSS	{ $$ = f_new_dynamic_attr_bit(8, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_REORDERING { $$ = f_new_dynamic_attr_bit(9, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_HOPLIMIT { $$ = f_new_dynamic_attr_bit(10, EA_KRT_LOCK); } ;
+attr_bit: KRT_LOCK_RTO_MIN { $$ = f_new_dynamic_attr_bit(13, EA_KRT_LOCK); } ;
 
-dynamic_attr: KRT_FEATURE_ECN	{ $$ = f_new_dynamic_attr_bit(0, T_BOOL, EA_KRT_FEATURES); } ;
-dynamic_attr: KRT_FEATURE_ALLFRAG { $$ = f_new_dynamic_attr(3, T_BOOL, EA_KRT_FEATURES); } ;
+attr_bit: KRT_FEATURE_ECN	{ $$ = f_new_dynamic_attr_bit(0, EA_KRT_FEATURES); } ;
+attr_bit: KRT_FEATURE_ALLFRAG { $$ = f_new_dynamic_attr_bit(3, EA_KRT_FEATURES); } ;
 
 
 CF_CODE
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index e103c8ef..6c8228fd 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1928,7 +1928,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	  {
 	    ea->attrs[n].id = EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t);
 	    ea->attrs[n].flags = 0;
-	    ea->attrs[n].type = EAF_TYPE_INT; /* FIXME: Some are EAF_TYPE_BITFIELD */
+	    ea->attrs[n].type = EAF_TYPE_INT;
 	    ea->attrs[n].u.data = metrics[t];
 	    n++;
 	  }
-- 
cgit v1.2.3


From 0d0f6554a5c233bf2bf830ae319191c4b1808d49 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Sat, 26 Mar 2022 11:56:02 +0100
Subject: Unified attribute and filter types

This commit removes the EAF_TYPE_* namespace completely and also for
route attributes, filter-based types T_* are used. This simplifies
fetching and setting route attributes from filters.

Also, there is now union bval which serves as an universal value holder
instead of private unions held separately by eattr and filter code.
---
 filter/config.Y             |   25 +-
 filter/data.c               |   20 +-
 filter/data.h               |   84 +-
 filter/decl.m4              |    4 +-
 filter/f-inst.c             |  128 +--
 filter/f-inst.h             |   12 +-
 filter/f-util.c             |   27 +-
 filter/filter.h             |    2 +-
 filter/test.conf            |    6 +-
 lib/type.h                  |   87 ++
 nest/config.Y               |    2 +-
 nest/route.h                |   47 +-
 nest/rt-attr.c              |   23 +-
 proto/babel/babel.c         |    6 +-
 proto/babel/config.Y        |    2 +-
 proto/bgp/attrs.c           |   40 +-
 proto/bgp/bgp.h             |   16 +-
 proto/bgp/config.Y          |   26 +-
 proto/ospf/config.Y         |    8 +-
 proto/ospf/rt.c             |    8 +-
 proto/radv/config.Y         |    4 +-
 proto/rip/config.Y          |    4 +-
 proto/rip/rip.c             |    6 +-
 sysdep/bsd/krt-sock.c       |    2 +-
 sysdep/linux/netlink.Y      |   32 +-
 sysdep/linux/netlink.c      |   12 +-
 sysdep/linux/netlink.c.orig | 2179 -------------------------------------------
 sysdep/unix/krt.Y           |    4 +-
 28 files changed, 299 insertions(+), 2517 deletions(-)
 create mode 100644 lib/type.h
 delete mode 100644 sysdep/linux/netlink.c.orig

(limited to 'sysdep/linux')

diff --git a/filter/config.Y b/filter/config.Y
index fb331c16..22981945 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -163,26 +163,11 @@ f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
 static inline struct f_inst *
 f_generate_empty(struct f_dynamic_attr dyn)
 {
-  struct f_val empty;
+  const struct f_val *empty = f_get_empty(dyn.type);
+  if (!empty)
+    cf_error("Can't empty that attribute");
 
-  switch (dyn.type) {
-    case EAF_TYPE_AS_PATH:
-      empty = f_const_empty_path;
-      break;
-    case EAF_TYPE_INT_SET:
-      empty = f_const_empty_clist;
-      break;
-    case EAF_TYPE_EC_SET:
-      empty = f_const_empty_eclist;
-      break;
-    case EAF_TYPE_LC_SET:
-      empty = f_const_empty_lclist;
-      break;
-    default:
-      cf_error("Can't empty that attribute");
-  }
-
-  return f_new_inst(FI_EA_SET, f_new_inst(FI_CONSTANT, empty), dyn);
+  return f_new_inst(FI_EA_SET, f_new_inst(FI_CONSTANT, *empty), dyn);
 }
 
 #define BA_AS_PATH 0x02
@@ -190,7 +175,7 @@ f_generate_empty(struct f_dynamic_attr dyn)
 static inline struct f_inst *
 f_implicit_roa_check(struct rtable_config *tab)
 {
-  struct f_dynamic_attr fda = f_new_dynamic_attr(EAF_TYPE_AS_PATH, T_PATH, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+  struct f_dynamic_attr fda = f_new_dynamic_attr(T_PATH, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
 
   struct f_static_attr fsa = f_new_static_attr(T_NET, SA_NET, 1);
 
diff --git a/filter/data.c b/filter/data.c
index 56c1fb17..c3f8bf57 100644
--- a/filter/data.c
+++ b/filter/data.c
@@ -27,6 +27,8 @@
 
 static const char * const f_type_str[] = {
   [T_VOID]	= "void",
+  [T_OPAQUE]	= "opaque byte string",
+  [T_IFACE]	= "interface",
 
   [T_INT]	= "int",
   [T_BOOL]	= "bool",
@@ -47,6 +49,7 @@ static const char * const f_type_str[] = {
   [T_NET]	= "prefix",
   [T_STRING]	= "string",
   [T_PATH_MASK]	= "bgpmask",
+  [T_PATH_MASK_ITEM] = "bgpmask item",
   [T_PATH]	= "bgppath",
   [T_CLIST]	= "clist",
   [T_EC]	= "ec",
@@ -54,22 +57,19 @@ static const char * const f_type_str[] = {
   [T_LC]	= "lc",
   [T_LCLIST]	= "lclist",
   [T_RD]	= "rd",
+
+  [T_SET]	= "set",
+  [T_PREFIX_SET] = "prefix set",
 };
 
 const char *
-f_type_name(enum f_type t)
+f_type_name(btype t)
 {
-  if (t < ARRAY_SIZE(f_type_str))
-    return f_type_str[t] ?: "?";
-
-  if ((t == T_SET) || (t == T_PREFIX_SET))
-    return "set";
-
-  return "?";
+  return (t < ARRAY_SIZE(f_type_str)) ? (f_type_str[t] ?: "?") : "?";
 }
 
-enum f_type
-f_type_element_type(enum f_type t)
+btype
+f_type_element_type(btype t)
 {
   switch(t) {
     case T_CLIST:  return T_PAIR;
diff --git a/filter/data.h b/filter/data.h
index 924bbf3e..0b1e8e57 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -11,65 +11,15 @@
 #define _BIRD_FILTER_DATA_H_
 
 #include "nest/bird.h"
-
-/* Type numbers must be in 0..0xff range */
-#define T_MASK 0xff
-
-/* Internal types */
-enum f_type {
-/* Nothing. Simply nothing. */
-  T_VOID = 0,
-
-/* Something but inaccessible. */
-  T_OPAQUE = 0xee,
-
-/* User visible types, which fit in int */
-  T_INT = 0x10,
-  T_BOOL = 0x11,
-  T_PAIR = 0x12,  /*	Notice that pair is stored as integer: first << 16 | second */
-  T_QUAD = 0x13,
-
-/* Put enumerational types in 0x30..0x3f range */
-  T_ENUM_LO = 0x30,
-  T_ENUM_HI = 0x3f,
-
-  T_ENUM_RTS = 0x30,
-  T_ENUM_BGP_ORIGIN = 0x31,
-  T_ENUM_SCOPE = 0x32,
-  T_ENUM_RTC = 0x33,
-  T_ENUM_RTD = 0x34,
-  T_ENUM_ROA = 0x35,
-  T_ENUM_NETTYPE = 0x36,
-  T_ENUM_RA_PREFERENCE = 0x37,
-  T_ENUM_AF = 0x38,
-
-/* new enums go here */
-
-#define T_ENUM T_ENUM_LO ... T_ENUM_HI
-
-/* Bigger ones */
-  T_IP = 0x20,
-  T_NET = 0x21,
-  T_STRING = 0x22,
-  T_PATH_MASK = 0x23,	/* mask for BGP path */
-  T_PATH = 0x24,		/* BGP path */
-  T_CLIST = 0x25,		/* Community list */
-  T_EC = 0x26,		/* Extended community value, u64 */
-  T_ECLIST = 0x27,		/* Extended community list */
-  T_LC = 0x28,		/* Large community value, lcomm */
-  T_LCLIST = 0x29,		/* Large community list */
-  T_RD = 0x2a,		/* Route distinguisher for VPN addresses */
-  T_PATH_MASK_ITEM = 0x2b,	/* Path mask item for path mask constructors */
-
-  T_SET = 0x80,
-  T_PREFIX_SET = 0x81,
-} PACKED;
+#include "lib/type.h"
 
 /* Filter value; size of this affects filter memory consumption */
 struct f_val {
-  enum f_type type;	/* T_*  */
+  btype type;	/* T_*  */
   union {
-    uint i;
+    union bval bval;
+    BVAL_ITEMS;
+
     u64 ec;
     lcomm lc;
     ip_addr ip;
@@ -77,17 +27,17 @@ struct f_val {
     const char *s;
     const struct f_tree *t;
     const struct f_trie *ti;
-    const struct adata *ad;
     const struct f_path_mask *path_mask;
     struct f_path_mask_item pmi;
   } val;
 };
 
+#define fputip(a)   ({ ip_addr *ax = falloc(sizeof(*ax)); *ax = (a); ax; })
+
 /* Dynamic attribute definition (eattrs) */
 struct f_dynamic_attr {
-  u8 type;		/* EA type (EAF_*) */
+  btype type;		/* EA type (EAF_*) */
   u8 bit;		/* For bitfield accessors */
-  enum f_type f_type;	/* Filter type */
   uint ea_code;		/* EA code */
 };
 
@@ -108,9 +58,9 @@ enum f_sa_code {
 
 /* Static attribute definition (members of struct rta) */
 struct f_static_attr {
-  enum f_type f_type;		/* Filter type */
+  btype type;			/* Data type */
   enum f_sa_code sa_code;	/* Static attribute id */
-  int readonly:1;			/* Don't allow writing */
+  int readonly:1;		/* Don't allow writing */
 };
 
 /* Filter l-value type */
@@ -266,9 +216,9 @@ trie_match_next_longest_ip6(net_addr_ip6 *n, ip6_addr *found)
 
 #define F_CMP_ERROR 999
 
-const char *f_type_name(enum f_type t);
+const char *f_type_name(btype t);
 
-enum f_type f_type_element_type(enum f_type t);
+enum btype f_type_element_type(btype t);
 
 int val_same(const struct f_val *v1, const struct f_val *v2);
 int val_compare(const struct f_val *v1, const struct f_val *v2);
@@ -301,6 +251,16 @@ undef_value(struct f_val v)
 }
 
 extern const struct f_val f_const_empty_path, f_const_empty_clist, f_const_empty_eclist, f_const_empty_lclist;
+static inline const struct f_val *f_get_empty(btype t)
+{
+  switch (t) {
+    case T_PATH:	return &f_const_empty_path;
+    case T_CLIST:	return &f_const_empty_clist;
+    case T_ECLIST:	return &f_const_empty_eclist;
+    case T_LCLIST:	return &f_const_empty_lclist;
+    default:		return NULL;
+  }
+}
 
 enum filter_return f_eval(const struct f_line *expr, struct linpool *tmp_pool, struct f_val *pres);
 
diff --git a/filter/decl.m4 b/filter/decl.m4
index 44537aaa..2e4fb235 100644
--- a/filter/decl.m4
+++ b/filter/decl.m4
@@ -490,7 +490,7 @@ fi_constant(struct f_inst *what, struct f_val val)
 }
 
 static int
-f_const_promotion(struct f_inst *arg, enum f_type want)
+f_const_promotion(struct f_inst *arg, btype want)
 {
   if (arg->fi_code != FI_CONSTANT)
     return 0;
@@ -640,7 +640,7 @@ FID_WR_PUT(4)m4_dnl
 struct f_inst {
   struct f_inst *next;			/* Next instruction */
   enum f_instruction_code fi_code;	/* Instruction code */
-  enum f_type type;			/* Type of returned value, if known */
+  btype type;				/* Type of returned value, if known */
   int size;				/* How many instructions are underneath */
   int lineno;				/* Line number */
   union {
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 75a53499..e0bad833 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -533,21 +533,21 @@
 
       switch (sa.sa_code)
       {
-      case SA_FROM:	RESULT(sa.f_type, ip, rta->from); break;
-      case SA_GW:	RESULT(sa.f_type, ip, rta->nh.gw); break;
-      case SA_NET:	RESULT(sa.f_type, net, (*fs->rte)->net->n.addr); break;
-      case SA_PROTO:	RESULT(sa.f_type, s, (*fs->rte)->src->proto->name); break;
-      case SA_SOURCE:	RESULT(sa.f_type, i, rta->source); break;
-      case SA_SCOPE:	RESULT(sa.f_type, i, rta->scope); break;
-      case SA_DEST:	RESULT(sa.f_type, i, rta->dest); break;
-      case SA_IFNAME:	RESULT(sa.f_type, s, rta->nh.iface ? rta->nh.iface->name : ""); break;
-      case SA_IFINDEX:	RESULT(sa.f_type, i, rta->nh.iface ? rta->nh.iface->index : 0); break;
-      case SA_WEIGHT:	RESULT(sa.f_type, i, rta->nh.weight + 1); break;
-      case SA_PREF:	RESULT(sa.f_type, i, rta->pref); break;
-      case SA_GW_MPLS:	RESULT(sa.f_type, i, rta->nh.labels ? rta->nh.label[0] : MPLS_NULL); break;
+      case SA_FROM:	RESULT(sa.type, ip, rta->from); break;
+      case SA_GW:	RESULT(sa.type, ip, rta->nh.gw); break;
+      case SA_NET:	RESULT(sa.type, net, (*fs->rte)->net->n.addr); break;
+      case SA_PROTO:	RESULT(sa.type, s, (*fs->rte)->src->proto->name); break;
+      case SA_SOURCE:	RESULT(sa.type, i, rta->source); break;
+      case SA_SCOPE:	RESULT(sa.type, i, rta->scope); break;
+      case SA_DEST:	RESULT(sa.type, i, rta->dest); break;
+      case SA_IFNAME:	RESULT(sa.type, s, rta->nh.iface ? rta->nh.iface->name : ""); break;
+      case SA_IFINDEX:	RESULT(sa.type, i, rta->nh.iface ? rta->nh.iface->index : 0); break;
+      case SA_WEIGHT:	RESULT(sa.type, i, rta->nh.weight + 1); break;
+      case SA_PREF:	RESULT(sa.type, i, rta->pref); break;
+      case SA_GW_MPLS:	RESULT(sa.type, i, rta->nh.labels ? rta->nh.label[0] : MPLS_NULL); break;
 
       default:
-	bug("Invalid static attribute access (%u/%u)", sa.f_type, sa.sa_code);
+	bug("Invalid static attribute access (%u/%u)", sa.type, sa.sa_code);
       }
     }
   }
@@ -556,7 +556,7 @@
     ACCESS_RTE;
     ARG_ANY(1);
     STATIC_ATTR;
-    ARG_TYPE(1, sa.f_type);
+    ARG_TYPE(1, sa.type);
 
     f_rta_cow(fs);
     {
@@ -653,7 +653,7 @@
 	break;
 
       default:
-	bug("Invalid static attribute access (%u/%u)", sa.f_type, sa.sa_code);
+	bug("Invalid static attribute access (%u/%u)", sa.type, sa.sa_code);
       }
     }
   }
@@ -662,68 +662,30 @@
     DYNAMIC_ATTR;
     ACCESS_RTE;
     ACCESS_EATTRS;
-    RESULT_TYPE(da.f_type);
+    RESULT_TYPE(da.type);
     {
+      const struct f_val *empty;
       eattr *e = ea_find(*fs->eattrs, da.ea_code);
 
-      if (!e) {
-	/* A special case: undefined as_path looks like empty as_path */
-	if (da.type == EAF_TYPE_AS_PATH) {
-	  RESULT_(T_PATH, ad, &null_adata);
-	  break;
-	}
-
-	/* The same special case for int_set */
-	if (da.type == EAF_TYPE_INT_SET) {
-	  RESULT_(T_CLIST, ad, &null_adata);
-	  break;
-	}
-
-	/* The same special case for ec_set */
-	if (da.type == EAF_TYPE_EC_SET) {
-	  RESULT_(T_ECLIST, ad, &null_adata);
-	  break;
-	}
+      if (e)
+      {
+	ASSERT_DIE(e->type == da.type);
 
-	/* The same special case for lc_set */
-	if (da.type == EAF_TYPE_LC_SET) {
-	  RESULT_(T_LCLIST, ad, &null_adata);
-	  break;
+	switch (e->type) {
+	  case T_IP:
+	    RESULT_(T_IP, ip, *((const ip_addr *) e->u.ptr->data));
+	    break;
+	  default:
+	    RESULT_VAL([[(struct f_val) {
+		.type = e->type,
+		.val.bval = e->u,
+		}]]);
 	}
-
-	/* Undefined value */
-	RESULT_VOID;
-	break;
-      }
-
-      switch (e->type) {
-      case EAF_TYPE_INT:
-	RESULT_(da.f_type, i, e->u.data);
-	break;
-      case EAF_TYPE_ROUTER_ID:
-	RESULT_(T_QUAD, i, e->u.data);
-	break;
-      case EAF_TYPE_OPAQUE:
-	RESULT_(T_OPAQUE, ad, e->u.ptr);
-	break;
-      case EAF_TYPE_IP_ADDRESS:
-	RESULT_(T_IP, ip, *((ip_addr *) e->u.ptr->data));
-	break;
-      case EAF_TYPE_AS_PATH:
-	RESULT_(T_PATH, ad, e->u.ptr);
-	break;
-      case EAF_TYPE_INT_SET:
-	RESULT_(T_CLIST, ad, e->u.ptr);
-	break;
-      case EAF_TYPE_EC_SET:
-	RESULT_(T_ECLIST, ad, e->u.ptr);
-	break;
-      case EAF_TYPE_LC_SET:
-	RESULT_(T_LCLIST, ad, e->u.ptr);
-	break;
-      default:
-	bug("Unknown dynamic attribute type");
       }
+      else if (empty = f_get_empty(da.type))
+	RESULT_VAL(*empty);
+      else
+	RESULT_VOID;
     }
   }
 
@@ -732,7 +694,7 @@
     ACCESS_EATTRS;
     ARG_ANY(1);
     DYNAMIC_ATTR;
-    ARG_TYPE(1, da.f_type);
+    ARG_TYPE(1, da.type);
     {
       struct ea_list *l = lp_alloc(fs->pool, sizeof(struct ea_list) + sizeof(eattr));
 
@@ -746,17 +708,16 @@
       l->attrs[0].fresh = 1;
       l->attrs[0].undef = 0;
 
-      switch (da.type) {
-      case EAF_TYPE_INT:
-      case EAF_TYPE_ROUTER_ID:
-	l->attrs[0].u.data = v1.val.i;
-	break;
+      if (da.type >= EAF_TYPE__MAX)
+	bug("Unsupported attribute type");
 
-      case EAF_TYPE_OPAQUE:
+      switch (da.type) {
+      case T_OPAQUE:
+      case T_IFACE:
 	runtime( "Setting opaque attribute is not allowed" );
 	break;
 
-      case EAF_TYPE_IP_ADDRESS:;
+      case T_IP:;
 	int len = sizeof(ip_addr);
 	struct adata *ad = lp_alloc(fs->pool, sizeof(struct adata) + len);
 	ad->length = len;
@@ -764,15 +725,10 @@
 	l->attrs[0].u.ptr = ad;
 	break;
 
-      case EAF_TYPE_AS_PATH:
-      case EAF_TYPE_INT_SET:
-      case EAF_TYPE_EC_SET:
-      case EAF_TYPE_LC_SET:
-	l->attrs[0].u.ptr = v1.val.ad;
+      default:
+	l->attrs[0].u = v1.val.bval;
 	break;
 
-      default:
-	bug("Unknown dynamic attribute type");
       }
 
       f_rta_cow(fs);
diff --git a/filter/f-inst.h b/filter/f-inst.h
index 9265ecec..32da4653 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -87,12 +87,12 @@ void f_add_lines(const struct f_line_item *what, struct filter_iterator *fit);
 
 
 struct filter *f_new_where(struct f_inst *);
-static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, enum f_type f_type, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
-{ return (struct f_dynamic_attr) { .type = type, .f_type = f_type, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */
-static inline struct f_dynamic_attr f_new_dynamic_attr_bit(u8 bit, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
-{ return (struct f_dynamic_attr) { .type = EAF_TYPE_INT, .bit = bit, .f_type = T_INT, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */
-static inline struct f_static_attr f_new_static_attr(int f_type, int code, int readonly)
-{ return (struct f_static_attr) { .f_type = f_type, .sa_code = code, .readonly = readonly }; }
+static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, uint code)
+{ return (struct f_dynamic_attr) { .type = type, .ea_code = code }; }
+static inline struct f_dynamic_attr f_new_dynamic_attr_bit(u8 bit, uint code)
+{ return (struct f_dynamic_attr) { .type = T_INT, .bit = bit, .ea_code = code }; }
+static inline struct f_static_attr f_new_static_attr(btype type, int code, int readonly)
+{ return (struct f_static_attr) { .type = type, .sa_code = code, .readonly = readonly }; }
 struct f_inst *f_generate_complex(enum f_instruction_code fi_code, struct f_dynamic_attr da, struct f_inst *argument);
 struct f_inst *f_generate_roa_check(struct rtable_config *table, struct f_inst *prefix, struct f_inst *asn);
 
diff --git a/filter/f-util.c b/filter/f-util.c
index 410999a6..79cf3452 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -82,8 +82,8 @@ static void
 ca_dump(resource *r)
 {
   struct custom_attribute *ca = (void *) r;
-  debug("name \"%s\" id 0x%04x ea_type 0x%02x f_type 0x%02x\n",
-      ca->name, ca->fda->ea_code, ca->fda->type, ca->fda->f_type);
+  debug("name \"%s\" id 0x%04x ea_type 0x%02x\n",
+      ca->name, ca->fda->ea_code, ca->fda->type);
 }
 
 static struct resclass ca_class = {
@@ -96,31 +96,16 @@ static struct resclass ca_class = {
 };
 
 struct custom_attribute *
-ca_lookup(pool *p, const char *name, int f_type)
+ca_lookup(pool *p, const char *name, btype type)
 {
-  int ea_type;
-
-  switch (f_type) {
+  switch (type) {
     case T_INT:
-      ea_type = EAF_TYPE_INT;
-      break;
     case T_IP:
-      ea_type = EAF_TYPE_IP_ADDRESS;
-      break;
     case T_QUAD:
-      ea_type = EAF_TYPE_ROUTER_ID;
-      break;
     case T_PATH:
-      ea_type = EAF_TYPE_AS_PATH;
-      break;
     case T_CLIST:
-      ea_type = EAF_TYPE_INT_SET;
-      break;
     case T_ECLIST:
-      ea_type = EAF_TYPE_EC_SET;
-      break;
     case T_LCLIST:
-      ea_type = EAF_TYPE_LC_SET;
       break;
     default:
       cf_error("Custom route attribute of unsupported type");
@@ -137,7 +122,7 @@ ca_lookup(pool *p, const char *name, int f_type)
     inited++;
   }
 
-  struct ca_storage *cas = HASH_FIND(ca_hash, CA, name, ea_type);
+  struct ca_storage *cas = HASH_FIND(ca_hash, CA, name, type);
   if (cas) {
     cas->uc++;
   } else {
@@ -153,7 +138,7 @@ ca_lookup(pool *p, const char *name, int f_type)
     }
 
     cas = mb_allocz(&root_pool, sizeof(struct ca_storage) + strlen(name) + 1);
-    cas->fda = f_new_dynamic_attr(ea_type, f_type, EA_CUSTOM(id));
+    cas->fda = f_new_dynamic_attr(type, EA_CUSTOM(id));
     cas->uc = 1;
 
     strcpy(cas->name, name);
diff --git a/filter/filter.h b/filter/filter.h
index 26c1037b..e9c9d917 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -77,6 +77,6 @@ struct custom_attribute {
   const char *name;
 };
 
-struct custom_attribute *ca_lookup(pool *p, const char *name, int ea_type);
+struct custom_attribute *ca_lookup(pool *p, const char *name, btype type);
 
 #endif
diff --git a/filter/test.conf b/filter/test.conf
index ee2f5be4..062756b1 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -406,9 +406,9 @@ bt_test_suite(t_ip_set, "Testing sets of ip address");
 
 function t_enum()
 {
-	bt_assert(format(RTS_STATIC) = "(enum 30)1");
-	bt_assert(format(NET_IP4) = "(enum 36)1");
-	bt_assert(format(NET_VPN6) = "(enum 36)4");
+	bt_assert(format(RTS_STATIC) = "(enum 31)1");
+	bt_assert(format(NET_IP4) = "(enum 3b)1");
+	bt_assert(format(NET_VPN6) = "(enum 3b)4");
 
 	bt_assert(RTS_STATIC ~ [RTS_STATIC, RTS_DEVICE]);
 	bt_assert(RTS_BGP !~ [RTS_STATIC, RTS_DEVICE]);
diff --git a/lib/type.h b/lib/type.h
new file mode 100644
index 00000000..d0a887d8
--- /dev/null
+++ b/lib/type.h
@@ -0,0 +1,87 @@
+/*
+ *     BIRD Internet Routing Daemon -- Internal Data Types
+ *
+ *     (c) 2022 Maria Matejka <mq@jmq.cz>
+ *
+ *     Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_TYPE_H_
+#define _BIRD_TYPE_H_
+
+#include "lib/birdlib.h"
+
+union bval {
+#define BVAL_ITEMS	\
+  u32 data;			/* Integer type inherited from eattrs */		\
+  u32 i;			/* Integer type inherited from filters */		\
+  const struct adata *ptr;	/* Generic attribute data inherited from eattrs */	\
+  const struct adata *ad;     	/* Generic attribute data inherited from filters */	\
+
+  BVAL_ITEMS
+};
+
+/* Internal types */
+enum btype {
+/* Nothing. Simply nothing. */
+  T_VOID = 0,
+
+/* Something but inaccessible. */
+  T_OPAQUE = 0x02,		/* Opaque byte string (not filterable) */
+  T_IFACE = 0x0c,		/* Pointer to an interface (inside adata) */
+
+/* Types shared with eattrs */
+  T_INT = 0x01,			/* 32-bit unsigned integer number */
+  T_IP = 0x04,			/* IP address */
+  T_QUAD = 0x05,		/* Router ID (IPv4 address) */
+  T_PATH = 0x06,		/* BGP AS path (encoding per RFC 1771:4.3) */
+  T_CLIST = 0x0a,		/* Set of u32's (e.g., a community list) */
+  T_ECLIST = 0x0e,		/* Set of pairs of u32's - ext. community list */
+  T_LCLIST = 0x08,		/* Set of triplets of u32's - large community list */
+
+  T_ENUM_BGP_ORIGIN = 0x11,	/* BGP Origin enum */
+  T_ENUM_RA_PREFERENCE = 0x13,	/* RA Preference enum */
+
+#define EAF_TYPE__MAX 0x1f
+#define EAF_EMBEDDED 0x01		/* Data stored in eattr.u.data (part of type spec) */
+					/* Otherwise, attribute data is adata */
+
+/* Other user visible types which fit in int */
+  T_BOOL = 0xa0,
+  T_PAIR = 0xa4,  /*	Notice that pair is stored as integer: first << 16 | second */
+
+/* Put enumerational types in 0x20..0x3f range */
+  T_ENUM_LO = 0x10,
+  T_ENUM_HI = 0x3f,
+
+  T_ENUM_RTS = 0x31,
+  T_ENUM_SCOPE = 0x33,
+  T_ENUM_RTC = 0x35,
+  T_ENUM_RTD = 0x37,
+  T_ENUM_ROA = 0x39,
+  T_ENUM_NETTYPE = 0x3b,
+  T_ENUM_AF = 0x3d,
+
+/* new enums go here */
+
+#define T_ENUM T_ENUM_LO ... T_ENUM_HI
+
+/* Bigger ones */
+  T_NET = 0xb0,
+  T_STRING = 0xb4,
+  T_PATH_MASK = 0xb8,	/* mask for BGP path */
+  T_EC = 0xbc,		/* Extended community value, u64 */
+  T_LC = 0xc0,		/* Large community value, lcomm */
+  T_RD = 0xc4,		/* Route distinguisher for VPN addresses */
+  T_PATH_MASK_ITEM = 0xc8,	/* Path mask item for path mask constructors */
+
+  T_SET = 0x80,
+  T_PREFIX_SET = 0x84,
+} PACKED;
+
+typedef enum btype btype;
+
+STATIC_ASSERT(sizeof(btype) == sizeof(byte));
+
+
+#endif
diff --git a/nest/config.Y b/nest/config.Y
index 92a80589..b597b332 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -921,7 +921,7 @@ proto_patt2:
  | TEXT { $$.ptr = $1; $$.patt = 1; }
  ;
 
-dynamic_attr: IGP_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_GEN_IGP_METRIC); } ;
+dynamic_attr: IGP_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_GEN_IGP_METRIC); } ;
 
 
 CF_CODE
diff --git a/nest/route.h b/nest/route.h
index d2f60f41..da8c723f 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -13,6 +13,7 @@
 #include "lib/bitmap.h"
 #include "lib/resource.h"
 #include "lib/net.h"
+#include "lib/type.h"
 
 struct ea_list;
 struct protocol;
@@ -506,10 +507,8 @@ typedef struct eattr {
   byte originated:1;			/* The attribute has originated locally */
   byte fresh:1;				/* An uncached attribute (e.g. modified in export filter) */
   byte undef:1;				/* Explicitly undefined */
-  union {
-    uintptr_t data;
-    const struct adata *ptr;		/* Attribute data elsewhere */
-  } u;
+
+  union bval u;
 } eattr;
 
 
@@ -530,22 +529,6 @@ const char *ea_custom_name(uint ea);
 #define EA_BIT(n) ((n) << 24)		/* Used in bitfield accessors */
 #define EA_BIT_GET(ea) ((ea) >> 24)
 
-#define EAF_TYPE_MASK 0x1f		/* Mask with this to get type */
-#define EAF_TYPE_INT 0x01		/* 32-bit unsigned integer number */
-#define EAF_TYPE_OPAQUE 0x02		/* Opaque byte string (not filterable) */
-#define EAF_TYPE_IP_ADDRESS 0x04	/* IP address */
-#define EAF_TYPE_ROUTER_ID 0x05		/* Router ID (IPv4 address) */
-#define EAF_TYPE_AS_PATH 0x06		/* BGP AS path (encoding per RFC 1771:4.3) */
-#define EAF_TYPE_INT_SET 0x0a		/* Set of u32's (e.g., a community list) */
-#define EAF_TYPE_EC_SET 0x0e		/* Set of pairs of u32's - ext. community list */
-#define EAF_TYPE_LC_SET 0x08		/* Set of triplets of u32's - large community list */
-#define EAF_TYPE_IFACE 0x0c		/* Interface pointer stored in adata */
-#define EAF_TYPE_BGP_ORIGIN 0x11	/* BGP Origin enum */
-#define EAF_TYPE_RA_PREFERENCE 0x13	/* RA Preference enum */
-
-#define EAF_EMBEDDED 0x01		/* Data stored in eattr.u.data (part of type spec) */
-					/* Otherwise, attribute data is adata */
-
 typedef struct adata {
   uint length;				/* Length of data */
   byte data[0];
@@ -591,7 +574,7 @@ struct ea_walk_state {
 
 eattr *ea_find(ea_list *, unsigned ea);
 eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
-uintptr_t ea_get_int(ea_list *, unsigned ea, uintptr_t def);
+u32 ea_get_int(ea_list *, unsigned ea, u32 def);
 void ea_dump(ea_list *);
 void ea_sort(ea_list *);		/* Sort entries in all sub-lists */
 unsigned ea_scan(ea_list *);		/* How many bytes do we need for merged ea_list */
@@ -618,7 +601,7 @@ struct ea_one_attr_list {
 };
 
 static inline eattr *
-ea_set_attr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, uintptr_t val)
+ea_set_attr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, union bval val)
 {
   struct ea_one_attr_list *ea = lp_alloc(pool, sizeof(*ea));
   *ea = (struct ea_one_attr_list) {
@@ -631,11 +614,7 @@ ea_set_attr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type,
     .a.flags = flags,
   };
 
-  if (type & EAF_EMBEDDED)
-    ea->a.u.data = val;
-  else
-    ea->a.u.ptr = (struct adata *) val;
-
+  ea->a.u = val;
   *to = &ea->l;
 
   return &ea->a;
@@ -659,19 +638,19 @@ ea_unset_attr(ea_list **to, struct linpool *pool, _Bool local, uint code)
 }
 
 static inline void
-ea_set_attr_u32(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, u32 val)
-{ ea_set_attr(to, pool, id, flags, type, (uintptr_t) val); }
-
-static inline void
-ea_set_attr_ptr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, struct adata *val)
-{ ea_set_attr(to, pool, id, flags, type, (uintptr_t) val); }
+ea_set_attr_u32(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, u32 data)
+{
+  union bval bv = { .data = data };
+  ea_set_attr(to, pool, id, flags, type, bv);
+}
 
 static inline void
 ea_set_attr_data(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, void *data, uint len)
 {
   struct adata *a = lp_alloc_adata(pool, len);
   memcpy(a->data, data, len);
-  ea_set_attr(to, pool, id, flags, type, (uintptr_t) a);
+  union bval bv = { .ptr = a, };
+  ea_set_attr(to, pool, id, flags, type, bv);
 }
 
 
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 25548dca..de45dfa1 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -539,8 +539,8 @@ ea_walk(struct ea_walk_state *s, uint id, uint max)
  * by calling ea_find() to find the attribute, extracting its value or returning
  * a provided default if no such attribute is present.
  */
-uintptr_t
-ea_get_int(ea_list *e, unsigned id, uintptr_t def)
+u32
+ea_get_int(ea_list *e, unsigned id, u32 def)
 {
   eattr *a = ea_find(e, id);
   if (!a)
@@ -950,30 +950,33 @@ ea_show(struct cli *c, const eattr *e)
       else
       switch (e->type)
 	{
-	case EAF_TYPE_INT:
+	case T_INT:
 	  bsprintf(pos, "%u", e->u.data);
 	  break;
-	case EAF_TYPE_OPAQUE:
+	case T_OPAQUE:
 	  opaque_format(ad, pos, end - pos);
 	  break;
-	case EAF_TYPE_IP_ADDRESS:
+	case T_IP:
 	  bsprintf(pos, "%I", *(ip_addr *) ad->data);
 	  break;
-	case EAF_TYPE_ROUTER_ID:
+	case T_QUAD:
 	  bsprintf(pos, "%R", e->u.data);
 	  break;
-	case EAF_TYPE_AS_PATH:
+	case T_PATH:
 	  as_path_format(ad, pos, end - pos);
 	  break;
-	case EAF_TYPE_INT_SET:
+	case T_CLIST:
 	  ea_show_int_set(c, ad, 1, pos, buf, end);
 	  return;
-	case EAF_TYPE_EC_SET:
+	case T_ECLIST:
 	  ea_show_ec_set(c, ad, pos, buf, end);
 	  return;
-	case EAF_TYPE_LC_SET:
+	case T_LCLIST:
 	  ea_show_lc_set(c, ad, pos, buf, end);
 	  return;
+	case T_IFACE:
+	  bsprintf(pos, "%s", ((struct iface *) e->u.ptr)->name);
+	  return;
 	default:
 	  bsprintf(pos, "<type %02x>", e->type);
 	}
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 8040345f..a6cc7aa3 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -654,7 +654,7 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
     *a0.eattrs = (ea_list) { .count = 3 };
     a0.eattrs->attrs[0] = (eattr) {
       .id = EA_BABEL_METRIC,
-      .type = EAF_TYPE_INT,
+      .type = T_INT,
       .u.data = r->metric,
     };
 
@@ -663,13 +663,13 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
     memcpy(ad->data, &(r->router_id), sizeof(u64));
     a0.eattrs->attrs[1] = (eattr) {
       .id = EA_BABEL_ROUTER_ID,
-      .type = EAF_TYPE_OPAQUE,
+      .type = T_OPAQUE,
       .u.ptr = ad,
     };
 
     a0.eattrs->attrs[2] = (eattr) {
       .id = EA_BABEL_SEQNO,
-      .type = EAF_TYPE_INT,
+      .type = T_INT,
       .u.data = r->seqno,
     };
 
diff --git a/proto/babel/config.Y b/proto/babel/config.Y
index 05210fa4..fa745993 100644
--- a/proto/babel/config.Y
+++ b/proto/babel/config.Y
@@ -163,7 +163,7 @@ babel_iface_opt_list:
 babel_iface:
   babel_iface_start iface_patt_list_nopx babel_iface_opt_list babel_iface_finish;
 
-dynamic_attr: BABEL_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_BABEL_METRIC); } ;
+dynamic_attr: BABEL_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_BABEL_METRIC); } ;
 
 CF_CLI_HELP(SHOW BABEL, ..., [[Show information about Babel protocol]]);
 
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index b514f1b9..1bae942d 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -80,7 +80,7 @@ static const struct bgp_attr_desc bgp_attr_table[];
 static inline int bgp_attr_known(uint code);
 
 eattr *
-bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val)
+bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, union bval val)
 {
   ASSERT(bgp_attr_known(code));
 
@@ -976,7 +976,7 @@ static inline void
 bgp_decode_unknown(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to)
 {
   /* Cannot use bgp_set_attr_data() as it works on known attributes only */
-  ea_set_attr_data(to, s->pool, EA_CODE(PROTOCOL_BGP, code), flags, EAF_TYPE_OPAQUE, data, len);
+  ea_set_attr_data(to, s->pool, EA_CODE(PROTOCOL_BGP, code), flags, T_OPAQUE, data, len);
 }
 
 
@@ -987,7 +987,7 @@ bgp_decode_unknown(struct bgp_parse_state *s, uint code, uint flags, byte *data,
 static const struct bgp_attr_desc bgp_attr_table[] = {
   [BA_ORIGIN] = {
     .name = "origin",
-    .type = EAF_TYPE_BGP_ORIGIN,
+    .type = T_ENUM_BGP_ORIGIN,
     .flags = BAF_TRANSITIVE,
     .export = bgp_export_origin,
     .encode = bgp_encode_u8,
@@ -996,14 +996,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_AS_PATH] = {
     .name = "as_path",
-    .type = EAF_TYPE_AS_PATH,
+    .type = T_PATH,
     .flags = BAF_TRANSITIVE,
     .encode = bgp_encode_as_path,
     .decode = bgp_decode_as_path,
   },
   [BA_NEXT_HOP] = {
     .name = "next_hop",
-    .type = EAF_TYPE_IP_ADDRESS,
+    .type = T_IP,
     .flags = BAF_TRANSITIVE,
     .encode = bgp_encode_next_hop,
     .decode = bgp_decode_next_hop,
@@ -1011,14 +1011,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_MULTI_EXIT_DISC] = {
     .name = "med",
-    .type = EAF_TYPE_INT,
+    .type = T_INT,
     .flags = BAF_OPTIONAL,
     .encode = bgp_encode_u32,
     .decode = bgp_decode_med,
   },
   [BA_LOCAL_PREF] = {
     .name = "local_pref",
-    .type = EAF_TYPE_INT,
+    .type = T_INT,
     .flags = BAF_TRANSITIVE,
     .export = bgp_export_local_pref,
     .encode = bgp_encode_u32,
@@ -1026,14 +1026,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_ATOMIC_AGGR] = {
     .name = "atomic_aggr",
-    .type = EAF_TYPE_OPAQUE,
+    .type = T_OPAQUE,
     .flags = BAF_TRANSITIVE,
     .encode = bgp_encode_raw,
     .decode = bgp_decode_atomic_aggr,
   },
   [BA_AGGREGATOR] = {
     .name = "aggregator",
-    .type = EAF_TYPE_OPAQUE,
+    .type = T_OPAQUE,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .encode = bgp_encode_aggregator,
     .decode = bgp_decode_aggregator,
@@ -1041,7 +1041,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_COMMUNITY] = {
     .name = "community",
-    .type = EAF_TYPE_INT_SET,
+    .type = T_CLIST,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .export = bgp_export_community,
     .encode = bgp_encode_u32s,
@@ -1049,7 +1049,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_ORIGINATOR_ID] = {
     .name = "originator_id",
-    .type = EAF_TYPE_ROUTER_ID,
+    .type = T_QUAD,
     .flags = BAF_OPTIONAL,
     .export = bgp_export_originator_id,
     .encode = bgp_encode_u32,
@@ -1057,7 +1057,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_CLUSTER_LIST] = {
     .name = "cluster_list",
-    .type = EAF_TYPE_INT_SET,
+    .type = T_CLIST,
     .flags = BAF_OPTIONAL,
     .export = bgp_export_cluster_list,
     .encode = bgp_encode_u32s,
@@ -1066,19 +1066,19 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_MP_REACH_NLRI] = {
     .name = "mp_reach_nlri",
-    .type = EAF_TYPE_OPAQUE,
+    .type = T_OPAQUE,
     .flags = BAF_OPTIONAL,
     .decode = bgp_decode_mp_reach_nlri,
   },
   [BA_MP_UNREACH_NLRI] = {
     .name = "mp_unreach_nlri",
-    .type = EAF_TYPE_OPAQUE,
+    .type = T_OPAQUE,
     .flags = BAF_OPTIONAL,
     .decode = bgp_decode_mp_unreach_nlri,
   },
   [BA_EXT_COMMUNITY] = {
     .name = "ext_community",
-    .type = EAF_TYPE_EC_SET,
+    .type = T_ECLIST,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .export = bgp_export_ext_community,
     .encode = bgp_encode_u32s,
@@ -1086,14 +1086,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_AS4_PATH] = {
     .name = "as4_path",
-    .type = EAF_TYPE_AS_PATH,
+    .type = T_PATH,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .encode = bgp_encode_raw,
     .decode = bgp_decode_as4_path,
   },
   [BA_AS4_AGGREGATOR] = {
     .name = "as4_aggregator",
-    .type = EAF_TYPE_OPAQUE,
+    .type = T_OPAQUE,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .encode = bgp_encode_raw,
     .decode = bgp_decode_as4_aggregator,
@@ -1101,7 +1101,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_AIGP] = {
     .name = "aigp",
-    .type = EAF_TYPE_OPAQUE,
+    .type = T_OPAQUE,
     .flags = BAF_OPTIONAL | BAF_DECODE_FLAGS,
     .export = bgp_export_aigp,
     .encode = bgp_encode_raw,
@@ -1110,7 +1110,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_LARGE_COMMUNITY] = {
     .name = "large_community",
-    .type = EAF_TYPE_LC_SET,
+    .type = T_LCLIST,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .export = bgp_export_large_community,
     .encode = bgp_encode_u32s,
@@ -1118,7 +1118,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
   [BA_MPLS_LABEL_STACK] = {
     .name = "mpls_label_stack",
-    .type = EAF_TYPE_INT_SET,
+    .type = T_CLIST,
     .export = bgp_export_mpls_label_stack,
     .encode = bgp_encode_mpls_label_stack,
     .decode = bgp_decode_mpls_label_stack,
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 8a44514c..6f209595 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -545,22 +545,28 @@ bgp_find_attr(ea_list *attrs, uint code)
 }
 
 eattr *
-bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val);
+bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, union bval val);
 
 static inline void
 bgp_set_attr_u32(ea_list **to, struct linpool *pool, uint code, uint flags, u32 val)
-{ bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
+{
+  union bval bv = { .data = val };
+  bgp_set_attr(to, pool, code, flags, bv);
+}
 
 static inline void
-bgp_set_attr_ptr(ea_list **to, struct linpool *pool, uint code, uint flags, const struct adata *val)
-{ bgp_set_attr(to, pool, code, flags, (uintptr_t) val); }
+bgp_set_attr_ptr(ea_list **to, struct linpool *pool, uint code, uint flags, const struct adata *ad)
+{
+  union bval bv = { .ptr = ad };
+  bgp_set_attr(to, pool, code, flags, bv);
+}
 
 static inline void
 bgp_set_attr_data(ea_list **to, struct linpool *pool, uint code, uint flags, void *data, uint len)
 {
   struct adata *a = lp_alloc_adata(pool, len);
   bmemcpy(a->data, data, len);
-  bgp_set_attr(to, pool, code, flags, (uintptr_t) a);
+  bgp_set_attr_ptr(to, pool, code, flags, a);
 }
 
 #define bgp_unset_attr(to, pool, code) ea_unset_attr(to, pool, 0, code)
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index 86124bfb..6a78f79b 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -318,31 +318,31 @@ bgp_proto_channel: bgp_channel_start bgp_channel_opt_list bgp_channel_end;
 
 
 dynamic_attr: BGP_ORIGIN
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_BGP_ORIGIN, T_ENUM_BGP_ORIGIN, EA_CODE(PROTOCOL_BGP, BA_ORIGIN)); } ;
+	{ $$ = f_new_dynamic_attr(T_ENUM_BGP_ORIGIN, EA_CODE(PROTOCOL_BGP, BA_ORIGIN)); } ;
 dynamic_attr: BGP_PATH
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_AS_PATH, T_PATH, EA_CODE(PROTOCOL_BGP, BA_AS_PATH)); } ;
+	{ $$ = f_new_dynamic_attr(T_PATH, EA_CODE(PROTOCOL_BGP, BA_AS_PATH)); } ;
 dynamic_attr: BGP_NEXT_HOP
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_CODE(PROTOCOL_BGP, BA_NEXT_HOP)); } ;
+	{ $$ = f_new_dynamic_attr(T_IP, EA_CODE(PROTOCOL_BGP, BA_NEXT_HOP)); } ;
 dynamic_attr: BGP_MED
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC)); } ;
+	{ $$ = f_new_dynamic_attr(T_INT, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC)); } ;
 dynamic_attr: BGP_LOCAL_PREF
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF)); } ;
+	{ $$ = f_new_dynamic_attr(T_INT, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF)); } ;
 dynamic_attr: BGP_ATOMIC_AGGR
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_OPAQUE, T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_ATOMIC_AGGR)); } ;
+	{ $$ = f_new_dynamic_attr(T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_ATOMIC_AGGR)); } ;
 dynamic_attr: BGP_AGGREGATOR
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_OPAQUE, T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_AGGREGATOR)); } ;
+	{ $$ = f_new_dynamic_attr(T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_AGGREGATOR)); } ;
 dynamic_attr: BGP_COMMUNITY
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT_SET, T_CLIST, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY)); } ;
+	{ $$ = f_new_dynamic_attr(T_CLIST, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY)); } ;
 dynamic_attr: BGP_ORIGINATOR_ID
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_ROUTER_ID, T_QUAD, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID)); } ;
+	{ $$ = f_new_dynamic_attr(T_QUAD, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID)); } ;
 dynamic_attr: BGP_CLUSTER_LIST
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT_SET, T_CLIST, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST)); } ;
+	{ $$ = f_new_dynamic_attr(T_CLIST, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST)); } ;
 dynamic_attr: BGP_EXT_COMMUNITY
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_EC_SET, T_ECLIST, EA_CODE(PROTOCOL_BGP, BA_EXT_COMMUNITY)); } ;
+	{ $$ = f_new_dynamic_attr(T_ECLIST, EA_CODE(PROTOCOL_BGP, BA_EXT_COMMUNITY)); } ;
 dynamic_attr: BGP_AIGP
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_OPAQUE, T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_AIGP)); } ;
+	{ $$ = f_new_dynamic_attr(T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_AIGP)); } ;
 dynamic_attr: BGP_LARGE_COMMUNITY
-	{ $$ = f_new_dynamic_attr(EAF_TYPE_LC_SET, T_LCLIST, EA_CODE(PROTOCOL_BGP, BA_LARGE_COMMUNITY)); } ;
+	{ $$ = f_new_dynamic_attr(T_LCLIST, EA_CODE(PROTOCOL_BGP, BA_LARGE_COMMUNITY)); } ;
 
 
 
diff --git a/proto/ospf/config.Y b/proto/ospf/config.Y
index 4b7d5a36..a8972d2c 100644
--- a/proto/ospf/config.Y
+++ b/proto/ospf/config.Y
@@ -505,10 +505,10 @@ ospf_iface:
   ospf_iface_start ospf_iface_patt_list ospf_iface_opt_list { ospf_iface_finish(); }
  ;
 
-dynamic_attr: OSPF_METRIC1 { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_OSPF_METRIC1); } ;
-dynamic_attr: OSPF_METRIC2 { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_OSPF_METRIC2); } ;
-dynamic_attr: OSPF_TAG { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_OSPF_TAG); } ;
-dynamic_attr: OSPF_ROUTER_ID { $$ = f_new_dynamic_attr(EAF_TYPE_ROUTER_ID, T_QUAD, EA_OSPF_ROUTER_ID); } ;
+dynamic_attr: OSPF_METRIC1 { $$ = f_new_dynamic_attr(T_INT, EA_OSPF_METRIC1); } ;
+dynamic_attr: OSPF_METRIC2 { $$ = f_new_dynamic_attr(T_INT, EA_OSPF_METRIC2); } ;
+dynamic_attr: OSPF_TAG { $$ = f_new_dynamic_attr(T_INT, EA_OSPF_TAG); } ;
+dynamic_attr: OSPF_ROUTER_ID { $$ = f_new_dynamic_attr(T_QUAD, EA_OSPF_ROUTER_ID); } ;
 
 CF_CLI_HELP(SHOW OSPF, ..., [[Show information about OSPF protocol]]);
 CF_CLI(SHOW OSPF, optproto, [<name>], [[Show information about OSPF protocol]])
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 471bb586..8643f456 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -2072,27 +2072,27 @@ again1:
 
 	a0.eattrs->attrs[a0.eattrs->count++] = (eattr) {
 	  .id = EA_OSPF_METRIC1,
-	  .type = EAF_TYPE_INT,
+	  .type = T_INT,
 	  .u.data = nf->n.metric1,
 	};
 
 	if (nf->n.type == RTS_OSPF_EXT2)
 	  a0.eattrs->attrs[a0.eattrs->count++] = (eattr) {
 	    .id = EA_OSPF_METRIC2,
-	    .type = EAF_TYPE_INT,
+	    .type = T_INT,
 	    .u.data = nf->n.metric2,
 	  };
 
 	if ((nf->n.type == RTS_OSPF_EXT1) || (nf->n.type == RTS_OSPF_EXT2))
 	  a0.eattrs->attrs[a0.eattrs->count++] = (eattr) {
 	    .id = EA_OSPF_TAG,
-	    .type = EAF_TYPE_INT,
+	    .type = T_INT,
 	    .u.data = nf->n.tag,
 	  };
 
 	a0.eattrs->attrs[a0.eattrs->count++] = (eattr) {
 	  .id = EA_OSPF_ROUTER_ID,
-	  .type = EAF_TYPE_ROUTER_ID,
+	  .type = T_QUAD,
 	  .u.data = nf->n.rid,
 	};
 
diff --git a/proto/radv/config.Y b/proto/radv/config.Y
index f16b897d..0a339cb4 100644
--- a/proto/radv/config.Y
+++ b/proto/radv/config.Y
@@ -336,8 +336,8 @@ radv_sensitive:
  | SENSITIVE bool { $$ = $2; }
  ;
 
-dynamic_attr: RA_PREFERENCE { $$ = f_new_dynamic_attr(EAF_TYPE_RA_PREFERENCE, T_ENUM_RA_PREFERENCE, EA_RA_PREFERENCE); } ;
-dynamic_attr: RA_LIFETIME { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_RA_LIFETIME); } ;
+dynamic_attr: RA_PREFERENCE { $$ = f_new_dynamic_attr(T_ENUM_RA_PREFERENCE, EA_RA_PREFERENCE); } ;
+dynamic_attr: RA_LIFETIME { $$ = f_new_dynamic_attr(T_INT, EA_RA_LIFETIME); } ;
 
 CF_CODE
 
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index 28ee9609..3934d337 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -190,8 +190,8 @@ rip_iface:
   rip_iface_start iface_patt_list_nopx rip_iface_opt_list rip_iface_finish;
 
 
-dynamic_attr: RIP_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_RIP_METRIC); } ;
-dynamic_attr: RIP_TAG { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_RIP_TAG); } ;
+dynamic_attr: RIP_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_RIP_METRIC); } ;
+dynamic_attr: RIP_TAG { $$ = f_new_dynamic_attr(T_INT, EA_RIP_TAG); } ;
 
 CF_CLI_HELP(SHOW RIP, ..., [[Show information about RIP protocol]]);
 
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 6ca7a6b5..fa5b1289 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -202,17 +202,17 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
       .e = {
 	{
 	  .id = EA_RIP_METRIC,
-	  .type = EAF_TYPE_INT,
+	  .type = T_INT,
 	  .u.data = rt_metric,
 	},
 	{
 	  .id = EA_RIP_TAG,
-	  .type = EAF_TYPE_INT,
+	  .type = T_INT,
 	  .u.data = rt_tag,
 	},
 	{
 	  .id = EA_RIP_FROM,
-	  .type = EAF_TYPE_IFACE,
+	  .type = T_IFACE,
 	  .u.ptr = &ea_block.riad.ad,
 	}
       },
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index efdb18a3..3b1d2299 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -589,7 +589,7 @@ krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
 
   ea->attrs[0] = (eattr) {
     .id = EA_KRT_SOURCE,
-    .type = EAF_TYPE_INT,
+    .type = T_INT,
     .u.data = src2,
   };
 
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index 7390be73..f31b88c7 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -28,23 +28,23 @@ kern_sys_item:
  | NETLINK RX BUFFER expr { THIS_KRT->sys.netlink_rx_buffer = $4; }
  ;
 
-dynamic_attr: KRT_PREFSRC	{ $$ = f_new_dynamic_attr(EAF_TYPE_IP_ADDRESS, T_IP, EA_KRT_PREFSRC); } ;
-dynamic_attr: KRT_REALM	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_REALM); } ;
-dynamic_attr: KRT_SCOPE	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_SCOPE); } ;
+dynamic_attr: KRT_PREFSRC	{ $$ = f_new_dynamic_attr(T_IP, EA_KRT_PREFSRC); } ;
+dynamic_attr: KRT_REALM	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_REALM); } ;
+dynamic_attr: KRT_SCOPE	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_SCOPE); } ;
 
-dynamic_attr: KRT_MTU		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_MTU); } ;
-dynamic_attr: KRT_WINDOW	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_WINDOW); } ;
-dynamic_attr: KRT_RTT		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_RTT); } ;
-dynamic_attr: KRT_RTTVAR	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_RTTVAR); } ;
-dynamic_attr: KRT_SSTRESH	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_SSTRESH); } ;
-dynamic_attr: KRT_CWND		{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_CWND); } ;
-dynamic_attr: KRT_ADVMSS	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_ADVMSS); } ;
-dynamic_attr: KRT_REORDERING	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_REORDERING); } ;
-dynamic_attr: KRT_HOPLIMIT	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_HOPLIMIT); } ;
-dynamic_attr: KRT_INITCWND	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_INITCWND); } ;
-dynamic_attr: KRT_RTO_MIN	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_RTO_MIN); } ;
-dynamic_attr: KRT_INITRWND	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_INITRWND); } ;
-dynamic_attr: KRT_QUICKACK	{ $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_QUICKACK); } ;
+dynamic_attr: KRT_MTU		{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_MTU); } ;
+dynamic_attr: KRT_WINDOW	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_WINDOW); } ;
+dynamic_attr: KRT_RTT		{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_RTT); } ;
+dynamic_attr: KRT_RTTVAR	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_RTTVAR); } ;
+dynamic_attr: KRT_SSTRESH	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_SSTRESH); } ;
+dynamic_attr: KRT_CWND		{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_CWND); } ;
+dynamic_attr: KRT_ADVMSS	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_ADVMSS); } ;
+dynamic_attr: KRT_REORDERING	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_REORDERING); } ;
+dynamic_attr: KRT_HOPLIMIT	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_HOPLIMIT); } ;
+dynamic_attr: KRT_INITCWND	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_INITCWND); } ;
+dynamic_attr: KRT_RTO_MIN	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_RTO_MIN); } ;
+dynamic_attr: KRT_INITRWND	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_INITRWND); } ;
+dynamic_attr: KRT_QUICKACK	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_QUICKACK); } ;
 
 /* Bits of EA_KRT_LOCK, based on RTAX_* constants */
 
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 6c8228fd..eb4be711 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1587,12 +1587,12 @@ nl_announce_route(struct nl_parse_state *s)
 
   ea->attrs[0] = (eattr) {
     .id = EA_KRT_SOURCE,
-    .type = EAF_TYPE_INT,
+    .type = T_INT,
     .u.data = s->krt_proto,
   };
   ea->attrs[1] = (eattr) {
     .id = EA_KRT_METRIC,
-    .type = EAF_TYPE_INT,
+    .type = T_INT,
     .u.data = s->krt_metric,
   };
 
@@ -1873,7 +1873,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
       ea->count = 1;
       ea->attrs[0].id = EA_KRT_SCOPE;
       ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_INT;
+      ea->attrs[0].type = T_INT;
       ea->attrs[0].u.data = i->rtm_scope;
     }
 
@@ -1888,7 +1888,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
       ea->count = 1;
       ea->attrs[0].id = EA_KRT_PREFSRC;
       ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_IP_ADDRESS;
+      ea->attrs[0].type = T_IP;
 
       struct adata *ad = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
       ad->length = sizeof(ps);
@@ -1907,7 +1907,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
       ea->count = 1;
       ea->attrs[0].id = EA_KRT_REALM;
       ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_INT;
+      ea->attrs[0].type = T_INT;
       ea->attrs[0].u.data = s->rta_flow;
     }
 
@@ -1928,7 +1928,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	  {
 	    ea->attrs[n].id = EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t);
 	    ea->attrs[n].flags = 0;
-	    ea->attrs[n].type = EAF_TYPE_INT;
+	    ea->attrs[n].type = T_INT;
 	    ea->attrs[n].u.data = metrics[t];
 	    n++;
 	  }
diff --git a/sysdep/linux/netlink.c.orig b/sysdep/linux/netlink.c.orig
deleted file mode 100644
index 7cea5322..00000000
--- a/sysdep/linux/netlink.c.orig
+++ /dev/null
@@ -1,2179 +0,0 @@
-/*
- *	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 <alloca.h>
-#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 "conf/conf.h"
-
-#include <asm/types.h>
-#include <linux/if.h>
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-
-#ifdef HAVE_MPLS_KERNEL
-#include <linux/lwtunnel.h>
-#endif
-
-#ifndef MSG_TRUNC			/* Hack: Several versions of glibc miss this one :( */
-#define MSG_TRUNC 0x20
-#endif
-
-#ifndef IFA_FLAGS
-#define IFA_FLAGS 8
-#endif
-
-#ifndef IFF_LOWER_UP
-#define IFF_LOWER_UP 0x10000
-#endif
-
-#ifndef RTA_TABLE
-#define RTA_TABLE  15
-#endif
-
-#ifndef RTA_VIA
-#define RTA_VIA	 18
-#endif
-
-#ifndef RTA_NEWDST
-#define RTA_NEWDST  19
-#endif
-
-#ifndef RTA_ENCAP_TYPE
-#define RTA_ENCAP_TYPE	21
-#endif
-
-#ifndef RTA_ENCAP
-#define RTA_ENCAP  22
-#endif
-
-#define krt_ipv4(p) ((p)->af == AF_INET)
-#define krt_ecmp6(p) ((p)->af == AF_INET6)
-
-const int rt_default_ecmp = 16;
-
-/*
- * Structure nl_parse_state keeps state of received route processing. Ideally,
- * we could just independently parse received Netlink messages and immediately
- * propagate received routes to the rest of BIRD, but older Linux kernel (before
- * version 4.11) represents and announces IPv6 ECMP routes not as one route with
- * multiple next hops (like RTA_MULTIPATH in IPv4 ECMP), but as a sequence of
- * routes with the same prefix. More recent kernels work as with IPv4.
- *
- * Therefore, BIRD keeps currently processed route in nl_parse_state structure
- * and postpones its propagation until we expect it to be final; i.e., when
- * non-matching route is received or when the scan ends. When another matching
- * route is received, it is merged with the already processed route to form an
- * ECMP route. Note that merging is done only for IPv6 (merge == 1), but the
- * postponing is done in both cases (for simplicity). All IPv4 routes or IPv6
- * routes with RTA_MULTIPATH set are just considered non-matching.
- *
- * This is ignored for asynchronous notifications (every notification is handled
- * as a separate route). It is not an issue for our routes, as we ignore such
- * notifications anyways. But importing alien IPv6 ECMP routes does not work
- * properly with older kernels.
- *
- * Whatever the kernel version is, IPv6 ECMP routes are sent as multiple routes
- * for the same prefix.
- */
-
-struct nl_parse_state
-{
-  struct linpool *pool;
-  int scan;
-  int merge;
-
-  net *net;
-  rta *attrs;
-  struct krt_proto *proto;
-  s8 new;
-  s8 krt_src;
-  u8 krt_type;
-  u8 krt_proto;
-  u32 krt_metric;
-
-  u32 rta_flow;		/* Used during parsing */
-};
-
-/*
- *	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 8192
-
-#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 void
-nl_open(void)
-{
-  nl_open_sock(&nl_scan);
-  nl_open_sock(&nl_req);
-}
-
-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(int af, int cmd)
-{
-  struct {
-    struct nlmsghdr nh;
-    struct rtgenmsg g;
-  } req = {
-    .nh.nlmsg_type = cmd,
-    .nh.nlmsg_len = sizeof(req),
-    .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
-    .g.rtgen_family = af
-  };
-  nl_send(&nl_scan, &req.nh);
-}
-
-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 = -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_WIRELESS+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 },
-};
-
-
-#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
-
-
-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 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 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
-    return ipa_from_ip6(rta_get_ip6(a));
-}
-
-#ifdef HAVE_MPLS_KERNEL
-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;
-}
-
-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_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 *nh, int af, ea_list *eattrs)
-{
-  struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
-  eattr *flow = ea_find(eattrs, EA_KRT_REALM);
-
-  for (; nh; nh = nh->next)
-  {
-    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 *
-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 = RTA_DATA(ra);
-  struct nexthop *rv, *first, **last;
-  unsigned len = RTA_PAYLOAD(ra);
-
-  first = NULL;
-  last = &first;
-
-  while (len)
-    {
-      /* 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))
-	goto next;
-
-      *last = rv = lp_allocz(s->pool, NEXTHOP_MAX_SIZE);
-      last = &(rv->next);
-
-      rv->weight = nh->rtnh_hops;
-      rv->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]);
-
-#ifdef HAVE_MPLS_KERNEL
-      if (a[RTA_VIA])
-	rv->gw = rta_get_via(a[RTA_VIA]);
-#endif
-
-      if (ipa_nonzero(rv->gw))
-	{
-	  if (nh->rtnh_flags & RTNH_F_ONLINK)
-	    rv->flags |= RNF_ONLINK;
-
-	  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
-
-    next:
-      len -= NLMSG_ALIGN(nh->rtnh_len);
-      nh = RTNH_NEXT(nh);
-    }
-
-  /* Ensure nexthops are sorted to satisfy nest invariant */
-  if (!nexthop_is_sorted(first))
-    first = nexthop_sort(first);
-
-  return first;
-
-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, 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))
-      nl_add_attr_u32(h, bufsize, t, metrics[t]);
-
-  nl_close_attr(h, a);
-}
-
-static int
-nl_parse_metrics(struct rtattr *hdr, u32 *metrics, 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 == RTA_UNSPEC)
-      continue;
-
-    if (a->rta_type >= max)
-      continue;
-
-    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;
-  char *name;
-  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]);
-
-  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;
-
-      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(AF_UNSPEC, RTM_GETLINK);
-  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 */
-  struct iface *i;
-  WALK_LIST(i, iface_list)
-    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(i->master_index)
-      };
-
-      if (f.master != i->master)
-      {
-	memcpy(f.name, i->name, sizeof(f.name));
-	if_update(&f);
-      }
-    }
-
-  nl_request_dump(AF_INET, RTM_GETADDR);
-  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(AF_INET6, RTM_GETADDR);
-  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, *2, 2, 2, 6, 20
-
-HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
-
-int
-krt_capable(rte *e)
-{
-  rta *a = e->attrs;
-
-  switch (a->dest)
-  {
-    case RTD_UNICAST:
-    case RTD_BLACKHOLE:
-    case RTD_UNREACHABLE:
-    case RTD_PROHIBIT:
-      return 1;
-
-    default:
-      return 0;
-  }
-}
-
-static inline int
-nh_bufsize(struct nexthop *nh)
-{
-  int rv = 0;
-  for (; nh != NULL; nh = nh->next)
-    rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
-  return rv;
-}
-
-static int
-nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
-{
-  eattr *ea;
-  net *net = e->net;
-  rta *a = e->attrs;
-  ea_list *eattrs = a->eattrs;
-  int bufsize = 128 + KRT_METRICS_MAX*8 + nh_bufsize(&(a->nh));
-  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", net->n.addr, 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(net->n.addr);
-  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(net->n.addr);
-    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(net->n.addr));
-
-    /* Add source address for IPv6 SADR routes */
-    if (net->n.addr->type == NET_IP6_SADR)
-    {
-      net_addr_ip6_sadr *a = (void *) &net->n.addr;
-      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 (a->source == RTS_DUMMY)
-    priority = e->u.krt.metric;
-  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 dest;
-
-  /* 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
-    r->r.rtm_scope = (dest == RTD_UNICAST && ipa_zero(nh->gw)) ? RT_SCOPE_LINK : 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];
-  metrics[0] = 0;
-
-  struct ea_walk_state ews = { .eattrs = eattrs };
-  while (ea = ea_walk(&ews, EA_KRT_METRICS, KRT_METRICS_MAX))
-  {
-    int id = ea->id - EA_KRT_METRICS;
-    metrics[0] |= 1 << id;
-    metrics[id] = ea->u.data;
-  }
-
-  if (metrics[0])
-    nl_add_metrics(&r->h, rsize, metrics, KRT_METRICS_MAX);
-
-
-dest:
-  switch (dest)
-    {
-    case RTD_UNICAST:
-      r->r.rtm_type = RTN_UNICAST;
-      if (nh->next && !krt_ecmp6(p))
-	nl_add_multipath(&r->h, rsize, nh, p->af, eattrs);
-      else
-      {
-	nl_add_attr_u32(&r->h, rsize, RTA_OIF, nh->iface->index);
-	nl_add_nexthop(&r->h, rsize, nh, p->af);
-
-	if (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");
-    }
-
-  /* Ignore missing for DELETE */
-  return nl_exchange(&r->h, (op == NL_OP_DELETE));
-}
-
-static inline int
-nl_add_rte(struct krt_proto *p, rte *e)
-{
-  rta *a = e->attrs;
-  int err = 0;
-
-  if (krt_ecmp6(p) && a->nh.next)
-  {
-    struct nexthop *nh = &(a->nh);
-
-    err = nl_send_route(p, e, NL_OP_ADD, RTD_UNICAST, nh);
-    if (err < 0)
-      return err;
-
-    for (nh = nh->next; nh; nh = nh->next)
-      err += nl_send_route(p, e, NL_OP_APPEND, RTD_UNICAST, nh);
-
-    return err;
-  }
-
-  return nl_send_route(p, e, NL_OP_ADD, a->dest, &(a->nh));
-}
-
-static inline int
-nl_delete_rte(struct krt_proto *p, rte *e)
-{
-  int err = 0;
-
-  /* For IPv6, we just repeatedly request DELETE until we get error */
-  do
-    err = nl_send_route(p, e, NL_OP_DELETE, RTD_NONE, NULL);
-  while (krt_ecmp6(p) && !err);
-
-  return err;
-}
-
-static inline int
-nl_replace_rte(struct krt_proto *p, rte *e)
-{
-  rta *a = e->attrs;
-  return nl_send_route(p, e, NL_OP_REPLACE, a->dest, &(a->nh));
-}
-
-
-void
-krt_replace_rte(struct krt_proto *p, net *n UNUSED, rte *new, rte *old)
-{
-  int err = 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.
-   *
-   * We do not use NL_OP_REPLACE for IPv6, as it has broken semantics for ECMP
-   * and with some kernel versions ECMP replace crashes kernel. Would need more
-   * testing and checks for kernel versions.
-   *
-   * For IPv6, we use NL_OP_DELETE and then NL_OP_ADD. We also do not trust the
-   * old route value, so we do not try to optimize IPv6 ECMP reconfigurations.
-   */
-
-  if (krt_ipv4(p) && old && new)
-  {
-    err = nl_replace_rte(p, new);
-  }
-  else
-  {
-    if (old)
-      nl_delete_rte(p, old);
-
-    if (new)
-      err = nl_add_rte(p, new);
-  }
-
-  if (new)
-  {
-    if (err < 0)
-      bmap_clear(&p->sync_map, new->id);
-    else
-      bmap_set(&p->sync_map, new->id);
-  }
-}
-
-static int
-nl_mergable_route(struct nl_parse_state *s, net *net, struct krt_proto *p, uint priority, uint krt_type, uint rtm_family)
-{
-  /* Route merging is used for IPv6 scans */
-  if (!s->scan || (rtm_family != AF_INET6))
-    return 0;
-
-  /* Saved and new route must have same network, proto/table, and priority */
-  if ((s->net != net) || (s->proto != p) || (s->krt_metric != priority))
-    return 0;
-
-  /* Both must be regular unicast routes */
-  if ((s->krt_type != RTN_UNICAST) || (krt_type != RTN_UNICAST))
-    return 0;
-
-  return 1;
-}
-
-static void
-nl_announce_route(struct nl_parse_state *s)
-{
-  rte *e = rte_get_temp(s->attrs);
-  e->net = s->net;
-  e->u.krt.src = s->krt_src;
-  e->u.krt.proto = s->krt_proto;
-  e->u.krt.seen = 0;
-  e->u.krt.best = 0;
-  e->u.krt.metric = s->krt_metric;
-
-  if (s->scan)
-    krt_got_route(s->proto, e);
-  else
-    krt_got_route_async(s->proto, e, s->new);
-
-  s->net = NULL;
-  s->attrs = NULL;
-  s->proto = NULL;
-  lp_flush(s->pool);
-}
-
-static inline void
-nl_parse_begin(struct nl_parse_state *s, int scan)
-{
-  memset(s, 0, sizeof (struct nl_parse_state));
-  s->pool = nl_linpool;
-  s->scan = scan;
-}
-
-static inline void
-nl_parse_end(struct nl_parse_state *s)
-{
-  if (s->net)
-    nl_announce_route(s);
-}
-
-
-#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;
-      return;
-
-    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 *n = &dst;
-  if (p->p.net_type == NET_IP6_SADR)
-  {
-    n = alloca(sizeof(net_addr_ip6_sadr));
-    net_fill_ip6_sadr(n, net6_prefix(&dst), net6_pxlen(&dst),
-		      net6_prefix(&src), net6_pxlen(&src));
-  }
-
-  net *net = net_get(p->p.main_channel->table, n);
-
-  if (s->net && !nl_mergable_route(s, net, p, priority, i->rtm_type, i->rtm_family))
-    nl_announce_route(s);
-
-  rta *ra = lp_allocz(s->pool, RTA_MAX_SIZE);
-  ra->src = p->p.main_source;
-  ra->source = RTS_INHERIT;
-  ra->scope = SCOPE_UNIVERSE;
-
-  if (a[RTA_FLOW])
-    s->rta_flow = rta_get_u32(a[RTA_FLOW]);
-  else
-    s->rta_flow = 0;
-
-  switch (i->rtm_type)
-    {
-    case RTN_UNICAST:
-      ra->dest = RTD_UNICAST;
-
-      if (a[RTA_MULTIPATH])
-        {
-	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
-	  if (!nh)
-	    SKIP("strange RTA_MULTIPATH\n");
-
-	  nexthop_link(ra, nh);
-	  break;
-	}
-
-      if ((i->rtm_flags & RTNH_F_DEAD) && (krt_src != KRT_SRC_BIRD))
-	SKIP("ignore RTNH_F_DEAD\n");
-
-      ra->nh.iface = if_find_by_index(oif);
-      if (!ra->nh.iface)
-	{
-	  log(L_ERR "KRT: Received route %N with unknown ifindex %u", net->n.addr, oif);
-	  return;
-	}
-
-      if (a[RTA_GATEWAY])
-	ra->nh.gw = rta_get_ipa(a[RTA_GATEWAY]);
-
-#ifdef HAVE_MPLS_KERNEL
-      if (a[RTA_VIA])
-	ra->nh.gw = rta_get_via(a[RTA_VIA]);
-#endif
-
-      if (ipa_nonzero(ra->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(ra->nh.gw, (net_addr *) &sit))
-	    return;
-
-	  if (i->rtm_flags & RTNH_F_ONLINK)
-	    ra->nh.flags |= RNF_ONLINK;
-
-	  neighbor *nbr;
-	  nbr = neigh_find(&p->p, ra->nh.gw, ra->nh.iface,
-			   (ra->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->n.addr,
-                  ra->nh.gw);
-	      return;
-	    }
-	}
-
-      break;
-    case RTN_BLACKHOLE:
-      ra->dest = RTD_BLACKHOLE;
-      break;
-    case RTN_UNREACHABLE:
-      ra->dest = RTD_UNREACHABLE;
-      break;
-    case RTN_PROHIBIT:
-      ra->dest = RTD_PROHIBIT;
-      break;
-    /* FIXME: What about RTN_THROW? */
-    default:
-      SKIP("type %d\n", i->rtm_type);
-      return;
-    }
-
-#ifdef HAVE_MPLS_KERNEL
-  if ((i->rtm_family == AF_MPLS) && a[RTA_NEWDST] && !ra->nh.next)
-    ra->nh.labels = rta_get_mpls(a[RTA_NEWDST], ra->nh.label);
-
-  if (a[RTA_ENCAP] && a[RTA_ENCAP_TYPE] && !ra->nh.next)
-    {
-      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));
-	      ra->nh.labels = rta_get_mpls(enca[RTA_DST], ra->nh.label);
-	      break;
-	    }
-	  default:
-	    SKIP("unknown encapsulation method %d\n", rta_get_u16(a[RTA_ENCAP_TYPE]));
-	    break;
-	}
-    }
-#endif
-
-  if (i->rtm_scope != def_scope)
-    {
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_SCOPE;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_INT;
-      ea->attrs[0].u.data = i->rtm_scope;
-    }
-
-  if (a[RTA_PREFSRC])
-    {
-      ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);
-
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_PREFSRC;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_IP_ADDRESS;
-
-      struct adata *ad = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
-      ad->length = sizeof(ps);
-      memcpy(ad->data, &ps, sizeof(ps));
-
-      ea->attrs[0].u.ptr = ad;
-    }
-
-  /* Can be set per-route or per-nexthop */
-  if (s->rta_flow)
-    {
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_REALM;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = EAF_TYPE_INT;
-      ea->attrs[0].u.data = s->rta_flow;
-    }
-
-  if (a[RTA_METRICS])
-    {
-      u32 metrics[KRT_METRICS_MAX];
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
-      int t, n = 0;
-
-      if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
-        {
-	  log(L_ERR "KRT: Received route %N with strange RTA_METRICS attribute", net->n.addr);
-	  return;
-	}
-
-      for (t = 1; t < KRT_METRICS_MAX; t++)
-	if (metrics[0] & (1 << t))
-	  {
-	    ea->attrs[n].id = EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t);
-	    ea->attrs[n].flags = 0;
-	    ea->attrs[n].type = EAF_TYPE_INT; /* FIXME: Some are EAF_TYPE_BITFIELD */
-	    ea->attrs[n].u.data = metrics[t];
-	    n++;
-	  }
-
-      if (n > 0)
-        {
-	  ea->next = ra->eattrs;
-	  ea->flags = EALF_SORTED;
-	  ea->count = n;
-	  ra->eattrs = ea;
-	}
-    }
-
-  /*
-   * Ideally, now we would send the received route to the rest of kernel code.
-   * But IPv6 ECMP routes before 4.11 are sent as a sequence of routes, so we
-   * postpone it and merge next hops until the end of the sequence. Note that
-   * when doing merging of next hops, we expect the new route to be unipath.
-   * Otherwise, we ignore additional next hops in nexthop_insert().
-   */
-
-  if (!s->net)
-  {
-    /* Store the new route */
-    s->net = net;
-    s->attrs = ra;
-    s->proto = p;
-    s->new = new;
-    s->krt_src = krt_src;
-    s->krt_type = i->rtm_type;
-    s->krt_proto = i->rtm_protocol;
-    s->krt_metric = priority;
-  }
-  else
-  {
-    /* Merge next hops with the stored route */
-    rta *oa = s->attrs;
-
-    struct nexthop *nhs = &oa->nh;
-    nexthop_insert(&nhs, &ra->nh);
-
-    /* Perhaps new nexthop is inserted at the first position */
-    if (nhs == &ra->nh)
-    {
-      /* Swap rtas */
-      s->attrs = ra;
-
-      /* Keep old eattrs */
-      ra->eattrs = oa->eattrs;
-    }
-  }
-}
-
-void
-krt_do_scan(struct krt_proto *p UNUSED)	/* CONFIG_ALL_TABLES_AT_ONCE => p is NULL */
-{
-  struct nlmsghdr *h;
-  struct nl_parse_state s;
-
-  nl_parse_begin(&s, 1);
-  nl_request_dump(AF_UNSPEC, RTM_GETROUTE);
-  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);
-  nl_parse_end(&s);
-}
-
-/*
- *	Asynchronous Netlink interface
- */
-
-static sock *nl_async_sk;		/* BIRD socket for asynchronous notifications */
-static byte *nl_async_rx_buffer;	/* Receive buffer */
-
-static void
-nl_async_msg(struct nlmsghdr *h)
-{
-  struct nl_parse_state s;
-
-  switch (h->nlmsg_type)
-    {
-    case RTM_NEWROUTE:
-    case RTM_DELROUTE:
-      DBG("KRT: Received async route notification (%d)\n", h->nlmsg_type);
-      nl_parse_begin(&s, 0);
-      nl_parse_route(&s, h);
-      nl_parse_end(&s);
-      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;
-    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_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) < 0)
-    bug("Netlink: sk_open failed");
-}
-
-
-/*
- *	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, 6);
-}
-
-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();
-
-  return 1;
-}
-
-void
-krt_sys_shutdown(struct krt_proto *p)
-{
-  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)
-{
-  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;
-}
-
-static const char *krt_metrics_names[KRT_METRICS_MAX] = {
-  NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
-  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
-};
-
-static const char *krt_features_names[KRT_FEATURES_MAX] = {
-  "ecn", NULL, NULL, "allfrag"
-};
-
-int
-krt_sys_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
-{
-  switch (a->id)
-  {
-  case EA_KRT_PREFSRC:
-    bsprintf(buf, "prefsrc");
-    return GA_NAME;
-
-  case EA_KRT_REALM:
-    bsprintf(buf, "realm");
-    return GA_NAME;
-
-  case EA_KRT_SCOPE:
-    bsprintf(buf, "scope");
-    return GA_NAME;
-
-  case EA_KRT_LOCK:
-    buf += bsprintf(buf, "lock:");
-    ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
-    return GA_FULL;
-
-  case EA_KRT_FEATURES:
-    buf += bsprintf(buf, "features:");
-    ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
-    return GA_FULL;
-
-  default:;
-    int id = (int)EA_ID(a->id) - KRT_METRICS_OFFSET;
-    if (id > 0 && id < KRT_METRICS_MAX)
-    {
-      bsprintf(buf, "%s", krt_metrics_names[id]);
-      return GA_NAME;
-    }
-
-    return GA_UNKNOWN;
-  }
-}
-
-
-
-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;
-}
diff --git a/sysdep/unix/krt.Y b/sysdep/unix/krt.Y
index 95b54d65..2a3f41de 100644
--- a/sysdep/unix/krt.Y
+++ b/sysdep/unix/krt.Y
@@ -122,8 +122,8 @@ kif_iface:
   kif_iface_start iface_patt_list_nopx kif_iface_opt_list;
 
 
-dynamic_attr: KRT_SOURCE { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_SOURCE); } ;
-dynamic_attr: KRT_METRIC { $$ = f_new_dynamic_attr(EAF_TYPE_INT, T_INT, EA_KRT_METRIC); } ;
+dynamic_attr: KRT_SOURCE { $$ = f_new_dynamic_attr(T_INT, EA_KRT_SOURCE); } ;
+dynamic_attr: KRT_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_KRT_METRIC); } ;
 
 CF_CODE
 
-- 
cgit v1.2.3


From ef6a903e6f44b467f9606018446095521ad01ef1 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 31 Mar 2022 19:09:38 +0200
Subject: Splitting route data structures out to lib

---
 conf/cf-lex.l          |   2 +-
 conf/conf.c            |   2 +-
 conf/confbase.Y        |   2 +-
 filter/data.c          |   2 +-
 filter/f-util.c        |   2 +-
 filter/filter.c        |   2 +-
 filter/filter.h        |   2 +-
 lib/event_test.c       |   2 +-
 lib/route.h            | 332 +++++++++++++++++++++++++
 nest/a-path.c          |   2 +-
 nest/a-path_test.c     |   2 +-
 nest/a-set.c           |   2 +-
 nest/a-set_test.c      |   2 +-
 nest/attrs.h           |   2 +-
 nest/cmds.c            |   2 +-
 nest/proto.c           |   2 +-
 nest/protocol.h        |   2 +-
 nest/route.h           | 639 -------------------------------------------------
 nest/rt-attr.c         |  21 +-
 nest/rt-dev.c          |   2 +-
 nest/rt-fib.c          |   2 +-
 nest/rt-show.c         |   2 +-
 nest/rt-table.c        |   2 +-
 nest/rt.h              | 343 ++++++++++++++++++++++++++
 proto/babel/babel.h    |   2 +-
 proto/bfd/bfd.h        |   2 +-
 proto/bgp/attrs.c      |   2 +-
 proto/bgp/bgp.c        |   2 +-
 proto/bgp/bgp.h        |   2 +-
 proto/bgp/packets.c    |   2 +-
 proto/mrt/mrt.h        |   2 +-
 proto/ospf/ospf.h      |   2 +-
 proto/perf/perf.c      |   2 +-
 proto/pipe/pipe.c      |   2 +-
 proto/radv/radv.h      |   2 +-
 proto/rip/rip.h        |   2 +-
 proto/rpki/rpki.h      |   2 +-
 proto/static/static.c  |   2 +-
 proto/static/static.h  |   2 +-
 sysdep/bsd/krt-sock.c  |   2 +-
 sysdep/linux/netlink.c |   2 +-
 sysdep/unix/krt.c      |   2 +-
 sysdep/unix/main.c     |   2 +-
 test/bt-utils.c        |   2 +-
 44 files changed, 716 insertions(+), 699 deletions(-)
 create mode 100644 lib/route.h
 delete mode 100644 nest/route.h
 create mode 100644 nest/rt.h

(limited to 'sysdep/linux')

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index b9457a83..75e1ceeb 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -42,7 +42,7 @@
 #define PARSER 1
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "filter/filter.h"
 #include "filter/f-inst.h"
diff --git a/conf/conf.c b/conf/conf.c
index a2b01667..0230053b 100644
--- a/conf/conf.c
+++ b/conf/conf.c
@@ -46,7 +46,7 @@
 #undef LOCAL_DEBUG
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "lib/resource.h"
diff --git a/conf/confbase.Y b/conf/confbase.Y
index 753df325..3fdacb12 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -18,7 +18,7 @@ CF_HDR
 #include "lib/string.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/bfd.h"
 #include "nest/cli.h"
 #include "filter/filter.h"
diff --git a/filter/data.c b/filter/data.c
index feb8c8bb..87ef4ff1 100644
--- a/filter/data.c
+++ b/filter/data.c
@@ -16,7 +16,7 @@
 #include "lib/unaligned.h"
 #include "lib/net.h"
 #include "lib/ip.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "nest/attrs.h"
diff --git a/filter/f-util.c b/filter/f-util.c
index 79cf3452..83ae01f6 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -13,7 +13,7 @@
 #include "filter/f-inst.h"
 #include "lib/idm.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 
 #define P(a,b) ((a<<8) | b)
 
diff --git a/filter/filter.c b/filter/filter.c
index 7004b96d..31ae79fe 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -35,7 +35,7 @@
 #include "lib/ip.h"
 #include "lib/net.h"
 #include "lib/flowspec.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "nest/attrs.h"
diff --git a/filter/filter.h b/filter/filter.h
index e9c9d917..8ce6c1e0 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -13,7 +13,7 @@
 #include "lib/resource.h"
 #include "lib/ip.h"
 #include "lib/macro.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 
 /* Possible return values of filter execution */
diff --git a/lib/event_test.c b/lib/event_test.c
index e1fbea8f..e14d0b95 100644
--- a/lib/event_test.c
+++ b/lib/event_test.c
@@ -15,7 +15,7 @@
 #include "nest/locks.h"
 #include "sysdep/unix/unix.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 
 #define MAX_NUM 4
 
diff --git a/lib/route.h b/lib/route.h
new file mode 100644
index 00000000..47355abc
--- /dev/null
+++ b/lib/route.h
@@ -0,0 +1,332 @@
+/*
+ *	BIRD Internet Routing Daemon -- Routing data structures
+ *
+ *	(c) 1998--2000 Martin Mares <mj@ucw.cz>
+ *	(c) 2022 Maria Matejka <mq@jmq.cz>
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_LIB_ROUTE_H_
+#define _BIRD_LIB_ROUTE_H_
+
+struct network;
+struct proto;
+struct cli;
+
+typedef struct rte {
+  struct rte *next;
+  struct network *net;			/* Network this RTE belongs to */
+  struct rte_src *src;			/* Route source that created the route */
+  struct channel *sender;		/* Channel used to send the route to the routing table */
+  struct rta *attrs;			/* Attributes of this route */
+  u32 id;				/* Table specific route id */
+  byte flags;				/* Flags (REF_...) */
+  byte pflags;				/* Protocol-specific flags */
+  btime lastmod;			/* Last modified */
+} rte;
+
+#define REF_COW		1		/* Copy this rte on write */
+#define REF_FILTERED	2		/* Route is rejected by import filter */
+#define REF_STALE	4		/* Route is stale in a refresh cycle */
+#define REF_DISCARD	8		/* Route is scheduled for discard */
+#define REF_MODIFY	16		/* Route is scheduled for modify */
+
+/* Route is valid for propagation (may depend on other flags in the future), accepts NULL */
+static inline int rte_is_valid(rte *r) { return r && !(r->flags & REF_FILTERED); }
+
+/* Route just has REF_FILTERED flag */
+static inline int rte_is_filtered(rte *r) { return !!(r->flags & REF_FILTERED); }
+
+struct rte_src {
+  struct rte_src *next;			/* Hash chain */
+  struct proto *proto;			/* Protocol the source is based on */
+  u32 private_id;			/* Private ID, assigned by the protocol */
+  u32 global_id;			/* Globally unique ID of the source */
+  unsigned uc;				/* Use count */
+};
+
+
+struct rte_src *rt_find_source(struct proto *p, u32 id);
+struct rte_src *rt_get_source(struct proto *p, u32 id);
+static inline void rt_lock_source(struct rte_src *src) { src->uc++; }
+static inline void rt_unlock_source(struct rte_src *src) { src->uc--; }
+void rt_prune_sources(void);
+
+/*
+ *	Route Attributes
+ *
+ *	Beware: All standard BGP attributes must be represented here instead
+ *	of making them local to the route. This is needed to ensure proper
+ *	construction of BGP route attribute lists.
+ */
+
+/* Nexthop structure */
+struct nexthop {
+  ip_addr gw;				/* Next hop */
+  struct iface *iface;			/* Outgoing interface */
+  struct nexthop *next;
+  byte flags;
+  byte weight;
+  byte labels_orig;			/* Number of labels before hostentry was applied */
+  byte labels;				/* Number of all labels */
+  u32 label[0];
+};
+
+#define RNF_ONLINK		0x1	/* Gateway is onlink regardless of IP ranges */
+
+
+typedef struct rta {
+  struct rta *next, **pprev;		/* Hash chain */
+  u32 uc;				/* Use count */
+  u32 hash_key;				/* Hash over important fields */
+  struct ea_list *eattrs;		/* Extended Attribute chain */
+  struct hostentry *hostentry;		/* Hostentry for recursive next-hops */
+  ip_addr from;				/* Advertising router */
+  u32 igp_metric;			/* IGP metric to next hop (for iBGP routes) */
+  u16 cached:1;				/* Are attributes cached? */
+  u16 source:7;				/* Route source (RTS_...) */
+  u16 scope:4;				/* Route scope (SCOPE_... -- see ip.h) */
+  u16 dest:4;				/* Route destination type (RTD_...) */
+  word pref;
+  struct nexthop nh;			/* Next hop */
+} rta;
+
+#define RTS_STATIC 1			/* Normal static route */
+#define RTS_INHERIT 2			/* Route inherited from kernel */
+#define RTS_DEVICE 3			/* Device route */
+#define RTS_STATIC_DEVICE 4		/* Static device route */
+#define RTS_REDIRECT 5			/* Learned via redirect */
+#define RTS_RIP 6			/* RIP route */
+#define RTS_OSPF 7			/* OSPF route */
+#define RTS_OSPF_IA 8			/* OSPF inter-area route */
+#define RTS_OSPF_EXT1 9			/* OSPF external route type 1 */
+#define RTS_OSPF_EXT2 10		/* OSPF external route type 2 */
+#define RTS_BGP 11			/* BGP route */
+#define RTS_PIPE 12			/* Inter-table wormhole */
+#define RTS_BABEL 13			/* Babel route */
+#define RTS_RPKI 14			/* Route Origin Authorization */
+#define RTS_PERF 15			/* Perf checker */
+#define RTS_MAX 16
+
+#define RTD_NONE 0			/* Undefined next hop */
+#define RTD_UNICAST 1			/* Next hop is neighbor router */
+#define RTD_BLACKHOLE 2			/* Silently drop packets */
+#define RTD_UNREACHABLE 3		/* Reject as unreachable */
+#define RTD_PROHIBIT 4			/* Administratively prohibited */
+#define RTD_MAX 5
+
+#define IGP_METRIC_UNKNOWN 0x80000000	/* Default igp_metric used when no other
+					   protocol-specific metric is availabe */
+
+
+extern const char * rta_dest_names[RTD_MAX];
+
+static inline const char *rta_dest_name(uint n)
+{ return (n < RTD_MAX) ? rta_dest_names[n] : "???"; }
+
+/* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
+static inline int rte_is_reachable(rte *r)
+{ return r->attrs->dest == RTD_UNICAST; }
+
+
+/*
+ *	Extended Route Attributes
+ */
+
+typedef struct eattr {
+  word id;				/* EA_CODE(PROTOCOL_..., protocol-dependent ID) */
+  byte flags;				/* Protocol-dependent flags */
+  byte type:5;				/* Attribute type */
+  byte originated:1;			/* The attribute has originated locally */
+  byte fresh:1;				/* An uncached attribute (e.g. modified in export filter) */
+  byte undef:1;				/* Explicitly undefined */
+
+  union bval u;
+} eattr;
+
+
+#define EA_CODE(proto,id) (((proto) << 8) | (id))
+#define EA_ID(ea) ((ea) & 0xff)
+#define EA_PROTO(ea) ((ea) >> 8)
+#define EA_CUSTOM(id) ((id) | EA_CUSTOM_BIT)
+#define EA_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT)
+#define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT)
+
+const char *ea_custom_name(uint ea);
+
+#define EA_GEN_IGP_METRIC EA_CODE(PROTOCOL_NONE, 0)
+
+#define EA_CODE_MASK 0xffff
+#define EA_CUSTOM_BIT 0x8000
+#define EA_ALLOW_UNDEF 0x10000		/* ea_find: allow EAF_TYPE_UNDEF */
+#define EA_BIT(n) ((n) << 24)		/* Used in bitfield accessors */
+#define EA_BIT_GET(ea) ((ea) >> 24)
+
+typedef struct adata {
+  uint length;				/* Length of data */
+  byte data[0];
+} adata;
+
+extern const adata null_adata;		/* adata of length 0 */
+
+static inline struct adata *
+lp_alloc_adata(struct linpool *pool, uint len)
+{
+  struct adata *ad = lp_alloc(pool, sizeof(struct adata) + len);
+  ad->length = len;
+  return ad;
+}
+
+static inline int adata_same(const struct adata *a, const struct adata *b)
+{ return (a->length == b->length && !memcmp(a->data, b->data, a->length)); }
+
+
+typedef struct ea_list {
+  struct ea_list *next;			/* In case we have an override list */
+  byte flags;				/* Flags: EALF_... */
+  byte rfu;
+  word count;				/* Number of attributes */
+  eattr attrs[0];			/* Attribute definitions themselves */
+} ea_list;
+
+#define EALF_SORTED 1			/* Attributes are sorted by code */
+#define EALF_BISECT 2			/* Use interval bisection for searching */
+#define EALF_CACHED 4			/* Attributes belonging to cached rta */
+
+struct ea_walk_state {
+  ea_list *eattrs;			/* Ccurrent ea_list, initially set by caller */
+  eattr *ea;				/* Current eattr, initially NULL */
+  u32 visited[4];			/* Bitfield, limiting max to 128 */
+};
+
+eattr *ea_find(ea_list *, unsigned ea);
+eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
+
+/**
+ * ea_get_int - fetch an integer attribute
+ * @e: attribute list
+ * @id: attribute ID
+ * @def: default value
+ *
+ * This function is a shortcut for retrieving a value of an integer attribute
+ * by calling ea_find() to find the attribute, extracting its value or returning
+ * a provided default if no such attribute is present.
+ */
+static inline u32
+ea_get_int(ea_list *e, unsigned id, u32 def)
+{
+  eattr *a = ea_find(e, id);
+  return a ? a->u.data : def;
+}
+
+void ea_dump(ea_list *);
+void ea_sort(ea_list *);		/* Sort entries in all sub-lists */
+unsigned ea_scan(ea_list *);		/* How many bytes do we need for merged ea_list */
+void ea_merge(ea_list *from, ea_list *to); /* Merge sub-lists to allocated buffer */
+int ea_same(ea_list *x, ea_list *y);	/* Test whether two ea_lists are identical */
+uint ea_hash(ea_list *e);	/* Calculate 16-bit hash value */
+ea_list *ea_append(ea_list *to, ea_list *what);
+void ea_format_bitfield(const struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max);
+
+#define ea_normalize(ea) do { \
+  if (ea->next) { \
+    ea_list *t = alloca(ea_scan(ea)); \
+    ea_merge(ea, t); \
+    ea = t; \
+  } \
+  ea_sort(ea); \
+  if (ea->count == 0) \
+    ea = NULL; \
+} while(0) \
+
+struct ea_one_attr_list {
+  ea_list l;
+  eattr a;
+};
+
+static inline eattr *
+ea_set_attr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, union bval val)
+{
+  struct ea_one_attr_list *ea = lp_alloc(pool, sizeof(*ea));
+  *ea = (struct ea_one_attr_list) {
+    .l.flags = EALF_SORTED,
+    .l.count = 1,
+    .l.next = *to,
+
+    .a.id = id,
+    .a.type = type,
+    .a.flags = flags,
+  };
+
+  ea->a.u = val;
+  *to = &ea->l;
+
+  return &ea->a;
+}
+
+static inline void
+ea_unset_attr(ea_list **to, struct linpool *pool, _Bool local, uint code)
+{
+  struct ea_one_attr_list *ea = lp_alloc(pool, sizeof(*ea));
+  *ea = (struct ea_one_attr_list) {
+    .l.flags = EALF_SORTED,
+    .l.count = 1,
+    .l.next = *to,
+    .a.id = code,
+    .a.fresh = local,
+    .a.originated = local,
+    .a.undef = 1,
+  };
+
+  *to = &ea->l;
+}
+
+static inline void
+ea_set_attr_u32(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, u32 data)
+{
+  union bval bv = { .data = data };
+  ea_set_attr(to, pool, id, flags, type, bv);
+}
+
+static inline void
+ea_set_attr_data(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, void *data, uint len)
+{
+  struct adata *a = lp_alloc_adata(pool, len);
+  memcpy(a->data, data, len);
+  union bval bv = { .ptr = a, };
+  ea_set_attr(to, pool, id, flags, type, bv);
+}
+
+
+#define NEXTHOP_MAX_SIZE (sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
+
+static inline size_t nexthop_size(const struct nexthop *nh)
+{ return sizeof(struct nexthop) + sizeof(u32)*nh->labels; }
+int nexthop__same(struct nexthop *x, struct nexthop *y); /* Compare multipath nexthops */
+static inline int nexthop_same(struct nexthop *x, struct nexthop *y)
+{ return (x == y) || nexthop__same(x, y); }
+struct nexthop *nexthop_merge(struct nexthop *x, struct nexthop *y, int rx, int ry, int max, linpool *lp);
+struct nexthop *nexthop_sort(struct nexthop *x);
+static inline void nexthop_link(struct rta *a, struct nexthop *from)
+{ memcpy(&a->nh, from, nexthop_size(from)); }
+void nexthop_insert(struct nexthop **n, struct nexthop *y);
+int nexthop_is_sorted(struct nexthop *x);
+
+void rta_init(void);
+static inline size_t rta_size(const rta *a) { return sizeof(rta) + sizeof(u32)*a->nh.labels; }
+#define RTA_MAX_SIZE (sizeof(rta) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
+rta *rta_lookup(rta *);			/* Get rta equivalent to this one, uc++ */
+static inline int rta_is_cached(rta *r) { return r->cached; }
+static inline rta *rta_clone(rta *r) { r->uc++; return r; }
+void rta__free(rta *r);
+static inline void rta_free(rta *r) { if (r && !--r->uc) rta__free(r); }
+rta *rta_do_cow(rta *o, linpool *lp);
+static inline rta * rta_cow(rta *r, linpool *lp) { return rta_is_cached(r) ? rta_do_cow(r, lp) : r; }
+void rta_dump(rta *);
+void rta_dump_all(void);
+void rta_show(struct cli *, rta *);
+
+u32 rt_get_igp_metric(rte *rt);
+
+#endif
diff --git a/nest/a-path.c b/nest/a-path.c
index badbc911..64504c93 100644
--- a/nest/a-path.c
+++ b/nest/a-path.c
@@ -8,7 +8,7 @@
  */
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 #include "lib/resource.h"
 #include "lib/unaligned.h"
diff --git a/nest/a-path_test.c b/nest/a-path_test.c
index e007a450..a6b4d3d8 100644
--- a/nest/a-path_test.c
+++ b/nest/a-path_test.c
@@ -9,7 +9,7 @@
 #include "test/birdtest.h"
 #include "test/bt-utils.h"
 
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 #include "lib/resource.h"
 
diff --git a/nest/a-set.c b/nest/a-set.c
index 71fbac94..93f6431e 100644
--- a/nest/a-set.c
+++ b/nest/a-set.c
@@ -10,7 +10,7 @@
 #include <stdlib.h>
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 #include "lib/resource.h"
 #include "lib/string.h"
diff --git a/nest/a-set_test.c b/nest/a-set_test.c
index 904e6764..daa6ab74 100644
--- a/nest/a-set_test.c
+++ b/nest/a-set_test.c
@@ -10,7 +10,7 @@
 #include "test/bt-utils.h"
 
 #include "lib/net.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 #include "lib/resource.h"
 
diff --git a/nest/attrs.h b/nest/attrs.h
index ef2b95e6..e0595846 100644
--- a/nest/attrs.h
+++ b/nest/attrs.h
@@ -11,7 +11,7 @@
 
 #include <stdint.h>
 #include "lib/unaligned.h"
-#include "nest/route.h"
+#include "lib/route.h"
 
 
 /* a-path.c */
diff --git a/nest/cmds.c b/nest/cmds.c
index 8481bf96..3e59cb6f 100644
--- a/nest/cmds.c
+++ b/nest/cmds.c
@@ -8,7 +8,7 @@
 
 #include "nest/bird.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "conf/conf.h"
 #include "nest/cmds.h"
diff --git a/nest/proto.c b/nest/proto.c
index c6bda73b..95c319db 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -16,7 +16,7 @@
 #include "lib/timer.h"
 #include "lib/string.h"
 #include "conf/conf.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/iface.h"
 #include "nest/cli.h"
 #include "filter/filter.h"
diff --git a/nest/protocol.h b/nest/protocol.h
index d0810a8f..7fb08992 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -12,7 +12,7 @@
 #include "lib/lists.h"
 #include "lib/resource.h"
 #include "lib/event.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "conf/conf.h"
 
 struct iface;
diff --git a/nest/route.h b/nest/route.h
deleted file mode 100644
index c6d30148..00000000
--- a/nest/route.h
+++ /dev/null
@@ -1,639 +0,0 @@
-/*
- *	BIRD Internet Routing Daemon -- Routing Table
- *
- *	(c) 1998--2000 Martin Mares <mj@ucw.cz>
- *
- *	Can be freely distributed and used under the terms of the GNU GPL.
- */
-
-#ifndef _BIRD_ROUTE_H_
-#define _BIRD_ROUTE_H_
-
-#include "lib/lists.h"
-#include "lib/bitmap.h"
-#include "lib/resource.h"
-#include "lib/net.h"
-#include "lib/type.h"
-#include "lib/fib.h"
-
-struct ea_list;
-struct protocol;
-struct proto;
-struct rte_src;
-struct symbol;
-struct timer;
-struct filter;
-struct f_trie;
-struct f_trie_walk_state;
-struct cli;
-
-/*
- *	Master Routing Tables. Generally speaking, each of them contains a FIB
- *	with each entry pointing to a list of route entries representing routes
- *	to given network (with the selected one at the head).
- *
- *	Each of the RTE's contains variable data (the preference and protocol-dependent
- *	metrics) and a pointer to a route attribute block common for many routes).
- *
- *	It's guaranteed that there is at most one RTE for every (prefix,proto) pair.
- */
-
-struct rtable_config {
-  node n;
-  char *name;
-  struct rtable *table;
-  struct proto_config *krt_attached;	/* Kernel syncer attached to this table */
-  uint addr_type;			/* Type of address data stored in table (NET_*) */
-  int gc_max_ops;			/* Maximum number of operations before GC is run */
-  int gc_min_time;			/* Minimum time between two consecutive GC runs */
-  byte sorted;				/* Routes of network are sorted according to rte_better() */
-  byte internal;			/* Internal table of a protocol */
-  byte trie_used;			/* Rtable has attached trie */
-  btime min_settle_time;		/* Minimum settle time for notifications */
-  btime max_settle_time;		/* Maximum settle time for notifications */
-};
-
-typedef struct rtable {
-  resource r;
-  node n;				/* Node in list of all tables */
-  pool *rp;				/* Resource pool to allocate everything from, including itself */
-  struct fib fib;
-  struct f_trie *trie;			/* Trie of prefixes defined in fib */
-  char *name;				/* Name of this table */
-  list channels;			/* List of attached channels (struct channel) */
-  uint addr_type;			/* Type of address data stored in table (NET_*) */
-  int pipe_busy;			/* Pipe loop detection */
-  int use_count;			/* Number of protocols using this table */
-  u32 rt_count;				/* Number of routes in the table */
-
-  byte internal;			/* Internal table of a protocol */
-
-  struct hmap id_map;
-  struct hostcache *hostcache;
-  struct rtable_config *config;		/* Configuration of this table */
-  struct config *deleted;		/* Table doesn't exist in current configuration,
-					 * delete as soon as use_count becomes 0 and remove
-					 * obstacle from this routing table.
-					 */
-  struct event *rt_event;		/* Routing table event */
-  btime last_rt_change;			/* Last time when route changed */
-  btime base_settle_time;		/* Start time of rtable settling interval */
-  btime gc_time;			/* Time of last GC */
-  int gc_counter;			/* Number of operations since last GC */
-  byte prune_state;			/* Table prune state, 1 -> scheduled, 2-> running */
-  byte prune_trie;			/* Prune prefix trie during next table prune */
-  byte hcu_scheduled;			/* Hostcache update is scheduled */
-  byte nhu_state;			/* Next Hop Update state */
-  struct fib_iterator prune_fit;	/* Rtable prune FIB iterator */
-  struct fib_iterator nhu_fit;		/* Next Hop Update FIB iterator */
-  struct f_trie *trie_new;		/* New prefix trie defined during pruning */
-  struct f_trie *trie_old;		/* Old prefix trie waiting to be freed */
-  u32 trie_lock_count;			/* Prefix trie locked by walks */
-  u32 trie_old_lock_count;		/* Old prefix trie locked by walks */
-
-  list subscribers;			/* Subscribers for notifications */
-  struct timer *settle_timer;		/* Settle time for notifications */
-  list flowspec_links;			/* List of flowspec links, src for NET_IPx and dst for NET_FLOWx */
-  struct f_trie *flowspec_trie;		/* Trie for evaluation of flowspec notifications */
-} rtable;
-
-struct rt_subscription {
-  node n;
-  rtable *tab;
-  void (*hook)(struct rt_subscription *b);
-  void *data;
-};
-
-struct rt_flowspec_link {
-  node n;
-  rtable *src;
-  rtable *dst;
-  u32 uc;
-};
-
-#define NHU_CLEAN	0
-#define NHU_SCHEDULED	1
-#define NHU_RUNNING	2
-#define NHU_DIRTY	3
-
-typedef struct network {
-  struct rte *routes;			/* Available routes for this network */
-  struct fib_node n;			/* FIB flags reserved for kernel syncer */
-} net;
-
-struct hostcache {
-  slab *slab;				/* Slab holding all hostentries */
-  struct hostentry **hash_table;	/* Hash table for hostentries */
-  unsigned hash_order, hash_shift;
-  unsigned hash_max, hash_min;
-  unsigned hash_items;
-  linpool *lp;				/* Linpool for trie */
-  struct f_trie *trie;			/* Trie of prefixes that might affect hostentries */
-  list hostentries;			/* List of all hostentries */
-  byte update_hostcache;
-};
-
-struct hostentry {
-  node ln;
-  ip_addr addr;				/* IP address of host, part of key */
-  ip_addr link;				/* (link-local) IP address of host, used as gw
-					   if host is directly attached */
-  struct rtable *tab;			/* Dependent table, part of key */
-  struct hostentry *next;		/* Next in hash chain */
-  unsigned hash_key;			/* Hash key */
-  unsigned uc;				/* Use count */
-  struct rta *src;			/* Source rta entry */
-  byte dest;				/* Chosen route destination type (RTD_...) */
-  byte nexthop_linkable;		/* Nexthop list is completely non-device */
-  u32 igp_metric;			/* Chosen route IGP metric */
-};
-
-typedef struct rte {
-  struct rte *next;
-  net *net;				/* Network this RTE belongs to */
-  struct rte_src *src;			/* Route source that created the route */
-  struct channel *sender;		/* Channel used to send the route to the routing table */
-  struct rta *attrs;			/* Attributes of this route */
-  u32 id;				/* Table specific route id */
-  byte flags;				/* Flags (REF_...) */
-  byte pflags;				/* Protocol-specific flags */
-  btime lastmod;			/* Last modified */
-} rte;
-
-#define REF_COW		1		/* Copy this rte on write */
-#define REF_FILTERED	2		/* Route is rejected by import filter */
-#define REF_STALE	4		/* Route is stale in a refresh cycle */
-#define REF_DISCARD	8		/* Route is scheduled for discard */
-#define REF_MODIFY	16		/* Route is scheduled for modify */
-
-/* Route is valid for propagation (may depend on other flags in the future), accepts NULL */
-static inline int rte_is_valid(rte *r) { return r && !(r->flags & REF_FILTERED); }
-
-/* Route just has REF_FILTERED flag */
-static inline int rte_is_filtered(rte *r) { return !!(r->flags & REF_FILTERED); }
-
-
-/* Types of route announcement, also used as flags */
-#define RA_UNDEF	0		/* Undefined RA type */
-#define RA_OPTIMAL	1		/* Announcement of optimal route change */
-#define RA_ACCEPTED	2		/* Announcement of first accepted route */
-#define RA_ANY		3		/* Announcement of any route change */
-#define RA_MERGED	4		/* Announcement of optimal route merged with next ones */
-
-/* Return value of preexport() callback */
-#define RIC_ACCEPT	1		/* Accepted by protocol */
-#define RIC_PROCESS	0		/* Process it through import filter */
-#define RIC_REJECT	-1		/* Rejected by protocol */
-#define RIC_DROP	-2		/* Silently dropped by protocol */
-
-extern list routing_tables;
-struct config;
-
-void rt_init(void);
-void rt_preconfig(struct config *);
-void rt_commit(struct config *new, struct config *old);
-void rt_lock_table(rtable *);
-void rt_unlock_table(rtable *);
-struct f_trie * rt_lock_trie(rtable *tab);
-void rt_unlock_trie(rtable *tab, struct f_trie *trie);
-void rt_subscribe(rtable *tab, struct rt_subscription *s);
-void rt_unsubscribe(struct rt_subscription *s);
-void rt_flowspec_link(rtable *src, rtable *dst);
-void rt_flowspec_unlink(rtable *src, rtable *dst);
-rtable *rt_setup(pool *, struct rtable_config *);
-static inline void rt_shutdown(rtable *r) { rfree(r->rp); }
-
-static inline net *net_find(rtable *tab, const net_addr *addr) { return (net *) fib_find(&tab->fib, addr); }
-static inline net *net_find_valid(rtable *tab, const net_addr *addr)
-{ net *n = net_find(tab, addr); return (n && rte_is_valid(n->routes)) ? n : NULL; }
-static inline net *net_get(rtable *tab, const net_addr *addr) { return (net *) fib_get(&tab->fib, addr); }
-net *net_get(rtable *tab, const net_addr *addr);
-net *net_route(rtable *tab, const net_addr *n);
-int net_roa_check(rtable *tab, const net_addr *n, u32 asn);
-rte *rte_find(net *net, struct rte_src *src);
-rte *rte_get_temp(struct rta *, struct rte_src *src);
-void rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
-/* rte_update() moved to protocol.h to avoid dependency conflicts */
-int rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter);
-rte *rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int silent);
-void rt_refresh_begin(rtable *t, struct channel *c);
-void rt_refresh_end(rtable *t, struct channel *c);
-void rt_modify_stale(rtable *t, struct channel *c);
-void rt_schedule_prune(rtable *t);
-void rte_dump(rte *);
-void rte_free(rte *);
-rte *rte_do_cow(rte *);
-static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
-rte *rte_cow_rta(rte *r, linpool *lp);
-void rt_dump(rtable *);
-void rt_dump_all(void);
-int rt_feed_channel(struct channel *c);
-void rt_feed_channel_abort(struct channel *c);
-int rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
-int rt_reload_channel(struct channel *c);
-void rt_reload_channel_abort(struct channel *c);
-void rt_prune_sync(rtable *t, int all);
-int rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old, rte **old_exported, int refeed);
-struct rtable_config *rt_new_table(struct symbol *s, uint addr_type);
-
-static inline int rt_is_ip(rtable *tab)
-{ return (tab->addr_type == NET_IP4) || (tab->addr_type == NET_IP6); }
-
-static inline int rt_is_vpn(rtable *tab)
-{ return (tab->addr_type == NET_VPN4) || (tab->addr_type == NET_VPN6); }
-
-static inline int rt_is_roa(rtable *tab)
-{ return (tab->addr_type == NET_ROA4) || (tab->addr_type == NET_ROA6); }
-
-static inline int rt_is_flow(rtable *tab)
-{ return (tab->addr_type == NET_FLOW4) || (tab->addr_type == NET_FLOW6); }
-
-
-/* Default limit for ECMP next hops, defined in sysdep code */
-extern const int rt_default_ecmp;
-
-struct rt_show_data_rtable {
-  node n;
-  rtable *table;
-  struct channel *export_channel;
-};
-
-struct rt_show_data {
-  net_addr *addr;
-  list tables;
-  struct rt_show_data_rtable *tab;	/* Iterator over table list */
-  struct rt_show_data_rtable *last_table; /* Last table in output */
-  struct fib_iterator fit;		/* Iterator over networks in table */
-  struct f_trie_walk_state *walk_state;	/* Iterator over networks in trie */
-  struct f_trie *walk_lock;		/* Locked trie for walking */
-  int verbose, tables_defined_by;
-  const struct filter *filter;
-  struct proto *show_protocol;
-  struct proto *export_protocol;
-  struct channel *export_channel;
-  struct config *running_on_config;
-  struct krt_proto *kernel;
-  int export_mode, addr_mode, primary_only, filtered, stats;
-
-  int table_open;			/* Iteration (fit) is open */
-  int trie_walk;			/* Current table is iterated using trie */
-  int net_counter, rt_counter, show_counter, table_counter;
-  int net_counter_last, rt_counter_last, show_counter_last;
-};
-
-void rt_show(struct rt_show_data *);
-struct rt_show_data_rtable * rt_show_add_table(struct rt_show_data *d, rtable *t);
-
-/* Value of table definition mode in struct rt_show_data */
-#define RSD_TDB_DEFAULT	  0		/* no table specified */
-#define RSD_TDB_INDIRECT  0		/* show route ... protocol P ... */
-#define RSD_TDB_ALL	  RSD_TDB_SET			/* show route ... table all ... */
-#define RSD_TDB_DIRECT	  RSD_TDB_SET | RSD_TDB_NMN	/* show route ... table X table Y ... */
-
-#define RSD_TDB_SET	  0x1		/* internal: show empty tables */
-#define RSD_TDB_NMN	  0x2		/* internal: need matching net */
-
-/* Value of addr_mode */
-#define RSD_ADDR_EQUAL	1		/* Exact query - show route <addr> */
-#define RSD_ADDR_FOR	2		/* Longest prefix match - show route for <addr> */
-#define RSD_ADDR_IN	3		/* Interval query - show route in <addr> */
-
-/* Value of export_mode in struct rt_show_data */
-#define RSEM_NONE	0		/* Export mode not used */
-#define RSEM_PREEXPORT	1		/* Routes ready for export, before filtering */
-#define RSEM_EXPORT	2		/* Routes accepted by export filter */
-#define RSEM_NOEXPORT	3		/* Routes rejected by export filter */
-#define RSEM_EXPORTED	4		/* Routes marked in export map */
-
-/*
- *	Route Attributes
- *
- *	Beware: All standard BGP attributes must be represented here instead
- *	of making them local to the route. This is needed to ensure proper
- *	construction of BGP route attribute lists.
- */
-
-/* Nexthop structure */
-struct nexthop {
-  ip_addr gw;				/* Next hop */
-  struct iface *iface;			/* Outgoing interface */
-  struct nexthop *next;
-  byte flags;
-  byte weight;
-  byte labels_orig;			/* Number of labels before hostentry was applied */
-  byte labels;				/* Number of all labels */
-  u32 label[0];
-};
-
-#define RNF_ONLINK		0x1	/* Gateway is onlink regardless of IP ranges */
-
-
-struct rte_src {
-  struct rte_src *next;			/* Hash chain */
-  struct proto *proto;			/* Protocol the source is based on */
-  u32 private_id;			/* Private ID, assigned by the protocol */
-  u32 global_id;			/* Globally unique ID of the source */
-  unsigned uc;				/* Use count */
-};
-
-
-typedef struct rta {
-  struct rta *next, **pprev;		/* Hash chain */
-  u32 uc;				/* Use count */
-  u32 hash_key;				/* Hash over important fields */
-  struct ea_list *eattrs;		/* Extended Attribute chain */
-  struct hostentry *hostentry;		/* Hostentry for recursive next-hops */
-  ip_addr from;				/* Advertising router */
-  u32 igp_metric;			/* IGP metric to next hop (for iBGP routes) */
-  u16 cached:1;				/* Are attributes cached? */
-  u16 source:7;				/* Route source (RTS_...) */
-  u16 scope:4;				/* Route scope (SCOPE_... -- see ip.h) */
-  u16 dest:4;				/* Route destination type (RTD_...) */
-  word pref;
-  struct nexthop nh;			/* Next hop */
-} rta;
-
-#define RTS_STATIC 1			/* Normal static route */
-#define RTS_INHERIT 2			/* Route inherited from kernel */
-#define RTS_DEVICE 3			/* Device route */
-#define RTS_STATIC_DEVICE 4		/* Static device route */
-#define RTS_REDIRECT 5			/* Learned via redirect */
-#define RTS_RIP 6			/* RIP route */
-#define RTS_OSPF 7			/* OSPF route */
-#define RTS_OSPF_IA 8			/* OSPF inter-area route */
-#define RTS_OSPF_EXT1 9			/* OSPF external route type 1 */
-#define RTS_OSPF_EXT2 10		/* OSPF external route type 2 */
-#define RTS_BGP 11			/* BGP route */
-#define RTS_PIPE 12			/* Inter-table wormhole */
-#define RTS_BABEL 13			/* Babel route */
-#define RTS_RPKI 14			/* Route Origin Authorization */
-#define RTS_PERF 15			/* Perf checker */
-#define RTS_MAX 16
-
-#define RTD_NONE 0			/* Undefined next hop */
-#define RTD_UNICAST 1			/* Next hop is neighbor router */
-#define RTD_BLACKHOLE 2			/* Silently drop packets */
-#define RTD_UNREACHABLE 3		/* Reject as unreachable */
-#define RTD_PROHIBIT 4			/* Administratively prohibited */
-#define RTD_MAX 5
-
-#define IGP_METRIC_UNKNOWN 0x80000000	/* Default igp_metric used when no other
-					   protocol-specific metric is availabe */
-
-
-extern const char * rta_dest_names[RTD_MAX];
-
-static inline const char *rta_dest_name(uint n)
-{ return (n < RTD_MAX) ? rta_dest_names[n] : "???"; }
-
-/* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
-static inline int rte_is_reachable(rte *r)
-{ return r->attrs->dest == RTD_UNICAST; }
-
-
-/*
- *	Extended Route Attributes
- */
-
-typedef struct eattr {
-  word id;				/* EA_CODE(PROTOCOL_..., protocol-dependent ID) */
-  byte flags;				/* Protocol-dependent flags */
-  byte type:5;				/* Attribute type */
-  byte originated:1;			/* The attribute has originated locally */
-  byte fresh:1;				/* An uncached attribute (e.g. modified in export filter) */
-  byte undef:1;				/* Explicitly undefined */
-
-  union bval u;
-} eattr;
-
-
-#define EA_CODE(proto,id) (((proto) << 8) | (id))
-#define EA_ID(ea) ((ea) & 0xff)
-#define EA_PROTO(ea) ((ea) >> 8)
-#define EA_CUSTOM(id) ((id) | EA_CUSTOM_BIT)
-#define EA_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT)
-#define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT)
-
-const char *ea_custom_name(uint ea);
-
-#define EA_GEN_IGP_METRIC EA_CODE(PROTOCOL_NONE, 0)
-
-#define EA_CODE_MASK 0xffff
-#define EA_CUSTOM_BIT 0x8000
-#define EA_ALLOW_UNDEF 0x10000		/* ea_find: allow EAF_TYPE_UNDEF */
-#define EA_BIT(n) ((n) << 24)		/* Used in bitfield accessors */
-#define EA_BIT_GET(ea) ((ea) >> 24)
-
-typedef struct adata {
-  uint length;				/* Length of data */
-  byte data[0];
-} adata;
-
-extern const adata null_adata;		/* adata of length 0 */
-
-static inline struct adata *
-lp_alloc_adata(struct linpool *pool, uint len)
-{
-  struct adata *ad = lp_alloc(pool, sizeof(struct adata) + len);
-  ad->length = len;
-  return ad;
-}
-
-static inline int adata_same(const struct adata *a, const struct adata *b)
-{ return (a->length == b->length && !memcmp(a->data, b->data, a->length)); }
-
-
-typedef struct ea_list {
-  struct ea_list *next;			/* In case we have an override list */
-  byte flags;				/* Flags: EALF_... */
-  byte rfu;
-  word count;				/* Number of attributes */
-  eattr attrs[0];			/* Attribute definitions themselves */
-} ea_list;
-
-#define EALF_SORTED 1			/* Attributes are sorted by code */
-#define EALF_BISECT 2			/* Use interval bisection for searching */
-#define EALF_CACHED 4			/* Attributes belonging to cached rta */
-
-struct rte_src *rt_find_source(struct proto *p, u32 id);
-struct rte_src *rt_get_source(struct proto *p, u32 id);
-static inline void rt_lock_source(struct rte_src *src) { src->uc++; }
-static inline void rt_unlock_source(struct rte_src *src) { src->uc--; }
-void rt_prune_sources(void);
-
-struct ea_walk_state {
-  ea_list *eattrs;			/* Ccurrent ea_list, initially set by caller */
-  eattr *ea;				/* Current eattr, initially NULL */
-  u32 visited[4];			/* Bitfield, limiting max to 128 */
-};
-
-eattr *ea_find(ea_list *, unsigned ea);
-eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
-u32 ea_get_int(ea_list *, unsigned ea, u32 def);
-void ea_dump(ea_list *);
-void ea_sort(ea_list *);		/* Sort entries in all sub-lists */
-unsigned ea_scan(ea_list *);		/* How many bytes do we need for merged ea_list */
-void ea_merge(ea_list *from, ea_list *to); /* Merge sub-lists to allocated buffer */
-int ea_same(ea_list *x, ea_list *y);	/* Test whether two ea_lists are identical */
-uint ea_hash(ea_list *e);	/* Calculate 16-bit hash value */
-ea_list *ea_append(ea_list *to, ea_list *what);
-void ea_format_bitfield(const struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max);
-
-#define ea_normalize(ea) do { \
-  if (ea->next) { \
-    ea_list *t = alloca(ea_scan(ea)); \
-    ea_merge(ea, t); \
-    ea = t; \
-  } \
-  ea_sort(ea); \
-  if (ea->count == 0) \
-    ea = NULL; \
-} while(0) \
-
-struct ea_one_attr_list {
-  ea_list l;
-  eattr a;
-};
-
-static inline eattr *
-ea_set_attr(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, union bval val)
-{
-  struct ea_one_attr_list *ea = lp_alloc(pool, sizeof(*ea));
-  *ea = (struct ea_one_attr_list) {
-    .l.flags = EALF_SORTED,
-    .l.count = 1,
-    .l.next = *to,
-
-    .a.id = id,
-    .a.type = type,
-    .a.flags = flags,
-  };
-
-  ea->a.u = val;
-  *to = &ea->l;
-
-  return &ea->a;
-}
-
-static inline void
-ea_unset_attr(ea_list **to, struct linpool *pool, _Bool local, uint code)
-{
-  struct ea_one_attr_list *ea = lp_alloc(pool, sizeof(*ea));
-  *ea = (struct ea_one_attr_list) {
-    .l.flags = EALF_SORTED,
-    .l.count = 1,
-    .l.next = *to,
-    .a.id = code,
-    .a.fresh = local,
-    .a.originated = local,
-    .a.undef = 1,
-  };
-
-  *to = &ea->l;
-}
-
-static inline void
-ea_set_attr_u32(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, u32 data)
-{
-  union bval bv = { .data = data };
-  ea_set_attr(to, pool, id, flags, type, bv);
-}
-
-static inline void
-ea_set_attr_data(ea_list **to, struct linpool *pool, uint id, uint flags, uint type, void *data, uint len)
-{
-  struct adata *a = lp_alloc_adata(pool, len);
-  memcpy(a->data, data, len);
-  union bval bv = { .ptr = a, };
-  ea_set_attr(to, pool, id, flags, type, bv);
-}
-
-
-#define NEXTHOP_MAX_SIZE (sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
-
-static inline size_t nexthop_size(const struct nexthop *nh)
-{ return sizeof(struct nexthop) + sizeof(u32)*nh->labels; }
-int nexthop__same(struct nexthop *x, struct nexthop *y); /* Compare multipath nexthops */
-static inline int nexthop_same(struct nexthop *x, struct nexthop *y)
-{ return (x == y) || nexthop__same(x, y); }
-struct nexthop *nexthop_merge(struct nexthop *x, struct nexthop *y, int rx, int ry, int max, linpool *lp);
-struct nexthop *nexthop_sort(struct nexthop *x);
-static inline void nexthop_link(struct rta *a, struct nexthop *from)
-{ memcpy(&a->nh, from, nexthop_size(from)); }
-void nexthop_insert(struct nexthop **n, struct nexthop *y);
-int nexthop_is_sorted(struct nexthop *x);
-
-void rta_init(void);
-static inline size_t rta_size(const rta *a) { return sizeof(rta) + sizeof(u32)*a->nh.labels; }
-#define RTA_MAX_SIZE (sizeof(rta) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
-rta *rta_lookup(rta *);			/* Get rta equivalent to this one, uc++ */
-static inline int rta_is_cached(rta *r) { return r->cached; }
-static inline rta *rta_clone(rta *r) { r->uc++; return r; }
-void rta__free(rta *r);
-static inline void rta_free(rta *r) { if (r && !--r->uc) rta__free(r); }
-rta *rta_do_cow(rta *o, linpool *lp);
-static inline rta * rta_cow(rta *r, linpool *lp) { return rta_is_cached(r) ? rta_do_cow(r, lp) : r; }
-void rta_dump(rta *);
-void rta_dump_all(void);
-void rta_show(struct cli *, rta *);
-
-u32 rt_get_igp_metric(rte *rt);
-struct hostentry * rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
-void rta_apply_hostentry(rta *a, struct hostentry *he, mpls_label_stack *mls);
-
-static inline void
-rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr gw, ip_addr ll, mpls_label_stack *mls)
-{
-  rta_apply_hostentry(a, rt_get_hostentry(tab, gw, ll, dep), mls);
-}
-
-/*
- * rta_set_recursive_next_hop() acquires hostentry from hostcache and fills
- * rta->hostentry field.  New hostentry has zero use count. Cached rta locks its
- * hostentry (increases its use count), uncached rta does not lock it. Hostentry
- * with zero use count is removed asynchronously during host cache update,
- * therefore it is safe to hold such hostentry temorarily. Hostentry holds a
- * lock for a 'source' rta, mainly to share multipath nexthops.
- *
- * There is no need to hold a lock for hostentry->dep table, because that table
- * contains routes responsible for that hostentry, and therefore is non-empty if
- * given hostentry has non-zero use count. If the hostentry has zero use count,
- * the entry is removed before dep is referenced.
- *
- * The protocol responsible for routes with recursive next hops should hold a
- * lock for a 'source' table governing that routes (argument tab to
- * rta_set_recursive_next_hop()), because its routes reference hostentries
- * (through rta) related to the governing table. When all such routes are
- * removed, rtas are immediately removed achieving zero uc. Then the 'source'
- * table lock could be immediately released, although hostentries may still
- * exist - they will be freed together with the 'source' table.
- */
-
-static inline void rt_lock_hostentry(struct hostentry *he) { if (he) he->uc++; }
-static inline void rt_unlock_hostentry(struct hostentry *he) { if (he) he->uc--; }
-
-int rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, int interior);
-
-
-/*
- *	Default protocol preferences
- */
-
-#define DEF_PREF_DIRECT		240	/* Directly connected */
-#define DEF_PREF_STATIC		200	/* Static route */
-#define DEF_PREF_OSPF		150	/* OSPF intra-area, inter-area and type 1 external routes */
-#define DEF_PREF_BABEL		130	/* Babel */
-#define DEF_PREF_RIP		120	/* RIP */
-#define DEF_PREF_BGP		100	/* BGP */
-#define DEF_PREF_RPKI		100	/* RPKI */
-#define DEF_PREF_INHERITED	10	/* Routes inherited from other routing daemons */
-
-/*
- *	Route Origin Authorization
- */
-
-#define ROA_UNKNOWN	0
-#define ROA_VALID	1
-#define ROA_INVALID	2
-
-#endif
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index de45dfa1..8f4319c5 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -45,7 +45,7 @@
  */
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "nest/cli.h"
@@ -529,25 +529,6 @@ ea_walk(struct ea_walk_state *s, uint id, uint max)
   return NULL;
 }
 
-/**
- * ea_get_int - fetch an integer attribute
- * @e: attribute list
- * @id: attribute ID
- * @def: default value
- *
- * This function is a shortcut for retrieving a value of an integer attribute
- * by calling ea_find() to find the attribute, extracting its value or returning
- * a provided default if no such attribute is present.
- */
-u32
-ea_get_int(ea_list *e, unsigned id, u32 def)
-{
-  eattr *a = ea_find(e, id);
-  if (!a)
-    return def;
-  return a->u.data;
-}
-
 static inline void
 ea_do_sort(ea_list *e)
 {
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index 05e64fc3..82533321 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -18,7 +18,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/rt-dev.h"
 #include "conf/conf.h"
 #include "lib/resource.h"
diff --git a/nest/rt-fib.c b/nest/rt-fib.c
index 43e3039d..801561da 100644
--- a/nest/rt-fib.c
+++ b/nest/rt-fib.c
@@ -55,7 +55,7 @@
 #undef LOCAL_DEBUG
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "lib/string.h"
 
 /*
diff --git a/nest/rt-show.c b/nest/rt-show.c
index 19877966..464e5f1b 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -10,7 +10,7 @@
 #undef LOCAL_DEBUG
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/cli.h"
 #include "nest/iface.h"
diff --git a/nest/rt-table.c b/nest/rt-table.c
index fbfdb1e6..031e462b 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -91,7 +91,7 @@
 #undef LOCAL_DEBUG
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "lib/resource.h"
diff --git a/nest/rt.h b/nest/rt.h
new file mode 100644
index 00000000..7451a261
--- /dev/null
+++ b/nest/rt.h
@@ -0,0 +1,343 @@
+/*
+ *	BIRD Internet Routing Daemon -- Routing Table
+ *
+ *	(c) 1998--2000 Martin Mares <mj@ucw.cz>
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL.
+ */
+
+#ifndef _BIRD_NEST_RT_H_
+#define _BIRD_NEST_RT_H_
+
+#include "lib/lists.h"
+#include "lib/bitmap.h"
+#include "lib/resource.h"
+#include "lib/net.h"
+#include "lib/type.h"
+#include "lib/fib.h"
+#include "lib/route.h"
+
+struct ea_list;
+struct protocol;
+struct proto;
+struct rte_src;
+struct symbol;
+struct timer;
+struct filter;
+struct f_trie;
+struct f_trie_walk_state;
+struct cli;
+
+/*
+ *	Master Routing Tables. Generally speaking, each of them contains a FIB
+ *	with each entry pointing to a list of route entries representing routes
+ *	to given network (with the selected one at the head).
+ *
+ *	Each of the RTE's contains variable data (the preference and protocol-dependent
+ *	metrics) and a pointer to a route attribute block common for many routes).
+ *
+ *	It's guaranteed that there is at most one RTE for every (prefix,proto) pair.
+ */
+
+struct rtable_config {
+  node n;
+  char *name;
+  struct rtable *table;
+  struct proto_config *krt_attached;	/* Kernel syncer attached to this table */
+  uint addr_type;			/* Type of address data stored in table (NET_*) */
+  int gc_max_ops;			/* Maximum number of operations before GC is run */
+  int gc_min_time;			/* Minimum time between two consecutive GC runs */
+  byte sorted;				/* Routes of network are sorted according to rte_better() */
+  byte internal;			/* Internal table of a protocol */
+  byte trie_used;			/* Rtable has attached trie */
+  btime min_settle_time;		/* Minimum settle time for notifications */
+  btime max_settle_time;		/* Maximum settle time for notifications */
+};
+
+typedef struct rtable {
+  resource r;
+  node n;				/* Node in list of all tables */
+  pool *rp;				/* Resource pool to allocate everything from, including itself */
+  struct fib fib;
+  struct f_trie *trie;			/* Trie of prefixes defined in fib */
+  char *name;				/* Name of this table */
+  list channels;			/* List of attached channels (struct channel) */
+  uint addr_type;			/* Type of address data stored in table (NET_*) */
+  int pipe_busy;			/* Pipe loop detection */
+  int use_count;			/* Number of protocols using this table */
+  u32 rt_count;				/* Number of routes in the table */
+
+  byte internal;			/* Internal table of a protocol */
+
+  struct hmap id_map;
+  struct hostcache *hostcache;
+  struct rtable_config *config;		/* Configuration of this table */
+  struct config *deleted;		/* Table doesn't exist in current configuration,
+					 * delete as soon as use_count becomes 0 and remove
+					 * obstacle from this routing table.
+					 */
+  struct event *rt_event;		/* Routing table event */
+  btime last_rt_change;			/* Last time when route changed */
+  btime base_settle_time;		/* Start time of rtable settling interval */
+  btime gc_time;			/* Time of last GC */
+  int gc_counter;			/* Number of operations since last GC */
+  byte prune_state;			/* Table prune state, 1 -> scheduled, 2-> running */
+  byte prune_trie;			/* Prune prefix trie during next table prune */
+  byte hcu_scheduled;			/* Hostcache update is scheduled */
+  byte nhu_state;			/* Next Hop Update state */
+  struct fib_iterator prune_fit;	/* Rtable prune FIB iterator */
+  struct fib_iterator nhu_fit;		/* Next Hop Update FIB iterator */
+  struct f_trie *trie_new;		/* New prefix trie defined during pruning */
+  struct f_trie *trie_old;		/* Old prefix trie waiting to be freed */
+  u32 trie_lock_count;			/* Prefix trie locked by walks */
+  u32 trie_old_lock_count;		/* Old prefix trie locked by walks */
+
+  list subscribers;			/* Subscribers for notifications */
+  struct timer *settle_timer;		/* Settle time for notifications */
+  list flowspec_links;			/* List of flowspec links, src for NET_IPx and dst for NET_FLOWx */
+  struct f_trie *flowspec_trie;		/* Trie for evaluation of flowspec notifications */
+} rtable;
+
+struct rt_subscription {
+  node n;
+  rtable *tab;
+  void (*hook)(struct rt_subscription *b);
+  void *data;
+};
+
+struct rt_flowspec_link {
+  node n;
+  rtable *src;
+  rtable *dst;
+  u32 uc;
+};
+
+#define NHU_CLEAN	0
+#define NHU_SCHEDULED	1
+#define NHU_RUNNING	2
+#define NHU_DIRTY	3
+
+typedef struct network {
+  struct rte *routes;			/* Available routes for this network */
+  struct fib_node n;			/* FIB flags reserved for kernel syncer */
+} net;
+
+struct hostcache {
+  slab *slab;				/* Slab holding all hostentries */
+  struct hostentry **hash_table;	/* Hash table for hostentries */
+  unsigned hash_order, hash_shift;
+  unsigned hash_max, hash_min;
+  unsigned hash_items;
+  linpool *lp;				/* Linpool for trie */
+  struct f_trie *trie;			/* Trie of prefixes that might affect hostentries */
+  list hostentries;			/* List of all hostentries */
+  byte update_hostcache;
+};
+
+struct hostentry {
+  node ln;
+  ip_addr addr;				/* IP address of host, part of key */
+  ip_addr link;				/* (link-local) IP address of host, used as gw
+					   if host is directly attached */
+  struct rtable *tab;			/* Dependent table, part of key */
+  struct hostentry *next;		/* Next in hash chain */
+  unsigned hash_key;			/* Hash key */
+  unsigned uc;				/* Use count */
+  struct rta *src;			/* Source rta entry */
+  byte dest;				/* Chosen route destination type (RTD_...) */
+  byte nexthop_linkable;		/* Nexthop list is completely non-device */
+  u32 igp_metric;			/* Chosen route IGP metric */
+};
+
+/* Types of route announcement, also used as flags */
+#define RA_UNDEF	0		/* Undefined RA type */
+#define RA_OPTIMAL	1		/* Announcement of optimal route change */
+#define RA_ACCEPTED	2		/* Announcement of first accepted route */
+#define RA_ANY		3		/* Announcement of any route change */
+#define RA_MERGED	4		/* Announcement of optimal route merged with next ones */
+
+/* Return value of preexport() callback */
+#define RIC_ACCEPT	1		/* Accepted by protocol */
+#define RIC_PROCESS	0		/* Process it through import filter */
+#define RIC_REJECT	-1		/* Rejected by protocol */
+#define RIC_DROP	-2		/* Silently dropped by protocol */
+
+extern list routing_tables;
+struct config;
+
+void rt_init(void);
+void rt_preconfig(struct config *);
+void rt_commit(struct config *new, struct config *old);
+void rt_lock_table(rtable *);
+void rt_unlock_table(rtable *);
+struct f_trie * rt_lock_trie(rtable *tab);
+void rt_unlock_trie(rtable *tab, struct f_trie *trie);
+void rt_subscribe(rtable *tab, struct rt_subscription *s);
+void rt_unsubscribe(struct rt_subscription *s);
+void rt_flowspec_link(rtable *src, rtable *dst);
+void rt_flowspec_unlink(rtable *src, rtable *dst);
+rtable *rt_setup(pool *, struct rtable_config *);
+static inline void rt_shutdown(rtable *r) { rfree(r->rp); }
+
+static inline net *net_find(rtable *tab, const net_addr *addr) { return (net *) fib_find(&tab->fib, addr); }
+static inline net *net_find_valid(rtable *tab, const net_addr *addr)
+{ net *n = net_find(tab, addr); return (n && rte_is_valid(n->routes)) ? n : NULL; }
+static inline net *net_get(rtable *tab, const net_addr *addr) { return (net *) fib_get(&tab->fib, addr); }
+net *net_get(rtable *tab, const net_addr *addr);
+net *net_route(rtable *tab, const net_addr *n);
+rte *rte_find(net *net, struct rte_src *src);
+rte *rte_get_temp(struct rta *, struct rte_src *src);
+void rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
+/* rte_update() moved to protocol.h to avoid dependency conflicts */
+int rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter);
+rte *rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int silent);
+void rt_refresh_begin(rtable *t, struct channel *c);
+void rt_refresh_end(rtable *t, struct channel *c);
+void rt_modify_stale(rtable *t, struct channel *c);
+void rt_schedule_prune(rtable *t);
+void rte_dump(rte *);
+void rte_free(rte *);
+rte *rte_do_cow(rte *);
+static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
+rte *rte_cow_rta(rte *r, linpool *lp);
+void rt_dump(rtable *);
+void rt_dump_all(void);
+int rt_feed_channel(struct channel *c);
+void rt_feed_channel_abort(struct channel *c);
+int rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
+int rt_reload_channel(struct channel *c);
+void rt_reload_channel_abort(struct channel *c);
+void rt_prune_sync(rtable *t, int all);
+int rte_update_out(struct channel *c, const net_addr *n, rte *new, rte *old, rte **old_exported, int refeed);
+struct rtable_config *rt_new_table(struct symbol *s, uint addr_type);
+
+static inline int rt_is_ip(rtable *tab)
+{ return (tab->addr_type == NET_IP4) || (tab->addr_type == NET_IP6); }
+
+static inline int rt_is_vpn(rtable *tab)
+{ return (tab->addr_type == NET_VPN4) || (tab->addr_type == NET_VPN6); }
+
+static inline int rt_is_roa(rtable *tab)
+{ return (tab->addr_type == NET_ROA4) || (tab->addr_type == NET_ROA6); }
+
+static inline int rt_is_flow(rtable *tab)
+{ return (tab->addr_type == NET_FLOW4) || (tab->addr_type == NET_FLOW6); }
+
+
+/* Default limit for ECMP next hops, defined in sysdep code */
+extern const int rt_default_ecmp;
+
+struct rt_show_data_rtable {
+  node n;
+  rtable *table;
+  struct channel *export_channel;
+};
+
+struct rt_show_data {
+  net_addr *addr;
+  list tables;
+  struct rt_show_data_rtable *tab;	/* Iterator over table list */
+  struct rt_show_data_rtable *last_table; /* Last table in output */
+  struct fib_iterator fit;		/* Iterator over networks in table */
+  struct f_trie_walk_state *walk_state;	/* Iterator over networks in trie */
+  struct f_trie *walk_lock;		/* Locked trie for walking */
+  int verbose, tables_defined_by;
+  const struct filter *filter;
+  struct proto *show_protocol;
+  struct proto *export_protocol;
+  struct channel *export_channel;
+  struct config *running_on_config;
+  struct krt_proto *kernel;
+  int export_mode, addr_mode, primary_only, filtered, stats;
+
+  int table_open;			/* Iteration (fit) is open */
+  int trie_walk;			/* Current table is iterated using trie */
+  int net_counter, rt_counter, show_counter, table_counter;
+  int net_counter_last, rt_counter_last, show_counter_last;
+};
+
+void rt_show(struct rt_show_data *);
+struct rt_show_data_rtable * rt_show_add_table(struct rt_show_data *d, rtable *t);
+
+/* Value of table definition mode in struct rt_show_data */
+#define RSD_TDB_DEFAULT	  0		/* no table specified */
+#define RSD_TDB_INDIRECT  0		/* show route ... protocol P ... */
+#define RSD_TDB_ALL	  RSD_TDB_SET			/* show route ... table all ... */
+#define RSD_TDB_DIRECT	  RSD_TDB_SET | RSD_TDB_NMN	/* show route ... table X table Y ... */
+
+#define RSD_TDB_SET	  0x1		/* internal: show empty tables */
+#define RSD_TDB_NMN	  0x2		/* internal: need matching net */
+
+/* Value of addr_mode */
+#define RSD_ADDR_EQUAL	1		/* Exact query - show route <addr> */
+#define RSD_ADDR_FOR	2		/* Longest prefix match - show route for <addr> */
+#define RSD_ADDR_IN	3		/* Interval query - show route in <addr> */
+
+/* Value of export_mode in struct rt_show_data */
+#define RSEM_NONE	0		/* Export mode not used */
+#define RSEM_PREEXPORT	1		/* Routes ready for export, before filtering */
+#define RSEM_EXPORT	2		/* Routes accepted by export filter */
+#define RSEM_NOEXPORT	3		/* Routes rejected by export filter */
+#define RSEM_EXPORTED	4		/* Routes marked in export map */
+
+struct hostentry * rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
+void rta_apply_hostentry(rta *a, struct hostentry *he, mpls_label_stack *mls);
+
+static inline void
+rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr gw, ip_addr ll, mpls_label_stack *mls)
+{
+  rta_apply_hostentry(a, rt_get_hostentry(tab, gw, ll, dep), mls);
+}
+
+/*
+ * rta_set_recursive_next_hop() acquires hostentry from hostcache and fills
+ * rta->hostentry field.  New hostentry has zero use count. Cached rta locks its
+ * hostentry (increases its use count), uncached rta does not lock it. Hostentry
+ * with zero use count is removed asynchronously during host cache update,
+ * therefore it is safe to hold such hostentry temorarily. Hostentry holds a
+ * lock for a 'source' rta, mainly to share multipath nexthops.
+ *
+ * There is no need to hold a lock for hostentry->dep table, because that table
+ * contains routes responsible for that hostentry, and therefore is non-empty if
+ * given hostentry has non-zero use count. If the hostentry has zero use count,
+ * the entry is removed before dep is referenced.
+ *
+ * The protocol responsible for routes with recursive next hops should hold a
+ * lock for a 'source' table governing that routes (argument tab to
+ * rta_set_recursive_next_hop()), because its routes reference hostentries
+ * (through rta) related to the governing table. When all such routes are
+ * removed, rtas are immediately removed achieving zero uc. Then the 'source'
+ * table lock could be immediately released, although hostentries may still
+ * exist - they will be freed together with the 'source' table.
+ */
+
+static inline void rt_lock_hostentry(struct hostentry *he) { if (he) he->uc++; }
+static inline void rt_unlock_hostentry(struct hostentry *he) { if (he) he->uc--; }
+
+int rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, int interior);
+
+
+/*
+ *	Default protocol preferences
+ */
+
+#define DEF_PREF_DIRECT		240	/* Directly connected */
+#define DEF_PREF_STATIC		200	/* Static route */
+#define DEF_PREF_OSPF		150	/* OSPF intra-area, inter-area and type 1 external routes */
+#define DEF_PREF_BABEL		130	/* Babel */
+#define DEF_PREF_RIP		120	/* RIP */
+#define DEF_PREF_BGP		100	/* BGP */
+#define DEF_PREF_RPKI		100	/* RPKI */
+#define DEF_PREF_INHERITED	10	/* Routes inherited from other routing daemons */
+
+/*
+ *	Route Origin Authorization
+ */
+
+#define ROA_UNKNOWN	0
+#define ROA_VALID	1
+#define ROA_INVALID	2
+
+int net_roa_check(rtable *tab, const net_addr *n, u32 asn);
+
+#endif
diff --git a/proto/babel/babel.h b/proto/babel/babel.h
index 8b6da3c8..00814641 100644
--- a/proto/babel/babel.h
+++ b/proto/babel/babel.h
@@ -16,7 +16,7 @@
 #include "nest/bird.h"
 #include "nest/cli.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/locks.h"
 #include "nest/password.h"
diff --git a/proto/bfd/bfd.h b/proto/bfd/bfd.h
index 91fdaa60..bbccd0b8 100644
--- a/proto/bfd/bfd.h
+++ b/proto/bfd/bfd.h
@@ -13,7 +13,7 @@
 #include "nest/cli.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/password.h"
 #include "conf/conf.h"
 #include "lib/hash.h"
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 1bae942d..3265cb5e 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -15,7 +15,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 #include "conf/conf.h"
 #include "lib/resource.h"
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index 8c97f7b3..aec78a45 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -114,7 +114,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "nest/locks.h"
 #include "conf/conf.h"
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 6f209595..d09a5c8f 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -14,7 +14,7 @@
 #include <stdint.h>
 #include <setjmp.h>
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/bfd.h"
 //#include "lib/lists.h"
 #include "lib/hash.h"
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index a805cdf0..5def0f27 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -15,7 +15,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/attrs.h"
 #include "proto/mrt/mrt.h"
 #include "conf/conf.h"
diff --git a/proto/mrt/mrt.h b/proto/mrt/mrt.h
index 4ff94c12..3b83aa39 100644
--- a/proto/mrt/mrt.h
+++ b/proto/mrt/mrt.h
@@ -13,7 +13,7 @@
 #include "nest/bird.h"
 #include "nest/protocol.h"
 #include "lib/lists.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "lib/event.h"
 #include "lib/hash.h"
 
diff --git a/proto/ospf/ospf.h b/proto/ospf/ospf.h
index 3e704ae8..3d0d57d9 100644
--- a/proto/ospf/ospf.h
+++ b/proto/ospf/ospf.h
@@ -22,7 +22,7 @@
 #include "lib/resource.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "nest/locks.h"
 #include "nest/bfd.h"
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index 5d228045..dde7e473 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -18,7 +18,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "conf/conf.h"
 #include "filter/filter.h"
diff --git a/proto/pipe/pipe.c b/proto/pipe/pipe.c
index c3457135..483ece67 100644
--- a/proto/pipe/pipe.c
+++ b/proto/pipe/pipe.c
@@ -35,7 +35,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "conf/conf.h"
 #include "filter/filter.h"
diff --git a/proto/radv/radv.h b/proto/radv/radv.h
index 14d40f8a..5cca3aca 100644
--- a/proto/radv/radv.h
+++ b/proto/radv/radv.h
@@ -19,7 +19,7 @@
 #include "lib/resource.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "nest/locks.h"
 #include "conf/conf.h"
diff --git a/proto/rip/rip.h b/proto/rip/rip.h
index f8713c4a..a6fa3326 100644
--- a/proto/rip/rip.h
+++ b/proto/rip/rip.h
@@ -16,7 +16,7 @@
 #include "nest/cli.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/password.h"
 #include "nest/locks.h"
 #include "nest/bfd.h"
diff --git a/proto/rpki/rpki.h b/proto/rpki/rpki.h
index 8a5c38fd..26fbb46e 100644
--- a/proto/rpki/rpki.h
+++ b/proto/rpki/rpki.h
@@ -13,7 +13,7 @@
 #define _BIRD_RPKI_H_
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "lib/socket.h"
 #include "lib/ip.h"
diff --git a/proto/static/static.c b/proto/static/static.c
index cd31afd3..3a0d9257 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -38,7 +38,7 @@
 #include "nest/bird.h"
 #include "nest/iface.h"
 #include "nest/protocol.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/cli.h"
 #include "conf/conf.h"
 #include "filter/filter.h"
diff --git a/proto/static/static.h b/proto/static/static.h
index fc91f71c..d99f7ebd 100644
--- a/proto/static/static.h
+++ b/proto/static/static.h
@@ -9,7 +9,7 @@
 #ifndef _BIRD_STATIC_H_
 #define _BIRD_STATIC_H_
 
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/bfd.h"
 #include "lib/buffer.h"
 
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index 3b1d2299..cd449d11 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -25,7 +25,7 @@
 
 #include "nest/bird.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "sysdep/unix/unix.h"
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index eb4be711..a37692d6 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -17,7 +17,7 @@
 #undef LOCAL_DEBUG
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "lib/alloca.h"
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index bfd69b73..671e91fe 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -53,7 +53,7 @@
 
 #include "nest/bird.h"
 #include "nest/iface.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "filter/filter.h"
 #include "conf/conf.h"
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 71749324..9bb37e5d 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -30,7 +30,7 @@
 #include "lib/event.h"
 #include "lib/timer.h"
 #include "lib/string.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 #include "nest/iface.h"
 #include "nest/cli.h"
diff --git a/test/bt-utils.c b/test/bt-utils.c
index 8496e185..ce9a49d7 100644
--- a/test/bt-utils.c
+++ b/test/bt-utils.c
@@ -14,7 +14,7 @@
 #include "test/bt-utils.h"
 
 #include "nest/bird.h"
-#include "nest/route.h"
+#include "nest/rt.h"
 #include "nest/protocol.h"
 
 #include "sysdep/unix/unix.h"
-- 
cgit v1.2.3


From cf07d8ad79273a3bbf0617c17e438602e4b64ece Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 14 Apr 2022 18:32:19 +0200
Subject: Replaced boilerplate eattr allocation by ea_set_attr()

---
 filter/f-inst.c        | 26 +++++---------
 lib/route.h            | 13 +++----
 sysdep/bsd/krt-sock.c  | 11 ++----
 sysdep/linux/netlink.c | 92 +++++++++++++-------------------------------------
 4 files changed, 40 insertions(+), 102 deletions(-)

(limited to 'sysdep/linux')

diff --git a/filter/f-inst.c b/filter/f-inst.c
index 0d042e37..7b34ef91 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -696,21 +696,13 @@
     DYNAMIC_ATTR;
     ARG_TYPE(1, da.type);
     {
-      struct ea_list *l = tmp_alloc(sizeof(struct ea_list) + sizeof(eattr));
-
-      l->next = NULL;
-      l->flags = EALF_SORTED;
-      l->count = 1;
-      l->attrs[0].id = da.ea_code;
-      l->attrs[0].flags = 0;
-      l->attrs[0].type = da.type;
-      l->attrs[0].originated = 1;
-      l->attrs[0].fresh = 1;
-      l->attrs[0].undef = 0;
+      struct eattr *a;
 
       if (da.type >= EAF_TYPE__MAX)
 	bug("Unsupported attribute type");
 
+      f_rta_cow(fs);
+
       switch (da.type) {
       case T_OPAQUE:
       case T_IFACE:
@@ -718,18 +710,18 @@
 	break;
 
       case T_IP:
-	l->attrs[0].u.ptr = tmp_store_adata(&v1.val.ip, sizeof(ip_addr));
+	a = ea_set_attr(fs->eattrs,
+	    EA_LITERAL_STORE_ADATA(da.ea_code, da.type, 0, &v1.val.ip, sizeof(ip_addr)));
 	break;
 
       default:
-	l->attrs[0].u = v1.val.bval;
+	a = ea_set_attr(fs->eattrs,
+	    EA_LITERAL_GENERIC(da.ea_code, da.type, 0, .u = v1.val.bval));
 	break;
-
       }
 
-      f_rta_cow(fs);
-      l->next = *fs->eattrs;
-      *fs->eattrs = l;
+      a->originated = 1;
+      a->fresh = 1;
     }
   }
 
diff --git a/lib/route.h b/lib/route.h
index ba7bab61..ad3f3fb7 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -217,10 +217,7 @@ ea_list *ea_normalize(const ea_list *e);
 uint ea_list_size(ea_list *);
 void ea_list_copy(ea_list *dest, ea_list *src, uint size);
 
-struct ea_one_attr_list {
-  ea_list l;
-  eattr a;
-};
+#define EA_LOCAL_LIST(N)  struct { ea_list l; eattr a[N]; }
 
 #define EA_LITERAL_EMBEDDED(_id, _type, _flags, _val) ({ \
     ASSERT_DIE(_type & EAF_EMBEDDED); \
@@ -243,16 +240,16 @@ struct ea_one_attr_list {
 static inline eattr *
 ea_set_attr(ea_list **to, eattr a)
 {
-  struct ea_one_attr_list *ea = tmp_alloc(sizeof(*ea));
-  *ea = (struct ea_one_attr_list) {
+  EA_LOCAL_LIST(1) *ea = tmp_alloc(sizeof(*ea));
+  *ea = (typeof(*ea)) {
     .l.flags = EALF_SORTED,
     .l.count = 1,
     .l.next = *to,
-    .a = a,
+    .a[0] = a,
   };
 
   *to = &ea->l;
-  return &ea->a;
+  return &ea->a[0];
 }
 
 static inline void
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index cd449d11..844b9f83 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -583,15 +583,8 @@ krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
   e = rte_get_temp(&a);
   e->net = net;
 
-  ea_list *ea = alloca(sizeof(ea_list) + 1 * sizeof(eattr));
-  *ea = (ea_list) { .count = 1, .next = e->attrs->eattrs };
-  e->attrs->eattrs = ea;
-
-  ea->attrs[0] = (eattr) {
-    .id = EA_KRT_SOURCE,
-    .type = T_INT,
-    .u.data = src2,
-  };
+  ea_set_attr(e->attrs->eattrs,
+      EA_LITERAL_EMBEDDED(EA_KRT_SOURCE, T_INT, 0, src2));
 
   if (scan)
     krt_got_route(p, e, src);
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index a37692d6..81e02b4c 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1581,21 +1581,22 @@ nl_announce_route(struct nl_parse_state *s)
   rte *e = rte_get_temp(s->attrs, s->proto->p.main_source);
   e->net = s->net;
 
-  ea_list *ea = alloca(sizeof(ea_list) + 2 * sizeof(eattr));
-  *ea = (ea_list) { .count = 2, .next = e->attrs->eattrs };
-  e->attrs->eattrs = ea;
-
-  ea->attrs[0] = (eattr) {
-    .id = EA_KRT_SOURCE,
-    .type = T_INT,
-    .u.data = s->krt_proto,
-  };
-  ea->attrs[1] = (eattr) {
-    .id = EA_KRT_METRIC,
-    .type = T_INT,
-    .u.data = s->krt_metric,
+  EA_LOCAL_LIST(2) ea0 = {
+    .l = { .count = 2, .next = e->attrs->eattrs },
+    .a[0] = (eattr) {
+      .id = EA_KRT_SOURCE,
+      .type = T_INT,
+      .u.data = s->krt_proto,
+    },
+    .a[1] = (eattr) {
+      .id = EA_KRT_METRIC,
+      .type = T_INT,
+      .u.data = s->krt_metric,
+    },
   };
 
+  e->attrs->eattrs = &ea0.l;
+
   if (s->scan)
     krt_got_route(s->proto, e, s->krt_src);
   else
@@ -1865,81 +1866,36 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 #endif
 
   if (i->rtm_scope != def_scope)
-    {
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_SCOPE;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = T_INT;
-      ea->attrs[0].u.data = i->rtm_scope;
-    }
+    ea_set_attr(&ra->eattrs,
+	EA_LITERAL_EMBEDDED(EA_KRT_SCOPE, T_INT, 0, i->rtm_scope));
 
   if (a[RTA_PREFSRC])
     {
       ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);
 
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_PREFSRC;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = T_IP;
-
-      struct adata *ad = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
-      ad->length = sizeof(ps);
-      memcpy(ad->data, &ps, sizeof(ps));
-
-      ea->attrs[0].u.ptr = ad;
+      ea_set_attr(&ra->eattrs,
+	  EA_LITERAL_STORE_ADATA(EA_KRT_PREFSRC, T_IP, 0, &ps, sizeof(ps)));
     }
 
   /* Can be set per-route or per-nexthop */
   if (s->rta_flow)
-    {
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
-      ea->next = ra->eattrs;
-      ra->eattrs = ea;
-      ea->flags = EALF_SORTED;
-      ea->count = 1;
-      ea->attrs[0].id = EA_KRT_REALM;
-      ea->attrs[0].flags = 0;
-      ea->attrs[0].type = T_INT;
-      ea->attrs[0].u.data = s->rta_flow;
-    }
+    ea_set_attr(&ra->eattrs,
+	EA_LITERAL_EMBEDDED(EA_KRT_REALM, T_INT, 0, s->rta_flow));
 
   if (a[RTA_METRICS])
     {
       u32 metrics[KRT_METRICS_MAX];
-      ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
-      int t, n = 0;
-
       if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
         {
 	  log(L_ERR "KRT: Received route %N with strange RTA_METRICS attribute", net->n.addr);
 	  return;
 	}
 
-      for (t = 1; t < KRT_METRICS_MAX; t++)
+      for (int t = 1; t < KRT_METRICS_MAX; t++)
 	if (metrics[0] & (1 << t))
-	  {
-	    ea->attrs[n].id = EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t);
-	    ea->attrs[n].flags = 0;
-	    ea->attrs[n].type = T_INT;
-	    ea->attrs[n].u.data = metrics[t];
-	    n++;
-	  }
-
-      if (n > 0)
-        {
-	  ea->next = ra->eattrs;
-	  ea->flags = EALF_SORTED;
-	  ea->count = n;
-	  ra->eattrs = ea;
-	}
+	  ea_set_attr(&ra->eattrs,
+	      EA_LITERAL_EMBEDDED(EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t),
+		T_INT, 0, metrics[t]));
     }
 
   /*
-- 
cgit v1.2.3


From 17f91f9e6e70f7e3f29502e854823c0d48571eaa Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Sat, 19 Mar 2022 16:23:42 +0100
Subject: Explicit definition structures of route attributes

Changes in internal API:

* Every route attribute must be defined as struct ea_class somewhere.
* Registration of route attributes known at startup must be done by
  ea_register_init() from protocol build functions.
* Every attribute has now its symbol registered in a global symbol table
  defined as SYM_ATTRIBUTE
* All attribute ID's are dynamically allocated.
* Attribute value custom formatting hook is defined in the ea_class.
* Attribute names are the same for display and filters, always prefixed
  by protocol name.

Also added some unit testing code for filters with route attributes.
---
 conf/cf-lex.l          |  54 ++++++++-
 conf/conf.h            |   2 +-
 conf/confbase.Y        |   3 +-
 filter/config.Y        |  88 +++++++++-----
 filter/data.h          |  10 +-
 filter/decl.m4         |   4 +-
 filter/f-inst.c        |  20 ++--
 filter/f-inst.h        |  12 +-
 filter/f-util.c        | 128 +-------------------
 filter/filter.h        |   9 --
 filter/test.conf       | 151 +++++++++++++++++++++++-
 lib/event_test.c       |   2 +-
 lib/mempool.c          |   2 -
 lib/resource.c         |  19 +++
 lib/resource.h         |  13 ++-
 lib/route.h            | 108 ++++++++++-------
 nest/config.Y          |   5 +-
 nest/proto.c           |   4 -
 nest/protocol.h        |  26 +----
 nest/rt-attr.c         | 221 ++++++++++++++++++++++++++---------
 nest/rt-dev.c          |   1 -
 nest/rt-table.c        |  10 +-
 proto/babel/babel.c    |  76 ++++++------
 proto/babel/babel.h    |   4 -
 proto/babel/config.Y   |   2 -
 proto/bfd/bfd.c        |   1 -
 proto/bgp/attrs.c      | 308 +++++++++++++++++++++++++------------------------
 proto/bgp/bgp.c        |   3 +-
 proto/bgp/bgp.h        |  54 ++++-----
 proto/bgp/config.Y     |  30 -----
 proto/mrt/mrt.c        |   1 -
 proto/ospf/config.Y    |   5 -
 proto/ospf/ospf.c      |  71 +++++++-----
 proto/ospf/ospf.h      |   7 +-
 proto/ospf/rt.c        |   8 +-
 proto/ospf/topology.c  |   6 +-
 proto/perf/perf.c      |   1 -
 proto/pipe/pipe.c      |   1 -
 proto/radv/config.Y    |   3 -
 proto/radv/radv.c      |  42 ++++---
 proto/radv/radv.h      |   4 -
 proto/rip/config.Y     |   3 -
 proto/rip/rip.c        |  65 ++++++-----
 proto/rip/rip.h        |   4 -
 proto/rpki/rpki.c      |   1 -
 proto/static/static.c  |  11 +-
 sysdep/linux/krt-sys.h |  32 -----
 sysdep/linux/netlink.Y |  45 +++-----
 sysdep/linux/netlink.c | 197 ++++++++++++++++++-------------
 sysdep/unix/krt.Y      |   3 -
 sysdep/unix/krt.c      |  35 +++---
 sysdep/unix/krt.h      |   4 +
 sysdep/unix/main.c     |   2 +-
 test/bt-utils.c        |   5 +-
 54 files changed, 1052 insertions(+), 874 deletions(-)

(limited to 'sysdep/linux')

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index bd424c69..e84e1d9d 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -86,9 +86,12 @@ static uint cf_hash(const byte *c);
 HASH_DEFINE_REHASH_FN(SYM, struct symbol)
 
 HASH(struct keyword) kw_hash;
+HASH(struct ea_class) ea_name_hash;
 
 struct sym_scope *conf_this_scope;
-struct sym_scope *global_root_scope;
+
+static struct sym_scope global_root_scope__init = { .active = 1, };
+struct sym_scope *global_root_scope = &global_root_scope__init;
 
 linpool *cfg_mem;
 
@@ -598,6 +601,25 @@ cf_new_symbol(const byte *c)
   return s;
 }
 
+static struct symbol *
+cf_root_symbol(const byte *c)
+{
+  uint l = strlen(c);
+  if (l > SYM_MAX_LEN)
+    bug("Root symbol %s too long", c);
+
+  struct symbol *s = mb_alloc(&root_pool, sizeof(struct symbol) + l + 1);
+  *s = (struct symbol) { .scope = global_root_scope, .class = SYM_VOID, };
+  memcpy(s->name, c, l+1);
+
+  if (!global_root_scope->hash.data)
+    HASH_INIT(global_root_scope->hash, &root_pool, SYM_ORDER);
+
+  HASH_INSERT2(global_root_scope->hash, SYM, &root_pool, s);
+  return s;
+}
+
+
 /**
  * cf_find_symbol_scope - find a symbol by name
  * @scope: config scope
@@ -652,7 +674,7 @@ cf_localize_symbol(struct symbol *sym)
   /* If the symbol type is void, it has been recently allocated just in this scope. */
   if (!sym->class)
     return sym;
-  
+
   /* If the scope is the current, it is already defined in this scope. */
   if (sym->scope == conf_this_scope)
     cf_error("Symbol already defined");
@@ -716,8 +738,34 @@ cf_lex_init_kh(void)
   struct keyword *k;
   for (k=keyword_list; k->name; k++)
     HASH_INSERT(kw_hash, KW, k);
+}
+
+void
+ea_lex_register(struct ea_class *def)
+{
+  struct symbol *sym = cf_root_symbol(def->name);
+  sym->class = SYM_ATTRIBUTE;
+  sym->attribute = def;
+  def->sym = sym;
+}
 
-  global_root_scope = mb_allocz(&root_pool, sizeof(*global_root_scope));
+void
+ea_lex_unregister(struct ea_class *def)
+{
+  struct symbol *sym = def->sym;
+  HASH_REMOVE2(global_root_scope->hash, SYM, &root_pool, sym);
+  mb_free(sym);
+  def->sym = NULL;
+}
+
+struct ea_class *
+ea_class_find_by_name(const char *name)
+{
+  struct symbol *sym = cf_find_symbol(global_root_scope, name);
+  if (!sym || (sym->class != SYM_ATTRIBUTE))
+    return NULL;
+  else
+    return sym->attribute;
 }
 
 /**
diff --git a/conf/conf.h b/conf/conf.h
index 2700295b..18de8def 100644
--- a/conf/conf.h
+++ b/conf/conf.h
@@ -120,7 +120,7 @@ struct symbol {
     const struct f_line *function;	/* For SYM_FUNCTION */
     const struct filter *filter;	/* For SYM_FILTER */
     struct rtable_config *table;	/* For SYM_TABLE */
-    struct f_dynamic_attr *attribute;	/* For SYM_ATTRIBUTE */
+    struct ea_class *attribute;		/* For SYM_ATTRIBUTE */
     struct f_val *val;			/* For SYM_CONSTANT */
     uint offset;			/* For SYM_VARIABLE */
   };
diff --git a/conf/confbase.Y b/conf/confbase.Y
index a81560dc..2286b257 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -71,8 +71,9 @@ CF_DECLS
   } xp;
   enum filter_return fret;
   enum ec_subtype ecs;
-  struct f_dynamic_attr fda;
+  struct ea_class *ea_class;
   struct f_static_attr fsa;
+  struct f_attr_bit fab;
   struct f_lval flv;
   struct f_line *fl;
   const struct filter *f;
diff --git a/filter/config.Y b/filter/config.Y
index 92656f7c..f21f1c8e 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -22,6 +22,13 @@ static inline u32 pair_b(u32 p) { return p & 0xFFFF; }
 #define f_generate_complex(fi_code, da, arg) \
   f_new_inst(FI_EA_SET, f_new_inst(fi_code, f_new_inst(FI_EA_GET, da), arg), da)
 
+#define f_generate_complex_sym(fi_code, sym, arg) ({ \
+  if (sym->class != SYM_ATTRIBUTE) \
+    cf_error("Can't empty %s: not an attribute", sym->name); \
+  f_generate_complex(fi_code, sym->attribute, arg); \
+})
+  
+
 /*
  * Sets and their items are during parsing handled as lists, linked
  * through left ptr. The first item in a list also contains a pointer
@@ -161,27 +168,31 @@ f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
 }
 
 static inline struct f_inst *
-f_generate_empty(struct f_dynamic_attr dyn)
+f_generate_empty(const struct symbol *sym)
 {
-  const struct f_val *empty = f_get_empty(dyn.type);
+  if (sym->class != SYM_ATTRIBUTE)
+    cf_error("Can't empty %s: not an attribute", sym->name);
+
+  const struct ea_class *def = sym->attribute;
+  const struct f_val *empty = f_get_empty(def->type);
   if (!empty)
-    cf_error("Can't empty that attribute");
+    cf_error("Can't empty attribute %s", def->name);
 
-  return f_new_inst(FI_EA_SET, f_new_inst(FI_CONSTANT, *empty), dyn);
+  return f_new_inst(FI_EA_SET, f_new_inst(FI_CONSTANT, *empty), def);
 }
 
-#define BA_AS_PATH 0x02
-
 static inline struct f_inst *
 f_implicit_roa_check(struct rtable_config *tab)
 {
-  struct f_dynamic_attr fda = f_new_dynamic_attr(T_PATH, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+  const struct ea_class *def = ea_class_find("bgp_path");
+  if (!def)
+    cf_error("Fatal: Couldn't find BGP path attribute definition.");
 
   struct f_static_attr fsa = f_new_static_attr(T_NET, SA_NET, 1);
 
   return f_new_inst(FI_ROA_CHECK,
 	    f_new_inst(FI_RTA_GET, fsa),
-	    f_new_inst(FI_AS_PATH_LAST, f_new_inst(FI_EA_GET, fda)),
+	    f_new_inst(FI_AS_PATH_LAST, f_new_inst(FI_EA_GET, def)),
 	    tab);
 }
 
@@ -293,8 +304,8 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 
 %type <xp> cmds_int cmd_prep
 %type <x> term block cmd cmds constant constructor print_list var_list function_call symbol_value bgp_path_expr bgp_path bgp_path_tail
-%type <fda> dynamic_attr attr_bit
 %type <fsa> static_attr
+%type <fab> attr_bit
 %type <f> filter where_filter
 %type <fl> filter_body function_body
 %type <flv> lvalue
@@ -335,7 +346,14 @@ filter_eval:
 
 conf: custom_attr ;
 custom_attr: ATTRIBUTE type symbol ';' {
-  cf_define_symbol($3, SYM_ATTRIBUTE, attribute, ca_lookup(new_config->pool, $3->name, $2)->fda);
+  if (($3->class == SYM_ATTRIBUTE) && ($3->scope == new_config->root_scope))
+    cf_error("Duplicate attribute %s definition", $3->name);
+
+  cf_define_symbol($3, SYM_ATTRIBUTE, attribute,
+      ea_register_alloc(new_config->pool, (struct ea_class) {
+	.name = $3->name,
+	.type = $2,
+	})->class);
 };
 
 conf: bt_test_suite ;
@@ -736,7 +754,7 @@ symbol_value: CF_SYM_KNOWN
 	$$ = f_new_inst(FI_VAR_GET, $1);
 	break;
       case SYM_ATTRIBUTE:
-	$$ = f_new_inst(FI_EA_GET, *$1->attribute);
+	$$ = f_new_inst(FI_EA_GET, $1->attribute);
 	break;
       default:
 	cf_error("Can't get value of symbol %s", $1->name);
@@ -785,11 +803,9 @@ term:
  | constructor { $$ = $1; }
 
  | static_attr { $$ = f_new_inst(FI_RTA_GET, $1); }
-
- | dynamic_attr { $$ = f_new_inst(FI_EA_GET, $1); }
  | attr_bit {
     struct f_inst *c = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = (1U << $1.bit)});
-    $$ = f_new_inst(FI_EQ, c, f_new_inst(FI_BITAND, f_new_inst(FI_EA_GET, $1), c));
+    $$ = f_new_inst(FI_EQ, c, f_new_inst(FI_BITAND, f_new_inst(FI_EA_GET, $1.class), c));
   }
 
  | term '.' IS_V4 { $$ = f_new_inst(FI_IS_V4, $1); }
@@ -833,8 +849,6 @@ term:
 
  | FORMAT '(' term ')' {  $$ = f_new_inst(FI_FORMAT, $3); }
 
-/* | term '.' LEN { $$->code = P('P','l'); } */
-
  | function_call
  ;
 
@@ -867,7 +881,9 @@ cmd:
 	 $$ = f_new_inst(FI_VAR_SET, $3, $1);
 	 break;
        case SYM_ATTRIBUTE:
-	 $$ = f_new_inst(FI_EA_SET, $3, *$1->attribute);
+	 if ($1->attribute->readonly)
+	   cf_error("Attribute %s is read-only", $1->attribute->name);
+	 $$ = f_new_inst(FI_EA_SET, $3, $1->attribute);
 	 break;
        default:
 	 cf_error("Can't assign to symbol %s", $1->name);
@@ -877,22 +893,23 @@ cmd:
      DBG( "Ook, we'll return the value\n" );
      $$ = f_new_inst(FI_RETURN, $2);
    }
- | dynamic_attr '=' term ';' {
-     $$ = f_new_inst(FI_EA_SET, $3, $1);
-   }
  | static_attr '=' term ';' {
      if ($1.readonly)
        cf_error( "This static attribute is read-only.");
      $$ = f_new_inst(FI_RTA_SET, $3, $1);
    }
- | UNSET '(' dynamic_attr ')' ';' {
-     $$ = f_new_inst(FI_EA_UNSET, $3);
+ | UNSET '(' CF_SYM_KNOWN ')' ';' {
+     if ($3->class != SYM_ATTRIBUTE)
+       cf_error("Can't unset %s", $3->name);
+     if ($3->attribute->readonly)
+       cf_error("Attribute %s is read-only", $3->attribute->name);
+     $$ = f_new_inst(FI_EA_UNSET, $3->attribute);
    }
  | attr_bit '=' term ';' {
      $$ = f_new_inst(FI_CONDITION, $3,
-	f_generate_complex(FI_BITOR, $1,
+	f_generate_complex(FI_BITOR, $1.class,
 	      f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = (1U << $1.bit)})),
-	f_generate_complex(FI_BITAND, $1,
+	f_generate_complex(FI_BITAND, $1.class,
 	      f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = ~(1U << $1.bit)}))
      );
    }
@@ -919,11 +936,11 @@ cmd:
       $$ = f_new_inst(FI_SWITCH, $2, build_tree($4));
    }
 
- | dynamic_attr '.' EMPTY ';' { $$ = f_generate_empty($1); }
- | dynamic_attr '.' PREPEND '(' term ')' ';'   { $$ = f_generate_complex( FI_PATH_PREPEND, $1, $5 ); }
- | dynamic_attr '.' ADD '(' term ')' ';'       { $$ = f_generate_complex( FI_CLIST_ADD, $1, $5 ); }
- | dynamic_attr '.' DELETE '(' term ')' ';'    { $$ = f_generate_complex( FI_CLIST_DEL, $1, $5 ); }
- | dynamic_attr '.' FILTER '(' term ')' ';'    { $$ = f_generate_complex( FI_CLIST_FILTER, $1, $5 ); }
+ | CF_SYM_KNOWN '.' EMPTY ';' { $$ = f_generate_empty($1); }
+ | CF_SYM_KNOWN '.' PREPEND '(' term ')' ';'   { $$ = f_generate_complex_sym( FI_PATH_PREPEND, $1, $5 ); }
+ | CF_SYM_KNOWN '.' ADD '(' term ')' ';'       { $$ = f_generate_complex_sym( FI_CLIST_ADD, $1, $5 ); }
+ | CF_SYM_KNOWN '.' DELETE '(' term ')' ';'    { $$ = f_generate_complex_sym( FI_CLIST_DEL, $1, $5 ); }
+ | CF_SYM_KNOWN '.' FILTER '(' term ')' ';'    { $$ = f_generate_complex_sym( FI_CLIST_FILTER, $1, $5 ); }
  | BT_ASSERT '(' get_cf_position term get_cf_position ')' ';' { $$ = assert_done($4, $3 + 1, $5 - 1); }
  | BT_CHECK_ASSIGN '(' get_cf_position lvalue get_cf_position ',' term ')' ';' { $$ = assert_assign(&$4, $7, $3 + 1, $5 - 1); }
  ;
@@ -934,8 +951,17 @@ get_cf_position:
 };
 
 lvalue:
-   CF_SYM_KNOWN { cf_assert_symbol($1, SYM_VARIABLE); $$ = (struct f_lval) { .type = F_LVAL_VARIABLE, .sym = $1 }; }
+   CF_SYM_KNOWN {
+      switch ($1->class) {
+	case SYM_VARIABLE_RANGE:
+	  $$ = (struct f_lval) { .type = F_LVAL_VARIABLE, .sym = $1 };
+	  break;
+	case SYM_ATTRIBUTE:
+	  $$ = (struct f_lval) { .type = F_LVAL_EA, .da = $1->attribute };
+	  break;
+      }
+  }
  | static_attr { $$ = (struct f_lval) { .type = F_LVAL_SA, .sa = $1 }; }
- | dynamic_attr { $$ = (struct f_lval) { .type = F_LVAL_EA, .da = $1 }; };
+ ;
 
 CF_END
diff --git a/filter/data.h b/filter/data.h
index cba47d6a..4d2622ab 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -21,13 +21,6 @@ struct f_val {
 
 #define fputip(a)   ({ ip_addr *ax = falloc(sizeof(*ax)); *ax = (a); ax; })
 
-/* Dynamic attribute definition (eattrs) */
-struct f_dynamic_attr {
-  btype type;		/* EA type (EAF_*) */
-  u8 bit;		/* For bitfield accessors */
-  uint ea_code;		/* EA code */
-};
-
 enum f_sa_code {
   SA_FROM = 1,
   SA_GW,
@@ -53,7 +46,6 @@ struct f_static_attr {
 /* Filter l-value type */
 enum f_lval_type {
   F_LVAL_VARIABLE,
-  F_LVAL_PREFERENCE,
   F_LVAL_SA,
   F_LVAL_EA,
 };
@@ -63,7 +55,7 @@ struct f_lval {
   enum f_lval_type type;
   union {
     struct symbol *sym;
-    struct f_dynamic_attr da;
+    const struct ea_class *da;
     struct f_static_attr sa;
   };
 };
diff --git a/filter/decl.m4 b/filter/decl.m4
index 2e4fb235..c59cd7f3 100644
--- a/filter/decl.m4
+++ b/filter/decl.m4
@@ -94,7 +94,7 @@ FID_DUMP_BODY()m4_dnl
 debug("%s" $4 "\n", INDENT, $5);
 ]])
 FID_INTERPRET_EXEC()m4_dnl
-const $1 $2 = whati->$2
+$1 $2 = whati->$2
 FID_INTERPRET_BODY')
 
 #	Instruction arguments are needed only until linearization is done.
@@ -256,7 +256,7 @@ FID_INTERPRET_BODY()')
 m4_define(SYMBOL, `FID_MEMBER(struct symbol *, sym, [[strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)]], "symbol %s", item->sym->name)')
 m4_define(RTC, `FID_MEMBER(struct rtable_config *, rtc, [[strcmp(f1->rtc->name, f2->rtc->name)]], "route table %s", item->rtc->name)')
 m4_define(STATIC_ATTR, `FID_MEMBER(struct f_static_attr, sa, f1->sa.sa_code != f2->sa.sa_code,,)')
-m4_define(DYNAMIC_ATTR, `FID_MEMBER(struct f_dynamic_attr, da, f1->da.ea_code != f2->da.ea_code,,)')
+m4_define(DYNAMIC_ATTR, `FID_MEMBER(const struct ea_class *, da, f1->da != f2->da,,)')
 m4_define(ACCESS_RTE, `FID_HIC(,[[do { if (!fs->rte) runtime("No route to access"); } while (0)]],NEVER_CONSTANT())')
 
 #	2) Code wrapping
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 7b34ef91..c5947955 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -662,14 +662,14 @@
     DYNAMIC_ATTR;
     ACCESS_RTE;
     ACCESS_EATTRS;
-    RESULT_TYPE(da.type);
+    RESULT_TYPE(da->type);
     {
       const struct f_val *empty;
-      eattr *e = ea_find(*fs->eattrs, da.ea_code);
+      const eattr *e = ea_find(*fs->eattrs, da->id);
 
       if (e)
       {
-	ASSERT_DIE(e->type == da.type);
+	ASSERT_DIE(e->type == da->type);
 
 	switch (e->type) {
 	  case T_IP:
@@ -682,7 +682,7 @@
 		}]]);
 	}
       }
-      else if (empty = f_get_empty(da.type))
+      else if (empty = f_get_empty(da->type))
 	RESULT_VAL(*empty);
       else
 	RESULT_VOID;
@@ -694,16 +694,16 @@
     ACCESS_EATTRS;
     ARG_ANY(1);
     DYNAMIC_ATTR;
-    ARG_TYPE(1, da.type);
+    ARG_TYPE(1, da->type);
     {
       struct eattr *a;
 
-      if (da.type >= EAF_TYPE__MAX)
+      if (da->type >= EAF_TYPE__MAX)
 	bug("Unsupported attribute type");
 
       f_rta_cow(fs);
 
-      switch (da.type) {
+      switch (da->type) {
       case T_OPAQUE:
       case T_IFACE:
 	runtime( "Setting opaque attribute is not allowed" );
@@ -711,12 +711,12 @@
 
       case T_IP:
 	a = ea_set_attr(fs->eattrs,
-	    EA_LITERAL_STORE_ADATA(da.ea_code, da.type, 0, &v1.val.ip, sizeof(ip_addr)));
+	    EA_LITERAL_STORE_ADATA(da, 0, &v1.val.ip, sizeof(ip_addr)));
 	break;
 
       default:
 	a = ea_set_attr(fs->eattrs,
-	    EA_LITERAL_GENERIC(da.ea_code, da.type, 0, .u = v1.val.bval));
+	    EA_LITERAL_GENERIC(da->id, da->type, 0, .u = v1.val.bval));
 	break;
       }
 
@@ -731,7 +731,7 @@
     ACCESS_EATTRS;
 
     f_rta_cow(fs);
-    ea_unset_attr(fs->eattrs, 1, da.ea_code);
+    ea_unset_attr(fs->eattrs, 1, da);
   }
 
   INST(FI_LENGTH, 1, 1) {	/* Get length of */
diff --git a/filter/f-inst.h b/filter/f-inst.h
index 32da4653..047a66c9 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -87,15 +87,17 @@ void f_add_lines(const struct f_line_item *what, struct filter_iterator *fit);
 
 
 struct filter *f_new_where(struct f_inst *);
-static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, uint code)
-{ return (struct f_dynamic_attr) { .type = type, .ea_code = code }; }
-static inline struct f_dynamic_attr f_new_dynamic_attr_bit(u8 bit, uint code)
-{ return (struct f_dynamic_attr) { .type = T_INT, .bit = bit, .ea_code = code }; }
 static inline struct f_static_attr f_new_static_attr(btype type, int code, int readonly)
 { return (struct f_static_attr) { .type = type, .sa_code = code, .readonly = readonly }; }
-struct f_inst *f_generate_complex(enum f_instruction_code fi_code, struct f_dynamic_attr da, struct f_inst *argument);
 struct f_inst *f_generate_roa_check(struct rtable_config *table, struct f_inst *prefix, struct f_inst *asn);
 
+struct f_attr_bit {
+  const struct ea_class *class;
+  uint bit;
+};
+
+#define f_new_dynamic_attr_bit(_bit, _name)  ((struct f_attr_bit) { .bit = _bit, .class = ea_class_find(_name) })
+
 /* Hook for call bt_assert() function in configuration */
 extern void (*bt_assert_hook)(int result, const struct f_line_item *assert);
 
diff --git a/filter/f-util.c b/filter/f-util.c
index 83ae01f6..fb93ee80 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -2,7 +2,7 @@
  *	Filters: utility functions
  *
  *	Copyright 1998 Pavel Machek <pavel@ucw.cz>
- *		  2017 Jan Maria Matejka <mq@ucw.cz>
+ *		  2017 Maria Matejka <mq@ucw.cz>
  *
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
@@ -40,129 +40,3 @@ struct filter *f_new_where(struct f_inst *where)
   f->root = f_linearize(cond);
   return f;
 }
-
-#define CA_KEY(n)	n->name, n->fda.type
-#define CA_NEXT(n)	n->next
-#define CA_EQ(na,ta,nb,tb)	(!strcmp(na,nb) && (ta == tb))
-#define CA_FN(n,t)	(mem_hash(n, strlen(n)) ^ (t*0xaae99453U))
-#define CA_ORDER	8 /* Fixed */
-
-struct ca_storage {
-  struct ca_storage *next;
-  struct f_dynamic_attr fda;
-  u32 uc;
-  char name[0];
-};
-
-HASH(struct ca_storage) ca_hash;
-
-static struct idm ca_idm;
-static struct ca_storage **ca_storage;
-static uint ca_storage_max;
-
-static void
-ca_free(resource *r)
-{
-  struct custom_attribute *ca = (void *) r;
-  struct ca_storage *cas = HASH_FIND(ca_hash, CA, ca->name, ca->fda->type);
-  ASSERT(cas);
-
-  ca->name = NULL;
-  ca->fda = NULL;
-  if (!--cas->uc) {
-    uint id = EA_CUSTOM_ID(cas->fda.ea_code);
-    idm_free(&ca_idm, id);
-    HASH_REMOVE(ca_hash, CA, cas);
-    ca_storage[id] = NULL;
-    mb_free(cas);
-  }
-}
-
-static void
-ca_dump(resource *r)
-{
-  struct custom_attribute *ca = (void *) r;
-  debug("name \"%s\" id 0x%04x ea_type 0x%02x\n",
-      ca->name, ca->fda->ea_code, ca->fda->type);
-}
-
-static struct resclass ca_class = {
-  .name = "Custom attribute",
-  .size = sizeof(struct custom_attribute),
-  .free = ca_free,
-  .dump = ca_dump,
-  .lookup = NULL,
-  .memsize = NULL,
-};
-
-struct custom_attribute *
-ca_lookup(pool *p, const char *name, btype type)
-{
-  switch (type) {
-    case T_INT:
-    case T_IP:
-    case T_QUAD:
-    case T_PATH:
-    case T_CLIST:
-    case T_ECLIST:
-    case T_LCLIST:
-      break;
-    default:
-      cf_error("Custom route attribute of unsupported type");
-  }
-
-  static int inited = 0;
-  if (!inited) {
-    idm_init(&ca_idm, &root_pool, 8);
-    HASH_INIT(ca_hash, &root_pool, CA_ORDER);
-
-    ca_storage_max = 256;
-    ca_storage = mb_allocz(&root_pool, sizeof(struct ca_storage *) * ca_storage_max);
-
-    inited++;
-  }
-
-  struct ca_storage *cas = HASH_FIND(ca_hash, CA, name, type);
-  if (cas) {
-    cas->uc++;
-  } else {
-
-    uint id = idm_alloc(&ca_idm);
-
-    if (id >= EA_CUSTOM_BIT)
-      cf_error("Too many custom attributes.");
-
-    if (id >= ca_storage_max) {
-      ca_storage_max *= 2;
-      ca_storage = mb_realloc(ca_storage, sizeof(struct ca_storage *) * ca_storage_max * 2);
-    }
-
-    cas = mb_allocz(&root_pool, sizeof(struct ca_storage) + strlen(name) + 1);
-    cas->fda = f_new_dynamic_attr(type, EA_CUSTOM(id));
-    cas->uc = 1;
-
-    strcpy(cas->name, name);
-    ca_storage[id] = cas;
-
-    HASH_INSERT(ca_hash, CA, cas);
-  }
-
-  struct custom_attribute *ca = ralloc(p, &ca_class);
-  ca->fda = &(cas->fda);
-  ca->name = cas->name;
-  return ca;
-}
-
-const char *
-ea_custom_name(uint ea)
-{
-  uint id = EA_CUSTOM_ID(ea);
-  if (id >= ca_storage_max)
-    return NULL;
-
-  if (!ca_storage[id])
-    return NULL;
-
-  return ca_storage[id]->name;
-}
-
diff --git a/filter/filter.h b/filter/filter.h
index 43c04443..0273ef15 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -70,13 +70,4 @@ void filters_dump_all(void);
 
 #define FF_SILENT 2			/* Silent filter execution */
 
-/* Custom route attributes */
-struct custom_attribute {
-  resource r;
-  struct f_dynamic_attr *fda;
-  const char *name;
-};
-
-struct custom_attribute *ca_lookup(pool *p, const char *name, btype type);
-
 #endif
diff --git a/filter/test.conf b/filter/test.conf
index 062756b1..21e7330f 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -9,7 +9,109 @@ router id 62.168.0.1;
 /* We have to setup any protocol */
 protocol device { }
 
-
+/* Setting some custom attributes, enough to force BIRD to reallocate the attribute idmap */
+attribute int test_ca_int1;
+attribute int test_ca_int2;
+attribute int test_ca_int3;
+attribute int test_ca_int4;
+attribute int test_ca_int5;
+attribute int test_ca_int6;
+attribute int test_ca_int7;
+attribute int test_ca_int8;
+attribute int test_ca_int9;
+attribute int test_ca_int10;
+
+attribute ip test_ca_ip1;
+attribute ip test_ca_ip2;
+attribute ip test_ca_ip3;
+attribute ip test_ca_ip4;
+attribute ip test_ca_ip5;
+attribute ip test_ca_ip6;
+attribute ip test_ca_ip7;
+attribute ip test_ca_ip8;
+attribute ip test_ca_ip9;
+attribute ip test_ca_ip10;
+
+attribute quad test_ca_quad1;
+attribute quad test_ca_quad2;
+attribute quad test_ca_quad3;
+attribute quad test_ca_quad4;
+attribute quad test_ca_quad5;
+attribute quad test_ca_quad6;
+attribute quad test_ca_quad7;
+attribute quad test_ca_quad8;
+attribute quad test_ca_quad9;
+attribute quad test_ca_quad10;
+
+attribute bgppath test_ca_bgppath1;
+attribute bgppath test_ca_bgppath2;
+attribute bgppath test_ca_bgppath3;
+attribute bgppath test_ca_bgppath4;
+attribute bgppath test_ca_bgppath5;
+attribute bgppath test_ca_bgppath6;
+attribute bgppath test_ca_bgppath7;
+attribute bgppath test_ca_bgppath8;
+attribute bgppath test_ca_bgppath9;
+attribute bgppath test_ca_bgppath10;
+
+attribute clist test_ca_clist1;
+attribute clist test_ca_clist2;
+attribute clist test_ca_clist3;
+attribute clist test_ca_clist4;
+attribute clist test_ca_clist5;
+attribute clist test_ca_clist6;
+attribute clist test_ca_clist7;
+attribute clist test_ca_clist8;
+attribute clist test_ca_clist9;
+attribute clist test_ca_clist10;
+
+attribute eclist test_ca_eclist1;
+attribute eclist test_ca_eclist2;
+attribute eclist test_ca_eclist3;
+attribute eclist test_ca_eclist4;
+attribute eclist test_ca_eclist5;
+attribute eclist test_ca_eclist6;
+attribute eclist test_ca_eclist7;
+attribute eclist test_ca_eclist8;
+attribute eclist test_ca_eclist9;
+attribute eclist test_ca_eclist10;
+
+attribute lclist test_ca_lclist1;
+attribute lclist test_ca_lclist2;
+attribute lclist test_ca_lclist3;
+attribute lclist test_ca_lclist4;
+attribute lclist test_ca_lclist5;
+attribute lclist test_ca_lclist6;
+attribute lclist test_ca_lclist7;
+attribute lclist test_ca_lclist8;
+attribute lclist test_ca_lclist9;
+attribute lclist test_ca_lclist10;
+
+attribute lclist test_ca_lclist_max1;
+attribute lclist test_ca_lclist_max2;
+attribute lclist test_ca_lclist_max3;
+attribute lclist test_ca_lclist_max4;
+attribute lclist test_ca_lclist_max5;
+attribute lclist test_ca_lclist_max6;
+attribute lclist test_ca_lclist_max7;
+attribute lclist test_ca_lclist_max8;
+attribute lclist test_ca_lclist_max9;
+attribute lclist test_ca_lclist_max10;
+attribute lclist test_ca_lclist_max11;
+attribute lclist test_ca_lclist_max12;
+attribute lclist test_ca_lclist_max13;
+attribute lclist test_ca_lclist_max14;
+attribute lclist test_ca_lclist_max15;
+attribute lclist test_ca_lclist_max16;
+attribute lclist test_ca_lclist_max17;
+attribute lclist test_ca_lclist_max18;
+attribute lclist test_ca_lclist_max19;
+attribute lclist test_ca_lclist_max20;
+attribute lclist test_ca_lclist_max21;
+
+
+/* Uncomment this to get an error */
+#attribute int bgp_path;
 
 /*
  * 	Common definitions and functions
@@ -1331,6 +1433,7 @@ function __test2()
 
 filter testf
 int j;
+bool t;
 {
 	print "Heya, filtering route to ", net.ip, " prefixlen ", net.len, " source ", source;
 	print "This route was from ", from;
@@ -1342,6 +1445,52 @@ int j;
 	rip_metric = 14;
 	unset(rip_metric);
 
+	test_ca_int1 = 42;
+	test_ca_ip2 = 1.3.5.7;
+	test_ca_quad3 = 2.4.6.8;
+	test_ca_bgppath4 = +empty+;
+	test_ca_clist5 = -empty-;
+	test_ca_eclist6 = --empty--;
+	test_ca_lclist7 = ---empty---;
+
+	igp_metric = 53;
+	babel_metric = 64;
+	t = defined(babel_router_id);
+	j = babel_seqno;
+
+	bgp_origin = ORIGIN_IGP;
+	bgp_path = +empty+;
+	bgp_next_hop = 3456:789a:bcde:f012::3456:789a;
+	bgp_med = 71;
+	bgp_local_pref = 942;
+	t = defined(bgp_atomic_aggr);
+	t = defined(bgp_aggregator);
+	bgp_community = -empty-;
+	bgp_originator_id = 9.7.5.3;
+	bgp_cluster_list = -empty-;
+	t = defined(bgp_mp_reach_nlri);
+	t = defined(bgp_mp_unreach_nlri);
+	bgp_ext_community = --empty--;
+	bgp_as4_path = +empty+;
+	t = defined(bgp_as4_aggregator);
+	t = defined(bgp_aigp);
+	bgp_large_community = ---empty---;
+	t = defined(bgp_mpls_label_stack);
+
+	ospf_metric1 = 64;
+	ospf_metric2 = 111;
+	ospf_tag = 654432;
+
+	radv_preference = RA_PREF_LOW;
+	radv_lifetime = 28;
+
+	rip_metric = 2;
+	rip_tag = 4;
+	t = defined(rip_from);
+
+	krt_source = 17;
+	krt_metric = 19;
+
 #	krt_lock_mtu = false;
 #	krt_lock_window = true;
 #	krt_lock_rtt = krt_lock_rttvar && krt_lock_sstresh || krt_lock_cwnd;
diff --git a/lib/event_test.c b/lib/event_test.c
index e14d0b95..3070327d 100644
--- a/lib/event_test.c
+++ b/lib/event_test.c
@@ -55,8 +55,8 @@ t_ev_run_list(void)
 
   olock_init();
   timer_init();
-  io_init();
   rt_init();
+  io_init();
   if_init();
 //  roa_init();
   config_init();
diff --git a/lib/mempool.c b/lib/mempool.c
index 325b1ecf..33eaec86 100644
--- a/lib/mempool.c
+++ b/lib/mempool.c
@@ -41,8 +41,6 @@ struct linpool {
   uint total, total_large;
 };
 
-_Thread_local linpool *tmp_linpool;
-
 static void lp_free(resource *);
 static void lp_dump(resource *);
 static resource *lp_lookup(resource *, unsigned long);
diff --git a/lib/resource.c b/lib/resource.c
index 89e559b4..c31d9889 100644
--- a/lib/resource.c
+++ b/lib/resource.c
@@ -292,6 +292,25 @@ resource_init(void)
   tmp_init(&root_pool);
 }
 
+_Thread_local struct tmp_resources tmp_res;
+
+void
+tmp_init(pool *p)
+{
+  tmp_res.lp = lp_new_default(p);
+  tmp_res.parent = p;
+  tmp_res.pool = rp_new(p, "TMP");
+}
+
+void
+tmp_flush(void)
+{
+  lp_flush(tmp_linpool);
+  rfree(tmp_res.pool);
+  tmp_res.pool = rp_new(tmp_res.parent, "TMP");
+}
+
+
 /**
  * DOC: Memory blocks
  *
diff --git a/lib/resource.h b/lib/resource.h
index a4e110a5..4cedbf00 100644
--- a/lib/resource.h
+++ b/lib/resource.h
@@ -80,14 +80,21 @@ void lp_flush(linpool *);			/* Free everything, but leave linpool */
 void lp_save(linpool *m, lp_state *p);		/* Save state */
 void lp_restore(linpool *m, lp_state *p);	/* Restore state */
 
-extern _Thread_local linpool *tmp_linpool;	/* Temporary linpool autoflushed regularily */
+struct tmp_resources {
+  pool *pool, *parent;
+  linpool *lp;
+};
+
+extern _Thread_local struct tmp_resources tmp_res;
 
+#define tmp_linpool	tmp_res.lp
 #define tmp_alloc(sz)	lp_alloc(tmp_linpool, sz)
 #define tmp_allocu(sz)	lp_allocu(tmp_linpool, sz)
 #define tmp_allocz(sz)	lp_allocz(tmp_linpool, sz)
 
-#define tmp_init(p)	tmp_linpool = lp_new_default(p)
-#define tmp_flush()	lp_flush(tmp_linpool)
+void tmp_init(pool *p);
+void tmp_flush(void);
+
 
 #define lp_new_default	lp_new
 
diff --git a/lib/route.h b/lib/route.h
index ad3f3fb7..f24fd555 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -150,19 +150,7 @@ typedef struct eattr {
 } eattr;
 
 
-#define EA_CODE(proto,id) (((proto) << 8) | (id))
-#define EA_ID(ea) ((ea) & 0xff)
-#define EA_PROTO(ea) ((ea) >> 8)
-#define EA_CUSTOM(id) ((id) | EA_CUSTOM_BIT)
-#define EA_IS_CUSTOM(ea) ((ea) & EA_CUSTOM_BIT)
-#define EA_CUSTOM_ID(ea) ((ea) & ~EA_CUSTOM_BIT)
-
-const char *ea_custom_name(uint ea);
-
-#define EA_GEN_IGP_METRIC EA_CODE(PROTOCOL_NONE, 0)
-
 #define EA_CODE_MASK 0xffff
-#define EA_CUSTOM_BIT 0x8000
 #define EA_ALLOW_UNDEF 0x10000		/* ea_find: allow EAF_TYPE_UNDEF */
 #define EA_BIT(n) ((n) << 24)		/* Used in bitfield accessors */
 #define EA_BIT_GET(ea) ((ea) >> 24)
@@ -179,32 +167,67 @@ typedef struct ea_list {
 #define EALF_BISECT 2			/* Use interval bisection for searching */
 #define EALF_CACHED 4			/* Attributes belonging to cached rta */
 
+struct ea_class {
+#define EA_CLASS_INSIDE \
+  const char *name;			/* Name (both print and filter) */ \
+  struct symbol *sym;			/* Symbol to export to configs */ \
+  uint id;				/* Autoassigned attribute ID */ \
+  uint uc;				/* Reference count */ \
+  btype type;				/* Data type ID */ \
+  uint readonly:1;			/* This attribute can't be changed by filters */ \
+  uint conf:1;				/* Requested by config */ \
+  void (*format)(const eattr *ea, byte *buf, uint size); \
+
+  EA_CLASS_INSIDE;
+};
+
+struct ea_class_ref {
+  resource r;
+  struct ea_class *class;
+};
+
+extern struct ea_class ea_gen_igp_metric;
+
+void ea_register_init(struct ea_class *);
+struct ea_class_ref *ea_register_alloc(pool *, struct ea_class);
+
+#define EA_REGISTER_ALL_HELPER(x)	ea_register_init(x);
+#define EA_REGISTER_ALL(...)		MACRO_FOREACH(EA_REGISTER_ALL_HELPER, __VA_ARGS__)
+
+struct ea_class *ea_class_find_by_id(uint id);
+struct ea_class *ea_class_find_by_name(const char *name);
+static inline struct ea_class *ea_class_self(struct ea_class *self) { return self; }
+#define ea_class_find(_arg)	_Generic((_arg), \
+  uint: ea_class_find_by_id, \
+  word: ea_class_find_by_id, \
+  char *: ea_class_find_by_name, \
+  const char *: ea_class_find_by_name, \
+  struct ea_class *: ea_class_self)(_arg)
+
 struct ea_walk_state {
   ea_list *eattrs;			/* Ccurrent ea_list, initially set by caller */
   eattr *ea;				/* Current eattr, initially NULL */
   u32 visited[4];			/* Bitfield, limiting max to 128 */
 };
 
-eattr *ea_find(ea_list *, unsigned ea);
-eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
-
-/**
- * ea_get_int - fetch an integer attribute
- * @e: attribute list
- * @id: attribute ID
- * @def: default value
- *
- * This function is a shortcut for retrieving a value of an integer attribute
- * by calling ea_find() to find the attribute, extracting its value or returning
- * a provided default if no such attribute is present.
- */
-static inline u32
-ea_get_int(ea_list *e, unsigned id, u32 def)
+#define ea_find(_l, _arg)	_Generic((_arg), uint: ea_find_by_id, struct ea_class *: ea_find_by_class, char *: ea_find_by_name)(_l, _arg)
+eattr *ea_find_by_id(ea_list *, unsigned ea);
+static inline eattr *ea_find_by_class(ea_list *l, const struct ea_class *def)
+{ return ea_find_by_id(l, def->id); }
+static inline eattr *ea_find_by_name(ea_list *l, const char *name)
 {
-  eattr *a = ea_find(e, id);
-  return a ? a->u.data : def;
+  const struct ea_class *def = ea_class_find_by_name(name);
+  return def ? ea_find_by_class(l, def) : NULL;
 }
 
+#define ea_get_int(_l, _ident, _def)  ({ \
+    struct ea_class *cls = ea_class_find((_ident)); \
+    ASSERT_DIE(cls->type & EAF_EMBEDDED); \
+    const eattr *ea = ea_find((_l), cls->id); \
+    (ea ? ea->u.data : (_def)); \
+    })
+
+eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
 void ea_dump(ea_list *);
 int ea_same(ea_list *x, ea_list *y);	/* Test whether two ea_lists are identical */
 uint ea_hash(ea_list *e);	/* Calculate 16-bit hash value */
@@ -219,19 +242,22 @@ void ea_list_copy(ea_list *dest, ea_list *src, uint size);
 
 #define EA_LOCAL_LIST(N)  struct { ea_list l; eattr a[N]; }
 
-#define EA_LITERAL_EMBEDDED(_id, _type, _flags, _val) ({ \
+#define EA_LITERAL_EMBEDDED(_class, _flags, _val) ({ \
+    btype _type = (_class)->type; \
     ASSERT_DIE(_type & EAF_EMBEDDED); \
-    EA_LITERAL_GENERIC(_id, _type, _flags, .u.i = _val); \
+    EA_LITERAL_GENERIC((_class)->id, _type, _flags, .u.i = _val); \
     })
 
-#define EA_LITERAL_STORE_ADATA(_id, _type, _flags, _buf, _len) ({ \
+#define EA_LITERAL_STORE_ADATA(_class, _flags, _buf, _len) ({ \
+    btype _type = (_class)->type; \
     ASSERT_DIE(!(_type & EAF_EMBEDDED)); \
-    EA_LITERAL_GENERIC(_id, _type, _flags, .u.ad = tmp_store_adata((_buf), (_len))); \
+    EA_LITERAL_GENERIC((_class)->id, _type, _flags, .u.ad = tmp_store_adata((_buf), (_len))); \
     })
 
-#define EA_LITERAL_DIRECT_ADATA(_id, _type, _flags, _adata) ({ \
+#define EA_LITERAL_DIRECT_ADATA(_class, _flags, _adata) ({ \
+    btype _type = (_class)->type; \
     ASSERT_DIE(!(_type & EAF_EMBEDDED)); \
-    EA_LITERAL_GENERIC(_id, _type, _flags, .u.ad = _adata); \
+    EA_LITERAL_GENERIC((_class)->id, _type, _flags, .u.ad = _adata); \
     })
 
 #define EA_LITERAL_GENERIC(_id, _type, _flags, ...) \
@@ -253,19 +279,19 @@ ea_set_attr(ea_list **to, eattr a)
 }
 
 static inline void
-ea_unset_attr(ea_list **to, _Bool local, uint code)
+ea_unset_attr(ea_list **to, _Bool local, const struct ea_class *def)
 {
-  ea_set_attr(to, EA_LITERAL_GENERIC(code, 0, 0,
+  ea_set_attr(to, EA_LITERAL_GENERIC(def->id, 0, 0,
 	.fresh = local, .originated = local, .undef = 1));
 }
 
 static inline void
-ea_set_attr_u32(ea_list **to, uint id, uint flags, uint type, u32 data)
-{ ea_set_attr(to, EA_LITERAL_EMBEDDED(id, type, flags, data)); }
+ea_set_attr_u32(ea_list **to, const struct ea_class *def, uint flags, u64 data)
+{ ea_set_attr(to, EA_LITERAL_EMBEDDED(def, flags, data)); }
 
 static inline void
-ea_set_attr_data(ea_list **to, uint id, uint flags, uint type, void *data, uint len)
-{ ea_set_attr(to, EA_LITERAL_STORE_ADATA(id, type, flags, data, len)); }
+ea_set_attr_data(ea_list **to, const struct ea_class *def, uint flags, void *data, uint len)
+{ ea_set_attr(to, EA_LITERAL_STORE_ADATA(def, flags, data, len)); }
 
 
 #define NEXTHOP_MAX_SIZE (sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
diff --git a/nest/config.Y b/nest/config.Y
index 12fd01a2..c2913506 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -120,7 +120,7 @@ CF_KEYWORDS(PASSWORD, KEY, FROM, PASSIVE, TO, ID, EVENTS, PACKETS, PROTOCOLS, CH
 CF_KEYWORDS(ALGORITHM, KEYED, HMAC, MD5, SHA1, SHA256, SHA384, SHA512, BLAKE2S128, BLAKE2S256, BLAKE2B256, BLAKE2B512)
 CF_KEYWORDS(PRIMARY, STATS, COUNT, BY, FOR, IN, COMMANDS, PREEXPORT, NOEXPORT, EXPORTED, GENERATE)
 CF_KEYWORDS(BGP, PASSWORDS, DESCRIPTION)
-CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, IGP_METRIC, CLASS, DSCP)
+CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, CLASS, DSCP)
 CF_KEYWORDS(TIMEFORMAT, ISO, SHORT, LONG, ROUTE, PROTOCOL, BASE, LOG, S, MS, US)
 CF_KEYWORDS(GRACEFUL, RESTART, WAIT, MAX, FLUSH, AS)
 CF_KEYWORDS(MIN, IDLE, RX, TX, INTERVAL, MULTIPLIER, PASSIVE)
@@ -921,9 +921,6 @@ proto_patt2:
  | TEXT { $$.ptr = $1; $$.patt = 1; }
  ;
 
-dynamic_attr: IGP_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_GEN_IGP_METRIC); } ;
-
-
 CF_CODE
 
 CF_END
diff --git a/nest/proto.c b/nest/proto.c
index 95c319db..72613f8d 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -26,7 +26,6 @@ pool *proto_pool;
 list STATIC_LIST_INIT(proto_list);
 
 static list STATIC_LIST_INIT(protocol_list);
-struct protocol *class_to_protocol[PROTOCOL__MAX];
 
 #define CD(c, msg, args...) ({ if (c->debug & D_STATES) log(L_TRACE "%s.%s: " msg, c->proto->name, c->name ?: "?", ## args); })
 #define PD(p, msg, args...) ({ if (p->debug & D_STATES) log(L_TRACE "%s: " msg, p->name, ## args); })
@@ -1637,9 +1636,6 @@ void
 proto_build(struct protocol *p)
 {
   add_tail(&protocol_list, &p->n);
-  ASSERT(p->class);
-  ASSERT(!class_to_protocol[p->class]);
-  class_to_protocol[p->class] = p;
 }
 
 /* FIXME: convert this call to some protocol hook */
diff --git a/nest/protocol.h b/nest/protocol.h
index 7fb08992..8f0cc4b4 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -37,38 +37,20 @@ struct symbol;
  *	Routing Protocol
  */
 
-enum protocol_class {
-  PROTOCOL_NONE,
-  PROTOCOL_BABEL,
-  PROTOCOL_BFD,
-  PROTOCOL_BGP,
-  PROTOCOL_DEVICE,
-  PROTOCOL_DIRECT,
-  PROTOCOL_KERNEL,
-  PROTOCOL_OSPF,
-  PROTOCOL_MRT,
-  PROTOCOL_PERF,
-  PROTOCOL_PIPE,
-  PROTOCOL_RADV,
-  PROTOCOL_RIP,
-  PROTOCOL_RPKI,
-  PROTOCOL_STATIC,
-  PROTOCOL__MAX
-};
-
-extern struct protocol *class_to_protocol[PROTOCOL__MAX];
 
 struct protocol {
   node n;
   char *name;
   char *template;			/* Template for automatic generation of names */
   int name_counter;			/* Counter for automatic name generation */
-  enum protocol_class class;		/* Machine readable protocol class */
   uint preference;			/* Default protocol preference */
   uint channel_mask;			/* Mask of accepted channel types (NB_*) */
   uint proto_size;			/* Size of protocol data structure */
   uint config_size;			/* Size of protocol config data structure */
 
+  uint eattr_begin;			/* First ID of registered eattrs */
+  uint eattr_end;			/* End of eattr id zone */
+
   void (*preconfig)(struct protocol *, struct config *);	/* Just before configuring */
   void (*postconfig)(struct proto_config *);			/* After configuring each instance */
   struct proto * (*init)(struct proto_config *);		/* Create new instance */
@@ -79,7 +61,7 @@ struct protocol {
   void (*cleanup)(struct proto *);		/* Called after shutdown when protocol became hungry/down */
   void (*get_status)(struct proto *, byte *buf); /* Get instance status (for `show protocols' command) */
   void (*get_route_info)(struct rte *, byte *buf); /* Get route information (for `show route' command) */
-  int (*get_attr)(const struct eattr *, byte *buf, int buflen);	/* ASCIIfy dynamic attribute (returns GA_*) */
+//  int (*get_attr)(const struct eattr *, byte *buf, int buflen);	/* ASCIIfy dynamic attribute (returns GA_*) */
   void (*show_proto_info)(struct proto *);	/* Show protocol info (for `show protocols all' command) */
   void (*copy_config)(struct proto_config *, struct proto_config *);	/* Copy config from given protocol instance */
 };
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index afa95eec..a763db4d 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -60,6 +60,11 @@
 
 const adata null_adata;		/* adata of length 0 */
 
+struct ea_class ea_gen_igp_metric = {
+  .name = "igp_metric",
+  .type = T_INT,
+};
+
 const char * const rta_src_names[RTS_MAX] = {
   [RTS_STATIC]		= "static",
   [RTS_INHERIT]		= "inherit",
@@ -401,6 +406,117 @@ nexthop_free(struct nexthop *o)
  *	Extended Attributes
  */
 
+#define EA_CLASS_INITIAL_MAX	128
+static struct ea_class **ea_class_global = NULL;
+static uint ea_class_max;
+static struct idm ea_class_idm;
+
+/* Config parser lex register function */
+void ea_lex_register(struct ea_class *def);
+void ea_lex_unregister(struct ea_class *def);
+
+static void
+ea_class_free(struct ea_class *cl)
+{
+  /* No more ea class references. Unregister the attribute. */
+  idm_free(&ea_class_idm, cl->id);
+  ea_class_global[cl->id] = NULL;
+  ea_lex_unregister(cl);
+}
+
+static void
+ea_class_ref_free(resource *r)
+{
+  struct ea_class_ref *ref = SKIP_BACK(struct ea_class_ref, r, r);
+  if (!--ref->class->uc)
+    ea_class_free(ref->class);
+}
+
+static void
+ea_class_ref_dump(resource *r)
+{
+  struct ea_class_ref *ref = SKIP_BACK(struct ea_class_ref, r, r);
+  debug("name \"%s\", type=%d\n", ref->class->name, ref->class->type);
+}
+
+static struct resclass ea_class_ref_class = {
+  .name = "Attribute class reference",
+  .size = sizeof(struct ea_class_ref),
+  .free = ea_class_ref_free,
+  .dump = ea_class_ref_dump,
+  .lookup = NULL,
+  .memsize = NULL,
+};
+
+static void
+ea_class_init(void)
+{
+  idm_init(&ea_class_idm, rta_pool, EA_CLASS_INITIAL_MAX);
+  ea_class_global = mb_allocz(rta_pool,
+      sizeof(*ea_class_global) * (ea_class_max = EA_CLASS_INITIAL_MAX));
+}
+
+static struct ea_class_ref *
+ea_ref_class(pool *p, struct ea_class *def)
+{
+  def->uc++;
+  struct ea_class_ref *ref = ralloc(p, &ea_class_ref_class);
+  ref->class = def;
+  return ref;
+}
+
+static struct ea_class_ref *
+ea_register(pool *p, struct ea_class *def)
+{
+  def->id = idm_alloc(&ea_class_idm);
+
+  ASSERT_DIE(ea_class_global);
+  while (def->id >= ea_class_max)
+    ea_class_global = mb_realloc(ea_class_global, sizeof(*ea_class_global) * (ea_class_max *= 2));
+
+  ASSERT_DIE(def->id < ea_class_max);
+  ea_class_global[def->id] = def;
+
+  ea_lex_register(def);
+
+  return ea_ref_class(p, def);
+}
+
+struct ea_class_ref *
+ea_register_alloc(pool *p, struct ea_class cl)
+{
+  struct ea_class *clp = ea_class_find_by_name(cl.name);
+  if (clp && clp->type == cl.type)
+    return ea_ref_class(p, clp);
+
+  uint namelen = strlen(cl.name) + 1;
+
+  struct {
+    struct ea_class cl;
+    char name[0];
+  } *cla = mb_alloc(rta_pool, sizeof(struct ea_class) + namelen);
+  cla->cl = cl;
+  memcpy(cla->name, cl.name, namelen);
+  cla->cl.name = cla->name;
+
+  return ea_register(p, &cla->cl);
+}
+
+void
+ea_register_init(struct ea_class *clp)
+{
+  ASSERT_DIE(!ea_class_find_by_name(clp->name));
+  ea_register(&root_pool, clp);
+}
+
+struct ea_class *
+ea_class_find_by_id(uint id)
+{
+  ASSERT_DIE(id < ea_class_max);
+  ASSERT_DIE(ea_class_global[id]);
+  return ea_class_global[id];
+}
+
 static inline eattr *
 ea__find(ea_list *e, unsigned id)
 {
@@ -444,7 +560,7 @@ ea__find(ea_list *e, unsigned id)
  * to its &eattr structure or %NULL if no such attribute exists.
  */
 eattr *
-ea_find(ea_list *e, unsigned id)
+ea_find_by_id(ea_list *e, unsigned id)
 {
   eattr *a = ea__find(e, id & EA_CODE_MASK);
 
@@ -784,26 +900,44 @@ ea_list_copy(ea_list *n, ea_list *o, uint elen)
   ASSERT_DIE(adpos == elen);
 }
 
-static inline void
-ea_free(ea_list *o)
+static void
+ea_list_ref(ea_list *l)
 {
-  if (o)
+  for(uint i=0; i<l->count; i++)
     {
-      ASSERT(!o->next);
-      mb_free(o);
+      eattr *a = &l->attrs[i];
+      ASSERT_DIE(a->id < ea_class_max);
+
+      struct ea_class *cl = ea_class_global[a->id];
+      ASSERT_DIE(cl && cl->uc);
+      cl->uc++;
     }
 }
 
-static int
-get_generic_attr(const eattr *a, byte **buf, int buflen UNUSED)
+static void
+ea_list_unref(ea_list *l)
 {
-  if (a->id == EA_GEN_IGP_METRIC)
+  for(uint i=0; i<l->count; i++)
     {
-      *buf += bsprintf(*buf, "igp_metric");
-      return GA_NAME;
+      eattr *a = &l->attrs[i];
+      ASSERT_DIE(a->id < ea_class_max);
+
+      struct ea_class *cl = ea_class_global[a->id];
+      ASSERT_DIE(cl && cl->uc);
+      if (!--cl->uc)
+	ea_class_free(cl);
     }
+}
 
-  return GA_UNKNOWN;
+static inline void
+ea_free(ea_list *o)
+{
+  if (o)
+    {
+      ea_list_unref(o);
+      ASSERT(!o->next);
+      mb_free(o);
+    }
 }
 
 void
@@ -905,47 +1039,27 @@ ea_show_lc_set(struct cli *c, const struct adata *ad, byte *pos, byte *buf, byte
 void
 ea_show(struct cli *c, const eattr *e)
 {
-  struct protocol *p;
-  int status = GA_UNKNOWN;
   const struct adata *ad = (e->type & EAF_EMBEDDED) ? NULL : e->u.ptr;
   byte buf[CLI_MSG_SIZE];
   byte *pos = buf, *end = buf + sizeof(buf);
 
-  if (EA_IS_CUSTOM(e->id))
-    {
-      const char *name = ea_custom_name(e->id);
-      if (name)
-        {
-	  pos += bsprintf(pos, "%s", name);
-	  status = GA_NAME;
-	}
-      else
-	pos += bsprintf(pos, "%02x.", EA_PROTO(e->id));
-    }
-  else if (p = class_to_protocol[EA_PROTO(e->id)])
-    {
-      pos += bsprintf(pos, "%s.", p->name);
-      if (p->get_attr)
-	status = p->get_attr(e, pos, end - pos);
-      pos += strlen(pos);
-    }
-  else if (EA_PROTO(e->id))
-    pos += bsprintf(pos, "%02x.", EA_PROTO(e->id));
-  else
-    status = get_generic_attr(e, &pos, end - pos);
+  ASSERT_DIE(e->id < ea_class_max);
 
-  if (status < GA_NAME)
-    pos += bsprintf(pos, "%02x", EA_ID(e->id));
-  if (status < GA_FULL)
-    {
-      *pos++ = ':';
-      *pos++ = ' ';
+  struct ea_class *cls = ea_class_global[e->id];
+  ASSERT_DIE(cls);
 
-      if (e->undef)
-	bsprintf(pos, "undefined");
-      else
-      switch (e->type)
-	{
+  pos += bsprintf(pos, "%s", cls->name);
+
+  *pos++ = ':';
+  *pos++ = ' ';
+
+  if (e->undef)
+    bsprintf(pos, "undefined (should not happen)");
+  else if (cls->format)
+    cls->format(e, buf, end - buf);
+  else
+    switch (e->type)
+      {
 	case T_INT:
 	  bsprintf(pos, "%u", e->u.data);
 	  break;
@@ -970,13 +1084,10 @@ ea_show(struct cli *c, const eattr *e)
 	case T_LCLIST:
 	  ea_show_lc_set(c, ad, pos, buf, end);
 	  return;
-	case T_IFACE:
-	  bsprintf(pos, "%s", ((struct iface *) e->u.ptr)->name);
-	  return;
 	default:
 	  bsprintf(pos, "<type %02x>", e->type);
-	}
-    }
+      }
+
   cli_printf(c, -1012, "\t%s", buf);
 }
 
@@ -1006,7 +1117,7 @@ ea_dump(ea_list *e)
       for(i=0; i<e->count; i++)
 	{
 	  eattr *a = &e->attrs[i];
-	  debug(" %02x:%02x.%02x", EA_PROTO(a->id), EA_ID(a->id), a->flags);
+	  debug(" %04x.%02x", a->id, a->flags);
 	  debug("=%c",
 	      "?iO?IRP???S??pE?"
 	      "??L???N?????????"
@@ -1157,6 +1268,7 @@ rta_copy(rta *o)
   uint elen = ea_list_size(o->eattrs);
   r->eattrs = mb_alloc(rta_pool, elen);
   ea_list_copy(r->eattrs, o->eattrs, elen);
+  ea_list_ref(r->eattrs);
   r->eattrs->flags |= EALF_CACHED;
   return r;
 }
@@ -1357,6 +1469,9 @@ rta_init(void)
 
   rta_alloc_hash();
   rte_src_init();
+  ea_class_init();
+
+  ea_register_init(&ea_gen_igp_metric);
 }
 
 /*
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index 82533321..bdf8584d 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -185,7 +185,6 @@ dev_copy_config(struct proto_config *dest, struct proto_config *src)
 struct protocol proto_device = {
   .name =		"Direct",
   .template =		"direct%d",
-  .class =		PROTOCOL_DIRECT,
   .preference =		DEF_PREF_DIRECT,
   .channel_mask =	NB_IP | NB_IP6_SADR,
   .proto_size =		sizeof(struct rt_dev_proto),
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 049b7a7f..af59d63b 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -2536,14 +2536,14 @@ net_flow_has_dst_prefix(const net_addr *n)
 static inline int
 rta_as_path_is_empty(rta *a)
 {
-  eattr *e = ea_find(a->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+  eattr *e = ea_find(a->eattrs, "bgp_path");
   return !e || (as_path_getlen(e->u.ptr) == 0);
 }
 
 static inline u32
 rta_get_first_asn(rta *a)
 {
-  eattr *e = ea_find(a->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+  eattr *e = ea_find(a->eattrs, "bgp_path");
   u32 asn;
 
   return (e && as_path_get_first_regular(e->u.ptr, &asn)) ? asn : 0;
@@ -2587,8 +2587,8 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
     return 0;
 
   /* Find ORIGINATOR_ID values */
-  u32 orig_a = ea_get_int(a->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID), 0);
-  u32 orig_b = ea_get_int(rb->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID), 0);
+  u32 orig_a = ea_get_int(a->eattrs, "bgp_originator_id", 0);
+  u32 orig_b = ea_get_int(rb->attrs->eattrs, "bgp_originator_id", 0);
 
   /* Originator is either ORIGINATOR_ID (if present), or BGP neighbor address (if not) */
   if ((orig_a != orig_b) || (!orig_a && !orig_b && !ipa_equal(a->from, rb->attrs->from)))
@@ -3458,7 +3458,7 @@ if_local_addr(ip_addr a, struct iface *i)
 u32
 rt_get_igp_metric(rte *rt)
 {
-  eattr *ea = ea_find(rt->attrs->eattrs, EA_GEN_IGP_METRIC);
+  eattr *ea = ea_find(rt->attrs->eattrs, "igp_metric");
 
   if (ea)
     return ea->u.data;
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index db710a0d..97dca4ac 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -37,6 +37,7 @@
 
 #include <stdlib.h>
 #include "babel.h"
+#include "lib/macro.h"
 
 #define LOG_PKT_AUTH(msg, args...) \
   log_rl(&p->log_pkt_tbf, L_AUTH "%s: " msg, p->p.name, args)
@@ -58,6 +59,8 @@ static void babel_update_cost(struct babel_neighbor *n);
 static inline void babel_kick_timer(struct babel_proto *p);
 static inline void babel_iface_kick_timer(struct babel_iface *ifa);
 
+static struct ea_class ea_babel_metric, ea_babel_router_id, ea_babel_seqno;
+
 /*
  *	Functions to maintain data structures
  */
@@ -646,9 +649,9 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
     } eattrs = {
       .l.count = 3,
       .a = {
-	EA_LITERAL_EMBEDDED(EA_BABEL_METRIC, T_INT, 0, r->metric),
-	EA_LITERAL_STORE_ADATA(EA_BABEL_ROUTER_ID, T_OPAQUE, 0, &r->router_id, sizeof(r->router_id)),
-	EA_LITERAL_EMBEDDED(EA_BABEL_SEQNO, T_INT, 0, r->seqno),
+	EA_LITERAL_EMBEDDED(&ea_babel_metric, 0, r->metric),
+	EA_LITERAL_STORE_ADATA(&ea_babel_router_id, 0, &r->router_id, sizeof(r->router_id)),
+	EA_LITERAL_EMBEDDED(&ea_babel_seqno, 0, r->seqno),
       }
     };
 
@@ -2018,38 +2021,40 @@ static void
 babel_get_route_info(rte *rte, byte *buf)
 {
   u64 rid = 0;
-  eattr *e = ea_find(rte->attrs->eattrs, EA_BABEL_ROUTER_ID);
+  eattr *e = ea_find(rte->attrs->eattrs, &ea_babel_router_id);
   if (e)
     memcpy(&rid, e->u.ptr->data, sizeof(u64));
 
   buf += bsprintf(buf, " (%d/%d) [%lR]", rte->attrs->pref,
-      ea_get_int(rte->attrs->eattrs, EA_BABEL_METRIC, BABEL_INFINITY), rid);
+      ea_get_int(rte->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY), rid);
 }
 
-static int
-babel_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
+static void
+babel_router_id_format(const eattr *a, byte *buf, uint len)
 {
-  switch (a->id)
-  {
-  case EA_BABEL_SEQNO:
-    return GA_FULL;
+  u64 rid = 0;
+  memcpy(&rid, a->u.ptr->data, sizeof(u64));
+  bsnprintf(buf, len, "%lR", rid);
+}
 
-  case EA_BABEL_METRIC:
-    bsprintf(buf, "metric: %d", a->u.data);
-    return GA_FULL;
+static struct ea_class ea_babel_metric = {
+  .name = "babel_metric",
+  .type = T_INT,
+};
 
-  case EA_BABEL_ROUTER_ID:
-  {
-    u64 rid = 0;
-    memcpy(&rid, a->u.ptr->data, sizeof(u64));
-    bsprintf(buf, "router_id: %lR", rid);
-    return GA_FULL;
-  }
+static struct ea_class ea_babel_router_id = {
+  .name = "babel_router_id",
+  .type = T_OPAQUE,
+  .readonly = 1,
+  .format = babel_router_id_format,
+};
+
+static struct ea_class ea_babel_seqno = {
+  .name = "babel_seqno",
+  .type = T_INT,
+  .readonly = 1,
+};
 
-  default:
-    return GA_UNKNOWN;
-  }
-}
 
 void
 babel_show_interfaces(struct proto *P, const char *iff)
@@ -2272,13 +2277,13 @@ babel_rt_notify(struct proto *P, struct channel *c UNUSED, struct network *net,
   {
     /* Update */
     uint rt_seqno;
-    uint rt_metric = ea_get_int(new->attrs->eattrs, EA_BABEL_METRIC, 0);
+    uint rt_metric = ea_get_int(new->attrs->eattrs, &ea_babel_metric, 0);
     u64 rt_router_id = 0;
 
     if (new->src->proto == P)
     {
-      rt_seqno = ea_find(new->attrs->eattrs, EA_BABEL_SEQNO)->u.data;
-      eattr *e = ea_find(new->attrs->eattrs, EA_BABEL_ROUTER_ID);
+      rt_seqno = ea_get_int(new->attrs->eattrs, &ea_babel_seqno, 0);
+      eattr *e = ea_find(new->attrs->eattrs, &ea_babel_router_id);
       if (e)
 	memcpy(&rt_router_id, e->u.ptr->data, sizeof(u64));
     }
@@ -2329,8 +2334,8 @@ babel_rt_notify(struct proto *P, struct channel *c UNUSED, struct network *net,
 static int
 babel_rte_better(struct rte *new, struct rte *old)
 {
-  uint new_metric = ea_find(new->attrs->eattrs, EA_BABEL_SEQNO)->u.data;
-  uint old_metric = ea_find(old->attrs->eattrs, EA_BABEL_SEQNO)->u.data;
+  uint new_metric = ea_get_int(new->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY);
+  uint old_metric = ea_get_int(old->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY);
 
   return new_metric < old_metric;
 }
@@ -2338,7 +2343,7 @@ babel_rte_better(struct rte *new, struct rte *old)
 static u32
 babel_rte_igp_metric(struct rte *rt)
 {
-  return ea_get_int(rt->attrs->eattrs, EA_BABEL_METRIC, BABEL_INFINITY);
+  return ea_get_int(rt->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY);
 }
 
 
@@ -2466,11 +2471,9 @@ babel_reconfigure(struct proto *P, struct proto_config *CF)
   return 1;
 }
 
-
 struct protocol proto_babel = {
   .name =		"Babel",
   .template =		"babel%d",
-  .class =		PROTOCOL_BABEL,
   .preference =		DEF_PREF_BABEL,
   .channel_mask =	NB_IP | NB_IP6_SADR,
   .proto_size =		sizeof(struct babel_proto),
@@ -2482,11 +2485,16 @@ struct protocol proto_babel = {
   .shutdown =		babel_shutdown,
   .reconfigure =	babel_reconfigure,
   .get_route_info =	babel_get_route_info,
-  .get_attr =		babel_get_attr
 };
 
 void
 babel_build(void)
 {
   proto_build(&proto_babel);
+
+  EA_REGISTER_ALL(
+      &ea_babel_metric,
+      &ea_babel_router_id,
+      &ea_babel_seqno
+      );
 }
diff --git a/proto/babel/babel.h b/proto/babel/babel.h
index 00814641..a980d1da 100644
--- a/proto/babel/babel.h
+++ b/proto/babel/babel.h
@@ -26,10 +26,6 @@
 #include "lib/string.h"
 #include "lib/timer.h"
 
-#define EA_BABEL_METRIC		EA_CODE(PROTOCOL_BABEL, 0)
-#define EA_BABEL_ROUTER_ID	EA_CODE(PROTOCOL_BABEL, 1)
-#define EA_BABEL_SEQNO		EA_CODE(PROTOCOL_BABEL, 2)
-
 #define BABEL_MAGIC		42
 #define BABEL_VERSION		2
 #define BABEL_PORT		6696
diff --git a/proto/babel/config.Y b/proto/babel/config.Y
index fa745993..82419b20 100644
--- a/proto/babel/config.Y
+++ b/proto/babel/config.Y
@@ -163,8 +163,6 @@ babel_iface_opt_list:
 babel_iface:
   babel_iface_start iface_patt_list_nopx babel_iface_opt_list babel_iface_finish;
 
-dynamic_attr: BABEL_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_BABEL_METRIC); } ;
-
 CF_CLI_HELP(SHOW BABEL, ..., [[Show information about Babel protocol]]);
 
 CF_CLI(SHOW BABEL INTERFACES, optproto opttext, [<name>] [\"<interface>\"], [[Show information about Babel interfaces]])
diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index d1e97cd5..1a2104ad 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -1170,7 +1170,6 @@ bfd_show_sessions(struct proto *P)
 struct protocol proto_bfd = {
   .name =		"BFD",
   .template =		"bfd%d",
-  .class =		PROTOCOL_BFD,
   .proto_size =		sizeof(struct bfd_proto),
   .config_size =	sizeof(struct bfd_config),
   .init =		bfd_init,
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 4c67b161..72a4f68a 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -21,6 +21,7 @@
 #include "lib/resource.h"
 #include "lib/string.h"
 #include "lib/unaligned.h"
+#include "lib/macro.h"
 
 #include "bgp.h"
 
@@ -64,28 +65,37 @@
  * format - Optional hook that converts eattr to textual representation.
  */
 
-
-struct bgp_attr_desc {
-  const char *name;
-  uint type;
-  uint flags;
-  void (*export)(struct bgp_export_state *s, eattr *a);
-  int  (*encode)(struct bgp_write_state *s, eattr *a, byte *buf, uint size);
-  void (*decode)(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to);
-  void (*format)(const eattr *ea, byte *buf, uint size);
+union bgp_attr_desc {
+  struct ea_class class;
+  struct {
+    EA_CLASS_INSIDE;
+    uint flags;
+    void (*export)(struct bgp_export_state *s, eattr *a);
+    int  (*encode)(struct bgp_write_state *s, eattr *a, byte *buf, uint size);
+    void (*decode)(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to);
+  };
 };
 
-static const struct bgp_attr_desc bgp_attr_table[];
+static union bgp_attr_desc bgp_attr_table[];
+static inline const union bgp_attr_desc *bgp_find_attr_desc(eattr *a)
+{
+  const struct ea_class *class = ea_class_find(a->id);
+
+  if ((class < &bgp_attr_table[0].class) || (class >= &bgp_attr_table[BGP_ATTR_MAX].class))
+    return NULL;
+
+  return (const union bgp_attr_desc *) class;
+}
 
-static inline int bgp_attr_known(uint code);
+#define BGP_EA_ID(code)	(bgp_attr_table[code].id)
+#define EA_BGP_ID(code)	(((union bgp_attr_desc *) ea_class_find(code)) - bgp_attr_table)
 
 void bgp_set_attr_u32(ea_list **to, uint code, uint flags, u32 val)
 {
-  ASSERT(bgp_attr_known(code));
+  const union bgp_attr_desc *desc = &bgp_attr_table[code];
 
   ea_set_attr(to, EA_LITERAL_EMBEDDED(
-	EA_CODE(PROTOCOL_BGP, code),
-	bgp_attr_table[code].type,
+	&desc->class,
 	flags & ~BAF_EXT_LEN,
 	val
 	));
@@ -93,11 +103,10 @@ void bgp_set_attr_u32(ea_list **to, uint code, uint flags, u32 val)
 
 void bgp_set_attr_ptr(ea_list **to, uint code, uint flags, const struct adata *ad)
 {
-  ASSERT(bgp_attr_known(code));
+  const union bgp_attr_desc *desc = &bgp_attr_table[code];
 
   ea_set_attr(to, EA_LITERAL_DIRECT_ADATA(
-	EA_CODE(PROTOCOL_BGP, code),
-	bgp_attr_table[code].type,
+	&desc->class,
 	flags & ~BAF_EXT_LEN,
 	ad
 	));
@@ -106,17 +115,23 @@ void bgp_set_attr_ptr(ea_list **to, uint code, uint flags, const struct adata *a
 void
 bgp_set_attr_data(ea_list **to, uint code, uint flags, void *data, uint len)
 {
-  ASSERT(bgp_attr_known(code));
+  const union bgp_attr_desc *desc = &bgp_attr_table[code];
 
   ea_set_attr(to, EA_LITERAL_STORE_ADATA(
-	EA_CODE(PROTOCOL_BGP, code),
-	bgp_attr_table[code].type,
+	&desc->class,
 	flags & ~BAF_EXT_LEN,
 	data,
 	len
 	));
 }
 
+void
+bgp_unset_attr(ea_list **to, uint code)
+{
+  const union bgp_attr_desc *desc = &bgp_attr_table[code];
+  ea_unset_attr(to, 0, &desc->class);
+}
+
 #define REPORT(msg, args...) \
   ({ log(L_REMOTE "%s: " msg, s->proto->p.name, ## args); })
 
@@ -172,7 +187,7 @@ bgp_encode_u8(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
   if (size < (3+1))
     return -1;
 
-  bgp_put_attr_hdr3(buf, EA_ID(a->id), a->flags, 1);
+  bgp_put_attr_hdr3(buf, EA_BGP_ID(a->id), a->flags, 1);
   buf[3] = a->u.data;
 
   return 3+1;
@@ -184,7 +199,7 @@ bgp_encode_u32(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
   if (size < (3+4))
     return -1;
 
-  bgp_put_attr_hdr3(buf, EA_ID(a->id), a->flags, 4);
+  bgp_put_attr_hdr3(buf, EA_BGP_ID(a->id), a->flags, 4);
   put_u32(buf+3, a->u.data);
 
   return 3+4;
@@ -198,7 +213,7 @@ bgp_encode_u32s(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size
   if (size < (4+len))
     return -1;
 
-  uint hdr = bgp_put_attr_hdr(buf, EA_ID(a->id), a->flags, len);
+  uint hdr = bgp_put_attr_hdr(buf, EA_BGP_ID(a->id), a->flags, len);
   put_u32s(buf + hdr, (u32 *) a->u.ptr->data, len / 4);
 
   return hdr + len;
@@ -219,7 +234,7 @@ bgp_put_attr(byte *buf, uint size, uint code, uint flags, const byte *data, uint
 static int
 bgp_encode_raw(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
 {
-  return bgp_put_attr(buf, size, EA_ID(a->id), a->flags, a->u.ptr->data, a->u.ptr->length);
+  return bgp_put_attr(buf, size, EA_BGP_ID(a->id), a->flags, a->u.ptr->data, a->u.ptr->length);
 }
 
 
@@ -359,7 +374,7 @@ bgp_aigp_set_metric(struct linpool *pool, const struct adata *ad, u64 metric)
 int
 bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad)
 {
-  eattr *a = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AIGP));
+  eattr *a = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_AIGP));
   if (!a)
     return 0;
 
@@ -993,11 +1008,30 @@ bgp_format_mpls_label_stack(const eattr *a, byte *buf, uint size)
   pos[lnum ? -1 : 0] = 0;
 }
 
+static inline void
+bgp_export_unknown(struct bgp_export_state *s UNUSED, eattr *a)
+{
+  if (!(a->flags & BAF_TRANSITIVE))
+    UNSET(a);
+
+  a->flags |= BAF_PARTIAL;
+}
+
 static inline void
 bgp_decode_unknown(struct bgp_parse_state *s UNUSED, uint code, uint flags, byte *data, uint len, ea_list **to)
 {
+  if (!(flags & BAF_OPTIONAL))
+    WITHDRAW("Unknown attribute (code %u) - conflicting flags (%02x)", code, flags);
+
   /* Cannot use bgp_set_attr_data() as it works on known attributes only */
-  ea_set_attr_data(to, EA_CODE(PROTOCOL_BGP, code), flags, T_OPAQUE, data, len);
+  ea_set_attr_data(to, &bgp_attr_table[code].class, flags, data, len);
+}
+
+static inline void
+bgp_format_unknown(const eattr *a, byte *buf, uint size)
+{
+  if (a->flags & BAF_TRANSITIVE)
+    bsnprintf(buf, size, "(transitive)");
 }
 
 
@@ -1005,9 +1039,9 @@ bgp_decode_unknown(struct bgp_parse_state *s UNUSED, uint code, uint flags, byte
  *	Attribute table
  */
 
-static const struct bgp_attr_desc bgp_attr_table[] = {
+static union bgp_attr_desc bgp_attr_table[BGP_ATTR_MAX] = {
   [BA_ORIGIN] = {
-    .name = "origin",
+    .name = "bgp_origin",
     .type = T_ENUM_BGP_ORIGIN,
     .flags = BAF_TRANSITIVE,
     .export = bgp_export_origin,
@@ -1016,14 +1050,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .format = bgp_format_origin,
   },
   [BA_AS_PATH] = {
-    .name = "as_path",
+    .name = "bgp_path",
     .type = T_PATH,
     .flags = BAF_TRANSITIVE,
     .encode = bgp_encode_as_path,
     .decode = bgp_decode_as_path,
   },
   [BA_NEXT_HOP] = {
-    .name = "next_hop",
+    .name = "bgp_next_hop",
     .type = T_IP,
     .flags = BAF_TRANSITIVE,
     .encode = bgp_encode_next_hop,
@@ -1031,14 +1065,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .format = bgp_format_next_hop,
   },
   [BA_MULTI_EXIT_DISC] = {
-    .name = "med",
+    .name = "bgp_med",
     .type = T_INT,
     .flags = BAF_OPTIONAL,
     .encode = bgp_encode_u32,
     .decode = bgp_decode_med,
   },
   [BA_LOCAL_PREF] = {
-    .name = "local_pref",
+    .name = "bgp_local_pref",
     .type = T_INT,
     .flags = BAF_TRANSITIVE,
     .export = bgp_export_local_pref,
@@ -1046,14 +1080,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .decode = bgp_decode_local_pref,
   },
   [BA_ATOMIC_AGGR] = {
-    .name = "atomic_aggr",
+    .name = "bgp_atomic_aggr",
     .type = T_OPAQUE,
     .flags = BAF_TRANSITIVE,
     .encode = bgp_encode_raw,
     .decode = bgp_decode_atomic_aggr,
   },
   [BA_AGGREGATOR] = {
-    .name = "aggregator",
+    .name = "bgp_aggregator",
     .type = T_OPAQUE,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .encode = bgp_encode_aggregator,
@@ -1061,7 +1095,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .format = bgp_format_aggregator,
   },
   [BA_COMMUNITY] = {
-    .name = "community",
+    .name = "bgp_community",
     .type = T_CLIST,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .export = bgp_export_community,
@@ -1069,7 +1103,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .decode = bgp_decode_community,
   },
   [BA_ORIGINATOR_ID] = {
-    .name = "originator_id",
+    .name = "bgp_originator_id",
     .type = T_QUAD,
     .flags = BAF_OPTIONAL,
     .export = bgp_export_originator_id,
@@ -1077,7 +1111,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .decode = bgp_decode_originator_id,
   },
   [BA_CLUSTER_LIST] = {
-    .name = "cluster_list",
+    .name = "bgp_cluster_list",
     .type = T_CLIST,
     .flags = BAF_OPTIONAL,
     .export = bgp_export_cluster_list,
@@ -1086,19 +1120,19 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .format = bgp_format_cluster_list,
   },
   [BA_MP_REACH_NLRI] = {
-    .name = "mp_reach_nlri",
+    .name = "bgp_mp_reach_nlri",
     .type = T_OPAQUE,
     .flags = BAF_OPTIONAL,
     .decode = bgp_decode_mp_reach_nlri,
   },
   [BA_MP_UNREACH_NLRI] = {
-    .name = "mp_unreach_nlri",
+    .name = "bgp_mp_unreach_nlri",
     .type = T_OPAQUE,
     .flags = BAF_OPTIONAL,
     .decode = bgp_decode_mp_unreach_nlri,
   },
   [BA_EXT_COMMUNITY] = {
-    .name = "ext_community",
+    .name = "bgp_ext_community",
     .type = T_ECLIST,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .export = bgp_export_ext_community,
@@ -1106,14 +1140,14 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .decode = bgp_decode_ext_community,
   },
   [BA_AS4_PATH] = {
-    .name = "as4_path",
+    .name = "bgp_as4_path",
     .type = T_PATH,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .encode = bgp_encode_raw,
     .decode = bgp_decode_as4_path,
   },
   [BA_AS4_AGGREGATOR] = {
-    .name = "as4_aggregator",
+    .name = "bgp_as4_aggregator",
     .type = T_OPAQUE,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .encode = bgp_encode_raw,
@@ -1121,7 +1155,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .format = bgp_format_aggregator,
   },
   [BA_AIGP] = {
-    .name = "aigp",
+    .name = "bgp_aigp",
     .type = T_OPAQUE,
     .flags = BAF_OPTIONAL | BAF_DECODE_FLAGS,
     .export = bgp_export_aigp,
@@ -1130,7 +1164,7 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .format = bgp_format_aigp,
   },
   [BA_LARGE_COMMUNITY] = {
-    .name = "large_community",
+    .name = "bgp_large_community",
     .type = T_LCLIST,
     .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
     .export = bgp_export_large_community,
@@ -1138,8 +1172,9 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
     .decode = bgp_decode_large_community,
   },
   [BA_MPLS_LABEL_STACK] = {
-    .name = "mpls_label_stack",
+    .name = "bgp_mpls_label_stack",
     .type = T_CLIST,
+    .readonly = 1,
     .export = bgp_export_mpls_label_stack,
     .encode = bgp_encode_mpls_label_stack,
     .decode = bgp_decode_mpls_label_stack,
@@ -1147,12 +1182,32 @@ static const struct bgp_attr_desc bgp_attr_table[] = {
   },
 };
 
-static inline int
-bgp_attr_known(uint code)
+eattr *
+bgp_find_attr(ea_list *attrs, uint code)
 {
-  return (code < ARRAY_SIZE(bgp_attr_table)) && bgp_attr_table[code].name;
+  return ea_find(attrs, BGP_EA_ID(code));
 }
 
+void
+bgp_register_attrs(void)
+{
+  for (uint i=0; i<ARRAY_SIZE(bgp_attr_table); i++)
+  {
+    if (!bgp_attr_table[i].name)
+      bgp_attr_table[i] = (union bgp_attr_desc) {
+	.name = mb_sprintf(&root_pool, "bgp_unknown_0x%02x", i),
+	.type = T_OPAQUE,
+	.flags = BAF_OPTIONAL,
+	.readonly = 1,
+	.export = bgp_export_unknown,
+	.encode = bgp_encode_raw,
+	.decode = bgp_decode_unknown,
+	.format = bgp_format_unknown,
+      };
+
+    ea_register_init(&bgp_attr_table[i].class);
+  }
+}
 
 /*
  *	Attribute export
@@ -1161,38 +1216,24 @@ bgp_attr_known(uint code)
 static inline void
 bgp_export_attr(struct bgp_export_state *s, eattr *a, ea_list *to)
 {
-  if (EA_PROTO(a->id) != PROTOCOL_BGP)
+  const union bgp_attr_desc *desc = bgp_find_attr_desc(a);
+  if (!desc)
     return;
 
-  uint code = EA_ID(a->id);
-
-  if (bgp_attr_known(code))
-  {
-    const struct bgp_attr_desc *desc = &bgp_attr_table[code];
-
-    /* The flags might have been zero if the attr was added by filters */
-    a->flags = (a->flags & BAF_PARTIAL) | desc->flags;
-
-    /* Set partial bit if new opt-trans attribute is attached to non-local route */
-    if ((s->src != NULL) && (a->originated) &&
-	(a->flags & BAF_OPTIONAL) && (a->flags & BAF_TRANSITIVE))
-      a->flags |= BAF_PARTIAL;
+  /* The flags might have been zero if the attr was added locally */
+  a->flags = (a->flags & BAF_PARTIAL) | desc->flags;
 
-    /* Call specific hook */
-    CALL(desc->export, s, a);
+  /* Set partial bit if new opt-trans attribute is attached to non-local route */
+  if ((s->src != NULL) && (a->originated) &&
+      (a->flags & BAF_OPTIONAL) && (a->flags & BAF_TRANSITIVE))
+    a->flags |= BAF_PARTIAL;
 
-    /* Attribute might become undefined in hook */
-    if (a->undef)
-      return;
-  }
-  else
-  {
-    /* Don't re-export unknown non-transitive attributes */
-    if (!(a->flags & BAF_TRANSITIVE))
-      return;
+  /* Call specific hook */
+  CALL(desc->export, s, a);
 
-    a->flags |= BAF_PARTIAL;
-  }
+  /* Attribute might become undefined in hook */
+  if (a->undef)
+    return;
 
   /* Append updated attribute */
   to->attrs[to->count++] = *a;
@@ -1240,14 +1281,9 @@ bgp_export_attrs(struct bgp_export_state *s, const ea_list *a)
 static inline int
 bgp_encode_attr(struct bgp_write_state *s, eattr *a, byte *buf, uint size)
 {
-  ASSERT(EA_PROTO(a->id) == PROTOCOL_BGP);
-
-  uint code = EA_ID(a->id);
-
-  if (bgp_attr_known(code))
-    return bgp_attr_table[code].encode(s, a, buf, size);
-  else
-    return bgp_encode_raw(s, a, buf, size);
+  const union bgp_attr_desc *desc = bgp_find_attr_desc(a);
+  ASSERT_DIE(desc);
+  return desc->encode(s, a, buf, size);
 }
 
 /**
@@ -1312,7 +1348,7 @@ bgp_cluster_list_loopy(struct bgp_proto *p, ea_list *attrs)
 }
 
 static inline void
-bgp_decode_attr(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to)
+bgp_decode_attr(struct bgp_parse_state *s, byte code, byte flags, byte *data, uint len, ea_list **to)
 {
   /* Handle duplicate attributes; RFC 7606 3 (g) */
   if (BIT32_TEST(s->attrs_seen, code))
@@ -1324,24 +1360,15 @@ bgp_decode_attr(struct bgp_parse_state *s, uint code, uint flags, byte *data, ui
   }
   BIT32_SET(s->attrs_seen, code);
 
-  if (bgp_attr_known(code))
-  {
-    const struct bgp_attr_desc *desc = &bgp_attr_table[code];
+  ASSERT_DIE(bgp_attr_table[code].id);
+  const union bgp_attr_desc *desc = &bgp_attr_table[code];
 
-    /* Handle conflicting flags; RFC 7606 3 (c) */
-    if (((flags ^ desc->flags) & (BAF_OPTIONAL | BAF_TRANSITIVE)) &&
-	!(desc->flags & BAF_DECODE_FLAGS))
-      WITHDRAW("Malformed %s attribute - conflicting flags (%02x)", desc->name, flags);
+  /* Handle conflicting flags; RFC 7606 3 (c) */
+  if (((flags ^ desc->flags) & (BAF_OPTIONAL | BAF_TRANSITIVE)) &&
+      !(desc->flags & BAF_DECODE_FLAGS))
+    WITHDRAW("Malformed %s attribute - conflicting flags (%02x, expected %02x)", desc->name, flags, desc->flags);
 
-    desc->decode(s, code, flags, data, len, to);
-  }
-  else /* Unknown attribute */
-  {
-    if (!(flags & BAF_OPTIONAL))
-      WITHDRAW("Unknown attribute (code %u) - conflicting flags (%02x)", code, flags);
-
-    bgp_decode_unknown(s, code, flags, data, len, to);
-  }
+  desc->decode(s, code, flags, data, len, to);
 }
 
 /**
@@ -1359,7 +1386,8 @@ bgp_decode_attrs(struct bgp_parse_state *s, byte *data, uint len)
 {
   struct bgp_proto *p = s->proto;
   ea_list *attrs = NULL;
-  uint code, flags, alen;
+  uint alen;
+  byte code, flags;
   byte *pos = data;
 
   /* Parse the attributes */
@@ -1703,7 +1731,7 @@ bgp_preexport(struct proto *P, rte *e)
   /* Handle well-known communities, RFC 1997 */
   struct eattr *c;
   if (p->cf->interpret_communities &&
-      (c = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY))))
+      (c = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_COMMUNITY))))
   {
     const struct adata *d = c->u.ptr;
 
@@ -1880,7 +1908,7 @@ bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old)
 static inline u32
 bgp_get_neighbor(rte *r)
 {
-  eattr *e = ea_find(r->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+  eattr *e = ea_find(r->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
   u32 as;
 
   if (e && as_path_get_first_regular(e->u.ptr, &as))
@@ -1901,7 +1929,7 @@ rte_stale(rte *r)
     return 0;
 
   /* If staleness is unknown, compute and cache it */
-  eattr *a = ea_find(r->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY));
+  eattr *a = ea_find(r->attrs->eattrs, BGP_EA_ID(BA_COMMUNITY));
   if (a && int_set_contains(a->u.ptr, BGP_COMM_LLGR_STALE))
   {
     r->pflags |= BGP_REF_STALE;
@@ -1947,8 +1975,8 @@ bgp_rte_better(rte *new, rte *old)
     return 1;
 
  /* Start with local preferences */
-  x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
-  y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
+  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
+  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
   n = x ? x->u.data : new_bgp->cf->default_local_pref;
   o = y ? y->u.data : old_bgp->cf->default_local_pref;
   if (n > o)
@@ -1967,8 +1995,8 @@ bgp_rte_better(rte *new, rte *old)
   /* RFC 4271 9.1.2.2. a)  Use AS path lengths */
   if (new_bgp->cf->compare_path_lengths || old_bgp->cf->compare_path_lengths)
   {
-    x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
-    y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+    x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
+    y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
     n = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
     o = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
     if (n < o)
@@ -1978,8 +2006,8 @@ bgp_rte_better(rte *new, rte *old)
   }
 
   /* RFC 4271 9.1.2.2. b) Use origins */
-  x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
-  y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
+  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
+  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
   n = x ? x->u.data : ORIGIN_INCOMPLETE;
   o = y ? y->u.data : ORIGIN_INCOMPLETE;
   if (n < o)
@@ -2001,8 +2029,8 @@ bgp_rte_better(rte *new, rte *old)
   if (new_bgp->cf->med_metric || old_bgp->cf->med_metric ||
       (bgp_get_neighbor(new) == bgp_get_neighbor(old)))
   {
-    x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
-    y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
+    x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
+    y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
     n = x ? x->u.data : new_bgp->cf->default_med;
     o = y ? y->u.data : old_bgp->cf->default_med;
     if (n < o)
@@ -2027,8 +2055,8 @@ bgp_rte_better(rte *new, rte *old)
 
   /* RFC 4271 9.1.2.2. f) Compare BGP identifiers */
   /* RFC 4456 9. a) Use ORIGINATOR_ID instead of local neighbor ID */
-  x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID));
-  y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID));
+  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_ORIGINATOR_ID));
+  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_ORIGINATOR_ID));
   n = x ? x->u.data : new_bgp->remote_id;
   o = y ? y->u.data : old_bgp->remote_id;
 
@@ -2045,8 +2073,8 @@ bgp_rte_better(rte *new, rte *old)
     return 0;
 
   /* RFC 4456 9. b) Compare cluster list lengths */
-  x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST));
-  y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST));
+  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_CLUSTER_LIST));
+  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_CLUSTER_LIST));
   n = x ? int_set_get_size(x->u.ptr) : 0;
   o = y ? int_set_get_size(y->u.ptr) : 0;
   if (n < o)
@@ -2080,8 +2108,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
     return 0;
 
   /* Start with local preferences */
-  x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
-  y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
+  x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
+  y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
   p = x ? x->u.data : pri_bgp->cf->default_local_pref;
   s = y ? y->u.data : sec_bgp->cf->default_local_pref;
   if (p != s)
@@ -2090,8 +2118,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
   /* RFC 4271 9.1.2.2. a)  Use AS path lengths */
   if (pri_bgp->cf->compare_path_lengths || sec_bgp->cf->compare_path_lengths)
   {
-    x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
-    y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
+    x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
+    y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
     p = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
     s = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
 
@@ -2103,8 +2131,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
   }
 
   /* RFC 4271 9.1.2.2. b) Use origins */
-  x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
-  y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
+  x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
+  y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
   p = x ? x->u.data : ORIGIN_INCOMPLETE;
   s = y ? y->u.data : ORIGIN_INCOMPLETE;
   if (p != s)
@@ -2114,8 +2142,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
   if (pri_bgp->cf->med_metric || sec_bgp->cf->med_metric ||
       (bgp_get_neighbor(pri) == bgp_get_neighbor(sec)))
   {
-    x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
-    y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
+    x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
+    y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
     p = x ? x->u.data : pri_bgp->cf->default_med;
     s = y ? y->u.data : sec_bgp->cf->default_med;
     if (p != s)
@@ -2281,7 +2309,7 @@ bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best)
 struct rte *
 bgp_rte_modify_stale(struct rte *r, struct linpool *pool)
 {
-  eattr *a = ea_find(r->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY));
+  eattr *a = ea_find(r->attrs->eattrs, BGP_EA_ID(BA_COMMUNITY));
   const struct adata *ad = a ? a->u.ptr : NULL;
   uint flags = a ? a->flags : BAF_PARTIAL;
 
@@ -2346,37 +2374,11 @@ bgp_process_as4_attrs(ea_list **attrs, struct linpool *pool)
   }
 }
 
-int
-bgp_get_attr(const eattr *a, byte *buf, int buflen)
-{
-  uint i = EA_ID(a->id);
-  const struct bgp_attr_desc *d;
-  int len;
-
-  if (bgp_attr_known(i))
-  {
-    d = &bgp_attr_table[i];
-    len = bsprintf(buf, "%s", d->name);
-    buf += len;
-    if (d->format)
-    {
-      *buf++ = ':';
-      *buf++ = ' ';
-      d->format(a, buf, buflen - len - 2);
-      return GA_FULL;
-    }
-    return GA_NAME;
-  }
-
-  bsprintf(buf, "%02x%s", i, (a->flags & BAF_TRANSITIVE) ? " [t]" : "");
-  return GA_NAME;
-}
-
 void
 bgp_get_route_info(rte *e, byte *buf)
 {
-  eattr *p = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
-  eattr *o = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
+  eattr *p = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
+  eattr *o = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
   u32 origas;
 
   buf += bsprintf(buf, " (%d", e->attrs->pref);
diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c
index aec78a45..bd4c68b7 100644
--- a/proto/bgp/bgp.c
+++ b/proto/bgp/bgp.c
@@ -2576,7 +2576,6 @@ struct channel_class channel_bgp = {
 struct protocol proto_bgp = {
   .name = 		"BGP",
   .template = 		"bgp%d",
-  .class =		PROTOCOL_BGP,
   .preference = 	DEF_PREF_BGP,
   .channel_mask =	NB_IP | NB_VPN | NB_FLOW,
   .proto_size =		sizeof(struct bgp_proto),
@@ -2588,7 +2587,6 @@ struct protocol proto_bgp = {
   .reconfigure = 	bgp_reconfigure,
   .copy_config = 	bgp_copy_config,
   .get_status = 	bgp_get_status,
-  .get_attr = 		bgp_get_attr,
   .get_route_info = 	bgp_get_route_info,
   .show_proto_info = 	bgp_show_proto_info
 };
@@ -2596,4 +2594,5 @@ struct protocol proto_bgp = {
 void bgp_build(void)
 {
   proto_build(&proto_bgp);
+  bgp_register_attrs();
 }
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index de5bd836..e04e3bd0 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -538,17 +538,13 @@ rte_resolvable(rte *rt)
 
 /* attrs.c */
 
-static inline eattr *
-bgp_find_attr(ea_list *attrs, uint code)
-{
-  return ea_find(attrs, EA_CODE(PROTOCOL_BGP, code));
-}
+eattr *
+bgp_find_attr(ea_list *attrs, uint code);
 
 void bgp_set_attr_u32(ea_list **to, uint code, uint flags, u32 val);
 void bgp_set_attr_ptr(ea_list **to, uint code, uint flags, const struct adata *ad);
 void bgp_set_attr_data(ea_list **to, uint code, uint flags, void *data, uint len);
-
-#define bgp_unset_attr(to, code) ea_unset_attr(to, 0, code)
+void bgp_unset_attr(ea_list **to, uint code);
 
 int bgp_encode_mp_reach_mrt(struct bgp_write_state *s, eattr *a, byte *buf, uint size);
 
@@ -573,7 +569,6 @@ struct rte *bgp_rte_modify_stale(struct rte *r, struct linpool *pool);
 u32 bgp_rte_igp_metric(struct rte *);
 void bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old);
 int bgp_preexport(struct proto *, struct rte *);
-int bgp_get_attr(const struct eattr *e, byte *buf, int buflen);
 void bgp_get_route_info(struct rte *, byte *buf);
 int bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad);
 
@@ -590,6 +585,8 @@ bgp_total_aigp_metric(rte *r)
   return metric;
 }
 
+void bgp_register_attrs(void);
+
 
 /* packets.c */
 
@@ -626,26 +623,31 @@ void bgp_update_next_hop(struct bgp_export_state *s, eattr *a, ea_list **to);
 
 #define BAF_DECODE_FLAGS	0x0100	/* Private flag - attribute flags are handled by the decode hook */
 
-#define BA_ORIGIN		0x01	/* RFC 4271 */		/* WM */
-#define BA_AS_PATH		0x02				/* WM */
-#define BA_NEXT_HOP		0x03				/* WM */
-#define BA_MULTI_EXIT_DISC	0x04				/* ON */
-#define BA_LOCAL_PREF		0x05				/* WD */
-#define BA_ATOMIC_AGGR		0x06				/* WD */
-#define BA_AGGREGATOR		0x07				/* OT */
-#define BA_COMMUNITY		0x08	/* RFC 1997 */		/* OT */
-#define BA_ORIGINATOR_ID	0x09	/* RFC 4456 */		/* ON */
-#define BA_CLUSTER_LIST		0x0a	/* RFC 4456 */		/* ON */
-#define BA_MP_REACH_NLRI	0x0e	/* RFC 4760 */
-#define BA_MP_UNREACH_NLRI	0x0f	/* RFC 4760 */
-#define BA_EXT_COMMUNITY	0x10	/* RFC 4360 */
-#define BA_AS4_PATH             0x11	/* RFC 6793 */
-#define BA_AS4_AGGREGATOR       0x12	/* RFC 6793 */
-#define BA_AIGP			0x1a	/* RFC 7311 */
-#define BA_LARGE_COMMUNITY	0x20	/* RFC 8092 */
+enum bgp_attr_id {
+  BA_ORIGIN		= 0x01,	/* RFC 4271 */		/* WM */
+  BA_AS_PATH		= 0x02,				/* WM */
+  BA_NEXT_HOP		= 0x03,				/* WM */
+  BA_MULTI_EXIT_DISC	= 0x04,				/* ON */
+  BA_LOCAL_PREF		= 0x05,				/* WD */
+  BA_ATOMIC_AGGR	= 0x06,				/* WD */
+  BA_AGGREGATOR		= 0x07,				/* OT */
+  BA_COMMUNITY		= 0x08,	/* RFC 1997 */		/* OT */
+  BA_ORIGINATOR_ID	= 0x09,	/* RFC 4456 */		/* ON */
+  BA_CLUSTER_LIST	= 0x0a,	/* RFC 4456 */		/* ON */
+  BA_MP_REACH_NLRI	= 0x0e,	/* RFC 4760 */
+  BA_MP_UNREACH_NLRI	= 0x0f,	/* RFC 4760 */
+  BA_EXT_COMMUNITY	= 0x10,	/* RFC 4360 */
+  BA_AS4_PATH		= 0x11,	/* RFC 6793 */
+  BA_AS4_AGGREGATOR	= 0x12,	/* RFC 6793 */
+  BA_AIGP		= 0x1a,	/* RFC 7311 */
+  BA_LARGE_COMMUNITY	= 0x20,	/* RFC 8092 */
 
 /* Bird's private internal BGP attributes */
-#define BA_MPLS_LABEL_STACK	0xfe	/* MPLS label stack transfer attribute */
+  BA_MPLS_LABEL_STACK	= 0x100, /* MPLS label stack transfer attribute */
+
+/* Maximum */
+  BGP_ATTR_MAX,
+};
 
 /* BGP connection states */
 
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index 6a78f79b..db261bbb 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -316,36 +316,6 @@ bgp_channel_end:
 
 bgp_proto_channel: bgp_channel_start bgp_channel_opt_list bgp_channel_end;
 
-
-dynamic_attr: BGP_ORIGIN
-	{ $$ = f_new_dynamic_attr(T_ENUM_BGP_ORIGIN, EA_CODE(PROTOCOL_BGP, BA_ORIGIN)); } ;
-dynamic_attr: BGP_PATH
-	{ $$ = f_new_dynamic_attr(T_PATH, EA_CODE(PROTOCOL_BGP, BA_AS_PATH)); } ;
-dynamic_attr: BGP_NEXT_HOP
-	{ $$ = f_new_dynamic_attr(T_IP, EA_CODE(PROTOCOL_BGP, BA_NEXT_HOP)); } ;
-dynamic_attr: BGP_MED
-	{ $$ = f_new_dynamic_attr(T_INT, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC)); } ;
-dynamic_attr: BGP_LOCAL_PREF
-	{ $$ = f_new_dynamic_attr(T_INT, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF)); } ;
-dynamic_attr: BGP_ATOMIC_AGGR
-	{ $$ = f_new_dynamic_attr(T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_ATOMIC_AGGR)); } ;
-dynamic_attr: BGP_AGGREGATOR
-	{ $$ = f_new_dynamic_attr(T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_AGGREGATOR)); } ;
-dynamic_attr: BGP_COMMUNITY
-	{ $$ = f_new_dynamic_attr(T_CLIST, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY)); } ;
-dynamic_attr: BGP_ORIGINATOR_ID
-	{ $$ = f_new_dynamic_attr(T_QUAD, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID)); } ;
-dynamic_attr: BGP_CLUSTER_LIST
-	{ $$ = f_new_dynamic_attr(T_CLIST, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST)); } ;
-dynamic_attr: BGP_EXT_COMMUNITY
-	{ $$ = f_new_dynamic_attr(T_ECLIST, EA_CODE(PROTOCOL_BGP, BA_EXT_COMMUNITY)); } ;
-dynamic_attr: BGP_AIGP
-	{ $$ = f_new_dynamic_attr(T_OPAQUE, EA_CODE(PROTOCOL_BGP, BA_AIGP)); } ;
-dynamic_attr: BGP_LARGE_COMMUNITY
-	{ $$ = f_new_dynamic_attr(T_LCLIST, EA_CODE(PROTOCOL_BGP, BA_LARGE_COMMUNITY)); } ;
-
-
-
 CF_ENUM(T_ENUM_BGP_ORIGIN, ORIGIN_, IGP, EGP, INCOMPLETE)
 
 CF_CODE
diff --git a/proto/mrt/mrt.c b/proto/mrt/mrt.c
index c595f298..e45f7cb7 100644
--- a/proto/mrt/mrt.c
+++ b/proto/mrt/mrt.c
@@ -907,7 +907,6 @@ mrt_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUSE
 struct protocol proto_mrt = {
   .name =		"MRT",
   .template =		"mrt%d",
-  .class =		PROTOCOL_MRT,
   .proto_size =		sizeof(struct mrt_proto),
   .config_size =	sizeof(struct mrt_config),
   .init =		mrt_init,
diff --git a/proto/ospf/config.Y b/proto/ospf/config.Y
index a8972d2c..136e1dcb 100644
--- a/proto/ospf/config.Y
+++ b/proto/ospf/config.Y
@@ -505,11 +505,6 @@ ospf_iface:
   ospf_iface_start ospf_iface_patt_list ospf_iface_opt_list { ospf_iface_finish(); }
  ;
 
-dynamic_attr: OSPF_METRIC1 { $$ = f_new_dynamic_attr(T_INT, EA_OSPF_METRIC1); } ;
-dynamic_attr: OSPF_METRIC2 { $$ = f_new_dynamic_attr(T_INT, EA_OSPF_METRIC2); } ;
-dynamic_attr: OSPF_TAG { $$ = f_new_dynamic_attr(T_INT, EA_OSPF_TAG); } ;
-dynamic_attr: OSPF_ROUTER_ID { $$ = f_new_dynamic_attr(T_QUAD, EA_OSPF_ROUTER_ID); } ;
-
 CF_CLI_HELP(SHOW OSPF, ..., [[Show information about OSPF protocol]]);
 CF_CLI(SHOW OSPF, optproto, [<name>], [[Show information about OSPF protocol]])
 { PROTO_WALK_CMD($3, &proto_ospf, p) ospf_sh(p); };
diff --git a/proto/ospf/ospf.c b/proto/ospf/ospf.c
index d8bcc838..66d0eba6 100644
--- a/proto/ospf/ospf.c
+++ b/proto/ospf/ospf.c
@@ -106,6 +106,7 @@
 
 #include <stdlib.h>
 #include "ospf.h"
+#include "lib/macro.h"
 
 static int ospf_preexport(struct proto *P, rte *new);
 static void ospf_reload_routes(struct channel *C);
@@ -386,7 +387,7 @@ ospf_init(struct proto_config *CF)
 static int
 ospf_rte_better(struct rte *new, struct rte *old)
 {
-  u32 new_metric1 = ea_get_int(new->attrs->eattrs, EA_OSPF_METRIC1, LSINFINITY);
+  u32 new_metric1 = ea_get_int(new->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
 
   if (new_metric1 == LSINFINITY)
     return 0;
@@ -396,13 +397,13 @@ ospf_rte_better(struct rte *new, struct rte *old)
 
   if(new->attrs->source == RTS_OSPF_EXT2)
   {
-    u32 old_metric2 = ea_get_int(old->attrs->eattrs, EA_OSPF_METRIC2, LSINFINITY);
-    u32 new_metric2 = ea_get_int(new->attrs->eattrs, EA_OSPF_METRIC2, LSINFINITY);
+    u32 old_metric2 = ea_get_int(old->attrs->eattrs, &ea_ospf_metric2, LSINFINITY);
+    u32 new_metric2 = ea_get_int(new->attrs->eattrs, &ea_ospf_metric2, LSINFINITY);
     if(new_metric2 < old_metric2) return 1;
     if(new_metric2 > old_metric2) return 0;
   }
 
-  u32 old_metric1 = ea_get_int(old->attrs->eattrs, EA_OSPF_METRIC1, LSINFINITY);
+  u32 old_metric1 = ea_get_int(old->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
   if (new_metric1 < old_metric1)
     return 1;
 
@@ -415,7 +416,7 @@ ospf_rte_igp_metric(struct rte *rt)
   if (rt->attrs->source == RTS_OSPF_EXT2)
     return IGP_METRIC_UNKNOWN;
 
-  return ea_get_int(rt->attrs->eattrs, EA_OSPF_METRIC1, LSINFINITY);
+  return ea_get_int(rt->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
 }
 
 void
@@ -587,42 +588,26 @@ ospf_get_route_info(rte * rte, byte * buf)
   }
 
   buf += bsprintf(buf, " %s", type);
-  buf += bsprintf(buf, " (%d/%d", rte->attrs->pref, ea_get_int(rte->attrs->eattrs, EA_OSPF_METRIC1, LSINFINITY));
+  buf += bsprintf(buf, " (%d/%d", rte->attrs->pref, ea_get_int(rte->attrs->eattrs, &ea_ospf_metric1, LSINFINITY));
   if (rte->attrs->source == RTS_OSPF_EXT2)
-    buf += bsprintf(buf, "/%d", ea_get_int(rte->attrs->eattrs, EA_OSPF_METRIC2, LSINFINITY));
+    buf += bsprintf(buf, "/%d", ea_get_int(rte->attrs->eattrs, &ea_ospf_metric2, LSINFINITY));
   buf += bsprintf(buf, ")");
   if (rte->attrs->source == RTS_OSPF_EXT1 || rte->attrs->source == RTS_OSPF_EXT2)
   {
-    eattr *ea = ea_find(rte->attrs->eattrs, EA_OSPF_TAG);
+    eattr *ea = ea_find(rte->attrs->eattrs, &ea_ospf_tag);
     if (ea && (ea->u.data > 0))
       buf += bsprintf(buf, " [%x]", ea->u.data);
   }
   
-  eattr *ea = ea_find(rte->attrs->eattrs, EA_OSPF_ROUTER_ID);
+  eattr *ea = ea_find(rte->attrs->eattrs, &ea_ospf_router_id);
   if (ea)
     buf += bsprintf(buf, " [%R]", ea->u.data);
 }
 
-static int
-ospf_get_attr(const eattr * a, byte * buf, int buflen UNUSED)
+static void
+ospf_tag_format(const eattr * a, byte * buf, uint buflen)
 {
-  switch (a->id)
-  {
-  case EA_OSPF_METRIC1:
-    bsprintf(buf, "metric1");
-    return GA_NAME;
-  case EA_OSPF_METRIC2:
-    bsprintf(buf, "metric2");
-    return GA_NAME;
-  case EA_OSPF_TAG:
-    bsprintf(buf, "tag: 0x%08x", a->u.data);
-    return GA_FULL;
-  case EA_OSPF_ROUTER_ID:
-    bsprintf(buf, "router_id");
-    return GA_NAME;
-  default:
-    return GA_UNKNOWN;
-  }
+  bsnprintf(buf, buflen, "0x%08x", a->u.data);
 }
 
 static void
@@ -1520,7 +1505,6 @@ ospf_sh_lsadb(struct lsadb_show_data *ld)
 struct protocol proto_ospf = {
   .name =		"OSPF",
   .template =		"ospf%d",
-  .class =		PROTOCOL_OSPF,
   .preference =		DEF_PREF_OSPF,
   .channel_mask =	NB_IP,
   .proto_size =		sizeof(struct ospf_proto),
@@ -1531,12 +1515,39 @@ struct protocol proto_ospf = {
   .shutdown =		ospf_shutdown,
   .reconfigure =	ospf_reconfigure,
   .get_status =		ospf_get_status,
-  .get_attr =		ospf_get_attr,
   .get_route_info =	ospf_get_route_info
 };
 
+struct ea_class ea_ospf_metric1 = {
+  .name = "ospf_metric1",
+  .type = T_INT,
+};
+
+struct ea_class ea_ospf_metric2 = {
+  .name = "ospf_metric2",
+  .type = T_INT,
+};
+
+struct ea_class ea_ospf_tag = {
+  .name = "ospf_tag",
+  .type = T_INT,
+  .format = ospf_tag_format,
+};
+
+struct ea_class ea_ospf_router_id = {
+  .name = "ospf_router_id",
+  .type = T_QUAD,
+};
+
 void
 ospf_build(void)
 {
   proto_build(&proto_ospf);
+
+  EA_REGISTER_ALL(
+      &ea_ospf_metric1,
+      &ea_ospf_metric2,
+      &ea_ospf_tag,
+      &ea_ospf_router_id
+  );
 }
diff --git a/proto/ospf/ospf.h b/proto/ospf/ospf.h
index 3d0d57d9..7bed5c85 100644
--- a/proto/ospf/ospf.h
+++ b/proto/ospf/ospf.h
@@ -939,12 +939,7 @@ struct lsadb_show_data {
   u32 router;		/* Advertising router, 0 -> all */
 };
 
-
-#define EA_OSPF_METRIC1	EA_CODE(PROTOCOL_OSPF, 0)
-#define EA_OSPF_METRIC2	EA_CODE(PROTOCOL_OSPF, 1)
-#define EA_OSPF_TAG	EA_CODE(PROTOCOL_OSPF, 2)
-#define EA_OSPF_ROUTER_ID EA_CODE(PROTOCOL_OSPF, 3)
-
+extern struct ea_class ea_ospf_metric1, ea_ospf_metric2, ea_ospf_tag, ea_ospf_router_id;
 
 /*
  * For regular networks, neighbor address must match network prefix.
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 5969b7c7..55bad599 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -2075,18 +2075,18 @@ again1:
 	eattrs.l = (ea_list) {};
 
 	eattrs.a[eattrs.l.count++] =
-	  EA_LITERAL_EMBEDDED(EA_OSPF_METRIC1, T_INT, 0, nf->n.metric1);
+	  EA_LITERAL_EMBEDDED(&ea_ospf_metric1, 0, nf->n.metric1);
 
 	if (nf->n.type == RTS_OSPF_EXT2)
 	  eattrs.a[eattrs.l.count++] =
-	    EA_LITERAL_EMBEDDED(EA_OSPF_METRIC2, T_INT, 0, nf->n.metric2);
+	    EA_LITERAL_EMBEDDED(&ea_ospf_metric2, 0, nf->n.metric2);
 
 	if ((nf->n.type == RTS_OSPF_EXT1) || (nf->n.type == RTS_OSPF_EXT2))
 	  eattrs.a[eattrs.l.count++] =
-	    EA_LITERAL_EMBEDDED(EA_OSPF_TAG, T_INT, 0, nf->n.tag);
+	    EA_LITERAL_EMBEDDED(&ea_ospf_tag, 0, nf->n.tag);
 
 	eattrs.a[eattrs.l.count++] =
-	  EA_LITERAL_EMBEDDED(EA_OSPF_ROUTER_ID, T_QUAD, 0, nf->n.rid);
+	  EA_LITERAL_EMBEDDED(&ea_ospf_router_id, 0, nf->n.rid);
 
 	a0.eattrs = &eattrs.l;
 
diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index 9fe68264..db423dc8 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -1338,8 +1338,8 @@ ospf_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
 
   /* Get route attributes */
   rta *a = new->attrs;
-  eattr *m1a = ea_find(a->eattrs, EA_OSPF_METRIC1);
-  eattr *m2a = ea_find(a->eattrs, EA_OSPF_METRIC2);
+  eattr *m1a = ea_find(a->eattrs, &ea_ospf_metric1);
+  eattr *m2a = ea_find(a->eattrs, &ea_ospf_metric2);
   uint m1 = m1a ? m1a->u.data : 0;
   uint m2 = m2a ? m2a->u.data : 10000;
 
@@ -1363,7 +1363,7 @@ ospf_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
 
   uint ebit = m2a || !m1a;
   uint metric = ebit ? m2 : m1;
-  uint tag = ea_get_int(a->eattrs, EA_OSPF_TAG, 0);
+  uint tag = ea_get_int(a->eattrs, &ea_ospf_tag, 0);
 
   ip_addr fwd = IPA_NONE;
   if ((a->dest == RTD_UNICAST) && use_gw_for_fwaddr(p, a->nh.gw, a->nh.iface))
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index dde7e473..2978100b 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -306,7 +306,6 @@ perf_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUS
 struct protocol proto_perf = {
   .name = 		"Perf",
   .template =		"perf%d",
-  .class =		PROTOCOL_PERF,
   .channel_mask = 	NB_IP,
   .proto_size =		sizeof(struct perf_proto),
   .config_size = 	sizeof(struct perf_config),
diff --git a/proto/pipe/pipe.c b/proto/pipe/pipe.c
index 483ece67..7a39beff 100644
--- a/proto/pipe/pipe.c
+++ b/proto/pipe/pipe.c
@@ -293,7 +293,6 @@ pipe_update_debug(struct proto *P)
 struct protocol proto_pipe = {
   .name =		"Pipe",
   .template =		"pipe%d",
-  .class =		PROTOCOL_PIPE,
   .proto_size =		sizeof(struct pipe_proto),
   .config_size =	sizeof(struct pipe_config),
   .postconfig =		pipe_postconfig,
diff --git a/proto/radv/config.Y b/proto/radv/config.Y
index 0a339cb4..f40fdcca 100644
--- a/proto/radv/config.Y
+++ b/proto/radv/config.Y
@@ -336,9 +336,6 @@ radv_sensitive:
  | SENSITIVE bool { $$ = $2; }
  ;
 
-dynamic_attr: RA_PREFERENCE { $$ = f_new_dynamic_attr(T_ENUM_RA_PREFERENCE, EA_RA_PREFERENCE); } ;
-dynamic_attr: RA_LIFETIME { $$ = f_new_dynamic_attr(T_INT, EA_RA_LIFETIME); } ;
-
 CF_CODE
 
 CF_END
diff --git a/proto/radv/radv.c b/proto/radv/radv.c
index 7985997a..5734dbc9 100644
--- a/proto/radv/radv.c
+++ b/proto/radv/radv.c
@@ -10,6 +10,7 @@
 
 #include <stdlib.h>
 #include "radv.h"
+#include "lib/macro.h"
 
 /**
  * DOC: Router Advertisements
@@ -42,6 +43,8 @@
  * RFC 6106 - DNS extensions (RDDNS, DNSSL)
  */
 
+static struct ea_class ea_radv_preference, ea_radv_lifetime;
+
 static void radv_prune_prefixes(struct radv_iface *ifa);
 static void radv_prune_routes(struct radv_proto *p);
 
@@ -444,11 +447,11 @@ radv_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
   {
     /* Update */
 
-    ea = ea_find(new->attrs->eattrs, EA_RA_PREFERENCE);
+    ea = ea_find(new->attrs->eattrs, &ea_radv_preference);
     uint preference = ea ? ea->u.data : RA_PREF_MEDIUM;
     uint preference_set = !!ea;
 
-    ea = ea_find(new->attrs->eattrs, EA_RA_LIFETIME);
+    ea = ea_find(new->attrs->eattrs, &ea_radv_lifetime);
     uint lifetime = ea ? ea->u.data : 0;
     uint lifetime_set = !!ea;
 
@@ -738,27 +741,26 @@ radv_pref_str(u32 pref)
   }
 }
 
-/* The buffer has some minimal size */
-static int
-radv_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
+static void
+radv_preference_format(const eattr *a, byte *buf, uint buflen)
 {
-  switch (a->id)
-  {
-  case EA_RA_PREFERENCE:
-    bsprintf(buf, "preference: %s", radv_pref_str(a->u.data));
-    return GA_FULL;
-  case EA_RA_LIFETIME:
-    bsprintf(buf, "lifetime");
-    return GA_NAME;
-  default:
-    return GA_UNKNOWN;
-  }
+  bsnprintf(buf, buflen, "%s", radv_pref_str(a->u.data));
 }
 
+static struct ea_class ea_radv_preference = {
+  .name = "radv_preference",
+  .type = T_ENUM_RA_PREFERENCE,
+  .format = radv_preference_format,
+};
+
+static struct ea_class ea_radv_lifetime = {
+  .name = "radv_lifetime",
+  .type = T_INT,
+};
+
 struct protocol proto_radv = {
   .name =		"RAdv",
   .template =		"radv%d",
-  .class =		PROTOCOL_RADV,
   .channel_mask =	NB_IP6,
   .proto_size =		sizeof(struct radv_proto),
   .config_size =	sizeof(struct radv_config),
@@ -769,11 +771,15 @@ struct protocol proto_radv = {
   .reconfigure =	radv_reconfigure,
   .copy_config =	radv_copy_config,
   .get_status =		radv_get_status,
-  .get_attr =		radv_get_attr
 };
 
 void
 radv_build(void)
 {
   proto_build(&proto_radv);
+
+  EA_REGISTER_ALL(
+      &ea_radv_preference,
+      &ea_radv_lifetime
+      );
 }
diff --git a/proto/radv/radv.h b/proto/radv/radv.h
index 5cca3aca..c9219bda 100644
--- a/proto/radv/radv.h
+++ b/proto/radv/radv.h
@@ -195,10 +195,6 @@ struct radv_iface
 #define RA_PREF_HIGH	0x08
 #define RA_PREF_MASK	0x18
 
-/* Attributes */
-#define EA_RA_PREFERENCE	EA_CODE(PROTOCOL_RADV, 0)
-#define EA_RA_LIFETIME		EA_CODE(PROTOCOL_RADV, 1)
-
 #ifdef LOCAL_DEBUG
 #define RADV_FORCE_DEBUG 1
 #else
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index 3934d337..234e9029 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -190,9 +190,6 @@ rip_iface:
   rip_iface_start iface_patt_list_nopx rip_iface_opt_list rip_iface_finish;
 
 
-dynamic_attr: RIP_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_RIP_METRIC); } ;
-dynamic_attr: RIP_TAG { $$ = f_new_dynamic_attr(T_INT, EA_RIP_TAG); } ;
-
 CF_CLI_HELP(SHOW RIP, ..., [[Show information about RIP protocol]]);
 
 CF_CLI(SHOW RIP INTERFACES, optproto opttext, [<name>] [\"<interface>\"], [[Show information about RIP interfaces]])
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 2b5babcb..52a3bd2c 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -78,6 +78,7 @@
 
 #include <stdlib.h>
 #include "rip.h"
+#include "lib/macro.h"
 
 
 static inline void rip_lock_neighbor(struct rip_neighbor *n);
@@ -88,6 +89,7 @@ static inline void rip_iface_kick_timer(struct rip_iface *ifa);
 static void rip_iface_timer(timer *timer);
 static void rip_trigger_update(struct rip_proto *p);
 
+static struct ea_class ea_rip_metric, ea_rip_tag, ea_rip_from;
 
 /*
  *	RIP routes
@@ -200,9 +202,9 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
     } ea_block = {
       .l.count = 3,
       .a = {
-	EA_LITERAL_EMBEDDED(EA_RIP_METRIC, T_INT, 0, rt_metric),
-	EA_LITERAL_EMBEDDED(EA_RIP_TAG, T_INT, 0, rt_tag),
-	EA_LITERAL_DIRECT_ADATA(EA_RIP_FROM, T_IFACE, 0, &ea_block.riad.ad),
+	EA_LITERAL_EMBEDDED(&ea_rip_metric, 0, rt_metric),
+	EA_LITERAL_EMBEDDED(&ea_rip_tag, 0, rt_tag),
+	EA_LITERAL_DIRECT_ADATA(&ea_rip_from, 0, &ea_block.riad.ad),
       },
       .riad = {
 	.ad = { .length = sizeof(struct rip_iface_adata) - sizeof(struct adata) },
@@ -326,9 +328,9 @@ rip_rt_notify(struct proto *P, struct channel *ch UNUSED, struct network *net, s
   if (new)
   {
     /* Update */
-    u32 rt_tag = ea_get_int(new->attrs->eattrs, EA_RIP_TAG, 0);
-    u32 rt_metric = ea_get_int(new->attrs->eattrs, EA_RIP_METRIC, 1);
-    const eattr *rie = ea_find(new->attrs->eattrs, EA_RIP_FROM);
+    u32 rt_tag = ea_get_int(new->attrs->eattrs, &ea_rip_tag, 0);
+    u32 rt_metric = ea_get_int(new->attrs->eattrs, &ea_rip_metric, 1);
+    const eattr *rie = ea_find(new->attrs->eattrs, &ea_rip_from);
     struct iface *rt_from = rie ? ((struct rip_iface_adata *) rie->u.ptr)->iface : NULL;
 
     if (rt_metric > p->infinity)
@@ -1095,8 +1097,8 @@ rip_rte_better(struct rte *new, struct rte *old)
   ASSERT_DIE(new->src == old->src);
   struct rip_proto *p = (struct rip_proto *) new->src->proto;
 
-  u32 new_metric = ea_get_int(new->attrs->eattrs, EA_RIP_METRIC, p->infinity);
-  u32 old_metric = ea_get_int(old->attrs->eattrs, EA_RIP_METRIC, p->infinity);
+  u32 new_metric = ea_get_int(new->attrs->eattrs, &ea_rip_metric, p->infinity);
+  u32 old_metric = ea_get_int(old->attrs->eattrs, &ea_rip_metric, p->infinity);
 
   return new_metric < old_metric;
 }
@@ -1104,7 +1106,7 @@ rip_rte_better(struct rte *new, struct rte *old)
 static u32
 rip_rte_igp_metric(struct rte *rt)
 {
-  return ea_get_int(rt->attrs->eattrs, EA_RIP_METRIC, IGP_METRIC_UNKNOWN);
+  return ea_get_int(rt->attrs->eattrs, &ea_rip_metric, IGP_METRIC_UNKNOWN);
 }
 
 static void
@@ -1205,8 +1207,8 @@ static void
 rip_get_route_info(rte *rte, byte *buf)
 {
   struct rip_proto *p = (struct rip_proto *) rte->src->proto;
-  u32 rt_metric = ea_get_int(rte->attrs->eattrs, EA_RIP_METRIC, p->infinity);
-  u32 rt_tag = ea_get_int(rte->attrs->eattrs, EA_RIP_TAG, 0);
+  u32 rt_metric = ea_get_int(rte->attrs->eattrs, &ea_rip_metric, p->infinity);
+  u32 rt_tag = ea_get_int(rte->attrs->eattrs, &ea_rip_tag, 0);
 
   buf += bsprintf(buf, " (%d/%d)", rte->attrs->pref, rt_metric);
 
@@ -1214,23 +1216,28 @@ rip_get_route_info(rte *rte, byte *buf)
     bsprintf(buf, " [%04x]", rt_tag);
 }
 
-static int
-rip_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
+static void
+rip_tag_format(const eattr *a, byte *buf, uint buflen)
 {
-  switch (a->id)
-  {
-  case EA_RIP_METRIC:
-    bsprintf(buf, "metric: %d", a->u.data);
-    return GA_FULL;
+  bsnprintf(buf, buflen, "tag: %04x", a->u.data);
+}
 
-  case EA_RIP_TAG:
-    bsprintf(buf, "tag: %04x", a->u.data);
-    return GA_FULL;
+static struct ea_class ea_rip_metric = {
+  .name = "rip_metric",
+  .type = T_INT,
+};
 
-  default:
-    return GA_UNKNOWN;
-  }
-}
+static struct ea_class ea_rip_tag = {
+  .name = "rip_tag",
+  .type = T_INT,
+  .format = rip_tag_format,
+};
+
+static struct ea_class ea_rip_from = {
+  .name = "rip_from",
+  .type = T_IFACE,
+  .readonly = 1,
+};
 
 void
 rip_show_interfaces(struct proto *P, const char *iff)
@@ -1334,7 +1341,6 @@ rip_dump(struct proto *P)
 struct protocol proto_rip = {
   .name =		"RIP",
   .template =		"rip%d",
-  .class =		PROTOCOL_RIP,
   .preference =		DEF_PREF_RIP,
   .channel_mask =	NB_IP,
   .proto_size =		sizeof(struct rip_proto),
@@ -1346,11 +1352,16 @@ struct protocol proto_rip = {
   .shutdown =		rip_shutdown,
   .reconfigure =	rip_reconfigure,
   .get_route_info =	rip_get_route_info,
-  .get_attr =		rip_get_attr
 };
 
 void
 rip_build(void)
 {
   proto_build(&proto_rip);
+
+  EA_REGISTER_ALL(
+      &ea_rip_metric,
+      &ea_rip_tag,
+      &ea_rip_from
+      );
 }
diff --git a/proto/rip/rip.h b/proto/rip/rip.h
index a6fa3326..a01f8d3b 100644
--- a/proto/rip/rip.h
+++ b/proto/rip/rip.h
@@ -195,10 +195,6 @@ struct rip_rte
 #define RIP_ENTRY_VALID		1	/* Valid outgoing route */
 #define RIP_ENTRY_STALE		2	/* Stale outgoing route, waiting for GC */
 
-#define EA_RIP_METRIC		EA_CODE(PROTOCOL_RIP, 0)
-#define EA_RIP_TAG		EA_CODE(PROTOCOL_RIP, 1)
-#define EA_RIP_FROM		EA_CODE(PROTOCOL_RIP, 2)
-
 static inline int rip_is_v2(struct rip_proto *p)
 { return p->rip2; }
 
diff --git a/proto/rpki/rpki.c b/proto/rpki/rpki.c
index 6e111a81..d4e95a83 100644
--- a/proto/rpki/rpki.c
+++ b/proto/rpki/rpki.c
@@ -935,7 +935,6 @@ rpki_copy_config(struct proto_config *dest UNUSED, struct proto_config *src UNUS
 struct protocol proto_rpki = {
   .name = 		"RPKI",
   .template = 		"rpki%d",
-  .class =		PROTOCOL_RPKI,
   .preference = 	DEF_PREF_RPKI,
   .proto_size = 	sizeof(struct rpki_proto),
   .config_size =	sizeof(struct rpki_config),
diff --git a/proto/static/static.c b/proto/static/static.c
index 42febcd4..090ec875 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -408,16 +408,16 @@ static_reload_routes(struct channel *C)
 static int
 static_rte_better(rte *new, rte *old)
 {
-  u32 n = ea_get_int(new->attrs->eattrs, EA_GEN_IGP_METRIC, IGP_METRIC_UNKNOWN);
-  u32 o = ea_get_int(old->attrs->eattrs, EA_GEN_IGP_METRIC, IGP_METRIC_UNKNOWN);
+  u32 n = ea_get_int(new->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
+  u32 o = ea_get_int(old->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
   return n < o;
 }
 
 static int
 static_rte_mergable(rte *pri, rte *sec)
 {
-  u32 a = ea_get_int(pri->attrs->eattrs, EA_GEN_IGP_METRIC, IGP_METRIC_UNKNOWN);
-  u32 b = ea_get_int(sec->attrs->eattrs, EA_GEN_IGP_METRIC, IGP_METRIC_UNKNOWN);
+  u32 a = ea_get_int(pri->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
+  u32 b = ea_get_int(sec->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
   return a == b;
 }
 
@@ -711,7 +711,7 @@ static_copy_config(struct proto_config *dest, struct proto_config *src)
 static void
 static_get_route_info(rte *rte, byte *buf)
 {
-  eattr *a = ea_find(rte->attrs->eattrs, EA_GEN_IGP_METRIC);
+  eattr *a = ea_find(rte->attrs->eattrs, &ea_gen_igp_metric);
   if (a)
     buf += bsprintf(buf, " (%d/%u)", rte->attrs->pref, a->u.data);
   else
@@ -769,7 +769,6 @@ static_show(struct proto *P)
 struct protocol proto_static = {
   .name =		"Static",
   .template =		"static%d",
-  .class =		PROTOCOL_STATIC,
   .preference =		DEF_PREF_STATIC,
   .channel_mask =	NB_ANY,
   .proto_size =		sizeof(struct static_proto),
diff --git a/sysdep/linux/krt-sys.h b/sysdep/linux/krt-sys.h
index 8897f889..aa90f6e4 100644
--- a/sysdep/linux/krt-sys.h
+++ b/sysdep/linux/krt-sys.h
@@ -34,38 +34,6 @@ static inline struct ifa * kif_get_primary_ip(struct iface *i UNUSED) { return N
 
 #define KRT_ALLOW_MERGE_PATHS	1
 
-#define EA_KRT_PREFSRC		EA_CODE(PROTOCOL_KERNEL, 0x10)
-#define EA_KRT_REALM		EA_CODE(PROTOCOL_KERNEL, 0x11)
-#define EA_KRT_SCOPE		EA_CODE(PROTOCOL_KERNEL, 0x12)
-
-
-#define KRT_METRICS_MAX		0x10	/* RTAX_QUICKACK+1 */
-#define KRT_METRICS_OFFSET	0x20	/* Offset of EA_KRT_* vs RTAX_* */
-
-#define KRT_FEATURES_MAX	4
-
-/*
- * Following attributes are parts of RTA_METRICS kernel route attribute, their
- * ids must be consistent with their RTAX_* constants (+ KRT_METRICS_OFFSET)
- */
-#define EA_KRT_METRICS		EA_CODE(PROTOCOL_KERNEL, 0x20)	/* Dummy one */
-#define EA_KRT_LOCK		EA_CODE(PROTOCOL_KERNEL, 0x21)
-#define EA_KRT_MTU		EA_CODE(PROTOCOL_KERNEL, 0x22)
-#define EA_KRT_WINDOW		EA_CODE(PROTOCOL_KERNEL, 0x23)
-#define EA_KRT_RTT		EA_CODE(PROTOCOL_KERNEL, 0x24)
-#define EA_KRT_RTTVAR		EA_CODE(PROTOCOL_KERNEL, 0x25)
-#define EA_KRT_SSTRESH		EA_CODE(PROTOCOL_KERNEL, 0x26)
-#define EA_KRT_CWND		EA_CODE(PROTOCOL_KERNEL, 0x27)
-#define EA_KRT_ADVMSS		EA_CODE(PROTOCOL_KERNEL, 0x28)
-#define EA_KRT_REORDERING 	EA_CODE(PROTOCOL_KERNEL, 0x29)
-#define EA_KRT_HOPLIMIT		EA_CODE(PROTOCOL_KERNEL, 0x2a)
-#define EA_KRT_INITCWND		EA_CODE(PROTOCOL_KERNEL, 0x2b)
-#define EA_KRT_FEATURES		EA_CODE(PROTOCOL_KERNEL, 0x2c)
-#define EA_KRT_RTO_MIN		EA_CODE(PROTOCOL_KERNEL, 0x2d)
-#define EA_KRT_INITRWND		EA_CODE(PROTOCOL_KERNEL, 0x2e)
-#define EA_KRT_QUICKACK		EA_CODE(PROTOCOL_KERNEL, 0x2f)
-
-
 struct krt_params {
   u32 table_id;				/* Kernel table ID we sync with */
   u32 metric;				/* Kernel metric used for all routes */
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index f31b88c7..17e17789 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -28,39 +28,22 @@ kern_sys_item:
  | NETLINK RX BUFFER expr { THIS_KRT->sys.netlink_rx_buffer = $4; }
  ;
 
-dynamic_attr: KRT_PREFSRC	{ $$ = f_new_dynamic_attr(T_IP, EA_KRT_PREFSRC); } ;
-dynamic_attr: KRT_REALM	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_REALM); } ;
-dynamic_attr: KRT_SCOPE	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_SCOPE); } ;
-
-dynamic_attr: KRT_MTU		{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_MTU); } ;
-dynamic_attr: KRT_WINDOW	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_WINDOW); } ;
-dynamic_attr: KRT_RTT		{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_RTT); } ;
-dynamic_attr: KRT_RTTVAR	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_RTTVAR); } ;
-dynamic_attr: KRT_SSTRESH	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_SSTRESH); } ;
-dynamic_attr: KRT_CWND		{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_CWND); } ;
-dynamic_attr: KRT_ADVMSS	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_ADVMSS); } ;
-dynamic_attr: KRT_REORDERING	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_REORDERING); } ;
-dynamic_attr: KRT_HOPLIMIT	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_HOPLIMIT); } ;
-dynamic_attr: KRT_INITCWND	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_INITCWND); } ;
-dynamic_attr: KRT_RTO_MIN	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_RTO_MIN); } ;
-dynamic_attr: KRT_INITRWND	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_INITRWND); } ;
-dynamic_attr: KRT_QUICKACK	{ $$ = f_new_dynamic_attr(T_INT, EA_KRT_QUICKACK); } ;
-
 /* Bits of EA_KRT_LOCK, based on RTAX_* constants */
 
-attr_bit: KRT_LOCK_MTU	{ $$ = f_new_dynamic_attr_bit(2, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_WINDOW	{ $$ = f_new_dynamic_attr_bit(3, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_RTT	{ $$ = f_new_dynamic_attr_bit(4, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_RTTVAR	{ $$ = f_new_dynamic_attr_bit(5, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_SSTRESH	{ $$ = f_new_dynamic_attr_bit(6, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_CWND	{ $$ = f_new_dynamic_attr_bit(7, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_ADVMSS	{ $$ = f_new_dynamic_attr_bit(8, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_REORDERING { $$ = f_new_dynamic_attr_bit(9, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_HOPLIMIT { $$ = f_new_dynamic_attr_bit(10, EA_KRT_LOCK); } ;
-attr_bit: KRT_LOCK_RTO_MIN { $$ = f_new_dynamic_attr_bit(13, EA_KRT_LOCK); } ;
-
-attr_bit: KRT_FEATURE_ECN	{ $$ = f_new_dynamic_attr_bit(0, EA_KRT_FEATURES); } ;
-attr_bit: KRT_FEATURE_ALLFRAG { $$ = f_new_dynamic_attr_bit(3, EA_KRT_FEATURES); } ;
+attr_bit: KRT_LOCK_MTU	{ $$ = f_new_dynamic_attr_bit(2, "krt_lock"); } ;
+attr_bit: KRT_LOCK_WINDOW	{ $$ = f_new_dynamic_attr_bit(3, "krt_lock"); } ;
+attr_bit: KRT_LOCK_RTT	{ $$ = f_new_dynamic_attr_bit(4, "krt_lock"); } ;
+attr_bit: KRT_LOCK_RTTVAR	{ $$ = f_new_dynamic_attr_bit(5, "krt_lock"); } ;
+attr_bit: KRT_LOCK_SSTRESH	{ $$ = f_new_dynamic_attr_bit(6, "krt_lock"); } ;
+attr_bit: KRT_LOCK_CWND	{ $$ = f_new_dynamic_attr_bit(7, "krt_lock"); } ;
+attr_bit: KRT_LOCK_ADVMSS	{ $$ = f_new_dynamic_attr_bit(8, "krt_lock"); } ;
+attr_bit: KRT_LOCK_REORDERING { $$ = f_new_dynamic_attr_bit(9, "krt_lock"); } ;
+attr_bit: KRT_LOCK_HOPLIMIT { $$ = f_new_dynamic_attr_bit(10, "krt_lock"); } ;
+attr_bit: KRT_LOCK_RTO_MIN { $$ = f_new_dynamic_attr_bit(13, "krt_lock"); } ;
+
+/* Bits of EA_KRT_FEATURES */
+attr_bit: KRT_FEATURE_ECN	{ $$ = f_new_dynamic_attr_bit(0, "krt_features"); } ;
+attr_bit: KRT_FEATURE_ALLFRAG { $$ = f_new_dynamic_attr_bit(3, "krt_features"); } ;
 
 
 CF_CODE
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 81e02b4c..23d41b56 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -26,6 +26,7 @@
 #include "lib/socket.h"
 #include "lib/string.h"
 #include "lib/hash.h"
+#include "lib/macro.h"
 #include "conf/conf.h"
 
 #include <asm/types.h>
@@ -121,6 +122,101 @@ struct nl_parse_state
   u32 rta_flow;		/* Used during parsing */
 };
 
+/*
+ *	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 ea_class
+  ea_krt_prefsrc = {
+    .name = "krt_prefsrc",
+    .type = T_IP,
+  },
+  ea_krt_realm = {
+    .name = "krt_realm",
+    .type = T_INT,
+  },
+  ea_krt_scope = {
+    .name = "krt_scope",
+    .type = T_INT,
+  };
+
+static struct ea_class ea_krt_metrics[] = {
+  [RTAX_LOCK] = {
+    .name = "krt_lock",
+    .type = T_INT,
+    .format = krt_bitfield_format,
+  },
+  [RTAX_FEATURES] = {
+    .name = "krt_features",
+    .type = T_INT,
+    .format = krt_bitfield_format,
+  },
+#define KRT_METRIC_INT(_rtax, _name)	[_rtax] = { .name = _name, .type = T_INT }
+  KRT_METRIC_INT(RTAX_MTU, "krt_mtu"),
+  KRT_METRIC_INT(RTAX_WINDOW, "krt_window"),
+  KRT_METRIC_INT(RTAX_RTT, "krt_rtt"),
+  KRT_METRIC_INT(RTAX_RTTVAR, "krt_rttvar"),
+  KRT_METRIC_INT(RTAX_SSTHRESH, "krt_sstresh"),
+  KRT_METRIC_INT(RTAX_CWND, "krt_cwnd"),
+  KRT_METRIC_INT(RTAX_ADVMSS, "krt_advmss"),
+  KRT_METRIC_INT(RTAX_REORDERING, "krt_reordering"),
+  KRT_METRIC_INT(RTAX_HOPLIMIT, "krt_hoplimit"),
+  KRT_METRIC_INT(RTAX_INITCWND, "krt_initcwnd"),
+  KRT_METRIC_INT(RTAX_RTO_MIN, "krt_rto_min"),
+  KRT_METRIC_INT(RTAX_INITRWND, "krt_initrwnd"),
+  KRT_METRIC_INT(RTAX_QUICKACK, "krt_quickack"),
+#undef KRT_METRIC_INT
+};
+
+static const char *krt_metrics_names[KRT_METRICS_MAX] = {
+  NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
+  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
+};
+
+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
  */
@@ -734,7 +830,7 @@ static void
 nl_add_multipath(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af, ea_list *eattrs)
 {
   struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
-  eattr *flow = ea_find(eattrs, EA_KRT_REALM);
+  eattr *flow = ea_find(eattrs, &ea_krt_realm);
 
   for (; nh; nh = nh->next)
   {
@@ -1399,7 +1495,7 @@ nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
     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)))
+  else if ((op != NL_OP_DELETE) && (ea = ea_find(eattrs, &ea_krt_metric)))
     priority = ea->u.data;
 
   if (priority)
@@ -1412,15 +1508,15 @@ nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
   /* 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))
+  else if (ea = ea_find(eattrs, &ea_krt_scope))
     r->r.rtm_scope = ea->u.data;
   else
     r->r.rtm_scope = (dest == RTD_UNICAST && ipa_zero(nh->gw)) ? RT_SCOPE_LINK : RT_SCOPE_UNIVERSE;
 
-  if (ea = ea_find(eattrs, EA_KRT_PREFSRC))
+  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))
+  if (ea = ea_find(eattrs, &ea_krt_realm))
     nl_add_attr_u32(&r->h, rsize, RTA_FLOW, ea->u.data);
 
 
@@ -1428,9 +1524,9 @@ nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
   metrics[0] = 0;
 
   struct ea_walk_state ews = { .eattrs = eattrs };
-  while (ea = ea_walk(&ews, EA_KRT_METRICS, KRT_METRICS_MAX))
+  while (ea = ea_walk(&ews, ea_krt_metrics[0].id, KRT_METRICS_MAX))
   {
-    int id = ea->id - EA_KRT_METRICS;
+    int id = ea->id - ea_krt_metrics[0].id;
     metrics[0] |= 1 << id;
     metrics[id] = ea->u.data;
   }
@@ -1581,21 +1677,15 @@ nl_announce_route(struct nl_parse_state *s)
   rte *e = rte_get_temp(s->attrs, s->proto->p.main_source);
   e->net = s->net;
 
-  EA_LOCAL_LIST(2) ea0 = {
+  EA_LOCAL_LIST(2) ea = {
     .l = { .count = 2, .next = e->attrs->eattrs },
-    .a[0] = (eattr) {
-      .id = EA_KRT_SOURCE,
-      .type = T_INT,
-      .u.data = s->krt_proto,
-    },
-    .a[1] = (eattr) {
-      .id = EA_KRT_METRIC,
-      .type = T_INT,
-      .u.data = s->krt_metric,
+    .a = {
+      EA_LITERAL_EMBEDDED(&ea_krt_source, 0, s->krt_proto),
+      EA_LITERAL_EMBEDDED(&ea_krt_metric, 0, s->krt_metric),
     },
   };
 
-  e->attrs->eattrs = &ea0.l;
+  e->attrs->eattrs = &ea.l;
 
   if (s->scan)
     krt_got_route(s->proto, e, s->krt_src);
@@ -1867,20 +1957,20 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 
   if (i->rtm_scope != def_scope)
     ea_set_attr(&ra->eattrs,
-	EA_LITERAL_EMBEDDED(EA_KRT_SCOPE, T_INT, 0, i->rtm_scope));
+	EA_LITERAL_EMBEDDED(&ea_krt_scope, 0, i->rtm_scope));
 
   if (a[RTA_PREFSRC])
-    {
-      ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);
+  {
+    ip_addr ps = rta_get_ipa(a[RTA_PREFSRC]);
 
-      ea_set_attr(&ra->eattrs,
-	  EA_LITERAL_STORE_ADATA(EA_KRT_PREFSRC, T_IP, 0, &ps, sizeof(ps)));
-    }
+    ea_set_attr(&ra->eattrs,
+	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->eattrs,
-	EA_LITERAL_EMBEDDED(EA_KRT_REALM, T_INT, 0, s->rta_flow));
+	EA_LITERAL_EMBEDDED(&ea_krt_realm, 0, s->rta_flow));
 
   if (a[RTA_METRICS])
     {
@@ -1891,11 +1981,10 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	  return;
 	}
 
-      for (int t = 1; t < KRT_METRICS_MAX; t++)
+      for (uint t = 1; t < KRT_METRICS_MAX; t++)
 	if (metrics[0] & (1 << t))
 	  ea_set_attr(&ra->eattrs,
-	      EA_LITERAL_EMBEDDED(EA_CODE(PROTOCOL_KERNEL, KRT_METRICS_OFFSET + t),
-		T_INT, 0, metrics[t]));
+	      EA_LITERAL_EMBEDDED(&ea_krt_metrics[t], 0, metrics[t]));
     }
 
   /*
@@ -2133,6 +2222,8 @@ krt_sys_io_init(void)
 {
   nl_linpool = lp_new_default(krt_pool);
   HASH_INIT(nl_table_map, krt_pool, 6);
+
+  nl_ea_register();
 }
 
 int
@@ -2186,56 +2277,6 @@ krt_sys_copy_config(struct krt_config *d, struct krt_config *s)
   d->sys.metric = s->sys.metric;
 }
 
-static const char *krt_metrics_names[KRT_METRICS_MAX] = {
-  NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
-  "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
-};
-
-static const char *krt_features_names[KRT_FEATURES_MAX] = {
-  "ecn", NULL, NULL, "allfrag"
-};
-
-int
-krt_sys_get_attr(const eattr *a, byte *buf, int buflen UNUSED)
-{
-  switch (a->id)
-  {
-  case EA_KRT_PREFSRC:
-    bsprintf(buf, "prefsrc");
-    return GA_NAME;
-
-  case EA_KRT_REALM:
-    bsprintf(buf, "realm");
-    return GA_NAME;
-
-  case EA_KRT_SCOPE:
-    bsprintf(buf, "scope");
-    return GA_NAME;
-
-  case EA_KRT_LOCK:
-    buf += bsprintf(buf, "lock:");
-    ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
-    return GA_FULL;
-
-  case EA_KRT_FEATURES:
-    buf += bsprintf(buf, "features:");
-    ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
-    return GA_FULL;
-
-  default:;
-    int id = (int)EA_ID(a->id) - KRT_METRICS_OFFSET;
-    if (id > 0 && id < KRT_METRICS_MAX)
-    {
-      bsprintf(buf, "%s", krt_metrics_names[id]);
-      return GA_NAME;
-    }
-
-    return GA_UNKNOWN;
-  }
-}
-
-
-
 void
 kif_sys_start(struct kif_proto *p UNUSED)
 {
diff --git a/sysdep/unix/krt.Y b/sysdep/unix/krt.Y
index 2a3f41de..9300e9c8 100644
--- a/sysdep/unix/krt.Y
+++ b/sysdep/unix/krt.Y
@@ -122,9 +122,6 @@ kif_iface:
   kif_iface_start iface_patt_list_nopx kif_iface_opt_list;
 
 
-dynamic_attr: KRT_SOURCE { $$ = f_new_dynamic_attr(T_INT, EA_KRT_SOURCE); } ;
-dynamic_attr: KRT_METRIC { $$ = f_new_dynamic_attr(T_INT, EA_KRT_METRIC); } ;
-
 CF_CODE
 
 CF_END
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index 0ebc4fb3..4da51ce2 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -232,7 +232,6 @@ kif_copy_config(struct proto_config *dest, struct proto_config *src)
 struct protocol proto_unix_iface = {
   .name = 		"Device",
   .template = 		"device%d",
-  .class =		PROTOCOL_DEVICE,
   .proto_size =		sizeof(struct kif_proto),
   .config_size =	sizeof(struct kif_config),
   .preconfig =		kif_preconfig,
@@ -287,7 +286,7 @@ static struct tbf rl_alien = TBF_DEFAULT_LOG_LIMITS;
 static inline u32
 krt_metric(rte *a)
 {
-  eattr *ea = ea_find(a->attrs->eattrs, EA_KRT_METRIC);
+  eattr *ea = ea_find(a->attrs->eattrs, &ea_krt_metric);
   return ea ? ea->u.data : 0;
 }
 
@@ -1133,24 +1132,15 @@ krt_copy_config(struct proto_config *dest, struct proto_config *src)
   krt_sys_copy_config(d, s);
 }
 
-static int
-krt_get_attr(const eattr *a, byte *buf, int buflen)
-{
-  switch (a->id)
-  {
-  case EA_KRT_SOURCE:
-    bsprintf(buf, "source");
-    return GA_NAME;
-
-  case EA_KRT_METRIC:
-    bsprintf(buf, "metric");
-    return GA_NAME;
-
-  default:
-    return krt_sys_get_attr(a, buf, buflen);
-  }
-}
+struct ea_class ea_krt_source = {
+  .name = "krt_source",
+  .type = T_INT,
+};
 
+struct ea_class ea_krt_metric = {
+  .name = "krt_metric",
+  .type = T_INT,
+};
 
 #ifdef CONFIG_IP6_SADR_KERNEL
 #define MAYBE_IP6_SADR	NB_IP6_SADR
@@ -1167,7 +1157,6 @@ krt_get_attr(const eattr *a, byte *buf, int buflen)
 struct protocol proto_unix_kernel = {
   .name =		"Kernel",
   .template =		"kernel%d",
-  .class =		PROTOCOL_KERNEL,
   .preference =		DEF_PREF_INHERITED,
   .channel_mask =	NB_IP | MAYBE_IP6_SADR | MAYBE_MPLS,
   .proto_size =		sizeof(struct krt_proto),
@@ -1179,7 +1168,6 @@ struct protocol proto_unix_kernel = {
   .shutdown =		krt_shutdown,
   .reconfigure =	krt_reconfigure,
   .copy_config =	krt_copy_config,
-  .get_attr =		krt_get_attr,
 #ifdef KRT_ALLOW_LEARN
   .dump =		krt_dump,
 #endif
@@ -1189,4 +1177,9 @@ void
 krt_build(void)
 {
   proto_build(&proto_unix_kernel);
+
+  EA_REGISTER_ALL(
+      &ea_krt_source,
+      &ea_krt_metric,
+      );
 }
diff --git a/sysdep/unix/krt.h b/sysdep/unix/krt.h
index 20858cd7..04b04162 100644
--- a/sysdep/unix/krt.h
+++ b/sysdep/unix/krt.h
@@ -21,8 +21,12 @@ struct kif_proto;
 
 #define KRT_DEFAULT_ECMP_LIMIT	16
 
+#if 0
 #define EA_KRT_SOURCE	EA_CODE(PROTOCOL_KERNEL, 0)
 #define EA_KRT_METRIC	EA_CODE(PROTOCOL_KERNEL, 1)
+#endif
+
+extern struct ea_class ea_krt_source, ea_krt_metric;
 
 #define KRT_REF_SEEN	0x1	/* Seen in table */
 #define KRT_REF_BEST	0x2	/* Best in table */
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index 9bb37e5d..8fdad4e6 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -881,8 +881,8 @@ main(int argc, char **argv)
   resource_init();
   timer_init();
   olock_init();
-  io_init();
   rt_init();
+  io_init();
   if_init();
 //  roa_init();
   config_init();
diff --git a/test/bt-utils.c b/test/bt-utils.c
index ce9a49d7..509b5ed4 100644
--- a/test/bt-utils.c
+++ b/test/bt-utils.c
@@ -62,8 +62,8 @@ bt_bird_init(void)
 
   olock_init();
   timer_init();
-  io_init();
   rt_init();
+  io_init();
   if_init();
   config_init();
 
@@ -72,9 +72,6 @@ bt_bird_init(void)
 
 void bt_bird_cleanup(void)
 {
-  for (int i = 0; i < PROTOCOL__MAX; i++)
-    class_to_protocol[i] = NULL;
-
   config = new_config = NULL;
 }
 
-- 
cgit v1.2.3


From cce974e8ea992d0e6d2f649eca7880b436d91d71 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 4 May 2022 12:24:30 +0200
Subject: Conf: Allowing keyword redefinition

Some tokens are both keywords and symbols. For now, we allow only
specific keywords to be redefined; in future, more of the keywords may
be added to this category.

The redefinable keywords must be specified in any .Y file as follows:

  toksym: THE_KEYWORD ;

See proto/bgp/config.Y for an example.

Also dropped a lot of unused terminals.
---
 conf/cf-lex.l          | 13 ++++++-------
 conf/confbase.Y        |  8 +++++---
 conf/gen_keywords.m4   |  3 +--
 conf/gen_parser.m4     |  2 +-
 filter/config.Y        | 32 ++++++++++++++++----------------
 nest/config.Y          | 10 +++++-----
 proto/babel/config.Y   |  2 +-
 proto/bgp/config.Y     | 13 +++++++------
 proto/ospf/config.Y    |  2 +-
 proto/radv/config.Y    |  2 +-
 proto/rip/config.Y     |  2 +-
 sysdep/linux/netlink.Y |  3 ---
 sysdep/unix/krt.Y      |  2 +-
 13 files changed, 46 insertions(+), 48 deletions(-)

(limited to 'sysdep/linux')

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index e84e1d9d..11bcdb18 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -709,10 +709,7 @@ cf_lex_symbol(const char *data)
   struct symbol *sym = cf_get_symbol(data);
   cf_lval.s = sym;
 
-  if (sym->class != SYM_VOID)
-    return CF_SYM_KNOWN;
-
-  /* Is it a keyword? */
+  /* Is it a keyword? Prefer the keyword. */
   struct keyword *k = HASH_FIND(kw_hash, KW, data);
   if (k)
   {
@@ -725,9 +722,11 @@ cf_lex_symbol(const char *data)
     }
   }
 
-  /* OK, undefined symbol */
-  cf_lval.s = sym;
-  return CF_SYM_UNDEFINED;
+  /* OK, only a symbol. */
+  if (sym->class == SYM_VOID)
+    return CF_SYM_UNDEFINED;
+  else
+    return CF_SYM_KNOWN;
 }
 
 static void
diff --git a/conf/confbase.Y b/conf/confbase.Y
index 2286b257..8a27c3d5 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -116,7 +116,7 @@ CF_DECLS
 %type <mls> label_stack_start label_stack
 
 %type <t> text opttext
-%type <s> symbol
+%type <s> symbol symbol_known toksym 
 
 %nonassoc PREFIX_DUMMY
 %left AND OR
@@ -162,7 +162,7 @@ definition:
 expr:
    NUM
  | '(' term ')' { $$ = f_eval_int(f_linearize($2)); }
- | CF_SYM_KNOWN {
+ | symbol_known {
      if ($1->class != (SYM_CONSTANT | T_INT)) cf_error("Number constant expected");
      $$ = SYM_VAL($1).i; }
  ;
@@ -173,7 +173,9 @@ expr_us:
  | expr US { $$ = $1 US_; }
  ;
 
-symbol: CF_SYM_UNDEFINED | CF_SYM_KNOWN ;
+toksym: FROM ;
+symbol: CF_SYM_UNDEFINED | CF_SYM_KNOWN | toksym ;
+symbol_known: CF_SYM_KNOWN | toksym ;
 
 /* Switches */
 
diff --git a/conf/gen_keywords.m4 b/conf/gen_keywords.m4
index 0c1dc545..53226e4d 100644
--- a/conf/gen_keywords.m4
+++ b/conf/gen_keywords.m4
@@ -26,8 +26,7 @@ m4_define(CF_DEFINES, `m4_divert(-1)')
 m4_define(CF_handle_kw, `m4_divert(1){ "m4_translit($1,[[A-Z]],[[a-z]])", $1, NULL },
 m4_divert(-1)')
 m4_define(CF_keywd, `m4_ifdef([[CF_tok_$1]],,[[m4_define([[CF_tok_$1]],1)CF_handle_kw($1)]])')
-m4_define(CF_KEYWORDS, `m4_define([[CF_toks]],[[]])CF_iterate([[CF_keywd]], [[$@]])m4_ifelse(CF_toks,,,%token[[]]CF_toks
-)DNL')
+m4_define(CF_KEYWORDS, `CF_iterate([[CF_keywd]], [[$@]])DNL')
 
 # CLI commands generate keywords as well
 m4_define(CF_CLI, `CF_KEYWORDS(m4_translit($1, [[ ]], [[,]]))
diff --git a/conf/gen_parser.m4 b/conf/gen_parser.m4
index 5b378a93..af4b1455 100644
--- a/conf/gen_parser.m4
+++ b/conf/gen_parser.m4
@@ -31,7 +31,7 @@ m4_define(CF_iterate, `m4_define([[CF_iter]], m4_defn([[$1]]))CF_itera($2)')
 
 # Keywords act as untyped %token
 m4_define(CF_keywd, `m4_ifdef([[CF_tok_$1]],,[[m4_define([[CF_tok_$1]],1)m4_define([[CF_toks]],CF_toks $1)]])')
-m4_define(CF_KEYWORDS, `m4_define([[CF_toks]],[[]])CF_iterate([[CF_keywd]], [[$@]])m4_ifelse(CF_toks,,,%token[[]]CF_toks
+m4_define(CF_KEYWORDS, `m4_define([[CF_toks]],[[]])CF_iterate([[CF_keywd]], [[$@]])m4_ifelse(CF_toks,,,%token<s>[[]]CF_toks
 )DNL')
 
 # CLI commands
diff --git a/filter/config.Y b/filter/config.Y
index e24233aa..7dcdb779 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -291,8 +291,8 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 	LEN, MAXLEN,
 	DATA, DATA1, DATA2,
 	DEFINED,
-	ADD, DELETE, CONTAINS, RESET,
-	PREPEND, FIRST, LAST, LAST_NONAGGREGATED, MATCH,
+	ADD, DELETE, RESET,
+	PREPEND, FIRST, LAST, LAST_NONAGGREGATED,
 	MIN, MAX,
 	EMPTY,
 	FILTER, WHERE, EVAL, ATTRIBUTE,
@@ -357,7 +357,7 @@ custom_attr: ATTRIBUTE type symbol ';' {
 
 conf: bt_test_suite ;
 bt_test_suite:
- BT_TEST_SUITE '(' CF_SYM_KNOWN ',' text ')' {
+ BT_TEST_SUITE '(' symbol_known ',' text ')' {
   cf_assert_symbol($3, SYM_FUNCTION);
   struct f_bt_test_suite *t = cfg_allocz(sizeof(struct f_bt_test_suite));
   t->fn = $3->function;
@@ -370,7 +370,7 @@ bt_test_suite:
 
 conf: bt_test_same ;
 bt_test_same:
- BT_TEST_SAME '(' CF_SYM_KNOWN ',' CF_SYM_KNOWN ',' NUM ')' {
+ BT_TEST_SAME '(' symbol_known ',' symbol_known ',' NUM ')' {
   cf_assert_symbol($3, SYM_FUNCTION);
   cf_assert_symbol($5, SYM_FUNCTION);
   struct f_bt_test_suite *t = cfg_allocz(sizeof(struct f_bt_test_suite));
@@ -448,7 +448,7 @@ function_vars:
 filter_body: function_body ;
 
 filter:
-   CF_SYM_KNOWN {
+   symbol_known {
      cf_assert_symbol($1, SYM_FILTER);
      $$ = $1->filter;
    }
@@ -549,7 +549,7 @@ set_atom:
      if (f_eval(f_linearize($2), &($$)) > F_RETURN) cf_error("Runtime error");
      if (!f_valid_set_type($$.type)) cf_error("Set-incompatible type");
    }
- | CF_SYM_KNOWN {
+ | symbol_known {
      cf_assert_symbol($1, SYM_CONSTANT);
      if (!f_valid_set_type(SYM_TYPE($1))) cf_error("%s: set-incompatible type", $1->name);
      $$ = *$1->val;
@@ -719,7 +719,7 @@ var_list: /* EMPTY */ { $$ = NULL; }
  | var_list ',' term { $$ = $3; $$->next = $1; }
 
 function_call:
-   CF_SYM_KNOWN '(' var_list ')' {
+   symbol_known '(' var_list ')' {
      if ($1->class != SYM_FUNCTION)
        cf_error("You can't call something which is not a function. Really.");
 
@@ -743,7 +743,7 @@ function_call:
    }
  ;
 
-symbol_value: CF_SYM_KNOWN
+symbol_value: symbol_known 
   {
     switch ($1->class) {
       case SYM_CONSTANT_RANGE:
@@ -872,7 +872,7 @@ cmd:
  | IF term THEN block ELSE block {
      $$ = f_new_inst(FI_CONDITION, $2, $4, $6);
    }
- | CF_SYM_KNOWN '=' term ';' {
+ | symbol_known '=' term ';' {
      switch ($1->class) {
        case SYM_VARIABLE_RANGE:
 	 $$ = f_new_inst(FI_VAR_SET, $3, $1);
@@ -895,7 +895,7 @@ cmd:
        cf_error( "This static attribute is read-only.");
      $$ = f_new_inst(FI_RTA_SET, $3, $1);
    }
- | UNSET '(' CF_SYM_KNOWN ')' ';' {
+ | UNSET '(' symbol_known ')' ';' {
      if ($3->class != SYM_ATTRIBUTE)
        cf_error("Can't unset %s", $3->name);
      if ($3->attribute->readonly)
@@ -933,11 +933,11 @@ cmd:
       $$ = f_new_inst(FI_SWITCH, $2, build_tree($4));
    }
 
- | CF_SYM_KNOWN '.' EMPTY ';' { $$ = f_generate_empty($1); }
- | CF_SYM_KNOWN '.' PREPEND '(' term ')' ';'   { $$ = f_generate_complex_sym( FI_PATH_PREPEND, $1, $5 ); }
- | CF_SYM_KNOWN '.' ADD '(' term ')' ';'       { $$ = f_generate_complex_sym( FI_CLIST_ADD, $1, $5 ); }
- | CF_SYM_KNOWN '.' DELETE '(' term ')' ';'    { $$ = f_generate_complex_sym( FI_CLIST_DEL, $1, $5 ); }
- | CF_SYM_KNOWN '.' FILTER '(' term ')' ';'    { $$ = f_generate_complex_sym( FI_CLIST_FILTER, $1, $5 ); }
+ | symbol_known '.' EMPTY ';' { $$ = f_generate_empty($1); }
+ | symbol_known '.' PREPEND '(' term ')' ';'   { $$ = f_generate_complex_sym( FI_PATH_PREPEND, $1, $5 ); }
+ | symbol_known '.' ADD '(' term ')' ';'       { $$ = f_generate_complex_sym( FI_CLIST_ADD, $1, $5 ); }
+ | symbol_known '.' DELETE '(' term ')' ';'    { $$ = f_generate_complex_sym( FI_CLIST_DEL, $1, $5 ); }
+ | symbol_known '.' FILTER '(' term ')' ';'    { $$ = f_generate_complex_sym( FI_CLIST_FILTER, $1, $5 ); }
  | BT_ASSERT '(' get_cf_position term get_cf_position ')' ';' { $$ = assert_done($4, $3 + 1, $5 - 1); }
  | BT_CHECK_ASSIGN '(' get_cf_position lvalue get_cf_position ',' term ')' ';' { $$ = assert_assign(&$4, $7, $3 + 1, $5 - 1); }
  ;
@@ -948,7 +948,7 @@ get_cf_position:
 };
 
 lvalue:
-   CF_SYM_KNOWN {
+   symbol_known {
       switch ($1->class) {
 	case SYM_VARIABLE_RANGE:
 	  $$ = (struct f_lval) { .type = F_LVAL_VARIABLE, .sym = $1 };
diff --git a/nest/config.Y b/nest/config.Y
index c2913506..c144f0f3 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -118,11 +118,11 @@ CF_KEYWORDS(IPV4, IPV6, VPN4, VPN6, ROA4, ROA6, FLOW4, FLOW6, SADR, MPLS)
 CF_KEYWORDS(RECEIVE, LIMIT, ACTION, WARN, BLOCK, RESTART, DISABLE, KEEP, FILTERED, RPKI)
 CF_KEYWORDS(PASSWORD, KEY, FROM, PASSIVE, TO, ID, EVENTS, PACKETS, PROTOCOLS, CHANNELS, INTERFACES)
 CF_KEYWORDS(ALGORITHM, KEYED, HMAC, MD5, SHA1, SHA256, SHA384, SHA512, BLAKE2S128, BLAKE2S256, BLAKE2B256, BLAKE2B512)
-CF_KEYWORDS(PRIMARY, STATS, COUNT, BY, FOR, IN, COMMANDS, PREEXPORT, NOEXPORT, EXPORTED, GENERATE)
+CF_KEYWORDS(PRIMARY, STATS, COUNT, FOR, IN, COMMANDS, PREEXPORT, NOEXPORT, EXPORTED, GENERATE)
 CF_KEYWORDS(BGP, PASSWORDS, DESCRIPTION)
 CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, CLASS, DSCP)
 CF_KEYWORDS(TIMEFORMAT, ISO, SHORT, LONG, ROUTE, PROTOCOL, BASE, LOG, S, MS, US)
-CF_KEYWORDS(GRACEFUL, RESTART, WAIT, MAX, FLUSH, AS)
+CF_KEYWORDS(GRACEFUL, RESTART, WAIT, MAX, AS)
 CF_KEYWORDS(MIN, IDLE, RX, TX, INTERVAL, MULTIPLIER, PASSIVE)
 CF_KEYWORDS(CHECK, LINK)
 CF_KEYWORDS(SORTED, TRIE, MIN, MAX, SETTLE, TIME)
@@ -659,7 +659,7 @@ r_args:
      $$->addr = $3;
      $$->addr_mode = RSD_ADDR_IN;
    }
-| r_args TABLE CF_SYM_KNOWN {
+| r_args TABLE symbol_known {
      cf_assert_symbol($3, SYM_TABLE);
      $$ = $1;
      rt_show_add_table($$, $3->table->table);
@@ -704,7 +704,7 @@ r_args:
      $$ = $1;
      $$->filtered = 1;
    }
- | r_args export_mode CF_SYM_KNOWN {
+ | r_args export_mode symbol_known {
      cf_assert_symbol($3, SYM_PROTO);
      struct proto_config *c = (struct proto_config *) $3->proto;
      $$ = $1;
@@ -721,7 +721,7 @@ r_args:
      $$->export_channel = $3;
      $$->tables_defined_by = RSD_TDB_INDIRECT;
    }
- | r_args PROTOCOL CF_SYM_KNOWN {
+ | r_args PROTOCOL symbol_known {
      cf_assert_symbol($3, SYM_PROTO);
      struct proto_config *c = (struct proto_config *) $3->proto;
      $$ = $1;
diff --git a/proto/babel/config.Y b/proto/babel/config.Y
index 82419b20..a4350eed 100644
--- a/proto/babel/config.Y
+++ b/proto/babel/config.Y
@@ -24,7 +24,7 @@ CF_DECLS
 
 CF_KEYWORDS(BABEL, INTERFACE, METRIC, RXCOST, HELLO, UPDATE, INTERVAL, PORT,
 	TYPE, WIRED, WIRELESS, RX, TX, BUFFER, PRIORITY, LENGTH, CHECK, LINK,
-	NEXT, HOP, IPV4, IPV6, BABEL_METRIC, SHOW, INTERFACES, NEIGHBORS,
+	NEXT, HOP, IPV4, IPV6, SHOW, INTERFACES, NEIGHBORS,
 	ENTRIES, RANDOMIZE, ROUTER, ID, AUTHENTICATION, NONE, MAC, PERMISSIVE)
 
 CF_GRAMMAR
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index db261bbb..b4d8b83f 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -19,18 +19,17 @@ CF_DECLS
 
 CF_KEYWORDS(BGP, LOCAL, NEIGHBOR, AS, HOLD, TIME, CONNECT, RETRY, KEEPALIVE,
 	MULTIHOP, STARTUP, VIA, NEXT, HOP, SELF, DEFAULT, PATH, METRIC, ERROR,
-	START, DELAY, FORGET, WAIT, ENABLE, DISABLE, AFTER, BGP_PATH,
-	BGP_LOCAL_PREF, BGP_MED, BGP_ORIGIN, BGP_NEXT_HOP, BGP_ATOMIC_AGGR,
-	BGP_AGGREGATOR, BGP_COMMUNITY, BGP_EXT_COMMUNITY, BGP_LARGE_COMMUNITY,
+	START, DELAY, FORGET, WAIT, ENABLE, DISABLE, AFTER,
+	BGP_LOCAL_PREF, BGP_MED, 
 	SOURCE, ADDRESS, PASSWORD, RR, RS, CLIENT, CLUSTER, ID, AS4, ADVERTISE,
 	IPV4, CAPABILITIES, LIMIT, PASSIVE, PREFER, OLDER, MISSING, LLADDR,
-	DROP, IGNORE, ROUTE, REFRESH, INTERPRET, COMMUNITIES, BGP_ORIGINATOR_ID,
-	BGP_CLUSTER_LIST, IGP, TABLE, GATEWAY, DIRECT, RECURSIVE, MED, TTL,
+	DROP, IGNORE, ROUTE, REFRESH, INTERPRET, COMMUNITIES,
+	IGP, TABLE, GATEWAY, DIRECT, RECURSIVE, MED, TTL,
 	SECURITY, DETERMINISTIC, SECONDARY, ALLOW, BFD, ADD, PATHS, RX, TX,
 	GRACEFUL, RESTART, AWARE, CHECK, LINK, PORT, EXTENDED, MESSAGES, SETKEY,
 	STRICT, BIND, CONFEDERATION, MEMBER, MULTICAST, FLOW4, FLOW6, LONG,
 	LIVED, STALE, IMPORT, IBGP, EBGP, MANDATORY, INTERNAL, EXTERNAL, SETS,
-	DYNAMIC, RANGE, NAME, DIGITS, BGP_AIGP, AIGP, ORIGINATE, COST, ENFORCE,
+	DYNAMIC, RANGE, NAME, DIGITS, AIGP, ORIGINATE, COST, ENFORCE,
 	FIRST, FREE, VALIDATE, BASE)
 
 %type <i> bgp_nh
@@ -44,6 +43,8 @@ CF_KEYWORDS(CEASE, PREFIX, LIMIT, HIT, ADMINISTRATIVE, SHUTDOWN, RESET, PEER,
 
 CF_GRAMMAR
 
+toksym: BGP_MED | BGP_LOCAL_PREF ;
+
 proto: bgp_proto '}'  ;
 
 bgp_proto_start: proto_start BGP {
diff --git a/proto/ospf/config.Y b/proto/ospf/config.Y
index 136e1dcb..bc3df8db 100644
--- a/proto/ospf/config.Y
+++ b/proto/ospf/config.Y
@@ -190,7 +190,7 @@ ospf_check_auth(void)
 
 CF_DECLS
 
-CF_KEYWORDS(OSPF, V2, V3, OSPF_METRIC1, OSPF_METRIC2, OSPF_TAG, OSPF_ROUTER_ID)
+CF_KEYWORDS(OSPF, V2, V3)
 CF_KEYWORDS(AREA, NEIGHBORS, RFC1583COMPAT, STUB, TICK, COST, COST2, RETRANSMIT)
 CF_KEYWORDS(HELLO, TRANSMIT, PRIORITY, DEAD, TYPE, BROADCAST, BCAST, DEFAULT)
 CF_KEYWORDS(NONBROADCAST, NBMA, POINTOPOINT, PTP, POINTOMULTIPOINT, PTMP)
diff --git a/proto/radv/config.Y b/proto/radv/config.Y
index f40fdcca..fb68d2e5 100644
--- a/proto/radv/config.Y
+++ b/proto/radv/config.Y
@@ -33,7 +33,7 @@ CF_KEYWORDS(RADV, PREFIX, INTERFACE, MIN, MAX, RA, DELAY, INTERVAL, SOLICITED,
 	RETRANS, TIMER, CURRENT, HOP, LIMIT, DEFAULT, VALID, PREFERRED, MULT,
 	LIFETIME, SKIP, ONLINK, AUTONOMOUS, RDNSS, DNSSL, NS, DOMAIN, LOCAL,
 	TRIGGER, SENSITIVE, PREFERENCE, LOW, MEDIUM, HIGH, PROPAGATE, ROUTE,
-	ROUTES, RA_PREFERENCE, RA_LIFETIME)
+	ROUTES)
 
 CF_ENUM(T_ENUM_RA_PREFERENCE, RA_PREF_, LOW, MEDIUM, HIGH)
 
diff --git a/proto/rip/config.Y b/proto/rip/config.Y
index 234e9029..3c0973b1 100644
--- a/proto/rip/config.Y
+++ b/proto/rip/config.Y
@@ -37,7 +37,7 @@ CF_KEYWORDS(RIP, NG, ECMP, LIMIT, WEIGHT, INFINITY, METRIC, UPDATE, TIMEOUT,
 	    PASSIVE, VERSION, SPLIT, HORIZON, POISON, REVERSE, CHECK, ZERO,
 	    TIME, BFD, AUTHENTICATION, NONE, PLAINTEXT, CRYPTOGRAPHIC, MD5,
 	    TTL, SECURITY, RX, TX, BUFFER, LENGTH, PRIORITY, ONLY, LINK,
-	    DEMAND, CIRCUIT, RIP_METRIC, RIP_TAG)
+	    DEMAND, CIRCUIT)
 
 %type <i> rip_variant rip_auth
 
diff --git a/sysdep/linux/netlink.Y b/sysdep/linux/netlink.Y
index 17e17789..7ba8c7c9 100644
--- a/sysdep/linux/netlink.Y
+++ b/sysdep/linux/netlink.Y
@@ -11,9 +11,6 @@ CF_HDR
 CF_DECLS
 
 CF_KEYWORDS(KERNEL, TABLE, METRIC, NETLINK, RX, BUFFER,
-	    KRT_PREFSRC, KRT_REALM, KRT_SCOPE, KRT_MTU, KRT_WINDOW,
-	    KRT_RTT, KRT_RTTVAR, KRT_SSTRESH, KRT_CWND, KRT_ADVMSS, KRT_REORDERING,
-	    KRT_HOPLIMIT, KRT_INITCWND, KRT_RTO_MIN, KRT_INITRWND, KRT_QUICKACK,
 	    KRT_LOCK_MTU, KRT_LOCK_WINDOW, KRT_LOCK_RTT, KRT_LOCK_RTTVAR,
 	    KRT_LOCK_SSTRESH, KRT_LOCK_CWND, KRT_LOCK_ADVMSS, KRT_LOCK_REORDERING,
 	    KRT_LOCK_HOPLIMIT, KRT_LOCK_RTO_MIN, KRT_FEATURE_ECN, KRT_FEATURE_ALLFRAG)
diff --git a/sysdep/unix/krt.Y b/sysdep/unix/krt.Y
index 9300e9c8..4ce9a328 100644
--- a/sysdep/unix/krt.Y
+++ b/sysdep/unix/krt.Y
@@ -29,7 +29,7 @@ kif_set_preferred(ip_addr ip)
 
 CF_DECLS
 
-CF_KEYWORDS(KERNEL, PERSIST, SCAN, TIME, LEARN, DEVICE, ROUTES, GRACEFUL, RESTART, KRT_SOURCE, KRT_METRIC, MERGE, PATHS)
+CF_KEYWORDS(KERNEL, PERSIST, SCAN, TIME, LEARN, DEVICE, ROUTES, GRACEFUL, RESTART, MERGE, PATHS)
 CF_KEYWORDS(INTERFACE, PREFERRED)
 
 %type <i> kern_mp_limit
-- 
cgit v1.2.3


From 702c04fbef222e802ca4dfac645dc75ede522db6 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 4 May 2022 12:41:54 +0200
Subject: Removing the route scope attribute. Use custom attributes instead.

The route scope attribute was used for simple user route marking. As
there is a better tool for this (custom attributes), the old and limited
way can be dropped.
---
 doc/bird.sgml          | 8 --------
 filter/config.Y        | 1 -
 filter/data.h          | 1 -
 filter/f-inst.c        | 5 -----
 filter/test.conf2      | 6 ------
 lib/route.h            | 1 -
 nest/rt-attr.c         | 8 +++-----
 nest/rt-dev.c          | 1 -
 proto/babel/babel.c    | 2 --
 proto/bgp/packets.c    | 1 -
 proto/ospf/rt.c        | 1 -
 proto/perf/perf.c      | 1 -
 proto/rip/rip.c        | 1 -
 proto/rpki/rpki.c      | 1 -
 proto/static/static.c  | 1 -
 sysdep/bsd/krt-sock.c  | 1 -
 sysdep/linux/netlink.c | 1 -
 17 files changed, 3 insertions(+), 38 deletions(-)

(limited to 'sysdep/linux')

diff --git a/doc/bird.sgml b/doc/bird.sgml
index a71624aa..aa058b37 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1723,14 +1723,6 @@ Common route attributes are:
 	primary key of the routing table. Read-only. (See the <ref id="routes"
 	name="chapter about routes">.)
 
-	<tag><label id="rta-scope"><m/enum/ scope</tag>
-	The scope of the route. Possible values: <cf/SCOPE_HOST/ for routes
-	local to this host, <cf/SCOPE_LINK/ for those specific for a physical
-	link, <cf/SCOPE_SITE/ and <cf/SCOPE_ORGANIZATION/ for private routes and
-	<cf/SCOPE_UNIVERSE/ for globally visible routes. This attribute is not
-	interpreted by BIRD and can be used to mark routes in filters. The
-	default value for new routes is <cf/SCOPE_UNIVERSE/.
-
 	<tag><label id="rta-preference"><m/int/ preference</tag>
 	Preference of the route.
 
diff --git a/filter/config.Y b/filter/config.Y
index 7dcdb779..6af39c10 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -766,7 +766,6 @@ static_attr:
  | NET     { $$ = f_new_static_attr(T_NET,	  SA_NET,	1); }
  | PROTO   { $$ = f_new_static_attr(T_STRING,     SA_PROTO,	1); }
  | SOURCE  { $$ = f_new_static_attr(T_ENUM_RTS,   SA_SOURCE,	1); }
- | SCOPE   { $$ = f_new_static_attr(T_ENUM_SCOPE, SA_SCOPE,	0); }
  | DEST    { $$ = f_new_static_attr(T_ENUM_RTD,   SA_DEST,	0); }
  | IFNAME  { $$ = f_new_static_attr(T_STRING,     SA_IFNAME,	0); }
  | IFINDEX { $$ = f_new_static_attr(T_INT,        SA_IFINDEX,	1); }
diff --git a/filter/data.h b/filter/data.h
index a0a164ed..49b29499 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -26,7 +26,6 @@ enum f_sa_code {
   SA_NET,
   SA_PROTO,
   SA_SOURCE,
-  SA_SCOPE,
   SA_DEST,
   SA_IFNAME,
   SA_IFINDEX,
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 7158d22e..5eacc716 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -537,7 +537,6 @@
       case SA_NET:	RESULT(sa.type, net, (*fs->rte)->net->n.addr); break;
       case SA_PROTO:	RESULT(sa.type, s, (*fs->rte)->src->proto->name); break;
       case SA_SOURCE:	RESULT(sa.type, i, rta->source); break;
-      case SA_SCOPE:	RESULT(sa.type, i, rta->scope); break;
       case SA_DEST:	RESULT(sa.type, i, rta->dest); break;
       case SA_IFNAME:	RESULT(sa.type, s, rta->nh.iface ? rta->nh.iface->name : ""); break;
       case SA_IFINDEX:	RESULT(sa.type, i, rta->nh.iface ? rta->nh.iface->index : 0); break;
@@ -579,10 +578,6 @@
 	}
 	break;
 
-      case SA_SCOPE:
-	rta->scope = v1.val.i;
-	break;
-
       case SA_DEST:
 	{
 	  int i = v1.val.i;
diff --git a/filter/test.conf2 b/filter/test.conf2
index e95f9563..9fc8330f 100644
--- a/filter/test.conf2
+++ b/filter/test.conf2
@@ -38,12 +38,6 @@ protocol static {
 			print from;
 			from = 1.2.3.4;
 			print from;
-			print scope;
-			scope = SCOPE_HOST;
-			print scope;
-			if !(scope ~ [ SCOPE_HOST, SCOPE_SITE ]) then {
-				print "Failed in test";
-			}
 
 			preference = 15;
 			print preference;
diff --git a/lib/route.h b/lib/route.h
index e02c63b3..40ba150d 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -86,7 +86,6 @@ typedef struct rta {
   struct hostentry *hostentry;		/* Hostentry for recursive next-hops */
   u16 cached:1;				/* Are attributes cached? */
   u16 source:7;				/* Route source (RTS_...) */
-  u16 scope:4;				/* Route scope (SCOPE_... -- see ip.h) */
   u16 dest:4;				/* Route destination type (RTD_...) */
   struct nexthop nh;			/* Next hop */
 } rta;
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 87f54b0d..a892bfd5 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -1235,7 +1235,6 @@ rta_hash(rta *a)
 #define BMIX(f) mem_hash_mix_num(&h, a->f);
   MIX(hostentry);
   BMIX(source);
-  BMIX(scope);
   BMIX(dest);
 #undef MIX
 
@@ -1246,7 +1245,6 @@ static inline int
 rta_same(rta *x, rta *y)
 {
   return (x->source == y->source &&
-	  x->scope == y->scope &&
 	  x->dest == y->dest &&
 	  x->hostentry == y->hostentry &&
 	  nexthop_same(&(x->nh), &(y->nh)) &&
@@ -1396,8 +1394,8 @@ rta_dump(rta *a)
 			 "RTS_OSPF_EXT2", "RTS_BGP", "RTS_PIPE", "RTS_BABEL" };
   static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
 
-  debug("uc=%d %s %s%s h=%04x",
-	a->uc, rts[a->source], ip_scope_text(a->scope),
+  debug("uc=%d %s %s h=%04x",
+	a->uc, rts[a->source],
 	rtd[a->dest], a->hash_key);
   if (!a->cached)
     debug(" !CACHED");
@@ -1443,7 +1441,7 @@ rta_dump_all(void)
 void
 rta_show(struct cli *c, rta *a)
 {
-  cli_printf(c, -1008, "\tType: %s %s", rta_src_names[a->source], ip_scope_text(a->scope));
+  cli_printf(c, -1008, "\tType: %s", rta_src_names[a->source]);
 
   for(ea_list *eal = a->eattrs; eal; eal=eal->next)
     for(int i=0; i<eal->count; i++)
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index 696b37b8..ffd5afd5 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -84,7 +84,6 @@ dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
 
       rta a0 = {
 	.source = RTS_DEVICE,
-	.scope = SCOPE_UNIVERSE,
 	.dest = RTD_UNICAST,
 	.nh.iface = ad->iface,
       };
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index f4503b99..cd221c7b 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -659,7 +659,6 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
 
     rta a0 = {
       .source = RTS_BABEL,
-      .scope = SCOPE_UNIVERSE,
       .dest = RTD_UNICAST,
       .nh.gw = r->next_hop,
       .nh.iface = r->neigh->ifa->iface,
@@ -685,7 +684,6 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
     /* Unreachable */
     rta a0 = {
       .source = RTS_BABEL,
-      .scope = SCOPE_UNIVERSE,
       .dest = RTD_UNREACHABLE,
     };
 
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 9760ebee..62d60e9a 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -2475,7 +2475,6 @@ bgp_decode_nlri(struct bgp_parse_state *s, u32 afi, byte *nlri, uint len, ea_lis
     a = allocz(RTA_MAX_SIZE);
 
     a->source = RTS_BGP;
-    a->scope = SCOPE_UNIVERSE;
     a->eattrs = ea;
 
     ea_set_attr_data(&a->eattrs, &ea_gen_from, 0, &s->proto->remote_ip, sizeof(ip_addr));
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 3d8cf22c..ddc5b162 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -2054,7 +2054,6 @@ again1:
     {
       rta a0 = {
 	.source = nf->n.type,
-	.scope = SCOPE_UNIVERSE,
 	.dest = RTD_UNICAST,
 	.nh = *(nf->n.nhs),
       };
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index 7b18866c..47a2867d 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -144,7 +144,6 @@ perf_loop(void *data)
     if (!p->attrs_per_rte || !(i % p->attrs_per_rte)) {
       struct rta a0 = {
 	.source = RTS_PERF,
-	.scope = SCOPE_UNIVERSE,
 	.dest = RTD_UNICAST,
 	.nh.iface = p->ifa->iface,
 	.nh.gw = gw,
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 7c097a92..f5442606 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -153,7 +153,6 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
     /* Update */
     rta a0 = {
       .source = RTS_RIP,
-      .scope = SCOPE_UNIVERSE,
       .dest = RTD_UNICAST,
     };
 
diff --git a/proto/rpki/rpki.c b/proto/rpki/rpki.c
index 710764e2..af963f49 100644
--- a/proto/rpki/rpki.c
+++ b/proto/rpki/rpki.c
@@ -122,7 +122,6 @@ rpki_table_add_roa(struct rpki_cache *cache, struct channel *channel, const net_
 
   rta a0 = {
     .source = RTS_RPKI,
-    .scope = SCOPE_UNIVERSE,
     .dest = RTD_NONE,
   };
 
diff --git a/proto/static/static.c b/proto/static/static.c
index d4b1c5f3..ff833b16 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -56,7 +56,6 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
   rta *a = allocz(RTA_MAX_SIZE);
   struct rte_src *src = static_get_source(p, r->index);
   a->source = RTS_STATIC;
-  a->scope = SCOPE_UNIVERSE;
   a->dest = r->dest;
   ea_set_attr_u32(&a->eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
 
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index 844b9f83..bc6b1839 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -521,7 +521,6 @@ krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
   rta a = {
     .src = p->p.main_source,
     .source = RTS_INHERIT,
-    .scope = SCOPE_UNIVERSE,
   };
 
   /* reject/blackhole routes have also set RTF_GATEWAY,
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 23d41b56..c506c71c 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1855,7 +1855,6 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 
   rta *ra = lp_allocz(s->pool, RTA_MAX_SIZE);
   ra->source = RTS_INHERIT;
-  ra->scope = SCOPE_UNIVERSE;
 
   if (a[RTA_FLOW])
     s->rta_flow = rta_get_u32(a[RTA_FLOW]);
-- 
cgit v1.2.3


From 1c30b689ddd032ef8000fb7836348a48ba3184ff Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Wed, 4 May 2022 14:41:51 +0200
Subject: Moved route source attribute (RTS_*) to eattrs

---
 filter/config.Y        |  3 +--
 filter/data.h          |  1 -
 filter/f-inst.c        |  1 -
 lib/route.h            | 12 +++++++++---
 lib/type_test.c        |  1 +
 nest/rt-attr.c         | 32 ++++++++++++++++++++------------
 nest/rt-dev.c          |  2 +-
 nest/rt-table.c        |  8 ++++----
 proto/babel/babel.c    |  6 +++---
 proto/bgp/attrs.c      |  2 +-
 proto/bgp/config.Y     |  2 +-
 proto/bgp/packets.c    |  2 +-
 proto/ospf/ospf.c      | 22 +++++++++++++---------
 proto/ospf/rt.c        | 21 ++++++++++++++++-----
 proto/perf/perf.c      |  2 +-
 proto/rip/rip.c        |  4 ++--
 proto/rpki/rpki.c      |  2 +-
 proto/static/static.c  |  2 +-
 sysdep/bsd/krt-sock.c  |  3 ++-
 sysdep/linux/netlink.c |  2 +-
 20 files changed, 79 insertions(+), 51 deletions(-)

(limited to 'sysdep/linux')

diff --git a/filter/config.Y b/filter/config.Y
index 6af39c10..ca792593 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -285,7 +285,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 	SET, STRING, BGPMASK, BGPPATH, CLIST, ECLIST, LCLIST,
 	IF, THEN, ELSE, CASE,
 	TRUE, FALSE, RT, RO, UNKNOWN, GENERIC,
-	FROM, GW, NET, MASK, PROTO, SOURCE, SCOPE, DEST, IFNAME, IFINDEX, WEIGHT, GW_MPLS,
+	FROM, GW, NET, MASK, PROTO, SCOPE, DEST, IFNAME, IFINDEX, WEIGHT, GW_MPLS,
 	ROA_CHECK, ASN, SRC, DST,
 	IS_V4, IS_V6,
 	LEN, MAXLEN,
@@ -765,7 +765,6 @@ static_attr:
    GW      { $$ = f_new_static_attr(T_IP,         SA_GW,	0); }
  | NET     { $$ = f_new_static_attr(T_NET,	  SA_NET,	1); }
  | PROTO   { $$ = f_new_static_attr(T_STRING,     SA_PROTO,	1); }
- | SOURCE  { $$ = f_new_static_attr(T_ENUM_RTS,   SA_SOURCE,	1); }
  | DEST    { $$ = f_new_static_attr(T_ENUM_RTD,   SA_DEST,	0); }
  | IFNAME  { $$ = f_new_static_attr(T_STRING,     SA_IFNAME,	0); }
  | IFINDEX { $$ = f_new_static_attr(T_INT,        SA_IFINDEX,	1); }
diff --git a/filter/data.h b/filter/data.h
index 49b29499..23db4a85 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -25,7 +25,6 @@ enum f_sa_code {
   SA_GW = 1,
   SA_NET,
   SA_PROTO,
-  SA_SOURCE,
   SA_DEST,
   SA_IFNAME,
   SA_IFINDEX,
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 5eacc716..23271ce7 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -536,7 +536,6 @@
       case SA_GW:	RESULT(sa.type, ip, rta->nh.gw); break;
       case SA_NET:	RESULT(sa.type, net, (*fs->rte)->net->n.addr); break;
       case SA_PROTO:	RESULT(sa.type, s, (*fs->rte)->src->proto->name); break;
-      case SA_SOURCE:	RESULT(sa.type, i, rta->source); break;
       case SA_DEST:	RESULT(sa.type, i, rta->dest); break;
       case SA_IFNAME:	RESULT(sa.type, s, rta->nh.iface ? rta->nh.iface->name : ""); break;
       case SA_IFINDEX:	RESULT(sa.type, i, rta->nh.iface ? rta->nh.iface->index : 0); break;
diff --git a/lib/route.h b/lib/route.h
index 40ba150d..8fdb5d8b 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -85,7 +85,6 @@ typedef struct rta {
   struct ea_list *eattrs;		/* Extended Attribute chain */
   struct hostentry *hostentry;		/* Hostentry for recursive next-hops */
   u16 cached:1;				/* Are attributes cached? */
-  u16 source:7;				/* Route source (RTS_...) */
   u16 dest:4;				/* Route destination type (RTD_...) */
   struct nexthop nh;			/* Next hop */
 } rta;
@@ -131,12 +130,13 @@ static inline int rte_is_reachable(rte *r)
 typedef struct eattr {
   word id;				/* EA_CODE(PROTOCOL_..., protocol-dependent ID) */
   byte flags;				/* Protocol-dependent flags */
-  byte type:5;				/* Attribute type */
+  byte type;				/* Attribute type */
+  byte rfu:5;
   byte originated:1;			/* The attribute has originated locally */
   byte fresh:1;				/* An uncached attribute (e.g. modified in export filter) */
   byte undef:1;				/* Explicitly undefined */
 
-  PADDING(unused, 0, 4);
+  PADDING(unused, 3, 3);
 
   union bval u;
 } eattr;
@@ -308,6 +308,12 @@ u32 rt_get_igp_metric(rte *rt);
 /* From: Advertising router */
 extern struct ea_class ea_gen_from;
 
+/* Source: An old method to devise the route source protocol and kind.
+ * To be superseded in a near future by something more informative. */
+extern struct ea_class ea_gen_source;
+static inline u32 rt_get_source_attr(rte *rt)
+{ return ea_get_int(rt->attrs->eattrs, &ea_gen_source, 0); }
+
 /* Next hop structures */
 
 #define NEXTHOP_MAX_SIZE (sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
diff --git a/lib/type_test.c b/lib/type_test.c
index 20e7630b..b526db69 100644
--- a/lib/type_test.c
+++ b/lib/type_test.c
@@ -54,6 +54,7 @@ t_eattr(void)
   e.id = ~0;
   e.flags = ~0;
   e.type = ~0;
+  e.rfu = ~0;
   e.originated = ~0;
   e.fresh = ~0;
   e.undef = ~0;
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index a892bfd5..39fd7db4 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -92,6 +92,22 @@ const char * const rta_src_names[RTS_MAX] = {
   [RTS_RPKI]		= "RPKI",
 };
 
+static void
+ea_gen_source_format(const eattr *a, byte *buf, uint size)
+{
+  if ((a->u.data >= RTS_MAX) || !rta_src_names[a->u.data])
+    bsnprintf(buf, size, "unknown");
+  else
+    bsnprintf(buf, size, "%s", rta_src_names[a->u.data]);
+}
+
+struct ea_class ea_gen_source = {
+  .name = "source",
+  .type = T_ENUM_RTS,
+  .readonly = 1,
+  .format = ea_gen_source_format,
+};
+
 const char * rta_dest_names[RTD_MAX] = {
   [RTD_NONE]		= "",
   [RTD_UNICAST]		= "unicast",
@@ -1234,7 +1250,6 @@ rta_hash(rta *a)
 #define MIX(f) mem_hash_mix(&h, &(a->f), sizeof(a->f));
 #define BMIX(f) mem_hash_mix_num(&h, a->f);
   MIX(hostentry);
-  BMIX(source);
   BMIX(dest);
 #undef MIX
 
@@ -1244,8 +1259,7 @@ rta_hash(rta *a)
 static inline int
 rta_same(rta *x, rta *y)
 {
-  return (x->source == y->source &&
-	  x->dest == y->dest &&
+  return (x->dest == y->dest &&
 	  x->hostentry == y->hostentry &&
 	  nexthop_same(&(x->nh), &(y->nh)) &&
 	  ea_same(x->eattrs, y->eattrs));
@@ -1388,15 +1402,10 @@ rta_do_cow(rta *o, linpool *lp)
 void
 rta_dump(rta *a)
 {
-  static char *rts[] = { "", "RTS_STATIC", "RTS_INHERIT", "RTS_DEVICE",
-			 "RTS_STAT_DEV", "RTS_REDIR", "RTS_RIP",
-			 "RTS_OSPF", "RTS_OSPF_IA", "RTS_OSPF_EXT1",
-			 "RTS_OSPF_EXT2", "RTS_BGP", "RTS_PIPE", "RTS_BABEL" };
   static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
 
-  debug("uc=%d %s %s h=%04x",
-	a->uc, rts[a->source],
-	rtd[a->dest], a->hash_key);
+  debug("uc=%d %s h=%04x",
+	a->uc, rtd[a->dest], a->hash_key);
   if (!a->cached)
     debug(" !CACHED");
   if (a->dest == RTD_UNICAST)
@@ -1441,8 +1450,6 @@ rta_dump_all(void)
 void
 rta_show(struct cli *c, rta *a)
 {
-  cli_printf(c, -1008, "\tType: %s", rta_src_names[a->source]);
-
   for(ea_list *eal = a->eattrs; eal; eal=eal->next)
     for(int i=0; i<eal->count; i++)
       ea_show(c, &eal->attrs[i]);
@@ -1476,6 +1483,7 @@ rta_init(void)
   ea_register_init(&ea_gen_preference);
   ea_register_init(&ea_gen_igp_metric);
   ea_register_init(&ea_gen_from);
+  ea_register_init(&ea_gen_source);
 }
 
 /*
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index ffd5afd5..af6506f6 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -83,12 +83,12 @@ dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
       struct rte_src *src = rt_get_source(P, ad->iface->index);
 
       rta a0 = {
-	.source = RTS_DEVICE,
 	.dest = RTD_UNICAST,
 	.nh.iface = ad->iface,
       };
 
       ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, c->preference);
+      ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_DEVICE);
 
       a = rta_lookup(&a0);
       e = rte_get_temp(a, src);
diff --git a/nest/rt-table.c b/nest/rt-table.c
index e8b04e0b..4f119ac0 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -2588,7 +2588,7 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
   trie_add_prefix(tab_flow->flowspec_trie, &dst, (nb ? nb->n.addr->pxlen : 0), max_pxlen);
 
   /* No best-match BGP route -> no flowspec */
-  if (!rb || (rb->attrs->source != RTS_BGP))
+  if (!rb || (rt_get_source_attr(rb) != RTS_BGP))
     return 0;
 
   /* Find ORIGINATOR_ID values */
@@ -2620,7 +2620,7 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
       continue;
 
     rte *rc = nc->routes;
-    if (rc->attrs->source != RTS_BGP)
+    if (rt_get_source_attr(rc) != RTS_BGP)
       return 0;
 
     if (rta_get_first_asn(rc->attrs) != asn_b)
@@ -2637,7 +2637,7 @@ static rte *
 rt_flowspec_update_rte(rtable *tab, rte *r)
 {
 #ifdef CONFIG_BGP
-  if (r->attrs->source != RTS_BGP)
+  if (rt_get_source_attr(r) != RTS_BGP)
     return NULL;
 
   struct bgp_channel *bc = (struct bgp_channel *) r->sender;
@@ -3471,7 +3471,7 @@ rt_get_igp_metric(rte *rt)
   if (ea)
     return ea->u.data;
 
-  if (rt->attrs->source == RTS_DEVICE)
+  if (rt_get_source_attr(rt) == RTS_DEVICE)
     return 0;
 
   if (rt->src->proto->rte_igp_metric)
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index cd221c7b..a7dcee09 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -645,12 +645,13 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
   {
     struct {
       ea_list l;
-      eattr a[5];
+      eattr a[6];
     } eattrs = {
       .l.count = ARRAY_SIZE(eattrs.a),
       .a = {
 	EA_LITERAL_EMBEDDED(&ea_gen_preference, 0, c->preference),
 	EA_LITERAL_STORE_ADATA(&ea_gen_from, 0, &r->neigh->addr, sizeof(r->neigh->addr)),
+	EA_LITERAL_EMBEDDED(&ea_gen_source, 0, RTS_BABEL),
 	EA_LITERAL_EMBEDDED(&ea_babel_metric, 0, r->metric),
 	EA_LITERAL_STORE_ADATA(&ea_babel_router_id, 0, &r->router_id, sizeof(r->router_id)),
 	EA_LITERAL_EMBEDDED(&ea_babel_seqno, 0, r->seqno),
@@ -658,7 +659,6 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
     };
 
     rta a0 = {
-      .source = RTS_BABEL,
       .dest = RTD_UNICAST,
       .nh.gw = r->next_hop,
       .nh.iface = r->neigh->ifa->iface,
@@ -683,11 +683,11 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
   {
     /* Unreachable */
     rta a0 = {
-      .source = RTS_BABEL,
       .dest = RTD_UNREACHABLE,
     };
 
     ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, 1);
+    ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_BABEL);
 
     rta *a = rta_lookup(&a0);
     rte *rte = rte_get_temp(a, p->p.main_source);
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 097ba9a2..1efc26ce 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -402,7 +402,7 @@ bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad)
 static inline int
 bgp_init_aigp_metric(rte *e, u64 *metric, const struct adata **ad)
 {
-  if (e->attrs->source == RTS_BGP)
+  if (rt_get_source_attr(e) == RTS_BGP)
     return 0;
 
   *metric = rt_get_igp_metric(e);
diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y
index b4d8b83f..24f3ec8f 100644
--- a/proto/bgp/config.Y
+++ b/proto/bgp/config.Y
@@ -43,7 +43,7 @@ CF_KEYWORDS(CEASE, PREFIX, LIMIT, HIT, ADMINISTRATIVE, SHUTDOWN, RESET, PEER,
 
 CF_GRAMMAR
 
-toksym: BGP_MED | BGP_LOCAL_PREF ;
+toksym: BGP_MED | BGP_LOCAL_PREF | SOURCE ;
 
 proto: bgp_proto '}'  ;
 
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 62d60e9a..0aa4dc40 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -2474,11 +2474,11 @@ bgp_decode_nlri(struct bgp_parse_state *s, u32 afi, byte *nlri, uint len, ea_lis
   {
     a = allocz(RTA_MAX_SIZE);
 
-    a->source = RTS_BGP;
     a->eattrs = ea;
 
     ea_set_attr_data(&a->eattrs, &ea_gen_from, 0, &s->proto->remote_ip, sizeof(ip_addr));
     ea_set_attr_u32(&a->eattrs, &ea_gen_preference, 0, c->c.preference);
+    ea_set_attr_u32(&a->eattrs, &ea_gen_source, 0, RTS_BGP);
 
     c->desc->decode_next_hop(s, nh, nh_len, a);
     bgp_finish_attrs(s, a);
diff --git a/proto/ospf/ospf.c b/proto/ospf/ospf.c
index 427c2c86..731adaa5 100644
--- a/proto/ospf/ospf.c
+++ b/proto/ospf/ospf.c
@@ -392,15 +392,18 @@ ospf_rte_better(struct rte *new, struct rte *old)
   if (new_metric1 == LSINFINITY)
     return 0;
 
-  if(new->attrs->source < old->attrs->source) return 1;
-  if(new->attrs->source > old->attrs->source) return 0;
+  u32 ns = rt_get_source_attr(new);
+  u32 os = rt_get_source_attr(old);
 
-  if(new->attrs->source == RTS_OSPF_EXT2)
+  if (ns < os) return 1;
+  if (ns > os) return 0;
+
+  if (ns == RTS_OSPF_EXT2)
   {
     u32 old_metric2 = ea_get_int(old->attrs->eattrs, &ea_ospf_metric2, LSINFINITY);
     u32 new_metric2 = ea_get_int(new->attrs->eattrs, &ea_ospf_metric2, LSINFINITY);
-    if(new_metric2 < old_metric2) return 1;
-    if(new_metric2 > old_metric2) return 0;
+    if (new_metric2 < old_metric2) return 1;
+    if (new_metric2 > old_metric2) return 0;
   }
 
   u32 old_metric1 = ea_get_int(old->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
@@ -413,7 +416,7 @@ ospf_rte_better(struct rte *new, struct rte *old)
 static u32
 ospf_rte_igp_metric(struct rte *rt)
 {
-  if (rt->attrs->source == RTS_OSPF_EXT2)
+  if (rt_get_source_attr(rt) == RTS_OSPF_EXT2)
     return IGP_METRIC_UNKNOWN;
 
   return ea_get_int(rt->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
@@ -571,7 +574,8 @@ ospf_get_route_info(rte * rte, byte * buf)
 {
   char *type = "<bug>";
 
-  switch (rte->attrs->source)
+  uint source = rt_get_source_attr(rte);
+  switch (source)
   {
   case RTS_OSPF:
     type = "I";
@@ -589,10 +593,10 @@ ospf_get_route_info(rte * rte, byte * buf)
 
   buf += bsprintf(buf, " %s", type);
   buf += bsprintf(buf, " (%d/%d", rt_get_preference(rte), ea_get_int(rte->attrs->eattrs, &ea_ospf_metric1, LSINFINITY));
-  if (rte->attrs->source == RTS_OSPF_EXT2)
+  if (source == RTS_OSPF_EXT2)
     buf += bsprintf(buf, "/%d", ea_get_int(rte->attrs->eattrs, &ea_ospf_metric2, LSINFINITY));
   buf += bsprintf(buf, ")");
-  if (rte->attrs->source == RTS_OSPF_EXT1 || rte->attrs->source == RTS_OSPF_EXT2)
+  if (source == RTS_OSPF_EXT1 || source == RTS_OSPF_EXT2)
   {
     eattr *ea = ea_find(rte->attrs->eattrs, &ea_ospf_tag);
     if (ea && (ea->u.data > 0))
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index ddc5b162..91739056 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -2004,11 +2004,19 @@ static inline int
 ort_changed(ort *nf, rta *nr)
 {
   rta *or = nf->old_rta;
-  return !or ||
+
+  if (!or ||
     (nf->n.metric1 != nf->old_metric1) || (nf->n.metric2 != nf->old_metric2) ||
     (nf->n.tag != nf->old_tag) || (nf->n.rid != nf->old_rid) ||
-    (nr->source != or->source) || (nr->dest != or->dest) ||
-    !nexthop_same(&(nr->nh), &(or->nh));
+    (nr->dest != or->dest) ||
+    !nexthop_same(&(nr->nh), &(or->nh)))
+    return 1;
+
+  if (	ea_get_int(nr->eattrs, &ea_gen_source, 0)
+     != ea_get_int(or->eattrs, &ea_gen_source, 0))
+    return 1;
+
+  return 0;
 }
 
 static void
@@ -2053,7 +2061,6 @@ again1:
     if (nf->n.type) /* Add the route */
     {
       rta a0 = {
-	.source = nf->n.type,
 	.dest = RTD_UNICAST,
 	.nh = *(nf->n.nhs),
       };
@@ -2067,7 +2074,7 @@ again1:
 
 	struct {
 	  ea_list l;
-	  eattr a[5];
+	  eattr a[6];
 	} eattrs;
 
 	eattrs.l = (ea_list) {};
@@ -2075,6 +2082,9 @@ again1:
 	eattrs.a[eattrs.l.count++] =
 	  EA_LITERAL_EMBEDDED(&ea_gen_preference, 0, p->p.main_channel->preference);
 
+	eattrs.a[eattrs.l.count++] = 
+	  EA_LITERAL_EMBEDDED(&ea_gen_source, 0, nf->n.type);
+
 	eattrs.a[eattrs.l.count++] =
 	  EA_LITERAL_EMBEDDED(&ea_ospf_metric1, 0, nf->n.metric1);
 
@@ -2089,6 +2099,7 @@ again1:
 	eattrs.a[eattrs.l.count++] =
 	  EA_LITERAL_EMBEDDED(&ea_ospf_router_id, 0, nf->n.rid);
 
+	ASSERT_DIE(ARRAY_SIZE(eattrs.a) >= eattrs.l.count);
 	a0.eattrs = &eattrs.l;
 
 	rta *a = rta_lookup(&a0);
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index 47a2867d..4329556c 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -143,7 +143,6 @@ perf_loop(void *data)
 
     if (!p->attrs_per_rte || !(i % p->attrs_per_rte)) {
       struct rta a0 = {
-	.source = RTS_PERF,
 	.dest = RTD_UNICAST,
 	.nh.iface = p->ifa->iface,
 	.nh.gw = gw,
@@ -151,6 +150,7 @@ perf_loop(void *data)
       };
 
       ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
+      ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_PERF);
 
       p->data[i].a = rta_lookup(&a0);
     }
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index f5442606..f7f34c27 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -152,17 +152,17 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
   {
     /* Update */
     rta a0 = {
-      .source = RTS_RIP,
       .dest = RTD_UNICAST,
     };
 
     struct {
       ea_list l;
-      eattr a[2];
+      eattr a[3];
     } ea_block = {
       .l.count = ARRAY_SIZE(ea_block.a),
       .a = {
 	EA_LITERAL_EMBEDDED(&ea_gen_preference, 0, p->p.main_channel->preference),
+	EA_LITERAL_EMBEDDED(&ea_gen_source, 0, RTS_RIP),
 	EA_LITERAL_EMBEDDED(&ea_rip_metric, 0, rt->metric),
       },
     };
diff --git a/proto/rpki/rpki.c b/proto/rpki/rpki.c
index af963f49..56d8add2 100644
--- a/proto/rpki/rpki.c
+++ b/proto/rpki/rpki.c
@@ -121,11 +121,11 @@ rpki_table_add_roa(struct rpki_cache *cache, struct channel *channel, const net_
   struct rpki_proto *p = cache->p;
 
   rta a0 = {
-    .source = RTS_RPKI,
     .dest = RTD_NONE,
   };
 
   ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, channel->preference);
+  ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_RPKI);
 
   rta *a = rta_lookup(&a0);
   rte *e = rte_get_temp(a, p->p.main_source);
diff --git a/proto/static/static.c b/proto/static/static.c
index ff833b16..1400e985 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -55,9 +55,9 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
 {
   rta *a = allocz(RTA_MAX_SIZE);
   struct rte_src *src = static_get_source(p, r->index);
-  a->source = RTS_STATIC;
   a->dest = r->dest;
   ea_set_attr_u32(&a->eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
+  ea_set_attr_u32(&a->eattrs, &ea_gen_source, 0, RTS_STATIC);
 
   if (r->dest == RTD_UNICAST)
   {
diff --git a/sysdep/bsd/krt-sock.c b/sysdep/bsd/krt-sock.c
index bc6b1839..61ac7a5c 100644
--- a/sysdep/bsd/krt-sock.c
+++ b/sysdep/bsd/krt-sock.c
@@ -520,9 +520,10 @@ krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
 
   rta a = {
     .src = p->p.main_source,
-    .source = RTS_INHERIT,
   };
 
+  ea_set_attr_u32(&a->eattrs, &ea_gen_source, 0, RTS_INHERIT);
+
   /* reject/blackhole routes have also set RTF_GATEWAY,
      we wil check them first. */
 
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index c506c71c..e0219ce0 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1854,7 +1854,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     nl_announce_route(s);
 
   rta *ra = lp_allocz(s->pool, RTA_MAX_SIZE);
-  ra->source = RTS_INHERIT;
+  ea_set_attr_u32(&ra->eattrs, &ea_gen_source, 0, RTS_INHERIT);
 
   if (a[RTA_FLOW])
     s->rta_flow = rta_get_u32(a[RTA_FLOW]);
-- 
cgit v1.2.3


From f15f2fcee7eeb5a100bd204a0e67018e25953420 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 5 May 2022 18:08:37 +0200
Subject: Moved nexthop from struct rta to extended attribute.

This doesn't do anything more than to put the whole structure inside
adata. The overall performance is certainly going downhill; we'll
optimize this later.

Anyway, this is one of the latest items inside rta and in several
commits we may drop rta completely and move to eattrs-only routes.
---
 filter/f-inst.c        | 133 ++++++++++++++++-------
 lib/attrs.h            |   2 +
 lib/route.h            |  65 ++++++++---
 lib/type.h             |   1 +
 nest/rt-attr.c         | 284 ++++++++++++++++++-------------------------------
 nest/rt-dev.c          |   7 +-
 nest/rt-show.c         |   9 +-
 nest/rt-table.c        | 156 +++++++++++++++------------
 proto/babel/babel.c    |  31 ++++--
 proto/bgp/packets.c    |  68 ++++++++----
 proto/ospf/rt.c        | 162 +++++++++++++---------------
 proto/ospf/rt.h        |   4 +-
 proto/ospf/topology.c  |  16 ++-
 proto/ospf/topology.h  |   4 +-
 proto/perf/perf.c      |  10 +-
 proto/rip/rip.c        |  54 +++++++---
 proto/static/static.c  |  34 +++---
 sysdep/linux/netlink.c | 185 +++++++++++++++++++-------------
 sysdep/unix/krt.c      |  10 +-
 19 files changed, 699 insertions(+), 536 deletions(-)

(limited to 'sysdep/linux')

diff --git a/filter/f-inst.c b/filter/f-inst.c
index 23271ce7..8ce78a99 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -529,27 +529,47 @@
     {
       STATIC_ATTR;
       ACCESS_RTE;
+      ACCESS_EATTRS;
       struct rta *rta = (*fs->rte)->attrs;
 
       switch (sa.sa_code)
       {
-      case SA_GW:	RESULT(sa.type, ip, rta->nh.gw); break;
       case SA_NET:	RESULT(sa.type, net, (*fs->rte)->net->n.addr); break;
       case SA_PROTO:	RESULT(sa.type, s, (*fs->rte)->src->proto->name); break;
       case SA_DEST:	RESULT(sa.type, i, rta->dest); break;
-      case SA_IFNAME:	RESULT(sa.type, s, rta->nh.iface ? rta->nh.iface->name : ""); break;
-      case SA_IFINDEX:	RESULT(sa.type, i, rta->nh.iface ? rta->nh.iface->index : 0); break;
-      case SA_WEIGHT:	RESULT(sa.type, i, rta->nh.weight + 1); break;
-      case SA_GW_MPLS:	RESULT(sa.type, i, rta->nh.labels ? rta->nh.label[0] : MPLS_NULL); break;
-
       default:
-	bug("Invalid static attribute access (%u/%u)", sa.type, sa.sa_code);
+	{
+	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
+	  struct nexthop *nh = nh_ea ? &((struct nexthop_adata *) nh_ea->u.ptr)->nh : NULL;
+
+	  switch (sa.sa_code)
+	  {
+	    case SA_GW:
+	      RESULT(sa.type, ip, nh ? nh->gw : IPA_NONE);
+	      break;
+	    case SA_IFNAME:
+	      RESULT(sa.type, s, (nh && nh->iface) ? nh->iface->name : "");
+	      break;
+	    case SA_IFINDEX:
+	      RESULT(sa.type, i, (nh && nh->iface) ? nh->iface->index : 0);
+	      break;
+	    case SA_WEIGHT:
+	      RESULT(sa.type, i, (nh ? nh->weight : 0) + 1);
+	      break;
+	    case SA_GW_MPLS:
+	      RESULT(sa.type, i, (nh && nh->labels) ? nh->label[0] : MPLS_NULL);
+	      break;
+	    default:
+	      bug("Invalid static attribute access (%u/%u)", sa.type, sa.sa_code);
+	  }
+	}
       }
     }
   }
 
   INST(FI_RTA_SET, 1, 0) {
     ACCESS_RTE;
+    ACCESS_EATTRS;
     ARG_ANY(1);
     STATIC_ATTR;
     ARG_TYPE(1, sa.type);
@@ -558,37 +578,51 @@
     {
       struct rta *rta = (*fs->rte)->attrs;
 
-      switch (sa.sa_code)
+      if (sa.sa_code == SA_DEST)
+	{
+	  int i = v1.val.i;
+	  if ((i != RTD_BLACKHOLE) && (i != RTD_UNREACHABLE) && (i != RTD_PROHIBIT))
+	    runtime( "Destination can be changed only to blackhole, unreachable or prohibit" );
+
+	  rta->dest = i;
+	  ea_unset_attr(fs->eattrs, 1, &ea_gen_nexthop);
+	}
+      else
       {
+	union {
+	  struct nexthop_adata nha;
+	  struct {
+	    struct adata ad;
+	    struct nexthop nh;
+	    u32 label;
+	  };
+	} nha;
+
+	nha.ad = (struct adata) {
+	  .length = sizeof (struct nexthop_adata) - sizeof (struct adata),
+	};
+
+	eattr *a = NULL;
+
+	switch (sa.sa_code)
+	  {
       case SA_GW:
 	{
+	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
+
 	  ip_addr ip = v1.val.ip;
-	  struct iface *ifa = ipa_is_link_local(ip) ? rta->nh.iface : NULL;
+	  struct iface *ifa = (ipa_is_link_local(ip) && nh_ea) ?
+	    ((struct nexthop_adata *) nh_ea->u.ptr)->nh.iface : NULL;
+	  
 	  neighbor *n = neigh_find((*fs->rte)->src->proto, ip, ifa, 0);
 	  if (!n || (n->scope == SCOPE_HOST))
 	    runtime( "Invalid gw address" );
 
 	  rta->dest = RTD_UNICAST;
-	  rta->nh.gw = ip;
-	  rta->nh.iface = n->iface;
-	  rta->nh.next = NULL;
-	  rta->hostentry = NULL;
-	  rta->nh.labels = 0;
-	}
-	break;
-
-      case SA_DEST:
-	{
-	  int i = v1.val.i;
-	  if ((i != RTD_BLACKHOLE) && (i != RTD_UNREACHABLE) && (i != RTD_PROHIBIT))
-	    runtime( "Destination can be changed only to blackhole, unreachable or prohibit" );
-
-	  rta->dest = i;
-	  rta->nh.gw = IPA_NONE;
-	  rta->nh.iface = NULL;
-	  rta->nh.next = NULL;
-	  rta->hostentry = NULL;
-	  rta->nh.labels = 0;
+	  nha.nh = (struct nexthop) {
+	    .gw = ip,
+	    .iface = n->iface,
+	  };
 	}
 	break;
 
@@ -599,11 +633,9 @@
 	    runtime( "Invalid iface name" );
 
 	  rta->dest = RTD_UNICAST;
-	  rta->nh.gw = IPA_NONE;
-	  rta->nh.iface = ifa;
-	  rta->nh.next = NULL;
-	  rta->hostentry = NULL;
-	  rta->nh.labels = 0;
+	  nha.nh = (struct nexthop) {
+	    .iface = ifa,
+	  };
 	}
 	break;
 
@@ -612,13 +644,20 @@
 	  if (v1.val.i >= 0x100000)
 	    runtime( "Invalid MPLS label" );
 
+	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
+	  if (!nh_ea)
+	    runtime( "No nexthop to add a MPLS label to" );
+
+	  nha.nh = ((struct nexthop_adata *) nh_ea->u.ptr)->nh;
+	  
 	  if (v1.val.i != MPLS_NULL)
 	  {
-	    rta->nh.label[0] = v1.val.i;
-	    rta->nh.labels = 1;
+	    nha.nh.label[0] = v1.val.i;
+	    nha.nh.labels = 1;
+	    nha.ad.length = sizeof nha - sizeof (struct adata);
 	  }
 	  else
-	    rta->nh.labels = 0;
+	    nha.nh.labels = 0;
 	}
 	break;
 
@@ -630,14 +669,32 @@
 	  if (rta->dest != RTD_UNICAST)
 	    runtime( "Setting weight needs regular nexthop " );
 
+	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
+	  if (!nh_ea)
+	    runtime( "No nexthop to set weight on" );
+
+	  struct nexthop_adata *nhax = (struct nexthop_adata *)
+	    tmp_copy_adata(&((struct nexthop_adata *) nh_ea->u.ptr)->ad);
+
 	  /* Set weight on all next hops */
-	  for (struct nexthop *nh = &rta->nh; nh; nh = nh->next)
+	  NEXTHOP_WALK(nh, nhax)
 	    nh->weight = i - 1;
+
+	  a = ea_set_attr(fs->eattrs,
+	      EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nhax->ad));
         }
 	break;
 
       default:
 	bug("Invalid static attribute access (%u/%u)", sa.type, sa.sa_code);
+	  }
+
+	if (!a)
+	  a = ea_set_attr(fs->eattrs,
+	      EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, tmp_copy_adata(&nha.ad)));
+
+	a->originated = 1;
+	a->fresh = 1;
       }
     }
   }
diff --git a/lib/attrs.h b/lib/attrs.h
index d2638f3f..79b7b14a 100644
--- a/lib/attrs.h
+++ b/lib/attrs.h
@@ -37,7 +37,9 @@ lp_store_adata(struct linpool *pool, const void *buf, uint len)
   return ad;
 }
 
+#define tmp_alloc_adata(len)	  lp_alloc_adata(tmp_linpool, len)
 #define tmp_store_adata(buf, len) lp_store_adata(tmp_linpool, buf, len)
+#define tmp_copy_adata(ad)	  tmp_store_adata((ad)->data, (ad)->length)
 
 static inline int adata_same(const struct adata *a, const struct adata *b)
 { return (a->length == b->length && !memcmp(a->data, b->data, a->length)); }
diff --git a/lib/route.h b/lib/route.h
index 5423ada3..29a78e90 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -67,13 +67,18 @@ void rt_prune_sources(void);
 struct nexthop {
   ip_addr gw;				/* Next hop */
   struct iface *iface;			/* Outgoing interface */
-  struct nexthop *next;
   byte flags;
   byte weight;
   byte labels;				/* Number of all labels */
   u32 label[0];
 };
 
+/* For packing one into eattrs */
+struct nexthop_adata {
+  struct adata ad;
+  struct nexthop nh;
+};
+
 #define RNF_ONLINK		0x1	/* Gateway is onlink regardless of IP ranges */
 
 
@@ -85,7 +90,6 @@ typedef struct rta {
   struct hostentry *hostentry;		/* Hostentry for recursive next-hops */
   u16 cached:1;				/* Are attributes cached? */
   u16 dest:4;				/* Route destination type (RTD_...) */
-  struct nexthop nh;			/* Next hop */
 } rta;
 
 #define RTS_STATIC 1			/* Normal static route */
@@ -286,9 +290,22 @@ ea_set_attr_u32(ea_list **to, const struct ea_class *def, uint flags, u64 data)
 { ea_set_attr(to, EA_LITERAL_EMBEDDED(def, flags, data)); }
 
 static inline void
-ea_set_attr_data(ea_list **to, const struct ea_class *def, uint flags, void *data, uint len)
+ea_set_attr_data(ea_list **to, const struct ea_class *def, uint flags, const void *data, uint len)
 { ea_set_attr(to, EA_LITERAL_STORE_ADATA(def, flags, data, len)); }
 
+static inline void
+ea_copy_attr(ea_list **to, ea_list *from, const struct ea_class *def)
+{
+  eattr *e = ea_find_by_class(from, def);
+  if (e)
+    if (e->type & EAF_EMBEDDED)
+      ea_set_attr_u32(to, def, e->flags, e->u.data);
+    else
+      ea_set_attr_data(to, def, e->flags, e->u.ptr->data, e->u.ptr->length);
+  else
+    ea_unset_attr(to, 0, def);
+}
+
 /*
  *	Common route attributes
  */
@@ -317,25 +334,39 @@ static inline u32 rt_get_source_attr(rte *rt)
  * to add additional labels to the resolved nexthop */
 extern struct ea_class ea_mpls_labels;
 
+/* Next hop: For now, stored as adata */
+extern struct ea_class ea_gen_nexthop;
+
 /* Next hop structures */
 
-#define NEXTHOP_MAX_SIZE (sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
+#define NEXTHOP_ALIGNMENT	(_Alignof(struct nexthop))
+#define NEXTHOP_MAX_SIZE	(sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
+#define NEXTHOP_SIZE(_nh)	NEXTHOP_SIZE_CNT(((_nh)->labels))
+#define NEXTHOP_SIZE_CNT(cnt)	BIRD_ALIGN((sizeof(struct nexthop) + sizeof(u32) * (cnt)), NEXTHOP_ALIGNMENT)
+#define nexthop_size(nh)	NEXTHOP_SIZE((nh))
+
+#define NEXTHOP_NEXT(_nh)	((void *) (_nh) + NEXTHOP_SIZE(_nh))
+#define NEXTHOP_END(_nhad)	((_nhad)->ad.data + (_nhad)->ad.length)
+#define NEXTHOP_VALID(_nh, _nhad) ((void *) (_nh) < (void *) NEXTHOP_END(_nhad))
+#define NEXTHOP_ONE(_nhad)	(NEXTHOP_NEXT(&(_nhad)->nh) == NEXTHOP_END(_nhad))
+
+#define NEXTHOP_WALK(_iter, _nhad) for ( \
+    struct nexthop *_iter = &(_nhad)->nh; \
+    (void *) _iter < (void *) NEXTHOP_END(_nhad); \
+    _iter = NEXTHOP_NEXT(_iter))
+
+
+static inline int nexthop_same(struct nexthop_adata *x, struct nexthop_adata *y)
+{ return adata_same(&x->ad, &y->ad); }
+struct nexthop_adata *nexthop_merge(struct nexthop_adata *x, struct nexthop_adata *y, int max, linpool *lp);
+struct nexthop_adata *nexthop_sort(struct nexthop_adata *x, linpool *lp);
+int nexthop_is_sorted(struct nexthop_adata *x);
+
 
-static inline size_t nexthop_size(const struct nexthop *nh)
-{ return sizeof(struct nexthop) + sizeof(u32)*nh->labels; }
-int nexthop__same(struct nexthop *x, struct nexthop *y); /* Compare multipath nexthops */
-static inline int nexthop_same(struct nexthop *x, struct nexthop *y)
-{ return (x == y) || nexthop__same(x, y); }
-struct nexthop *nexthop_merge(struct nexthop *x, struct nexthop *y, int rx, int ry, int max, linpool *lp);
-struct nexthop *nexthop_sort(struct nexthop *x);
-static inline void nexthop_link(struct rta *a, struct nexthop *from)
-{ memcpy(&a->nh, from, nexthop_size(from)); }
-void nexthop_insert(struct nexthop **n, struct nexthop *y);
-int nexthop_is_sorted(struct nexthop *x);
 
 void rta_init(void);
-static inline size_t rta_size(const rta *a) { return sizeof(rta) + sizeof(u32)*a->nh.labels; }
-#define RTA_MAX_SIZE (sizeof(rta) + sizeof(u32)*MPLS_MAX_LABEL_STACK)
+#define rta_size(...) (sizeof(rta))
+#define RTA_MAX_SIZE (sizeof(rta))
 rta *rta_lookup(rta *);			/* Get rta equivalent to this one, uc++ */
 static inline int rta_is_cached(rta *r) { return r->cached; }
 static inline rta *rta_clone(rta *r) { r->uc++; return r; }
diff --git a/lib/type.h b/lib/type.h
index abce1a1f..6da86c77 100644
--- a/lib/type.h
+++ b/lib/type.h
@@ -52,6 +52,7 @@ enum btype {
 /* Something but inaccessible. */
   T_OPAQUE = 0x02,		/* Opaque byte string (not filterable) */
   T_IFACE = 0x0c,		/* Pointer to an interface (inside adata) */
+  T_NEXTHOP_LIST = 0x2c,	/* The whole nexthop block */
 
 /* Types shared with eattrs */
   T_INT = 0x01,			/* 32-bit unsigned integer number */
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index dc4fe785..bd7ca425 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -57,6 +57,7 @@
 #include "lib/string.h"
 
 #include <stddef.h>
+#include <stdlib.h>
 
 const adata null_adata;		/* adata of length 0 */
 
@@ -108,6 +109,11 @@ struct ea_class ea_gen_source = {
   .format = ea_gen_source_format,
 };
 
+struct ea_class ea_gen_nexthop = {
+  .name = "nexthop",
+  .type = T_NEXTHOP_LIST,
+};
+
 struct ea_class ea_mpls_labels = {
   .name = "mpls_labels",
   .type = T_CLIST,
@@ -124,8 +130,7 @@ const char * rta_dest_names[RTD_MAX] = {
 
 pool *rta_pool;
 
-static slab *rta_slab_[4];
-static slab *nexthop_slab_[4];
+static slab *rta_slab;
 static slab *rte_src_slab;
 
 static struct idm src_ids;
@@ -204,50 +209,10 @@ rt_prune_sources(void)
  *	Multipath Next Hop
  */
 
-static inline u32
-nexthop_hash(struct nexthop *x)
-{
-  u32 h = 0;
-  for (; x; x = x->next)
-  {
-    h ^= ipa_hash(x->gw) ^ (h << 5) ^ (h >> 9);
-
-    for (int i = 0; i < x->labels; i++)
-      h ^= x->label[i] ^ (h << 6) ^ (h >> 7);
-  }
-
-  return h;
-}
-
-int
-nexthop__same(struct nexthop *x, struct nexthop *y)
-{
-  for (; x && y; x = x->next, y = y->next)
-  {
-    if (!ipa_equal(x->gw, y->gw) || (x->iface != y->iface) ||
-	(x->flags != y->flags) || (x->weight != y->weight) ||
-	(x->labels != y->labels))
-      return 0;
-
-    for (int i = 0; i < x->labels; i++)
-      if (x->label[i] != y->label[i])
-	return 0;
-  }
-
-  return x == y;
-}
-
 static int
 nexthop_compare_node(const struct nexthop *x, const struct nexthop *y)
 {
   int r;
-
-  if (!x)
-    return 1;
-
-  if (!y)
-    return -1;
-
   /* Should we also compare flags ? */
 
   r = ((int) y->weight) - ((int) x->weight);
@@ -272,23 +237,16 @@ nexthop_compare_node(const struct nexthop *x, const struct nexthop *y)
   return ((int) x->iface->index) - ((int) y->iface->index);
 }
 
-static inline struct nexthop *
-nexthop_copy_node(const struct nexthop *src, linpool *lp)
+static int
+nexthop_compare_qsort(const void *x, const void *y)
 {
-  struct nexthop *n = lp_alloc(lp, nexthop_size(src));
-
-  memcpy(n, src, nexthop_size(src));
-  n->next = NULL;
-
-  return n;
+  return nexthop_compare_node( *(const struct nexthop **) x, *(const struct nexthop **) y );
 }
 
 /**
  * nexthop_merge - merge nexthop lists
  * @x: list 1
  * @y: list 2
- * @rx: reusability of list @x
- * @ry: reusability of list @y
  * @max: max number of nexthops
  * @lp: linpool for allocating nexthops
  *
@@ -305,134 +263,111 @@ nexthop_copy_node(const struct nexthop *src, linpool *lp)
  * resulting list is no longer needed. When reusability is not set, the
  * corresponding lists are not modified nor linked from the resulting list.
  */
-struct nexthop *
-nexthop_merge(struct nexthop *x, struct nexthop *y, int rx, int ry, int max, linpool *lp)
+struct nexthop_adata *
+nexthop_merge(struct nexthop_adata *xin, struct nexthop_adata *yin, int max, linpool *lp)
 {
-  struct nexthop *root = NULL;
-  struct nexthop **n = &root;
+  uint outlen = ADATA_SIZE(xin->ad.length) + ADATA_SIZE(yin->ad.length);
+  struct nexthop_adata *out = lp_alloc(lp, outlen);
+  out->ad.length = outlen - sizeof (struct adata);
+
+  struct nexthop *x = &xin->nh, *y = &yin->nh, *cur = &out->nh;
+  int xvalid, yvalid;
 
-  while ((x || y) && max--)
+  while (max--)
   {
-    int cmp = nexthop_compare_node(x, y);
+    xvalid = NEXTHOP_VALID(x, xin);
+    yvalid = NEXTHOP_VALID(y, yin);
+
+    if (!xvalid && !yvalid)
+      break;
+
+    ASSUME(NEXTHOP_VALID(cur, out));
+
+    int cmp = !xvalid ? 1 : !yvalid ? -1 : nexthop_compare_node(x, y);
 
     if (cmp < 0)
     {
-      ASSUME(x);
-      *n = rx ? x : nexthop_copy_node(x, lp);
-      x = x->next;
+      ASSUME(NEXTHOP_VALID(x, xin));
+      memcpy(cur, x, nexthop_size(x));
+      x = NEXTHOP_NEXT(x);
     }
     else if (cmp > 0)
     {
-      ASSUME(y);
-      *n = ry ? y : nexthop_copy_node(y, lp);
-      y = y->next;
+      ASSUME(NEXTHOP_VALID(y, yin));
+      memcpy(cur, y, nexthop_size(y));
+      y = NEXTHOP_NEXT(y);
     }
     else
     {
-      ASSUME(x && y);
-      *n = rx ? x : (ry ? y : nexthop_copy_node(x, lp));
-      x = x->next;
-      y = y->next;
+      ASSUME(NEXTHOP_VALID(x, xin));
+      memcpy(cur, x, nexthop_size(x));
+      x = NEXTHOP_NEXT(x);
+
+      ASSUME(NEXTHOP_VALID(y, yin));
+      y = NEXTHOP_NEXT(y);
     }
-    n = &((*n)->next);
+    cur = NEXTHOP_NEXT(cur);
   }
-  *n = NULL;
 
-  return root;
+  out->ad.length = (void *) cur - (void *) out->ad.data;
+
+  return out;
 }
 
-void
-nexthop_insert(struct nexthop **n, struct nexthop *x)
+struct nexthop_adata *
+nexthop_sort(struct nexthop_adata *nhad, linpool *lp)
 {
-  for (; *n; n = &((*n)->next))
-  {
-    int cmp = nexthop_compare_node(*n, x);
+  /* Count the nexthops */
+  uint cnt = 0;
+  NEXTHOP_WALK(nh, nhad)
+    cnt++;
 
-    if (cmp < 0)
-      continue;
-    else if (cmp > 0)
-      break;
-    else
-      return;
-  }
+  if (cnt <= 1)
+    return nhad;
 
-  x->next = *n;
-  *n = x;
-}
+  /* Get pointers to them */
+  struct nexthop **sptr = tmp_alloc(cnt * sizeof(struct nexthop *));
 
-struct nexthop *
-nexthop_sort(struct nexthop *x)
-{
-  struct nexthop *s = NULL;
+  uint i = 0;
+  NEXTHOP_WALK(nh, nhad)
+    sptr[i++] = nh;
+
+  /* Sort the pointers */
+  qsort(sptr, cnt, sizeof(struct nexthop *), nexthop_compare_qsort);
+
+  /* Allocate the output */
+  struct nexthop_adata *out = (struct nexthop_adata *) lp_alloc_adata(lp, nhad->ad.length);
+  struct nexthop *dest = &out->nh;
 
-  /* Simple insert-sort */
-  while (x)
+  /* Deduplicate nexthops while storing them */
+  for (uint i = 0; i < cnt; i++)
   {
-    struct nexthop *n = x;
-    x = n->next;
-    n->next = NULL;
+    if (i && !nexthop_compare_node(sptr[i], sptr[i-1]))
+      continue;
 
-    nexthop_insert(&s, n);
+    memcpy(dest, sptr[i], NEXTHOP_SIZE(sptr[i]));
+    dest = NEXTHOP_NEXT(dest);
   }
 
-  return s;
+  out->ad.length = (void *) dest - (void *) out->ad.data;
+  return out;
 }
 
 int
-nexthop_is_sorted(struct nexthop *x)
+nexthop_is_sorted(struct nexthop_adata *nhad)
 {
-  for (; x && x->next; x = x->next)
-    if (nexthop_compare_node(x, x->next) >= 0)
+  struct nexthop *prev = NULL;
+  NEXTHOP_WALK(nh, nhad)
+  {
+    if (prev && (nexthop_compare_node(prev, nh) >= 0))
       return 0;
 
-  return 1;
-}
-
-static inline slab *
-nexthop_slab(struct nexthop *nh)
-{
-  return nexthop_slab_[MIN(nh->labels, 3)];
-}
-
-static struct nexthop *
-nexthop_copy(struct nexthop *o)
-{
-  struct nexthop *first = NULL;
-  struct nexthop **last = &first;
-
-  for (; o; o = o->next)
-    {
-      struct nexthop *n = sl_allocz(nexthop_slab(o));
-      n->gw = o->gw;
-      n->iface = o->iface;
-      n->next = NULL;
-      n->flags = o->flags;
-      n->weight = o->weight;
-      n->labels = o->labels;
-      for (int i=0; i<o->labels; i++)
-	n->label[i] = o->label[i];
-
-      *last = n;
-      last = &(n->next);
-    }
-
-  return first;
-}
-
-static void
-nexthop_free(struct nexthop *o)
-{
-  struct nexthop *n;
+    prev = nh;
+  }
 
-  while (o)
-    {
-      n = o->next;
-      sl_free(o);
-      o = n;
-    }
+  return 1;
 }
 
-
 /*
  *	Extended Attributes
  */
@@ -1122,6 +1057,23 @@ ea_show(struct cli *c, const eattr *e)
   cli_printf(c, -1012, "\t%s", buf);
 }
 
+static void
+nexthop_dump(const struct adata *ad)
+{
+  struct nexthop_adata *nhad = (struct nexthop_adata *) ad;
+
+  debug(":");
+
+  NEXTHOP_WALK(nh, nhad)
+    {
+      if (ipa_nonzero(nh->gw)) debug(" ->%I", nh->gw);
+      if (nh->labels) debug(" L %d", nh->label[0]);
+      for (int i=1; i<nh->labels; i++)
+	debug("/%d", nh->label[i]);
+      debug(" [%s]", nh->iface ? nh->iface->name : "???");
+    }
+}
+
 /**
  * ea_dump - dump an extended attribute
  * @e: attribute to be dumped
@@ -1157,6 +1109,8 @@ ea_dump(ea_list *e)
 	    debug("o");
 	  if (a->type & EAF_EMBEDDED)
 	    debug(":%08x", a->u.data);
+	  else if (a->id == ea_gen_nexthop.id)
+	    nexthop_dump(a->u.ptr);
 	  else
 	    {
 	      int j, len = a->u.ptr->length;
@@ -1258,7 +1212,7 @@ rta_hash(rta *a)
   BMIX(dest);
 #undef MIX
 
-  return mem_hash_value(&h) ^ nexthop_hash(&(a->nh)) ^ ea_hash(a->eattrs);
+  return mem_hash_value(&h) ^ ea_hash(a->eattrs);
 }
 
 static inline int
@@ -1266,24 +1220,16 @@ rta_same(rta *x, rta *y)
 {
   return (x->dest == y->dest &&
 	  x->hostentry == y->hostentry &&
-	  nexthop_same(&(x->nh), &(y->nh)) &&
 	  ea_same(x->eattrs, y->eattrs));
 }
 
-static inline slab *
-rta_slab(rta *a)
-{
-  return rta_slab_[a->nh.labels > 2 ? 3 : a->nh.labels];
-}
-
 static rta *
 rta_copy(rta *o)
 {
-  rta *r = sl_alloc(rta_slab(o));
+  rta *r = sl_alloc(rta_slab);
 
   memcpy(r, o, rta_size(o));
   r->uc = 1;
-  r->nh.next = nexthop_copy(o->nh.next);
   if (!r->eattrs)
     return r;
 
@@ -1375,8 +1321,6 @@ rta__free(rta *a)
   if (a->next)
     a->next->pprev = a->pprev;
   rt_unlock_hostentry(a->hostentry);
-  if (a->nh.next)
-    nexthop_free(a->nh.next);
   ea_free(a->eattrs);
   a->cached = 0;
   sl_free(a);
@@ -1387,12 +1331,6 @@ rta_do_cow(rta *o, linpool *lp)
 {
   rta *r = lp_alloc(lp, rta_size(o));
   memcpy(r, o, rta_size(o));
-  for (struct nexthop **nhn = &(r->nh.next), *nho = o->nh.next; nho; nho = nho->next)
-    {
-      *nhn = lp_alloc(lp, nexthop_size(nho));
-      memcpy(*nhn, nho, nexthop_size(nho));
-      nhn = &((*nhn)->next);
-    }
   r->cached = 0;
   r->uc = 0;
   return r;
@@ -1413,15 +1351,6 @@ rta_dump(rta *a)
 	a->uc, rtd[a->dest], a->hash_key);
   if (!a->cached)
     debug(" !CACHED");
-  if (a->dest == RTD_UNICAST)
-    for (struct nexthop *nh = &(a->nh); nh; nh = nh->next)
-      {
-	if (ipa_nonzero(nh->gw)) debug(" ->%I", nh->gw);
-	if (nh->labels) debug(" L %d", nh->label[0]);
-	for (int i=1; i<nh->labels; i++)
-	  debug("/%d", nh->label[i]);
-	debug(" [%s]", nh->iface ? nh->iface->name : "???");
-      }
   if (a->eattrs)
     {
       debug(" EA: ");
@@ -1471,15 +1400,7 @@ rta_init(void)
 {
   rta_pool = rp_new(&root_pool, "Attributes");
 
-  rta_slab_[0] = sl_new(rta_pool, sizeof(rta));
-  rta_slab_[1] = sl_new(rta_pool, sizeof(rta) + sizeof(u32));
-  rta_slab_[2] = sl_new(rta_pool, sizeof(rta) + sizeof(u32)*2);
-  rta_slab_[3] = sl_new(rta_pool, sizeof(rta) + sizeof(u32)*MPLS_MAX_LABEL_STACK);
-
-  nexthop_slab_[0] = sl_new(rta_pool, sizeof(struct nexthop));
-  nexthop_slab_[1] = sl_new(rta_pool, sizeof(struct nexthop) + sizeof(u32));
-  nexthop_slab_[2] = sl_new(rta_pool, sizeof(struct nexthop) + sizeof(u32)*2);
-  nexthop_slab_[3] = sl_new(rta_pool, sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK);
+  rta_slab = sl_new(rta_pool, sizeof(rta));
 
   rta_alloc_hash();
   rte_src_init();
@@ -1489,6 +1410,7 @@ rta_init(void)
   ea_register_init(&ea_gen_igp_metric);
   ea_register_init(&ea_gen_from);
   ea_register_init(&ea_gen_source);
+  ea_register_init(&ea_gen_nexthop);
 
   ea_register_init(&ea_mpls_labels);
 }
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index af6506f6..9953e270 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -84,11 +84,16 @@ dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
 
       rta a0 = {
 	.dest = RTD_UNICAST,
-	.nh.iface = ad->iface,
+      };
+
+      struct nexthop_adata nhad = {
+	.nh = { .iface = ad->iface, },
+	.ad = { .length = (void *) NEXTHOP_NEXT(&nhad.nh) - (void *) nhad.ad.data, },
       };
 
       ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, c->preference);
       ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_DEVICE);
+      ea_set_attr_data(&a0.eattrs, &ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length);
 
       a = rta_lookup(&a0);
       e = rte_get_temp(a, src);
diff --git a/nest/rt-show.c b/nest/rt-show.c
index be4c0186..32f7aa2d 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -45,11 +45,12 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
   rta *a = e->attrs;
   int sync_error = d->kernel ? krt_get_sync_error(d->kernel, e) : 0;
   void (*get_route_info)(struct rte *, byte *buf);
-  struct nexthop *nh;
+  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
 
   tm_format_time(tm, &config->tf_route, e->lastmod);
   ip_addr a_from = ea_get_ip(a->eattrs, &ea_gen_from, IPA_NONE);
-  if (ipa_nonzero(a_from) && !ipa_equal(a_from, a->nh.gw))
+  if (ipa_nonzero(a_from) && (!nhad || !ipa_equal(a_from, nhad->nh.gw)))
     bsprintf(from, " from %I", a_from);
   else
     from[0] = 0;
@@ -71,7 +72,7 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
 	     e->src->proto->name, tm, from, primary ? (sync_error ? " !" : " *") : "", info);
 
   if (a->dest == RTD_UNICAST)
-    for (nh = &(a->nh); nh; nh = nh->next)
+    NEXTHOP_WALK(nh, nhad)
     {
       char mpls[MPLS_MAX_LABEL_STACK*12 + 5], *lsp = mpls;
       char *onlink = (nh->flags & RNF_ONLINK) ? " onlink" : "";
@@ -85,7 +86,7 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
 	}
       *lsp = '\0';
 
-      if (a->nh.next)
+      if (!NEXTHOP_ONE(nhad))
 	bsprintf(weight, " weight %d", nh->weight + 1);
 
       if (ipa_nonzero(nh->gw))
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 37f17bbc..6f948ada 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -940,18 +940,11 @@ rt_notify_accepted(struct channel *c, net *net, rte *new_changed, rte *old_chang
     rte_free(new_free);
 }
 
-
-static struct nexthop *
-nexthop_merge_rta(struct nexthop *nhs, rta *a, linpool *pool, int max)
-{
-  return nexthop_merge(nhs, &(a->nh), 1, 0, max, pool);
-}
-
 rte *
 rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int silent)
 {
   // struct proto *p = c->proto;
-  struct nexthop *nhs = NULL;
+  struct nexthop_adata *nhs = NULL;
   rte *best0, *best, *rt0, *rt, *tmp;
 
   best0 = net->routes;
@@ -976,21 +969,31 @@ rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int
       continue;
 
     if (rte_is_reachable(rt))
-      nhs = nexthop_merge_rta(nhs, rt->attrs, pool, c->merge_limit);
+    {
+      eattr *nhea = ea_find(rt->attrs->eattrs, &ea_gen_nexthop);
+      ASSERT_DIE(nhea);
+
+      if (nhs)
+	nhs = nexthop_merge(nhs, (struct nexthop_adata *) nhea->u.ptr, c->merge_limit, pool);
+      else
+	nhs = (struct nexthop_adata *) nhea->u.ptr;
+    }
 
     if (tmp)
       rte_free(tmp);
   }
 
+
   if (nhs)
   {
-    nhs = nexthop_merge_rta(nhs, best->attrs, pool, c->merge_limit);
+    eattr *nhea = ea_find(best->attrs->eattrs, &ea_gen_nexthop);
+    ASSERT_DIE(nhea);
 
-    if (nhs->next)
-    {
-      best = rte_cow_rta(best, pool);
-      nexthop_link(best->attrs, nhs);
-    }
+    nhs = nexthop_merge(nhs, (struct nexthop_adata *) nhea->u.ptr, c->merge_limit, pool);
+
+    best = rte_cow_rta(best, pool);
+    ea_set_attr(&best->attrs->eattrs,
+	EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nhs->ad));
   }
 
   if (best != best0)
@@ -1184,7 +1187,16 @@ rte_validate(rte *e)
     return 0;
   }
 
-  if ((e->attrs->dest == RTD_UNICAST) && !nexthop_is_sorted(&(e->attrs->nh)))
+  eattr *nhea = ea_find(e->attrs->eattrs, &ea_gen_nexthop);
+  if ((!nhea) != (e->attrs->dest != RTD_UNICAST))
+  {
+    log(L_WARN "Ignoring route %N with destination %d and %snexthop received via %s",
+	n->n.addr, e->attrs->dest, (nhea ? "" : "no "), e->sender->proto->name);
+    return 0;
+  }
+
+  if ((e->attrs->dest == RTD_UNICAST) &&
+      !nexthop_is_sorted((struct nexthop_adata *) nhea->u.ptr))
   {
     log(L_WARN "Ignoring unsorted multipath route %N received via %s",
 	n->n.addr, e->sender->proto->name);
@@ -2395,8 +2407,7 @@ rta_apply_hostentry(rta *a, struct hostentry *he)
   if (a->dest != RTD_UNICAST)
   {
     /* No nexthop */
-no_nexthop:
-    a->nh = (struct nexthop) {};
+    ea_unset_attr(&a->eattrs, 0, &ea_gen_nexthop);
     return;
   }
 
@@ -2404,74 +2415,71 @@ no_nexthop:
 
   if (!mls_ea && he->nexthop_linkable)
   { /* Just link the nexthop chain, no label append happens. */
-    memcpy(&(a->nh), &(he->src->nh), nexthop_size(&(he->src->nh)));
+    ea_copy_attr(&a->eattrs, he->src->eattrs, &ea_gen_nexthop);
     return;
   }
 
-  struct nexthop *nhp = NULL, *nhr = NULL;
-  int skip_nexthop = 0;
-
   const struct adata *mls = mls_ea ? mls_ea->u.ptr : NULL;
   uint mls_cnt = mls ? mls->length / sizeof(u32) : 0;
 
-  for (struct nexthop *nh = &(he->src->nh); nh; nh = nh->next)
+  eattr *he_nh_ea = ea_find(he->src->eattrs, &ea_gen_nexthop);
+  struct nexthop_adata *nhad = (struct nexthop_adata *) he_nh_ea->u.ptr;
+
+  uint total_size = OFFSETOF(struct nexthop_adata, nh);
+
+  NEXTHOP_WALK(nh, nhad)
   {
-    if (skip_nexthop)
-      skip_nexthop--;
-    else
+    if (nh->labels + mls_cnt > MPLS_MAX_LABEL_STACK)
     {
-      nhr = nhp;
-      nhp = (nhp ? (nhp->next = lp_alloc(rte_update_pool, NEXTHOP_MAX_SIZE)) : &(a->nh));
+      log(L_WARN "Sum of label stack sizes %d + %d = %d exceedes allowed maximum (%d)",
+	    nh->labels, mls_cnt, nh->labels + mls_cnt, MPLS_MAX_LABEL_STACK);
+      continue;
     }
 
-    memset(nhp, 0, NEXTHOP_MAX_SIZE);
-    nhp->iface = nh->iface;
-    nhp->weight = nh->weight;
+    total_size += NEXTHOP_SIZE_CNT(nh->labels + mls_cnt);
+  }
 
-    if (mls)
-    {
-      nhp->labels = nh->labels + mls_cnt;
-      if (nhp->labels <= MPLS_MAX_LABEL_STACK)
-      {
-	memcpy(nhp->label, nh->label, nh->labels * sizeof(u32)); /* First the hostentry labels */
-	memcpy(&(nhp->label[nh->labels]), mls->data, mls->length); /* Then the bottom labels */
-      }
-      else
-      {
-	log(L_WARN "Sum of label stack sizes %d + %d = %d exceedes allowed maximum (%d)",
-	    nh->labels, mls_cnt, nhp->labels, MPLS_MAX_LABEL_STACK);
-	skip_nexthop++;
-	continue;
-      }
-    }
-    else if (nh->labels)
+  if (total_size == OFFSETOF(struct nexthop_adata, nh))
+  {
+    a->dest = RTD_UNREACHABLE;
+    log(L_WARN "No valid nexthop remaining, setting route unreachable");
+
+    ea_unset_attr(&a->eattrs, 0, &ea_gen_nexthop);
+    return;
+  }
+
+  struct nexthop_adata *new = (struct nexthop_adata *) tmp_alloc_adata(total_size);
+  struct nexthop *dest = &new->nh;
+
+  NEXTHOP_WALK(nh, nhad)
+  {
+    if (nh->labels + mls_cnt > MPLS_MAX_LABEL_STACK)
+      continue;
+
+    memcpy(dest, nh, NEXTHOP_SIZE(nh));
+    if (mls_cnt)
     {
-      nhp->labels = nh->labels;
-      memcpy(nhp->label, nh->label, nh->labels * sizeof(u32));
+      memcpy(&(dest->label[dest->labels]), mls->data, mls->length);
+      dest->labels += mls_cnt;
     }
 
     if (ipa_nonzero(nh->gw))
-    {
-      nhp->gw = nh->gw;			/* Router nexthop */
-      nhp->flags |= (nh->flags & RNF_ONLINK);
-    }
+      /* Router nexthop */
+      dest->flags = (dest->flags & RNF_ONLINK);
     else if (!(nh->iface->flags & IF_MULTIACCESS) || (nh->iface->flags & IF_LOOPBACK))
-      nhp->gw = IPA_NONE;		/* PtP link - no need for nexthop */
+      dest->gw = IPA_NONE;		/* PtP link - no need for nexthop */
     else if (ipa_nonzero(he->link))
-      nhp->gw = he->link;		/* Device nexthop with link-local address known */
+      dest->gw = he->link;		/* Device nexthop with link-local address known */
     else
-      nhp->gw = he->addr;		/* Device nexthop with link-local address unknown */
+      dest->gw = he->addr;		/* Device nexthop with link-local address unknown */
+
+    dest = NEXTHOP_NEXT(dest);
   }
 
-  if (skip_nexthop)
-    if (nhr)
-      nhr->next = NULL;
-    else
-    {
-      a->dest = RTD_UNREACHABLE;
-      log(L_WARN "No valid nexthop remaining, setting route unreachable");
-      goto no_nexthop;
-    }
+  /* Fix final length */
+  new->ad.length = (void *) dest - (void *) new->ad.data;
+  ea_set_attr(&a->eattrs, EA_LITERAL_DIRECT_ADATA(
+	&ea_gen_nexthop, 0, &new->ad));
 }
 
 static inline int
@@ -2485,9 +2493,14 @@ rta_next_hop_outdated(rta *a)
   if (!he->src)
     return a->dest != RTD_UNREACHABLE;
 
+  eattr *he_nh_ea = ea_find(he->src->eattrs, &ea_gen_nexthop);
+  eattr *a_nh_ea = ea_find(a->eattrs, &ea_gen_nexthop);
+
   return (a->dest != he->dest) ||
     (ea_get_int(a->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN) != he->igp_metric) ||
-    (!he->nexthop_linkable) || !nexthop_same(&(a->nh), &(he->src->nh));
+    (!he->nexthop_linkable) ||
+    (!he_nh_ea != !a_nh_ea) ||
+    (he_nh_ea && a_nh_ea && !adata_same(he_nh_ea->u.ptr, a_nh_ea->u.ptr));
 }
 
 static inline rte *
@@ -3507,7 +3520,14 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
 
       if (a->dest == RTD_UNICAST)
 	{
-	  for (struct nexthop *nh = &(a->nh); nh; nh = nh->next)
+	  eattr *ea = ea_find(a->eattrs, &ea_gen_nexthop);
+	  if (!ea)
+	    {
+	      log(L_WARN "No nexthop in unicast route");
+	      goto done;
+	    }
+	    
+	  NEXTHOP_WALK(nh, (struct nexthop_adata *) ea->u.ptr)
 	    if (ipa_zero(nh->gw))
 	      {
 		if (if_local_addr(he->addr, nh->iface))
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index a7dcee09..9a43f484 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -643,15 +643,34 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
 
   if (r)
   {
+    struct nexthop_adata nhad = {
+      .nh = {
+	.gw = r->next_hop,
+	.iface = r->neigh->ifa->iface,
+      },
+      .ad = {
+	.length = sizeof nhad - sizeof nhad.ad,
+      },
+    };
+
+    /*
+     * If we cannot find a reachable neighbour, set the entry to be onlink. This
+     * makes it possible to, e.g., assign /32 addresses on a mesh interface and
+     * have routing work.
+     */
+    if (!neigh_find(&p->p, r->next_hop, r->neigh->ifa->iface, 0))
+      nhad.nh.flags = RNF_ONLINK;
+    
     struct {
       ea_list l;
-      eattr a[6];
+      eattr a[7];
     } eattrs = {
       .l.count = ARRAY_SIZE(eattrs.a),
       .a = {
 	EA_LITERAL_EMBEDDED(&ea_gen_preference, 0, c->preference),
 	EA_LITERAL_STORE_ADATA(&ea_gen_from, 0, &r->neigh->addr, sizeof(r->neigh->addr)),
 	EA_LITERAL_EMBEDDED(&ea_gen_source, 0, RTS_BABEL),
+	EA_LITERAL_STORE_ADATA(&ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length),
 	EA_LITERAL_EMBEDDED(&ea_babel_metric, 0, r->metric),
 	EA_LITERAL_STORE_ADATA(&ea_babel_router_id, 0, &r->router_id, sizeof(r->router_id)),
 	EA_LITERAL_EMBEDDED(&ea_babel_seqno, 0, r->seqno),
@@ -660,19 +679,9 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
 
     rta a0 = {
       .dest = RTD_UNICAST,
-      .nh.gw = r->next_hop,
-      .nh.iface = r->neigh->ifa->iface,
       .eattrs = &eattrs.l,
     };
 
-    /*
-     * If we cannot find a reachable neighbour, set the entry to be onlink. This
-     * makes it possible to, e.g., assign /32 addresses on a mesh interface and
-     * have routing work.
-     */
-    if (!neigh_find(&p->p, r->next_hop, r->neigh->ifa->iface, 0))
-      a0.nh.flags = RNF_ONLINK;
-
     rta *a = rta_lookup(&a0);
     rte *rte = rte_get_temp(a, p->p.main_source);
 
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index f8228313..fd0a1be4 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -966,10 +966,19 @@ bgp_apply_next_hop(struct bgp_parse_state *s, rta *a, ip_addr gw, ip_addr ll)
     if (nbr->scope == SCOPE_HOST)
       WITHDRAW(BAD_NEXT_HOP " - address %I is local", nbr->addr);
 
-    a->dest = RTD_UNICAST;
-    a->nh.gw = nbr->addr;
-    a->nh.iface = nbr->iface;
     ea_set_attr_u32(&a->eattrs, &ea_gen_igp_metric, 0, c->cf->cost);
+
+    a->dest = RTD_UNICAST;
+    struct nexthop_adata nhad = {
+      .nh = {
+	.gw = nbr->addr,
+	.iface = nbr->iface,
+      },
+      .ad = {
+	.length = sizeof nhad - sizeof nhad.ad,
+      },
+    };
+    ea_set_attr_data(&a->eattrs, &ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length);
   }
   else /* GW_RECURSIVE */
   {
@@ -998,7 +1007,7 @@ bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a)
 
     a->dest = RTD_UNREACHABLE;
     a->hostentry = NULL;
-    a->nh = (struct nexthop) { };
+    ea_unset_attr(&a->eattrs, 0, &ea_gen_nexthop);
     return;
   }
 
@@ -1008,8 +1017,16 @@ bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a)
 
   if (s->channel->cf->gw_mode == GW_DIRECT)
   {
-    a->nh.labels = lnum;
-    memcpy(a->nh.label, labels, 4*lnum);
+    eattr *e = ea_find(a->eattrs, &ea_gen_nexthop);
+    struct {
+      struct nexthop_adata nhad;
+      u32 labels[MPLS_MAX_LABEL_STACK];
+    } nh;
+    
+    memcpy(&nh.nhad, e->u.ptr, sizeof(struct adata) + e->u.ptr->length);
+    nh.nhad.nh.labels = lnum;
+    memcpy(nh.labels, labels, lnum * sizeof(u32));
+    nh.nhad.ad.length = sizeof nh.nhad + lnum * sizeof(u32);
   }
   else /* GW_RECURSIVE */
     rta_apply_hostentry(a, s->hostentry);
@@ -1076,7 +1093,7 @@ bgp_use_next_hop(struct bgp_export_state *s, eattr *a)
   return p->neigh && (p->neigh->iface == ifa);
 }
 
-static inline int
+static inline struct nexthop *
 bgp_use_gateway(struct bgp_export_state *s)
 {
   struct bgp_proto *p = s->proto;
@@ -1085,22 +1102,35 @@ bgp_use_gateway(struct bgp_export_state *s)
 
   /* Handle next hop self option - also applies to gateway */
   if (c->cf->next_hop_self && bgp_match_src(s, c->cf->next_hop_self))
-    return 0;
+    return NULL;
+
+  /* Unreachable */
+  if (ra->dest != RTD_UNICAST)
+    return NULL;
+
+  eattr *nhea = ea_find(ra->eattrs, &ea_gen_nexthop);
+  if (!nhea)
+    return NULL;
 
   /* We need one valid global gateway */
-  if ((ra->dest != RTD_UNICAST) || ra->nh.next || ipa_zero(ra->nh.gw) || ipa_is_link_local(ra->nh.gw))
-    return 0;
+  struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
+  if (!NEXTHOP_ONE(nhad) || ipa_zero(nhad->nh.gw) ||
+      ipa_is_link_local(nhad->nh.gw))
+    return NULL;
 
   /* Check for non-matching AF */
-  if ((ipa_is_ip4(ra->nh.gw) != bgp_channel_is_ipv4(c)) && !c->ext_next_hop)
-    return 0;
+  if ((ipa_is_ip4(nhad->nh.gw) != bgp_channel_is_ipv4(c)) && !c->ext_next_hop)
+    return NULL;
 
   /* Use it when exported to internal peers */
   if (p->is_interior)
-    return 1;
+    return &nhad->nh;
 
   /* Use it when forwarded to single-hop BGP peer on on the same iface */
-  return p->neigh && (p->neigh->iface == ra->nh.iface);
+  if (p->neigh && (p->neigh->iface == nhad->nh.iface))
+    return &nhad->nh;
+
+  return NULL;
 }
 
 static void
@@ -1108,17 +1138,17 @@ bgp_update_next_hop_ip(struct bgp_export_state *s, eattr *a, ea_list **to)
 {
   if (!a || !bgp_use_next_hop(s, a))
   {
-    if (bgp_use_gateway(s))
+    struct nexthop *nhloc;
+    if (nhloc = bgp_use_gateway(s))
     {
-      rta *ra = s->route->attrs;
-      ip_addr nh[1] = { ra->nh.gw };
+      ip_addr nh[1] = { nhloc->gw };
       bgp_set_attr_data(to, BA_NEXT_HOP, 0, nh, 16);
 
       if (s->mpls)
       {
 	u32 implicit_null = BGP_MPLS_NULL;
-	u32 *labels = ra->nh.labels ? ra->nh.label : &implicit_null;
-	uint lnum = ra->nh.labels ? ra->nh.labels : 1;
+	u32 *labels = nhloc->labels ? nhloc->label : &implicit_null;
+	uint lnum = nhloc->labels ? nhloc->labels : 1;
 	bgp_set_attr_data(to, BA_MPLS_LABEL_STACK, 0, labels, lnum * 4);
       }
     }
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 91739056..6070fd34 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -28,24 +28,30 @@ nh_is_vlink(struct nexthop *nhs)
 static inline int
 unresolved_vlink(ort *ort)
 {
-  return ort->n.nhs && nh_is_vlink(ort->n.nhs);
+  return ort->n.nhs && nh_is_vlink(&ort->n.nhs->nh);
 }
 
-static inline struct nexthop *
+static inline struct nexthop_adata *
 new_nexthop(struct ospf_proto *p, ip_addr gw, struct iface *iface, byte weight)
 {
-  struct nexthop *nh = lp_allocz(p->nhpool, sizeof(struct nexthop));
-  nh->gw = gw;
-  nh->iface = iface;
-  nh->weight = weight;
-  return nh;
+  struct nexthop_adata *nhad = lp_alloc(p->nhpool, sizeof(struct nexthop_adata));
+  *nhad = (struct nexthop_adata) {
+    .ad = { .length = sizeof *nhad - sizeof nhad->ad, },
+    .nh = {
+      .gw = gw,
+      .iface = iface,
+      .weight = weight,
+    },
+  };
+
+  return nhad;
 }
 
 /* Returns true if there are device nexthops in n */
 static inline int
-has_device_nexthops(const struct nexthop *n)
+has_device_nexthops(struct nexthop_adata *nhad)
 {
-  for (; n; n = n->next)
+  NEXTHOP_WALK(n, nhad)
     if (ipa_zero(n->gw))
       return 1;
 
@@ -53,38 +59,22 @@ has_device_nexthops(const struct nexthop *n)
 }
 
 /* Replace device nexthops with nexthops to gw */
-static struct nexthop *
-fix_device_nexthops(struct ospf_proto *p, const struct nexthop *n, ip_addr gw)
+static struct nexthop_adata *
+fix_device_nexthops(struct ospf_proto *p, struct nexthop_adata *old, ip_addr gw)
 {
-  struct nexthop *root1 = NULL;
-  struct nexthop *root2 = NULL;
-  struct nexthop **nn1 = &root1;
-  struct nexthop **nn2 = &root2;
-
   if (!p->ecmp)
-    return new_nexthop(p, gw, n->iface, n->weight);
-
-  /* This is a bit tricky. We cannot just copy the list and update n->gw,
-     because the list should stay sorted, so we create two lists, one with new
-     gateways and one with old ones, and then merge them. */
-
-  for (; n; n = n->next)
   {
-    struct nexthop *nn = new_nexthop(p, ipa_zero(n->gw) ? gw : n->gw, n->iface, n->weight);
+    struct nexthop_adata *new = (struct nexthop_adata *) lp_store_adata(p->nhpool, old->ad.data, old->ad.length);
+    new->nh.gw = gw;
+    return new;
+  }
 
+  struct nexthop_adata *tmp = (struct nexthop_adata *) tmp_copy_adata(&old->ad);
+  NEXTHOP_WALK(n, tmp)
     if (ipa_zero(n->gw))
-    {
-      *nn1 = nn;
-      nn1 = &(nn->next);
-    }
-    else
-    {
-      *nn2 = nn;
-      nn2 = &(nn->next);
-    }
-  }
+      n->gw = gw;
 
-  return nexthop_merge(root1, root2, 1, 1, p->ecmp, p->nhpool);
+  return nexthop_sort(tmp, p->nhpool);
 }
 
 
@@ -169,9 +159,9 @@ orta_compare(const struct ospf_proto *p, const orta *new, const orta *old)
     return -1;
   if (!new->nhs)
     return 1;
-  if (nh_is_vlink(new->nhs))
+  if (nh_is_vlink(&new->nhs->nh))
     return -1;
-  if (nh_is_vlink(old->nhs))
+  if (nh_is_vlink(&old->nhs->nh))
     return 1;
 
 
@@ -279,11 +269,7 @@ ort_merge(struct ospf_proto *p, ort *o, const orta *new)
   orta *old = &o->n;
 
   if (old->nhs != new->nhs)
-  {
-    old->nhs = nexthop_merge(old->nhs, new->nhs, old->nhs_reuse, new->nhs_reuse,
-			  p->ecmp, p->nhpool);
-    old->nhs_reuse = 1;
-  }
+    old->nhs = nexthop_merge(old->nhs, new->nhs, p->ecmp, p->nhpool);
 
   if (old->rid < new->rid)
     old->rid = new->rid;
@@ -295,11 +281,7 @@ ort_merge_ext(struct ospf_proto *p, ort *o, const orta *new)
   orta *old = &o->n;
 
   if (old->nhs != new->nhs)
-  {
-    old->nhs = nexthop_merge(old->nhs, new->nhs, old->nhs_reuse, new->nhs_reuse,
-			  p->ecmp, p->nhpool);
-    old->nhs_reuse = 1;
-  }
+    old->nhs = nexthop_merge(old->nhs, new->nhs, p->ecmp, p->nhpool);
 
   if (old->tag != new->tag)
     old->tag = 0;
@@ -1165,7 +1147,7 @@ ospf_check_vlinks(struct ospf_proto *p)
 
       if (tmp && (tmp->color == INSPF) && ipa_nonzero(tmp->lb) && tmp->nhs)
       {
-	struct ospf_iface *nhi = ospf_iface_find(p, tmp->nhs->iface);
+	struct ospf_iface *nhi = ospf_iface_find(p, tmp->nhs->nh.iface);
 
 	if ((ifa->state != OSPF_IS_PTP)
 	    || (ifa->vifa != nhi)
@@ -1579,10 +1561,7 @@ ospf_ext_spf(struct ospf_proto *p)
 
       /* Replace device nexthops with nexthops to forwarding address from LSA */
       if (has_device_nexthops(nfa.nhs))
-      {
 	nfa.nhs = fix_device_nexthops(p, nfa.nhs, rt.fwaddr);
-	nfa.nhs_reuse = 1;
-      }
     }
 
     if (rt.ebit)
@@ -1726,10 +1705,10 @@ ospf_rt_spf(struct ospf_proto *p)
 
 
 static inline int
-inherit_nexthops(struct nexthop *pn)
+inherit_nexthops(struct nexthop_adata *pn)
 {
   /* Proper nexthops (with defined GW) or dummy vlink nexthops (without iface) */
-  return pn && (ipa_nonzero(pn->gw) || !pn->iface);
+  return pn && (ipa_nonzero(pn->nh.gw) || !pn->nh.iface);
 }
 
 static inline ip_addr
@@ -1744,12 +1723,12 @@ link_lsa_lladdr(struct ospf_proto *p, struct top_hash_entry *en)
   return ospf_is_ip4(p) ? ipa_from_ip4(ospf3_6to4(ll)) : ipa_from_ip6(ll);
 }
 
-static struct nexthop *
+static struct nexthop_adata *
 calc_next_hop(struct ospf_area *oa, struct top_hash_entry *en,
 	      struct top_hash_entry *par, int pos, uint data, uint lif, uint nif)
 {
   struct ospf_proto *p = oa->po;
-  struct nexthop *pn = par->nhs;
+  struct nexthop_adata *pn = par->nhs;
   struct top_hash_entry *link = NULL;
   struct ospf_iface *ifa = NULL;
   ip_addr nh = IPA_NONE;
@@ -1827,10 +1806,10 @@ calc_next_hop(struct ospf_area *oa, struct top_hash_entry *en,
 	return NULL;
     }
 
-    struct nexthop *nhs = new_nexthop(p, nh, ifa->iface, ifa->ecmp_weight);
+    struct nexthop_adata *nhs = new_nexthop(p, nh, ifa->iface, ifa->ecmp_weight);
 
     if (ifa->addr->flags & IA_HOST)
-      nhs->flags = RNF_ONLINK;
+      nhs->nh.flags = RNF_ONLINK;
 
     return nhs;
   }
@@ -1851,7 +1830,7 @@ calc_next_hop(struct ospf_area *oa, struct top_hash_entry *en,
       if (ipa_zero(en->lb))
 	goto bad;
 
-      return new_nexthop(p, en->lb, pn->iface, pn->weight);
+      return new_nexthop(p, en->lb, pn->nh.iface, pn->nh.weight);
     }
     else /* OSPFv3 */
     {
@@ -1859,7 +1838,7 @@ calc_next_hop(struct ospf_area *oa, struct top_hash_entry *en,
        * Next-hop is taken from lladdr field of Link-LSA, en->lb_id
        * is computed in link_back().
        */
-      link = ospf_hash_find(p->gr, pn->iface->index, en->lb_id, rid, LSA_T_LINK);
+      link = ospf_hash_find(p->gr, pn->nh.iface->index, en->lb_id, rid, LSA_T_LINK);
       if (!link)
 	return NULL;
 
@@ -1867,7 +1846,7 @@ calc_next_hop(struct ospf_area *oa, struct top_hash_entry *en,
       if (ipa_zero(nh))
 	return NULL;
 
-      return new_nexthop(p, nh, pn->iface, pn->weight);
+      return new_nexthop(p, nh, pn->nh.iface, pn->nh.weight);
     }
   }
 
@@ -1914,7 +1893,7 @@ add_cand(struct ospf_area *oa, struct top_hash_entry *en, struct top_hash_entry
   if (!link_back(oa, en, par, lif, nif))
     return;
 
-  struct nexthop *nhs = calc_next_hop(oa, en, par, pos, data, lif, nif);
+  struct nexthop_adata *nhs = calc_next_hop(oa, en, par, pos, data, lif, nif);
   if (!nhs)
   {
     log(L_WARN "%s: Cannot find next hop for LSA (Type: %04x, Id: %R, Rt: %R)",
@@ -1923,7 +1902,7 @@ add_cand(struct ospf_area *oa, struct top_hash_entry *en, struct top_hash_entry
   }
 
   /* If en->dist > 0, we know that en->color == CANDIDATE and en->nhs is defined. */
-  if ((dist == en->dist) && !nh_is_vlink(en->nhs))
+  if ((dist == en->dist) && !nh_is_vlink(&en->nhs->nh))
   {
     /*
      * For multipath, we should merge nexthops. We merge regular nexthops only.
@@ -1947,13 +1926,11 @@ add_cand(struct ospf_area *oa, struct top_hash_entry *en, struct top_hash_entry
      */
 
     /* Keep old ones */
-    if (!p->ecmp || nh_is_vlink(nhs) || (nhs == en->nhs))
+    if (!p->ecmp || nh_is_vlink(&nhs->nh) || (nhs == en->nhs))
       return;
 
     /* Merge old and new */
-    int new_reuse = (par->nhs != nhs);
-    en->nhs = nexthop_merge(en->nhs, nhs, en->nhs_reuse, new_reuse, p->ecmp, p->nhpool);
-    en->nhs_reuse = 1;
+    en->nhs = nexthop_merge(en->nhs, nhs, p->ecmp, p->nhpool);
     return;
   }
 
@@ -1967,7 +1944,6 @@ add_cand(struct ospf_area *oa, struct top_hash_entry *en, struct top_hash_entry
   en->nhs = nhs;
   en->dist = dist;
   en->color = CANDIDATE;
-  en->nhs_reuse = (par->nhs != nhs);
 
   prev = NULL;
 
@@ -2008,10 +1984,23 @@ ort_changed(ort *nf, rta *nr)
   if (!or ||
     (nf->n.metric1 != nf->old_metric1) || (nf->n.metric2 != nf->old_metric2) ||
     (nf->n.tag != nf->old_tag) || (nf->n.rid != nf->old_rid) ||
-    (nr->dest != or->dest) ||
-    !nexthop_same(&(nr->nh), &(or->nh)))
+    (nr->dest != or->dest))
     return 1;
 
+  eattr *nhea_n = ea_find(nr->eattrs, &ea_gen_nexthop);
+  eattr *nhea_o = ea_find(or->eattrs, &ea_gen_nexthop);
+  if (!nhea_n != !nhea_o)
+    return 1;
+
+  if (nhea_n && nhea_o)
+  {
+    struct nexthop_adata *nhad_n = (struct nexthop_adata *) nhea_n->u.ptr;
+    struct nexthop_adata *nhad_o = (struct nexthop_adata *) nhea_o->u.ptr;
+
+    if (!nexthop_same(nhad_n, nhad_o))
+      return 1;
+  }
+
   if (	ea_get_int(nr->eattrs, &ea_gen_source, 0)
      != ea_get_int(or->eattrs, &ea_gen_source, 0))
     return 1;
@@ -2038,10 +2027,9 @@ again1:
   FIB_ITERATE_START(fib, &fit, ort, nf)
   {
     /* Sanity check of next-hop addresses, failure should not happen */
-    if (nf->n.type)
+    if (nf->n.type && nf->n.nhs)
     {
-      struct nexthop *nh;
-      for (nh = nf->n.nhs; nh; nh = nh->next)
+      NEXTHOP_WALK(nh, nf->n.nhs)
 	if (ipa_nonzero(nh->gw))
 	{
 	  neighbor *nbr = neigh_find(&p->p, nh->gw, nh->iface,
@@ -2062,9 +2050,24 @@ again1:
     {
       rta a0 = {
 	.dest = RTD_UNICAST,
-	.nh = *(nf->n.nhs),
       };
 
+      struct {
+	ea_list l;
+	eattr a[7];
+      } eattrs;
+
+      eattrs.l = (ea_list) {};
+
+      eattrs.a[eattrs.l.count++] =
+	EA_LITERAL_EMBEDDED(&ea_gen_preference, 0, p->p.main_channel->preference);
+
+      eattrs.a[eattrs.l.count++] = 
+	EA_LITERAL_EMBEDDED(&ea_gen_source, 0, nf->n.type);
+
+      eattrs.a[eattrs.l.count++] =
+	EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nf->n.nhs->ad);
+
       if (reload || ort_changed(nf, &a0))
       {
 	nf->old_metric1 = nf->n.metric1;
@@ -2072,19 +2075,6 @@ again1:
 	nf->old_tag = nf->n.tag;
 	nf->old_rid = nf->n.rid;
 
-	struct {
-	  ea_list l;
-	  eattr a[6];
-	} eattrs;
-
-	eattrs.l = (ea_list) {};
-
-	eattrs.a[eattrs.l.count++] =
-	  EA_LITERAL_EMBEDDED(&ea_gen_preference, 0, p->p.main_channel->preference);
-
-	eattrs.a[eattrs.l.count++] = 
-	  EA_LITERAL_EMBEDDED(&ea_gen_source, 0, nf->n.type);
-
 	eattrs.a[eattrs.l.count++] =
 	  EA_LITERAL_EMBEDDED(&ea_ospf_metric1, 0, nf->n.metric1);
 
diff --git a/proto/ospf/rt.h b/proto/ospf/rt.h
index 094e125b..180216b7 100644
--- a/proto/ospf/rt.h
+++ b/proto/ospf/rt.h
@@ -18,8 +18,6 @@
 typedef struct orta
 {
   u8 type;			/* RTS_OSPF_* */
-  u8 nhs_reuse;			/* Whether nhs nodes can be reused during merging.
-				   See a note in rt.c:add_cand() */
   u32 options;
   /*
    * For ORT_ROUTER routes, options field are router-LSA style
@@ -53,7 +51,7 @@ typedef struct orta
   struct ospf_area *oa;
   struct ospf_area *voa;	/* Used when route is replaced in ospf_rt_sum_tr(),
 				   NULL otherwise */
-  struct nexthop *nhs;		/* Next hops computed during SPF */
+  struct nexthop_adata *nhs;	/* Next hops computed during SPF */
   struct top_hash_entry *en;	/* LSA responsible for this orta */
 }
 orta;
diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index db423dc8..ca4620cc 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -1366,8 +1366,20 @@ ospf_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
   uint tag = ea_get_int(a->eattrs, &ea_ospf_tag, 0);
 
   ip_addr fwd = IPA_NONE;
-  if ((a->dest == RTD_UNICAST) && use_gw_for_fwaddr(p, a->nh.gw, a->nh.iface))
-    fwd = a->nh.gw;
+  if (a->dest == RTD_UNICAST)
+  {
+    eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+    if (!nhea)
+    {
+      log(L_ERR "%s: Unicast route without nexthop for %N",
+	  p->p.name, n->n.addr);
+      return;
+    }
+
+    struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
+    if (use_gw_for_fwaddr(p, nhad->nh.gw, nhad->nh.iface))
+      fwd = nhad->nh.gw;
+  }
 
   /* NSSA-LSA with P-bit set must have non-zero forwarding address */
   if (oa && ipa_zero(fwd))
diff --git a/proto/ospf/topology.h b/proto/ospf/topology.h
index 535d1f1b..fe102f77 100644
--- a/proto/ospf/topology.h
+++ b/proto/ospf/topology.h
@@ -28,7 +28,7 @@ struct top_hash_entry
   u16 next_lsa_opts;		/* For postponed LSA origination */
   btime inst_time;		/* Time of installation into DB */
   struct ort *nf;		/* Reference fibnode for sum and ext LSAs, NULL for otherwise */
-  struct nexthop *nhs;		/* Computed nexthops - valid only in ospf_rt_spf() */
+  struct nexthop_adata *nhs;	/* Computed nexthops - valid only in ospf_rt_spf() */
   ip_addr lb;			/* In OSPFv2, link back address. In OSPFv3, any global address in the area useful for vlinks */
   u32 lb_id;			/* Interface ID of link back iface (for bcast or NBMA networks) */
   u32 dist;			/* Distance from the root */
@@ -39,8 +39,6 @@ struct top_hash_entry
 #define CANDIDATE 1
 #define INSPF 2
   u8 mode;			/* LSA generated during RT calculation (LSA_RTCALC or LSA_STALE)*/
-  u8 nhs_reuse;			/* Whether nhs nodes can be reused during merging.
-				   See a note in rt.c:add_cand() */
 };
 
 
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index 4329556c..8642e0a1 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -144,13 +144,19 @@ perf_loop(void *data)
     if (!p->attrs_per_rte || !(i % p->attrs_per_rte)) {
       struct rta a0 = {
 	.dest = RTD_UNICAST,
+      };
+
+      ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
+      ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_PERF);
+
+      struct nexthop_adata nhad = {
 	.nh.iface = p->ifa->iface,
 	.nh.gw = gw,
 	.nh.weight = 1,
       };
 
-      ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
-      ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_PERF);
+      ea_set_attr_data(&a0.eattrs, &ea_gen_nexthop, 0,
+	  &nhad.ad.data, sizeof nhad - sizeof nhad.ad);
 
       p->data[i].a = rta_lookup(&a0);
     }
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index f7f34c27..425a411c 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -169,38 +169,58 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
     a0.eattrs = &ea_block.l;
 
     u16 rt_tag = rt->tag;
+    struct iface *rt_from = NULL;
 
     if (p->ecmp)
     {
       /* ECMP route */
-      struct nexthop *nhs = NULL;
       int num = 0;
 
+      for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
+	if (rip_valid_rte(rt))
+	  num++;
+
+      struct nexthop_adata *nhad = (struct nexthop_adata *) tmp_alloc_adata((num+1) * sizeof(struct nexthop));
+      struct nexthop *nh = &nhad->nh;
+
       for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
       {
 	if (!rip_valid_rte(rt))
-	    continue;
+	  continue;
 
-	struct nexthop *nh = allocz(sizeof(struct nexthop));
+	*nh = (struct nexthop) {
+	  .gw = rt->next_hop,
+	  .iface = rt->from->ifa->iface,
+	  .weight = rt->from->ifa->cf->ecmp_weight,
+	};
 
-	nh->gw = rt->next_hop;
-	nh->iface = rt->from->ifa->iface;
-	nh->weight = rt->from->ifa->cf->ecmp_weight;
+	if (!rt_from)
+	  rt_from = rt->from->ifa->iface;
 
-	nexthop_insert(&nhs, nh);
-	num++;
+	nh = NEXTHOP_NEXT(nh);
 
 	if (rt->tag != rt_tag)
 	  rt_tag = 0;
       }
 
-      a0.nh = *nhs;
+      nhad->ad.length = ((void *) nh - (void *) nhad->ad.data);
+
+      ea_set_attr(&a0.eattrs,
+	  EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0,
+	    &(nexthop_sort(nhad, tmp_linpool)->ad)));
     }
     else
     {
       /* Unipath route */
-      a0.nh.gw = rt->next_hop;
-      a0.nh.iface = rt->from->ifa->iface;
+      rt_from = rt->from->ifa->iface;
+
+      struct nexthop_adata nhad = {
+	.nh.gw = rt->next_hop,
+	.nh.iface = rt->from->ifa->iface,
+      };
+
+      ea_set_attr_data(&a0.eattrs, &ea_gen_nexthop, 0,
+	  &nhad.ad.data, sizeof nhad - sizeof nhad.ad);
       ea_set_attr_data(&a0.eattrs, &ea_gen_from, 0, &rt->from->nbr->addr, sizeof(ip_addr));
     }
 
@@ -208,7 +228,7 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 
     struct rip_iface_adata riad = {
       .ad = { .length = sizeof(struct rip_iface_adata) - sizeof(struct adata) },
-      .iface = a0.nh.iface,
+      .iface = rt_from,
     };
     ea_set_attr(&a0.eattrs,
 	EA_LITERAL_DIRECT_ADATA(&ea_rip_from, 0, &riad.ad));
@@ -362,8 +382,14 @@ rip_rt_notify(struct proto *P, struct channel *ch UNUSED, struct network *net, s
     en->metric = rt_metric;
     en->tag = rt_tag;
     en->from = (new->src->proto == P) ? rt_from : NULL;
-    en->iface = new->attrs->nh.iface;
-    en->next_hop = new->attrs->nh.gw;
+
+    eattr *nhea = ea_find(new->attrs->eattrs, &ea_gen_nexthop);
+    if (nhea)
+    {
+      struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
+      en->iface = nhad->nh.iface;
+      en->next_hop = nhad->nh.gw;
+    }
   }
   else
   {
diff --git a/proto/static/static.c b/proto/static/static.c
index e792a148..2e4a46a6 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -61,32 +61,40 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
 
   if (r->dest == RTD_UNICAST)
   {
-    struct static_route *r2;
-    struct nexthop *nhs = NULL;
+    uint sz = 0;
+    for (struct static_route *r2 = r; r2; r2 = r2->mp_next)
+      if (r2->active)
+	sz += NEXTHOP_SIZE_CNT(r2->mls ? r2->mls->length / sizeof(u32) : 0);
 
-    for (r2 = r; r2; r2 = r2->mp_next)
+    if (!sz)
+      goto withdraw;
+
+    struct nexthop_adata *nhad = allocz(sz + sizeof *nhad);
+    struct nexthop *nh = &nhad->nh;
+
+    for (struct static_route *r2 = r; r2; r2 = r2->mp_next)
     {
       if (!r2->active)
 	continue;
 
-      struct nexthop *nh = allocz(NEXTHOP_MAX_SIZE);
-      nh->gw = r2->via;
-      nh->iface = r2->neigh->iface;
-      nh->flags = r2->onlink ? RNF_ONLINK : 0;
-      nh->weight = r2->weight;
+      *nh = (struct nexthop) {
+	.gw = r2->via,
+	.iface = r2->neigh->iface,
+	.flags = r2->onlink ? RNF_ONLINK : 0,
+	.weight = r2->weight,
+      };
+
       if (r2->mls)
       {
 	nh->labels = r2->mls->length / sizeof(u32);
 	memcpy(nh->label, r2->mls->data, r2->mls->length);
       }
 
-      nexthop_insert(&nhs, nh);
+      nh = NEXTHOP_NEXT(nh);
     }
 
-    if (!nhs)
-      goto withdraw;
-
-    nexthop_link(a, nhs);
+    ea_set_attr_data(&a->eattrs, &ea_gen_nexthop, 0,
+	nhad->ad.data, (void *) nh - (void *) nhad->ad.data);
   }
 
   if (r->dest == RTDX_RECURSIVE)
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index e0219ce0..fdfd4885 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -827,12 +827,12 @@ nl_add_nexthop(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af UNUS
 }
 
 static void
-nl_add_multipath(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af, ea_list *eattrs)
+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);
 
-  for (; nh; nh = nh->next)
+  NEXTHOP_WALK(nh, nhad)
   {
     struct rtnexthop *rtnh = nl_open_nexthop(h, bufsize);
 
@@ -856,31 +856,44 @@ nl_add_multipath(struct nlmsghdr *h, uint bufsize, struct nexthop *nh, int af, e
   nl_close_attr(h, a);
 }
 
-static struct nexthop *
+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 = RTA_DATA(ra);
-  struct nexthop *rv, *first, **last;
-  unsigned len = RTA_PAYLOAD(ra);
+  struct rtnexthop *nh, *orig_nh = RTA_DATA(ra);
+  unsigned len, orig_len = RTA_PAYLOAD(ra);
+  uint cnt = 0;
 
-  first = NULL;
-  last = &first;
+  /* 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;
 
-  while (len)
+  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))
-	goto next;
+	continue;
 
-      *last = rv = lp_allocz(s->pool, NEXTHOP_MAX_SIZE);
-      last = &(rv->next);
+      *rv = (struct nexthop) {
+	.weight = nh->rtnh_hops,
+	.iface = if_find_by_index(nh->rtnh_ifindex),
+      };
 
-      rv->weight = nh->rtnh_hops;
-      rv->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);
@@ -959,16 +972,14 @@ nl_parse_multipath(struct nl_parse_state *s, struct krt_proto *p, const net_addr
       }
 #endif
 
-    next:
-      len -= NLMSG_ALIGN(nh->rtnh_len);
-      nh = RTNH_NEXT(nh);
+      rv = NEXTHOP_NEXT(rv);
     }
 
-  /* Ensure nexthops are sorted to satisfy nest invariant */
-  if (!nexthop_is_sorted(first))
-    first = nexthop_sort(first);
+  /* Store final length */
+  nhad->ad.length = (void *) rv - (void *) nhad->ad.data;
 
-  return first;
+  /* 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);
@@ -1412,22 +1423,23 @@ krt_capable(rte *e)
 }
 
 static inline int
-nh_bufsize(struct nexthop *nh)
+nh_bufsize(struct nexthop_adata *nhad)
 {
   int rv = 0;
-  for (; nh != NULL; nh = nh->next)
+  NEXTHOP_WALK(nh, nhad)
     rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
   return rv;
 }
 
 static int
-nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
+nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop_adata *nh)
 {
   eattr *ea;
   net *net = e->net;
   rta *a = e->attrs;
   ea_list *eattrs = a->eattrs;
-  int bufsize = 128 + KRT_METRICS_MAX*8 + nh_bufsize(&(a->nh));
+
+  int bufsize = 128 + KRT_METRICS_MAX*8 + (nh ? nh_bufsize(nh) : 0);
   u32 priority = 0;
 
   struct {
@@ -1511,7 +1523,7 @@ nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop *nh)
   else if (ea = ea_find(eattrs, &ea_krt_scope))
     r->r.rtm_scope = ea->u.data;
   else
-    r->r.rtm_scope = (dest == RTD_UNICAST && ipa_zero(nh->gw)) ? RT_SCOPE_LINK : RT_SCOPE_UNIVERSE;
+    r->r.rtm_scope = (dest == RTD_UNICAST && ipa_zero(nh->nh.gw)) ? RT_SCOPE_LINK : 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);
@@ -1540,14 +1552,14 @@ dest:
     {
     case RTD_UNICAST:
       r->r.rtm_type = RTN_UNICAST;
-      if (nh->next && !krt_ecmp6(p))
+      if (!NEXTHOP_ONE(nh) && !krt_ecmp6(p))
 	nl_add_multipath(&r->h, rsize, nh, p->af, eattrs);
       else
       {
-	nl_add_attr_u32(&r->h, rsize, RTA_OIF, nh->iface->index);
-	nl_add_nexthop(&r->h, rsize, nh, p->af);
+	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->flags & RNF_ONLINK)
+	if (nh->nh.flags & RNF_ONLINK)
 	  r->r.rtm_flags |= RTNH_F_ONLINK;
       }
       break;
@@ -1576,21 +1588,35 @@ nl_add_rte(struct krt_proto *p, rte *e)
   rta *a = e->attrs;
   int err = 0;
 
-  if (krt_ecmp6(p) && a->nh.next)
-  {
-    struct nexthop *nh = &(a->nh);
-
-    err = nl_send_route(p, e, NL_OP_ADD, RTD_UNICAST, nh);
-    if (err < 0)
-      return err;
+  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
 
-    for (nh = nh->next; nh; nh = nh->next)
-      err += nl_send_route(p, e, NL_OP_APPEND, RTD_UNICAST, nh);
+  if (krt_ecmp6(p) && nhad && !NEXTHOP_ONE(nhad))
+  {
+    uint cnt = 0;
+    NEXTHOP_WALK(nh, nhad)
+    {
+      struct {
+	struct nexthop_adata nhad;
+	u32 labels[MPLS_MAX_LABEL_STACK];
+      } nhx;
+      memcpy(&nhx.nhad.nh, nh, NEXTHOP_SIZE(nh));
+      nhx.nhad.ad.length = (void *) NEXTHOP_NEXT(&nhx.nhad.nh) - (void *) nhx.nhad.ad.data;
+
+      if (!cnt++)
+      {
+	err = nl_send_route(p, e, NL_OP_ADD, RTD_UNICAST, &nhx.nhad);
+	if (err < 0)
+	  return err;
+      }
+      else
+	err += nl_send_route(p, e, NL_OP_APPEND, RTD_UNICAST, &nhx.nhad);
+    }
 
     return err;
   }
 
-  return nl_send_route(p, e, NL_OP_ADD, a->dest, &(a->nh));
+  return nl_send_route(p, e, NL_OP_ADD, a->dest, nhad);
 }
 
 static inline int
@@ -1610,7 +1636,9 @@ static inline int
 nl_replace_rte(struct krt_proto *p, rte *e)
 {
   rta *a = e->attrs;
-  return nl_send_route(p, e, NL_OP_REPLACE, a->dest, &(a->nh));
+  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
+  return nl_send_route(p, e, NL_OP_REPLACE, a->dest, nhad);
 }
 
 
@@ -1861,6 +1889,15 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   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:
@@ -1868,49 +1905,50 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 
       if (a[RTA_MULTIPATH])
         {
-	  struct nexthop *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
+	  struct nexthop_adata *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
 	  if (!nh)
 	    SKIP("strange RTA_MULTIPATH\n");
 
-	  nexthop_link(ra, nh);
+	  ea_set_attr(&ra->eattrs, 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");
 
-      ra->nh.iface = if_find_by_index(oif);
-      if (!ra->nh.iface)
+      nhad.nh.iface = if_find_by_index(oif);
+      if (!nhad.nh.iface)
 	{
 	  log(L_ERR "KRT: Received route %N with unknown ifindex %u", net->n.addr, oif);
 	  return;
 	}
 
       if (a[RTA_GATEWAY])
-	ra->nh.gw = rta_get_ipa(a[RTA_GATEWAY]);
+	nhad.nh.gw = rta_get_ipa(a[RTA_GATEWAY]);
 
 #ifdef HAVE_MPLS_KERNEL
       if (a[RTA_VIA])
-	ra->nh.gw = rta_get_via(a[RTA_VIA]);
+	nhad.nh.gw = rta_get_via(a[RTA_VIA]);
 #endif
 
-      if (ipa_nonzero(ra->nh.gw))
+      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(ra->nh.gw, (net_addr *) &sit))
+	  if ((i->rtm_family == AF_INET6) && ipa_in_netX(nhad.nh.gw, (net_addr *) &sit))
 	    return;
 
 	  if (i->rtm_flags & RTNH_F_ONLINK)
-	    ra->nh.flags |= RNF_ONLINK;
+	    nhad.nh.flags |= RNF_ONLINK;
 
 	  neighbor *nbr;
-	  nbr = neigh_find(&p->p, ra->nh.gw, ra->nh.iface,
-			   (ra->nh.flags & RNF_ONLINK) ? NEF_ONLINK : 0);
+	  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->n.addr,
-                  ra->nh.gw);
+                  nhad.nh.gw);
 	      return;
 	    }
 	}
@@ -1932,10 +1970,10 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     }
 
 #ifdef HAVE_MPLS_KERNEL
-  if ((i->rtm_family == AF_MPLS) && a[RTA_NEWDST] && !ra->nh.next)
-    ra->nh.labels = rta_get_mpls(a[RTA_NEWDST], ra->nh.label);
+  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] && !ra->nh.next)
+  if (a[RTA_ENCAP] && a[RTA_ENCAP_TYPE] && !a[RTA_MULTIPATH])
     {
       switch (rta_get_u16(a[RTA_ENCAP_TYPE]))
 	{
@@ -1944,7 +1982,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	      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));
-	      ra->nh.labels = rta_get_mpls(enca[RTA_DST], ra->nh.label);
+	      nhad.nh.labels = rta_get_mpls(enca[RTA_DST], nhad.nh.label);
 	      break;
 	    }
 	  default:
@@ -1954,6 +1992,9 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     }
 #endif
 
+  /* Finalize the nexthop */
+  nhad.ad.length = (void *) NEXTHOP_NEXT(&nhad.nh) - (void *) nhad.ad.data;
+
   if (i->rtm_scope != def_scope)
     ea_set_attr(&ra->eattrs,
 	EA_LITERAL_EMBEDDED(&ea_krt_scope, 0, i->rtm_scope));
@@ -1999,6 +2040,10 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     /* Store the new route */
     s->net = net;
     s->attrs = ra;
+
+    ea_set_attr_data(&ra->eattrs, &ea_gen_nexthop, 0,
+	nhad.ad.data, nhad.ad.length);
+
     s->proto = p;
     s->new = new;
     s->krt_src = krt_src;
@@ -2009,20 +2054,18 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   else
   {
     /* Merge next hops with the stored route */
-    rta *oa = s->attrs;
-
-    struct nexthop *nhs = &oa->nh;
-    nexthop_insert(&nhs, &ra->nh);
-
-    /* Perhaps new nexthop is inserted at the first position */
-    if (nhs == &ra->nh)
-    {
-      /* Swap rtas */
-      s->attrs = ra;
-
-      /* Keep old eattrs */
-      ra->eattrs = oa->eattrs;
-    }
+    eattr *nhea = ea_find(s->attrs->eattrs, &ea_gen_nexthop);
+    struct nexthop_adata *nhad_old = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
+
+    if (nhad_old)
+      ea_set_attr(&s->attrs->eattrs,
+	  EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, 
+	    &(nexthop_merge(nhad_old, &nhad.nhad,
+		KRT_CF->merge_paths, s->pool)->ad)
+	  ));
+    else
+      ea_set_attr_data(&s->attrs->eattrs, &ea_gen_nexthop, 0,
+	  nhad.ad.data, nhad.ad.length);
   }
 }
 
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index b8e7670e..89e9e97e 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -611,10 +611,14 @@ krt_same_dest(rte *k, rte *e)
   if (ka->dest != ea->dest)
     return 0;
 
-  if (ka->dest == RTD_UNICAST)
-    return nexthop_same(&(ka->nh), &(ea->nh));
+  if (ka->dest != RTD_UNICAST)
+    return 1;
 
-  return 1;
+  eattr *nhea_k = ea_find(ka->eattrs, &ea_gen_nexthop);
+  eattr *nhea_e = ea_find(ea->eattrs, &ea_gen_nexthop);
+
+  ASSUME(nhea_k && nhea_e);
+  return adata_same(nhea_k->u.ptr, nhea_e->u.ptr);
 }
 
 /*
-- 
cgit v1.2.3


From 950775f6fa3d569a9d7cd05e33538d35e895d688 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Sun, 15 May 2022 18:09:30 +0200
Subject: Route destination field merged with nexthop attribute; splitting
 flowspec validation result out.

As there is either a nexthop or another destination specification
(or othing in case of ROAs and Flowspec), it may be merged together.
This code is somehow quirky and should be replaced in future by better
implementation of nexthop.

Also flowspec validation result has its own attribute now as it doesn't
have anything to do with route nexthop.
---
 filter/f-inst.c        | 79 +++++++++++++++++++++----------------------
 lib/route.h            | 60 ++++++++++++++++++++++++++++----
 lib/type.h             |  1 +
 nest/config.Y          |  2 +-
 nest/rt-attr.c         | 24 ++++++-------
 nest/rt-dev.c          |  5 +--
 nest/rt-show.c         |  5 +--
 nest/rt-table.c        | 92 ++++++++++++++++++++++++--------------------------
 nest/rt.h              |  1 -
 proto/babel/babel.c    | 18 +++++-----
 proto/bgp/attrs.c      | 17 ++++++++--
 proto/bgp/bgp.h        |  4 ++-
 proto/bgp/packets.c    | 25 +++++++-------
 proto/ospf/rt.c        |  4 +--
 proto/ospf/topology.c  | 11 ++----
 proto/perf/perf.c      |  4 +--
 proto/rip/rip.c        |  4 +--
 proto/rpki/rpki.c      |  4 +--
 proto/static/static.c  |  6 ++--
 sysdep/linux/netlink.c | 78 ++++++++++++++++++++++--------------------
 sysdep/unix/krt.c      |  9 +----
 21 files changed, 245 insertions(+), 208 deletions(-)

(limited to 'sysdep/linux')

diff --git a/filter/f-inst.c b/filter/f-inst.c
index 8ce78a99..c2abd5aa 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -530,20 +530,24 @@
       STATIC_ATTR;
       ACCESS_RTE;
       ACCESS_EATTRS;
-      struct rta *rta = (*fs->rte)->attrs;
 
       switch (sa.sa_code)
       {
       case SA_NET:	RESULT(sa.type, net, (*fs->rte)->net->n.addr); break;
       case SA_PROTO:	RESULT(sa.type, s, (*fs->rte)->src->proto->name); break;
-      case SA_DEST:	RESULT(sa.type, i, rta->dest); break;
       default:
 	{
-	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
-	  struct nexthop *nh = nh_ea ? &((struct nexthop_adata *) nh_ea->u.ptr)->nh : NULL;
+	  struct eattr *nhea = ea_find(*fs->eattrs, &ea_gen_nexthop);
+	  struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
+	  struct nexthop *nh = nhad ? &nhad->nh : NULL;
 
 	  switch (sa.sa_code)
 	  {
+	    case SA_DEST:
+	      RESULT(sa.type, i, nhad ?
+		  (NEXTHOP_IS_REACHABLE(nhad) ? RTD_UNICAST : nhad->dest)
+		  : RTD_NONE);
+	      break;
 	    case SA_GW:
 	      RESULT(sa.type, ip, nh ? nh->gw : IPA_NONE);
 	      break;
@@ -576,36 +580,33 @@
 
     f_rta_cow(fs);
     {
-      struct rta *rta = (*fs->rte)->attrs;
+      union {
+	struct nexthop_adata nha;
+	struct {
+	  struct adata ad;
+	  struct nexthop nh;
+	  u32 label;
+	};
+      } nha;
+
+      nha.ad = (struct adata) {
+	.length = sizeof (struct nexthop_adata) - sizeof (struct adata),
+      };
 
-      if (sa.sa_code == SA_DEST)
+      eattr *a = NULL;
+
+      switch (sa.sa_code)
+      {
+      case SA_DEST:
 	{
 	  int i = v1.val.i;
 	  if ((i != RTD_BLACKHOLE) && (i != RTD_UNREACHABLE) && (i != RTD_PROHIBIT))
 	    runtime( "Destination can be changed only to blackhole, unreachable or prohibit" );
 
-	  rta->dest = i;
-	  ea_unset_attr(fs->eattrs, 1, &ea_gen_nexthop);
+	  nha.nha.dest = i;
+	  nha.ad.length = NEXTHOP_DEST_SIZE;
+	  break;
 	}
-      else
-      {
-	union {
-	  struct nexthop_adata nha;
-	  struct {
-	    struct adata ad;
-	    struct nexthop nh;
-	    u32 label;
-	  };
-	} nha;
-
-	nha.ad = (struct adata) {
-	  .length = sizeof (struct nexthop_adata) - sizeof (struct adata),
-	};
-
-	eattr *a = NULL;
-
-	switch (sa.sa_code)
-	  {
       case SA_GW:
 	{
 	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
@@ -618,7 +619,6 @@
 	  if (!n || (n->scope == SCOPE_HOST))
 	    runtime( "Invalid gw address" );
 
-	  rta->dest = RTD_UNICAST;
 	  nha.nh = (struct nexthop) {
 	    .gw = ip,
 	    .iface = n->iface,
@@ -632,7 +632,6 @@
 	  if (!ifa)
 	    runtime( "Invalid iface name" );
 
-	  rta->dest = RTD_UNICAST;
 	  nha.nh = (struct nexthop) {
 	    .iface = ifa,
 	  };
@@ -666,15 +665,16 @@
 	  int i = v1.val.i;
 	  if (i < 1 || i > 256)
 	    runtime( "Setting weight value out of bounds" );
-	  if (rta->dest != RTD_UNICAST)
-	    runtime( "Setting weight needs regular nexthop " );
 
 	  struct eattr *nh_ea = ea_find(*fs->eattrs, &ea_gen_nexthop);
 	  if (!nh_ea)
 	    runtime( "No nexthop to set weight on" );
 
-	  struct nexthop_adata *nhax = (struct nexthop_adata *)
-	    tmp_copy_adata(&((struct nexthop_adata *) nh_ea->u.ptr)->ad);
+	  struct nexthop_adata *nhad = (struct nexthop_adata *) nh_ea->u.ptr;
+	  if (!NEXTHOP_IS_REACHABLE(nhad))
+	    runtime( "Setting weight needs regular nexthop " );
+
+	  struct nexthop_adata *nhax = (struct nexthop_adata *) tmp_copy_adata(&nhad->ad);
 
 	  /* Set weight on all next hops */
 	  NEXTHOP_WALK(nh, nhax)
@@ -687,15 +687,14 @@
 
       default:
 	bug("Invalid static attribute access (%u/%u)", sa.type, sa.sa_code);
-	  }
+      }
 
-	if (!a)
-	  a = ea_set_attr(fs->eattrs,
-	      EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, tmp_copy_adata(&nha.ad)));
+      if (!a)
+	a = ea_set_attr(fs->eattrs,
+	    EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, tmp_copy_adata(&nha.ad)));
 
-	a->originated = 1;
-	a->fresh = 1;
-      }
+      a->originated = 1;
+      a->fresh = 1;
     }
   }
 
diff --git a/lib/route.h b/lib/route.h
index 3ce8021d..1d8877c8 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -76,9 +76,17 @@ struct nexthop {
 /* For packing one into eattrs */
 struct nexthop_adata {
   struct adata ad;
-  struct nexthop nh;
+  /* There is either a set of nexthops or a special destination (RTD_*) */
+  union {
+    struct nexthop nh;
+    uint dest;
+  };
 };
 
+#define NEXTHOP_DEST_SIZE	(OFFSETOF(struct nexthop_adata, dest) + sizeof(uint) - OFFSETOF(struct adata, data))
+#define NEXTHOP_DEST_LITERAL(x)	((struct nexthop_adata) { \
+      .ad.length = NEXTHOP_DEST_SIZE, .dest = (x), })
+
 #define RNF_ONLINK		0x1	/* Gateway is onlink regardless of IP ranges */
 
 
@@ -88,7 +96,6 @@ typedef struct rta {
   u32 hash_key;				/* Hash over important fields */
   struct ea_list *eattrs;		/* Extended Attribute chain */
   u16 cached:1;				/* Are attributes cached? */
-  u16 dest:4;				/* Route destination type (RTD_...) */
 } rta;
 
 #define RTS_STATIC 1			/* Normal static route */
@@ -109,7 +116,7 @@ typedef struct rta {
 #define RTS_MAX 16
 
 #define RTD_NONE 0			/* Undefined next hop */
-#define RTD_UNICAST 1			/* Next hop is neighbor router */
+#define RTD_UNICAST 1			/* A standard next hop */
 #define RTD_BLACKHOLE 2			/* Silently drop packets */
 #define RTD_UNREACHABLE 3		/* Reject as unreachable */
 #define RTD_PROHIBIT 4			/* Administratively prohibited */
@@ -120,10 +127,6 @@ extern const char * rta_dest_names[RTD_MAX];
 static inline const char *rta_dest_name(uint n)
 { return (n < RTD_MAX) ? rta_dest_names[n] : "???"; }
 
-/* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
-static inline int rte_is_reachable(rte *r)
-{ return r->attrs->dest == RTD_UNICAST; }
-
 
 /*
  *	Extended Route Attributes
@@ -331,9 +334,24 @@ extern struct ea_class ea_gen_source;
 static inline u32 rt_get_source_attr(rte *rt)
 { return ea_get_int(rt->attrs->eattrs, &ea_gen_source, 0); }
 
+/* Flowspec validation result */
+#define FLOWSPEC_UNKNOWN	0
+#define FLOWSPEC_VALID		1
+#define FLOWSPEC_INVALID	2
+
+extern struct ea_class ea_gen_flowspec_valid;
+static inline u32 rt_get_flowspec_valid(rte *rt)
+{ return ea_get_int(rt->attrs->eattrs, &ea_gen_flowspec_valid, FLOWSPEC_UNKNOWN); }
+
 /* Next hop: For now, stored as adata */
 extern struct ea_class ea_gen_nexthop;
 
+static inline void ea_set_dest(struct ea_list **to, uint flags, uint dest)
+{
+  struct nexthop_adata nhad = NEXTHOP_DEST_LITERAL(dest);
+  ea_set_attr_data(to, &ea_gen_nexthop, flags, &nhad.ad.data, nhad.ad.length);
+}
+
 /* Next hop structures */
 
 #define NEXTHOP_ALIGNMENT	(_Alignof(struct nexthop))
@@ -359,7 +377,35 @@ struct nexthop_adata *nexthop_merge(struct nexthop_adata *x, struct nexthop_adat
 struct nexthop_adata *nexthop_sort(struct nexthop_adata *x, linpool *lp);
 int nexthop_is_sorted(struct nexthop_adata *x);
 
+#define NEXTHOP_IS_REACHABLE(nhad)	((nhad)->ad.length > NEXTHOP_DEST_SIZE)
 
+/* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
+static inline int rte_is_reachable(rte *r)
+{
+  eattr *nhea = ea_find(r->attrs->eattrs, &ea_gen_nexthop);
+  if (!nhea)
+    return 0;
+
+  struct nexthop_adata *nhad = (void *) nhea->u.ptr;
+  return NEXTHOP_IS_REACHABLE(nhad);
+}
+
+static inline int nhea_dest(eattr *nhea)
+{
+  if (!nhea)
+    return RTD_NONE;
+
+  struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
+  if (NEXTHOP_IS_REACHABLE(nhad))
+    return RTD_UNICAST;
+  else
+    return nhad->dest;
+}
+
+static inline int rte_dest(rte *r)
+{
+  return nhea_dest(ea_find(r->attrs->eattrs, &ea_gen_nexthop));
+}
 
 void rta_init(void);
 #define rta_size(...) (sizeof(rta))
diff --git a/lib/type.h b/lib/type.h
index 65a032ec..b54744c1 100644
--- a/lib/type.h
+++ b/lib/type.h
@@ -66,6 +66,7 @@ enum btype {
 
   T_ENUM_BGP_ORIGIN = 0x11,	/* BGP Origin enum */
   T_ENUM_RA_PREFERENCE = 0x13,	/* RA Preference enum */
+  T_ENUM_FLOWSPEC_VALID = 0x15,	/* Flowspec validation result */
 
 #define EAF_TYPE__MAX 0x1f
 #define EAF_EMBEDDED 0x01		/* Data stored in eattr.u.data (part of type spec) */
diff --git a/nest/config.Y b/nest/config.Y
index c144f0f3..6a35cdd2 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -133,7 +133,7 @@ CF_KEYWORDS(IPV4, IPV4_MC, IPV4_MPLS, IPV6, IPV6_MC, IPV6_MPLS, IPV6_SADR, VPN4,
 CF_ENUM(T_ENUM_RTS, RTS_, STATIC, INHERIT, DEVICE, STATIC_DEVICE, REDIRECT,
 	RIP, OSPF, OSPF_IA, OSPF_EXT1, OSPF_EXT2, BGP, PIPE, BABEL)
 CF_ENUM(T_ENUM_SCOPE, SCOPE_, HOST, LINK, SITE, ORGANIZATION, UNIVERSE, UNDEFINED)
-CF_ENUM(T_ENUM_RTD, RTD_, UNICAST, BLACKHOLE, UNREACHABLE, PROHIBIT)
+CF_ENUM(T_ENUM_RTD, RTD_, BLACKHOLE, UNREACHABLE, PROHIBIT)
 CF_ENUM(T_ENUM_ROA, ROA_, UNKNOWN, VALID, INVALID)
 CF_ENUM_PX(T_ENUM_AF, AF_, AFI_, IPV4, IPV6)
 
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index cf3ab659..b5be936b 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -166,6 +166,12 @@ const char * rta_dest_names[RTD_MAX] = {
   [RTD_PROHIBIT]	= "prohibited",
 };
 
+struct ea_class ea_gen_flowspec_valid = {
+  .name = "flowspec_valid",
+  .type = T_ENUM_FLOWSPEC_VALID,
+  .readonly = 1,
+};
+
 pool *rta_pool;
 
 static slab *rta_slab;
@@ -1246,20 +1252,13 @@ rta_alloc_hash(void)
 static inline uint
 rta_hash(rta *a)
 {
-  u64 h;
-  mem_hash_init(&h);
-#define BMIX(f) mem_hash_mix_num(&h, a->f);
-  BMIX(dest);
-#undef MIX
-
-  return mem_hash_value(&h) ^ ea_hash(a->eattrs);
+  return ea_hash(a->eattrs);
 }
 
 static inline int
 rta_same(rta *x, rta *y)
 {
-  return (x->dest == y->dest &&
-	  ea_same(x->eattrs, y->eattrs));
+  return ea_same(x->eattrs, y->eattrs);
 }
 
 static rta *
@@ -1382,10 +1381,8 @@ rta_do_cow(rta *o, linpool *lp)
 void
 rta_dump(rta *a)
 {
-  static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
-
-  debug("uc=%d %s h=%04x",
-	a->uc, rtd[a->dest], a->hash_key);
+  debug("uc=%d h=%04x",
+	a->uc, a->hash_key);
   if (!a->cached)
     debug(" !CACHED");
   if (a->eattrs)
@@ -1449,6 +1446,7 @@ rta_init(void)
   ea_register_init(&ea_gen_source);
   ea_register_init(&ea_gen_nexthop);
   ea_register_init(&ea_gen_hostentry);
+  ea_register_init(&ea_gen_flowspec_valid);
 }
 
 /*
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index 9953e270..c50e018c 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -82,10 +82,7 @@ dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
       /* Use iface ID as local source ID */
       struct rte_src *src = rt_get_source(P, ad->iface->index);
 
-      rta a0 = {
-	.dest = RTD_UNICAST,
-      };
-
+      rta a0 = {};
       struct nexthop_adata nhad = {
 	.nh = { .iface = ad->iface, },
 	.ad = { .length = (void *) NEXTHOP_NEXT(&nhad.nh) - (void *) nhad.ad.data, },
diff --git a/nest/rt-show.c b/nest/rt-show.c
index 32f7aa2d..0ad8f5c6 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -47,6 +47,7 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
   void (*get_route_info)(struct rte *, byte *buf);
   eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
   struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
+  int dest = NEXTHOP_IS_REACHABLE(nhad) ? RTD_UNICAST : nhad->dest;
 
   tm_format_time(tm, &config->tf_route, e->lastmod);
   ip_addr a_from = ea_get_ip(a->eattrs, &ea_gen_from, IPA_NONE);
@@ -68,10 +69,10 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
   if (d->last_table != d->tab)
     rt_show_table(c, d);
 
-  cli_printf(c, -1007, "%-20s %s [%s %s%s]%s%s", ia, rta_dest_name(a->dest),
+  cli_printf(c, -1007, "%-20s %s [%s %s%s]%s%s", ia, rta_dest_name(dest),
 	     e->src->proto->name, tm, from, primary ? (sync_error ? " !" : " *") : "", info);
 
-  if (a->dest == RTD_UNICAST)
+  if (dest == RTD_UNICAST)
     NEXTHOP_WALK(nh, nhad)
     {
       char mpls[MPLS_MAX_LABEL_STACK*12 + 5], *lsp = mpls;
diff --git a/nest/rt-table.c b/nest/rt-table.c
index d98f33e4..539e04d0 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -699,7 +699,7 @@ rte_trace(struct channel *c, rte *e, int dir, char *msg)
 {
   log(L_TRACE "%s.%s %c %s %N %uL %uG %s",
       c->proto->name, c->name ?: "?", dir, msg, e->net->n.addr, e->src->private_id, e->src->global_id,
-      rta_dest_name(e->attrs->dest));
+      rta_dest_name(rte_dest(e)));
 }
 
 static inline void
@@ -1177,26 +1177,17 @@ rte_validate(rte *e)
     return 0;
   }
 
-  if (net_type_match(n->n.addr, NB_DEST) == !e->attrs->dest)
-  {
-    /* Exception for flowspec that failed validation */
-    if (net_is_flow(n->n.addr) && (e->attrs->dest == RTD_UNREACHABLE))
-      return 1;
-
-    log(L_WARN "Ignoring route %N with invalid dest %d received via %s",
-	n->n.addr, e->attrs->dest, e->sender->proto->name);
-    return 0;
-  }
-
   eattr *nhea = ea_find(e->attrs->eattrs, &ea_gen_nexthop);
-  if ((!nhea) != (e->attrs->dest != RTD_UNICAST))
+  int dest = nhea_dest(nhea);
+
+  if (net_type_match(n->n.addr, NB_DEST) == !dest)
   {
-    log(L_WARN "Ignoring route %N with destination %d and %snexthop received via %s",
-	n->n.addr, e->attrs->dest, (nhea ? "" : "no "), e->sender->proto->name);
+    log(L_WARN "Ignoring route %N with invalid dest %d received via %s",
+	n->n.addr, dest, e->sender->proto->name);
     return 0;
   }
 
-  if ((e->attrs->dest == RTD_UNICAST) &&
+  if ((dest == RTD_UNICAST) &&
       !nexthop_is_sorted((struct nexthop_adata *) nhea->u.ptr))
   {
     log(L_WARN "Ignoring unsorted multipath route %N received via %s",
@@ -2431,26 +2422,27 @@ rta_apply_hostentry(rta *a, struct hostentry_adata *head)
   u32 *labels = head->labels;
   u32 lnum = (u32 *) (head->ad.data + head->ad.length) - labels;
 
-  a->dest = he->dest;
-
   ea_set_attr_u32(&a->eattrs, &ea_gen_igp_metric, 0, he->igp_metric);
 
-  if (a->dest != RTD_UNICAST)
+  if (!he->src)
   {
-    /* No nexthop */
-    ea_unset_attr(&a->eattrs, 0, &ea_gen_nexthop);
+    ea_set_dest(&a->eattrs, 0, RTD_UNREACHABLE);
     return;
   }
 
-  if (!lnum && he->nexthop_linkable)
+  eattr *he_nh_ea = ea_find(he->src->eattrs, &ea_gen_nexthop);
+  ASSERT_DIE(he_nh_ea);
+
+  struct nexthop_adata *nhad = (struct nexthop_adata *) he_nh_ea->u.ptr;
+  int idest = nhea_dest(he_nh_ea);
+
+  if ((idest != RTD_UNICAST) ||
+      !lnum && he->nexthop_linkable)
   { /* Just link the nexthop chain, no label append happens. */
     ea_copy_attr(&a->eattrs, he->src->eattrs, &ea_gen_nexthop);
     return;
   }
 
-  eattr *he_nh_ea = ea_find(he->src->eattrs, &ea_gen_nexthop);
-  struct nexthop_adata *nhad = (struct nexthop_adata *) he_nh_ea->u.ptr;
-
   uint total_size = OFFSETOF(struct nexthop_adata, nh);
 
   NEXTHOP_WALK(nh, nhad)
@@ -2467,10 +2459,14 @@ rta_apply_hostentry(rta *a, struct hostentry_adata *head)
 
   if (total_size == OFFSETOF(struct nexthop_adata, nh))
   {
-    a->dest = RTD_UNREACHABLE;
     log(L_WARN "No valid nexthop remaining, setting route unreachable");
 
-    ea_unset_attr(&a->eattrs, 0, &ea_gen_nexthop);
+    struct nexthop_adata nha = {
+      .ad.length = NEXTHOP_DEST_SIZE,
+      .dest = RTD_UNREACHABLE,
+    };
+
+    ea_set_attr_data(&a->eattrs, &ea_gen_nexthop, 0, &nha.ad.data, nha.ad.length);
     return;
   }
 
@@ -2511,19 +2507,28 @@ rta_apply_hostentry(rta *a, struct hostentry_adata *head)
 static inline struct hostentry_adata *
 rta_next_hop_outdated(rta *a)
 {
+  /* First retrieve the hostentry */
   eattr *heea = ea_find(a->eattrs, &ea_gen_hostentry);
   if (!heea)
     return NULL;
 
   struct hostentry_adata *head = (struct hostentry_adata *) heea->u.ptr;
 
+  /* If no nexthop is present, we have to create one */
+  eattr *a_nh_ea = ea_find(a->eattrs, &ea_gen_nexthop);
+  if (!a_nh_ea)
+    return head;
+
+  struct nexthop_adata *nhad = (struct nexthop_adata *) a_nh_ea->u.ptr;
+
+  /* Shortcut for unresolvable hostentry */
   if (!head->he->src)
-    return (a->dest != RTD_UNREACHABLE) ? head : NULL;
+    return NEXTHOP_IS_REACHABLE(nhad) ? head : NULL;
 
+  /* Comparing our nexthop with the hostentry nexthop */
   eattr *he_nh_ea = ea_find(head->he->src->eattrs, &ea_gen_nexthop);
-  eattr *a_nh_ea = ea_find(a->eattrs, &ea_gen_nexthop);
 
-  return ((a->dest != head->he->dest) ||
+  return (
       (ea_get_int(a->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN) != head->he->igp_metric) ||
       (!head->he->nexthop_linkable) ||
       (!he_nh_ea != !a_nh_ea) ||
@@ -2682,16 +2687,16 @@ rt_flowspec_update_rte(rtable *tab, rte *r)
   const net_addr *n = r->net->n.addr;
   struct bgp_proto *p = (void *) r->src->proto;
   int valid = rt_flowspec_check(bc->base_table, tab, n, r->attrs, p->is_interior);
-  int dest = valid ? RTD_NONE : RTD_UNREACHABLE;
-
-  if (dest == r->attrs->dest)
+  int old = rt_get_flowspec_valid(r);
+  if (old == valid)
     return NULL;
 
   rta *a = alloca(RTA_MAX_SIZE);
   memcpy(a, r->attrs, rta_size(r->attrs));
-  a->dest = dest;
   a->cached = 0;
 
+  ea_set_attr_u32(&a->eattrs, &ea_gen_flowspec_valid, 0, valid);
+
   rte *new = sl_alloc(rte_slab);
   memcpy(new, r, sizeof(rte));
   new->attrs = rta_lookup(a);
@@ -3524,7 +3529,6 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
 
   /* Reset the hostentry */
   he->src = NULL;
-  he->dest = RTD_UNREACHABLE;
   he->nexthop_linkable = 0;
   he->igp_metric = 0;
 
@@ -3545,16 +3549,12 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
 	  goto done;
 	}
 
-      if (a->dest == RTD_UNICAST)
-	{
-	  eattr *ea = ea_find(a->eattrs, &ea_gen_nexthop);
-	  if (!ea)
-	    {
-	      log(L_WARN "No nexthop in unicast route");
-	      goto done;
-	    }
-	    
-	  NEXTHOP_WALK(nh, (struct nexthop_adata *) ea->u.ptr)
+      eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+      ASSERT_DIE(nhea);
+      struct nexthop_adata *nhad = (void *) nhea->u.ptr;
+
+      if (NEXTHOP_IS_REACHABLE(nhad))
+	  NEXTHOP_WALK(nh, nhad)
 	    if (ipa_zero(nh->gw))
 	      {
 		if (if_local_addr(he->addr, nh->iface))
@@ -3567,10 +3567,8 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
 
 		direct++;
 	      }
-	}
 
       he->src = rta_clone(a);
-      he->dest = a->dest;
       he->nexthop_linkable = !direct;
       he->igp_metric = rt_get_igp_metric(e);
     }
diff --git a/nest/rt.h b/nest/rt.h
index eb3f8454..6f15fec6 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -144,7 +144,6 @@ struct hostentry {
   unsigned hash_key;			/* Hash key */
   unsigned uc;				/* Use count */
   struct rta *src;			/* Source rta entry */
-  byte dest;				/* Chosen route destination type (RTD_...) */
   byte nexthop_linkable;		/* Nexthop list is completely non-device */
   u32 igp_metric;			/* Chosen route IGP metric */
 };
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 9a43f484..b90dcd3f 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -677,10 +677,7 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
       }
     };
 
-    rta a0 = {
-      .dest = RTD_UNICAST,
-      .eattrs = &eattrs.l,
-    };
+    rta a0 = { .eattrs = &eattrs.l, };
 
     rta *a = rta_lookup(&a0);
     rte *rte = rte_get_temp(a, p->p.main_source);
@@ -691,12 +688,11 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
   else if (e->valid && (e->router_id != p->router_id))
   {
     /* Unreachable */
-    rta a0 = {
-      .dest = RTD_UNREACHABLE,
-    };
+    rta a0 = {};
 
     ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, 1);
     ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_BABEL);
+    ea_set_dest(&a0.eattrs, 0, RTD_UNREACHABLE);
 
     rta *a = rta_lookup(&a0);
     rte *rte = rte_get_temp(a, p->p.main_source);
@@ -2263,9 +2259,13 @@ babel_kick_timer(struct babel_proto *p)
 static int
 babel_preexport(struct proto *P, struct rte *new)
 {
-  struct rta *a = new->attrs;
+  if (new->src->proto != P)
+    return 0;
+
   /* Reject our own unreachable routes */
-  if ((a->dest == RTD_UNREACHABLE) && (new->src->proto == P))
+  eattr *ea = ea_find(new->attrs->eattrs, &ea_gen_nexthop);
+  struct nexthop_adata *nhad = (void *) ea->u.ptr;
+  if (!NEXTHOP_IS_REACHABLE(nhad))
     return -1;
 
   return 0;
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 1efc26ce..6a9e4026 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -1711,9 +1711,20 @@ bgp_preexport(struct proto *P, rte *e)
   if (src == NULL)
     return 0;
 
-  /* Reject flowspec that failed validation */
-  if ((e->attrs->dest == RTD_UNREACHABLE) && net_is_flow(e->net->n.addr))
-      return -1;
+  /* Reject flowspec that failed or are pending validation */
+  if (net_is_flow(e->net->n.addr))
+    switch (rt_get_flowspec_valid(e))
+    {
+      case FLOWSPEC_VALID:
+	break;
+      case FLOWSPEC_INVALID:
+	return -1;
+      case FLOWSPEC_UNKNOWN:
+	if ((rt_get_source_attr(e) == RTS_BGP) &&
+	    ((struct bgp_channel *) e->sender)->base_table)
+	  return -1;
+	break;
+    }
 
   /* IBGP route reflection, RFC 4456 */
   if (p->is_internal && src->is_internal && (p->local_as == src->local_as))
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 6abb7870..2f98dc1b 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -519,7 +519,9 @@ struct rte_source *bgp_get_source(struct bgp_proto *p, u32 path_id);
 static inline int
 rte_resolvable(rte *rt)
 {
-  return rt->attrs->dest != RTD_UNREACHABLE;
+  eattr *nhea = ea_find(rt->attrs->eattrs, &ea_gen_nexthop);
+  struct nexthop_adata *nhad = (void *) nhea->u.ptr;
+  return NEXTHOP_IS_REACHABLE(nhad) || (nhad->dest != RTD_UNREACHABLE);
 }
 
 
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index b07320aa..4c46c60e 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -968,7 +968,6 @@ bgp_apply_next_hop(struct bgp_parse_state *s, rta *a, ip_addr gw, ip_addr ll)
 
     ea_set_attr_u32(&a->eattrs, &ea_gen_igp_metric, 0, c->cf->cost);
 
-    a->dest = RTD_UNICAST;
     struct nexthop_adata nhad = {
       .nh = {
 	.gw = nbr->addr,
@@ -1003,8 +1002,7 @@ bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a, u32 lnum, u32 labels[ln
   {
     REPORT("Too many MPLS labels ($u)", lnum);
 
-    a->dest = RTD_UNREACHABLE;
-    ea_unset_attr(&a->eattrs, 0, &ea_gen_nexthop);
+    ea_set_dest(&a->eattrs, 0, RTD_UNREACHABLE);
     return;
   }
 
@@ -1039,15 +1037,21 @@ static void
 bgp_apply_flow_validation(struct bgp_parse_state *s, const net_addr *n, rta *a)
 {
   struct bgp_channel *c = s->channel;
-  int valid = rt_flowspec_check(c->base_table, c->c.table, n, a, s->proto->is_interior);
-  a->dest = valid ? RTD_NONE : RTD_UNREACHABLE;
+  uint valid = rt_flowspec_check(c->base_table, c->c.table, n, a, s->proto->is_interior);
 
-  /* Invalidate cached rta if dest changes */
-  if (s->cached_rta && (s->cached_rta->dest != a->dest))
+  /* Invalidate cached rta */
+  if (s->cached_rta)
   {
+    /* Has't changed */
+    if (valid == ea_get_int(s->cached_rta->eattrs, &ea_gen_flowspec_valid, FLOWSPEC_UNKNOWN))
+      return;
+
     rta_free(s->cached_rta);
     s->cached_rta = NULL;
   }
+
+  /* Set the value */
+  ea_set_attr_u32(&a->eattrs, &ea_gen_flowspec_valid, 0, valid);
 }
 
 static int
@@ -1107,17 +1111,14 @@ bgp_use_gateway(struct bgp_export_state *s)
   if (c->cf->next_hop_self && bgp_match_src(s, c->cf->next_hop_self))
     return NULL;
 
-  /* Unreachable */
-  if (ra->dest != RTD_UNICAST)
-    return NULL;
-
   eattr *nhea = ea_find(ra->eattrs, &ea_gen_nexthop);
   if (!nhea)
     return NULL;
 
   /* We need one valid global gateway */
   struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
-  if (!NEXTHOP_ONE(nhad) || ipa_zero(nhad->nh.gw) ||
+  if (!NEXTHOP_IS_REACHABLE(nhad) ||
+      !NEXTHOP_ONE(nhad) || ipa_zero(nhad->nh.gw) ||
       ipa_is_link_local(nhad->nh.gw))
     return NULL;
 
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index 6070fd34..afe4a01f 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -1983,8 +1983,7 @@ ort_changed(ort *nf, rta *nr)
 
   if (!or ||
     (nf->n.metric1 != nf->old_metric1) || (nf->n.metric2 != nf->old_metric2) ||
-    (nf->n.tag != nf->old_tag) || (nf->n.rid != nf->old_rid) ||
-    (nr->dest != or->dest))
+    (nf->n.tag != nf->old_tag) || (nf->n.rid != nf->old_rid))
     return 1;
 
   eattr *nhea_n = ea_find(nr->eattrs, &ea_gen_nexthop);
@@ -2049,7 +2048,6 @@ again1:
     if (nf->n.type) /* Add the route */
     {
       rta a0 = {
-	.dest = RTD_UNICAST,
       };
 
       struct {
diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index ca4620cc..09ec9f28 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -1366,16 +1366,9 @@ ospf_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
   uint tag = ea_get_int(a->eattrs, &ea_ospf_tag, 0);
 
   ip_addr fwd = IPA_NONE;
-  if (a->dest == RTD_UNICAST)
+  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  if (nhea)
   {
-    eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
-    if (!nhea)
-    {
-      log(L_ERR "%s: Unicast route without nexthop for %N",
-	  p->p.name, n->n.addr);
-      return;
-    }
-
     struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
     if (use_gw_for_fwaddr(p, nhad->nh.gw, nhad->nh.iface))
       fwd = nhad->nh.gw;
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index 8642e0a1..d1ff6adf 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -142,9 +142,7 @@ perf_loop(void *data)
     *((net_addr_ip4 *) &(p->data[i].net)) = random_net_ip4();
 
     if (!p->attrs_per_rte || !(i % p->attrs_per_rte)) {
-      struct rta a0 = {
-	.dest = RTD_UNICAST,
-      };
+      struct rta a0 = {};
 
       ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
       ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_PERF);
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 425a411c..a0f2fdc0 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -151,9 +151,7 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
   if (rt)
   {
     /* Update */
-    rta a0 = {
-      .dest = RTD_UNICAST,
-    };
+    rta a0 = {};
 
     struct {
       ea_list l;
diff --git a/proto/rpki/rpki.c b/proto/rpki/rpki.c
index 56d8add2..4318cbb7 100644
--- a/proto/rpki/rpki.c
+++ b/proto/rpki/rpki.c
@@ -120,9 +120,7 @@ rpki_table_add_roa(struct rpki_cache *cache, struct channel *channel, const net_
 {
   struct rpki_proto *p = cache->p;
 
-  rta a0 = {
-    .dest = RTD_NONE,
-  };
+  rta a0 = {};
 
   ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, channel->preference);
   ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_RPKI);
diff --git a/proto/static/static.c b/proto/static/static.c
index 5102617f..806849c4 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -55,7 +55,6 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
 {
   rta *a = allocz(RTA_MAX_SIZE);
   struct rte_src *src = static_get_source(p, r->index);
-  a->dest = r->dest;
   ea_set_attr_u32(&a->eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
   ea_set_attr_u32(&a->eattrs, &ea_gen_source, 0, RTS_STATIC);
 
@@ -97,7 +96,7 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
 	nhad->ad.data, (void *) nh - (void *) nhad->ad.data);
   }
 
-  if (r->dest == RTDX_RECURSIVE)
+  else if (r->dest == RTDX_RECURSIVE)
   {
     rtable *tab = ipa_is_ip4(r->via) ? p->igp_table_ip4 : p->igp_table_ip6;
     u32 *labels = r->mls ? (void *) r->mls->data : NULL;
@@ -107,6 +106,9 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
 	r->via, IPA_NONE, lnum, labels);
   }
 
+  else if (r->dest)
+    ea_set_dest(&a->eattrs, 0, r->dest);
+
   /* Already announced */
   if (r->state == SRS_CLEAN)
     return;
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index fdfd4885..40f6212e 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -1407,11 +1407,16 @@ HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
 int
 krt_capable(rte *e)
 {
-  rta *a = e->attrs;
+  eattr *ea = ea_find(e->attrs->eattrs, &ea_gen_nexthop);
+  if (!ea)
+    return 0;
+
+  struct nexthop_adata *nhad = (void *) ea->u.ptr;
+  if (NEXTHOP_IS_REACHABLE(nhad))
+    return 1;
 
-  switch (a->dest)
+  switch (nhad->dest)
   {
-    case RTD_UNICAST:
     case RTD_BLACKHOLE:
     case RTD_UNREACHABLE:
     case RTD_PROHIBIT:
@@ -1591,7 +1596,7 @@ nl_add_rte(struct krt_proto *p, rte *e)
   eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
   struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
 
-  if (krt_ecmp6(p) && nhad && !NEXTHOP_ONE(nhad))
+  if (krt_ecmp6(p) && nhad && NEXTHOP_IS_REACHABLE(nhad) && !NEXTHOP_ONE(nhad))
   {
     uint cnt = 0;
     NEXTHOP_WALK(nh, nhad)
@@ -1616,7 +1621,8 @@ nl_add_rte(struct krt_proto *p, rte *e)
     return err;
   }
 
-  return nl_send_route(p, e, NL_OP_ADD, a->dest, nhad);
+  return nl_send_route(p, e, NL_OP_ADD,
+      NEXTHOP_IS_REACHABLE(nhad) ? RTD_UNICAST : nhad->dest, nhad);
 }
 
 static inline int
@@ -1638,7 +1644,8 @@ nl_replace_rte(struct krt_proto *p, rte *e)
   rta *a = e->attrs;
   eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
   struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
-  return nl_send_route(p, e, NL_OP_REPLACE, a->dest, nhad);
+  return nl_send_route(p, e, NL_OP_REPLACE,
+      NEXTHOP_IS_REACHABLE(nhad) ? RTD_UNICAST : nhad->dest, nhad);
 }
 
 
@@ -1901,8 +1908,6 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   switch (i->rtm_type)
     {
     case RTN_UNICAST:
-      ra->dest = RTD_UNICAST;
-
       if (a[RTA_MULTIPATH])
         {
 	  struct nexthop_adata *nh = nl_parse_multipath(s, p, n, a[RTA_MULTIPATH], i->rtm_family, krt_src);
@@ -1953,15 +1958,40 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	    }
 	}
 
+#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:
-      ra->dest = RTD_BLACKHOLE;
+      nhad.nhad = NEXTHOP_DEST_LITERAL(RTD_BLACKHOLE);
       break;
     case RTN_UNREACHABLE:
-      ra->dest = RTD_UNREACHABLE;
+      nhad.nhad = NEXTHOP_DEST_LITERAL(RTD_UNREACHABLE);
       break;
     case RTN_PROHIBIT:
-      ra->dest = RTD_PROHIBIT;
+      nhad.nhad = NEXTHOP_DEST_LITERAL(RTD_PROHIBIT);
       break;
     /* FIXME: What about RTN_THROW? */
     default:
@@ -1969,32 +1999,6 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
       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;
-
   if (i->rtm_scope != def_scope)
     ea_set_attr(&ra->eattrs,
 	EA_LITERAL_EMBEDDED(&ea_krt_scope, 0, i->rtm_scope));
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index 89e9e97e..a0789936 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -608,17 +608,10 @@ krt_same_dest(rte *k, rte *e)
 {
   rta *ka = k->attrs, *ea = e->attrs;
 
-  if (ka->dest != ea->dest)
-    return 0;
-
-  if (ka->dest != RTD_UNICAST)
-    return 1;
-
   eattr *nhea_k = ea_find(ka->eattrs, &ea_gen_nexthop);
   eattr *nhea_e = ea_find(ea->eattrs, &ea_gen_nexthop);
 
-  ASSUME(nhea_k && nhea_e);
-  return adata_same(nhea_k->u.ptr, nhea_e->u.ptr);
+  return (!nhea_k == !nhea_e) && adata_same(nhea_k->u.ptr, nhea_e->u.ptr);
 }
 
 /*
-- 
cgit v1.2.3


From 938742decc6e1d6d3a0375dd012b75172e747bbc Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Mon, 30 May 2022 12:03:03 +0200
Subject: Squashing the route attribute structure into one level.

For now, all route attributes are stored as eattrs in ea_list. This
should make route manipulation easier and it also allows for a layered
approach of route attributes where updates from filters will be stored
as an overlay over the previous version.
---
 filter/f-inst.c        |   8 +--
 filter/filter.c        |  41 +++----------
 lib/route.h            |  52 ++++++++--------
 nest/config.Y          |   2 +-
 nest/rt-attr.c         | 160 ++++++++++++++-----------------------------------
 nest/rt-dev.c          |  12 ++--
 nest/rt-show.c         |  12 ++--
 nest/rt-table.c        |  88 +++++++++++++--------------
 nest/rt.h              |  19 ++----
 proto/babel/babel.c    |  34 +++++------
 proto/bgp/attrs.c      |  66 ++++++++++----------
 proto/bgp/bgp.h        |  10 ++--
 proto/bgp/packets.c    | 127 ++++++++++++++++++---------------------
 proto/mrt/mrt.c        |   2 +-
 proto/ospf/ospf.c      |  20 +++----
 proto/ospf/rt.c        |  32 +++++-----
 proto/ospf/rt.h        |   2 +-
 proto/ospf/topology.c  |  10 ++--
 proto/perf/perf.c      |  12 ++--
 proto/pipe/pipe.c      |   8 +--
 proto/radv/radv.c      |   4 +-
 proto/rip/rip.c        |  36 ++++++-----
 proto/rpki/rpki.c      |  10 ++--
 proto/static/static.c  |  24 ++++----
 sysdep/linux/netlink.c |  40 ++++++-------
 sysdep/unix/krt.c      |  18 +++---
 26 files changed, 352 insertions(+), 497 deletions(-)

(limited to 'sysdep/linux')

diff --git a/filter/f-inst.c b/filter/f-inst.c
index c2abd5aa..65a0b011 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -212,7 +212,7 @@
  *	m4_dnl	  NEVER_CONSTANT-> don't generate pre-interpretation code at all
  *	m4_dnl	  ACCESS_RTE	-> check that route is available, also NEVER_CONSTANT
  *	m4_dnl	  ACCESS_EATTRS	-> pre-cache the eattrs; use only with ACCESS_RTE
- *	m4_dnl	  f_rta_cow(fs)	-> function to call before any change to route should be done
+ *	m4_dnl	  f_rte_cow(fs)	-> function to call before any change to route should be done
  *
  *	m4_dnl	If you are stymied, see FI_CALL or FI_CONSTANT or just search for
  *	m4_dnl	the mentioned macros in this file to see what is happening there in wild.
@@ -578,7 +578,7 @@
     STATIC_ATTR;
     ARG_TYPE(1, sa.type);
 
-    f_rta_cow(fs);
+    f_rte_cow(fs);
     {
       union {
 	struct nexthop_adata nha;
@@ -741,7 +741,7 @@
       if (da->type >= EAF_TYPE__MAX)
 	bug("Unsupported attribute type");
 
-      f_rta_cow(fs);
+      f_rte_cow(fs);
 
       switch (da->type) {
       case T_OPAQUE:
@@ -770,7 +770,7 @@
     ACCESS_RTE;
     ACCESS_EATTRS;
 
-    f_rta_cow(fs);
+    f_rte_cow(fs);
     ea_unset_attr(fs->eattrs, 1, da);
   }
 
diff --git a/filter/filter.c b/filter/filter.c
index 9bedb938..ff6a3419 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -76,9 +76,6 @@ struct filter_state {
   /* The route we are processing. This may be NULL to indicate no route available. */
   struct rte **rte;
 
-  /* The old rta to be freed after filters are done. */
-  struct rta *old_rta;
-
   /* Cached pointer to ea_list */
   struct ea_list **eattrs;
 
@@ -99,7 +96,7 @@ void (*bt_assert_hook)(int result, const struct f_line_item *assert);
 
 static inline void f_cache_eattrs(struct filter_state *fs)
 {
-  fs->eattrs = &((*fs->rte)->attrs->eattrs);
+  fs->eattrs = &((*fs->rte)->attrs);
 }
 
 static inline void f_rte_cow(struct filter_state *fs)
@@ -110,33 +107,6 @@ static inline void f_rte_cow(struct filter_state *fs)
   *fs->rte = rte_cow(*fs->rte);
 }
 
-/*
- * rta_cow - prepare rta for modification by filter
- */
-static void
-f_rta_cow(struct filter_state *fs)
-{
-  if (!rta_is_cached((*fs->rte)->attrs))
-    return;
-
-  /* Prepare to modify rte */
-  f_rte_cow(fs);
-
-  /* Store old rta to free it later, it stores reference from rte_cow() */
-  fs->old_rta = (*fs->rte)->attrs;
-
-  /*
-   * Get shallow copy of rta. Fields eattrs and nexthops of rta are shared
-   * with fs->old_rta (they will be copied when the cached rta will be obtained
-   * at the end of f_run()), also the lock of hostentry is inherited (we
-   * suppose hostentry is not changed by filters).
-   */
-  (*fs->rte)->attrs = rta_do_cow((*fs->rte)->attrs, tmp_linpool);
-
-  /* Re-cache the ea_list */
-  f_cache_eattrs(fs);
-}
-
 static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;
 
 /**
@@ -289,7 +259,7 @@ f_run(const struct filter *filter, struct rte **rte, int flags)
   /* Run the interpreter itself */
   enum filter_return fret = interpret(&filter_state, filter->root, NULL);
 
-  if (filter_state.old_rta) {
+  if (filter_state.eattrs && !ea_is_cached(*filter_state.eattrs)) {
     /*
      * Cached rta was modified and filter_state->rte contains now an uncached one,
      * sharing some part with the cached one. The cached rta should
@@ -302,6 +272,10 @@ f_run(const struct filter *filter, struct rte **rte, int flags)
      * This is not the problem if rte was COW, because original rte
      * also holds the same rta.
      */
+    ea_list *cached = *filter_state.eattrs;
+    while (cached && !ea_is_cached(cached))
+      cached = cached->next;
+
     if (!rte_cow) {
       /* Cache the new attrs */
       (*filter_state.rte)->attrs = rta_lookup((*filter_state.rte)->attrs);
@@ -311,8 +285,7 @@ f_run(const struct filter *filter, struct rte **rte, int flags)
     }
 
     /* Uncache the old attrs and drop the pointer as it is invalid now. */
-    rta_free(filter_state.old_rta);
-    filter_state.old_rta = NULL;
+    rta_free(cached);
   }
 
   /* Process the filter output, log it and return */
diff --git a/lib/route.h b/lib/route.h
index 1d8877c8..3f6fc5a9 100644
--- a/lib/route.h
+++ b/lib/route.h
@@ -21,7 +21,7 @@ typedef struct rte {
   struct network *net;			/* Network this RTE belongs to */
   struct rte_src *src;			/* Route source that created the route */
   struct channel *sender;		/* Channel used to send the route to the routing table */
-  struct rta *attrs;			/* Attributes of this route */
+  struct ea_list *attrs;		/* Attributes of this route */
   u32 id;				/* Table specific route id */
   byte flags;				/* Flags (REF_...) */
   byte pflags;				/* Protocol-specific flags */
@@ -90,14 +90,6 @@ struct nexthop_adata {
 #define RNF_ONLINK		0x1	/* Gateway is onlink regardless of IP ranges */
 
 
-typedef struct rta {
-  struct rta *next, **pprev;		/* Hash chain */
-  u32 uc;				/* Use count */
-  u32 hash_key;				/* Hash over important fields */
-  struct ea_list *eattrs;		/* Extended Attribute chain */
-  u16 cached:1;				/* Are attributes cached? */
-} rta;
-
 #define RTS_STATIC 1			/* Normal static route */
 #define RTS_INHERIT 2			/* Route inherited from kernel */
 #define RTS_DEVICE 3			/* Device route */
@@ -153,6 +145,10 @@ typedef struct eattr {
 #define EA_BIT_GET(ea) ((ea) >> 24)
 
 typedef struct ea_list {
+  struct ea_list *next_hash;		/* Next in hash chain */
+  struct ea_list **pprev_hash;		/* Previous in hash chain */
+  u32 uc;				/* Use count */
+  u32 hash_key;				/* List hash */
   struct ea_list *next;			/* In case we have an override list */
   byte flags;				/* Flags: EALF_... */
   byte rfu;
@@ -162,7 +158,7 @@ typedef struct ea_list {
 
 #define EALF_SORTED 1			/* Attributes are sorted by code */
 #define EALF_BISECT 2			/* Use interval bisection for searching */
-#define EALF_CACHED 4			/* Attributes belonging to cached rta */
+#define EALF_CACHED 4			/* List is cached */
 
 struct ea_class {
 #define EA_CLASS_INSIDE \
@@ -317,7 +313,7 @@ ea_copy_attr(ea_list **to, ea_list *from, const struct ea_class *def)
 /* Preference: first-order comparison */
 extern struct ea_class ea_gen_preference;
 static inline u32 rt_get_preference(rte *rt)
-{ return ea_get_int(rt->attrs->eattrs, &ea_gen_preference, 0); }
+{ return ea_get_int(rt->attrs, &ea_gen_preference, 0); }
 
 /* IGP metric: second-order comparison */
 extern struct ea_class ea_gen_igp_metric;
@@ -332,7 +328,7 @@ extern struct ea_class ea_gen_from;
  * To be superseded in a near future by something more informative. */
 extern struct ea_class ea_gen_source;
 static inline u32 rt_get_source_attr(rte *rt)
-{ return ea_get_int(rt->attrs->eattrs, &ea_gen_source, 0); }
+{ return ea_get_int(rt->attrs, &ea_gen_source, 0); }
 
 /* Flowspec validation result */
 #define FLOWSPEC_UNKNOWN	0
@@ -341,7 +337,7 @@ static inline u32 rt_get_source_attr(rte *rt)
 
 extern struct ea_class ea_gen_flowspec_valid;
 static inline u32 rt_get_flowspec_valid(rte *rt)
-{ return ea_get_int(rt->attrs->eattrs, &ea_gen_flowspec_valid, FLOWSPEC_UNKNOWN); }
+{ return ea_get_int(rt->attrs, &ea_gen_flowspec_valid, FLOWSPEC_UNKNOWN); }
 
 /* Next hop: For now, stored as adata */
 extern struct ea_class ea_gen_nexthop;
@@ -382,7 +378,7 @@ int nexthop_is_sorted(struct nexthop_adata *x);
 /* Route has regular, reachable nexthop (i.e. not RTD_UNREACHABLE and like) */
 static inline int rte_is_reachable(rte *r)
 {
-  eattr *nhea = ea_find(r->attrs->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(r->attrs, &ea_gen_nexthop);
   if (!nhea)
     return 0;
 
@@ -404,21 +400,23 @@ static inline int nhea_dest(eattr *nhea)
 
 static inline int rte_dest(rte *r)
 {
-  return nhea_dest(ea_find(r->attrs->eattrs, &ea_gen_nexthop));
+  return nhea_dest(ea_find(r->attrs, &ea_gen_nexthop));
 }
 
 void rta_init(void);
-#define rta_size(...) (sizeof(rta))
-#define RTA_MAX_SIZE (sizeof(rta))
-rta *rta_lookup(rta *);			/* Get rta equivalent to this one, uc++ */
-static inline int rta_is_cached(rta *r) { return r->cached; }
-static inline rta *rta_clone(rta *r) { r->uc++; return r; }
-void rta__free(rta *r);
-static inline void rta_free(rta *r) { if (r && !--r->uc) rta__free(r); }
-rta *rta_do_cow(rta *o, linpool *lp);
-static inline rta * rta_cow(rta *r, linpool *lp) { return rta_is_cached(r) ? rta_do_cow(r, lp) : r; }
-void rta_dump(rta *);
-void rta_dump_all(void);
-void rta_show(struct cli *, rta *);
+ea_list *ea_lookup(ea_list *);		/* Get a cached (and normalized) variant of this attribute list */
+static inline int ea_is_cached(ea_list *r) { return r->flags & EALF_CACHED; }
+static inline ea_list *ea_clone(ea_list *r) { r->uc++; return r; }
+void ea__free(ea_list *r);
+static inline void ea_free(ea_list *r) { if (r && !--r->uc) ea__free(r); }
+
+void ea_dump(ea_list *);
+void ea_dump_all(void);
+void ea_show_list(struct cli *, ea_list *);
+
+#define rta_lookup	ea_lookup
+#define rta_is_cached	ea_is_cached
+#define rta_clone	ea_clone
+#define rta_free	ea_free
 
 #endif
diff --git a/nest/config.Y b/nest/config.Y
index 6a35cdd2..773673e8 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -849,7 +849,7 @@ CF_CLI(DUMP INTERFACES,,, [[Dump interface information]])
 CF_CLI(DUMP NEIGHBORS,,, [[Dump neighbor cache]])
 { neigh_dump_all(); cli_msg(0, ""); } ;
 CF_CLI(DUMP ATTRIBUTES,,, [[Dump attribute cache]])
-{ rta_dump_all(); cli_msg(0, ""); } ;
+{ ea_dump_all(); cli_msg(0, ""); } ;
 CF_CLI(DUMP ROUTES,,, [[Dump routing table]])
 { rt_dump_all(); cli_msg(0, ""); } ;
 CF_CLI(DUMP PROTOCOLS,,, [[Dump protocol information]])
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index b5be936b..6927751f 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -174,7 +174,6 @@ struct ea_class ea_gen_flowspec_valid = {
 
 pool *rta_pool;
 
-static slab *rta_slab;
 static slab *rte_src_slab;
 
 static struct idm src_ids;
@@ -943,17 +942,6 @@ ea_list_unref(ea_list *l)
     }
 }
 
-static inline void
-ea_free(ea_list *o)
-{
-  if (o)
-    {
-      ea_list_unref(o);
-      ASSERT(!o->next);
-      mb_free(o);
-    }
-}
-
 void
 ea_format_bitfield(const struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max)
 {
@@ -1050,7 +1038,7 @@ ea_show_lc_set(struct cli *c, const struct adata *ad, byte *pos, byte *buf, byte
  * If the protocol defining the attribute provides its own
  * get_attr() hook, it's consulted first.
  */
-void
+static void
 ea_show(struct cli *c, const eattr *e)
 {
   const struct adata *ad = (e->type & EAF_EMBEDDED) ? NULL : e->u.ptr;
@@ -1141,10 +1129,11 @@ ea_dump(ea_list *e)
     }
   while (e)
     {
-      debug("[%c%c%c]",
+      debug("[%c%c%c] uc=%d h=%08x",
 	    (e->flags & EALF_SORTED) ? 'S' : 's',
 	    (e->flags & EALF_BISECT) ? 'B' : 'b',
-	    (e->flags & EALF_CACHED) ? 'C' : 'c');
+	    (e->flags & EALF_CACHED) ? 'C' : 'c',
+	    e->uc, e->hash_key);
       for(i=0; i<e->count; i++)
 	{
 	  eattr *a = &e->attrs[i];
@@ -1236,12 +1225,12 @@ static uint rta_cache_count;
 static uint rta_cache_size = 32;
 static uint rta_cache_limit;
 static uint rta_cache_mask;
-static rta **rta_hash_table;
+static ea_list **rta_hash_table;
 
 static void
 rta_alloc_hash(void)
 {
-  rta_hash_table = mb_allocz(rta_pool, sizeof(rta *) * rta_cache_size);
+  rta_hash_table = mb_allocz(rta_pool, sizeof(ea_list *) * rta_cache_size);
   if (rta_cache_size < 32768)
     rta_cache_limit = rta_cache_size * 2;
   else
@@ -1249,44 +1238,14 @@ rta_alloc_hash(void)
   rta_cache_mask = rta_cache_size - 1;
 }
 
-static inline uint
-rta_hash(rta *a)
-{
-  return ea_hash(a->eattrs);
-}
-
-static inline int
-rta_same(rta *x, rta *y)
-{
-  return ea_same(x->eattrs, y->eattrs);
-}
-
-static rta *
-rta_copy(rta *o)
-{
-  rta *r = sl_alloc(rta_slab);
-
-  memcpy(r, o, rta_size(o));
-  r->uc = 1;
-  if (!r->eattrs)
-    return r;
-
-  uint elen = ea_list_size(o->eattrs);
-  r->eattrs = mb_alloc(rta_pool, elen);
-  ea_list_copy(r->eattrs, o->eattrs, elen);
-  ea_list_ref(r->eattrs);
-  r->eattrs->flags |= EALF_CACHED;
-  return r;
-}
-
 static inline void
-rta_insert(rta *r)
+rta_insert(ea_list *r)
 {
   uint h = r->hash_key & rta_cache_mask;
-  r->next = rta_hash_table[h];
-  if (r->next)
-    r->next->pprev = &r->next;
-  r->pprev = &rta_hash_table[h];
+  r->next_hash = rta_hash_table[h];
+  if (r->next_hash)
+    r->next_hash->pprev_hash = &r->next_hash;
+  r->pprev_hash = &rta_hash_table[h];
   rta_hash_table[h] = r;
 }
 
@@ -1295,8 +1254,8 @@ rta_rehash(void)
 {
   uint ohs = rta_cache_size;
   uint h;
-  rta *r, *n;
-  rta **oht = rta_hash_table;
+  ea_list *r, *n;
+  ea_list **oht = rta_hash_table;
 
   rta_cache_size = 2*rta_cache_size;
   DBG("Rehashing rta cache from %d to %d entries.\n", ohs, rta_cache_size);
@@ -1304,7 +1263,7 @@ rta_rehash(void)
   for(h=0; h<ohs; h++)
     for(r=oht[h]; r; r=n)
       {
-	n = r->next;
+	n = r->next_hash;
 	rta_insert(r);
       }
   mb_free(oht);
@@ -1323,24 +1282,29 @@ rta_rehash(void)
  * The extended attribute lists attached to the &rta are automatically
  * converted to the normalized form.
  */
-rta *
-rta_lookup(rta *o)
+ea_list *
+ea_lookup(ea_list *o)
 {
-  rta *r;
+  ea_list *r;
   uint h;
 
-  ASSERT(!o->cached);
-  if (o->eattrs)
-    o->eattrs = ea_normalize(o->eattrs);
+  ASSERT(!ea_is_cached(o));
+  o = ea_normalize(o);
+  h = ea_hash(o);
+
+  for(r=rta_hash_table[h & rta_cache_mask]; r; r=r->next_hash)
+    if (r->hash_key == h && ea_same(r, o))
+      return ea_clone(r);
 
-  h = rta_hash(o);
-  for(r=rta_hash_table[h & rta_cache_mask]; r; r=r->next)
-    if (r->hash_key == h && rta_same(r, o))
-      return rta_clone(r);
+  uint elen = ea_list_size(o);
+  r = mb_alloc(rta_pool, elen);
+  ea_list_copy(r, o, elen);
+  ea_list_ref(r);
 
-  r = rta_copy(o);
+  r->flags |= EALF_CACHED;
   r->hash_key = h;
-  r->cached = 1;
+  r->uc = 1;
+
   rta_insert(r);
 
   if (++rta_cache_count > rta_cache_limit)
@@ -1350,46 +1314,17 @@ rta_lookup(rta *o)
 }
 
 void
-rta__free(rta *a)
+ea__free(ea_list *a)
 {
-  ASSERT(rta_cache_count && a->cached);
+  ASSERT(rta_cache_count && ea_is_cached(a));
   rta_cache_count--;
-  *a->pprev = a->next;
-  if (a->next)
-    a->next->pprev = a->pprev;
-  ea_free(a->eattrs);
-  a->cached = 0;
-  sl_free(a);
-}
-
-rta *
-rta_do_cow(rta *o, linpool *lp)
-{
-  rta *r = lp_alloc(lp, rta_size(o));
-  memcpy(r, o, rta_size(o));
-  r->cached = 0;
-  r->uc = 0;
-  return r;
-}
+  *a->pprev_hash = a->next_hash;
+  if (a->next_hash)
+    a->next_hash->pprev_hash = a->pprev_hash;
 
-/**
- * rta_dump - dump route attributes
- * @a: attribute structure to dump
- *
- * This function takes a &rta and dumps its contents to the debug output.
- */
-void
-rta_dump(rta *a)
-{
-  debug("uc=%d h=%04x",
-	a->uc, a->hash_key);
-  if (!a->cached)
-    debug(" !CACHED");
-  if (a->eattrs)
-    {
-      debug(" EA: ");
-      ea_dump(a->eattrs);
-    }
+  ASSERT(!a->next);
+  ea_list_unref(a);
+  mb_free(a);
 }
 
 /**
@@ -1399,26 +1334,23 @@ rta_dump(rta *a)
  * to the debug output.
  */
 void
-rta_dump_all(void)
+ea_dump_all(void)
 {
-  rta *a;
-  uint h;
-
   debug("Route attribute cache (%d entries, rehash at %d):\n", rta_cache_count, rta_cache_limit);
-  for(h=0; h<rta_cache_size; h++)
-    for(a=rta_hash_table[h]; a; a=a->next)
+  for (uint h=0; h < rta_cache_size; h++)
+    for (ea_list *a = rta_hash_table[h]; a; a = a->next_hash)
       {
 	debug("%p ", a);
-	rta_dump(a);
+	ea_dump(a);
 	debug("\n");
       }
   debug("\n");
 }
 
 void
-rta_show(struct cli *c, rta *a)
+ea_show_list(struct cli *c, ea_list *eal)
 {
-  for(ea_list *eal = a->eattrs; eal; eal=eal->next)
+  for( ; eal; eal=eal->next)
     for(int i=0; i<eal->count; i++)
       ea_show(c, &eal->attrs[i]);
 }
@@ -1434,8 +1366,6 @@ rta_init(void)
 {
   rta_pool = rp_new(&root_pool, "Attributes");
 
-  rta_slab = sl_new(rta_pool, sizeof(rta));
-
   rta_alloc_hash();
   rte_src_init();
   ea_class_init();
diff --git a/nest/rt-dev.c b/nest/rt-dev.c
index c50e018c..63f8a26b 100644
--- a/nest/rt-dev.c
+++ b/nest/rt-dev.c
@@ -71,7 +71,6 @@ dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
     }
   else if (flags & IF_CHANGE_UP)
     {
-      rta *a;
       rte *e;
 
       DBG("dev_if_notify: %s:%I going up\n", ad->iface->name, ad->ip);
@@ -82,18 +81,17 @@ dev_ifa_notify(struct proto *P, uint flags, struct ifa *ad)
       /* Use iface ID as local source ID */
       struct rte_src *src = rt_get_source(P, ad->iface->index);
 
-      rta a0 = {};
+      ea_list *ea = NULL;
       struct nexthop_adata nhad = {
 	.nh = { .iface = ad->iface, },
 	.ad = { .length = (void *) NEXTHOP_NEXT(&nhad.nh) - (void *) nhad.ad.data, },
       };
 
-      ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, c->preference);
-      ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_DEVICE);
-      ea_set_attr_data(&a0.eattrs, &ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length);
+      ea_set_attr_u32(&ea, &ea_gen_preference, 0, c->preference);
+      ea_set_attr_u32(&ea, &ea_gen_source, 0, RTS_DEVICE);
+      ea_set_attr_data(&ea, &ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length);
 
-      a = rta_lookup(&a0);
-      e = rte_get_temp(a, src);
+      e = rte_get_temp(rta_lookup(ea), src);
       e->pflags = 0;
       rte_update2(c, net, e, src);
     }
diff --git a/nest/rt-show.c b/nest/rt-show.c
index 0ad8f5c6..2cbc500a 100644
--- a/nest/rt-show.c
+++ b/nest/rt-show.c
@@ -42,23 +42,23 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
 {
   byte from[IPA_MAX_TEXT_LENGTH+8];
   byte tm[TM_DATETIME_BUFFER_SIZE], info[256];
-  rta *a = e->attrs;
+  ea_list *a = e->attrs;
   int sync_error = d->kernel ? krt_get_sync_error(d->kernel, e) : 0;
   void (*get_route_info)(struct rte *, byte *buf);
-  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(a, &ea_gen_nexthop);
   struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
   int dest = NEXTHOP_IS_REACHABLE(nhad) ? RTD_UNICAST : nhad->dest;
 
   tm_format_time(tm, &config->tf_route, e->lastmod);
-  ip_addr a_from = ea_get_ip(a->eattrs, &ea_gen_from, IPA_NONE);
+  ip_addr a_from = ea_get_ip(a, &ea_gen_from, IPA_NONE);
   if (ipa_nonzero(a_from) && (!nhad || !ipa_equal(a_from, nhad->nh.gw)))
     bsprintf(from, " from %I", a_from);
   else
     from[0] = 0;
 
   /* Need to normalize the extended attributes */
-  if (d->verbose && !rta_is_cached(a) && a->eattrs)
-    a->eattrs = ea_normalize(a->eattrs);
+  if (d->verbose && !rta_is_cached(a) && a)
+    a = ea_normalize(a);
 
   get_route_info = e->src->proto->proto->get_route_info;
   if (get_route_info)
@@ -99,7 +99,7 @@ rt_show_rte(struct cli *c, byte *ia, rte *e, struct rt_show_data *d, int primary
     }
 
   if (d->verbose)
-    rta_show(c, a);
+    ea_show_list(c, a);
 }
 
 static void
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 539e04d0..e3dab120 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -564,7 +564,7 @@ rte_find(net *net, struct rte_src *src)
  * the protocol.
  */
 rte *
-rte_get_temp(rta *a, struct rte_src *src)
+rte_get_temp(ea_list *a, struct rte_src *src)
 {
   rte *e = sl_alloc(rte_slab);
 
@@ -608,15 +608,15 @@ rte_do_cow(rte *r)
  * Result: a pointer to the new writable &rte with writable &rta.
  */
 rte *
-rte_cow_rta(rte *r, linpool *lp)
+rte_cow_rta(rte *r)
 {
   if (!rta_is_cached(r->attrs))
     return r;
 
   r = rte_cow(r);
-  rta *a = rta_do_cow(r->attrs, lp);
+
+  /* This looks stupid but should DWIW. */
   rta_free(r->attrs);
-  r->attrs = a;
   return r;
 }
 
@@ -971,7 +971,7 @@ rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int
 
     if (rte_is_reachable(rt))
     {
-      eattr *nhea = ea_find(rt->attrs->eattrs, &ea_gen_nexthop);
+      eattr *nhea = ea_find(rt->attrs, &ea_gen_nexthop);
       ASSERT_DIE(nhea);
 
       if (nhs)
@@ -987,13 +987,13 @@ rt_export_merged(struct channel *c, net *net, rte **rt_free, linpool *pool, int
 
   if (nhs)
   {
-    eattr *nhea = ea_find(best->attrs->eattrs, &ea_gen_nexthop);
+    eattr *nhea = ea_find(best->attrs, &ea_gen_nexthop);
     ASSERT_DIE(nhea);
 
     nhs = nexthop_merge(nhs, (struct nexthop_adata *) nhea->u.ptr, c->merge_limit, pool);
 
-    best = rte_cow_rta(best, pool);
-    ea_set_attr(&best->attrs->eattrs,
+    best = rte_cow_rta(best);
+    ea_set_attr(&best->attrs,
 	EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nhs->ad));
   }
 
@@ -1177,7 +1177,7 @@ rte_validate(rte *e)
     return 0;
   }
 
-  eattr *nhea = ea_find(e->attrs->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(e->attrs, &ea_gen_nexthop);
   int dest = nhea_dest(nhea);
 
   if (net_type_match(n->n.addr, NB_DEST) == !dest)
@@ -1808,7 +1808,7 @@ rte_dump(rte *e)
   net *n = e->net;
   debug("%-1N ", n->n.addr);
   debug("PF=%02x ", e->pflags);
-  rta_dump(e->attrs);
+  ea_dump(e->attrs);
   debug("\n");
 }
 
@@ -2416,21 +2416,21 @@ ea_set_hostentry(ea_list **to, struct rtable *dep, struct rtable *tab, ip_addr g
 
 
 static void
-rta_apply_hostentry(rta *a, struct hostentry_adata *head)
+rta_apply_hostentry(ea_list **to, struct hostentry_adata *head)
 {
   struct hostentry *he = head->he;
   u32 *labels = head->labels;
   u32 lnum = (u32 *) (head->ad.data + head->ad.length) - labels;
 
-  ea_set_attr_u32(&a->eattrs, &ea_gen_igp_metric, 0, he->igp_metric);
+  ea_set_attr_u32(to, &ea_gen_igp_metric, 0, he->igp_metric);
 
   if (!he->src)
   {
-    ea_set_dest(&a->eattrs, 0, RTD_UNREACHABLE);
+    ea_set_dest(to, 0, RTD_UNREACHABLE);
     return;
   }
 
-  eattr *he_nh_ea = ea_find(he->src->eattrs, &ea_gen_nexthop);
+  eattr *he_nh_ea = ea_find(he->src, &ea_gen_nexthop);
   ASSERT_DIE(he_nh_ea);
 
   struct nexthop_adata *nhad = (struct nexthop_adata *) he_nh_ea->u.ptr;
@@ -2439,7 +2439,7 @@ rta_apply_hostentry(rta *a, struct hostentry_adata *head)
   if ((idest != RTD_UNICAST) ||
       !lnum && he->nexthop_linkable)
   { /* Just link the nexthop chain, no label append happens. */
-    ea_copy_attr(&a->eattrs, he->src->eattrs, &ea_gen_nexthop);
+    ea_copy_attr(to, he->src, &ea_gen_nexthop);
     return;
   }
 
@@ -2466,7 +2466,7 @@ rta_apply_hostentry(rta *a, struct hostentry_adata *head)
       .dest = RTD_UNREACHABLE,
     };
 
-    ea_set_attr_data(&a->eattrs, &ea_gen_nexthop, 0, &nha.ad.data, nha.ad.length);
+    ea_set_attr_data(to, &ea_gen_nexthop, 0, &nha.ad.data, nha.ad.length);
     return;
   }
 
@@ -2500,22 +2500,22 @@ rta_apply_hostentry(rta *a, struct hostentry_adata *head)
 
   /* Fix final length */
   new->ad.length = (void *) dest - (void *) new->ad.data;
-  ea_set_attr(&a->eattrs, EA_LITERAL_DIRECT_ADATA(
+  ea_set_attr(to, EA_LITERAL_DIRECT_ADATA(
 	&ea_gen_nexthop, 0, &new->ad));
 }
 
 static inline struct hostentry_adata *
-rta_next_hop_outdated(rta *a)
+rta_next_hop_outdated(ea_list *a)
 {
   /* First retrieve the hostentry */
-  eattr *heea = ea_find(a->eattrs, &ea_gen_hostentry);
+  eattr *heea = ea_find(a, &ea_gen_hostentry);
   if (!heea)
     return NULL;
 
   struct hostentry_adata *head = (struct hostentry_adata *) heea->u.ptr;
 
   /* If no nexthop is present, we have to create one */
-  eattr *a_nh_ea = ea_find(a->eattrs, &ea_gen_nexthop);
+  eattr *a_nh_ea = ea_find(a, &ea_gen_nexthop);
   if (!a_nh_ea)
     return head;
 
@@ -2526,10 +2526,10 @@ rta_next_hop_outdated(rta *a)
     return NEXTHOP_IS_REACHABLE(nhad) ? head : NULL;
 
   /* Comparing our nexthop with the hostentry nexthop */
-  eattr *he_nh_ea = ea_find(head->he->src->eattrs, &ea_gen_nexthop);
+  eattr *he_nh_ea = ea_find(head->he->src, &ea_gen_nexthop);
 
   return (
-      (ea_get_int(a->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN) != head->he->igp_metric) ||
+      (ea_get_int(a, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN) != head->he->igp_metric) ||
       (!head->he->nexthop_linkable) ||
       (!he_nh_ea != !a_nh_ea) ||
       (he_nh_ea && a_nh_ea && !adata_same(he_nh_ea->u.ptr, a_nh_ea->u.ptr)))
@@ -2543,13 +2543,12 @@ rt_next_hop_update_rte(rtable *tab UNUSED, rte *old)
   if (!head)
     return NULL;
 
-  rta a = *old->attrs;
-  a.cached = 0;
-  rta_apply_hostentry(&a, head);
+  ea_list *ea = old->attrs;
+  rta_apply_hostentry(&ea, head);
 
   rte *e = sl_alloc(rte_slab);
   memcpy(e, old, sizeof(rte));
-  e->attrs = rta_lookup(&a);
+  e->attrs = rta_lookup(ea);
   rt_lock_source(e->src);
 
   return e;
@@ -2579,23 +2578,23 @@ net_flow_has_dst_prefix(const net_addr *n)
 }
 
 static inline int
-rta_as_path_is_empty(rta *a)
+rta_as_path_is_empty(ea_list *a)
 {
-  eattr *e = ea_find(a->eattrs, "bgp_path");
+  eattr *e = ea_find(a, "bgp_path");
   return !e || (as_path_getlen(e->u.ptr) == 0);
 }
 
 static inline u32
-rta_get_first_asn(rta *a)
+rta_get_first_asn(ea_list *a)
 {
-  eattr *e = ea_find(a->eattrs, "bgp_path");
+  eattr *e = ea_find(a, "bgp_path");
   u32 asn;
 
   return (e && as_path_get_first_regular(e->u.ptr, &asn)) ? asn : 0;
 }
 
 int
-rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, int interior)
+rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, ea_list *a, int interior)
 {
   ASSERT(rt_is_ip(tab_ip));
   ASSERT(rt_is_flow(tab_flow));
@@ -2632,13 +2631,13 @@ rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, i
     return 0;
 
   /* Find ORIGINATOR_ID values */
-  u32 orig_a = ea_get_int(a->eattrs, "bgp_originator_id", 0);
-  u32 orig_b = ea_get_int(rb->attrs->eattrs, "bgp_originator_id", 0);
+  u32 orig_a = ea_get_int(a, "bgp_originator_id", 0);
+  u32 orig_b = ea_get_int(rb->attrs, "bgp_originator_id", 0);
 
   /* Originator is either ORIGINATOR_ID (if present), or BGP neighbor address (if not) */
   if ((orig_a != orig_b) || (!orig_a && !orig_b && !ipa_equal(
-	  ea_get_ip(a->eattrs, &ea_gen_from, IPA_NONE),
-	  ea_get_ip(rb->attrs->eattrs, &ea_gen_from, IPA_NONE)
+	  ea_get_ip(a, &ea_gen_from, IPA_NONE),
+	  ea_get_ip(rb->attrs, &ea_gen_from, IPA_NONE)
 	  )))
     return 0;
 
@@ -2691,15 +2690,12 @@ rt_flowspec_update_rte(rtable *tab, rte *r)
   if (old == valid)
     return NULL;
 
-  rta *a = alloca(RTA_MAX_SIZE);
-  memcpy(a, r->attrs, rta_size(r->attrs));
-  a->cached = 0;
-
-  ea_set_attr_u32(&a->eattrs, &ea_gen_flowspec_valid, 0, valid);
+  ea_list *a = r->attrs;
+  ea_set_attr_u32(&a, &ea_gen_flowspec_valid, 0, valid);
 
   rte *new = sl_alloc(rte_slab);
   memcpy(new, r, sizeof(rte));
-  new->attrs = rta_lookup(a);
+  new->attrs = ea_lookup(a);
 
   return new;
 #else
@@ -3506,7 +3502,7 @@ if_local_addr(ip_addr a, struct iface *i)
 u32
 rt_get_igp_metric(rte *rt)
 {
-  eattr *ea = ea_find(rt->attrs->eattrs, "igp_metric");
+  eattr *ea = ea_find(rt->attrs, "igp_metric");
 
   if (ea)
     return ea->u.data;
@@ -3523,7 +3519,7 @@ rt_get_igp_metric(rte *rt)
 static int
 rt_update_hostentry(rtable *tab, struct hostentry *he)
 {
-  rta *old_src = he->src;
+  ea_list *old_src = he->src;
   int direct = 0;
   int pxlen = 0;
 
@@ -3538,10 +3534,10 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
   if (n)
     {
       rte *e = n->routes;
-      rta *a = e->attrs;
+      ea_list *a = e->attrs;
       pxlen = n->n.addr->pxlen;
 
-      if (ea_find(a->eattrs, &ea_gen_hostentry))
+      if (ea_find(a, &ea_gen_hostentry))
 	{
 	  /* Recursive route should not depend on another recursive route */
 	  log(L_WARN "Next hop address %I resolvable through recursive route for %N",
@@ -3549,7 +3545,7 @@ rt_update_hostentry(rtable *tab, struct hostentry *he)
 	  goto done;
 	}
 
-      eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+      eattr *nhea = ea_find(a, &ea_gen_nexthop);
       ASSERT_DIE(nhea);
       struct nexthop_adata *nhad = (void *) nhea->u.ptr;
 
diff --git a/nest/rt.h b/nest/rt.h
index 6f15fec6..f7cc164d 100644
--- a/nest/rt.h
+++ b/nest/rt.h
@@ -143,7 +143,7 @@ struct hostentry {
   struct hostentry *next;		/* Next in hash chain */
   unsigned hash_key;			/* Hash key */
   unsigned uc;				/* Use count */
-  struct rta *src;			/* Source rta entry */
+  ea_list *src;				/* Source attributes */
   byte nexthop_linkable;		/* Nexthop list is completely non-device */
   u32 igp_metric;			/* Chosen route IGP metric */
 };
@@ -185,7 +185,7 @@ static inline net *net_get(rtable *tab, const net_addr *addr) { return (net *) f
 net *net_get(rtable *tab, const net_addr *addr);
 net *net_route(rtable *tab, const net_addr *n);
 rte *rte_find(net *net, struct rte_src *src);
-rte *rte_get_temp(struct rta *, struct rte_src *src);
+rte *rte_get_temp(ea_list *, struct rte_src *src);
 void rte_update2(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
 /* rte_update() moved to protocol.h to avoid dependency conflicts */
 int rt_examine(rtable *t, net_addr *a, struct proto *p, const struct filter *filter);
@@ -198,7 +198,7 @@ void rte_dump(rte *);
 void rte_free(rte *);
 rte *rte_do_cow(rte *);
 static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
-rte *rte_cow_rta(rte *r, linpool *lp);
+rte *rte_cow_rta(rte *r);
 void rt_dump(rtable *);
 void rt_dump_all(void);
 int rt_feed_channel(struct channel *c);
@@ -290,18 +290,7 @@ struct hostentry_adata {
 void
 ea_set_hostentry(ea_list **to, struct rtable *dep, struct rtable *tab, ip_addr gw, ip_addr ll, u32 lnum, u32 labels[lnum]);
 
-/*
-struct hostentry * rt_get_hostentry(rtable *tab, ip_addr a, ip_addr ll, rtable *dep);
-void rta_apply_hostentry(rta *a, struct hostentry *he, u32 lnum, u32 labels[lnum]);
-
-static inline void
-rta_set_recursive_next_hop(rtable *dep, rta *a, rtable *tab, ip_addr gw, ip_addr ll, u32 lnum, u32 labels[lnum])
-{
-  rta_apply_hostentry(a, rt_get_hostentry(tab, gw, ll, dep), lnum, labels);
-}
-*/
-
-int rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, rta *a, int interior);
+int rt_flowspec_check(rtable *tab_ip, rtable *tab_flow, const net_addr *n, ea_list *a, int interior);
 
 
 /*
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index b90dcd3f..e3903c67 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -677,10 +677,7 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
       }
     };
 
-    rta a0 = { .eattrs = &eattrs.l, };
-
-    rta *a = rta_lookup(&a0);
-    rte *rte = rte_get_temp(a, p->p.main_source);
+    rte *rte = rte_get_temp(rta_lookup(&eattrs.l), p->p.main_source);
 
     e->unreachable = 0;
     rte_update2(c, e->n.addr, rte, p->p.main_source);
@@ -688,14 +685,13 @@ babel_announce_rte(struct babel_proto *p, struct babel_entry *e)
   else if (e->valid && (e->router_id != p->router_id))
   {
     /* Unreachable */
-    rta a0 = {};
+    ea_list *ea = NULL;
 
-    ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, 1);
-    ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_BABEL);
-    ea_set_dest(&a0.eattrs, 0, RTD_UNREACHABLE);
+    ea_set_attr_u32(&ea, &ea_gen_preference, 0, 1);
+    ea_set_attr_u32(&ea, &ea_gen_source, 0, RTS_BABEL);
+    ea_set_dest(&ea, 0, RTD_UNREACHABLE);
 
-    rta *a = rta_lookup(&a0);
-    rte *rte = rte_get_temp(a, p->p.main_source);
+    rte *rte = rte_get_temp(rta_lookup(ea), p->p.main_source);
     rte->pflags = 0;
 
     e->unreachable = 1;
@@ -2025,13 +2021,13 @@ static void
 babel_get_route_info(rte *rte, byte *buf)
 {
   u64 rid = 0;
-  eattr *e = ea_find(rte->attrs->eattrs, &ea_babel_router_id);
+  eattr *e = ea_find(rte->attrs, &ea_babel_router_id);
   if (e)
     memcpy(&rid, e->u.ptr->data, sizeof(u64));
 
   buf += bsprintf(buf, " (%d/%d) [%lR]",
       rt_get_preference(rte),
-      ea_get_int(rte->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY), rid);
+      ea_get_int(rte->attrs, &ea_babel_metric, BABEL_INFINITY), rid);
 }
 
 static void
@@ -2263,7 +2259,7 @@ babel_preexport(struct proto *P, struct rte *new)
     return 0;
 
   /* Reject our own unreachable routes */
-  eattr *ea = ea_find(new->attrs->eattrs, &ea_gen_nexthop);
+  eattr *ea = ea_find(new->attrs, &ea_gen_nexthop);
   struct nexthop_adata *nhad = (void *) ea->u.ptr;
   if (!NEXTHOP_IS_REACHABLE(nhad))
     return -1;
@@ -2286,13 +2282,13 @@ babel_rt_notify(struct proto *P, struct channel *c UNUSED, struct network *net,
   {
     /* Update */
     uint rt_seqno;
-    uint rt_metric = ea_get_int(new->attrs->eattrs, &ea_babel_metric, 0);
+    uint rt_metric = ea_get_int(new->attrs, &ea_babel_metric, 0);
     u64 rt_router_id = 0;
 
     if (new->src->proto == P)
     {
-      rt_seqno = ea_get_int(new->attrs->eattrs, &ea_babel_seqno, 0);
-      eattr *e = ea_find(new->attrs->eattrs, &ea_babel_router_id);
+      rt_seqno = ea_get_int(new->attrs, &ea_babel_seqno, 0);
+      eattr *e = ea_find(new->attrs, &ea_babel_router_id);
       if (e)
 	memcpy(&rt_router_id, e->u.ptr->data, sizeof(u64));
     }
@@ -2343,8 +2339,8 @@ babel_rt_notify(struct proto *P, struct channel *c UNUSED, struct network *net,
 static int
 babel_rte_better(struct rte *new, struct rte *old)
 {
-  uint new_metric = ea_get_int(new->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY);
-  uint old_metric = ea_get_int(old->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY);
+  uint new_metric = ea_get_int(new->attrs, &ea_babel_metric, BABEL_INFINITY);
+  uint old_metric = ea_get_int(old->attrs, &ea_babel_metric, BABEL_INFINITY);
 
   return new_metric < old_metric;
 }
@@ -2352,7 +2348,7 @@ babel_rte_better(struct rte *new, struct rte *old)
 static u32
 babel_rte_igp_metric(struct rte *rt)
 {
-  return ea_get_int(rt->attrs->eattrs, &ea_babel_metric, BABEL_INFINITY);
+  return ea_get_int(rt->attrs, &ea_babel_metric, BABEL_INFINITY);
 }
 
 
diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c
index 6a9e4026..c605bb07 100644
--- a/proto/bgp/attrs.c
+++ b/proto/bgp/attrs.c
@@ -374,7 +374,7 @@ bgp_aigp_set_metric(struct linpool *pool, const struct adata *ad, u64 metric)
 int
 bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad)
 {
-  eattr *a = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_AIGP));
+  eattr *a = ea_find(e->attrs, BGP_EA_ID(BA_AIGP));
   if (!a)
     return 0;
 
@@ -1492,13 +1492,13 @@ loop:
 }
 
 void
-bgp_finish_attrs(struct bgp_parse_state *s, rta *a)
+bgp_finish_attrs(struct bgp_parse_state *s, ea_list **to)
 {
   /* AIGP test here instead of in bgp_decode_aigp() - we need to know channel */
   if (BIT32_TEST(s->attrs_seen, BA_AIGP) && !s->channel->cf->aigp)
   {
     REPORT("Discarding AIGP attribute received on non-AIGP session");
-    bgp_unset_attr(&a->eattrs, BA_AIGP);
+    bgp_unset_attr(to, BA_AIGP);
   }
 }
 
@@ -1735,14 +1735,14 @@ bgp_preexport(struct proto *P, rte *e)
 
     /* Generally, this should be handled when path is received, but we check it
        also here as rr_cluster_id may be undefined or different in src. */
-    if (p->rr_cluster_id && bgp_cluster_list_loopy(p, e->attrs->eattrs))
+    if (p->rr_cluster_id && bgp_cluster_list_loopy(p, e->attrs))
       return -1;
   }
 
   /* Handle well-known communities, RFC 1997 */
   struct eattr *c;
   if (p->cf->interpret_communities &&
-      (c = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_COMMUNITY))))
+      (c = ea_find(e->attrs, BGP_EA_ID(BA_COMMUNITY))))
   {
     const struct adata *d = c->u.ptr;
 
@@ -1893,7 +1893,7 @@ bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old)
 
   if (new)
   {
-    struct ea_list *attrs = bgp_update_attrs(p, c, new, new->attrs->eattrs, tmp_linpool);
+    struct ea_list *attrs = bgp_update_attrs(p, c, new, new->attrs, tmp_linpool);
 
     /* Error during attribute processing */
     if (!attrs)
@@ -1919,7 +1919,7 @@ bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old)
 static inline u32
 bgp_get_neighbor(rte *r)
 {
-  eattr *e = ea_find(r->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
+  eattr *e = ea_find(r->attrs, BGP_EA_ID(BA_AS_PATH));
   u32 as;
 
   if (e && as_path_get_first_regular(e->u.ptr, &as))
@@ -1940,7 +1940,7 @@ rte_stale(rte *r)
     return 0;
 
   /* If staleness is unknown, compute and cache it */
-  eattr *a = ea_find(r->attrs->eattrs, BGP_EA_ID(BA_COMMUNITY));
+  eattr *a = ea_find(r->attrs, BGP_EA_ID(BA_COMMUNITY));
   if (a && int_set_contains(a->u.ptr, BGP_COMM_LLGR_STALE))
   {
     r->pflags |= BGP_REF_STALE;
@@ -1986,8 +1986,8 @@ bgp_rte_better(rte *new, rte *old)
     return 1;
 
  /* Start with local preferences */
-  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
-  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
+  x = ea_find(new->attrs, BGP_EA_ID(BA_LOCAL_PREF));
+  y = ea_find(old->attrs, BGP_EA_ID(BA_LOCAL_PREF));
   n = x ? x->u.data : new_bgp->cf->default_local_pref;
   o = y ? y->u.data : old_bgp->cf->default_local_pref;
   if (n > o)
@@ -2006,8 +2006,8 @@ bgp_rte_better(rte *new, rte *old)
   /* RFC 4271 9.1.2.2. a)  Use AS path lengths */
   if (new_bgp->cf->compare_path_lengths || old_bgp->cf->compare_path_lengths)
   {
-    x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
-    y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
+    x = ea_find(new->attrs, BGP_EA_ID(BA_AS_PATH));
+    y = ea_find(old->attrs, BGP_EA_ID(BA_AS_PATH));
     n = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
     o = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
     if (n < o)
@@ -2017,8 +2017,8 @@ bgp_rte_better(rte *new, rte *old)
   }
 
   /* RFC 4271 9.1.2.2. b) Use origins */
-  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
-  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
+  x = ea_find(new->attrs, BGP_EA_ID(BA_ORIGIN));
+  y = ea_find(old->attrs, BGP_EA_ID(BA_ORIGIN));
   n = x ? x->u.data : ORIGIN_INCOMPLETE;
   o = y ? y->u.data : ORIGIN_INCOMPLETE;
   if (n < o)
@@ -2040,8 +2040,8 @@ bgp_rte_better(rte *new, rte *old)
   if (new_bgp->cf->med_metric || old_bgp->cf->med_metric ||
       (bgp_get_neighbor(new) == bgp_get_neighbor(old)))
   {
-    x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
-    y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
+    x = ea_find(new->attrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
+    y = ea_find(old->attrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
     n = x ? x->u.data : new_bgp->cf->default_med;
     o = y ? y->u.data : old_bgp->cf->default_med;
     if (n < o)
@@ -2066,8 +2066,8 @@ bgp_rte_better(rte *new, rte *old)
 
   /* RFC 4271 9.1.2.2. f) Compare BGP identifiers */
   /* RFC 4456 9. a) Use ORIGINATOR_ID instead of local neighbor ID */
-  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_ORIGINATOR_ID));
-  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_ORIGINATOR_ID));
+  x = ea_find(new->attrs, BGP_EA_ID(BA_ORIGINATOR_ID));
+  y = ea_find(old->attrs, BGP_EA_ID(BA_ORIGINATOR_ID));
   n = x ? x->u.data : new_bgp->remote_id;
   o = y ? y->u.data : old_bgp->remote_id;
 
@@ -2084,8 +2084,8 @@ bgp_rte_better(rte *new, rte *old)
     return 0;
 
   /* RFC 4456 9. b) Compare cluster list lengths */
-  x = ea_find(new->attrs->eattrs, BGP_EA_ID(BA_CLUSTER_LIST));
-  y = ea_find(old->attrs->eattrs, BGP_EA_ID(BA_CLUSTER_LIST));
+  x = ea_find(new->attrs, BGP_EA_ID(BA_CLUSTER_LIST));
+  y = ea_find(old->attrs, BGP_EA_ID(BA_CLUSTER_LIST));
   n = x ? int_set_get_size(x->u.ptr) : 0;
   o = y ? int_set_get_size(y->u.ptr) : 0;
   if (n < o)
@@ -2119,8 +2119,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
     return 0;
 
   /* Start with local preferences */
-  x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
-  y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_LOCAL_PREF));
+  x = ea_find(pri->attrs, BGP_EA_ID(BA_LOCAL_PREF));
+  y = ea_find(sec->attrs, BGP_EA_ID(BA_LOCAL_PREF));
   p = x ? x->u.data : pri_bgp->cf->default_local_pref;
   s = y ? y->u.data : sec_bgp->cf->default_local_pref;
   if (p != s)
@@ -2129,8 +2129,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
   /* RFC 4271 9.1.2.2. a)  Use AS path lengths */
   if (pri_bgp->cf->compare_path_lengths || sec_bgp->cf->compare_path_lengths)
   {
-    x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
-    y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
+    x = ea_find(pri->attrs, BGP_EA_ID(BA_AS_PATH));
+    y = ea_find(sec->attrs, BGP_EA_ID(BA_AS_PATH));
     p = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
     s = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
 
@@ -2142,8 +2142,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
   }
 
   /* RFC 4271 9.1.2.2. b) Use origins */
-  x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
-  y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
+  x = ea_find(pri->attrs, BGP_EA_ID(BA_ORIGIN));
+  y = ea_find(sec->attrs, BGP_EA_ID(BA_ORIGIN));
   p = x ? x->u.data : ORIGIN_INCOMPLETE;
   s = y ? y->u.data : ORIGIN_INCOMPLETE;
   if (p != s)
@@ -2153,8 +2153,8 @@ bgp_rte_mergable(rte *pri, rte *sec)
   if (pri_bgp->cf->med_metric || sec_bgp->cf->med_metric ||
       (bgp_get_neighbor(pri) == bgp_get_neighbor(sec)))
   {
-    x = ea_find(pri->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
-    y = ea_find(sec->attrs->eattrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
+    x = ea_find(pri->attrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
+    y = ea_find(sec->attrs, BGP_EA_ID(BA_MULTI_EXIT_DISC));
     p = x ? x->u.data : pri_bgp->cf->default_med;
     s = y ? y->u.data : sec_bgp->cf->default_med;
     if (p != s)
@@ -2320,7 +2320,7 @@ bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best)
 struct rte *
 bgp_rte_modify_stale(struct rte *r, struct linpool *pool)
 {
-  eattr *a = ea_find(r->attrs->eattrs, BGP_EA_ID(BA_COMMUNITY));
+  eattr *a = ea_find(r->attrs, BGP_EA_ID(BA_COMMUNITY));
   const struct adata *ad = a ? a->u.ptr : NULL;
   uint flags = a ? a->flags : BAF_PARTIAL;
 
@@ -2330,8 +2330,8 @@ bgp_rte_modify_stale(struct rte *r, struct linpool *pool)
   if (ad && int_set_contains(ad, BGP_COMM_LLGR_STALE))
     return r;
 
-  r = rte_cow_rta(r, pool);
-  bgp_set_attr_ptr(&(r->attrs->eattrs), BA_COMMUNITY, flags,
+  r = rte_cow_rta(r);
+  bgp_set_attr_ptr(&(r->attrs), BA_COMMUNITY, flags,
 		   int_set_add(pool, ad, BGP_COMM_LLGR_STALE));
   r->pflags |= BGP_REF_STALE;
 
@@ -2388,8 +2388,8 @@ bgp_process_as4_attrs(ea_list **attrs, struct linpool *pool)
 void
 bgp_get_route_info(rte *e, byte *buf)
 {
-  eattr *p = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_AS_PATH));
-  eattr *o = ea_find(e->attrs->eattrs, BGP_EA_ID(BA_ORIGIN));
+  eattr *p = ea_find(e->attrs, BGP_EA_ID(BA_AS_PATH));
+  eattr *o = ea_find(e->attrs, BGP_EA_ID(BA_ORIGIN));
   u32 origas;
 
   buf += bsprintf(buf, " (%d", rt_get_preference(e));
diff --git a/proto/bgp/bgp.h b/proto/bgp/bgp.h
index 2f98dc1b..376b463f 100644
--- a/proto/bgp/bgp.h
+++ b/proto/bgp/bgp.h
@@ -67,10 +67,10 @@ struct bgp_af_desc {
   u8 no_igp;
   const char *name;
   uint (*encode_nlri)(struct bgp_write_state *s, struct bgp_bucket *buck, byte *buf, uint size);
-  void (*decode_nlri)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
+  void (*decode_nlri)(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a);
   void (*update_next_hop)(struct bgp_export_state *s, eattr *nh, ea_list **to);
   uint (*encode_next_hop)(struct bgp_write_state *s, eattr *nh, byte *buf, uint size);
-  void (*decode_next_hop)(struct bgp_parse_state *s, byte *pos, uint len, rta *a);
+  void (*decode_next_hop)(struct bgp_parse_state *s, byte *pos, uint len, ea_list **to);
 };
 
 
@@ -461,7 +461,7 @@ struct bgp_parse_state {
   /* Cached state for bgp_rte_update() */
   u32 last_id;
   struct rte_src *last_src;
-  rta *cached_rta;
+  ea_list *cached_ea;
 };
 
 #define BGP_PORT		179
@@ -519,7 +519,7 @@ struct rte_source *bgp_get_source(struct bgp_proto *p, u32 path_id);
 static inline int
 rte_resolvable(rte *rt)
 {
-  eattr *nhea = ea_find(rt->attrs->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(rt->attrs, &ea_gen_nexthop);
   struct nexthop_adata *nhad = (void *) nhea->u.ptr;
   return NEXTHOP_IS_REACHABLE(nhad) || (nhad->dest != RTD_UNREACHABLE);
 }
@@ -551,7 +551,7 @@ int bgp_encode_mp_reach_mrt(struct bgp_write_state *s, eattr *a, byte *buf, uint
 
 int bgp_encode_attrs(struct bgp_write_state *s, ea_list *attrs, byte *buf, byte *end);
 ea_list * bgp_decode_attrs(struct bgp_parse_state *s, byte *data, uint len);
-void bgp_finish_attrs(struct bgp_parse_state *s, rta *a);
+void bgp_finish_attrs(struct bgp_parse_state *s, ea_list **to);
 
 void bgp_init_bucket_table(struct bgp_channel *c);
 void bgp_free_bucket_table(struct bgp_channel *c);
diff --git a/proto/bgp/packets.c b/proto/bgp/packets.c
index 4c46c60e..e72ec222 100644
--- a/proto/bgp/packets.c
+++ b/proto/bgp/packets.c
@@ -943,7 +943,7 @@ bgp_rx_open(struct bgp_conn *conn, byte *pkt, uint len)
 #define MISMATCHED_AF	" - mismatched address family (%I for %s)"
 
 static void
-bgp_apply_next_hop(struct bgp_parse_state *s, rta *a, ip_addr gw, ip_addr ll)
+bgp_apply_next_hop(struct bgp_parse_state *s, ea_list **to, ip_addr gw, ip_addr ll)
 {
   struct bgp_proto *p = s->proto;
   struct bgp_channel *c = s->channel;
@@ -966,7 +966,7 @@ bgp_apply_next_hop(struct bgp_parse_state *s, rta *a, ip_addr gw, ip_addr ll)
     if (nbr->scope == SCOPE_HOST)
       WITHDRAW(BAD_NEXT_HOP " - address %I is local", nbr->addr);
 
-    ea_set_attr_u32(&a->eattrs, &ea_gen_igp_metric, 0, c->cf->cost);
+    ea_set_attr_u32(to, &ea_gen_igp_metric, 0, c->cf->cost);
 
     struct nexthop_adata nhad = {
       .nh = {
@@ -977,7 +977,7 @@ bgp_apply_next_hop(struct bgp_parse_state *s, rta *a, ip_addr gw, ip_addr ll)
 	.length = sizeof nhad - sizeof nhad.ad,
       },
     };
-    ea_set_attr_data(&a->eattrs, &ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length);
+    ea_set_attr_data(to, &ea_gen_nexthop, 0, nhad.ad.data, nhad.ad.length);
   }
   else /* GW_RECURSIVE */
   {
@@ -988,21 +988,21 @@ bgp_apply_next_hop(struct bgp_parse_state *s, rta *a, ip_addr gw, ip_addr ll)
     if (s->mpls)
     {
       u32 labels[BGP_MPLS_MAX];
-      ea_set_hostentry(&a->eattrs, c->c.table, tab, gw, ll, BGP_MPLS_MAX, labels);
+      ea_set_hostentry(to, c->c.table, tab, gw, ll, BGP_MPLS_MAX, labels);
     }
     else
-      ea_set_hostentry(&a->eattrs, c->c.table, tab, gw, ll, 0, NULL);
+      ea_set_hostentry(to, c->c.table, tab, gw, ll, 0, NULL);
   }
 }
 
 static void
-bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a, u32 lnum, u32 labels[lnum])
+bgp_apply_mpls_labels(struct bgp_parse_state *s, ea_list **to, u32 lnum, u32 labels[lnum])
 {
   if (lnum > MPLS_MAX_LABEL_STACK)
   {
     REPORT("Too many MPLS labels ($u)", lnum);
 
-    ea_set_dest(&a->eattrs, 0, RTD_UNREACHABLE);
+    ea_set_dest(to, 0, RTD_UNREACHABLE);
     return;
   }
 
@@ -1012,7 +1012,7 @@ bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a, u32 lnum, u32 labels[ln
 
   if (s->channel->cf->gw_mode == GW_DIRECT)
   {
-    eattr *e = ea_find(a->eattrs, &ea_gen_nexthop);
+    eattr *e = ea_find(*to, &ea_gen_nexthop);
     struct {
       struct nexthop_adata nhad;
       u32 labels[MPLS_MAX_LABEL_STACK];
@@ -1025,7 +1025,7 @@ bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a, u32 lnum, u32 labels[ln
   }
   else /* GW_RECURSIVE */
   {
-    eattr *e = ea_find(a->eattrs, &ea_gen_hostentry);
+    eattr *e = ea_find(*to, &ea_gen_hostentry);
     ASSERT_DIE(e);
     struct hostentry_adata *head = (void *) e->u.ptr;
     memcpy(&head->labels, labels, lnum * sizeof(u32));
@@ -1034,24 +1034,24 @@ bgp_apply_mpls_labels(struct bgp_parse_state *s, rta *a, u32 lnum, u32 labels[ln
 }
 
 static void
-bgp_apply_flow_validation(struct bgp_parse_state *s, const net_addr *n, rta *a)
+bgp_apply_flow_validation(struct bgp_parse_state *s, const net_addr *n, ea_list **to)
 {
   struct bgp_channel *c = s->channel;
-  uint valid = rt_flowspec_check(c->base_table, c->c.table, n, a, s->proto->is_interior);
+  uint valid = rt_flowspec_check(c->base_table, c->c.table, n, *to, s->proto->is_interior);
 
   /* Invalidate cached rta */
-  if (s->cached_rta)
+  if (s->cached_ea)
   {
     /* Has't changed */
-    if (valid == ea_get_int(s->cached_rta->eattrs, &ea_gen_flowspec_valid, FLOWSPEC_UNKNOWN))
+    if (valid == ea_get_int(s->cached_ea, &ea_gen_flowspec_valid, FLOWSPEC_UNKNOWN))
       return;
 
-    rta_free(s->cached_rta);
-    s->cached_rta = NULL;
+    rta_free(s->cached_ea);
+    s->cached_ea = NULL;
   }
 
   /* Set the value */
-  ea_set_attr_u32(&a->eattrs, &ea_gen_flowspec_valid, 0, valid);
+  ea_set_attr_u32(to, &ea_gen_flowspec_valid, 0, valid);
 }
 
 static int
@@ -1105,13 +1105,13 @@ bgp_use_gateway(struct bgp_export_state *s)
 {
   struct bgp_proto *p = s->proto;
   struct bgp_channel *c = s->channel;
-  rta *ra = s->route->attrs;
+  ea_list *ra = s->route->attrs;
 
   /* Handle next hop self option - also applies to gateway */
   if (c->cf->next_hop_self && bgp_match_src(s, c->cf->next_hop_self))
     return NULL;
 
-  eattr *nhea = ea_find(ra->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(ra, &ea_gen_nexthop);
   if (!nhea)
     return NULL;
 
@@ -1229,7 +1229,7 @@ bgp_encode_next_hop_ip(struct bgp_write_state *s, eattr *a, byte *buf, uint size
 }
 
 static void
-bgp_decode_next_hop_ip(struct bgp_parse_state *s, byte *data, uint len, rta *a)
+bgp_decode_next_hop_ip(struct bgp_parse_state *s, byte *data, uint len, ea_list **to)
 {
   struct bgp_channel *c = s->channel;
   struct adata *ad = lp_alloc_adata(s->pool, 32);
@@ -1270,8 +1270,8 @@ bgp_decode_next_hop_ip(struct bgp_parse_state *s, byte *data, uint len, rta *a)
 
   // XXXX validate next hop
 
-  bgp_set_attr_ptr(&(a->eattrs), BA_NEXT_HOP, 0, ad);
-  bgp_apply_next_hop(s, a, nh[0], nh[1]);
+  bgp_set_attr_ptr(to, BA_NEXT_HOP, 0, ad);
+  bgp_apply_next_hop(s, to, nh[0], nh[1]);
 }
 
 static uint
@@ -1309,7 +1309,7 @@ bgp_encode_next_hop_vpn(struct bgp_write_state *s, eattr *a, byte *buf, uint siz
 }
 
 static void
-bgp_decode_next_hop_vpn(struct bgp_parse_state *s, byte *data, uint len, rta *a)
+bgp_decode_next_hop_vpn(struct bgp_parse_state *s, byte *data, uint len, ea_list **to)
 {
   struct bgp_channel *c = s->channel;
   struct adata *ad = lp_alloc_adata(s->pool, 32);
@@ -1351,8 +1351,8 @@ bgp_decode_next_hop_vpn(struct bgp_parse_state *s, byte *data, uint len, rta *a)
 
   // XXXX validate next hop
 
-  bgp_set_attr_ptr(&(a->eattrs), BA_NEXT_HOP, 0, ad);
-  bgp_apply_next_hop(s, a, nh[0], nh[1]);
+  bgp_set_attr_ptr(to, BA_NEXT_HOP, 0, ad);
+  bgp_apply_next_hop(s, to, nh[0], nh[1]);
 }
 
 
@@ -1364,7 +1364,7 @@ bgp_encode_next_hop_none(struct bgp_write_state *s UNUSED, eattr *a UNUSED, byte
 }
 
 static void
-bgp_decode_next_hop_none(struct bgp_parse_state *s UNUSED, byte *data UNUSED, uint len UNUSED, rta *a UNUSED)
+bgp_decode_next_hop_none(struct bgp_parse_state *s UNUSED, byte *data UNUSED, uint len UNUSED, ea_list **to UNUSED)
 {
   /*
    * Although we expect no next hop and RFC 7606 7.11 states that attribute
@@ -1389,15 +1389,15 @@ bgp_update_next_hop_none(struct bgp_export_state *s UNUSED, eattr *a, ea_list **
  */
 
 static void
-bgp_rte_update(struct bgp_parse_state *s, const net_addr *n, u32 path_id, rta *a0)
+bgp_rte_update(struct bgp_parse_state *s, const net_addr *n, u32 path_id, ea_list *a0)
 {
   if (path_id != s->last_id)
   {
     s->last_src = rt_get_source(&s->proto->p, path_id);
     s->last_id = path_id;
 
-    rta_free(s->cached_rta);
-    s->cached_rta = NULL;
+    ea_free(s->cached_ea);
+    s->cached_ea = NULL;
   }
 
   if (!a0)
@@ -1412,16 +1412,10 @@ bgp_rte_update(struct bgp_parse_state *s, const net_addr *n, u32 path_id, rta *a
   }
 
   /* Prepare cached route attributes */
-  if (s->cached_rta == NULL)
-  {
-    /* Workaround for rta_lookup() breaking eattrs */
-    ea_list *ea = a0->eattrs;
-    s->cached_rta = rta_lookup(a0);
-    a0->eattrs = ea;
-  }
+  if (s->cached_ea == NULL)
+    s->cached_ea = ea_lookup(a0);
 
-  rta *a = rta_clone(s->cached_rta);
-  rte *e = rte_get_temp(a, s->last_src);
+  rte *e = rte_get_temp(rta_clone(s->cached_ea), s->last_src);
 
   e->pflags = 0;
   rte_update3(&s->channel->c, n, e, s->last_src);
@@ -1447,7 +1441,7 @@ bgp_encode_mpls_labels(struct bgp_write_state *s UNUSED, const adata *mpls, byte
 }
 
 static void
-bgp_decode_mpls_labels(struct bgp_parse_state *s, byte **pos, uint *len, uint *pxlen, rta *a)
+bgp_decode_mpls_labels(struct bgp_parse_state *s, byte **pos, uint *len, uint *pxlen, ea_list **to)
 {
   u32 labels[BGP_MPLS_MAX];
   u32 label;
@@ -1469,15 +1463,15 @@ bgp_decode_mpls_labels(struct bgp_parse_state *s, byte **pos, uint *len, uint *p
   }
   while (!(label & BGP_MPLS_BOS));
 
-  if (!a)
+  if (!*to)
     return;
 
   /* Update next hop entry in rta */
-  bgp_apply_mpls_labels(s, a, lnum, labels);
+  bgp_apply_mpls_labels(s, to, lnum, labels);
 
   /* Attributes were changed, invalidate cached entry */
-  rta_free(s->cached_rta);
-  s->cached_rta = NULL;
+  rta_free(s->cached_ea);
+  s->cached_ea = NULL;
 
   return;
 }
@@ -1520,7 +1514,7 @@ bgp_encode_nlri_ip4(struct bgp_write_state *s, struct bgp_bucket *buck, byte *bu
 }
 
 static void
-bgp_decode_nlri_ip4(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
+bgp_decode_nlri_ip4(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a)
 {
   while (len)
   {
@@ -1546,7 +1540,7 @@ bgp_decode_nlri_ip4(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
 
     /* Decode MPLS labels */
     if (s->mpls)
-      bgp_decode_mpls_labels(s, &pos, &len, &l, a);
+      bgp_decode_mpls_labels(s, &pos, &len, &l, &a);
 
     if (l > IP4_MAX_PREFIX_LENGTH)
       bgp_parse_error(s, 10);
@@ -1605,7 +1599,7 @@ bgp_encode_nlri_ip6(struct bgp_write_state *s, struct bgp_bucket *buck, byte *bu
 }
 
 static void
-bgp_decode_nlri_ip6(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
+bgp_decode_nlri_ip6(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a)
 {
   while (len)
   {
@@ -1631,7 +1625,7 @@ bgp_decode_nlri_ip6(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
 
     /* Decode MPLS labels */
     if (s->mpls)
-      bgp_decode_mpls_labels(s, &pos, &len, &l, a);
+      bgp_decode_mpls_labels(s, &pos, &len, &l, &a);
 
     if (l > IP6_MAX_PREFIX_LENGTH)
       bgp_parse_error(s, 10);
@@ -1693,7 +1687,7 @@ bgp_encode_nlri_vpn4(struct bgp_write_state *s, struct bgp_bucket *buck, byte *b
 }
 
 static void
-bgp_decode_nlri_vpn4(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
+bgp_decode_nlri_vpn4(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a)
 {
   while (len)
   {
@@ -1719,7 +1713,7 @@ bgp_decode_nlri_vpn4(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
 
     /* Decode MPLS labels */
     if (s->mpls)
-      bgp_decode_mpls_labels(s, &pos, &len, &l, a);
+      bgp_decode_mpls_labels(s, &pos, &len, &l, &a);
 
     /* Decode route distinguisher */
     if (l < 64)
@@ -1790,7 +1784,7 @@ bgp_encode_nlri_vpn6(struct bgp_write_state *s, struct bgp_bucket *buck, byte *b
 }
 
 static void
-bgp_decode_nlri_vpn6(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
+bgp_decode_nlri_vpn6(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a)
 {
   while (len)
   {
@@ -1816,7 +1810,7 @@ bgp_decode_nlri_vpn6(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
 
     /* Decode MPLS labels */
     if (s->mpls)
-      bgp_decode_mpls_labels(s, &pos, &len, &l, a);
+      bgp_decode_mpls_labels(s, &pos, &len, &l, &a);
 
     /* Decode route distinguisher */
     if (l < 64)
@@ -1877,7 +1871,7 @@ bgp_encode_nlri_flow4(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
 }
 
 static void
-bgp_decode_nlri_flow4(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
+bgp_decode_nlri_flow4(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a)
 {
   while (len)
   {
@@ -1930,7 +1924,7 @@ bgp_decode_nlri_flow4(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
 
     /* Apply validation procedure per RFC 8955 (6) */
     if (a && s->channel->cf->validate)
-      bgp_apply_flow_validation(s, n, a);
+      bgp_apply_flow_validation(s, n, &a);
 
     bgp_rte_update(s, n, path_id, a);
   }
@@ -1969,7 +1963,7 @@ bgp_encode_nlri_flow6(struct bgp_write_state *s, struct bgp_bucket *buck, byte *
 }
 
 static void
-bgp_decode_nlri_flow6(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
+bgp_decode_nlri_flow6(struct bgp_parse_state *s, byte *pos, uint len, ea_list *a)
 {
   while (len)
   {
@@ -2022,7 +2016,7 @@ bgp_decode_nlri_flow6(struct bgp_parse_state *s, byte *pos, uint len, rta *a)
 
     /* Apply validation procedure per RFC 8955 (6) */
     if (a && s->channel->cf->validate)
-      bgp_apply_flow_validation(s, n, a);
+      bgp_apply_flow_validation(s, n, &a);
 
     bgp_rte_update(s, n, path_id, a);
   }
@@ -2472,7 +2466,6 @@ static inline void
 bgp_decode_nlri(struct bgp_parse_state *s, u32 afi, byte *nlri, uint len, ea_list *ea, byte *nh, uint nh_len)
 {
   struct bgp_channel *c = bgp_get_channel(s->proto, afi);
-  rta *a = NULL;
 
   if (!c)
     DISCARD(BAD_AFI, BGP_AFI(afi), BGP_SAFI(afi));
@@ -2493,26 +2486,22 @@ bgp_decode_nlri(struct bgp_parse_state *s, u32 afi, byte *nlri, uint len, ea_lis
 
   if (ea)
   {
-    a = allocz(RTA_MAX_SIZE);
-
-    a->eattrs = ea;
-
-    ea_set_attr_data(&a->eattrs, &ea_gen_from, 0, &s->proto->remote_ip, sizeof(ip_addr));
-    ea_set_attr_u32(&a->eattrs, &ea_gen_preference, 0, c->c.preference);
-    ea_set_attr_u32(&a->eattrs, &ea_gen_source, 0, RTS_BGP);
+    ea_set_attr_data(&ea, &ea_gen_from, 0, &s->proto->remote_ip, sizeof(ip_addr));
+    ea_set_attr_u32(&ea, &ea_gen_preference, 0, c->c.preference);
+    ea_set_attr_u32(&ea, &ea_gen_source, 0, RTS_BGP);
 
-    c->desc->decode_next_hop(s, nh, nh_len, a);
-    bgp_finish_attrs(s, a);
+    c->desc->decode_next_hop(s, nh, nh_len, &ea);
+    bgp_finish_attrs(s, &ea);
 
     /* Handle withdraw during next hop decoding */
     if (s->err_withdraw)
-      a = NULL;
+      ea = NULL;
   }
 
-  c->desc->decode_nlri(s, nlri, len, a);
+  c->desc->decode_nlri(s, nlri, len, ea);
 
-  rta_free(s->cached_rta);
-  s->cached_rta = NULL;
+  rta_free(s->cached_ea);
+  s->cached_ea = NULL;
 }
 
 static void
@@ -2617,7 +2606,7 @@ bgp_rx_update(struct bgp_conn *conn, byte *pkt, uint len)
 		    ea, s.mp_next_hop_data, s.mp_next_hop_len);
 
 done:
-  rta_free(s.cached_rta);
+  rta_free(s.cached_ea);
   lp_restore(tmp_linpool, &tmpp);
   return;
 }
diff --git a/proto/mrt/mrt.c b/proto/mrt/mrt.c
index e45f7cb7..7b6e7772 100644
--- a/proto/mrt/mrt.c
+++ b/proto/mrt/mrt.c
@@ -423,7 +423,7 @@ mrt_rib_table_header(struct mrt_table_dump_state *s, net_addr *n)
 static void
 mrt_rib_table_entry_bgp_attrs(struct mrt_table_dump_state *s, rte *r)
 {
-  struct ea_list *eattrs = r->attrs->eattrs;
+  struct ea_list *eattrs = r->attrs;
   buffer *b = &s->buf;
 
   if (!eattrs)
diff --git a/proto/ospf/ospf.c b/proto/ospf/ospf.c
index 731adaa5..87911531 100644
--- a/proto/ospf/ospf.c
+++ b/proto/ospf/ospf.c
@@ -387,7 +387,7 @@ ospf_init(struct proto_config *CF)
 static int
 ospf_rte_better(struct rte *new, struct rte *old)
 {
-  u32 new_metric1 = ea_get_int(new->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
+  u32 new_metric1 = ea_get_int(new->attrs, &ea_ospf_metric1, LSINFINITY);
 
   if (new_metric1 == LSINFINITY)
     return 0;
@@ -400,13 +400,13 @@ ospf_rte_better(struct rte *new, struct rte *old)
 
   if (ns == RTS_OSPF_EXT2)
   {
-    u32 old_metric2 = ea_get_int(old->attrs->eattrs, &ea_ospf_metric2, LSINFINITY);
-    u32 new_metric2 = ea_get_int(new->attrs->eattrs, &ea_ospf_metric2, LSINFINITY);
+    u32 old_metric2 = ea_get_int(old->attrs, &ea_ospf_metric2, LSINFINITY);
+    u32 new_metric2 = ea_get_int(new->attrs, &ea_ospf_metric2, LSINFINITY);
     if (new_metric2 < old_metric2) return 1;
     if (new_metric2 > old_metric2) return 0;
   }
 
-  u32 old_metric1 = ea_get_int(old->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
+  u32 old_metric1 = ea_get_int(old->attrs, &ea_ospf_metric1, LSINFINITY);
   if (new_metric1 < old_metric1)
     return 1;
 
@@ -419,7 +419,7 @@ ospf_rte_igp_metric(struct rte *rt)
   if (rt_get_source_attr(rt) == RTS_OSPF_EXT2)
     return IGP_METRIC_UNKNOWN;
 
-  return ea_get_int(rt->attrs->eattrs, &ea_ospf_metric1, LSINFINITY);
+  return ea_get_int(rt->attrs, &ea_ospf_metric1, LSINFINITY);
 }
 
 void
@@ -535,7 +535,7 @@ ospf_shutdown(struct proto *P)
   /* Cleanup locked rta entries */
   FIB_WALK(&p->rtf, ort, nf)
   {
-    rta_free(nf->old_rta);
+    ea_free(nf->old_ea);
   }
   FIB_WALK_END;
 
@@ -592,18 +592,18 @@ ospf_get_route_info(rte * rte, byte * buf)
   }
 
   buf += bsprintf(buf, " %s", type);
-  buf += bsprintf(buf, " (%d/%d", rt_get_preference(rte), ea_get_int(rte->attrs->eattrs, &ea_ospf_metric1, LSINFINITY));
+  buf += bsprintf(buf, " (%d/%d", rt_get_preference(rte), ea_get_int(rte->attrs, &ea_ospf_metric1, LSINFINITY));
   if (source == RTS_OSPF_EXT2)
-    buf += bsprintf(buf, "/%d", ea_get_int(rte->attrs->eattrs, &ea_ospf_metric2, LSINFINITY));
+    buf += bsprintf(buf, "/%d", ea_get_int(rte->attrs, &ea_ospf_metric2, LSINFINITY));
   buf += bsprintf(buf, ")");
   if (source == RTS_OSPF_EXT1 || source == RTS_OSPF_EXT2)
   {
-    eattr *ea = ea_find(rte->attrs->eattrs, &ea_ospf_tag);
+    eattr *ea = ea_find(rte->attrs, &ea_ospf_tag);
     if (ea && (ea->u.data > 0))
       buf += bsprintf(buf, " [%x]", ea->u.data);
   }
   
-  eattr *ea = ea_find(rte->attrs->eattrs, &ea_ospf_router_id);
+  eattr *ea = ea_find(rte->attrs, &ea_ospf_router_id);
   if (ea)
     buf += bsprintf(buf, " [%R]", ea->u.data);
 }
diff --git a/proto/ospf/rt.c b/proto/ospf/rt.c
index afe4a01f..3889d634 100644
--- a/proto/ospf/rt.c
+++ b/proto/ospf/rt.c
@@ -1977,17 +1977,17 @@ add_cand(struct ospf_area *oa, struct top_hash_entry *en, struct top_hash_entry
 }
 
 static inline int
-ort_changed(ort *nf, rta *nr)
+ort_changed(ort *nf, ea_list *nr)
 {
-  rta *or = nf->old_rta;
+  ea_list *or = nf->old_ea;
 
   if (!or ||
     (nf->n.metric1 != nf->old_metric1) || (nf->n.metric2 != nf->old_metric2) ||
     (nf->n.tag != nf->old_tag) || (nf->n.rid != nf->old_rid))
     return 1;
 
-  eattr *nhea_n = ea_find(nr->eattrs, &ea_gen_nexthop);
-  eattr *nhea_o = ea_find(or->eattrs, &ea_gen_nexthop);
+  eattr *nhea_n = ea_find(nr, &ea_gen_nexthop);
+  eattr *nhea_o = ea_find(or, &ea_gen_nexthop);
   if (!nhea_n != !nhea_o)
     return 1;
 
@@ -2000,8 +2000,8 @@ ort_changed(ort *nf, rta *nr)
       return 1;
   }
 
-  if (	ea_get_int(nr->eattrs, &ea_gen_source, 0)
-     != ea_get_int(or->eattrs, &ea_gen_source, 0))
+  if (	ea_get_int(nr, &ea_gen_source, 0)
+     != ea_get_int(or, &ea_gen_source, 0))
     return 1;
 
   return 0;
@@ -2047,9 +2047,6 @@ again1:
 
     if (nf->n.type) /* Add the route */
     {
-      rta a0 = {
-      };
-
       struct {
 	ea_list l;
 	eattr a[7];
@@ -2066,7 +2063,7 @@ again1:
       eattrs.a[eattrs.l.count++] =
 	EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, &nf->n.nhs->ad);
 
-      if (reload || ort_changed(nf, &a0))
+      if (reload || ort_changed(nf, &eattrs.l))
       {
 	nf->old_metric1 = nf->n.metric1;
 	nf->old_metric2 = nf->n.metric2;
@@ -2088,24 +2085,25 @@ again1:
 	  EA_LITERAL_EMBEDDED(&ea_ospf_router_id, 0, nf->n.rid);
 
 	ASSERT_DIE(ARRAY_SIZE(eattrs.a) >= eattrs.l.count);
-	a0.eattrs = &eattrs.l;
 
-	rta *a = rta_lookup(&a0);
+	ea_list *a = rta_lookup(&eattrs.l);
 	rte *e = rte_get_temp(a, p->p.main_source);
 
-	rta_free(nf->old_rta);
-	nf->old_rta = rta_clone(a);
+	rta_free(nf->old_ea);
+	nf->old_ea = rta_clone(a);
 
+	/*
 	DBG("Mod rte type %d - %N via %I on iface %s, met %d\n",
 	    a0.source, nf->fn.addr, a0.gw, a0.iface ? a0.iface->name : "(none)", nf->n.metric1);
+	    */
 	rte_update(&p->p, nf->fn.addr, e);
       }
     }
-    else if (nf->old_rta)
+    else if (nf->old_ea)
     {
       /* Remove the route */
-      rta_free(nf->old_rta);
-      nf->old_rta = NULL;
+      rta_free(nf->old_ea);
+      nf->old_ea = NULL;
 
       rte_update(&p->p, nf->fn.addr, NULL);
     }
diff --git a/proto/ospf/rt.h b/proto/ospf/rt.h
index 180216b7..88eefef9 100644
--- a/proto/ospf/rt.h
+++ b/proto/ospf/rt.h
@@ -78,7 +78,7 @@ typedef struct ort
    */
   orta n;
   u32 old_metric1, old_metric2, old_tag, old_rid;
-  rta *old_rta;
+  ea_list *old_ea;
   u32 lsa_id;
   u8 external_rte;
   u8 area_net;
diff --git a/proto/ospf/topology.c b/proto/ospf/topology.c
index 09ec9f28..e3dd0885 100644
--- a/proto/ospf/topology.c
+++ b/proto/ospf/topology.c
@@ -1337,9 +1337,9 @@ ospf_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
   ASSERT(p->asbr);
 
   /* Get route attributes */
-  rta *a = new->attrs;
-  eattr *m1a = ea_find(a->eattrs, &ea_ospf_metric1);
-  eattr *m2a = ea_find(a->eattrs, &ea_ospf_metric2);
+  ea_list *a = new->attrs;
+  eattr *m1a = ea_find(a, &ea_ospf_metric1);
+  eattr *m2a = ea_find(a, &ea_ospf_metric2);
   uint m1 = m1a ? m1a->u.data : 0;
   uint m2 = m2a ? m2a->u.data : 10000;
 
@@ -1363,10 +1363,10 @@ ospf_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
 
   uint ebit = m2a || !m1a;
   uint metric = ebit ? m2 : m1;
-  uint tag = ea_get_int(a->eattrs, &ea_ospf_tag, 0);
+  uint tag = ea_get_int(a, &ea_ospf_tag, 0);
 
   ip_addr fwd = IPA_NONE;
-  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(a, &ea_gen_nexthop);
   if (nhea)
   {
     struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
diff --git a/proto/perf/perf.c b/proto/perf/perf.c
index d1ff6adf..17e4041b 100644
--- a/proto/perf/perf.c
+++ b/proto/perf/perf.c
@@ -85,7 +85,7 @@ random_net_ip4(void)
 }
 
 struct perf_random_routes {
-  struct rta *a;
+  ea_list *a;
   net_addr net;
 };
 
@@ -142,10 +142,10 @@ perf_loop(void *data)
     *((net_addr_ip4 *) &(p->data[i].net)) = random_net_ip4();
 
     if (!p->attrs_per_rte || !(i % p->attrs_per_rte)) {
-      struct rta a0 = {};
+      ea_list *ea = NULL;
 
-      ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
-      ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_PERF);
+      ea_set_attr_u32(&ea, &ea_gen_preference, 0, p->p.main_channel->preference);
+      ea_set_attr_u32(&ea, &ea_gen_source, 0, RTS_PERF);
 
       struct nexthop_adata nhad = {
 	.nh.iface = p->ifa->iface,
@@ -153,10 +153,10 @@ perf_loop(void *data)
 	.nh.weight = 1,
       };
 
-      ea_set_attr_data(&a0.eattrs, &ea_gen_nexthop, 0,
+      ea_set_attr_data(&ea, &ea_gen_nexthop, 0,
 	  &nhad.ad.data, sizeof nhad - sizeof nhad.ad);
 
-      p->data[i].a = rta_lookup(&a0);
+      p->data[i].a = rta_lookup(ea);
     }
     else
       p->data[i].a = rta_clone(p->data[i-1].a);
diff --git a/proto/pipe/pipe.c b/proto/pipe/pipe.c
index e458a238..bdffed3b 100644
--- a/proto/pipe/pipe.c
+++ b/proto/pipe/pipe.c
@@ -55,7 +55,6 @@ pipe_rt_notify(struct proto *P, struct channel *src_ch, net *n, rte *new, rte *o
   struct rte_src *src;
 
   rte *e;
-  rta *a;
 
   if (!new && !old)
     return;
@@ -71,11 +70,8 @@ pipe_rt_notify(struct proto *P, struct channel *src_ch, net *n, rte *new, rte *o
     {
       src = new->src;
 
-      a = alloca(rta_size(new->attrs));
-      memcpy(a, new->attrs, rta_size(new->attrs));
-
-      a->cached = 0;
-      ea_unset_attr(&a->eattrs, 0, &ea_gen_hostentry);
+      ea_list *a = new->attrs;
+      ea_unset_attr(&a, 0, &ea_gen_hostentry);
 
       e = rte_get_temp(a, src);
       e->pflags = new->pflags;
diff --git a/proto/radv/radv.c b/proto/radv/radv.c
index 5734dbc9..c0715b68 100644
--- a/proto/radv/radv.c
+++ b/proto/radv/radv.c
@@ -447,11 +447,11 @@ radv_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte
   {
     /* Update */
 
-    ea = ea_find(new->attrs->eattrs, &ea_radv_preference);
+    ea = ea_find(new->attrs, &ea_radv_preference);
     uint preference = ea ? ea->u.data : RA_PREF_MEDIUM;
     uint preference_set = !!ea;
 
-    ea = ea_find(new->attrs->eattrs, &ea_radv_lifetime);
+    ea = ea_find(new->attrs, &ea_radv_lifetime);
     uint lifetime = ea ? ea->u.data : 0;
     uint lifetime_set = !!ea;
 
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index a0f2fdc0..ce452ac7 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -151,8 +151,6 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
   if (rt)
   {
     /* Update */
-    rta a0 = {};
-
     struct {
       ea_list l;
       eattr a[3];
@@ -164,7 +162,8 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 	EA_LITERAL_EMBEDDED(&ea_rip_metric, 0, rt->metric),
       },
     };
-    a0.eattrs = &ea_block.l;
+
+    ea_list *ea = &ea_block.l;
 
     u16 rt_tag = rt->tag;
     struct iface *rt_from = NULL;
@@ -203,7 +202,7 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 
       nhad->ad.length = ((void *) nh - (void *) nhad->ad.data);
 
-      ea_set_attr(&a0.eattrs,
+      ea_set_attr(&ea,
 	  EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0,
 	    &(nexthop_sort(nhad, tmp_linpool)->ad)));
     }
@@ -217,22 +216,21 @@ rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
 	.nh.iface = rt->from->ifa->iface,
       };
 
-      ea_set_attr_data(&a0.eattrs, &ea_gen_nexthop, 0,
+      ea_set_attr_data(&ea, &ea_gen_nexthop, 0,
 	  &nhad.ad.data, sizeof nhad - sizeof nhad.ad);
-      ea_set_attr_data(&a0.eattrs, &ea_gen_from, 0, &rt->from->nbr->addr, sizeof(ip_addr));
+      ea_set_attr_data(&ea, &ea_gen_from, 0, &rt->from->nbr->addr, sizeof(ip_addr));
     }
 
-    ea_set_attr_u32(&a0.eattrs, &ea_rip_tag, 0, rt_tag);
+    ea_set_attr_u32(&ea, &ea_rip_tag, 0, rt_tag);
 
     struct rip_iface_adata riad = {
       .ad = { .length = sizeof(struct rip_iface_adata) - sizeof(struct adata) },
       .iface = rt_from,
     };
-    ea_set_attr(&a0.eattrs,
+    ea_set_attr(&ea,
 	EA_LITERAL_DIRECT_ADATA(&ea_rip_from, 0, &riad.ad));
 
-    rta *a = rta_lookup(&a0);
-    rte *e = rte_get_temp(a, p->p.main_source);
+    rte *e = rte_get_temp(rta_lookup(ea), p->p.main_source);
 
     rte_update(&p->p, en->n.addr, e);
   }
@@ -345,9 +343,9 @@ rip_rt_notify(struct proto *P, struct channel *ch UNUSED, struct network *net, s
   if (new)
   {
     /* Update */
-    u32 rt_tag = ea_get_int(new->attrs->eattrs, &ea_rip_tag, 0);
-    u32 rt_metric = ea_get_int(new->attrs->eattrs, &ea_rip_metric, 1);
-    const eattr *rie = ea_find(new->attrs->eattrs, &ea_rip_from);
+    u32 rt_tag = ea_get_int(new->attrs, &ea_rip_tag, 0);
+    u32 rt_metric = ea_get_int(new->attrs, &ea_rip_metric, 1);
+    const eattr *rie = ea_find(new->attrs, &ea_rip_from);
     struct iface *rt_from = rie ? ((struct rip_iface_adata *) rie->u.ptr)->iface : NULL;
 
     if (rt_metric > p->infinity)
@@ -381,7 +379,7 @@ rip_rt_notify(struct proto *P, struct channel *ch UNUSED, struct network *net, s
     en->tag = rt_tag;
     en->from = (new->src->proto == P) ? rt_from : NULL;
 
-    eattr *nhea = ea_find(new->attrs->eattrs, &ea_gen_nexthop);
+    eattr *nhea = ea_find(new->attrs, &ea_gen_nexthop);
     if (nhea)
     {
       struct nexthop_adata *nhad = (struct nexthop_adata *) nhea->u.ptr;
@@ -1120,8 +1118,8 @@ rip_rte_better(struct rte *new, struct rte *old)
   ASSERT_DIE(new->src == old->src);
   struct rip_proto *p = (struct rip_proto *) new->src->proto;
 
-  u32 new_metric = ea_get_int(new->attrs->eattrs, &ea_rip_metric, p->infinity);
-  u32 old_metric = ea_get_int(old->attrs->eattrs, &ea_rip_metric, p->infinity);
+  u32 new_metric = ea_get_int(new->attrs, &ea_rip_metric, p->infinity);
+  u32 old_metric = ea_get_int(old->attrs, &ea_rip_metric, p->infinity);
 
   return new_metric < old_metric;
 }
@@ -1129,7 +1127,7 @@ rip_rte_better(struct rte *new, struct rte *old)
 static u32
 rip_rte_igp_metric(struct rte *rt)
 {
-  return ea_get_int(rt->attrs->eattrs, &ea_rip_metric, IGP_METRIC_UNKNOWN);
+  return ea_get_int(rt->attrs, &ea_rip_metric, IGP_METRIC_UNKNOWN);
 }
 
 static void
@@ -1230,8 +1228,8 @@ static void
 rip_get_route_info(rte *rte, byte *buf)
 {
   struct rip_proto *p = (struct rip_proto *) rte->src->proto;
-  u32 rt_metric = ea_get_int(rte->attrs->eattrs, &ea_rip_metric, p->infinity);
-  u32 rt_tag = ea_get_int(rte->attrs->eattrs, &ea_rip_tag, 0);
+  u32 rt_metric = ea_get_int(rte->attrs, &ea_rip_metric, p->infinity);
+  u32 rt_tag = ea_get_int(rte->attrs, &ea_rip_tag, 0);
 
   buf += bsprintf(buf, " (%d/%d)", rt_get_preference(rte), rt_metric);
 
diff --git a/proto/rpki/rpki.c b/proto/rpki/rpki.c
index 4318cbb7..2d36f1fb 100644
--- a/proto/rpki/rpki.c
+++ b/proto/rpki/rpki.c
@@ -120,13 +120,11 @@ rpki_table_add_roa(struct rpki_cache *cache, struct channel *channel, const net_
 {
   struct rpki_proto *p = cache->p;
 
-  rta a0 = {};
+  ea_list *ea = NULL;
+  ea_set_attr_u32(&ea, &ea_gen_preference, 0, channel->preference);
+  ea_set_attr_u32(&ea, &ea_gen_source, 0, RTS_RPKI);
 
-  ea_set_attr_u32(&a0.eattrs, &ea_gen_preference, 0, channel->preference);
-  ea_set_attr_u32(&a0.eattrs, &ea_gen_source, 0, RTS_RPKI);
-
-  rta *a = rta_lookup(&a0);
-  rte *e = rte_get_temp(a, p->p.main_source);
+  rte *e = rte_get_temp(rta_lookup(ea), p->p.main_source);
 
   e->pflags = 0;
 
diff --git a/proto/static/static.c b/proto/static/static.c
index 806849c4..29285d37 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -53,10 +53,10 @@ static inline struct rte_src * static_get_source(struct static_proto *p, uint i)
 static void
 static_announce_rte(struct static_proto *p, struct static_route *r)
 {
-  rta *a = allocz(RTA_MAX_SIZE);
+  ea_list *ea = NULL;
   struct rte_src *src = static_get_source(p, r->index);
-  ea_set_attr_u32(&a->eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
-  ea_set_attr_u32(&a->eattrs, &ea_gen_source, 0, RTS_STATIC);
+  ea_set_attr_u32(&ea, &ea_gen_preference, 0, p->p.main_channel->preference);
+  ea_set_attr_u32(&ea, &ea_gen_source, 0, RTS_STATIC);
 
   if (r->dest == RTD_UNICAST)
   {
@@ -92,7 +92,7 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
       nh = NEXTHOP_NEXT(nh);
     }
 
-    ea_set_attr_data(&a->eattrs, &ea_gen_nexthop, 0,
+    ea_set_attr_data(&ea, &ea_gen_nexthop, 0,
 	nhad->ad.data, (void *) nh - (void *) nhad->ad.data);
   }
 
@@ -102,19 +102,19 @@ static_announce_rte(struct static_proto *p, struct static_route *r)
     u32 *labels = r->mls ? (void *) r->mls->data : NULL;
     u32 lnum = r->mls ? r->mls->length / sizeof(u32) : 0;
 
-    ea_set_hostentry(&a->eattrs, p->p.main_channel->table, tab,
+    ea_set_hostentry(&ea, p->p.main_channel->table, tab,
 	r->via, IPA_NONE, lnum, labels);
   }
 
   else if (r->dest)
-    ea_set_dest(&a->eattrs, 0, r->dest);
+    ea_set_dest(&ea, 0, r->dest);
 
   /* Already announced */
   if (r->state == SRS_CLEAN)
     return;
 
   /* We skip rta_lookup() here */
-  rte *e = rte_get_temp(a, src);
+  rte *e = rte_get_temp(ea, src);
   e->pflags = 0;
 
   if (r->cmds)
@@ -407,16 +407,16 @@ static_reload_routes(struct channel *C)
 static int
 static_rte_better(rte *new, rte *old)
 {
-  u32 n = ea_get_int(new->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
-  u32 o = ea_get_int(old->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
+  u32 n = ea_get_int(new->attrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
+  u32 o = ea_get_int(old->attrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
   return n < o;
 }
 
 static int
 static_rte_mergable(rte *pri, rte *sec)
 {
-  u32 a = ea_get_int(pri->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
-  u32 b = ea_get_int(sec->attrs->eattrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
+  u32 a = ea_get_int(pri->attrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
+  u32 b = ea_get_int(sec->attrs, &ea_gen_igp_metric, IGP_METRIC_UNKNOWN);
   return a == b;
 }
 
@@ -710,7 +710,7 @@ static_copy_config(struct proto_config *dest, struct proto_config *src)
 static void
 static_get_route_info(rte *rte, byte *buf)
 {
-  eattr *a = ea_find(rte->attrs->eattrs, &ea_gen_igp_metric);
+  eattr *a = ea_find(rte->attrs, &ea_gen_igp_metric);
   u32 pref = rt_get_preference(rte);
   if (a)
     buf += bsprintf(buf, " (%d/%u)", pref, a->u.data);
diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index 40f6212e..4cfd7c80 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -111,7 +111,7 @@ struct nl_parse_state
   int merge;
 
   net *net;
-  rta *attrs;
+  ea_list *attrs;
   struct krt_proto *proto;
   s8 new;
   s8 krt_src;
@@ -1407,7 +1407,7 @@ HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
 int
 krt_capable(rte *e)
 {
-  eattr *ea = ea_find(e->attrs->eattrs, &ea_gen_nexthop);
+  eattr *ea = ea_find(e->attrs, &ea_gen_nexthop);
   if (!ea)
     return 0;
 
@@ -1441,8 +1441,7 @@ nl_send_route(struct krt_proto *p, rte *e, int op, int dest, struct nexthop_adat
 {
   eattr *ea;
   net *net = e->net;
-  rta *a = e->attrs;
-  ea_list *eattrs = a->eattrs;
+  ea_list *eattrs = e->attrs;
 
   int bufsize = 128 + KRT_METRICS_MAX*8 + (nh ? nh_bufsize(nh) : 0);
   u32 priority = 0;
@@ -1590,10 +1589,10 @@ dest:
 static inline int
 nl_add_rte(struct krt_proto *p, rte *e)
 {
-  rta *a = e->attrs;
+  ea_list *ea = e->attrs;
   int err = 0;
 
-  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(ea, &ea_gen_nexthop);
   struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
 
   if (krt_ecmp6(p) && nhad && NEXTHOP_IS_REACHABLE(nhad) && !NEXTHOP_ONE(nhad))
@@ -1641,8 +1640,7 @@ nl_delete_rte(struct krt_proto *p, rte *e)
 static inline int
 nl_replace_rte(struct krt_proto *p, rte *e)
 {
-  rta *a = e->attrs;
-  eattr *nhea = ea_find(a->eattrs, &ea_gen_nexthop);
+  eattr *nhea = ea_find(e->attrs, &ea_gen_nexthop);
   struct nexthop_adata *nhad = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
   return nl_send_route(p, e, NL_OP_REPLACE,
       NEXTHOP_IS_REACHABLE(nhad) ? RTD_UNICAST : nhad->dest, nhad);
@@ -1713,14 +1711,14 @@ nl_announce_route(struct nl_parse_state *s)
   e->net = s->net;
 
   EA_LOCAL_LIST(2) ea = {
-    .l = { .count = 2, .next = e->attrs->eattrs },
+    .l = { .count = 2, .next = e->attrs },
     .a = {
       EA_LITERAL_EMBEDDED(&ea_krt_source, 0, s->krt_proto),
       EA_LITERAL_EMBEDDED(&ea_krt_metric, 0, s->krt_metric),
     },
   };
 
-  e->attrs->eattrs = &ea.l;
+  e->attrs = &ea.l;
 
   if (s->scan)
     krt_got_route(s->proto, e, s->krt_src);
@@ -1888,8 +1886,8 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   if (s->net && !nl_mergable_route(s, net, p, priority, i->rtm_type, i->rtm_family))
     nl_announce_route(s);
 
-  rta *ra = lp_allocz(s->pool, RTA_MAX_SIZE);
-  ea_set_attr_u32(&ra->eattrs, &ea_gen_source, 0, RTS_INHERIT);
+  ea_list *ra = NULL;
+  ea_set_attr_u32(&ra, &ea_gen_source, 0, RTS_INHERIT);
 
   if (a[RTA_FLOW])
     s->rta_flow = rta_get_u32(a[RTA_FLOW]);
@@ -1914,7 +1912,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 	  if (!nh)
 	    SKIP("strange RTA_MULTIPATH\n");
 
-	  ea_set_attr(&ra->eattrs, EA_LITERAL_DIRECT_ADATA(
+	  ea_set_attr(&ra, EA_LITERAL_DIRECT_ADATA(
 		&ea_gen_nexthop, 0, &nh->ad));
 	  break;
 	}
@@ -2000,20 +1998,20 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     }
 
   if (i->rtm_scope != def_scope)
-    ea_set_attr(&ra->eattrs,
+    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->eattrs,
+    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->eattrs,
+    ea_set_attr(&ra,
 	EA_LITERAL_EMBEDDED(&ea_krt_realm, 0, s->rta_flow));
 
   if (a[RTA_METRICS])
@@ -2027,7 +2025,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
 
       for (uint t = 1; t < KRT_METRICS_MAX; t++)
 	if (metrics[0] & (1 << t))
-	  ea_set_attr(&ra->eattrs,
+	  ea_set_attr(&ra,
 	      EA_LITERAL_EMBEDDED(&ea_krt_metrics[t], 0, metrics[t]));
     }
 
@@ -2045,7 +2043,7 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     s->net = net;
     s->attrs = ra;
 
-    ea_set_attr_data(&ra->eattrs, &ea_gen_nexthop, 0,
+    ea_set_attr_data(&ra, &ea_gen_nexthop, 0,
 	nhad.ad.data, nhad.ad.length);
 
     s->proto = p;
@@ -2058,17 +2056,17 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
   else
   {
     /* Merge next hops with the stored route */
-    eattr *nhea = ea_find(s->attrs->eattrs, &ea_gen_nexthop);
+    eattr *nhea = ea_find(s->attrs, &ea_gen_nexthop);
     struct nexthop_adata *nhad_old = nhea ? (struct nexthop_adata *) nhea->u.ptr : NULL;
 
     if (nhad_old)
-      ea_set_attr(&s->attrs->eattrs,
+      ea_set_attr(&s->attrs,
 	  EA_LITERAL_DIRECT_ADATA(&ea_gen_nexthop, 0, 
 	    &(nexthop_merge(nhad_old, &nhad.nhad,
 		KRT_CF->merge_paths, s->pool)->ad)
 	  ));
     else
-      ea_set_attr_data(&s->attrs->eattrs, &ea_gen_nexthop, 0,
+      ea_set_attr_data(&s->attrs, &ea_gen_nexthop, 0,
 	  nhad.ad.data, nhad.ad.length);
   }
 }
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index a0789936..3edbdfa2 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -286,7 +286,7 @@ static struct tbf rl_alien = TBF_DEFAULT_LOG_LIMITS;
 static inline u32
 krt_metric(rte *a)
 {
-  eattr *ea = ea_find(a->attrs->eattrs, &ea_krt_metric);
+  eattr *ea = ea_find(a->attrs, &ea_krt_metric);
   return ea ? ea->u.data : 0;
 }
 
@@ -306,8 +306,7 @@ static void
 krt_learn_announce_update(struct krt_proto *p, rte *e)
 {
   net *n = e->net;
-  rta *aa = rta_clone(e->attrs);
-  rte *ee = rte_get_temp(aa, p->p.main_source);
+  rte *ee = rte_get_temp(ea_clone(e->attrs), p->p.main_source);
   rte_update(&p->p, n->n.addr, ee);
 }
 
@@ -437,10 +436,9 @@ krt_learn_async(struct krt_proto *p, rte *e, int new)
   net *n = net_get(p->krt_table, n0->n.addr);
   rte *g, **gg, *best, **bestp, *old_best;
 
-  ASSERT(!e->attrs->cached);
-  ea_set_attr_u32(&e->attrs->eattrs, &ea_gen_preference, 0, p->p.main_channel->preference);
-
-  e->attrs = rta_lookup(e->attrs);
+  ea_list *ea = e->attrs;
+  ea_set_attr_u32(&ea, &ea_gen_preference, 0, p->p.main_channel->preference);
+  e->attrs = rta_lookup(ea);
 
   old_best = n->routes;
   for(gg=&n->routes; g = *gg; gg = &g->next)
@@ -606,10 +604,10 @@ reject:
 static int
 krt_same_dest(rte *k, rte *e)
 {
-  rta *ka = k->attrs, *ea = e->attrs;
+  ea_list *ka = k->attrs, *ea = e->attrs;
 
-  eattr *nhea_k = ea_find(ka->eattrs, &ea_gen_nexthop);
-  eattr *nhea_e = ea_find(ea->eattrs, &ea_gen_nexthop);
+  eattr *nhea_k = ea_find(ka, &ea_gen_nexthop);
+  eattr *nhea_e = ea_find(ea, &ea_gen_nexthop);
 
   return (!nhea_k == !nhea_e) && adata_same(nhea_k->u.ptr, nhea_e->u.ptr);
 }
-- 
cgit v1.2.3


From 9efaf6bafea1c69629e59c6504980fb2986287fe Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Mon, 11 Jul 2022 17:04:52 +0200
Subject: Dropped the internal kernel protocol table for learnt routes.

The learnt routes are now pushed all into the connected table, not only
the best one. This shouldn't do any damage in well managed setups, yet
it should be noted that it is a change of behavior.

If anybody misses a feature which they implemented by misusing this
internal learn table, let us know, we'll consider implementing it in a
better way.
---
 sysdep/linux/netlink.c |   3 +-
 sysdep/unix/krt.c      | 239 +++----------------------------------------------
 sysdep/unix/krt.h      |   4 -
 3 files changed, 11 insertions(+), 235 deletions(-)

(limited to 'sysdep/linux')

diff --git a/sysdep/linux/netlink.c b/sysdep/linux/netlink.c
index d802d3e0..656202ac 100644
--- a/sysdep/linux/netlink.c
+++ b/sysdep/linux/netlink.c
@@ -2042,11 +2042,10 @@ nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
     s->net = lp_alloc(s->pool, net->length);
     net_copy(s->net, net);
 
-    s->attrs = ra;
-
     ea_set_attr_data(&ra, &ea_gen_nexthop, 0,
 	nhad.ad.data, nhad.ad.length);
 
+    s->attrs = ra;
     s->proto = p;
     s->new = new;
     s->krt_src = krt_src;
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index a37d3186..67d19cbb 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -302,236 +302,29 @@ krt_uptodate(rte *a, rte *b)
   return (a->attrs == b->attrs);
 }
 
-static void
-krt_learn_announce_update(struct krt_proto *p, rte *e)
-{
-  rte e0 = {
-    .attrs = ea_clone(e->attrs),
-    .src = p->p.main_source,
-  };
-
-  rte_update(p->p.main_channel, e->net, &e0, p->p.main_source);
-}
-
-static void
-krt_learn_announce_delete(struct krt_proto *p, net_addr *n)
-{
-  rte_update(p->p.main_channel, n, NULL, p->p.main_source);
-}
-
 /* Called when alien route is discovered during scan */
 static void
 krt_learn_scan(struct krt_proto *p, rte *e)
 {
-  net *n = net_get(p->krt_table, e->net);
-  struct rte_storage *m, **mm;
-
-  struct rte_storage *ee = rte_store(e, n, p->krt_table);
-
-  for(mm = &n->routes; m = *mm; mm = &m->next)
-    if (krt_same_key(&m->rte, e))
-      break;
-  if (m)
-    {
-      if (krt_uptodate(&m->rte, e))
-	{
-	  krt_trace_in_rl(&rl_alien, p, e, "[alien] seen");
-	  rte_free(ee);
-	  m->rte.pflags |= KRT_REF_SEEN;
-	}
-      else
-	{
-	  krt_trace_in(p, e, "[alien] updated");
-	  *mm = m->next;
-	  rte_free(m);
-	  m = NULL;
-	}
-    }
-  else
-    krt_trace_in(p, e, "[alien] created");
-
-  if (!m)
-    {
-      ee->next = n->routes;
-      n->routes = ee;
-      ee->rte.pflags |= KRT_REF_SEEN;
-    }
-}
-
-static void
-krt_learn_prune(struct krt_proto *p)
-{
-  struct fib *fib = &p->krt_table->fib;
-  struct fib_iterator fit;
-
-  KRT_TRACE(p, D_EVENTS, "Pruning inherited routes");
-
-  FIB_ITERATE_INIT(&fit, fib);
-again:
-  FIB_ITERATE_START(fib, &fit, net, n)
-    {
-      struct rte_storage *e, **ee, *best, **pbest, *old_best;
-
-      /*
-       * Note that old_best may be NULL even if there was an old best route in
-       * the previous step, because it might be replaced in krt_learn_scan().
-       * But in that case there is a new valid best route.
-       */
-
-      old_best = NULL;
-      best = NULL;
-      pbest = NULL;
-      ee = &n->routes;
-      while (e = *ee)
-	{
-	  if (e->rte.pflags & KRT_REF_BEST)
-	    old_best = e;
-
-	  if (!(e->rte.pflags & KRT_REF_SEEN))
-	    {
-	      *ee = e->next;
-	      rte_free(e);
-	      continue;
-	    }
-
-	  if (!best || krt_metric(&best->rte) > krt_metric(&e->rte))
-	    {
-	      best = e;
-	      pbest = ee;
-	    }
-
-	  e->rte.pflags &= ~(KRT_REF_SEEN | KRT_REF_BEST);
-	  ee = &e->next;
-	}
-      if (!n->routes)
-	{
-	  DBG("%I/%d: deleting\n", n->n.prefix, n->n.pxlen);
-	  if (old_best)
-	    krt_learn_announce_delete(p, n->n.addr);
-
-	  FIB_ITERATE_PUT(&fit);
-	  fib_delete(fib, n);
-	  goto again;
-	}
-
-      best->rte.pflags |= KRT_REF_BEST;
-      *pbest = best->next;
-      best->next = n->routes;
-      n->routes = best;
+  rte e0 = {
+    .attrs = e->attrs,
+    .src = rt_get_source(&p->p, krt_metric(e)),
+  };
 
-      if ((best != old_best) || p->reload)
-	{
-	  DBG("%I/%d: announcing (metric=%d)\n", n->n.prefix, n->n.pxlen, krt_metric(&best->rte));
-	  krt_learn_announce_update(p, &best->rte);
-	}
-      else
-	DBG("%I/%d: uptodate (metric=%d)\n", n->n.prefix, n->n.pxlen, krt_metric(&best->rte));
-    }
-  FIB_ITERATE_END;
+  ea_set_attr_u32(&e0.attrs, &ea_gen_preference, 0, p->p.main_channel->preference);
 
-  p->reload = 0;
+  rte_update(p->p.main_channel, e->net, &e0, e0.src);
 }
 
 static void
 krt_learn_async(struct krt_proto *p, rte *e, int new)
 {
-  net *n = net_get(p->krt_table, e->net);
-  struct rte_storage *g, **gg, *best, **bestp, *old_best;
-
-  ea_set_attr_u32(&e->attrs, &ea_gen_preference, 0, p->p.main_channel->preference);
-  struct rte_storage *ee = rte_store(e, n, p->krt_table);
-
-  old_best = n->routes;
-  for(gg=&n->routes; g = *gg; gg = &g->next)
-    if (krt_same_key(&g->rte, e))
-      break;
   if (new)
-    {
-      if (g)
-	{
-	  if (krt_uptodate(&g->rte, e))
-	    {
-	      krt_trace_in(p, e, "[alien async] same");
-	      rte_free(ee);
-	      return;
-	    }
-	  krt_trace_in(p, e, "[alien async] updated");
-	  *gg = g->next;
-	  rte_free(g);
-	}
-      else
-	krt_trace_in(p, e, "[alien async] created");
-
-      ee->next = n->routes;
-      n->routes = ee;
-    }
-  else if (!g)
-    {
-      krt_trace_in(p, e, "[alien async] delete failed");
-      rte_free(ee);
-      return;
-    }
-  else
-    {
-      krt_trace_in(p, e, "[alien async] removed");
-      *gg = g->next;
-      rte_free(ee);
-      rte_free(g);
-    }
-  best = n->routes;
-  bestp = &n->routes;
-  for(gg=&n->routes; g=*gg; gg=&g->next)
-  {
-    if (krt_metric(&best->rte) > krt_metric(&g->rte))
-      {
-	best = g;
-	bestp = gg;
-      }
-
-    g->rte.pflags &= ~KRT_REF_BEST;
-  }
-
-  if (best)
-    {
-      best->rte.pflags |= KRT_REF_BEST;
-      *bestp = best->next;
-      best->next = n->routes;
-      n->routes = best;
-    }
+    return krt_learn_scan(p, e);
 
-  if (best != old_best)
-    {
-      DBG("krt_learn_async: distributing change\n");
-      if (best)
-	krt_learn_announce_update(p, &best->rte);
-      else
-	krt_learn_announce_delete(p, n->n.addr);
-    }
-}
-
-static void
-krt_learn_init(struct krt_proto *p)
-{
-  if (KRT_CF->learn)
-  {
-    struct rtable_config *cf = mb_allocz(p->p.pool, sizeof(struct rtable_config));
-    cf->name = "Inherited";
-    cf->addr_type = p->p.net_type;
-    cf->internal = 1;
-
-    p->krt_table = rt_setup(p->p.pool, cf);
-  }
-}
-
-static void
-krt_dump(struct proto *P)
-{
-  struct krt_proto *p = (struct krt_proto *) P;
-
-  if (!KRT_CF->learn)
-    return;
-  debug("KRT: Table of inheritable routes\n");
-  rt_dump(p->krt_table);
+  struct rte_src *src = rt_find_source(&p->p, krt_metric(e));
+  if (src)
+    rte_update(p->p.main_channel, e->net, NULL, src);
 }
 
 #endif
@@ -738,11 +531,6 @@ krt_prune(struct krt_proto *p)
   }
   FIB_WALK_END;
 
-#ifdef KRT_ALLOW_LEARN
-  if (KRT_CF->learn)
-    krt_learn_prune(p);
-#endif
-
   if (p->ready)
     p->initialized = 1;
 }
@@ -1053,10 +841,6 @@ krt_start(struct proto *P)
   bmap_init(&p->seen_map, p->p.pool, 1024);
   add_tail(&krt_proto_list, &p->krt_node);
 
-#ifdef KRT_ALLOW_LEARN
-  krt_learn_init(p);
-#endif
-
   if (!krt_sys_start(p))
   {
     rem_node(&p->krt_node);
@@ -1172,9 +956,6 @@ struct protocol proto_unix_kernel = {
   .shutdown =		krt_shutdown,
   .reconfigure =	krt_reconfigure,
   .copy_config =	krt_copy_config,
-#ifdef KRT_ALLOW_LEARN
-  .dump =		krt_dump,
-#endif
 };
 
 void
diff --git a/sysdep/unix/krt.h b/sysdep/unix/krt.h
index 69fc9aa1..e0d60cbd 100644
--- a/sysdep/unix/krt.h
+++ b/sysdep/unix/krt.h
@@ -55,10 +55,6 @@ struct krt_proto {
   struct proto p;
   struct krt_state sys;		/* Sysdep state */
 
-#ifdef KRT_ALLOW_LEARN
-  struct rtable *krt_table;	/* Internal table of inherited routes */
-#endif
-
 #ifndef CONFIG_ALL_TABLES_AT_ONCE
   timer *scan_timer;
 #endif
-- 
cgit v1.2.3