[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/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) {
@@ -176,6 +189,9 @@ 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_encap)
+		rtnl_nh_encap_free(nh->nh_encap);
+
 	if (nh->nh_group)
 		rtnl_nh_grp_put(nh->nh_group);
 }
@@ -237,6 +253,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 +609,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;
@@ -757,6 +840,26 @@ 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]) {
+		int err2;
+		struct rtnl_nh_encap *nh_encap = NULL;
+
+		err2 = nh_encap_parse_msg(tb[NHA_ENCAP], tb[NHA_ENCAP_TYPE],
+					  &nh_encap);
+		if (err2 == 0) {
+			err2 = rtnl_nh_set_encap(nexthop, nh_encap);
+			if (err2 < 0) {
+				rtnl_nh_encap_free(nh_encap);
+				return err2;
+			}
+			nexthop->ce_mask |= NH_ATTR_ENCAP;
+		} else if (err2 != -NLE_MSGTYPE_NOSUPPORT) {
+			return err2;
+		}
+		/* If NOSUPPORT, silently ignore to keep parity with previous
+         * behavior where only MPLS was supported. */
+	}
+
 	if (tb[NHA_BLACKHOLE]) {
 		nexthop->ce_mask |= NH_ATTR_FLAG_BLACKHOLE;
 	}
@@ -869,6 +972,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");
 
@@ -929,6 +1035,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

@@ -1391,6 +1391,8 @@ global:
 	rtnl_nh_set_res_group_bucket_size;
 	rtnl_nh_set_res_group_idle_timer;
 	rtnl_nh_set_res_group_unbalanced_timer;
+	rtnl_nh_set_encap;
+	rtnl_nh_get_encap;
 	rtnl_route_nh_set_encap;
 	rtnl_route_nh_get_encap;
 } libnl_3_11;

tests/cksuite-route-nh.c

@@ -18,6 +18,7 @@
 #include <netlink/route/nh.h>
 #include <netlink/route/link.h>
 #include <netlink/route/addr.h>
+#include <netlink/route/nexthop.h>
 
 #include "cksuite-all.h"
 
@@ -75,6 +76,72 @@ START_TEST(test_kernel_roundtrip_basic_v4)
 }
 END_TEST
 
+/* Kernel round-trip tests for MPLS encap on rtnl_nh */
+
+START_TEST(test_kernel_roundtrip_encap_mpls)
+{
+	const char *IFNAME_DUMMY = "nh-dummy-encap0";
+	_nltst_auto_delete_link const char *auto_del_dummy = NULL;
+	_nl_auto_nl_socket struct nl_sock *sk = NULL;
+	_nl_auto_nl_cache struct nl_cache *cache = NULL;
+	_nl_auto_rtnl_nh struct rtnl_nh *nh = NULL;
+	struct rtnl_nh *knh;
+	struct rtnl_nh_encap *kencap;
+	_nl_auto_nl_addr struct nl_addr *gw4 = NULL;
+	_nl_auto_nl_addr struct nl_addr *labels = NULL;
+	struct rtnl_nh_encap *encap = NULL;
+	int ifindex_dummy;
+
+	if (_nltst_skip_no_netns())
+		return;
+
+	sk = _nltst_socket(NETLINK_ROUTE);
+
+	/* Create underlay */
+	auto_del_dummy = IFNAME_DUMMY;
+	_nltst_add_link(sk, IFNAME_DUMMY, "dummy", &ifindex_dummy);
+	_nltst_link_up(sk, IFNAME_DUMMY);
+	_nltst_addr4_add(sk, ifindex_dummy, "192.0.2.2", 24);
+
+	/* Build nexthop: v4 gw over dummy with MPLS encap */
+	nh = rtnl_nh_alloc();
+	ck_assert_ptr_nonnull(nh);
+	ck_assert_int_eq(rtnl_nh_set_id(nh, 3101), 0);
+
+	/* Surprisingly the kernel accepts a nexthop with encap and a gw */
+	ck_assert_int_eq(nl_addr_parse("192.0.2.1", AF_INET, &gw4), 0);
+	ck_assert_int_eq(rtnl_nh_set_gateway(nh, gw4), 0);
+
+	encap = rtnl_nh_encap_alloc();
+	ck_assert_ptr_nonnull(encap);
+	ck_assert_int_eq(nl_addr_parse("100", AF_MPLS, &labels), 0);
+	ck_assert_int_eq(rtnl_nh_encap_mpls(encap, labels, 64), 0);
+	ck_assert_int_eq(rtnl_nh_set_encap(nh, encap), 0);
+
+	/* Fails - we need a family & oif*/
+	ck_assert_int_eq(rtnl_nh_add(sk, nh, NLM_F_CREATE), -NLE_INVAL);
+
+	/* Fails, we need a family */
+	ck_assert_int_eq(rtnl_nh_set_oif(nh, (uint32_t)ifindex_dummy), 0);
+	ck_assert_int_eq(rtnl_nh_add(sk, nh, NLM_F_CREATE), -NLE_INVAL);
+
+	ck_assert_int_eq(rtnl_nh_set_family(nh, AF_INET), 0);
+	ck_assert_int_eq(rtnl_nh_add(sk, nh, NLM_F_CREATE), 0);
+
+	/* Query and verify */
+	ck_assert_int_eq(rtnl_nh_alloc_cache(sk, AF_UNSPEC, &cache), 0);
+	knh = rtnl_nh_get(cache, 3101);
+	ck_assert_ptr_nonnull(knh);
+	ck_assert_int_eq(rtnl_nh_get_id(knh), 3101);
+	ck_assert_int_eq(rtnl_nh_get_oif(knh), ifindex_dummy);
+
+	kencap = rtnl_nh_get_encap(knh);
+	ck_assert_ptr_nonnull(kencap);
+	ck_assert_ptr_nonnull(rtnl_nh_get_encap_mpls_dst(kencap));
+	ck_assert_uint_eq(rtnl_nh_get_encap_mpls_ttl(kencap), 64);
+}
+END_TEST
+
 START_TEST(test_kernel_negative_mismatched_gw_family)
 {
 	const char *IFNAME_DUMMY = "nh-dummy-neg0";
@@ -518,6 +585,56 @@ START_TEST(test_api_set_get_all)
 }
 END_TEST
 
