[mirror_frr.git] / zebra / rt_socket.c

/*
 * Kernel routing table updates by routing socket.
 * Copyright (C) 1997, 98 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#ifndef HAVE_NETLINK

#ifdef __OpenBSD__
#include <netmpls/mpls.h>
#endif

#include "if.h"
#include "prefix.h"
#include "sockunion.h"
#include "log.h"
#include "privs.h"
#include "vxlan.h"
#include "lib_errors.h"

#include "zebra/debug.h"
#include "zebra/rib.h"
#include "zebra/rt.h"
#include "zebra/kernel_socket.h"
#include "zebra/zebra_mpls.h"
#include "zebra/zebra_errors.h"

extern struct zebra_privs_t zserv_privs;

#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
/* Adjust netmask socket length. Return value is a adjusted sin_len
   value. */
static int sin_masklen(struct in_addr mask)
{
	char *p, *lim;
	int len;
	struct sockaddr_in sin;

	if (mask.s_addr == 0)
		return sizeof(long);

	sin.sin_addr = mask;
	len = sizeof(struct sockaddr_in);

	lim = (char *)&sin.sin_addr;
	p = lim + sizeof(sin.sin_addr);

	while (*--p == 0 && p >= lim)
		len--;
	return len;
}
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */

#ifdef __OpenBSD__
static int kernel_rtm_add_labels(struct mpls_label_stack *nh_label,
				 struct sockaddr_mpls *smpls)
{
	if (nh_label->num_labels > 1) {
		flog_warn(EC_ZEBRA_MAX_LABELS_PUSH,
			  "%s: can't push %u labels at "
			  "once (maximum is 1)",
			  __func__, nh_label->num_labels);
		return -1;
	}

	memset(smpls, 0, sizeof(*smpls));
	smpls->smpls_len = sizeof(*smpls);
	smpls->smpls_family = AF_MPLS;
	smpls->smpls_label = htonl(nh_label->label[0] << MPLS_LABEL_OFFSET);

	return 0;
}
#endif

#ifdef SIN6_LEN
/* Calculate sin6_len value for netmask socket value. */
static int sin6_masklen(struct in6_addr mask)
{
	struct sockaddr_in6 sin6;
	char *p, *lim;
	int len;

	if (IN6_IS_ADDR_UNSPECIFIED(&mask))
		return sizeof(long);

	sin6.sin6_addr = mask;
	len = sizeof(struct sockaddr_in6);

	lim = (char *)&sin6.sin6_addr;
	p = lim + sizeof(sin6.sin6_addr);

	while (*--p == 0 && p >= lim)
		len--;

	return len;
}
#endif /* SIN6_LEN */

/* Interface between zebra message and rtm message. */
static int kernel_rtm(int cmd, const struct prefix *p,
		      const struct nexthop_group *ng, uint32_t metric)

