[mirror_frr.git] / zebra / zebra_fpm_netlink.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Code for encoding/decoding FPM messages that are in netlink format.
 *
 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
 * Copyright (C) 2012 by Open Source Routing.
 * Copyright (C) 2012 by Internet Systems Consortium, Inc. ("ISC")
 */

#include <zebra.h>

#ifdef HAVE_NETLINK

#include "log.h"
#include "rib.h"
#include "vty.h"
#include "prefix.h"

#include "zebra/zserv.h"
#include "zebra/zebra_router.h"
#include "zebra/zebra_dplane.h"
#include "zebra/zebra_ns.h"
#include "zebra/zebra_vrf.h"
#include "zebra/kernel_netlink.h"
#include "zebra/rt_netlink.h"
#include "nexthop.h"

#include "zebra/zebra_fpm_private.h"
#include "zebra/zebra_vxlan_private.h"
#include "zebra/interface.h"

/*
 * af_addr_size
 *
 * The size of an address in a given address family.
 */
static size_t af_addr_size(uint8_t af)
{
	switch (af) {

	case AF_INET:
		return 4;
	case AF_INET6:
		return 16;
	default:
		assert(0);
		return 16;
	}
}

/*
 * We plan to use RTA_ENCAP_TYPE attribute for VxLAN encap as well.
 * Currently, values 0 to 8 for this attribute are used by lwtunnel_encap_types
 * So, we cannot use these values for VxLAN encap.
 */
enum fpm_nh_encap_type_t {
	FPM_NH_ENCAP_NONE = 0,
	FPM_NH_ENCAP_VXLAN = 100,
	FPM_NH_ENCAP_MAX,
};

/*
 * fpm_nh_encap_type_to_str
 */
static const char *fpm_nh_encap_type_to_str(enum fpm_nh_encap_type_t encap_type)
{
	switch (encap_type) {
	case FPM_NH_ENCAP_NONE:
		return "none";

	case FPM_NH_ENCAP_VXLAN:
		return "VxLAN";

	case FPM_NH_ENCAP_MAX:
		return "invalid";
	}

	return "invalid";
}

struct vxlan_encap_info_t {
	vni_t vni;
};

enum vxlan_encap_info_type_t {
	VXLAN_VNI = 0,
};

struct fpm_nh_encap_info_t {
	enum fpm_nh_encap_type_t encap_type;
	union {
		struct vxlan_encap_info_t vxlan_encap;
	};
};

/*
 * netlink_nh_info
 *
 * Holds information about a single nexthop for netlink. These info
 * structures are transient and may contain pointers into rib
 * data structures for convenience.
 */
struct netlink_nh_info {
	/* Weight of the nexthop ( for unequal cost ECMP ) */
	uint8_t weight;
	uint32_t if_index;
	union g_addr *gateway;

	/*
	 * Information from the struct nexthop from which this nh was
	 * derived. For debug purposes only.
	 */
	int recursive;
	enum nexthop_types_t type;
	struct fpm_nh_encap_info_t encap_info;
};

/*
 * netlink_route_info
 *
 * A structure for holding information for a netlink route message.
 */
struct netlink_route_info {
	uint32_t nlmsg_pid;
	uint16_t nlmsg_type;
	uint8_t rtm_type;
	uint32_t rtm_table;
	uint8_t rtm_protocol;
	uint8_t af;
	struct prefix *prefix;
	uint32_t *metric;
	unsigned int num_nhs;

	/*
	 * Nexthop structures
	 */
	struct netlink_nh_info nhs[MULTIPATH_NUM];
	union g_addr *pref_src;
};

/*
 * netlink_route_info_add_nh
 *
 * Add information about the given nexthop to the given route info
 * structure.
 *
 * Returns true if a nexthop was added, false otherwise.
 */
static int netlink_route_info_add_nh(struct netlink_route_info *ri,
				     struct nexthop *nexthop,
				     struct route_entry *re)
{
	struct netlink_nh_info nhi;
	union g_addr *src;
	struct zebra_vrf *zvrf = NULL;
	struct interface *ifp = NULL, *link_if = NULL;
	struct zebra_if *zif = NULL;
	vni_t vni = 0;

	memset(&nhi, 0, sizeof(nhi));
	src = NULL;

	if (ri->num_nhs >= (int)array_size(ri->nhs))
		return 0;

	nhi.recursive = nexthop->rparent ? 1 : 0;
	nhi.type = nexthop->type;
	nhi.if_index = nexthop->ifindex;
	nhi.weight = nexthop->weight;

	if (nexthop->type == NEXTHOP_TYPE_IPV4
	    || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX) {
		nhi.gateway = &nexthop->gate;
		if (nexthop->src.ipv4.s_addr != INADDR_ANY)
			src = &nexthop->src;
	}

	if (nexthop->type == NEXTHOP_TYPE_IPV6
	    || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
		/* Special handling for IPv4 route with IPv6 Link Local next hop
		 */
		if (ri->af == AF_INET)
			nhi.gateway = &ipv4ll_gateway;
		else
			nhi.gateway = &nexthop->gate;
	}

	if (nexthop->type == NEXTHOP_TYPE_IFINDEX) {
		if (nexthop->src.ipv4.s_addr != INADDR_ANY)
			src = &nexthop->src;
	}

	if (!nhi.gateway && nhi.if_index == 0)
		return 0;

	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_EVPN)) {
		nhi.encap_info.encap_type = FPM_NH_ENCAP_VXLAN;

		/* Extract VNI id for the nexthop SVI interface */
		zvrf = zebra_vrf_lookup_by_id(nexthop->vrf_id);
		if (zvrf) {
			ifp = if_lookup_by_index_per_ns(zvrf->zns,
							nexthop->ifindex);
			if (ifp) {
				zif = (struct zebra_if *)ifp->info;
				if (zif) {
					if (IS_ZEBRA_IF_BRIDGE(ifp))
						link_if = ifp;
					else if (IS_ZEBRA_IF_VLAN(ifp))
						link_if =
						if_lookup_by_index_per_ns(
							zvrf->zns,
							zif->link_ifindex);
					if (link_if)
						vni = vni_id_from_svi(ifp,
								      link_if);
				}
			}
		}

		nhi.encap_info.vxlan_encap.vni = vni;
	}

	/*
	 * We have a valid nhi. Copy the structure over to the route_info.
	 */
	ri->nhs[ri->num_nhs] = nhi;
	ri->num_nhs++;

	if (src && !ri->pref_src)
		ri->pref_src = src;

	return 1;
}

