[mirror_frr.git] / zebra / ioctl.c

/*
 * Common ioctl functions.
 * 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>

#include "linklist.h"
#include "if.h"
#include "prefix.h"
#include "ioctl.h"
#include "log.h"
#include "privs.h"
#include "lib_errors.h"

#include "vty.h"
#include "zebra/rib.h"
#include "zebra/rt.h"
#include "zebra/interface.h"
#include "zebra/zebra_errors.h"
#include "zebra/debug.h"

#ifndef SUNOS_5

#ifdef HAVE_BSD_LINK_DETECT
#include <net/if_media.h>
#endif /* HAVE_BSD_LINK_DETECT*/

extern struct zebra_privs_t zserv_privs;

/* clear and set interface name string */
void ifreq_set_name(struct ifreq *ifreq, struct interface *ifp)
{
	strlcpy(ifreq->ifr_name, ifp->name, sizeof(ifreq->ifr_name));
}

/* call ioctl system call */
int if_ioctl(unsigned long request, caddr_t buffer)
{
	int sock;
	int ret;
	int err = 0;

	frr_with_privs(&zserv_privs) {
		sock = socket(AF_INET, SOCK_DGRAM, 0);
		if (sock < 0) {
			zlog_err("Cannot create UDP socket: %s",
				 safe_strerror(errno));
			exit(1);
		}
		if ((ret = ioctl(sock, request, buffer)) < 0)
			err = errno;
	}
	close(sock);

	if (ret < 0) {
		errno = err;
		return ret;
	}
	return 0;
}

/* call ioctl system call */
int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
{
	int sock;
	int ret;
	int err = 0;

	frr_with_privs(&zserv_privs) {
		sock = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf_id, NULL);
		if (sock < 0) {
			zlog_err("Cannot create UDP socket: %s",
				 safe_strerror(errno));
			exit(1);
		}
		ret = vrf_ioctl(vrf_id, sock, request, buffer);
		if (ret < 0)
			err = errno;
	}
	close(sock);

	if (ret < 0) {
		errno = err;
		return ret;
	}
	return 0;
}

#ifndef HAVE_NETLINK
static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
{
	int sock;
	int ret;
	int err = 0;

	frr_with_privs(&zserv_privs) {
		sock = socket(AF_INET6, SOCK_DGRAM, 0);
		if (sock < 0) {
			zlog_err("Cannot create IPv6 datagram socket: %s",
				 safe_strerror(errno));
			exit(1);
		}

		if ((ret = ioctl(sock, request, buffer)) < 0)
			err = errno;
	}
	close(sock);

	if (ret < 0) {
		errno = err;
		return ret;
	}
	return 0;
}
#endif /* ! HAVE_NETLINK */

/*
 * get interface metric
 *   -- if value is not avaliable set -1
 */
void if_get_metric(struct interface *ifp)
{
#ifdef SIOCGIFMETRIC
	struct ifreq ifreq;

	ifreq_set_name(&ifreq, ifp);

	if (vrf_if_ioctl(SIOCGIFMETRIC, (caddr_t)&ifreq, ifp->vrf_id) < 0)
		return;
	ifp->metric = ifreq.ifr_metric;
	if (ifp->metric == 0)
		ifp->metric = 1;
#else  /* SIOCGIFMETRIC */
	ifp->metric = -1;
#endif /* SIOCGIFMETRIC */
}

/* get interface MTU */
void if_get_mtu(struct interface *ifp)
{
	struct ifreq ifreq;

	ifreq_set_name(&ifreq, ifp);

#if defined(SIOCGIFMTU)
	if (vrf_if_ioctl(SIOCGIFMTU, (caddr_t)&ifreq, ifp->vrf_id) < 0) {
		zlog_info("Can't lookup mtu by ioctl(SIOCGIFMTU)");
		ifp->mtu6 = ifp->mtu = -1;
		return;
	}

#ifdef SUNOS_5
	ifp->mtu6 = ifp->mtu = ifreq.ifr_metric;
#else
	ifp->mtu6 = ifp->mtu = ifreq.ifr_mtu;
#endif /* SUNOS_5 */

	/* propogate */
	zebra_interface_up_update(ifp);

#else
	zlog_info("Can't lookup mtu on this system");
	ifp->mtu6 = ifp->mtu = -1;
#endif
}

/*
 * Handler for interface address programming via the zebra dplane,
 * for non-netlink platforms. This handler dispatches to per-platform
 * helpers, based on the operation requested.
 */
#ifndef HAVE_NETLINK

/* Prototypes: these are placed in this block so that they're only seen
 * on non-netlink platforms.
 */
static int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx);
static int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx);
static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx);
static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx);

enum zebra_dplane_result kernel_address_update_ctx(
	struct zebra_dplane_ctx *ctx)
{
	int ret = -1;
	const struct prefix *p;

	p = dplane_ctx_get_intf_addr(ctx);