+/* Userspace tests for MPLS encap on rtnl_nh */
+
+START_TEST(test_api_encap_mpls_set_get)
+{
+	_nl_auto_rtnl_nh struct rtnl_nh *nh = NULL;
+	struct rtnl_nh_encap *encap = NULL;
+	struct rtnl_nh_encap *got = NULL;
+	_nl_auto_nl_addr struct nl_addr *labels = NULL;
+
+	/* Allocate nh and an encap container */
+	nh = rtnl_nh_alloc();
+	ck_assert_ptr_nonnull(nh);
+
+	/* Negative: NULL nh */
+	encap = rtnl_nh_encap_alloc();
+	ck_assert_ptr_nonnull(encap);
+	/* This will free encap */
+	ck_assert_int_eq(rtnl_nh_set_encap(NULL, encap), -NLE_INVAL);
+
+	encap = rtnl_nh_encap_alloc();
+	ck_assert_ptr_nonnull(encap);
+
+	/* "empty" encap (no type set) cannot be assigned. */
+	ck_assert_int_eq(rtnl_nh_set_encap(nh, encap), -NLE_INVAL);
+	ck_assert_ptr_eq(rtnl_nh_get_encap_mpls_dst(rtnl_nh_get_encap(nh)),
+			 NULL);
+	ck_assert_uint_eq(rtnl_nh_get_encap_mpls_ttl(rtnl_nh_get_encap(nh)),
+			  -NLE_INVAL);
+
+	encap = rtnl_nh_encap_alloc();
+	ck_assert_ptr_nonnull(encap);
+	/* Now build a valid MPLS encap: push label 100 with TTL 64 */
+	ck_assert_int_eq(nl_addr_parse("100", AF_MPLS, &labels), 0);
+	ck_assert_int_eq(rtnl_nh_encap_mpls(encap, labels, 64), 0);
+
+	/* Attach and retrieve */
+	ck_assert_int_eq(rtnl_nh_set_encap(nh, encap), 0);
+	got = rtnl_nh_get_encap(nh);
+	ck_assert_ptr_nonnull(got);
+
+	/* Access MPLS-specific getters */
+	ck_assert_ptr_nonnull(rtnl_nh_get_encap_mpls_dst(got));
+	ck_assert_uint_eq(rtnl_nh_get_encap_mpls_ttl(got), 64);
+
+	/* Clear encap */
+	ck_assert_int_eq(rtnl_nh_set_encap(nh, NULL), 0);
+	ck_assert_ptr_eq(rtnl_nh_get_encap(nh), NULL);
+}
+END_TEST
+
 Suite *make_nl_route_nh_suite(void)
 {
 	Suite *suite = suite_create("route-nh");
@@ -526,6 +643,8 @@ Suite *make_nl_route_nh_suite(void)
 
 	/* Comprehensive API setter/getter test (userspace only) */
 	tcase_add_test(tc_api, test_api_set_get_all);
+	/* Userspace encap tests */
+	tcase_add_test(tc_api, test_api_encap_mpls_set_get);
 	suite_add_tcase(suite, tc_api);
 
 	/* Kernel round-trip – needs private netns */
@@ -538,6 +657,8 @@ Suite *make_nl_route_nh_suite(void)
 	tcase_add_test(tc_kernel, test_kernel_roundtrip_oif_only);
 	tcase_add_test(tc_kernel, test_kernel_roundtrip_group_mpath);
 	tcase_add_test(tc_kernel, test_kernel_roundtrip_group_resilient);
+	/* Encap (MPLS) on rtnl_nh */
+	tcase_add_test(tc_kernel, test_kernel_roundtrip_encap_mpls);
 	/* Negative tests: kernel should reject invalid nexthops */
 	tcase_add_test(tc_kernel, test_kernel_negative_mismatched_gw_family);
 	tcase_add_test(tc_kernel, test_kernel_negative_group_without_entries);