nh-encap: Allow adding a nh_encap to a rtnl_nh

A regular "nexthop object" à la `ip nexthop` can have an associated
encapsulation. So, add the code to support that.

Signed-off-by: Christoph Paasch <[email protected]>

Author: cpaasch-oai

include/netlink/route/nh.h

@@ -72,6 +72,11 @@ extern int rtnl_nh_set_res_group_unbalanced_timer(struct rtnl_nh *,
 extern int rtnl_nh_get_res_group_unbalanced_timer(struct rtnl_nh *,
 						  uint32_t *out_value);
 
+/* lwtunnel encapsulation */
+struct rtnl_nh_encap;
+extern int rtnl_nh_set_encap(struct rtnl_nh *, struct rtnl_nh_encap *);
+extern struct rtnl_nh_encap *rtnl_nh_get_encap(struct rtnl_nh *);
+
 #ifdef __cplusplus
 }
 #endif

lib/route/nexthop_encap.c

@@ -78,23 +78,34 @@ int nh_encap_parse_msg(struct nlattr *encap, struct nlattr *encap_type,
 
 	if (e_type == LWTUNNEL_ENCAP_NONE) {
 		NL_DBG(2, "RTA_ENCAP_TYPE should not be LWTUNNEL_ENCAP_NONE\n");
-		return -NLE_INVAL;
+
+		goto unsupported_encap;
 	}
+
 	if (e_type > LWTUNNEL_ENCAP_MAX) {
 		NL_DBG(2, "Unknown RTA_ENCAP_TYPE: %d\n", e_type);
-		return -NLE_INVAL;
+
+		goto unsupported_encap;
 	}
 
 	if (!lwtunnel_encap_types[e_type].ops) {
 		NL_DBG(2, "RTA_ENCAP_TYPE %s is not implemented\n",
 		       lwtunnel_encap_types[e_type].name);
-		return -NLE_MSGTYPE_NOSUPPORT;
-	}
 
-	if (!lwtunnel_encap_types[e_type].ops->parse_msg)
-		return -NLE_MSGTYPE_NOSUPPORT;
+		goto unsupported_encap;
+	}
 
 	return lwtunnel_encap_types[e_type].ops->parse_msg(encap, encap_out);
+
+unsupported_encap:
+	/* If we don't yet support this lwtunnel, just return 0.
+	 *
+	 * Force encap_out to NULL so that subsequent calls to set
+	 * it on a nexthop/route will simply reset the encapsulation
+	 * on that nexthop/route.
+	 */
+	*encap_out = NULL;
+	return 0;
 }
 
 int nh_encap_compare(struct rtnl_nh_encap *a, struct rtnl_nh_encap *b)

lib/route/nh.c

@@ -6,6 +6,8 @@
 #include "nl-default.h"
 
 #include <linux/nexthop.h>
+#include <linux/lwtunnel.h>
+#include <linux/mpls_iptunnel.h>
 
 #include <netlink/route/nh.h>
 #include <netlink/hashtable.h>
