[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 __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

/* 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;
	bool gate = false;
	int error;
	char gate_buf[INET6_BUFSIZ];
	char prefix_buf[PREFIX_STRLEN];
	enum blackhole_type bh_type = BLACKHOLE_UNSPEC;

	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",
				   __func__, prefix_buf,
				   lookup_msg(rtm_type_str, cmd, NULL));
		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;
		sin_dest.sin.sin_addr = p->u.prefix4;
		sin_gate.sin.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
		sin_dest.sin.sin_len = sizeof(struct sockaddr_in);
		sin_gate.sin.sin_len = sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
		break;
	case AF_INET6:
		sin_dest.sin6.sin6_family = AF_INET6;
		sin_dest.sin6.sin6_addr = p->u.prefix6;
		sin_gate.sin6.sin6_family = AF_INET6;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
		sin_dest.sin6.sin6_len = sizeof(struct sockaddr_in6);
		sin_gate.sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif /* HAVE_STRUCT_SOCKADDR_SA_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;

		smplsp = NULL;
		gate = false;
		snprintf(gate_buf, sizeof(gate_buf), "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;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
			sin_gate.sin.sin_len = sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
			ifindex = nexthop->ifindex;
			gate = true;
			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;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
			sin_gate.sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
			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 = true;
			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;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
				sin_gate.sin.sin_len =
					sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
				gate = true;
			}
				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_SA_LEN
			sin_mask.sin.sin_len = sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
			break;
		case AF_INET6:
			masklen2ip6(p->prefixlen, &sin_mask.sin6.sin6_addr);
			sin_mask.sin6.sin6_family = AF_INET6;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
			sin_mask.sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
			break;
		}

#ifdef __OpenBSD__
		if (nexthop->nh_label) {
			if (kernel_rtm_add_labels(nexthop->nh_label,
						  &smpls) != 0)
				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 {
				switch (p->family) {
				case AFI_IP:
					inet_ntop(AF_INET,
						  &sin_gate.sin.sin_addr,
						  gate_buf, sizeof(gate_buf));
					break;

				case AFI_IP6:
					inet_ntop(AF_INET6,
						  &sin_gate.sin6.sin6_addr,
						  gate_buf, sizeof(gate_buf));
					break;

				default:
					snprintf(gate_buf, sizeof(gate_buf),
						 "(invalid-af)");
					break;
				}
			}
		}
		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__, 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__, 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;
	uint32_t type, old_type;

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

	type = dplane_ctx_get_type(ctx);
	old_type = dplane_ctx_get_old_type(ctx);

	frr_elevate_privs(&zserv_privs) {

		if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_DELETE) {
			if (!RSYSTEM_ROUTE(type))
				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) {
			if (!RSYSTEM_ROUTE(type))
				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
			 */
			if (!RSYSTEM_ROUTE(old_type))
				kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
					   dplane_ctx_get_old_ng(ctx),
					   dplane_ctx_get_old_metric(ctx));

			if (!RSYSTEM_ROUTE(type))
				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 */

	if (RSYSTEM_ROUTE(type)
	    && dplane_ctx_get_op(ctx) != DPLANE_OP_ROUTE_DELETE) {
		struct nexthop *nexthop;

		for (ALL_NEXTHOPS_PTR(dplane_ctx_get_ng(ctx), nexthop)) {
			if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
				continue;

			if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)) {
				SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
			}
		}
	}

	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
5e8c8947	47	#ifdef __OpenBSD__
8ecdb26e	48	static int kernel_rtm_add_labels(struct mpls_label_stack *nh_label,
5e8c8947 RW	49	struct sockaddr_mpls *smpls)
	50	{
	51	if (nh_label->num_labels > 1) {
e914ccbe	52	flog_warn(EC_ZEBRA_MAX_LABELS_PUSH,
9df414fe QY	53	"%s: can't push %u labels at "
	54	"once (maximum is 1)",
	55	__func__, nh_label->num_labels);
5e8c8947 RW	56	return -1;
	57	}
	58
	59	memset(smpls, 0, sizeof(*smpls));
	60	smpls->smpls_len = sizeof(*smpls);
	61	smpls->smpls_family = AF_MPLS;
	62	smpls->smpls_label = htonl(nh_label->label[0] << MPLS_LABEL_OFFSET);
	63
	64	return 0;
	65	}
	66	#endif
	67