/*
 * netlink_proto_from_route_type
 */
static uint8_t netlink_proto_from_route_type(int type)
{
	return zebra2proto(type);
}

/*
 * netlink_route_info_fill
 *
 * Fill out the route information object from the given route.
 *
 * Returns true on success and false on failure.
 */
static int netlink_route_info_fill(struct netlink_route_info *ri, int cmd,
				   rib_dest_t *dest, struct route_entry *re)
{
	struct nexthop *nexthop;
	struct rib_table_info *table_info =
		rib_table_info(rib_dest_table(dest));
	struct zebra_vrf *zvrf = table_info->zvrf;

	memset(ri, 0, sizeof(*ri));

	ri->prefix = rib_dest_prefix(dest);
	ri->af = rib_dest_af(dest);

	if (zvrf && zvrf->zns)
		ri->nlmsg_pid = zvrf->zns->netlink_dplane_out.snl.nl_pid;

	ri->nlmsg_type = cmd;
	ri->rtm_table = table_info->table_id;
	ri->rtm_protocol = RTPROT_UNSPEC;

	/*
	 * An RTM_DELROUTE need not be accompanied by any nexthops,
	 * particularly in our communication with the FPM.
	 */
	if (cmd == RTM_DELROUTE && !re)
		return 1;

	if (!re) {
		zfpm_debug("%s: Expected non-NULL re pointer", __func__);
		return 0;
	}

	ri->rtm_protocol = netlink_proto_from_route_type(re->type);
	ri->rtm_type = RTN_UNICAST;
	ri->metric = &re->metric;

	for (ALL_NEXTHOPS(re->nhe->nhg, nexthop)) {
		if (ri->num_nhs >= zrouter.multipath_num)
			break;

		if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
			continue;

		if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE) {
			switch (nexthop->bh_type) {
			case BLACKHOLE_ADMINPROHIB:
				ri->rtm_type = RTN_PROHIBIT;
				break;
			case BLACKHOLE_REJECT:
				ri->rtm_type = RTN_UNREACHABLE;
				break;
			case BLACKHOLE_NULL:
			case BLACKHOLE_UNSPEC:
				ri->rtm_type = RTN_BLACKHOLE;
				break;
			}
		}

		if ((cmd == RTM_NEWROUTE
		     && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
		    || (cmd == RTM_DELROUTE
			&& CHECK_FLAG(re->status, ROUTE_ENTRY_INSTALLED))) {
			netlink_route_info_add_nh(ri, nexthop, re);
		}
	}

	if (ri->num_nhs == 0) {
		switch (ri->rtm_type) {
		case RTN_PROHIBIT:
		case RTN_UNREACHABLE:
		case RTN_BLACKHOLE:
			break;
		default:
			/* If there is no useful nexthop then return. */
			zfpm_debug(
				"netlink_encode_route(): No useful nexthop.");
			return 0;
		}
	}

	return 1;
}

/*
 * netlink_route_info_encode
 *
 * Returns the number of bytes written to the buffer. 0 or a negative
 * value indicates an error.
 */
