xref: /illumos-gate/usr/src/lib/libipadm/common/ipadm_ndpd.c (revision c8152f8f417d34bc129af68ca0b76cfa9ca764db)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
 * Copyright 2023 Oxide Computer Company
 */

/*
 * This file contains the functions that are required for communicating
 * with in.ndpd while creating autoconfigured addresses.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/sockio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <inet/ip.h>
#include <arpa/inet.h>
#include <assert.h>
#include <poll.h>
#include <ipadm_ndpd.h>
#include "libipadm_impl.h"

#define	NDPDTIMEOUT		5000
#define	PREFIXLEN_LINKLOCAL	10

static ipadm_status_t	i_ipadm_create_linklocal(ipadm_handle_t,
			    ipadm_addrobj_t);
static void		i_ipadm_make_linklocal(struct sockaddr_in6 *,
			    const struct in6_addr *);
static ipadm_status_t	i_ipadm_send_ndpd_cmd(const char *,
			    const struct ipadm_addrobj_s *, int);

/*
 * Sends message to in.ndpd asking not to do autoconf for the given interface,
 * until IPADM_CREATE_ADDRS or IPADM_ENABLE_AUTOCONF is sent.
 */
ipadm_status_t
i_ipadm_disable_autoconf(const char *ifname)
{
	return (i_ipadm_send_ndpd_cmd(ifname, NULL, IPADM_DISABLE_AUTOCONF));
}

/*
 * Sends message to in.ndpd to enable autoconf for the given interface,
 * until another IPADM_DISABLE_AUTOCONF is sent.
 */
ipadm_status_t
i_ipadm_enable_autoconf(const char *ifname)
{
	return (i_ipadm_send_ndpd_cmd(ifname, NULL, IPADM_ENABLE_AUTOCONF));
}

ipadm_status_t
i_ipadm_create_ipv6addrs(ipadm_handle_t iph, ipadm_addrobj_t addr,
    uint32_t i_flags)
{
	ipadm_status_t status;

	/*
	 * Create the link local based on the given token. If the same intfid
	 * was already used with a different address object, this step will
	 * fail.
	 */
	status = i_ipadm_create_linklocal(iph, addr);
	if (status != IPADM_SUCCESS)
		return (status);

	/*
	 * Request in.ndpd to start the autoconfiguration.
	 * If autoconfiguration was already started by another means (e.g.
	 * "ifconfig" ), in.ndpd will return EEXIST.
	 */
	if (addr->ipadm_stateless || addr->ipadm_stateful) {
		status = i_ipadm_send_ndpd_cmd(addr->ipadm_ifname, addr,
		    IPADM_CREATE_ADDRS);
		if (status != IPADM_SUCCESS &&
		    status != IPADM_NDPD_NOT_RUNNING) {
			(void) i_ipadm_delete_addr(iph, addr);
			return (status);
		}
	}

	/* Persist the intfid. */
	status = i_ipadm_addr_persist(iph, addr, B_FALSE, i_flags, NULL);
	if (status != IPADM_SUCCESS) {
		(void) i_ipadm_delete_addr(iph, addr);
		(void) i_ipadm_send_ndpd_cmd(addr->ipadm_ifname, addr,
		    IPADM_DELETE_ADDRS);
	}

	return (status);
}

ipadm_status_t
i_ipadm_delete_ipv6addrs(ipadm_handle_t iph, ipadm_addrobj_t ipaddr)
{
	ipadm_status_t status;

	/*
	 * Send a msg to in.ndpd to remove the autoconfigured addresses,
	 * and delete the link local that was created.
	 */
	status = i_ipadm_send_ndpd_cmd(ipaddr->ipadm_ifname, ipaddr,
	    IPADM_DELETE_ADDRS);

	/* if the entry is not found, or ndpd is not running, just carry on */
	if (status == IPADM_NDPD_NOT_RUNNING || status == IPADM_ENXIO ||
	    status == IPADM_NOTFOUND)
		status = IPADM_SUCCESS;

	if (status == IPADM_SUCCESS)
		status = i_ipadm_delete_addr(iph, ipaddr);

	return (status);
}