	if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_INSTALL) {
		if (p->family == AF_INET)
			ret = if_set_prefix_ctx(ctx);
		else
			ret = if_set_prefix6_ctx(ctx);
	} else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_UNINSTALL) {
		if (p->family == AF_INET)
			ret = if_unset_prefix_ctx(ctx);
		else
			ret = if_unset_prefix6_ctx(ctx);
	} else {
		if (IS_ZEBRA_DEBUG_DPLANE)
			zlog_debug("Invalid op in interface-addr install");
	}

	return (ret == 0 ?
		ZEBRA_DPLANE_REQUEST_SUCCESS : ZEBRA_DPLANE_REQUEST_FAILURE);
}

#endif	/* !HAVE_NETLINK */

#ifdef HAVE_NETLINK

/* TODO -- remove; no use of these apis with netlink any longer */

#else /* ! HAVE_NETLINK */
#ifdef HAVE_STRUCT_IFALIASREQ

/*
 * Helper for interface-addr install, non-netlink
 */
static int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx)
{
	int ret;
	struct ifaliasreq addreq;
	struct sockaddr_in addr, mask, peer;
	struct prefix_ipv4 *p;

	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);

	memset(&addreq, 0, sizeof(addreq));
	strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
		sizeof(addreq.ifra_name));

	memset(&addr, 0, sizeof(struct sockaddr_in));
	addr.sin_addr = p->prefix;
	addr.sin_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	addr.sin_len = sizeof(struct sockaddr_in);
#endif
	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));

	if (dplane_ctx_intf_is_connected(ctx)) {
		p = (struct prefix_ipv4 *)dplane_ctx_get_intf_dest(ctx);
		memset(&mask, 0, sizeof(struct sockaddr_in));
		peer.sin_addr = p->prefix;
		peer.sin_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		peer.sin_len = sizeof(struct sockaddr_in);
#endif
		memcpy(&addreq.ifra_broadaddr, &peer,
		       sizeof(struct sockaddr_in));
	}

	memset(&mask, 0, sizeof(struct sockaddr_in));
	masklen2ip(p->prefixlen, &mask.sin_addr);
	mask.sin_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	mask.sin_len = sizeof(struct sockaddr_in);
#endif
	memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));

	ret = if_ioctl(SIOCAIFADDR, (caddr_t)&addreq);
	if (ret < 0)
		return ret;
	return 0;

}

/*
 * Helper for interface-addr un-install, non-netlink
 */
static int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx)
{
	int ret;
	struct ifaliasreq addreq;
	struct sockaddr_in addr, mask, peer;
	struct prefix_ipv4 *p;

	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);

	memset(&addreq, 0, sizeof(addreq));
	strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
		sizeof(addreq.ifra_name));

	memset(&addr, 0, sizeof(struct sockaddr_in));
	addr.sin_addr = p->prefix;
	addr.sin_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	addr.sin_len = sizeof(struct sockaddr_in);
#endif
	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));

	if (dplane_ctx_intf_is_connected(ctx)) {
		p = (struct prefix_ipv4 *)dplane_ctx_get_intf_dest(ctx);
		memset(&mask, 0, sizeof(struct sockaddr_in));
		peer.sin_addr = p->prefix;
		peer.sin_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		peer.sin_len = sizeof(struct sockaddr_in);
#endif
		memcpy(&addreq.ifra_broadaddr, &peer,
		       sizeof(struct sockaddr_in));
	}

	memset(&mask, 0, sizeof(struct sockaddr_in));
	masklen2ip(p->prefixlen, &mask.sin_addr);
	mask.sin_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	mask.sin_len = sizeof(struct sockaddr_in);
#endif
	memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));

	ret = if_ioctl(SIOCDIFADDR, (caddr_t)&addreq);
	if (ret < 0)
		return ret;
	return 0;
}
#else
/* Set up interface's address, netmask (and broadcas? ).  Linux or
   Solaris uses ifname:number semantics to set IP address aliases. */
int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx)
{
	int ret;
	struct ifreq ifreq;
	struct sockaddr_in addr;
	struct sockaddr_in broad;
	struct sockaddr_in mask;
	struct prefix_ipv4 ifaddr;
	struct prefix_ipv4 *p;

	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);

	ifaddr = *p;

	strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
		sizeof(ifreq.ifr_name));

	addr.sin_addr = p->prefix;
	addr.sin_family = p->family;
	memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
	ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
	if (ret < 0)
		return ret;

	/* We need mask for make broadcast addr. */
	masklen2ip(p->prefixlen, &mask.sin_addr);

	if (dplane_ctx_intf_is_broadcast(ctx)) {
		apply_mask_ipv4(&ifaddr);
		addr.sin_addr = ifaddr.prefix;

		broad.sin_addr.s_addr =
			(addr.sin_addr.s_addr | ~mask.sin_addr.s_addr);
		broad.sin_family = p->family;

		memcpy(&ifreq.ifr_broadaddr, &broad,
		       sizeof(struct sockaddr_in));
		ret = if_ioctl(SIOCSIFBRDADDR, (caddr_t)&ifreq);
		if (ret < 0)
			return ret;
	}

	mask.sin_family = p->family;
#ifdef SUNOS_5
	memcpy(&mask, &ifreq.ifr_addr, sizeof(mask));
#else
	memcpy(&ifreq.ifr_addr, &mask, sizeof(struct sockaddr_in));
#endif /* SUNOS5 */
	ret = if_ioctl(SIOCSIFNETMASK, (caddr_t)&ifreq);
	if (ret < 0)
		return ret;

	return 0;
}