static int netlink_route_info_encode(struct netlink_route_info *ri,
				     char *in_buf, size_t in_buf_len)
{
	size_t bytelen;
	unsigned int nexthop_num = 0;
	size_t buf_offset;
	struct netlink_nh_info *nhi;
	enum fpm_nh_encap_type_t encap;
	struct rtattr *nest, *inner_nest;
	struct rtnexthop *rtnh;
	struct vxlan_encap_info_t *vxlan;
	struct in6_addr ipv6;

	struct {
		struct nlmsghdr n;
		struct rtmsg r;
		char buf[1];
	} * req;

	req = (void *)in_buf;

	buf_offset = ((char *)req->buf) - ((char *)req);

	if (in_buf_len < buf_offset) {
		assert(0);
		return 0;
	}

	memset(req, 0, buf_offset);

	bytelen = af_addr_size(ri->af);

	req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
	req->n.nlmsg_flags = NLM_F_CREATE | NLM_F_REQUEST;
	req->n.nlmsg_pid = ri->nlmsg_pid;
	req->n.nlmsg_type = ri->nlmsg_type;
	req->r.rtm_family = ri->af;

	/*
	 * rtm_table field is a uchar field which can accommodate table_id less
	 * than 256.
	 * To support table id greater than 255, if the table_id is greater than
	 * 255, set rtm_table to RT_TABLE_UNSPEC and add RTA_TABLE attribute
	 * with 32 bit value as the table_id.
	 */
	if (ri->rtm_table < 256)
		req->r.rtm_table = ri->rtm_table;
	else {
		req->r.rtm_table = RT_TABLE_UNSPEC;
		nl_attr_put32(&req->n, in_buf_len, RTA_TABLE, ri->rtm_table);
	}

	req->r.rtm_dst_len = ri->prefix->prefixlen;
	req->r.rtm_protocol = ri->rtm_protocol;
	req->r.rtm_scope = RT_SCOPE_UNIVERSE;

	nl_attr_put(&req->n, in_buf_len, RTA_DST, &ri->prefix->u.prefix,
		    bytelen);

	req->r.rtm_type = ri->rtm_type;

	/* Metric. */
	if (ri->metric)
		nl_attr_put32(&req->n, in_buf_len, RTA_PRIORITY, *ri->metric);

	if (ri->num_nhs == 0)
		goto done;

	if (ri->num_nhs == 1) {
		nhi = &ri->nhs[0];

		if (nhi->gateway) {
			if (nhi->type == NEXTHOP_TYPE_IPV4_IFINDEX
			    && ri->af == AF_INET6) {
				ipv4_to_ipv4_mapped_ipv6(&ipv6,
							 nhi->gateway->ipv4);
				nl_attr_put(&req->n, in_buf_len, RTA_GATEWAY,
					    &ipv6, bytelen);
			} else
				nl_attr_put(&req->n, in_buf_len, RTA_GATEWAY,
					    nhi->gateway, bytelen);
		}

		if (nhi->if_index) {
			nl_attr_put32(&req->n, in_buf_len, RTA_OIF,
				      nhi->if_index);
		}

		encap = nhi->encap_info.encap_type;
		switch (encap) {
		case FPM_NH_ENCAP_NONE:
		case FPM_NH_ENCAP_MAX:
			break;
		case FPM_NH_ENCAP_VXLAN:
			nl_attr_put16(&req->n, in_buf_len, RTA_ENCAP_TYPE,
				      encap);
			vxlan = &nhi->encap_info.vxlan_encap;
			nest = nl_attr_nest(&req->n, in_buf_len, RTA_ENCAP);
			nl_attr_put32(&req->n, in_buf_len, VXLAN_VNI,
				      vxlan->vni);
			nl_attr_nest_end(&req->n, nest);
			break;
		}

		goto done;
	}

	/*
	 * Multipath case.
	 */
	nest = nl_attr_nest(&req->n, in_buf_len, RTA_MULTIPATH);

	for (nexthop_num = 0; nexthop_num < ri->num_nhs; nexthop_num++) {
		rtnh = nl_attr_rtnh(&req->n, in_buf_len);
		nhi = &ri->nhs[nexthop_num];

		if (nhi->gateway)
			nl_attr_put(&req->n, in_buf_len, RTA_GATEWAY,
				    nhi->gateway, bytelen);

		if (nhi->if_index) {
			rtnh->rtnh_ifindex = nhi->if_index;
		}

		rtnh->rtnh_hops = nhi->weight;

		encap = nhi->encap_info.encap_type;
		switch (encap) {
		case FPM_NH_ENCAP_NONE:
		case FPM_NH_ENCAP_MAX:
			break;
		case FPM_NH_ENCAP_VXLAN:
			nl_attr_put16(&req->n, in_buf_len, RTA_ENCAP_TYPE,
				      encap);
			vxlan = &nhi->encap_info.vxlan_encap;
			inner_nest =
				nl_attr_nest(&req->n, in_buf_len, RTA_ENCAP);
			nl_attr_put32(&req->n, in_buf_len, VXLAN_VNI,
				      vxlan->vni);
			nl_attr_nest_end(&req->n, inner_nest);
			break;
		}

		nl_attr_rtnh_end(&req->n, rtnh);
	}

	nl_attr_nest_end(&req->n, nest);
	assert(nest->rta_len > RTA_LENGTH(0));

done:

	if (ri->pref_src) {
		nl_attr_put(&req->n, in_buf_len, RTA_PREFSRC, ri->pref_src,
			    bytelen);
	}

	assert(req->n.nlmsg_len < in_buf_len);
	return req->n.nlmsg_len;
}

/*
 * zfpm_log_route_info
 *
 * Helper function to log the information in a route_info structure.
 */
static void zfpm_log_route_info(struct netlink_route_info *ri,
				const char *label)
{
	struct netlink_nh_info *nhi;
	unsigned int i;
	char buf[PREFIX_STRLEN];

	zfpm_debug("%s : %s %pFX, Proto: %s, Metric: %u", label,
		   nl_msg_type_to_str(ri->nlmsg_type), ri->prefix,
		   nl_rtproto_to_str(ri->rtm_protocol),
		   ri->metric ? *ri->metric : 0);

	for (i = 0; i < ri->num_nhs; i++) {
		nhi = &ri->nhs[i];

		if (nhi->gateway) {
			if (ri->af == AF_INET)
				inet_ntop(AF_INET, nhi->gateway, buf,
					  sizeof(buf));
			else
				inet_ntop(AF_INET6, nhi->gateway, buf,
					  sizeof(buf));
		} else
			strlcpy(buf, "none", sizeof(buf));

		zfpm_debug("  Intf: %u, Gateway: %s, Recursive: %s, Type: %s, Encap type: %s",
			   nhi->if_index, buf, nhi->recursive ? "yes" : "no",
			   nexthop_type_to_str(nhi->type),
			   fpm_nh_encap_type_to_str(nhi->encap_info.encap_type)
			   );
	}
}

/*
 * zfpm_netlink_encode_route
 *
 * Create a netlink message corresponding to the given route in the
 * given buffer space.
 *
 * Returns the number of bytes written to the buffer. 0 or a negative
 * value indicates an error.
 */
int zfpm_netlink_encode_route(int cmd, rib_dest_t *dest, struct route_entry *re,
			      char *in_buf, size_t in_buf_len)
{
	struct netlink_route_info ri_space, *ri;

	ri = &ri_space;

	if (!netlink_route_info_fill(ri, cmd, dest, re))
		return 0;

	zfpm_log_route_info(ri, __func__);

	return netlink_route_info_encode(ri, in_buf, in_buf_len);
}

/*
 * zfpm_netlink_encode_mac
 *
 * Create a netlink message corresponding to the given MAC.
 *
 * Returns the number of bytes written to the buffer. 0 or a negative
 * value indicates an error.
 */