{
	union sockunion sin_dest, sin_mask, sin_gate;
#ifdef __OpenBSD__
	struct sockaddr_mpls smpls;
#endif
	union sockunion *smplsp = NULL;
	struct nexthop *nexthop;
	int nexthop_num = 0;
	ifindex_t ifindex = 0;
	int gate = 0;
	int error;
	char prefix_buf[PREFIX_STRLEN];
	enum blackhole_type bh_type = BLACKHOLE_UNSPEC;

	if (IS_ZEBRA_DEBUG_RIB)
		prefix2str(p, prefix_buf, sizeof(prefix_buf));

	/*
	 * We only have the ability to ADD or DELETE at this point
	 * in time.
	 */
	if (cmd != RTM_ADD && cmd != RTM_DELETE) {
		if (IS_ZEBRA_DEBUG_KERNEL)
			zlog_debug("%s: %s odd command %s for flags %d",
				   __func__, prefix_buf,
				   lookup_msg(rtm_type_str, cmd, NULL),
				   nexthop->flags);
		return 0;
	}

	memset(&sin_dest, 0, sizeof(sin_dest));
	memset(&sin_gate, 0, sizeof(sin_gate));
	memset(&sin_mask, 0, sizeof(sin_mask));

	switch (p->family) {
	case AF_INET:
		sin_dest.sin.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		sin_dest.sin.sin_len = sizeof(sin_dest);
		sin_gate.sin.sin_len = sizeof(sin_gate);
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
		sin_dest.sin.sin_addr = p->u.prefix4;
		sin_gate.sin.sin_family = AF_INET;
		break;
	case AF_INET6:
		sin_dest.sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
		sin_dest.sin6.sin6_len = sizeof(sin_dest);
#endif /* SIN6_LEN */
		sin_dest.sin6.sin6_addr = p->u.prefix6;
		sin_gate.sin6.sin6_family = AF_INET6;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		sin_gate.sin6.sin6_len = sizeof(sin_gate);
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
		break;
	}

	/* Make gateway. */
	for (ALL_NEXTHOPS_PTR(ng, nexthop)) {
		/*
		 * We only want to use the actual good nexthops
		 */
		if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE) ||
		    !CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
			continue;

		gate = 0;
		char gate_buf[INET_ADDRSTRLEN] = "NULL";

		switch (nexthop->type) {
		case NEXTHOP_TYPE_IPV4:
		case NEXTHOP_TYPE_IPV4_IFINDEX:
			sin_gate.sin.sin_addr = nexthop->gate.ipv4;
			sin_gate.sin.sin_family = AF_INET;
			ifindex = nexthop->ifindex;
			gate = 1;
			break;
		case NEXTHOP_TYPE_IPV6:
		case NEXTHOP_TYPE_IPV6_IFINDEX:
			sin_gate.sin6.sin6_addr = nexthop->gate.ipv6;
			sin_gate.sin6.sin6_family = AF_INET6;
			ifindex = nexthop->ifindex;
/* Under kame set interface index to link local address */
#ifdef KAME

#define SET_IN6_LINKLOCAL_IFINDEX(a, i)                                        \
        do {                                                                   \
                (a).s6_addr[2] = ((i) >> 8) & 0xff;                            \
                (a).s6_addr[3] = (i)&0xff;                                     \
        } while (0)

			if (IN6_IS_ADDR_LINKLOCAL(&sin_gate.sin6.sin6_addr))
				SET_IN6_LINKLOCAL_IFINDEX(
					sin_gate.sin6.sin6_addr,
					ifindex);
#endif /* KAME */

			gate = 1;
			break;
		case NEXTHOP_TYPE_IFINDEX:
			ifindex = nexthop->ifindex;
			break;
		case NEXTHOP_TYPE_BLACKHOLE:
			bh_type = nexthop->bh_type;
			switch (p->family) {
			case AFI_IP: {
				struct in_addr loopback;
				loopback.s_addr = htonl(INADDR_LOOPBACK);
				sin_gate.sin.sin_addr = loopback;
				gate = 1;
			}
				break;
			case AFI_IP6:
				break;
			}
		}

		switch (p->family) {
		case AF_INET:
			masklen2ip(p->prefixlen, &sin_mask.sin.sin_addr);
			sin_mask.sin.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
			sin_mask.sin.sin_len = sin_masklen(
				sin_mask.sin.sin_addr);
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
			break;
		case AF_INET6:
			masklen2ip6(p->prefixlen, &sin_mask.sin6.sin6_addr);
			sin_mask.sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
			sin_mask.sin6.sin6_len = sin6_masklen(
				sin_mask.sin6.sin6_addr);
#endif /* SIN6_LEN */
			break;
		}

#ifdef __OpenBSD__
		if (nexthop->nh_label
		    && !kernel_rtm_add_labels(nexthop->nh_label, &smpls))
			continue;
		smplsp = (union sockunion *)&smpls;
#endif
		error = rtm_write(cmd, &sin_dest, &sin_mask,
				  gate ? &sin_gate : NULL, smplsp,
				  ifindex, bh_type, metric);

		if (IS_ZEBRA_DEBUG_KERNEL) {
			if (!gate) {
				zlog_debug("%s: %s: attention! gate not found for re",
					   __func__, prefix_buf);
			} else
				inet_ntop(p->family == AFI_IP ? AF_INET
					  : AF_INET6,
					  &sin_gate.sin.sin_addr,
					  gate_buf, INET_ADDRSTRLEN);
		}
		switch (error) {
			/* We only flag nexthops as being in FIB if
			 * rtm_write() did its work. */
		case ZEBRA_ERR_NOERROR:
			nexthop_num++;
			if (IS_ZEBRA_DEBUG_KERNEL)
				zlog_debug("%s: %s: successfully did NH %s",
					   __func__, prefix_buf, gate_buf);
			if (cmd == RTM_ADD)
				SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
			break;

			/* The only valid case for this error is
			 * kernel's failure to install a multipath
			 * route, which is common for FreeBSD. This
			 * should be ignored silently, but logged as an error
			 * otherwise.
			 */
		case ZEBRA_ERR_RTEXIST:
			if (cmd != RTM_ADD)
				flog_err(EC_LIB_SYSTEM_CALL,
					 "%s: rtm_write() returned %d for command %d",
					 __func__, error, cmd);
			continue;

			/* Note any unexpected status returns */
		default:
			flog_err(EC_LIB_SYSTEM_CALL,
				 "%s: %s: rtm_write() unexpectedly returned %d for command %s",
				 __func__,
				 prefix2str(p, prefix_buf,
					    sizeof(prefix_buf)),
				 error, lookup_msg(rtm_type_str, cmd, NULL));
			break;
		}
	} /* for (ALL_NEXTHOPS(...))*/

	/* If there was no useful nexthop, then complain. */
	if (nexthop_num == 0) {
		if (IS_ZEBRA_DEBUG_KERNEL)
			zlog_debug("%s: No useful nexthops were found in RIB prefix %s",
				   __func__, prefix2str(p, prefix_buf,
							sizeof(prefix_buf)));
		return 1;
	}

	return 0; /*XXX*/
}