718e3744	68	/* Interface between zebra message and rtm message. */
08ea27d1 DS	69	static int kernel_rtm(int cmd, const struct prefix *p,
08ea27d1 DS	70	const struct nexthop_group *ng, uint32_t metric)
718e3744	71
718e3744	72	{
ca2c70bd	73	union sockunion sin_dest, sin_mask, sin_gate;
fe6c7157	74	#ifdef __OpenBSD__
d62a17ae	75	struct sockaddr_mpls smpls;
d3e2c74a	76	#endif
d62a17ae	77	union sockunion *smplsp = NULL;
	78	struct nexthop *nexthop;
	79	int nexthop_num = 0;
	80	ifindex_t ifindex = 0;
4dd39a0e	81	bool gate = false;
d62a17ae	82	int error;
981dc13f	83	char gate_buf[INET6_BUFSIZ];
d62a17ae	84	char prefix_buf[PREFIX_STRLEN];
a8309422	85	enum blackhole_type bh_type = BLACKHOLE_UNSPEC;
d62a17ae	86
683c06ad	87	prefix2str(p, prefix_buf, sizeof(prefix_buf));
718e3744	88
86afd529 DS	89	/*
	90	* We only have the ability to ADD or DELETE at this point
	91	* in time.
	92	*/
	93	if (cmd != RTM_ADD && cmd != RTM_DELETE) {
	94	if (IS_ZEBRA_DEBUG_KERNEL)
5ea8213f	95	zlog_debug("%s: %s odd command %s",
86afd529	96	__func__, prefix_buf,
5ea8213f	97	lookup_msg(rtm_type_str, cmd, NULL));
86afd529 DS	98	return 0;
	99	}
	100
08ea27d1 DS	101	memset(&sin_dest, 0, sizeof(sin_dest));
08ea27d1 DS	102	memset(&sin_gate, 0, sizeof(sin_gate));
ca2c70bd	103	memset(&sin_mask, 0, sizeof(sin_mask));
718e3744	104
08ea27d1 DS	105	switch (p->family) {
	106	case AF_INET:
	107	sin_dest.sin.sin_family = AF_INET;
08ea27d1 DS	108	sin_dest.sin.sin_addr = p->u.prefix4;
08ea27d1 DS	109	sin_gate.sin.sin_family = AF_INET;
0413dd75 RZ	110	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	111	sin_dest.sin.sin_len = sizeof(struct sockaddr_in);
	112	sin_gate.sin.sin_len = sizeof(struct sockaddr_in);
	113	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
08ea27d1 DS	114	break;
	115	case AF_INET6:
	116	sin_dest.sin6.sin6_family = AF_INET6;
08ea27d1 DS	117	sin_dest.sin6.sin6_addr = p->u.prefix6;
08ea27d1 DS	118	sin_gate.sin6.sin6_family = AF_INET6;
0413dd75 RZ	119	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	120	sin_dest.sin6.sin6_len = sizeof(struct sockaddr_in6);
	121	sin_gate.sin6.sin6_len = sizeof(struct sockaddr_in6);
	122	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
08ea27d1 DS	123	break;
08ea27d1 DS	124	}
718e3744	125
d62a17ae	126	/* Make gateway. */
01ce7cba	127	for (ALL_NEXTHOPS_PTR(ng, nexthop)) {
86afd529 DS	128	/*
	129	* We only want to use the actual good nexthops
	130	*/
	131	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE) \|\|
	132	!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
d62a17ae	133	continue;
d62a17ae	134
c2519893	135	smplsp = NULL;
4dd39a0e	136	gate = false;
981dc13f	137	snprintf(gate_buf, sizeof(gate_buf), "NULL");
d62a17ae	138
86afd529 DS	139	switch (nexthop->type) {
	140	case NEXTHOP_TYPE_IPV4:
	141	case NEXTHOP_TYPE_IPV4_IFINDEX:
	142	sin_gate.sin.sin_addr = nexthop->gate.ipv4;
	143	sin_gate.sin.sin_family = AF_INET;
0413dd75 RZ	144	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	145	sin_gate.sin.sin_len = sizeof(struct sockaddr_in);
	146	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
86afd529	147	ifindex = nexthop->ifindex;
4dd39a0e	148	gate = true;
86afd529 DS	149	break;
	150	case NEXTHOP_TYPE_IPV6:
	151	case NEXTHOP_TYPE_IPV6_IFINDEX:
	152	sin_gate.sin6.sin6_addr = nexthop->gate.ipv6;
	153	sin_gate.sin6.sin6_family = AF_INET6;
0413dd75 RZ	154	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	155	sin_gate.sin6.sin6_len = sizeof(struct sockaddr_in6);
	156	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
86afd529	157	ifindex = nexthop->ifindex;
08ea27d1 DS	158	/* Under kame set interface index to link local address */
	159	#ifdef KAME
	160
	161	#define SET_IN6_LINKLOCAL_IFINDEX(a, i) \
c9277ebb DS	162	do { \
	163	(a).s6_addr[2] = ((i) >> 8) & 0xff; \
	164	(a).s6_addr[3] = (i)&0xff; \
	165	} while (0)
08ea27d1	166
86afd529 DS	167	if (IN6_IS_ADDR_LINKLOCAL(&sin_gate.sin6.sin6_addr))
	168	SET_IN6_LINKLOCAL_IFINDEX(
	169	sin_gate.sin6.sin6_addr,
	170	ifindex);
08ea27d1 DS	171	#endif /* KAME */
08ea27d1 DS	172
4dd39a0e	173	gate = true;
86afd529 DS	174	break;
	175	case NEXTHOP_TYPE_IFINDEX:
	176	ifindex = nexthop->ifindex;
	177	break;
	178	case NEXTHOP_TYPE_BLACKHOLE:
	179	bh_type = nexthop->bh_type;
	180	switch (p->family) {
	181	case AFI_IP: {
	182	struct in_addr loopback;
	183	loopback.s_addr = htonl(INADDR_LOOPBACK);
	184	sin_gate.sin.sin_addr = loopback;
0413dd75 RZ	185	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	186	sin_gate.sin.sin_len =
	187	sizeof(struct sockaddr_in);
	188	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
4dd39a0e	189	gate = true;
86afd529	190	}
08ea27d1	191	break;
86afd529	192	case AFI_IP6:
08ea27d1	193	break;
d62a17ae	194	}
86afd529 DS	195	}
	196
	197	switch (p->family) {
	198	case AF_INET:
18d10d88 DS	199	masklen2ip(p->prefixlen, &sin_mask.sin.sin_addr);
18d10d88 DS	200	sin_mask.sin.sin_family = AF_INET;
0413dd75 RZ	201	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	202	sin_mask.sin.sin_len = sizeof(struct sockaddr_in);
	203	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
86afd529 DS	204	break;
86afd529 DS	205	case AF_INET6:
18d10d88 DS	206	masklen2ip6(p->prefixlen, &sin_mask.sin6.sin6_addr);
18d10d88 DS	207	sin_mask.sin6.sin6_family = AF_INET6;
0413dd75 RZ	208	#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
	209	sin_mask.sin6.sin6_len = sizeof(struct sockaddr_in6);
	210	#endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
86afd529 DS	211	break;
86afd529 DS	212	}
718e3744	213
fe6c7157	214	#ifdef __OpenBSD__
b24204be MS	215	if (nexthop->nh_label) {
	216	if (kernel_rtm_add_labels(nexthop->nh_label,
	217	&smpls) != 0)
	218	continue;
	219	smplsp = (union sockunion *)&smpls;
	220	}
d3e2c74a	221	#endif
18d10d88	222	error = rtm_write(cmd, &sin_dest, &sin_mask,
86afd529 DS	223	gate ? &sin_gate : NULL, smplsp,
	224	ifindex, bh_type, metric);
	225
	226	if (IS_ZEBRA_DEBUG_KERNEL) {
	227	if (!gate) {
981dc13f RZ	228	zlog_debug(
	229	"%s: %s: attention! gate not found for re",
	230	__func__, prefix_buf);
	231	} else {
	232	switch (p->family) {
	233	case AFI_IP:
	234	inet_ntop(AF_INET,
	235	&sin_gate.sin.sin_addr,
	236	gate_buf, sizeof(gate_buf));
	237	break;
	238
	239	case AFI_IP6:
	240	inet_ntop(AF_INET6,
	241	&sin_gate.sin6.sin6_addr,
	242	gate_buf, sizeof(gate_buf));
	243	break;
	244
	245	default:
	246	snprintf(gate_buf, sizeof(gate_buf),
	247	"(invalid-af)");
	248	break;
	249	}
	250	}
86afd529 DS	251	}
	252	switch (error) {
	253	/* We only flag nexthops as being in FIB if
	254	* rtm_write() did its work. */
	255	case ZEBRA_ERR_NOERROR:
	256	nexthop_num++;
	257	if (IS_ZEBRA_DEBUG_KERNEL)
	258	zlog_debug("%s: %s: successfully did NH %s",
	259	__func__, prefix_buf, gate_buf);
	260	if (cmd == RTM_ADD)
	261	SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
	262	break;
	263
	264	/* The only valid case for this error is
	265	* kernel's failure to install a multipath
	266	* route, which is common for FreeBSD. This
	267	* should be ignored silently, but logged as an error
	268	* otherwise.
	269	*/
	270	case ZEBRA_ERR_RTEXIST:
	271	if (cmd != RTM_ADD)
	272	flog_err(EC_LIB_SYSTEM_CALL,
	273	"%s: rtm_write() returned %d for command %d",
	274	__func__, error, cmd);
	275	continue;
d62a17ae	276
86afd529 DS	277	/* Note any unexpected status returns */
86afd529 DS	278	default:
31be7dbb RZ	279	flog_err(
	280	EC_LIB_SYSTEM_CALL,
	281	"%s: %s: rtm_write() unexpectedly returned %d for command %s",
	282	__func__, prefix_buf, error,
	283	lookup_msg(rtm_type_str, cmd, NULL));
86afd529 DS	284	break;
86afd529 DS	285	}
d62a17ae	286	} /* for (ALL_NEXTHOPS(...))*/
	287
	288	/* If there was no useful nexthop, then complain. */