int zfpm_netlink_encode_mac(struct fpm_mac_info_t *mac, char *in_buf,
			    size_t in_buf_len)
{
	size_t buf_offset;

	struct macmsg {
		struct nlmsghdr hdr;
		struct ndmsg ndm;
		char buf[0];
	} *req;
	req = (void *)in_buf;

	buf_offset = offsetof(struct macmsg, buf);
	if (in_buf_len < buf_offset)
		return 0;
	memset(req, 0, buf_offset);

	/* Construct nlmsg header */
	req->hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
	req->hdr.nlmsg_type = CHECK_FLAG(mac->fpm_flags, ZEBRA_MAC_DELETE_FPM) ?
				RTM_DELNEIGH : RTM_NEWNEIGH;
	req->hdr.nlmsg_flags = NLM_F_REQUEST;
	if (req->hdr.nlmsg_type == RTM_NEWNEIGH)
		req->hdr.nlmsg_flags |= (NLM_F_CREATE | NLM_F_REPLACE);

	/* Construct ndmsg */
	req->ndm.ndm_family = AF_BRIDGE;
	req->ndm.ndm_ifindex = mac->vxlan_if;

	req->ndm.ndm_state = NUD_REACHABLE;
	req->ndm.ndm_flags |= NTF_SELF | NTF_MASTER;
	if (CHECK_FLAG(mac->zebra_flags,
		(ZEBRA_MAC_STICKY | ZEBRA_MAC_REMOTE_DEF_GW)))
		req->ndm.ndm_state |= NUD_NOARP;
	else
		req->ndm.ndm_flags |= NTF_EXT_LEARNED;

	/* Add attributes */
	nl_attr_put(&req->hdr, in_buf_len, NDA_LLADDR, &mac->macaddr, 6);
	nl_attr_put(&req->hdr, in_buf_len, NDA_DST, &mac->r_vtep_ip, 4);
	nl_attr_put32(&req->hdr, in_buf_len, NDA_MASTER, mac->svi_if);
	nl_attr_put32(&req->hdr, in_buf_len, NDA_VNI, mac->vni);

	assert(req->hdr.nlmsg_len < in_buf_len);

	zfpm_debug("Tx %s family %s ifindex %u MAC %pEA DEST %pI4",
		   nl_msg_type_to_str(req->hdr.nlmsg_type),
		   nl_family_to_str(req->ndm.ndm_family), req->ndm.ndm_ifindex,
		   &mac->macaddr, &mac->r_vtep_ip);

	return req->hdr.nlmsg_len;
}

#endif /* HAVE_NETLINK */
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: GPL-2.0-or-later
5adc2528 AS	2	/*
	3	* Code for encoding/decoding FPM messages that are in netlink format.
	4	*
	5	* Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
	6	* Copyright (C) 2012 by Open Source Routing.
	7	* Copyright (C) 2012 by Internet Systems Consortium, Inc. ("ISC")
5adc2528 AS	8	*/
	9
	10	#include <zebra.h>
	11
ddfeb486 DL	12	#ifdef HAVE_NETLINK
ddfeb486 DL	13
5adc2528 AS	14	#include "log.h"
5adc2528 AS	15	#include "rib.h"
82f97584	16	#include "vty.h"
e3be0432	17	#include "prefix.h"
5adc2528	18
1fdc9eae	19	#include "zebra/zserv.h"
b3f2b590	20	#include "zebra/zebra_router.h"
85a75f1e	21	#include "zebra/zebra_dplane.h"
1fdc9eae	22	#include "zebra/zebra_ns.h"
	23	#include "zebra/zebra_vrf.h"
	24	#include "zebra/kernel_netlink.h"
	25	#include "zebra/rt_netlink.h"
fb018d25	26	#include "nexthop.h"
5adc2528	27
1fdc9eae	28	#include "zebra/zebra_fpm_private.h"
9d21b7c6	29	#include "zebra/zebra_vxlan_private.h"
1b09e77e	30	#include "zebra/interface.h"
5adc2528	31
5adc2528 AS	32	/*
	33	* af_addr_size
	34	*
	35	* The size of an address in a given address family.
	36	*/
d7c0a89a	37	static size_t af_addr_size(uint8_t af)
5adc2528	38	{
d62a17ae	39	switch (af) {
	40
	41	case AF_INET:
	42	return 4;
d62a17ae	43	case AF_INET6:
d62a17ae	44	return 16;
d62a17ae	45	default:
	46	assert(0);
	47	return 16;
	48	}
5adc2528 AS	49	}
5adc2528 AS	50
9d21b7c6 AD	51	/*
	52	* We plan to use RTA_ENCAP_TYPE attribute for VxLAN encap as well.
	53	* Currently, values 0 to 8 for this attribute are used by lwtunnel_encap_types
	54	* So, we cannot use these values for VxLAN encap.
	55	*/
	56	enum fpm_nh_encap_type_t {
	57	FPM_NH_ENCAP_NONE = 0,
	58	FPM_NH_ENCAP_VXLAN = 100,
	59	FPM_NH_ENCAP_MAX,
	60	};
	61
	62	/*
	63	* fpm_nh_encap_type_to_str
	64	*/
	65	static const char *fpm_nh_encap_type_to_str(enum fpm_nh_encap_type_t encap_type)
	66	{
	67	switch (encap_type) {
	68	case FPM_NH_ENCAP_NONE:
	69	return "none";
	70
	71	case FPM_NH_ENCAP_VXLAN:
	72	return "VxLAN";
	73
	74	case FPM_NH_ENCAP_MAX:
	75	return "invalid";
	76	}
	77
	78	return "invalid";
	79	}
	80
	81	struct vxlan_encap_info_t {
	82	vni_t vni;
	83	};
	84
	85	enum vxlan_encap_info_type_t {
	86	VXLAN_VNI = 0,
	87	};
	88
	89	struct fpm_nh_encap_info_t {
	90	enum fpm_nh_encap_type_t encap_type;
	91	union {
	92	struct vxlan_encap_info_t vxlan_encap;
	93	};
	94	};
	95
5adc2528	96	/*
7cf19069	97	* netlink_nh_info
5adc2528 AS	98	*
	99	* Holds information about a single nexthop for netlink. These info
	100	* structures are transient and may contain pointers into rib
	101	* data structures for convenience.
	102	*/