/* Set up interface's address, netmask (and broadcas? ).  Linux or
   Solaris uses ifname:number semantics to set IP address aliases. */
int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx)
{
	int ret;
	struct ifreq ifreq;
	struct sockaddr_in addr;
	struct prefix_ipv4 *p;

	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);

	strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
		sizeof(ifreq.ifr_name));

	memset(&addr, 0, sizeof(struct sockaddr_in));
	addr.sin_family = p->family;
	memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
	ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
	if (ret < 0)
		return ret;

	return 0;
}
#endif /* HAVE_STRUCT_IFALIASREQ */
#endif /* HAVE_NETLINK */

/* get interface flags */
void if_get_flags(struct interface *ifp)
{
	int ret;
	struct ifreq ifreq;
#ifdef HAVE_BSD_LINK_DETECT
	struct ifmediareq ifmr;
#endif /* HAVE_BSD_LINK_DETECT */

	ifreq_set_name(&ifreq, ifp);

	ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
	if (ret < 0) {
		flog_err_sys(EC_LIB_SYSTEM_CALL,
			     "vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
			     safe_strerror(errno));
		return;
	}
#ifdef HAVE_BSD_LINK_DETECT /* Detect BSD link-state at start-up */

	/* Per-default, IFF_RUNNING is held high, unless link-detect says
	 * otherwise - we abuse IFF_RUNNING inside zebra as a link-state flag,
	 * following practice on Linux and Solaris kernels
	 */
	SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);

	if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)) {
		(void)memset(&ifmr, 0, sizeof(ifmr));
		strlcpy(ifmr.ifm_name, ifp->name, sizeof(ifmr.ifm_name));

		/* Seems not all interfaces implement this ioctl */
		if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) == -1 &&
		    errno != EINVAL)
			flog_err_sys(EC_LIB_SYSTEM_CALL,
				     "if_ioctl(SIOCGIFMEDIA) failed: %s",
				     safe_strerror(errno));
		else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
		{
			if (ifmr.ifm_status & IFM_ACTIVE)
				SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
			else
				UNSET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
		}
	}
#endif /* HAVE_BSD_LINK_DETECT */

	if_flags_update(ifp, (ifreq.ifr_flags & 0x0000ffff));
}

/* Set interface flags */
int if_set_flags(struct interface *ifp, uint64_t flags)
{
	int ret;
	struct ifreq ifreq;

	memset(&ifreq, 0, sizeof(struct ifreq));
	ifreq_set_name(&ifreq, ifp);

	ifreq.ifr_flags = ifp->flags;
	ifreq.ifr_flags |= flags;

	ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);

	if (ret < 0) {
		zlog_info("can't set interface flags");
		return ret;
	}
	return 0;
}

/* Unset interface's flag. */
int if_unset_flags(struct interface *ifp, uint64_t flags)
{
	int ret;
	struct ifreq ifreq;

	memset(&ifreq, 0, sizeof(struct ifreq));
	ifreq_set_name(&ifreq, ifp);

	ifreq.ifr_flags = ifp->flags;
	ifreq.ifr_flags &= ~flags;

	ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);

	if (ret < 0) {
		zlog_info("can't unset interface flags");
		return ret;
	}
	return 0;
}

#ifndef LINUX_IPV6 /* Netlink has its own code */

#ifdef HAVE_STRUCT_IN6_ALIASREQ
#ifndef ND6_INFINITE_LIFETIME
#define ND6_INFINITE_LIFETIME 0xffffffffL
#endif /* ND6_INFINITE_LIFETIME */

/*
 * Helper for interface-addr install, non-netlink
 */
static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
{
	int ret;
	struct in6_aliasreq addreq;
	struct sockaddr_in6 addr;
	struct sockaddr_in6 mask;
	struct prefix_ipv6 *p;

	p = (struct prefix_ipv6 *)dplane_ctx_get_intf_addr(ctx);

	memset(&addreq, 0, sizeof(addreq));
	strlcpy((char *)&addreq.ifra_name,
		dplane_ctx_get_ifname(ctx), sizeof(addreq.ifra_name));

	memset(&addr, 0, sizeof(struct sockaddr_in6));
	addr.sin6_addr = p->prefix;
	addr.sin6_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	addr.sin6_len = sizeof(struct sockaddr_in6);
#endif
	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));

	memset(&mask, 0, sizeof(struct sockaddr_in6));
	masklen2ip6(p->prefixlen, &mask.sin6_addr);
	mask.sin6_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	mask.sin6_len = sizeof(struct sockaddr_in6);
#endif
	memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));

	addreq.ifra_lifetime.ia6t_vltime = 0xffffffff;
	addreq.ifra_lifetime.ia6t_pltime = 0xffffffff;

#ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
	addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
	addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
#endif

	ret = if_ioctl_ipv6(SIOCAIFADDR_IN6, (caddr_t)&addreq);
	if (ret < 0)
		return ret;
	return 0;
}

/*
 * Helper for interface-addr un-install, non-netlink
 */