/*
 * Update or delete a prefix from the kernel,
 * using info from a dataplane context struct.
 */
enum zebra_dplane_result kernel_route_update(struct zebra_dplane_ctx *ctx)
{
	enum zebra_dplane_result res = ZEBRA_DPLANE_REQUEST_SUCCESS;

	if (dplane_ctx_get_src(ctx) != NULL) {
		zlog_err("route add: IPv6 sourcedest routes unsupported!");
		res = ZEBRA_DPLANE_REQUEST_FAILURE;
		goto done;
	}

	frr_elevate_privs(&zserv_privs) {

		if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_DELETE)
			kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
				   dplane_ctx_get_ng(ctx),
				   dplane_ctx_get_metric(ctx));
		else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_INSTALL)
			kernel_rtm(RTM_ADD, dplane_ctx_get_dest(ctx),
				   dplane_ctx_get_ng(ctx),
				   dplane_ctx_get_metric(ctx));
		else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_UPDATE) {
			/* Must do delete and add separately -
			 * no update available
			 */
			kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
				   dplane_ctx_get_old_ng(ctx),
				   dplane_ctx_get_old_metric(ctx));

			kernel_rtm(RTM_ADD, dplane_ctx_get_dest(ctx),
				   dplane_ctx_get_ng(ctx),
				   dplane_ctx_get_metric(ctx));
		} else {
			zlog_err("Invalid routing socket update op %s (%u)",
				 dplane_op2str(dplane_ctx_get_op(ctx)),
				 dplane_ctx_get_op(ctx));
			res = ZEBRA_DPLANE_REQUEST_FAILURE;
		}
	} /* Elevated privs */

done:

	return res;
}

int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
			int llalen, ns_id_t ns_id)
{
	/* TODO */
	return 0;
}