7cf19069	103	struct netlink_nh_info {
eca3256d	104	/* Weight of the nexthop ( for unequal cost ECMP ) */
eca3256d	105	uint8_t weight;
d62a17ae	106	uint32_t if_index;
	107	union g_addr *gateway;
	108
	109	/*
	110	* Information from the struct nexthop from which this nh was
	111	* derived. For debug purposes only.
	112	*/
	113	int recursive;
	114	enum nexthop_types_t type;
9d21b7c6	115	struct fpm_nh_encap_info_t encap_info;
7cf19069	116	};
5adc2528 AS	117
5adc2528 AS	118	/*
67ceb408	119	* netlink_route_info
5adc2528 AS	120	*
	121	* A structure for holding information for a netlink route message.
	122	*/
67ceb408	123	struct netlink_route_info {
869a5f71	124	uint32_t nlmsg_pid;
d62a17ae	125	uint16_t nlmsg_type;
d7c0a89a	126	uint8_t rtm_type;
d62a17ae	127	uint32_t rtm_table;
d7c0a89a QY	128	uint8_t rtm_protocol;
d7c0a89a QY	129	uint8_t af;
d62a17ae	130	struct prefix *prefix;
	131	uint32_t *metric;
	132	unsigned int num_nhs;
	133
	134	/*
	135	* Nexthop structures
	136	*/
7cf19069	137	struct netlink_nh_info nhs[MULTIPATH_NUM];
d62a17ae	138	union g_addr *pref_src;
67ceb408	139	};
5adc2528 AS	140
	141	/*
	142	* netlink_route_info_add_nh
	143	*
	144	* Add information about the given nexthop to the given route info
	145	* structure.
	146	*
2951a7a4	147	* Returns true if a nexthop was added, false otherwise.
5adc2528	148	*/
67ceb408	149	static int netlink_route_info_add_nh(struct netlink_route_info *ri,
9d21b7c6 AD	150	struct nexthop *nexthop,
9d21b7c6 AD	151	struct route_entry *re)
5adc2528	152	{
7cf19069	153	struct netlink_nh_info nhi;
d62a17ae	154	union g_addr *src;
1b09e77e AD	155	struct zebra_vrf *zvrf = NULL;
	156	struct interface ifp = NULL, link_if = NULL;
	157	struct zebra_if *zif = NULL;
	158	vni_t vni = 0;
d62a17ae	159
	160	memset(&nhi, 0, sizeof(nhi));
	161	src = NULL;
	162
7e3a1ec7	163	if (ri->num_nhs >= (int)array_size(ri->nhs))
d62a17ae	164	return 0;
	165
	166	nhi.recursive = nexthop->rparent ? 1 : 0;
	167	nhi.type = nexthop->type;
	168	nhi.if_index = nexthop->ifindex;
eca3256d	169	nhi.weight = nexthop->weight;
d62a17ae	170
	171	if (nexthop->type == NEXTHOP_TYPE_IPV4
	172	\|\| nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX) {
	173	nhi.gateway = &nexthop->gate;
975a328e	174	if (nexthop->src.ipv4.s_addr != INADDR_ANY)
d62a17ae	175	src = &nexthop->src;
	176	}
	177
	178	if (nexthop->type == NEXTHOP_TYPE_IPV6
	179	\|\| nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
316d2d52 NK	180	/* Special handling for IPv4 route with IPv6 Link Local next hop
	181	*/
	182	if (ri->af == AF_INET)
	183	nhi.gateway = &ipv4ll_gateway;
	184	else
	185	nhi.gateway = &nexthop->gate;
d62a17ae	186	}
	187
	188	if (nexthop->type == NEXTHOP_TYPE_IFINDEX) {
975a328e	189	if (nexthop->src.ipv4.s_addr != INADDR_ANY)
d62a17ae	190	src = &nexthop->src;
	191	}
	192
	193	if (!nhi.gateway && nhi.if_index == 0)
	194	return 0;
	195
5609e70f	196	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_EVPN)) {
9d21b7c6 AD	197	nhi.encap_info.encap_type = FPM_NH_ENCAP_VXLAN;
9d21b7c6 AD	198
1b09e77e AD	199	/* Extract VNI id for the nexthop SVI interface */
	200	zvrf = zebra_vrf_lookup_by_id(nexthop->vrf_id);
	201	if (zvrf) {
	202	ifp = if_lookup_by_index_per_ns(zvrf->zns,
	203	nexthop->ifindex);
	204	if (ifp) {
	205	zif = (struct zebra_if *)ifp->info;
	206	if (zif) {
	207	if (IS_ZEBRA_IF_BRIDGE(ifp))
	208	link_if = ifp;
	209	else if (IS_ZEBRA_IF_VLAN(ifp))
	210	link_if =
	211	if_lookup_by_index_per_ns(
	212	zvrf->zns,
	213	zif->link_ifindex);
	214	if (link_if)
	215	vni = vni_id_from_svi(ifp,
	216	link_if);
	217	}
	218	}
9d21b7c6	219	}
1b09e77e AD	220
1b09e77e AD	221	nhi.encap_info.vxlan_encap.vni = vni;
9d21b7c6 AD	222	}
9d21b7c6 AD	223
d62a17ae	224	/*
	225	* We have a valid nhi. Copy the structure over to the route_info.
	226	*/
	227	ri->nhs[ri->num_nhs] = nhi;
	228	ri->num_nhs++;
	229
	230	if (src && !ri->pref_src)
	231	ri->pref_src = src;
	232
	233	return 1;
5adc2528 AS	234	}
	235
	236	/*
	237	* netlink_proto_from_route_type
	238	*/