static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
{
	int ret;
	struct in6_aliasreq addreq;
	struct sockaddr_in6 addr;
	struct sockaddr_in6 mask;
	struct prefix_ipv6 *p;

	p = (struct prefix_ipv6 *)dplane_ctx_get_intf_addr(ctx);

	memset(&addreq, 0, sizeof(addreq));
	strlcpy((char *)&addreq.ifra_name,
		dplane_ctx_get_ifname(ctx), sizeof(addreq.ifra_name));

	memset(&addr, 0, sizeof(struct sockaddr_in6));
	addr.sin6_addr = p->prefix;
	addr.sin6_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	addr.sin6_len = sizeof(struct sockaddr_in6);
#endif
	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));

	memset(&mask, 0, sizeof(struct sockaddr_in6));
	masklen2ip6(p->prefixlen, &mask.sin6_addr);
	mask.sin6_family = p->family;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	mask.sin6_len = sizeof(struct sockaddr_in6);
#endif
	memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));

#ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
	addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
	addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
#endif

	ret = if_ioctl_ipv6(SIOCDIFADDR_IN6, (caddr_t)&addreq);
	if (ret < 0)
		return ret;
	return 0;
}
#else
/* The old, pre-dataplane code here just returned, so we're retaining that
 * choice.
 */
static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
{
	return 0;
}

static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
{
	return 0;
}
#endif /* HAVE_STRUCT_IN6_ALIASREQ */

#endif /* LINUX_IPV6 */

#endif /* !SUNOS_5 */
Commit	Line	Data
718e3744	1	/*
	2	* Common ioctl functions.
	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>
	23
	24	#include "linklist.h"
	25	#include "if.h"
	26	#include "prefix.h"
	27	#include "ioctl.h"
	28	#include "log.h"
edd7c245	29	#include "privs.h"
174482ef	30	#include "lib_errors.h"
718e3744	31
5e6a74d8	32	#include "vty.h"
718e3744	33	#include "zebra/rib.h"
718e3744	34	#include "zebra/rt.h"
5c78b3d0	35	#include "zebra/interface.h"
364fed6b	36	#include "zebra/zebra_errors.h"
0f1f6ce4	37	#include "zebra/debug.h"
718e3744	38
ddfeb486 DL	39	#ifndef SUNOS_5
ddfeb486 DL	40
55edb0d4 AS	41	#ifdef HAVE_BSD_LINK_DETECT
	42	#include <net/if_media.h>
	43	#endif /* HAVE_BSD_LINK_DETECT*/
	44
edd7c245	45	extern struct zebra_privs_t zserv_privs;
edd7c245	46
718e3744	47	/* clear and set interface name string */
d62a17ae	48	void ifreq_set_name(struct ifreq ifreq, struct interface ifp)
718e3744	49	{
0af35d90	50	strlcpy(ifreq->ifr_name, ifp->name, sizeof(ifreq->ifr_name));
718e3744	51	}
	52
	53	/* call ioctl system call */
d7c0a89a	54	int if_ioctl(unsigned long request, caddr_t buffer)
718e3744	55	{
d62a17ae	56	int sock;
	57	int ret;
	58	int err = 0;
	59
0cf6db21	60	frr_with_privs(&zserv_privs) {
01b9e3fd DL	61	sock = socket(AF_INET, SOCK_DGRAM, 0);
	62	if (sock < 0) {
	63	zlog_err("Cannot create UDP socket: %s",
	64	safe_strerror(errno));
	65	exit(1);
	66	}
	67	if ((ret = ioctl(sock, request, buffer)) < 0)
	68	err = errno;
d62a17ae	69	}
d62a17ae	70	close(sock);
	71
	72	if (ret < 0) {
	73	errno = err;
	74	return ret;
	75	}
	76	return 0;
718e3744	77	}
718e3744	78
4db21619	79	/* call ioctl system call */
d7c0a89a	80	int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
4db21619 PG	81	{
	82	int sock;
	83	int ret;
	84	int err = 0;
	85
0cf6db21	86	frr_with_privs(&zserv_privs) {
01b9e3fd DL	87	sock = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf_id, NULL);
	88	if (sock < 0) {
	89	zlog_err("Cannot create UDP socket: %s",
	90	safe_strerror(errno));
	91	exit(1);
	92	}
	93	ret = vrf_ioctl(vrf_id, sock, request, buffer);
	94	if (ret < 0)
	95	err = errno;
4db21619	96	}
4db21619 PG	97	close(sock);
	98
	99	if (ret < 0) {
	100	errno = err;
	101	return ret;
	102	}
	103	return 0;
	104	}
	105
e86b71f1	106	#ifndef HAVE_NETLINK
d7c0a89a	107	static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
718e3744	108	{
d62a17ae	109	int sock;
	110	int ret;
	111	int err = 0;
	112
0cf6db21	113	frr_with_privs(&zserv_privs) {
01b9e3fd DL	114	sock = socket(AF_INET6, SOCK_DGRAM, 0);
	115	if (sock < 0) {
	116	zlog_err("Cannot create IPv6 datagram socket: %s",
	117	safe_strerror(errno));
	118	exit(1);
	119	}
d62a17ae	120
01b9e3fd DL	121	if ((ret = ioctl(sock, request, buffer)) < 0)
	122	err = errno;
	123	}
d62a17ae	124	close(sock);
	125
	126	if (ret < 0) {
	127	errno = err;
	128	return ret;
	129	}
	130	return 0;
718e3744	131	}
e86b71f1	132	#endif /* ! HAVE_NETLINK */
718e3744	133
	134	/*
	135	* get interface metric
	136	* -- if value is not avaliable set -1
	137	*/