static ipadm_status_t
i_ipadm_create_linklocal(ipadm_handle_t iph, ipadm_addrobj_t addr)
{
	boolean_t addif = B_FALSE;
	struct sockaddr_in6 *sin6;
	struct lifreq lifr;
	int err;
	ipadm_status_t status;
	in6_addr_t ll_template = {0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
	    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };

	/*
	 * Create a logical interface if needed.
	 */
retry:
	status = i_ipadm_do_addif(iph, addr, &addif);
	if (status != IPADM_SUCCESS)
		return (status);
	if (!(iph->iph_flags & IPH_INIT)) {
		status = i_ipadm_setlifnum_addrobj(iph, addr);
		if (status == IPADM_ADDROBJ_EXISTS)
			goto retry;
		if (status != IPADM_SUCCESS)
			return (status);
	}

	bzero(&lifr, sizeof (lifr));
	(void) strlcpy(lifr.lifr_name, addr->ipadm_ifname, LIFNAMSIZ);
	i_ipadm_addrobj2lifname(addr, lifr.lifr_name, sizeof (lifr.lifr_name));
	sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;

	/* Create the link-local address */
	bzero(&lifr.lifr_addr, sizeof (lifr.lifr_addr));
	(void) plen2mask(PREFIXLEN_LINKLOCAL, AF_INET6,
	    (struct sockaddr *)&lifr.lifr_addr);
	if ((err = ioctl(iph->iph_sock6, SIOCSLIFNETMASK, (caddr_t)&lifr)) < 0)
		goto fail;
	if (addr->ipadm_intfidlen == 0) {
		/*
		 * If we have to use the default interface id,
		 * we just need to set the prefix to the link-local prefix.
		 * SIOCSLIFPREFIX sets the address with the given prefix
		 * and the default interface id.
		 */
		sin6->sin6_addr = ll_template;
		err = ioctl(iph->iph_sock6, SIOCSLIFPREFIX, (caddr_t)&lifr);
		if (err < 0)
			goto fail;
	} else {
		/* Make a linklocal address in sin6 and set it */
		i_ipadm_make_linklocal(sin6, &addr->ipadm_intfid.sin6_addr);
		err = ioctl(iph->iph_sock6, SIOCSLIFADDR, (caddr_t)&lifr);
		if (err < 0)
			goto fail;
	}
	if ((err = ioctl(iph->iph_sock6, SIOCGLIFFLAGS, (char *)&lifr)) < 0)
		goto fail;
	lifr.lifr_flags |= IFF_UP;
	if ((err = ioctl(iph->iph_sock6, SIOCSLIFFLAGS, (char *)&lifr)) < 0)
		goto fail;
	return (IPADM_SUCCESS);

fail:
	if (errno == EEXIST)
		status = IPADM_ADDRCONF_EXISTS;
	else
		status = ipadm_errno2status(errno);
	/* Remove the linklocal that was created. */
	if (addif) {
		(void) ioctl(iph->iph_sock6, SIOCLIFREMOVEIF, (caddr_t)&lifr);
	} else {
		struct sockaddr_in6 *sin6;

		sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
		lifr.lifr_flags &= ~IFF_UP;
		(void) ioctl(iph->iph_sock6, SIOCSLIFFLAGS, (caddr_t)&lifr);
		sin6->sin6_family = AF_INET6;
		sin6->sin6_addr = in6addr_any;
		(void) ioctl(iph->iph_sock6, SIOCSLIFADDR, (caddr_t)&lifr);
	}
	return (status);
}

/*
 * Make a linklocal address based on the given intfid and copy it into
 * the output parameter `sin6'.
 */
static void
i_ipadm_make_linklocal(struct sockaddr_in6 *sin6, const struct in6_addr *intfid)
{
	int i;
	in6_addr_t ll_template = {0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
	    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };

	sin6->sin6_family = AF_INET6;
	sin6->sin6_addr = *intfid;
	for (i = 0; i < 4; i++) {
		sin6->sin6_addr.s6_addr[i] =
		    sin6->sin6_addr.s6_addr[i] | ll_template.s6_addr[i];
	}
}

/*
 * Function that forms an ndpd msg and sends it to the in.ndpd daemon's loopback
 * listener socket.
 */