d7c0a89a	239	static uint8_t netlink_proto_from_route_type(int type)
5adc2528	240	{
4a563f27	241	return zebra2proto(type);
5adc2528 AS	242	}
	243
	244	/*
	245	* netlink_route_info_fill
	246	*
	247	* Fill out the route information object from the given route.
	248	*
2951a7a4	249	* Returns true on success and false on failure.
5adc2528	250	*/
67ceb408	251	static int netlink_route_info_fill(struct netlink_route_info *ri, int cmd,
d62a17ae	252	rib_dest_t dest, struct route_entry re)
5adc2528	253	{
d62a17ae	254	struct nexthop *nexthop;
869a5f71 DE	255	struct rib_table_info *table_info =
	256	rib_table_info(rib_dest_table(dest));
	257	struct zebra_vrf *zvrf = table_info->zvrf;
d62a17ae	258
	259	memset(ri, 0, sizeof(*ri));
	260
	261	ri->prefix = rib_dest_prefix(dest);
	262	ri->af = rib_dest_af(dest);
	263
869a5f71	264	if (zvrf && zvrf->zns)
80dcc388	265	ri->nlmsg_pid = zvrf->zns->netlink_dplane_out.snl.nl_pid;
869a5f71	266
d62a17ae	267	ri->nlmsg_type = cmd;
869a5f71	268	ri->rtm_table = table_info->table_id;
d62a17ae	269	ri->rtm_protocol = RTPROT_UNSPEC;
	270
	271	/*
	272	* An RTM_DELROUTE need not be accompanied by any nexthops,
	273	* particularly in our communication with the FPM.
	274	*/
	275	if (cmd == RTM_DELROUTE && !re)
	276	return 1;
	277
	278	if (!re) {
5e81f5dd	279	zfpm_debug("%s: Expected non-NULL re pointer", __func__);
d62a17ae	280	return 0;
	281	}
	282
	283	ri->rtm_protocol = netlink_proto_from_route_type(re->type);
a8309422	284	ri->rtm_type = RTN_UNICAST;
d62a17ae	285	ri->metric = &re->metric;
d62a17ae	286
c415d895	287	for (ALL_NEXTHOPS(re->nhe->nhg, nexthop)) {
b3f2b590	288	if (ri->num_nhs >= zrouter.multipath_num)
d62a17ae	289	break;
	290
	291	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
	292	continue;
	293
a8309422 DL	294	if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE) {
	295	switch (nexthop->bh_type) {
	296	case BLACKHOLE_ADMINPROHIB:
	297	ri->rtm_type = RTN_PROHIBIT;
	298	break;
	299	case BLACKHOLE_REJECT:
	300	ri->rtm_type = RTN_UNREACHABLE;
	301	break;
	302	case BLACKHOLE_NULL:
a98701f0	303	case BLACKHOLE_UNSPEC:
a8309422 DL	304	ri->rtm_type = RTN_BLACKHOLE;
	305	break;
	306	}
a8309422 DL	307	}
a8309422 DL	308
d62a17ae	309	if ((cmd == RTM_NEWROUTE
	310	&& CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
	311	\|\| (cmd == RTM_DELROUTE
677c1dd5	312	&& CHECK_FLAG(re->status, ROUTE_ENTRY_INSTALLED))) {
9d21b7c6	313	netlink_route_info_add_nh(ri, nexthop, re);
d62a17ae	314	}
	315	}
	316
94f77863 DE	317	if (ri->num_nhs == 0) {
	318	switch (ri->rtm_type) {
	319	case RTN_PROHIBIT:
	320	case RTN_UNREACHABLE:
	321	case RTN_BLACKHOLE:
	322	break;
	323	default:
	324	/* If there is no useful nexthop then return. */
	325	zfpm_debug(
	326	"netlink_encode_route(): No useful nexthop.");
	327	return 0;
	328	}
d62a17ae	329	}
	330
	331	return 1;
5adc2528 AS	332	}
	333
	334	/*
	335	* netlink_route_info_encode
	336	*
	337	* Returns the number of bytes written to the buffer. 0 or a negative
	338	* value indicates an error.
	339	*/