d62a17ae	138	void if_get_metric(struct interface *ifp)
718e3744	139	{
718e3744	140	#ifdef SIOCGIFMETRIC
d62a17ae	141	struct ifreq ifreq;
718e3744	142
d62a17ae	143	ifreq_set_name(&ifreq, ifp);
718e3744	144
a36898e7	145	if (vrf_if_ioctl(SIOCGIFMETRIC, (caddr_t)&ifreq, ifp->vrf_id) < 0)
d62a17ae	146	return;
	147	ifp->metric = ifreq.ifr_metric;
	148	if (ifp->metric == 0)
	149	ifp->metric = 1;
	150	#else /* SIOCGIFMETRIC */
	151	ifp->metric = -1;
718e3744	152	#endif /* SIOCGIFMETRIC */
	153	}
	154
	155	/* get interface MTU */
d62a17ae	156	void if_get_mtu(struct interface *ifp)
718e3744	157	{
d62a17ae	158	struct ifreq ifreq;
718e3744	159
d62a17ae	160	ifreq_set_name(&ifreq, ifp);
718e3744	161
718e3744	162	#if defined(SIOCGIFMTU)
a36898e7	163	if (vrf_if_ioctl(SIOCGIFMTU, (caddr_t)&ifreq, ifp->vrf_id) < 0) {
d62a17ae	164	zlog_info("Can't lookup mtu by ioctl(SIOCGIFMTU)");
	165	ifp->mtu6 = ifp->mtu = -1;
	166	return;
	167	}
718e3744	168
718e3744	169	#ifdef SUNOS_5
d62a17ae	170	ifp->mtu6 = ifp->mtu = ifreq.ifr_metric;
718e3744	171	#else
d62a17ae	172	ifp->mtu6 = ifp->mtu = ifreq.ifr_mtu;
718e3744	173	#endif /* SUNOS_5 */
718e3744	174
d62a17ae	175	/* propogate */
d62a17ae	176	zebra_interface_up_update(ifp);
f5e004f7	177
718e3744	178	#else
d62a17ae	179	zlog_info("Can't lookup mtu on this system");
d62a17ae	180	ifp->mtu6 = ifp->mtu = -1;
718e3744	181	#endif
	182	}
	183
64168803	184	/*
0f1f6ce4 MS	185	* Handler for interface address programming via the zebra dplane,
	186	* for non-netlink platforms. This handler dispatches to per-platform
	187	* helpers, based on the operation requested.
64168803 MS	188	*/
	189	#ifndef HAVE_NETLINK
	190
0f1f6ce4 MS	191	/* Prototypes: these are placed in this block so that they're only seen
	192	* on non-netlink platforms.
	193	*/
	194	static int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx);
	195	static int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx);
	196	static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx);
	197	static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx);
	198
64168803 MS	199	enum zebra_dplane_result kernel_address_update_ctx(
	200	struct zebra_dplane_ctx *ctx)
	201	{
0f1f6ce4 MS	202	int ret = -1;
	203	const struct prefix *p;
	204
	205	p = dplane_ctx_get_intf_addr(ctx);
	206
	207	if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_INSTALL) {
	208	if (p->family == AF_INET)
	209	ret = if_set_prefix_ctx(ctx);
	210	else
	211	ret = if_set_prefix6_ctx(ctx);
	212	} else if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_UNINSTALL) {
	213	if (p->family == AF_INET)
	214	ret = if_unset_prefix_ctx(ctx);
	215	else
	216	ret = if_unset_prefix6_ctx(ctx);
	217	} else {
	218	if (IS_ZEBRA_DEBUG_DPLANE)
	219	zlog_debug("Invalid op in interface-addr install");
	220	}
	221
	222	return (ret == 0 ?
	223	ZEBRA_DPLANE_REQUEST_SUCCESS : ZEBRA_DPLANE_REQUEST_FAILURE);
64168803 MS	224	}
	225
	226	#endif /* !HAVE_NETLINK */
	227
718e3744	228	#ifdef HAVE_NETLINK
0f1f6ce4 MS	229
	230	/* TODO -- remove; no use of these apis with netlink any longer */
	231
	232	#else /* ! HAVE_NETLINK */
	233	#ifdef HAVE_STRUCT_IFALIASREQ
	234
	235	/*
	236	* Helper for interface-addr install, non-netlink
	237	*/
	238	static int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx)