extern int kernel_get_ipmr_sg_stats(struct zebra_vrf *zvrf, void *mroute)
{
	return 0;
}

int kernel_add_vtep(vni_t vni, struct interface *ifp, struct in_addr *vtep_ip)
{
	return 0;
}

int kernel_del_vtep(vni_t vni, struct interface *ifp, struct in_addr *vtep_ip)
{
	return 0;
}

int kernel_add_mac(struct interface *ifp, vlanid_t vid, struct ethaddr *mac,
		   struct in_addr vtep_ip, bool sticky)
{
	return 0;
}

int kernel_del_mac(struct interface *ifp, vlanid_t vid, struct ethaddr *mac,
		   struct in_addr vtep_ip)
{
	return 0;
}

int kernel_add_neigh(struct interface *ifp, struct ipaddr *ip,
		     struct ethaddr *mac, uint8_t flags)
{
	return 0;
}

int kernel_del_neigh(struct interface *ifp, struct ipaddr *ip)
{
	return 0;
}

extern int kernel_interface_set_master(struct interface *master,
				       struct interface *slave)
{
	return 0;
}

uint32_t kernel_get_speed(struct interface *ifp)
{
	return ifp->speed;
}

#endif /* !HAVE_NETLINK */
Commit	Line	Data
718e3744	1	/*
	2	* Kernel routing table updates by routing socket.
	3	* Copyright (C) 1997, 98 Kunihiro Ishiguro
	4	*
	5	* This file is part of GNU Zebra.
	6	*
	7	* GNU Zebra is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the
	9	* Free Software Foundation; either version 2, or (at your option) any
	10	* later version.
	11	*
	12	* GNU Zebra is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
896014f4 DL	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; see the file COPYING; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
718e3744	20	*/
	21
	22	#include <zebra.h>
ddfeb486 DL	23
	24	#ifndef HAVE_NETLINK
	25
fe6c7157	26	#ifdef __OpenBSD__
d3e2c74a RW	27	#include <netmpls/mpls.h>
d3e2c74a RW	28	#endif
718e3744	29
	30	#include "if.h"
	31	#include "prefix.h"
	32	#include "sockunion.h"
	33	#include "log.h"
edd7c245	34	#include "privs.h"
13d60d35	35	#include "vxlan.h"
174482ef	36	#include "lib_errors.h"
718e3744	37
	38	#include "zebra/debug.h"
	39	#include "zebra/rib.h"
6621ca86	40	#include "zebra/rt.h"
dc95824a	41	#include "zebra/kernel_socket.h"
d3e2c74a	42	#include "zebra/zebra_mpls.h"
364fed6b	43	#include "zebra/zebra_errors.h"
718e3744	44
edd7c245	45	extern struct zebra_privs_t zserv_privs;
edd7c245	46
746c4f02	47	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
718e3744	48	/* Adjust netmask socket length. Return value is a adjusted sin_len
718e3744	49	value. */
d62a17ae	50	static int sin_masklen(struct in_addr mask)
718e3744	51	{
d62a17ae	52	char p, lim;
	53	int len;
	54	struct sockaddr_in sin;
718e3744	55
d62a17ae	56	if (mask.s_addr == 0)
d62a17ae	57	return sizeof(long);
718e3744	58
d62a17ae	59	sin.sin_addr = mask;
d62a17ae	60	len = sizeof(struct sockaddr_in);
718e3744	61
d62a17ae	62	lim = (char *)&sin.sin_addr;
d62a17ae	63	p = lim + sizeof(sin.sin_addr);
718e3744	64
d62a17ae	65	while (*--p == 0 && p >= lim)
	66	len--;
	67	return len;
718e3744	68	}
746c4f02	69	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
718e3744	70
5e8c8947	71	#ifdef __OpenBSD__
8ecdb26e	72	static int kernel_rtm_add_labels(struct mpls_label_stack *nh_label,
5e8c8947 RW	73	struct sockaddr_mpls *smpls)
	74	{
	75	if (nh_label->num_labels > 1) {
e914ccbe	76	flog_warn(EC_ZEBRA_MAX_LABELS_PUSH,
9df414fe QY	77	"%s: can't push %u labels at "
	78	"once (maximum is 1)",
	79	__func__, nh_label->num_labels);
5e8c8947 RW	80	return -1;
	81	}
	82
	83	memset(smpls, 0, sizeof(*smpls));
	84	smpls->smpls_len = sizeof(*smpls);
	85	smpls->smpls_family = AF_MPLS;
	86	smpls->smpls_label = htonl(nh_label->label[0] << MPLS_LABEL_OFFSET);
	87
	88	return 0;
	89	}
	90	#endif
	91