67ceb408 DS	340	static int netlink_route_info_encode(struct netlink_route_info *ri,
67ceb408 DS	341	char *in_buf, size_t in_buf_len)
5adc2528	342	{
d62a17ae	343	size_t bytelen;
	344	unsigned int nexthop_num = 0;
	345	size_t buf_offset;
7cf19069	346	struct netlink_nh_info *nhi;
9d21b7c6	347	enum fpm_nh_encap_type_t encap;
312a6bee JU	348	struct rtattr nest, inner_nest;
312a6bee JU	349	struct rtnexthop *rtnh;
9d21b7c6	350	struct vxlan_encap_info_t *vxlan;
92d6f769	351	struct in6_addr ipv6;
5adc2528	352
d62a17ae	353	struct {
	354	struct nlmsghdr n;
	355	struct rtmsg r;
	356	char buf[1];
	357	} * req;
5adc2528	358
d62a17ae	359	req = (void *)in_buf;
5adc2528	360
d62a17ae	361	buf_offset = ((char )req->buf) - ((char )req);
5adc2528	362
d62a17ae	363	if (in_buf_len < buf_offset) {
	364	assert(0);
	365	return 0;
	366	}
5adc2528	367
d62a17ae	368	memset(req, 0, buf_offset);
5adc2528	369
d62a17ae	370	bytelen = af_addr_size(ri->af);
5adc2528	371
d62a17ae	372	req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
d62a17ae	373	req->n.nlmsg_flags = NLM_F_CREATE \| NLM_F_REQUEST;
869a5f71	374	req->n.nlmsg_pid = ri->nlmsg_pid;
d62a17ae	375	req->n.nlmsg_type = ri->nlmsg_type;
d62a17ae	376	req->r.rtm_family = ri->af;
6dfcd754 AD	377
6dfcd754 AD	378	/*
f5267398	379	* rtm_table field is a uchar field which can accommodate table_id less
6dfcd754 AD	380	* than 256.
	381	* To support table id greater than 255, if the table_id is greater than
	382	* 255, set rtm_table to RT_TABLE_UNSPEC and add RTA_TABLE attribute
	383	* with 32 bit value as the table_id.
	384	*/
	385	if (ri->rtm_table < 256)
	386	req->r.rtm_table = ri->rtm_table;
	387	else {
	388	req->r.rtm_table = RT_TABLE_UNSPEC;
312a6bee	389	nl_attr_put32(&req->n, in_buf_len, RTA_TABLE, ri->rtm_table);
6dfcd754 AD	390	}
6dfcd754 AD	391
d62a17ae	392	req->r.rtm_dst_len = ri->prefix->prefixlen;
	393	req->r.rtm_protocol = ri->rtm_protocol;
	394	req->r.rtm_scope = RT_SCOPE_UNIVERSE;
5adc2528	395
312a6bee JU	396	nl_attr_put(&req->n, in_buf_len, RTA_DST, &ri->prefix->u.prefix,
312a6bee JU	397	bytelen);
5adc2528	398
d62a17ae	399	req->r.rtm_type = ri->rtm_type;
5adc2528	400
d62a17ae	401	/* Metric. */
d62a17ae	402	if (ri->metric)
312a6bee	403	nl_attr_put32(&req->n, in_buf_len, RTA_PRIORITY, *ri->metric);
5adc2528	404
d62a17ae	405	if (ri->num_nhs == 0)
d62a17ae	406	goto done;
5adc2528	407
d62a17ae	408	if (ri->num_nhs == 1) {
d62a17ae	409	nhi = &ri->nhs[0];
5adc2528	410
d62a17ae	411	if (nhi->gateway) {
92d6f769 K	412	if (nhi->type == NEXTHOP_TYPE_IPV4_IFINDEX
	413	&& ri->af == AF_INET6) {
	414	ipv4_to_ipv4_mapped_ipv6(&ipv6,
	415	nhi->gateway->ipv4);
	416	nl_attr_put(&req->n, in_buf_len, RTA_GATEWAY,
	417	&ipv6, bytelen);
	418	} else
	419	nl_attr_put(&req->n, in_buf_len, RTA_GATEWAY,
	420	nhi->gateway, bytelen);
d62a17ae	421	}
5adc2528	422
d62a17ae	423	if (nhi->if_index) {
312a6bee JU	424	nl_attr_put32(&req->n, in_buf_len, RTA_OIF,
312a6bee JU	425	nhi->if_index);
d62a17ae	426	}
5adc2528	427
9d21b7c6	428	encap = nhi->encap_info.encap_type;
58c3cdb9 DS	429	switch (encap) {
	430	case FPM_NH_ENCAP_NONE:
	431	case FPM_NH_ENCAP_MAX:
	432	break;
	433	case FPM_NH_ENCAP_VXLAN:
312a6bee JU	434	nl_attr_put16(&req->n, in_buf_len, RTA_ENCAP_TYPE,
312a6bee JU	435	encap);
58c3cdb9	436	vxlan = &nhi->encap_info.vxlan_encap;
312a6bee JU	437	nest = nl_attr_nest(&req->n, in_buf_len, RTA_ENCAP);
	438	nl_attr_put32(&req->n, in_buf_len, VXLAN_VNI,
	439	vxlan->vni);
	440	nl_attr_nest_end(&req->n, nest);
58c3cdb9	441	break;
9d21b7c6 AD	442	}
9d21b7c6 AD	443
d62a17ae	444	goto done;
5adc2528 AS	445	}
5adc2528 AS	446
d62a17ae	447	/*
	448	* Multipath case.
	449	*/
312a6bee	450	nest = nl_attr_nest(&req->n, in_buf_len, RTA_MULTIPATH);
d62a17ae	451
d62a17ae	452	for (nexthop_num = 0; nexthop_num < ri->num_nhs; nexthop_num++) {
312a6bee	453	rtnh = nl_attr_rtnh(&req->n, in_buf_len);
d62a17ae	454	nhi = &ri->nhs[nexthop_num];
d62a17ae	455
312a6bee JU	456	if (nhi->gateway)
	457	nl_attr_put(&req->n, in_buf_len, RTA_GATEWAY,
	458	nhi->gateway, bytelen);
d62a17ae	459
	460	if (nhi->if_index) {
	461	rtnh->rtnh_ifindex = nhi->if_index;
	462	}
	463
eca3256d	464	rtnh->rtnh_hops = nhi->weight;
eca3256d	465
9d21b7c6	466	encap = nhi->encap_info.encap_type;
58c3cdb9 DS	467	switch (encap) {
	468	case FPM_NH_ENCAP_NONE:
	469	case FPM_NH_ENCAP_MAX:
	470	break;
	471	case FPM_NH_ENCAP_VXLAN:
312a6bee JU	472	nl_attr_put16(&req->n, in_buf_len, RTA_ENCAP_TYPE,
312a6bee JU	473	encap);
58c3cdb9	474	vxlan = &nhi->encap_info.vxlan_encap;
312a6bee JU	475	inner_nest =
	476	nl_attr_nest(&req->n, in_buf_len, RTA_ENCAP);
	477	nl_attr_put32(&req->n, in_buf_len, VXLAN_VNI,
	478	vxlan->vni);
	479	nl_attr_nest_end(&req->n, inner_nest);
58c3cdb9	480	break;
9d21b7c6 AD	481	}
9d21b7c6 AD	482
312a6bee	483	nl_attr_rtnh_end(&req->n, rtnh);
5adc2528 AS	484	}
5adc2528 AS	485
312a6bee JU	486	nl_attr_nest_end(&req->n, nest);
312a6bee JU	487	assert(nest->rta_len > RTA_LENGTH(0));
5adc2528 AS	488
	489	done:
	490
d62a17ae	491	if (ri->pref_src) {
18b7958e	492	nl_attr_put(&req->n, in_buf_len, RTA_PREFSRC, ri->pref_src,
312a6bee	493	bytelen);
d62a17ae	494	}
5adc2528	495
d62a17ae	496	assert(req->n.nlmsg_len < in_buf_len);
d62a17ae	497	return req->n.nlmsg_len;
5adc2528 AS	498	}
	499
	500	/*
	501	* zfpm_log_route_info
	502	*
	503	* Helper function to log the information in a route_info structure.
	504	*/