718e3744	239	{
0f1f6ce4 MS	240	int ret;
	241	struct ifaliasreq addreq;
	242	struct sockaddr_in addr, mask, peer;
	243	struct prefix_ipv4 *p;
	244
	245	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
	246
	247	memset(&addreq, 0, sizeof(addreq));
fcb072cd	248	strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
0f1f6ce4 MS	249	sizeof(addreq.ifra_name));
	250
	251	memset(&addr, 0, sizeof(struct sockaddr_in));
	252	addr.sin_addr = p->prefix;
	253	addr.sin_family = p->family;
	254	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	255	addr.sin_len = sizeof(struct sockaddr_in);
	256	#endif
	257	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
	258
	259	if (dplane_ctx_intf_is_connected(ctx)) {
	260	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_dest(ctx);
	261	memset(&mask, 0, sizeof(struct sockaddr_in));
	262	peer.sin_addr = p->prefix;
	263	peer.sin_family = p->family;
	264	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	265	peer.sin_len = sizeof(struct sockaddr_in);
	266	#endif
	267	memcpy(&addreq.ifra_broadaddr, &peer,
	268	sizeof(struct sockaddr_in));
	269	}
	270
	271	memset(&mask, 0, sizeof(struct sockaddr_in));
	272	masklen2ip(p->prefixlen, &mask.sin_addr);
	273	mask.sin_family = p->family;
	274	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	275	mask.sin_len = sizeof(struct sockaddr_in);
	276	#endif
	277	memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));
	278
	279	ret = if_ioctl(SIOCAIFADDR, (caddr_t)&addreq);
	280	if (ret < 0)
	281	return ret;
	282	return 0;
	283
718e3744	284	}
718e3744	285
0f1f6ce4 MS	286	/*
	287	* Helper for interface-addr un-install, non-netlink
	288	*/
	289	static int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx)
718e3744	290	{
0f1f6ce4 MS	291	int ret;
	292	struct ifaliasreq addreq;
	293	struct sockaddr_in addr, mask, peer;
	294	struct prefix_ipv4 *p;
	295
	296	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
	297
	298	memset(&addreq, 0, sizeof(addreq));
fcb072cd	299	strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
0f1f6ce4 MS	300	sizeof(addreq.ifra_name));
	301
	302	memset(&addr, 0, sizeof(struct sockaddr_in));
	303	addr.sin_addr = p->prefix;
	304	addr.sin_family = p->family;
	305	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	306	addr.sin_len = sizeof(struct sockaddr_in);
	307	#endif
	308	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in));
	309
	310	if (dplane_ctx_intf_is_connected(ctx)) {
	311	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_dest(ctx);
	312	memset(&mask, 0, sizeof(struct sockaddr_in));
	313	peer.sin_addr = p->prefix;
	314	peer.sin_family = p->family;
	315	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	316	peer.sin_len = sizeof(struct sockaddr_in);
	317	#endif
	318	memcpy(&addreq.ifra_broadaddr, &peer,
	319	sizeof(struct sockaddr_in));
	320	}
	321
	322	memset(&mask, 0, sizeof(struct sockaddr_in));
	323	masklen2ip(p->prefixlen, &mask.sin_addr);
	324	mask.sin_family = p->family;
	325	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	326	mask.sin_len = sizeof(struct sockaddr_in);
	327	#endif
	328	memcpy(&addreq.ifra_mask, &mask, sizeof(struct sockaddr_in));
	329
	330	ret = if_ioctl(SIOCDIFADDR, (caddr_t)&addreq);
	331	if (ret < 0)
	332	return ret;
	333	return 0;
718e3744	334	}
718e3744	335	#else
	336	/* Set up interface's address, netmask (and broadcas? ). Linux or
	337	Solaris uses ifname:number semantics to set IP address aliases. */
39fa2825	338	int if_set_prefix_ctx(const struct zebra_dplane_ctx *ctx)
718e3744	339	{
d62a17ae	340	int ret;
	341	struct ifreq ifreq;
	342	struct sockaddr_in addr;
	343	struct sockaddr_in broad;
	344	struct sockaddr_in mask;
	345	struct prefix_ipv4 ifaddr;
	346	struct prefix_ipv4 *p;
	347
39fa2825	348	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
d62a17ae	349
	350	ifaddr = *p;
	351
39fa2825 MS	352	strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
39fa2825 MS	353	sizeof(ifreq.ifr_name));
d62a17ae	354
	355	addr.sin_addr = p->prefix;
	356	addr.sin_family = p->family;
	357	memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
	358	ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
	359	if (ret < 0)
	360	return ret;
	361
	362	/* We need mask for make broadcast addr. */
	363	masklen2ip(p->prefixlen, &mask.sin_addr);
	364
39fa2825	365	if (dplane_ctx_intf_is_broadcast(ctx)) {
d62a17ae	366	apply_mask_ipv4(&ifaddr);
	367	addr.sin_addr = ifaddr.prefix;
	368
	369	broad.sin_addr.s_addr =
	370	(addr.sin_addr.s_addr \| ~mask.sin_addr.s_addr);
	371	broad.sin_family = p->family;
	372
	373	memcpy(&ifreq.ifr_broadaddr, &broad,
	374	sizeof(struct sockaddr_in));
	375	ret = if_ioctl(SIOCSIFBRDADDR, (caddr_t)&ifreq);
	376	if (ret < 0)
	377	return ret;
	378	}
	379
	380	mask.sin_family = p->family;
718e3744	381	#ifdef SUNOS_5
d62a17ae	382	memcpy(&mask, &ifreq.ifr_addr, sizeof(mask));
718e3744	383	#else
39fa2825	384	memcpy(&ifreq.ifr_addr, &mask, sizeof(struct sockaddr_in));
718e3744	385	#endif /* SUNOS5 */
d62a17ae	386	ret = if_ioctl(SIOCSIFNETMASK, (caddr_t)&ifreq);
	387	if (ret < 0)
	388	return ret;