560e3136 DS	289	if (nexthop_num == 0) {
560e3136 DS	290	if (IS_ZEBRA_DEBUG_KERNEL)
31be7dbb RZ	291	zlog_debug(
	292	"%s: No useful nexthops were found in RIB prefix %s",
	293	__func__, prefix_buf);
560e3136 DS	294	return 1;
560e3136 DS	295	}
d62a17ae	296
d62a17ae	297	return 0; /XXX/
718e3744	298	}
718e3744	299
01ce7cba MS	300	/*
	301	* Update or delete a prefix from the kernel,
	302	* using info from a dataplane context struct.
	303	*/
25779064	304	enum zebra_dplane_result kernel_route_update(struct zebra_dplane_ctx *ctx)
01ce7cba MS	305	{
01ce7cba MS	306	enum zebra_dplane_result res = ZEBRA_DPLANE_REQUEST_SUCCESS;
3cdba47a	307	uint32_t type, old_type;
01ce7cba MS	308
	309	if (dplane_ctx_get_src(ctx) != NULL) {
	310	zlog_err("route add: IPv6 sourcedest routes unsupported!");
e677d109	311	return ZEBRA_DPLANE_REQUEST_FAILURE;
01ce7cba MS	312	}
01ce7cba MS	313
3cdba47a DS	314	type = dplane_ctx_get_type(ctx);
	315	old_type = dplane_ctx_get_old_type(ctx);
	316
49ddb66a	317	frr_elevate_privs(&zserv_privs) {
f183e380	318
3cdba47a DS	319	if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_DELETE) {
	320	if (!RSYSTEM_ROUTE(type))
	321	kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
	322	dplane_ctx_get_ng(ctx),
	323	dplane_ctx_get_metric(ctx));
	324	} else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_INSTALL) {
	325	if (!RSYSTEM_ROUTE(type))
	326	kernel_rtm(RTM_ADD, dplane_ctx_get_dest(ctx),
	327	dplane_ctx_get_ng(ctx),
	328	dplane_ctx_get_metric(ctx));
	329	} else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ROUTE_UPDATE) {
f183e380 MS	330	/* Must do delete and add separately -
	331	* no update available
	332	*/
3cdba47a DS	333	if (!RSYSTEM_ROUTE(old_type))
	334	kernel_rtm(RTM_DELETE, dplane_ctx_get_dest(ctx),
	335	dplane_ctx_get_old_ng(ctx),
	336	dplane_ctx_get_old_metric(ctx));
	337
	338	if (!RSYSTEM_ROUTE(type))
	339	kernel_rtm(RTM_ADD, dplane_ctx_get_dest(ctx),
	340	dplane_ctx_get_ng(ctx),
	341	dplane_ctx_get_metric(ctx));
f183e380 MS	342	} else {
	343	zlog_err("Invalid routing socket update op %s (%u)",
	344	dplane_op2str(dplane_ctx_get_op(ctx)),
	345	dplane_ctx_get_op(ctx));
	346	res = ZEBRA_DPLANE_REQUEST_FAILURE;
	347	}
	348	} /* Elevated privs */