static ipadm_status_t
i_ipadm_send_ndpd_cmd(const char *ifname, const struct ipadm_addrobj_s *addr,
    int cmd)
{
	int fd;
	struct sockaddr_un servaddr;
	int flags;
	ipadm_ndpd_msg_t msg;
	int retval;

	if (addr == NULL &&
	    (cmd == IPADM_CREATE_ADDRS || cmd == IPADM_DELETE_ADDRS)) {
		return (IPADM_INVALID_ARG);
	}

	fd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (fd == -1)
		return (IPADM_FAILURE);

	/* Put the socket in non-blocking mode */
	flags = fcntl(fd, F_GETFL, 0);
	if (flags != -1)
		(void) fcntl(fd, F_SETFL, flags | O_NONBLOCK);

	/* Connect to in.ndpd */
	bzero(&servaddr, sizeof (servaddr));
	servaddr.sun_family = AF_UNIX;
	(void) strlcpy(servaddr.sun_path, IPADM_UDS_PATH,
	    sizeof (servaddr.sun_path));
	if (connect(fd, (struct sockaddr *)&servaddr, sizeof (servaddr)) == -1)
		goto fail;

	bzero(&msg, sizeof (msg));
	msg.inm_cmd = cmd;
	(void) strlcpy(msg.inm_ifname, ifname, sizeof (msg.inm_ifname));
	if (addr != NULL) {
		msg.inm_intfid = addr->ipadm_intfid;
		msg.inm_intfidlen = addr->ipadm_intfidlen;
		msg.inm_stateless = addr->ipadm_stateless;
		msg.inm_stateful = addr->ipadm_stateful;
		if (cmd == IPADM_CREATE_ADDRS) {
			(void) strlcpy(msg.inm_aobjname, addr->ipadm_aobjname,
			    sizeof (msg.inm_aobjname));
		}
	}
	if (ipadm_ndpd_write(fd, &msg, sizeof (msg)) < 0)
		goto fail;
	if (ipadm_ndpd_read(fd, &retval, sizeof (retval)) < 0)
		goto fail;
	(void) close(fd);
	if (cmd == IPADM_CREATE_ADDRS && retval == EEXIST)
		return (IPADM_ADDRCONF_EXISTS);
	return (ipadm_errno2status(retval));
fail:
	(void) close(fd);
	return (IPADM_NDPD_NOT_RUNNING);
}

/*
 * Attempt to read `buflen' worth of bytes from `fd' into the buffer pointed
 * to by `buf'.
 */
int
ipadm_ndpd_read(int fd, void *buffer, size_t buflen)
{
	int		retval;
	ssize_t		nbytes = 0;	/* total bytes processed */
	ssize_t		prbytes;	/* per-round bytes processed */
	struct pollfd	pfd;

	while (nbytes < buflen) {

		pfd.fd = fd;
		pfd.events = POLLIN;

		/*
		 * Wait for data to come in or for the timeout to fire.
		 */
		retval = poll(&pfd, 1, NDPDTIMEOUT);
		if (retval <= 0) {
			if (retval == 0)
				errno = ETIME;
			break;
		}

		/*
		 * Descriptor is ready; have at it.
		 */
		prbytes = read(fd, (caddr_t)buffer + nbytes, buflen - nbytes);
		if (prbytes <= 0) {
			if (prbytes == -1 && errno == EINTR)
				continue;
			break;
		}
		nbytes += prbytes;
	}

	return (nbytes == buflen ? 0 : -1);
}

/*
 * Write `buflen' bytes from `buffer' to open file `fd'.  Returns 0
 * if all requested bytes were written, or an error code if not.
 */
int
ipadm_ndpd_write(int fd, const void *buffer, size_t buflen)
{
	size_t		nwritten;
	ssize_t		nbytes;
	const char	*buf = buffer;

	for (nwritten = 0; nwritten < buflen; nwritten += nbytes) {
		nbytes = write(fd, &buf[nwritten], buflen - nwritten);
		if (nbytes == -1)
			return (-1);
		if (nbytes == 0) {
			errno = EIO;
			return (-1);
		}
	}

	assert(nwritten == buflen);
	return (0);
}