718e3744	389
d62a17ae	390	return 0;
718e3744	391	}
	392
	393	/* Set up interface's address, netmask (and broadcas? ). Linux or
	394	Solaris uses ifname:number semantics to set IP address aliases. */
39fa2825	395	int if_unset_prefix_ctx(const struct zebra_dplane_ctx *ctx)
718e3744	396	{
d62a17ae	397	int ret;
	398	struct ifreq ifreq;
	399	struct sockaddr_in addr;
	400	struct prefix_ipv4 *p;
718e3744	401
39fa2825	402	p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
718e3744	403
39fa2825 MS	404	strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
39fa2825 MS	405	sizeof(ifreq.ifr_name));
718e3744	406
d62a17ae	407	memset(&addr, 0, sizeof(struct sockaddr_in));
	408	addr.sin_family = p->family;
	409	memcpy(&ifreq.ifr_addr, &addr, sizeof(struct sockaddr_in));
	410	ret = if_ioctl(SIOCSIFADDR, (caddr_t)&ifreq);
	411	if (ret < 0)
	412	return ret;
718e3744	413
d62a17ae	414	return 0;
718e3744	415	}
6f0e3f6e	416	#endif /* HAVE_STRUCT_IFALIASREQ */
718e3744	417	#endif /* HAVE_NETLINK */
	418
	419	/* get interface flags */
d62a17ae	420	void if_get_flags(struct interface *ifp)
718e3744	421	{
d62a17ae	422	int ret;
d62a17ae	423	struct ifreq ifreq;
c543a173	424	#ifdef HAVE_BSD_LINK_DETECT
d62a17ae	425	struct ifmediareq ifmr;
c543a173	426	#endif /* HAVE_BSD_LINK_DETECT */
718e3744	427
d62a17ae	428	ifreq_set_name(&ifreq, ifp);
718e3744	429
a36898e7	430	ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
d62a17ae	431	if (ret < 0) {
450971aa	432	flog_err_sys(EC_LIB_SYSTEM_CALL,
09c866e3 QY	433	"vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
09c866e3 QY	434	safe_strerror(errno));
d62a17ae	435	return;
d62a17ae	436	}
c543a173	437	#ifdef HAVE_BSD_LINK_DETECT /* Detect BSD link-state at start-up */
0b3f3d47	438
d62a17ae	439	/* Per-default, IFF_RUNNING is held high, unless link-detect says
	440	* otherwise - we abuse IFF_RUNNING inside zebra as a link-state flag,
	441	* following practice on Linux and Solaris kernels
	442	*/
	443	SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
	444
	445	if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)) {
	446	(void)memset(&ifmr, 0, sizeof(ifmr));
138a4965	447	strlcpy(ifmr.ifm_name, ifp->name, sizeof(ifmr.ifm_name));
d62a17ae	448
d62a17ae	449	/* Seems not all interfaces implement this ioctl */
c69f2c1f RZ	450	if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) == -1 &&
c69f2c1f RZ	451	errno != EINVAL)
450971aa	452	flog_err_sys(EC_LIB_SYSTEM_CALL,
09c866e3 QY	453	"if_ioctl(SIOCGIFMEDIA) failed: %s",
09c866e3 QY	454	safe_strerror(errno));
d62a17ae	455	else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
	456	{
	457	if (ifmr.ifm_status & IFM_ACTIVE)
	458	SET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
	459	else
	460	UNSET_FLAG(ifreq.ifr_flags, IFF_RUNNING);
	461	}
	462	}
c543a173	463	#endif /* HAVE_BSD_LINK_DETECT */
718e3744	464
d62a17ae	465	if_flags_update(ifp, (ifreq.ifr_flags & 0x0000ffff));
718e3744	466	}
	467
	468	/* Set interface flags */
d62a17ae	469	int if_set_flags(struct interface *ifp, uint64_t flags)
718e3744	470	{
d62a17ae	471	int ret;
d62a17ae	472	struct ifreq ifreq;
718e3744	473
d62a17ae	474	memset(&ifreq, 0, sizeof(struct ifreq));
d62a17ae	475	ifreq_set_name(&ifreq, ifp);
718e3744	476
d62a17ae	477	ifreq.ifr_flags = ifp->flags;
d62a17ae	478	ifreq.ifr_flags \|= flags;
718e3744	479
a36898e7	480	ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
718e3744	481
d62a17ae	482	if (ret < 0) {
	483	zlog_info("can't set interface flags");
	484	return ret;
	485	}
	486	return 0;
718e3744	487	}
	488
	489	/* Unset interface's flag. */