9ba0e570 DS	92	#ifdef SIN6_LEN
	93	/* Calculate sin6_len value for netmask socket value. */
	94	static int sin6_masklen(struct in6_addr mask)
	95	{
	96	struct sockaddr_in6 sin6;
	97	char p, lim;
	98	int len;
	99
	100	if (IN6_IS_ADDR_UNSPECIFIED(&mask))
	101	return sizeof(long);
	102
	103	sin6.sin6_addr = mask;
	104	len = sizeof(struct sockaddr_in6);
	105
	106	lim = (char *)&sin6.sin6_addr;
	107	p = lim + sizeof(sin6.sin6_addr);
	108
	109	while (*--p == 0 && p >= lim)
	110	len--;
	111
	112	return len;
	113	}
	114	#endif /* SIN6_LEN */
	115
718e3744	116	/* Interface between zebra message and rtm message. */
08ea27d1 DS	117	static int kernel_rtm(int cmd, const struct prefix *p,
08ea27d1 DS	118	const struct nexthop_group *ng, uint32_t metric)
718e3744	119
718e3744	120	{
ca2c70bd	121	union sockunion sin_dest, sin_mask, sin_gate;
fe6c7157	122	#ifdef __OpenBSD__
d62a17ae	123	struct sockaddr_mpls smpls;
d3e2c74a	124	#endif
d62a17ae	125	union sockunion *smplsp = NULL;
	126	struct nexthop *nexthop;
	127	int nexthop_num = 0;
	128	ifindex_t ifindex = 0;
	129	int gate = 0;
	130	int error;
	131	char prefix_buf[PREFIX_STRLEN];
a8309422	132	enum blackhole_type bh_type = BLACKHOLE_UNSPEC;
d62a17ae	133
	134	if (IS_ZEBRA_DEBUG_RIB)
	135	prefix2str(p, prefix_buf, sizeof(prefix_buf));
718e3744	136
86afd529 DS	137	/*
	138	* We only have the ability to ADD or DELETE at this point
	139	* in time.
	140	*/
	141	if (cmd != RTM_ADD && cmd != RTM_DELETE) {
	142	if (IS_ZEBRA_DEBUG_KERNEL)
	143	zlog_debug("%s: %s odd command %s for flags %d",
	144	__func__, prefix_buf,
	145	lookup_msg(rtm_type_str, cmd, NULL),
	146	nexthop->flags);
	147	return 0;
	148	}
	149
08ea27d1 DS	150	memset(&sin_dest, 0, sizeof(sin_dest));
08ea27d1 DS	151	memset(&sin_gate, 0, sizeof(sin_gate));
ca2c70bd	152	memset(&sin_mask, 0, sizeof(sin_mask));
718e3744	153
08ea27d1 DS	154	switch (p->family) {
	155	case AF_INET:
	156	sin_dest.sin.sin_family = AF_INET;
	157	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	158	sin_dest.sin.sin_len = sizeof(sin_dest);
	159	sin_gate.sin.sin_len = sizeof(sin_gate);
	160	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
	161	sin_dest.sin.sin_addr = p->u.prefix4;
	162	sin_gate.sin.sin_family = AF_INET;
	163	break;
	164	case AF_INET6:
	165	sin_dest.sin6.sin6_family = AF_INET6;
	166	#ifdef SIN6_LEN
	167	sin_dest.sin6.sin6_len = sizeof(sin_dest);
	168	#endif /* SIN6_LEN */
	169	sin_dest.sin6.sin6_addr = p->u.prefix6;
	170	sin_gate.sin6.sin6_family = AF_INET6;
6f0e3f6e	171	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
08ea27d1	172	sin_gate.sin6.sin6_len = sizeof(sin_gate);
6f0e3f6e	173	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
08ea27d1 DS	174	break;
08ea27d1 DS	175	}
718e3744	176
d62a17ae	177	/* Make gateway. */
01ce7cba	178	for (ALL_NEXTHOPS_PTR(ng, nexthop)) {
86afd529 DS	179	/*
	180	* We only want to use the actual good nexthops
	181	*/
	182	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE) \|\|
	183	!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
d62a17ae	184	continue;
	185
	186	gate = 0;
	187	char gate_buf[INET_ADDRSTRLEN] = "NULL";
	188
86afd529 DS	189	switch (nexthop->type) {
	190	case NEXTHOP_TYPE_IPV4:
	191	case NEXTHOP_TYPE_IPV4_IFINDEX:
	192	sin_gate.sin.sin_addr = nexthop->gate.ipv4;
	193	sin_gate.sin.sin_family = AF_INET;
	194	ifindex = nexthop->ifindex;
	195	gate = 1;
	196	break;
	197	case NEXTHOP_TYPE_IPV6:
	198	case NEXTHOP_TYPE_IPV6_IFINDEX:
	199	sin_gate.sin6.sin6_addr = nexthop->gate.ipv6;
	200	sin_gate.sin6.sin6_family = AF_INET6;
	201	ifindex = nexthop->ifindex;
08ea27d1 DS	202	/* Under kame set interface index to link local address */
	203	#ifdef KAME
	204
	205	#define SET_IN6_LINKLOCAL_IFINDEX(a, i) \
	206	do { \
	207	(a).s6_addr[2] = ((i) >> 8) & 0xff; \
	208	(a).s6_addr[3] = (i)&0xff; \
	209	} while (0)
	210
86afd529 DS	211	if (IN6_IS_ADDR_LINKLOCAL(&sin_gate.sin6.sin6_addr))
	212	SET_IN6_LINKLOCAL_IFINDEX(
	213	sin_gate.sin6.sin6_addr,
	214	ifindex);
08ea27d1 DS	215	#endif /* KAME */
08ea27d1 DS	216
86afd529 DS	217	gate = 1;
	218	break;
	219	case NEXTHOP_TYPE_IFINDEX:
	220	ifindex = nexthop->ifindex;
	221	break;
	222	case NEXTHOP_TYPE_BLACKHOLE:
	223	bh_type = nexthop->bh_type;
	224	switch (p->family) {
	225	case AFI_IP: {
	226	struct in_addr loopback;
	227	loopback.s_addr = htonl(INADDR_LOOPBACK);
	228	sin_gate.sin.sin_addr = loopback;
d62a17ae	229	gate = 1;
86afd529	230	}
08ea27d1	231	break;
86afd529	232	case AFI_IP6:
08ea27d1	233	break;
d62a17ae	234	}
86afd529 DS	235	}
	236
	237	switch (p->family) {
	238	case AF_INET:
18d10d88 DS	239	masklen2ip(p->prefixlen, &sin_mask.sin.sin_addr);
18d10d88 DS	240	sin_mask.sin.sin_family = AF_INET;
6f0e3f6e	241	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
18d10d88 DS	242	sin_mask.sin.sin_len = sin_masklen(
18d10d88 DS	243	sin_mask.sin.sin_addr);
6f0e3f6e	244	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
86afd529 DS	245	break;
86afd529 DS	246	case AF_INET6:
18d10d88 DS	247	masklen2ip6(p->prefixlen, &sin_mask.sin6.sin6_addr);
18d10d88 DS	248	sin_mask.sin6.sin6_family = AF_INET6;
08ea27d1	249	#ifdef SIN6_LEN
18d10d88 DS	250	sin_mask.sin6.sin6_len = sin6_masklen(
18d10d88 DS	251	sin_mask.sin6.sin6_addr);
08ea27d1	252	#endif /* SIN6_LEN */
86afd529 DS	253	break;
86afd529 DS	254	}
718e3744	255
fe6c7157	256	#ifdef __OpenBSD__
86afd529 DS	257	if (nexthop->nh_label
	258	&& !kernel_rtm_add_labels(nexthop->nh_label, &smpls))
	259	continue;
	260	smplsp = (union sockunion *)&smpls;
d3e2c74a	261	#endif
18d10d88	262	error = rtm_write(cmd, &sin_dest, &sin_mask,
86afd529 DS	263	gate ? &sin_gate : NULL, smplsp,
	264	ifindex, bh_type, metric);
	265
	266	if (IS_ZEBRA_DEBUG_KERNEL) {
	267	if (!gate) {
	268	zlog_debug("%s: %s: attention! gate not found for re",
	269	__func__, prefix_buf);
	270	} else
	271	inet_ntop(p->family == AFI_IP ? AF_INET
	272	: AF_INET6,
	273	&sin_gate.sin.sin_addr,
	274	gate_buf, INET_ADDRSTRLEN);
	275	}
	276	switch (error) {
	277	/* We only flag nexthops as being in FIB if
	278	* rtm_write() did its work. */
	279	case ZEBRA_ERR_NOERROR:
	280	nexthop_num++;
	281	if (IS_ZEBRA_DEBUG_KERNEL)
	282	zlog_debug("%s: %s: successfully did NH %s",
	283	__func__, prefix_buf, gate_buf);
	284	if (cmd == RTM_ADD)
	285	SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
	286	break;
	287
	288	/* The only valid case for this error is
	289	* kernel's failure to install a multipath
	290	* route, which is common for FreeBSD. This
	291	* should be ignored silently, but logged as an error
	292	* otherwise.
	293	*/
	294	case ZEBRA_ERR_RTEXIST:
	295	if (cmd != RTM_ADD)
	296	flog_err(EC_LIB_SYSTEM_CALL,
	297	"%s: rtm_write() returned %d for command %d",
	298	__func__, error, cmd);
	299	continue;
d62a17ae	300
86afd529 DS	301	/* Note any unexpected status returns */
	302	default:
	303	flog_err(EC_LIB_SYSTEM_CALL,
	304	"%s: %s: rtm_write() unexpectedly returned %d for command %s",
	305	__func__,
	306	prefix2str(p, prefix_buf,
	307	sizeof(prefix_buf)),
	308	error, lookup_msg(rtm_type_str, cmd, NULL));
	309	break;
	310	}
d62a17ae	311	} /* for (ALL_NEXTHOPS(...))*/
	312
	313	/* If there was no useful nexthop, then complain. */