@@ -29,6 +31,7 @@ struct rtnl_nh {
 	nl_nh_group_t *nh_group;
 	uint32_t nh_oif;
 	struct nl_addr *nh_gateway;
+	struct rtnl_nh_encap *nh_encap;
 
 	/* Resilient nexthop group parameters */
 	uint16_t res_grp_buckets;
@@ -50,6 +53,7 @@ struct rtnl_nh {
 #define NH_ATTR_RES_BUCKETS (1 << 10)
 #define NH_ATTR_RES_IDLE_TIMER (1 << 11)
 #define NH_ATTR_RES_UNBALANCED_TIMER (1 << 12)
+#define NH_ATTR_ENCAP (1 << 13)
 /** @endcond */
 
 struct nla_policy rtnl_nh_policy[NHA_MAX + 1] = {
@@ -60,6 +64,8 @@ struct nla_policy rtnl_nh_policy[NHA_MAX + 1] = {
 	[NHA_BLACKHOLE] = { .type = NLA_UNSPEC },
 	[NHA_OIF] = { .type = NLA_U32 },
 	[NHA_RES_GROUP] = { .type = NLA_NESTED },
+	[NHA_ENCAP] = { .type = NLA_NESTED },
+	[NHA_ENCAP_TYPE] = { .type = NLA_U16 },
 };
 
 static struct nl_cache_ops rtnl_nh_ops;
@@ -155,6 +161,13 @@ static int nh_clone(struct nl_object *_src, struct nl_object *_dst)
 	dst->res_grp_unbalanced_timer = src->res_grp_unbalanced_timer;
 	dst->ce_mask = src->ce_mask;
 
+	if (src->nh_encap) {
+		dst->nh_encap = rtnl_nh_encap_clone(src->nh_encap);
+		if (!dst->nh_encap)
+			return -NLE_NOMEM;
+		dst->ce_mask |= NH_ATTR_ENCAP;
+	}
+
 	if (src->nh_gateway) {
 		dst->nh_gateway = nl_addr_clone(src->nh_gateway);
 		if (!dst->nh_gateway) {
@@ -174,10 +187,10 @@ static int nh_clone(struct nl_object *_src, struct nl_object *_dst)
 static void nh_free(struct nl_object *obj)
 {
 	struct rtnl_nh *nh = nl_object_priv(obj);
-	nl_addr_put(nh->nh_gateway);
 
-	if (nh->nh_group)
-		rtnl_nh_grp_put(nh->nh_group);
+	nl_addr_put(nh->nh_gateway);
+	rtnl_nh_encap_free(nh->nh_encap);
+	rtnl_nh_grp_put(nh->nh_group);
 }
 
 void rtnl_nh_put(struct rtnl_nh *nh)
@@ -237,6 +250,52 @@ struct nl_addr *rtnl_nh_get_gateway(struct rtnl_nh *nexthop)
 	return nexthop->nh_gateway;
 }
 
+/**
+ * Set nexthop encapsulation
+ * @arg nh          Nexthop object
+ * @arg encap       Encapsulation descriptor
+ *
+ * Assigns ownership of the encapsulation object to the nexthop. Any
+ * previously configured encapsulation is released. Passing a NULL
+ * encapsulation clears the encapsulation on the nexthop.
+ *
+ * On failure, the function consumes and frees encap.
+ *
+ * @return 0 on success, or the appropriate error-code on failure.
+ */
+int rtnl_nh_set_encap(struct rtnl_nh *nh, struct rtnl_nh_encap *encap)
+{
+	if (!nh) {
+		rtnl_nh_encap_free(encap);
+		return -NLE_INVAL;
+	}
+
+	if (encap && !encap->ops) {
+		rtnl_nh_encap_free(encap);
+		return -NLE_INVAL;
+	}
+
+	rtnl_nh_encap_free(nh->nh_encap);
+
+	if (encap) {
+		nh->nh_encap = encap;
+		nh->ce_mask |= NH_ATTR_ENCAP;
+	} else {
+		nh->nh_encap = NULL;
+		nh->ce_mask &= ~NH_ATTR_ENCAP;
+	}
+
+	return 0;
+}
+
+struct rtnl_nh_encap *rtnl_nh_get_encap(struct rtnl_nh *nh)
+{
+	if (!nh || !(nh->ce_mask & NH_ATTR_ENCAP))
+		return NULL;
+
+	return nh->nh_encap;
+}
+
 int rtnl_nh_set_fdb(struct rtnl_nh *nexthop, int value)
 {
 	if (value)
@@ -547,6 +606,27 @@ static int rtnl_nh_build_msg(struct nl_msg *msg, struct rtnl_nh *nh)
 	if (nh->ce_mask & NH_ATTR_FLAG_BLACKHOLE)
 		NLA_PUT_FLAG(msg, NHA_BLACKHOLE);
 
+	if (nh->ce_mask & NH_ATTR_ENCAP) {
+		struct nlattr *encap;
+
+		if (!nh->nh_encap || !nh->nh_encap->ops)
+			return -NLE_INVAL;
+
+		NLA_PUT_U16(msg, NHA_ENCAP_TYPE, nh->nh_encap->ops->encap_type);
+
+		encap = nla_nest_start(msg, NHA_ENCAP);
+		if (!encap)
+			goto nla_put_failure;
+
+		if (nh->nh_encap->ops->build_msg) {
+			int err = nh->nh_encap->ops->build_msg(
+				msg, nh->nh_encap->priv);
+			if (err < 0)
+				return err;
+		}
+		nla_nest_end(msg, encap);
+	}
+
 	/* Nexthop group */
 	if (nh->ce_mask & NH_ATTR_GROUP) {
 		struct nexthop_grp *grp;
@@ -758,6 +838,19 @@ static int nexthop_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 		nexthop->ce_mask |= NH_ATTR_GROUP_TYPE;
 	}
 
+	if (tb[NHA_ENCAP] && tb[NHA_ENCAP_TYPE]) {
+		_nl_auto_rtnl_nh_encap struct rtnl_nh_encap *nh_encap = NULL;
+
+		err = nh_encap_parse_msg(tb[NHA_ENCAP], tb[NHA_ENCAP_TYPE],
+					 &nh_encap);
+		if (err < 0)
+			return err;
+
+		err = rtnl_nh_set_encap(nexthop, _nl_steal_pointer(&nh_encap));
+		if (err < 0)
+			return err;
+	}
+
 	if (tb[NHA_BLACKHOLE]) {
 		nexthop->ce_mask |= NH_ATTR_FLAG_BLACKHOLE;
 	}
@@ -870,6 +963,9 @@ static void nh_dump_line(struct nl_object *obj, struct nl_dump_params *dp)
 		nl_dump(dp, " via %s",
 			nl_addr2str(nh->nh_gateway, buf, sizeof(buf)));
 
+	if (nh->ce_mask & NH_ATTR_ENCAP && nh->nh_encap)
+		nh_encap_dump(nh->nh_encap, dp);
+
 	if (nh->ce_mask & NH_ATTR_FLAG_BLACKHOLE)
 		nl_dump(dp, " blackhole");
 
@@ -930,6 +1026,8 @@ static uint64_t nh_compare(struct nl_object *a, struct nl_object *b,
 	diff |= _DIFF(NH_ATTR_RES_UNBALANCED_TIMER,
 		      src->res_grp_unbalanced_timer !=
 			      dst->res_grp_unbalanced_timer);
+	diff |= _DIFF(NH_ATTR_ENCAP,
+		      nh_encap_compare(src->nh_encap, dst->nh_encap));
 #undef _DIFF
 
 	return diff;

libnl-route-3.sym

@@ -1375,6 +1375,7 @@ global:
 	rtnl_nh_encap_clone;
 	rtnl_nh_encap_free;
 	rtnl_nh_encap_mpls;
+	rtnl_nh_get_encap;
 	rtnl_nh_get_encap_mpls_dst;
 	rtnl_nh_get_encap_mpls_ttl;
 	rtnl_nh_get_family;
@@ -1383,6 +1384,7 @@ global:
 	rtnl_nh_get_res_group_bucket_size;
 	rtnl_nh_get_res_group_idle_timer;
 	rtnl_nh_get_res_group_unbalanced_timer;
+	rtnl_nh_set_encap;
 	rtnl_nh_set_family;
 	rtnl_nh_set_group;
 	rtnl_nh_set_group_type;