67ceb408 DS	505	static void zfpm_log_route_info(struct netlink_route_info *ri,
67ceb408 DS	506	const char *label)
5adc2528	507	{
7cf19069	508	struct netlink_nh_info *nhi;
d62a17ae	509	unsigned int i;
9bcef951	510	char buf[PREFIX_STRLEN];
d62a17ae	511
5e9f9adb DL	512	zfpm_debug("%s : %s %pFX, Proto: %s, Metric: %u", label,
5e9f9adb DL	513	nl_msg_type_to_str(ri->nlmsg_type), ri->prefix,
d62a17ae	514	nl_rtproto_to_str(ri->rtm_protocol),
	515	ri->metric ? *ri->metric : 0);
	516
	517	for (i = 0; i < ri->num_nhs; i++) {
	518	nhi = &ri->nhs[i];
9bcef951	519
278749ca	520	if (nhi->gateway) {
	521	if (ri->af == AF_INET)
	522	inet_ntop(AF_INET, nhi->gateway, buf,
	523	sizeof(buf));
	524	else
	525	inet_ntop(AF_INET6, nhi->gateway, buf,
	526	sizeof(buf));
	527	} else
	528	strlcpy(buf, "none", sizeof(buf));
9bcef951	529
9d21b7c6	530	zfpm_debug(" Intf: %u, Gateway: %s, Recursive: %s, Type: %s, Encap type: %s",
9bcef951	531	nhi->if_index, buf, nhi->recursive ? "yes" : "no",
9d21b7c6 AD	532	nexthop_type_to_str(nhi->type),
	533	fpm_nh_encap_type_to_str(nhi->encap_info.encap_type)
	534	);
d62a17ae	535	}
5adc2528 AS	536	}
	537
	538	/*
	539	* zfpm_netlink_encode_route
	540	*
	541	* Create a netlink message corresponding to the given route in the
	542	* given buffer space.
	543	*
	544	* Returns the number of bytes written to the buffer. 0 or a negative
	545	* value indicates an error.
	546	*/
d62a17ae	547	int zfpm_netlink_encode_route(int cmd, rib_dest_t dest, struct route_entry re,
d62a17ae	548	char *in_buf, size_t in_buf_len)
5adc2528	549	{
67ceb408	550	struct netlink_route_info ri_space, *ri;
5adc2528	551
d62a17ae	552	ri = &ri_space;
5adc2528	553
d62a17ae	554	if (!netlink_route_info_fill(ri, cmd, dest, re))
d62a17ae	555	return 0;
5adc2528	556
15569c58	557	zfpm_log_route_info(ri, __func__);
5adc2528	558
d62a17ae	559	return netlink_route_info_encode(ri, in_buf, in_buf_len);
5adc2528	560	}
ddfeb486	561
9da60d0a AD	562	/*
	563	* zfpm_netlink_encode_mac
	564	*
	565	* Create a netlink message corresponding to the given MAC.
	566	*
	567	* Returns the number of bytes written to the buffer. 0 or a negative
	568	* value indicates an error.
	569	*/
	570	int zfpm_netlink_encode_mac(struct fpm_mac_info_t mac, char in_buf,
	571	size_t in_buf_len)
	572	{
9da60d0a AD	573	size_t buf_offset;
9da60d0a AD	574
c5431822	575	struct macmsg {
9da60d0a AD	576	struct nlmsghdr hdr;
	577	struct ndmsg ndm;
	578	char buf[0];
	579	} *req;
	580	req = (void *)in_buf;
	581
c5431822	582	buf_offset = offsetof(struct macmsg, buf);
9da60d0a AD	583	if (in_buf_len < buf_offset)
	584	return 0;
	585	memset(req, 0, buf_offset);
	586
	587	/* Construct nlmsg header */
	588	req->hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
	589	req->hdr.nlmsg_type = CHECK_FLAG(mac->fpm_flags, ZEBRA_MAC_DELETE_FPM) ?
	590	RTM_DELNEIGH : RTM_NEWNEIGH;
	591	req->hdr.nlmsg_flags = NLM_F_REQUEST;
	592	if (req->hdr.nlmsg_type == RTM_NEWNEIGH)
	593	req->hdr.nlmsg_flags \|= (NLM_F_CREATE \| NLM_F_REPLACE);
	594
	595	/* Construct ndmsg */
	596	req->ndm.ndm_family = AF_BRIDGE;
	597	req->ndm.ndm_ifindex = mac->vxlan_if;
	598
	599	req->ndm.ndm_state = NUD_REACHABLE;
	600	req->ndm.ndm_flags \|= NTF_SELF \| NTF_MASTER;
	601	if (CHECK_FLAG(mac->zebra_flags,
	602	(ZEBRA_MAC_STICKY \| ZEBRA_MAC_REMOTE_DEF_GW)))
	603	req->ndm.ndm_state \|= NUD_NOARP;
	604	else
	605	req->ndm.ndm_flags \|= NTF_EXT_LEARNED;
	606
	607	/* Add attributes */
312a6bee JU	608	nl_attr_put(&req->hdr, in_buf_len, NDA_LLADDR, &mac->macaddr, 6);
	609	nl_attr_put(&req->hdr, in_buf_len, NDA_DST, &mac->r_vtep_ip, 4);
	610	nl_attr_put32(&req->hdr, in_buf_len, NDA_MASTER, mac->svi_if);
	611	nl_attr_put32(&req->hdr, in_buf_len, NDA_VNI, mac->vni);
9da60d0a AD	612
	613	assert(req->hdr.nlmsg_len < in_buf_len);
	614
5e9f9adb	615	zfpm_debug("Tx %s family %s ifindex %u MAC %pEA DEST %pI4",
9da60d0a AD	616	nl_msg_type_to_str(req->hdr.nlmsg_type),
9da60d0a AD	617	nl_family_to_str(req->ndm.ndm_family), req->ndm.ndm_ifindex,
5e9f9adb	618	&mac->macaddr, &mac->r_vtep_ip);
9da60d0a AD	619
	620	return req->hdr.nlmsg_len;
	621	}
	622
ddfeb486	623	#endif /* HAVE_NETLINK */