560e3136 DS	314	if (nexthop_num == 0) {
560e3136 DS	315	if (IS_ZEBRA_DEBUG_KERNEL)
01ce7cba MS	316	zlog_debug("%s: No useful nexthops were found in RIB prefix %s",
	317	__func__, prefix2str(p, prefix_buf,
	318	sizeof(prefix_buf)));
560e3136 DS	319	return 1;
560e3136 DS	320	}
d62a17ae	321
d62a17ae	322	return 0; /XXX/
718e3744	323	}
718e3744	324
01ce7cba MS	325	/*
	326	* Update or delete a prefix from the kernel,
	327	* using info from a dataplane context struct.
	328	*/
25779064	329	enum zebra_dplane_result kernel_route_update(struct zebra_dplane_ctx *ctx)
01ce7cba MS	330	{
	331	enum zebra_dplane_result res = ZEBRA_DPLANE_REQUEST_SUCCESS;
	332
	333	if (dplane_ctx_get_src(ctx) != NULL) {
	334	zlog_err("route add: IPv6 sourcedest routes unsupported!");
	335	res = ZEBRA_DPLANE_REQUEST_FAILURE;
	336	goto done;
	337	}
	338
49ddb66a	339	frr_elevate_privs(&zserv_privs) {
f183e380 MS	340
	341	if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_DELETE)
	342	kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
	343	dplane_ctx_get_ng(ctx),
	344	dplane_ctx_get_metric(ctx));
	345	else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_INSTALL)
	346	kernel_rtm(RTM_ADD, dplane_ctx_get_dest(ctx),
	347	dplane_ctx_get_ng(ctx),
	348	dplane_ctx_get_metric(ctx));
	349	else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_UPDATE) {
	350	/* Must do delete and add separately -
	351	* no update available
	352	*/
	353	kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
	354	dplane_ctx_get_old_ng(ctx),
	355	dplane_ctx_get_old_metric(ctx));
	356
	357	kernel_rtm(RTM_ADD, dplane_ctx_get_dest(ctx),
	358	dplane_ctx_get_ng(ctx),
	359	dplane_ctx_get_metric(ctx));
	360	} else {
	361	zlog_err("Invalid routing socket update op %s (%u)",
	362	dplane_op2str(dplane_ctx_get_op(ctx)),
	363	dplane_ctx_get_op(ctx));
	364	res = ZEBRA_DPLANE_REQUEST_FAILURE;
	365	}
	366	} /* Elevated privs */