d62a17ae	490	int if_unset_flags(struct interface *ifp, uint64_t flags)
718e3744	491	{
d62a17ae	492	int ret;
d62a17ae	493	struct ifreq ifreq;
718e3744	494
d62a17ae	495	memset(&ifreq, 0, sizeof(struct ifreq));
d62a17ae	496	ifreq_set_name(&ifreq, ifp);
718e3744	497
d62a17ae	498	ifreq.ifr_flags = ifp->flags;
d62a17ae	499	ifreq.ifr_flags &= ~flags;
718e3744	500
a36898e7	501	ret = vrf_if_ioctl(SIOCSIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
718e3744	502
d62a17ae	503	if (ret < 0) {
	504	zlog_info("can't unset interface flags");
	505	return ret;
	506	}
	507	return 0;
718e3744	508	}
718e3744	509
39fa2825	510	#ifndef LINUX_IPV6 /* Netlink has its own code */
718e3744	511
6f0e3f6e	512	#ifdef HAVE_STRUCT_IN6_ALIASREQ
718e3744	513	#ifndef ND6_INFINITE_LIFETIME
	514	#define ND6_INFINITE_LIFETIME 0xffffffffL
	515	#endif /* ND6_INFINITE_LIFETIME */
0f1f6ce4 MS	516
	517	/*
	518	* Helper for interface-addr install, non-netlink
	519	*/
	520	static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
	521	{
	522	int ret;
	523	struct in6_aliasreq addreq;
	524	struct sockaddr_in6 addr;
	525	struct sockaddr_in6 mask;
	526	struct prefix_ipv6 *p;
	527
	528	p = (struct prefix_ipv6 *)dplane_ctx_get_intf_addr(ctx);
	529
	530	memset(&addreq, 0, sizeof(addreq));
39fa2825	531	strlcpy((char *)&addreq.ifra_name,
0f1f6ce4 MS	532	dplane_ctx_get_ifname(ctx), sizeof(addreq.ifra_name));
	533
	534	memset(&addr, 0, sizeof(struct sockaddr_in6));
	535	addr.sin6_addr = p->prefix;
	536	addr.sin6_family = p->family;
	537	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	538	addr.sin6_len = sizeof(struct sockaddr_in6);
	539	#endif
	540	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));
	541
	542	memset(&mask, 0, sizeof(struct sockaddr_in6));
	543	masklen2ip6(p->prefixlen, &mask.sin6_addr);
	544	mask.sin6_family = p->family;
	545	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	546	mask.sin6_len = sizeof(struct sockaddr_in6);
	547	#endif
	548	memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));
	549
	550	addreq.ifra_lifetime.ia6t_vltime = 0xffffffff;
	551	addreq.ifra_lifetime.ia6t_pltime = 0xffffffff;
	552
	553	#ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
	554	addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
	555	addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
	556	#endif
	557
	558	ret = if_ioctl_ipv6(SIOCAIFADDR_IN6, (caddr_t)&addreq);
	559	if (ret < 0)
	560	return ret;
	561	return 0;
	562	}
	563
	564	/*
	565	* Helper for interface-addr un-install, non-netlink
	566	*/
	567	static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
	568	{
	569	int ret;
	570	struct in6_aliasreq addreq;
	571	struct sockaddr_in6 addr;
	572	struct sockaddr_in6 mask;
	573	struct prefix_ipv6 *p;
	574
	575	p = (struct prefix_ipv6 *)dplane_ctx_get_intf_addr(ctx);
	576
	577	memset(&addreq, 0, sizeof(addreq));
39fa2825	578	strlcpy((char *)&addreq.ifra_name,
0f1f6ce4 MS	579	dplane_ctx_get_ifname(ctx), sizeof(addreq.ifra_name));
	580
	581	memset(&addr, 0, sizeof(struct sockaddr_in6));
	582	addr.sin6_addr = p->prefix;
	583	addr.sin6_family = p->family;
	584	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	585	addr.sin6_len = sizeof(struct sockaddr_in6);
	586	#endif
	587	memcpy(&addreq.ifra_addr, &addr, sizeof(struct sockaddr_in6));
	588
	589	memset(&mask, 0, sizeof(struct sockaddr_in6));
	590	masklen2ip6(p->prefixlen, &mask.sin6_addr);
	591	mask.sin6_family = p->family;
	592	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	593	mask.sin6_len = sizeof(struct sockaddr_in6);
	594	#endif
	595	memcpy(&addreq.ifra_prefixmask, &mask, sizeof(struct sockaddr_in6));
	596
6f0e3f6e	597	#ifdef HAVE_STRUCT_IF6_ALIASREQ_IFRA_LIFETIME
d62a17ae	598	addreq.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
d62a17ae	599	addreq.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
726f9b2b	600	#endif
718e3744	601
d62a17ae	602	ret = if_ioctl_ipv6(SIOCDIFADDR_IN6, (caddr_t)&addreq);
	603	if (ret < 0)
	604	return ret;
	605	return 0;
718e3744	606	}
718e3744	607	#else
39fa2825 MS	608	/* The old, pre-dataplane code here just returned, so we're retaining that
	609	* choice.
	610	*/
	611	static int if_set_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
718e3744	612	{
d62a17ae	613	return 0;
718e3744	614	}
718e3744	615
39fa2825	616	static int if_unset_prefix6_ctx(const struct zebra_dplane_ctx *ctx)
718e3744	617	{
d62a17ae	618	return 0;
718e3744	619	}
6f0e3f6e	620	#endif /* HAVE_STRUCT_IN6_ALIASREQ */
718e3744	621
718e3744	622	#endif /* LINUX_IPV6 */
ddfeb486 DL	623
ddfeb486 DL	624	#endif /* !SUNOS_5 */