01ce7cba	349
3cdba47a DS	350	if (RSYSTEM_ROUTE(type)
	351	&& dplane_ctx_get_op(ctx) != DPLANE_OP_ROUTE_DELETE) {
	352	struct nexthop *nexthop;
	353
	354	for (ALL_NEXTHOPS_PTR(dplane_ctx_get_ng(ctx), nexthop)) {
	355	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
	356	continue;
	357
	358	if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)) {
	359	SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
	360	}
	361	}
	362	}
	363
01ce7cba MS	364	return res;
	365	}
	366
d62a17ae	367	int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
5895d33f	368	int llalen, ns_id_t ns_id)
6b8a5694	369	{
d62a17ae	370	/* TODO */
d62a17ae	371	return 0;
6b8a5694	372	}
1498c059	373
43b5cc5e	374	extern int kernel_get_ipmr_sg_stats(struct zebra_vrf zvrf, void mroute)
1498c059	375	{
d62a17ae	376	return 0;
1498c059	377	}
13d60d35	378
d62a17ae	379	int kernel_add_vtep(vni_t vni, struct interface ifp, struct in_addr vtep_ip)
13d60d35	380	{
d62a17ae	381	return 0;
13d60d35	382	}
13d60d35	383
d62a17ae	384	int kernel_del_vtep(vni_t vni, struct interface ifp, struct in_addr vtep_ip)
13d60d35	385	{
d62a17ae	386	return 0;
13d60d35	387	}
2232a77c	388
d62a17ae	389	int kernel_add_mac(struct interface ifp, vlanid_t vid, struct ethaddr mac,
a37f4598	390	struct in_addr vtep_ip, bool sticky)
2232a77c	391	{
d62a17ae	392	return 0;
2232a77c	393	}
2232a77c	394
d62a17ae	395	int kernel_del_mac(struct interface ifp, vlanid_t vid, struct ethaddr mac,
d63c1b18	396	struct in_addr vtep_ip)
2232a77c	397	{
d62a17ae	398	return 0;
2232a77c	399	}
2232a77c	400
d62a17ae	401	int kernel_add_neigh(struct interface ifp, struct ipaddr ip,
68e33151	402	struct ethaddr *mac, uint8_t flags)
2232a77c	403	{
d62a17ae	404	return 0;
2232a77c	405	}
2232a77c	406
d62a17ae	407	int kernel_del_neigh(struct interface ifp, struct ipaddr ip)
2232a77c	408	{
d62a17ae	409	return 0;
2232a77c	410	}
e0ae31b8 DS	411
	412	extern int kernel_interface_set_master(struct interface *master,
	413	struct interface *slave)
	414	{
	415	return 0;
	416	}
0ecfe5bf	417
dc7b3cae DS	418	uint32_t kernel_get_speed(struct interface *ifp)
	419	{
	420	return ifp->speed;
	421	}
	422
ddfeb486	423	#endif /* !HAVE_NETLINK */