01ce7cba MS	367
	368	done:
	369
	370	return res;
	371	}
	372
d62a17ae	373	int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
5895d33f	374	int llalen, ns_id_t ns_id)
6b8a5694	375	{
d62a17ae	376	/* TODO */
d62a17ae	377	return 0;
6b8a5694	378	}
1498c059	379
43b5cc5e	380	extern int kernel_get_ipmr_sg_stats(struct zebra_vrf zvrf, void mroute)
1498c059	381	{
d62a17ae	382	return 0;
1498c059	383	}
13d60d35	384
d62a17ae	385	int kernel_add_vtep(vni_t vni, struct interface ifp, struct in_addr vtep_ip)
13d60d35	386	{
d62a17ae	387	return 0;
13d60d35	388	}
13d60d35	389
d62a17ae	390	int kernel_del_vtep(vni_t vni, struct interface ifp, struct in_addr vtep_ip)
13d60d35	391	{
d62a17ae	392	return 0;
13d60d35	393	}
2232a77c	394
d62a17ae	395	int kernel_add_mac(struct interface ifp, vlanid_t vid, struct ethaddr mac,
a37f4598	396	struct in_addr vtep_ip, bool sticky)
2232a77c	397	{
d62a17ae	398	return 0;
2232a77c	399	}
2232a77c	400
d62a17ae	401	int kernel_del_mac(struct interface ifp, vlanid_t vid, struct ethaddr mac,
d63c1b18	402	struct in_addr vtep_ip)
2232a77c	403	{
d62a17ae	404	return 0;
2232a77c	405	}
2232a77c	406
d62a17ae	407	int kernel_add_neigh(struct interface ifp, struct ipaddr ip,
68e33151	408	struct ethaddr *mac, uint8_t flags)
2232a77c	409	{
d62a17ae	410	return 0;
2232a77c	411	}
2232a77c	412
d62a17ae	413	int kernel_del_neigh(struct interface ifp, struct ipaddr ip)
2232a77c	414	{
d62a17ae	415	return 0;
2232a77c	416	}
e0ae31b8 DS	417
	418	extern int kernel_interface_set_master(struct interface *master,
	419	struct interface *slave)
	420	{
	421	return 0;
	422	}
0ecfe5bf	423
dc7b3cae DS	424	uint32_t kernel_get_speed(struct interface *ifp)
	425	{
	426	return ifp->speed;
	427	}
	428
ddfeb486	429	#endif /* !HAVE_NETLINK */