Add VXLAN support.

2 files changed, 1158 insertions, 0 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index a6aa06d..def16ba 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -75,6 +75,7 @@ libnl_route_3_la_SOURCES = \
 	route/link/api.c route/link/vlan.c route/link/dummy.c \
 	route/link/bridge.c route/link/inet6.c route/link/inet.c \
 	route/link/bonding.c route/link/can.c route/link/macvlan.c \
+	route/link/vxlan.c \
 	\
 	route/qdisc/blackhole.c route/qdisc/cbq.c route/qdisc/dsmark.c \
 	route/qdisc/fifo.c route/qdisc/htb.c route/qdisc/netem.c \
diff --git a/lib/route/link/vxlan.c b/lib/route/link/vxlan.c
new file mode 100644
index 0000000..f3e3538
--- /dev/null
+++ b/lib/route/link/vxlan.c
@@ -0,0 +1,1157 @@
+/*
+ * lib/route/link/vxlan.c	VXLAN Link Info
+ *
+ *	This library is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU Lesser General Public
+ *	License as published by the Free Software Foundation version 2.1
+ *	of the License.
+ *
+ * Copyright (c) 2013 Yasunobu Chiba <yasu@dsl.gr.jp>
+ */
+
+/**
+ * @ingroup link
+ * @defgroup vxlan VXLAN
+ * Virtual eXtensible Local Area Network link module
+ *
+ * @details
+ * \b Link Type Name: "vxlan"
+ *
+ * @route_doc{link_vxlan, VXLAN Documentation}
+ *
+ * @{
+ */
+
+#include <netlink-private/netlink.h>
+#include <netlink/netlink.h>
+#include <netlink/attr.h>
+#include <netlink/utils.h>
+#include <netlink/object.h>
+#include <netlink/route/rtnl.h>
+#include <netlink-private/route/link/api.h>
+#include <netlink/route/link/vxlan.h>
+
+#include <linux/if_link.h>
+
+/** @cond SKIP */
+#define VXLAN_HAS_ID	(1<<0)
+#define VXLAN_HAS_GROUP	(1<<1)
+#define VXLAN_HAS_LINK	(1<<2)
+#define VXLAN_HAS_LOCAL	(1<<3)
+#define VXLAN_HAS_TTL	(1<<4)
+#define VXLAN_HAS_TOS	(1<<5)
+#define VXLAN_HAS_LEARNING	(1<<6)
+#define VXLAN_HAS_AGEING	(1<<7)
+#define VXLAN_HAS_LIMIT		(1<<8)
+#define VXLAN_HAS_PORT_RANGE	(1<<9)
+#define VXLAN_HAS_PROXY	(1<<10)
+#define VXLAN_HAS_RSC	(1<<11)
+#define VXLAN_HAS_L2MISS	(1<<12)
+#define VXLAN_HAS_L3MISS	(1<<13)
+
+struct vxlan_info
+{
+	uint32_t		vxi_id;
+	uint32_t		vxi_group;
+	uint32_t		vxi_link;
+	uint32_t		vxi_local;
+	uint8_t			vxi_ttl;
+	uint8_t			vxi_tos;
+	uint8_t			vxi_learning;
+	uint32_t		vxi_ageing;
+	uint32_t		vxi_limit;
+	struct ifla_vxlan_port_range	vxi_port_range;
+	uint8_t			vxi_proxy;
+	uint8_t			vxi_rsc;
+	uint8_t			vxi_l2miss;
+	uint8_t			vxi_l3miss;
+	uint32_t		vxi_mask;
+};
+
+/** @endcond */
+
+static struct nla_policy vxlan_policy[IFLA_VXLAN_MAX+1] = {
+	[IFLA_VXLAN_ID]	= { .type = NLA_U32 },
+	[IFLA_VXLAN_GROUP] = { .minlen = sizeof(uint32_t) },
+	[IFLA_VXLAN_LINK] = { .type = NLA_U32 },
+	[IFLA_VXLAN_LOCAL] = { .minlen = sizeof(uint32_t) },
+	[IFLA_VXLAN_TTL] = { .type = NLA_U8 },
+	[IFLA_VXLAN_TOS] = { .type = NLA_U8 },
+	[IFLA_VXLAN_LEARNING] = { .type = NLA_U8 },
+	[IFLA_VXLAN_AGEING] = { .type = NLA_U32 },
+	[IFLA_VXLAN_LIMIT] = { .type = NLA_U32 },
+	[IFLA_VXLAN_PORT_RANGE] = { .minlen = sizeof(struct ifla_vxlan_port_range) },
+	[IFLA_VXLAN_PROXY] = { .type = NLA_U8 },
+	[IFLA_VXLAN_RSC] = { .type = NLA_U8 },
+	[IFLA_VXLAN_L2MISS] = { .type = NLA_U8 },
+	[IFLA_VXLAN_L3MISS] = { .type = NLA_U8 },
+};
+
+static int vxlan_alloc(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi;
+
+	if ((vxi = calloc(1, sizeof(*vxi))) == NULL)
+		return -NLE_NOMEM;
+
+	link->l_info = vxi;
+
+	return 0;
+}
+
+static int vxlan_parse(struct rtnl_link *link, struct nlattr *data,
+		      struct nlattr *xstats)
+{
+	struct nlattr *tb[IFLA_VXLAN_MAX+1];
+	struct vxlan_info *vxi;
+	int err;
+
+	NL_DBG(3, "Parsing VXLAN link info");
+
+	if ((err = nla_parse_nested(tb, IFLA_VXLAN_MAX, data, vxlan_policy)) < 0)
+		goto errout;
+
+	if ((err = vxlan_alloc(link)) < 0)
+		goto errout;
+
+	vxi = link->l_info;
+
+	if (tb[IFLA_VXLAN_ID]) {
+		vxi->vxi_id = nla_get_u32(tb[IFLA_VXLAN_ID]);
+		vxi->vxi_mask |= VXLAN_HAS_ID;
+	}
+
+	if (tb[IFLA_VXLAN_GROUP]) {
+		nla_memcpy(&vxi->vxi_group, tb[IFLA_VXLAN_GROUP],
+				   sizeof(vxi->vxi_group));
+		vxi->vxi_mask |= VXLAN_HAS_GROUP;
+	}
+
+	if (tb[IFLA_VXLAN_LINK]) {
+		vxi->vxi_link = nla_get_u32(tb[IFLA_VXLAN_LINK]);
+		vxi->vxi_mask |= VXLAN_HAS_LINK;
+	}
+
+	if (tb[IFLA_VXLAN_LOCAL]) {
+		nla_memcpy(&vxi->vxi_local, tb[IFLA_VXLAN_LOCAL],
+				   sizeof(vxi->vxi_local));
+		vxi->vxi_mask |= VXLAN_HAS_LOCAL;
+	}
+
+	if (tb[IFLA_VXLAN_TTL]) {
+		vxi->vxi_ttl = nla_get_u8(tb[IFLA_VXLAN_TTL]);
+		vxi->vxi_mask |= VXLAN_HAS_TTL;
+	}
+
+	if (tb[IFLA_VXLAN_TOS]) {
+		vxi->vxi_tos = nla_get_u8(tb[IFLA_VXLAN_TOS]);
+		vxi->vxi_mask |= VXLAN_HAS_TOS;
+	}
+
+	if (tb[IFLA_VXLAN_LEARNING]) {
+		vxi->vxi_learning = nla_get_u8(tb[IFLA_VXLAN_LEARNING]);
+		vxi->vxi_mask |= VXLAN_HAS_LEARNING;
+	}
+
+	if (tb[IFLA_VXLAN_AGEING]) {
+		vxi->vxi_ageing = nla_get_u32(tb[IFLA_VXLAN_AGEING]);
+		vxi->vxi_mask |= VXLAN_HAS_AGEING;
+	}
+
+	if (tb[IFLA_VXLAN_LIMIT]) {
+		vxi->vxi_limit = nla_get_u32(tb[IFLA_VXLAN_LIMIT]);
+		vxi->vxi_mask |= VXLAN_HAS_LIMIT;
+	}
+
+	if (tb[IFLA_VXLAN_PORT_RANGE]) {
+		nla_memcpy(&vxi->vxi_port_range, tb[IFLA_VXLAN_PORT_RANGE],
+				   sizeof(vxi->vxi_port_range));
+		vxi->vxi_mask |= VXLAN_HAS_PORT_RANGE;
+	}
+
+	if (tb[IFLA_VXLAN_PROXY]) {
+		vxi->vxi_proxy = nla_get_u8(tb[IFLA_VXLAN_PROXY]);
+		vxi->vxi_mask |= VXLAN_HAS_PROXY;
+	}
+
+	if (tb[IFLA_VXLAN_RSC]) {
+		vxi->vxi_rsc = nla_get_u8(tb[IFLA_VXLAN_RSC]);
+		vxi->vxi_mask |= VXLAN_HAS_RSC;
+	}
+
+	if (tb[IFLA_VXLAN_L2MISS]) {
+		vxi->vxi_l2miss = nla_get_u8(tb[IFLA_VXLAN_L2MISS]);
+		vxi->vxi_mask |= VXLAN_HAS_L2MISS;
+	}
+
+	if (tb[IFLA_VXLAN_L3MISS]) {
+		vxi->vxi_l3miss = nla_get_u8(tb[IFLA_VXLAN_L3MISS]);
+		vxi->vxi_mask |= VXLAN_HAS_L3MISS;
+	}
+
+	err = 0;
+
+errout:
+	return err;
+}
+
+static void vxlan_free(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	free(vxi);
+	link->l_info = NULL;
+}
+
+static void vxlan_dump_line(struct rtnl_link *link, struct nl_dump_params *p)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	nl_dump(p, "vxlan-id %u", vxi->vxi_id);
+}
+
+static void vxlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
+{
+	struct vxlan_info *vxi = link->l_info;
+	char *name, addr[INET_ADDRSTRLEN];
+
+	nl_dump_line(p, "    vxlan-id %u\n", vxi->vxi_id);
+
+	if (vxi->vxi_mask & VXLAN_HAS_GROUP) {
+		nl_dump(p, "      group ");
+		if(inet_ntop(AF_INET, &vxi->vxi_group, addr, sizeof(addr)))
+			nl_dump_line(p, "%s\n", addr);
+		else
+			nl_dump_line(p, "%#x\n", ntohs(vxi->vxi_group));
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_LINK) {
+		nl_dump(p, "      link ");
+		name = rtnl_link_get_name(link);
+		if (name)
+			nl_dump_line(p, "%s\n", name);
+		else
+			nl_dump_line(p, "%u\n", vxi->vxi_link);
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_LOCAL) {
+		nl_dump(p, "      local ");
+		if(inet_ntop(AF_INET, &vxi->vxi_local, addr, sizeof(addr)))
+			nl_dump_line(p, "%s\n", addr);
+		else
+			nl_dump_line(p, "%#x\n", ntohs(vxi->vxi_local));
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_TTL) {
+		nl_dump(p, "      ttl ");
+		if(vxi->vxi_ttl)
+			nl_dump_line(p, "%u\n", vxi->vxi_ttl);
+		else
+			nl_dump_line(p, "inherit\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_TOS) {
+		nl_dump(p, "      tos ");
+		if (vxi->vxi_tos == 1)
+			nl_dump_line(p, "inherit\n", vxi->vxi_tos);
+		else
+			nl_dump_line(p, "%#x\n", vxi->vxi_tos);
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_LEARNING) {
+		nl_dump(p, "      learning ");
+		if (vxi->vxi_learning)
+			nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_learning);
+		else
+			nl_dump_line(p, "disabled\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_AGEING) {
+		nl_dump(p, "      ageing ");
+		if (vxi->vxi_ageing)
+			nl_dump_line(p, "%u seconds\n", vxi->vxi_ageing);
+		else
+			nl_dump_line(p, "disabled\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_LIMIT) {
+		nl_dump(p, "      limit ");
+		if (vxi->vxi_limit)
+			nl_dump_line(p, "%u\n", vxi->vxi_limit);
+		else
+			nl_dump_line(p, "unlimited\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_PORT_RANGE)
+		nl_dump_line(p, "      port range %u - %u\n",
+					 ntohs(vxi->vxi_port_range.low),
+					 ntohs(vxi->vxi_port_range.high));
+
+	if (vxi->vxi_mask & VXLAN_HAS_PROXY) {
+		nl_dump(p, "      proxy ");
+		if (vxi->vxi_proxy)
+			nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_proxy);
+		else
+			nl_dump_line(p, "disabled\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_RSC) {
+		nl_dump(p, "      rsc ");
+		if (vxi->vxi_rsc)
+			nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_rsc);
+		else
+			nl_dump_line(p, "disabled\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_L2MISS) {
+		nl_dump(p, "      l2miss ");
+		if (vxi->vxi_l2miss)
+			nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_l2miss);
+		else
+			nl_dump_line(p, "disabled\n");
+	}
+
+	if (vxi->vxi_mask & VXLAN_HAS_L3MISS) {
+		nl_dump(p, "      l3miss ");
+		if (vxi->vxi_l3miss)
+			nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_l3miss);
+		else
+			nl_dump_line(p, "disabled\n");
+	}
+}
+
+static int vxlan_clone(struct rtnl_link *dst, struct rtnl_link *src)
+{
+	struct vxlan_info *vdst, *vsrc = src->l_info;
+	int err;
+
+	dst->l_info = NULL;
+	if ((err = rtnl_link_set_type(dst, "vxlan")) < 0)
+		return err;
+	vdst = dst->l_info;
+
+	if (!vdst || !vsrc)
+		return -NLE_NOMEM;
+
+	memcpy(vdst, vsrc, sizeof(struct vxlan_info));
+
+	return 0;
+}
+
+static int vxlan_put_attrs(struct nl_msg *msg, struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+	struct nlattr *data;
+
+	if (!(data = nla_nest_start(msg, IFLA_INFO_DATA)))
+		return -NLE_MSGSIZE;
+
+	if (vxi->vxi_mask & VXLAN_HAS_ID)
+		NLA_PUT_U32(msg, IFLA_VXLAN_ID, vxi->vxi_id);
+
+	if (vxi->vxi_mask & VXLAN_HAS_GROUP)
+		NLA_PUT(msg, IFLA_VXLAN_GROUP, sizeof(vxi->vxi_group), &vxi->vxi_group);
+
+	if (vxi->vxi_mask & VXLAN_HAS_LINK)
+		NLA_PUT_U32(msg, IFLA_VXLAN_LINK, vxi->vxi_link);
+
+	if (vxi->vxi_mask & VXLAN_HAS_LOCAL)
+		NLA_PUT(msg, IFLA_VXLAN_LOCAL, sizeof(vxi->vxi_local), &vxi->vxi_local);
+
+	if (vxi->vxi_mask & VXLAN_HAS_TTL)
+		NLA_PUT_U8(msg, IFLA_VXLAN_TTL, vxi->vxi_ttl);
+
+	if (vxi->vxi_mask & VXLAN_HAS_TOS)
+		NLA_PUT_U8(msg, IFLA_VXLAN_TOS, vxi->vxi_tos);
+
+	if (vxi->vxi_mask & VXLAN_HAS_LEARNING)
+		NLA_PUT_U8(msg, IFLA_VXLAN_LEARNING, vxi->vxi_learning);
+
+	if (vxi->vxi_mask & VXLAN_HAS_AGEING)
+		NLA_PUT_U32(msg, IFLA_VXLAN_AGEING, vxi->vxi_ageing);
+
+	if (vxi->vxi_mask & VXLAN_HAS_LIMIT)
+		NLA_PUT_U32(msg, IFLA_VXLAN_LIMIT, vxi->vxi_limit);
+
+	if (vxi->vxi_mask & VXLAN_HAS_PORT_RANGE)
+		NLA_PUT(msg, IFLA_VXLAN_PORT_RANGE, sizeof(vxi->vxi_port_range),
+				&vxi->vxi_port_range);
+
+	if (vxi->vxi_mask & VXLAN_HAS_PROXY)
+		NLA_PUT_U8(msg, IFLA_VXLAN_PROXY, vxi->vxi_proxy);
+
+	if (vxi->vxi_mask & VXLAN_HAS_RSC)
+		NLA_PUT_U8(msg, IFLA_VXLAN_RSC, vxi->vxi_rsc);
+
+	if (vxi->vxi_mask & VXLAN_HAS_L2MISS)
+		NLA_PUT_U8(msg, IFLA_VXLAN_L2MISS, vxi->vxi_l2miss);
+
+	if (vxi->vxi_mask & VXLAN_HAS_L3MISS)
+		NLA_PUT_U8(msg, IFLA_VXLAN_L3MISS, vxi->vxi_l3miss);
+
+	nla_nest_end(msg, data);
+
+nla_put_failure:
+
+	return 0;
+}
+
+static struct rtnl_link_info_ops vxlan_info_ops = {
+	.io_name		= "vxlan",
+	.io_alloc		= vxlan_alloc,
+	.io_parse		= vxlan_parse,
+	.io_dump = {
+	    [NL_DUMP_LINE]	= vxlan_dump_line,
+	    [NL_DUMP_DETAILS]	= vxlan_dump_details,
+	},
+	.io_clone		= vxlan_clone,
+	.io_put_attrs		= vxlan_put_attrs,
+	.io_free		= vxlan_free,
+};
+
+/** @cond SKIP */
+#define IS_VXLAN_LINK_ASSERT(link) \
+	if ((link)->l_info_ops != &vxlan_info_ops) { \
+		APPBUG("Link is not a vxlan link. set type \"vxlan\" first."); \
+		return -NLE_OPNOTSUPP; \
+	}
+/** @endcond */
+
+/**
+ * @name VXLAN Object
+ * @{
+ */
+
+/**
+ * Allocate link object of type VXLAN
+ *
+ * @return Allocated link object or NULL.
+ */
+struct rtnl_link *rtnl_link_vxlan_alloc(void)
+{
+	struct rtnl_link *link;
+	int err;
+
+	if (!(link = rtnl_link_alloc()))
+		return NULL;
+
+	if ((err = rtnl_link_set_type(link, "vxlan")) < 0) {
+		rtnl_link_put(link);
+		return NULL;
+	}
+
+	return link;
+}
+
+/**
+ * Check if link is a VXLAN link
+ * @arg link		Link object
+ *
+ * @return True if link is a VXLAN link, otherwise false is returned.
+ */
+int rtnl_link_is_vxlan(struct rtnl_link *link)
+{
+	return link->l_info_ops && !strcmp(link->l_info_ops->io_name, "vxlan");
+}
+
+/**
+ * Set VXLAN Network Identifier
+ * @arg link		Link object
+ * @arg id		VXLAN network identifier (or VXLAN segment identifier)
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_id(struct rtnl_link *link, uint32_t id)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (id > VXLAN_ID_MAX)
+		return -NLE_INVAL;
+
+	vxi->vxi_id = id;
+	vxi->vxi_mask |= VXLAN_HAS_ID;
+
+	return 0;
+}
+
+/**
+ * Get VXLAN Network Identifier
+ * @arg link		Link object
+ * @arg id			Pointer to store network identifier
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_id(struct rtnl_link *link, uint32_t *id)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if(!id)
+		return -NLE_INVAL;
+
+	if (vxi->vxi_mask & VXLAN_HAS_ID)
+		*id = vxi->vxi_id;
+	else
+		return -NLE_AGAIN;
+
+	return 0;
+}
+
+/**
+ * Set VXLAN multicast IP address
+ * @arg link		Link object
+ * @arg addr		Multicast IP address to join
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_group(struct rtnl_link *link, struct nl_addr *addr)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if ((nl_addr_get_family(addr) != AF_INET) ||
+		(nl_addr_get_len(addr) != sizeof(vxi->vxi_group)))
+		return -NLE_INVAL;
+
+	memcpy(&vxi->vxi_group, nl_addr_get_binary_addr(addr),
+		   sizeof(vxi->vxi_group));
+	vxi->vxi_mask |= VXLAN_HAS_GROUP;
+
+	return 0;
+}
+
+/**
+ * Get VXLAN multicast IP address
+ * @arg link		Link object
+ * @arg addr		Pointer to store multicast IP address
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_group(struct rtnl_link *link, struct nl_addr **addr)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!addr)
+		return -NLE_INVAL;
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_GROUP))
+		return -NLE_AGAIN;
+
+	*addr = nl_addr_build(AF_INET, &vxi->vxi_group, sizeof(vxi->vxi_group));
+
+	return 0;
+}
+
+/**
+ * Set physical device to use for VXLAN
+ * @arg link		Link object
+ * @arg index		Interface index
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_link(struct rtnl_link *link, uint32_t index)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_link = index;
+	vxi->vxi_mask |= VXLAN_HAS_LINK;
+
+	return 0;
+}
+
+/**
+ * Get physical device to use for VXLAN
+ * @arg link		Link object
+ * @arg index		Pointer to store interface index
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_link(struct rtnl_link *link, uint32_t *index)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!index)
+		return -NLE_INVAL;
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_LINK))
+		return -NLE_AGAIN;
+
+	*index = vxi->vxi_link;
+
+	return 0;
+}
+
+/**
+ * Set source address to use for VXLAN
+ * @arg link		Link object
+ * @arg addr		Local address
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_local(struct rtnl_link *link, struct nl_addr *addr)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if ((nl_addr_get_family(addr) != AF_INET) ||
+		(nl_addr_get_len(addr) != sizeof(vxi->vxi_local)))
+		return -NLE_INVAL;
+
+	memcpy(&vxi->vxi_local, nl_addr_get_binary_addr(addr),
+		   sizeof(vxi->vxi_local));
+	vxi->vxi_mask |= VXLAN_HAS_LOCAL;
+
+	return 0;
+}
+
+/**
+ * Get source address to use for VXLAN
+ * @arg link		Link object
+ * @arg addr		Pointer to store local address
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_local(struct rtnl_link *link, struct nl_addr **addr)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!addr)
+		return -NLE_INVAL;
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_LOCAL))
+		return -NLE_AGAIN;
+
+	*addr = nl_addr_build(AF_INET, &vxi->vxi_local, sizeof(vxi->vxi_local));
+
+	return 0;
+}
+
+/**
+ * Set IP TTL value to use for VXLAN
+ * @arg link		Link object
+ * @arg ttl			TTL value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_ttl(struct rtnl_link *link, uint8_t ttl)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_ttl = ttl;
+	vxi->vxi_mask |= VXLAN_HAS_TTL;
+
+	return 0;
+}
+
+/**
+ * Get IP TTL value to use for VXLAN
+ * @arg link		Link object
+ *
+ * @return TTL value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_ttl(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_TTL))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_ttl;
+}
+
+/**
+ * Set IP ToS value to use for VXLAN
+ * @arg link		Link object
+ * @arg tos		ToS value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_tos(struct rtnl_link *link, uint8_t tos)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_tos = tos;
+	vxi->vxi_mask |= VXLAN_HAS_TOS;
+
+	return 0;
+}
+
+/**
+ * Get IP ToS value to use for VXLAN
+ * @arg link		Link object
+ *
+ * @return ToS value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_tos(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_TOS))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_tos;
+}
+
+/**
+ * Set VXLAN learning status
+ * @arg link		Link object
+ * @arg learning	Learning status value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_learning(struct rtnl_link *link, uint8_t learning)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_learning = learning;
+	vxi->vxi_mask |= VXLAN_HAS_LEARNING;
+
+	return 0;
+}
+
+/**
+ * Get VXLAN learning status
+ * @arg link		Link object
+ *
+ * @return Learning status value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_learning(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_LEARNING))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_learning;
+}
+
+/**
+ * Enable VXLAN address learning
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_enable_learning(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_learning(link, 1);
+}
+
+/**
+ * Disable VXLAN address learning
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_disable_learning(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_learning(link, 0);
+}
+
+/**
+ * Set expiration timer value to use for VXLAN
+ * @arg link		Link object
+ * @arg expiry		Expiration timer value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_ageing(struct rtnl_link *link, uint32_t expiry)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_ageing = expiry;
+	vxi->vxi_mask |= VXLAN_HAS_AGEING;
+
+	return 0;
+}
+
+/**
+ * Get expiration timer value to use for VXLAN
+ * @arg link		Link object
+ * @arg expiry		Pointer to store expiration timer value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_ageing(struct rtnl_link *link, uint32_t *expiry)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!expiry)
+		return -NLE_INVAL;
+
+	if (vxi->vxi_mask & VXLAN_HAS_AGEING)
+		*expiry = vxi->vxi_ageing;
+	else
+		return -NLE_AGAIN;
+
+	return 0;
+}
+
+/**
+ * Set maximum number of forwarding database entries to use for VXLAN
+ * @arg link		Link object
+ * @arg limit		Maximum number
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_limit(struct rtnl_link *link, uint32_t limit)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_limit = limit;
+	vxi->vxi_mask |= VXLAN_HAS_LIMIT;
+
+	return 0;
+}
+
+/**
+ * Get maximum number of forwarding database entries to use for VXLAN
+ * @arg link		Link object
+ * @arg limit		Pointer to store maximum number
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_limit(struct rtnl_link *link, uint32_t *limit)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!limit)
+		return -NLE_INVAL;
+
+	if (vxi->vxi_mask & VXLAN_HAS_LIMIT)
+		*limit = vxi->vxi_limit;
+	else
+		return -NLE_AGAIN;
+
+	return 0;
+}
+
+/**
+ * Set range of UDP port numbers to use for VXLAN
+ * @arg link		Link object
+ * @arg range		Port number range
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_port_range(struct rtnl_link *link,
+								   struct ifla_vxlan_port_range *range)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!range)
+		return -NLE_INVAL;
+
+	memcpy(&vxi->vxi_port_range, range, sizeof(vxi->vxi_port_range));
+	vxi->vxi_mask |= VXLAN_HAS_PORT_RANGE;
+
+	return 0;
+}
+
+/**
+ * Get range of UDP port numbers to use for VXLAN
+ * @arg link		Link object
+ * @arg range		Pointer to store port range
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_get_port_range(struct rtnl_link *link,
+								   struct ifla_vxlan_port_range *range)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!range)
+		return -NLE_INVAL;
+
+	if (vxi->vxi_mask & VXLAN_HAS_PORT_RANGE)
+		memcpy(range, &vxi->vxi_port_range, sizeof(*range));
+	else
+		return -NLE_AGAIN;
+
+	return 0;
+}
+
+/**
+ * Set ARP proxy status to use for VXLAN
+ * @arg link		Link object
+ * @arg proxy		Status value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_proxy(struct rtnl_link *link, uint8_t proxy)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_proxy = proxy;
+	vxi->vxi_mask |= VXLAN_HAS_PROXY;
+
+	return 0;
+}
+
+/**
+ * Get ARP proxy status to use for VXLAN
+ * @arg link		Link object
+ *
+ * @return Status value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_proxy(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_PROXY))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_proxy;
+}
+
+/**
+ * Enable ARP proxy
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_enable_proxy(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_proxy(link, 1);
+}
+
+/**
+ * Disable ARP proxy
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_disable_proxy(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_proxy(link, 0);
+}
+
+/**
+ * Set Route Short Circuit status to use for VXLAN
+ * @arg link		Link object
+ * @arg rsc			Status value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_rsc(struct rtnl_link *link, uint8_t rsc)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_rsc = rsc;
+	vxi->vxi_mask |= VXLAN_HAS_RSC;
+
+	return 0;
+}
+
+/**
+ * Get Route Short Circuit status to use for VXLAN
+ * @arg link		Link object
+ *
+ * @return Status value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_rsc(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_RSC))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_rsc;
+}
+
+/**
+ * Enable Route Short Circuit
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_enable_rsc(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_rsc(link, 1);
+}
+
+/**
+ * Disable Route Short Circuit
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_disable_rsc(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_rsc(link, 0);
+}
+
+/**
+ * Set netlink LLADDR miss notification status to use for VXLAN
+ * @arg link		Link object
+ * @arg miss		Status value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_l2miss(struct rtnl_link *link, uint8_t miss)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_l2miss = miss;
+	vxi->vxi_mask |= VXLAN_HAS_L2MISS;
+
+	return 0;
+}
+
+/**
+ * Get netlink LLADDR miss notification status to use for VXLAN
+ * @arg link		Link object
+ *
+ * @return Status value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_l2miss(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_L2MISS))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_l2miss;
+}
+
+/**
+ * Enable netlink LLADDR miss notifications
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_enable_l2miss(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_l2miss(link, 1);
+}
+
+/**
+ * Disable netlink LLADDR miss notifications
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_disable_l2miss(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_l2miss(link, 0);
+}
+
+/**
+ * Set netlink IP ADDR miss notification status to use for VXLAN
+ * @arg link		Link object
+ * @arg miss		Status value
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_set_l3miss(struct rtnl_link *link, uint8_t miss)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	vxi->vxi_l3miss = miss;
+	vxi->vxi_mask |= VXLAN_HAS_L3MISS;
+
+	return 0;
+}
+
+/**
+ * Get netlink IP ADDR miss notification status to use for VXLAN
+ * @arg link		Link object
+ *
+ * @return Status value on success or a negative error code
+ */
+int rtnl_link_vxlan_get_l3miss(struct rtnl_link *link)
+{
+	struct vxlan_info *vxi = link->l_info;
+
+	IS_VXLAN_LINK_ASSERT(link);
+
+	if (!(vxi->vxi_mask & VXLAN_HAS_L3MISS))
+		return -NLE_AGAIN;
+
+	return vxi->vxi_l3miss;
+}
+
+/**
+ * Enable netlink IP DDR miss notifications
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_enable_l3miss(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_l3miss(link, 1);
+}
+
+/**
+ * Disable netlink IP ADDR miss notifications
+ * @arg link		Link object
+ *
+ * @return 0 on success or a negative error code
+ */
+int rtnl_link_vxlan_disable_l3miss(struct rtnl_link *link)
+{
+	return rtnl_link_vxlan_set_l3miss(link, 0);
+}
+
+/** @} */
+
+static void __init vxlan_init(void)
+{
+	rtnl_link_register_info(&vxlan_info_ops);
+}
+
+static void __exit vxlan_exit(void)
+{
+	rtnl_link_unregister_info(&vxlan_info_ops);
+}
+
+/** @} */