path: root/usr/src/cmd/cmd-inet/usr.sbin/ndp.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2015 Joyent, Inc.  All rights reserved.
 */

/*
 * ndp - display and manipulate Neighbor Cache Entries from NDP
 */

#include <stdio.h>
#include <stdarg.h>
#include <signal.h>
#include <time.h>
#include <err.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <libgen.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <wait.h>
#include <sys/mac.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <netdb.h>
#include <net/if_types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <inet/ip.h>
#include <net/if_dl.h>
#include <net/route.h>

typedef	struct	sockaddr_in6	sin6_t;

#define	BUF_SIZE 2048
typedef struct rtmsg_pkt {
	struct	rt_msghdr m_rtm;
	char	m_space[BUF_SIZE];
} rtmsg_pkt_t;

enum ndp_action {
	NDP_A_DEFAULT,
	NDP_A_GET,		/* Show a single NDP entry */
	NDP_A_GET_ALL,		/* Show NDP entries */
	NDP_A_GET_FOREVER,	/* Repeatedly show entries */
	NDP_A_DELETE,		/* Delete an NDP entry */
	NDP_A_SET_NCE,		/* Set NDP entry */
	NDP_A_SET_FILE		/* Read in & set NDP entries */
};

typedef	int	(ndp_addr_f)(int, struct lifreq *, void *);
typedef	void	(ndp_void_f)(void);

static	void	ndp_usage(const char *, ...);
static	void	ndp_fatal(const char *, ...);
static	void	ndp_badflag(enum ndp_action);
static	void	ndp_missingarg(char);

static	void	ndp_run_in_child(ndp_void_f *);
static	void	ndp_do_run(void);
static	void	ndp_setup_handler(sigset_t *);
static	void	ndp_start_timer(time_t period);
static	void	ndp_run_periodically(time_t, ndp_void_f *);

static	int	ndp_salen(const struct sockaddr *sa);
static	int	ndp_extract_sockaddrs(struct rt_msghdr *, struct sockaddr **,
		    struct sockaddr **, struct sockaddr **, struct sockaddr **,
		    struct sockaddr_dl **);
static	int	ndp_rtmsg_get(int, rtmsg_pkt_t *, struct sockaddr *);
static	int	ndp_find_interface(int, struct sockaddr *, char *, int);

static	int	ndp_initialize_lifreq(int, struct lifreq *, struct sockaddr *);
static	int	ndp_host_enumerate(char *, ndp_addr_f *, void *);

static	int	ndp_display(struct lifreq *);
static	int	ndp_display_missing(struct lifreq *);
static	void	ndp_lifr2ip(struct lifreq *, char *, int);

static	int	ndp_get(int, struct lifreq *, void *);
static	void	ndp_get_all(void);
static	int	ndp_delete(int, struct lifreq *, void *);
static	int	ndp_set(int, struct lifreq *, void *);
static	int	ndp_set_nce(char *, char *, char *[], int);
static	int	ndp_set_file(char *);

static	char		*ndp_iface = NULL;
static	char		*netstat_path = "/usr/bin/netstat";
static	pid_t		ndp_pid;
static	boolean_t	ndp_noresolve = B_FALSE; /* Don't lookup addresses */
static	boolean_t	ndp_run = B_TRUE;

#define	MAX_ATTEMPTS 5
#define	MAX_OPTS 5
#define	WORDSEPS " \t\r\n"

/*
 * Macros borrowed from route(1M) for working with PF_ROUTE messages
 */
#define	RT_ADVANCE(x, n) ((x) += ndp_salen(n))
#define	RT_NEXTADDR(cp, w, u) \
	l = ndp_salen(u); \
	(void) memmove(cp, u, l); \
	cp += l;

/*
 * Print an error to stderr and then exit non-zero.
 */
static void
ndp_fatal(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	vwarnx(format, ap);
	va_end(ap);
	exit(EXIT_FAILURE);
}

/*
 * Print out the command usage to stderr, along with any reason why it's being
 * printed, and then exit non-zero.
 */
static void
ndp_usage(const char *reason, ...)
{
	va_list ap;
	const char *ndp_progname = getprogname();

	if (reason != NULL) {
		va_start(ap, reason);
		(void) fprintf(stderr, "%s: ", ndp_progname);
		(void) vfprintf(stderr, reason, ap);
		(void) fprintf(stderr, "\n");
		va_end(ap);
	}

	(void) fprintf(stderr,
	    "Usage: %s [-n] [-i iface] hostname\n"
	    "       %s [-n] [-i iface] -s nodeaddr etheraddr [temp] [proxy]\n"
	    "       %s [-n] [-i iface] -d nodeaddr\n"
	    "       %s [-n] [-i iface] -f filename\n"
	    "       %s [-n] -a\n"
	    "       %s [-n] -A period\n",
	    ndp_progname, ndp_progname, ndp_progname,
	    ndp_progname, ndp_progname, ndp_progname);
	exit(EXIT_FAILURE);
}

static void
ndp_badflag(enum ndp_action action)
{
	switch (action) {
	case NDP_A_DEFAULT:
	case NDP_A_GET:
		ndp_usage("Already going to print an entry, "
		    "but extra -%c given", optopt);
		break;
	case NDP_A_GET_ALL:
		ndp_usage("Already going to print all entries (-a), "
		    "but extra -%c given", optopt);
		break;
	case NDP_A_GET_FOREVER:
		ndp_usage("Already going to repeatedly print all entries (-A), "
		    "but extra -%c given", optopt);
		break;
	case NDP_A_DELETE:
		ndp_usage("Already going to delete an entry (-d), "
		    "but extra -%c given", optopt);
		break;
	case NDP_A_SET_NCE:
		ndp_usage("Already going to set an entry (-s), "
		    "but extra -%c given", optopt);
		break;
	case NDP_A_SET_FILE:
		ndp_usage("Already going to set from file (-f), "
		    "but extra -%c given", optopt);
		break;
	}
}

static void
ndp_missingarg(char flag)
{
	switch (flag) {
	case 'A':
		ndp_usage("Missing time period after -%c", flag);
		break;
	case 'd':
		ndp_usage("Missing node name after -%c", flag);
		break;
	case 'f':
		ndp_usage("Missing filename after -%c", flag);
		break;
	case 's':
		ndp_usage("Missing node name after -%c", flag);
		break;
	case 'i':
		ndp_usage("Missing interface name after -%c", flag);
		break;
	default:
		ndp_usage("Missing option argument after -%c", flag);
		break;
	}
}

/*
 * Run a function that's going to exec in a child process, and don't return
 * until it exits.
 */
static void
ndp_run_in_child(ndp_void_f *func)
{
	pid_t child_pid;
	int childstat = 0, status = 0;

	child_pid = fork();
	if (child_pid == (pid_t)-1) {
		ndp_fatal("Unable to fork: %s", strerror(errno));
	} else if (child_pid == (pid_t)0) {
		func();
		exit(EXIT_FAILURE);
	}

	while (waitpid(child_pid, &childstat, 0) == -1) {
		if (errno == EINTR)
			continue;

		ndp_fatal("Failed to wait on child: %s", strerror(errno));
	}

	status = WEXITSTATUS(childstat);
	if (status != 0) {
		ndp_fatal("Child process exited with %d", status);
	}
}

/*
 * SIGALRM handler to schedule a run.
 */
static void
ndp_do_run(void)
{
	ndp_run = B_TRUE;
}


/*
 * Prepare signal masks, and install the SIGALRM handler. Return old signal
 * masks through the first argument.
 */
static void
ndp_setup_handler(sigset_t *oset)
{
	struct sigaction sa;

	/*
	 * Mask off SIGALRM so we only trigger the handler when we're ready
	 * using sigsuspend(3C), in case the child process takes longer to
	 * run than the alarm interval.
	 */
	if (sigprocmask(0, NULL, oset) != 0) {
		ndp_fatal("Unable to set signal mask: %s", strerror(errno));
	}

	if (sighold(SIGALRM) != 0) {
		ndp_fatal("Unable to add SIGALRM to signal mask: %s",
		    strerror(errno));
	}

	sa.sa_flags = 0;
	sa.sa_handler = ndp_do_run;

	if (sigemptyset(&sa.sa_mask) != 0) {
		ndp_fatal("Unable to prepare empty signal set: %s",
		    strerror(errno));
	}

	if (sigaction(SIGALRM, &sa, NULL) != 0) {
		ndp_fatal("Unable to install timer handler: %s",
		    strerror(errno));
	}
}

/*
 * Start the printing timer.
 */
static void
ndp_start_timer(time_t period)
{
	timer_t timer;
	struct itimerspec interval;
	interval.it_value.tv_sec  = interval.it_interval.tv_sec  = period;
	interval.it_value.tv_nsec = interval.it_interval.tv_nsec = 0;

	if (timer_create(CLOCK_REALTIME, NULL, &timer) != 0) {
		ndp_fatal("Unable to create timer: %s", strerror(errno));
	}

	if (timer_settime(timer, 0, &interval, NULL) != 0) {
		ndp_fatal("Unable to set time on timer: %s", strerror(errno));
	}
}


/*
 * Run a given function forever periodically in a child process.
 */
static void
ndp_run_periodically(time_t period, ndp_void_f *func)
{
	sigset_t oset;

	ndp_setup_handler(&oset);
	ndp_start_timer(period);

	do {
		if (ndp_run) {
			ndp_run = B_FALSE;
			ndp_run_in_child(func);
		}
		(void) sigsuspend(&oset);
	} while (errno == EINTR);

	/*
	 * Only an EFAULT should get us here. Abort so we get a core dump.
	 */
	warnx("Failure while waiting on timer: %s", strerror(errno));
	abort();
}

/*
 * Given an address, return its size.
 */
static int
ndp_salen(const struct sockaddr *sa)
{
	switch (sa->sa_family) {
	case AF_INET:
		return (sizeof (struct sockaddr_in));
	case AF_LINK:
		return (sizeof (struct sockaddr_dl));
	case AF_INET6:
		return (sizeof (struct sockaddr_in6));
	default:
		warnx("Unrecognized sockaddr with address family %d!",
		    sa->sa_family);
		abort();
	}
	/*NOTREACHED*/
}

/*
 * Extract all socket addresses from a routing message, and return them
 * through the pointers given as arguments to ndp_extract_sockaddrs. None
 * of the pointers should be null.
 */
static int
ndp_extract_sockaddrs(struct rt_msghdr *rtm, struct sockaddr **dst,
    struct sockaddr **gate, struct sockaddr **mask, struct sockaddr **src,
    struct sockaddr_dl **ifp)
{
	struct sockaddr *sa;
	char *cp;
	int i;

	if (rtm->rtm_version != RTM_VERSION) {
		warnx("Routing message version %d not understood",
		    rtm->rtm_version);
		return (-1);
	}

	if (rtm->rtm_errno != 0)  {
		warnx("Routing message couldn't be processed: %s",
		    strerror(rtm->rtm_errno));
		return (-1);
	}

	cp = ((char *)(rtm + 1));
	if (rtm->rtm_addrs != 0) {
		for (i = 1; i != 0; i <<= 1) {
			if ((i & rtm->rtm_addrs) == 0)
				continue;

			/*LINTED*/
			sa = (struct sockaddr *)cp;
			switch (i) {
			case RTA_DST:
				*dst = sa;
				break;
			case RTA_GATEWAY:
				*gate = sa;
				break;
			case RTA_NETMASK:
				*mask = sa;
				break;
			case RTA_IFP:
				if (sa->sa_family == AF_LINK &&
				    ((struct sockaddr_dl *)sa)->sdl_nlen != 0)
					*ifp = (struct sockaddr_dl *)sa;
				break;
			case RTA_SRC:
				*src = sa;
				break;
			}
			RT_ADVANCE(cp, sa);
		}
	}

	return (0);
}

/*
 * Given an IPv6 address, use routing information to look up
 * the destination and interface it would pass through.
 */
static int
ndp_rtmsg_get(int fd, rtmsg_pkt_t *msg, struct sockaddr *sin6p)
{
	static int seq = 0;
	struct sockaddr_dl sdl;
	int mlen, l;
	char ipaddr[INET6_ADDRSTRLEN];
	char *cp = msg->m_space;
	struct	rt_msghdr *m_rtm = &msg->m_rtm;

	bzero(msg, sizeof (rtmsg_pkt_t));
	bzero(&sdl, sizeof (struct sockaddr_dl));

	m_rtm->rtm_type = RTM_GET;
	m_rtm->rtm_version = RTM_VERSION;
	m_rtm->rtm_seq = ++seq;
	m_rtm->rtm_addrs = RTA_DST | RTA_IFP;
	m_rtm->rtm_msglen = sizeof (rtmsg_pkt_t);

	/* Place the address we're looking up after the header */
	RT_NEXTADDR(cp, RTA_DST, sin6p);

	/* Load an empty link-level address, so we get an interface back */
	sdl.sdl_family = AF_LINK;
	RT_NEXTADDR(cp, RTA_IFP, (struct sockaddr *)&sdl);

	m_rtm->rtm_msglen = cp - (char *)msg;

	if ((mlen = write(fd, (char *)msg, m_rtm->rtm_msglen)) < 0) {
		if (errno == ESRCH) {
			/*LINTED*/
			if (inet_ntop(AF_INET6, &((sin6_t *)sin6p)->sin6_addr,
			    ipaddr, sizeof (ipaddr)) == NULL) {
				(void) snprintf(ipaddr, sizeof (ipaddr),
				    "(failed to format IP)");
			};
			warnx("An appropriate interface for the address %s "
			    "is not in the routing table; use -i to force an "
			    "interface", ipaddr);
			return (-1);
		} else {
			warnx("Failed to send routing message: %s",
			    strerror(errno));
			return (-1);
		}
	} else if (mlen < (int)m_rtm->rtm_msglen) {
		warnx("Failed to write all bytes to routing socket");
		return (-1);
	}

	/*
	 * Keep reading routing messages until we find the response to the one
	 * we just sent. Note that we depend on the sequence number being unique
	 * to the running program.
	 */
	do {
		mlen = read(fd, (char *)msg, sizeof (rtmsg_pkt_t));
	} while (mlen > 0 &&
	    (m_rtm->rtm_seq != seq || m_rtm->rtm_pid != ndp_pid));
	if (mlen < 0) {
		warnx("Failed to read from routing socket: %s",
		    strerror(errno));
		return (-1);
	}

	return (0);
}

/*
 * Find the interface that the IPv6 address would be routed through, and store
 * the name of the interface in the buffer passed in.
 */
static int
ndp_find_interface(int fd, struct sockaddr *sin6p, char *buf, int buflen)
{
	struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL, *src = NULL;
	struct sockaddr_dl *ifp = NULL;
	rtmsg_pkt_t msg;

	if (ndp_rtmsg_get(fd, &msg, sin6p) != 0) {
		return (-1);
	}

	if (ndp_extract_sockaddrs(&msg.m_rtm, &dst, &gate,
	    &mask, &src, &ifp) != 0) {
		return (-1);
	}

	if (ifp == NULL) {
		warnx("Unable to find appropriate interface for address");
		return (-1);
	} else {
		if (ifp->sdl_nlen >= buflen) {
			warnx("The interface name \"%.*s\" is too big for the "
			    "available buffer", ifp->sdl_nlen, ifp->sdl_data);
			return (-1);
		} else {
			(void) snprintf(buf, buflen, "%.*s", ifp->sdl_nlen,
			    ifp->sdl_data);
		}
	}

	return (0);
}

/*
 * Zero out a lifreq struct for a SIOCLIF*ND ioctl, set the address, and fetch
 * the appropriate interface using the given routing socket.
 */
static int
ndp_initialize_lifreq(int route, struct lifreq *lifrp, struct sockaddr *sap)
{
	struct sockaddr_storage *lnr_addr;
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	struct sockaddr_in6 *sin6p = (sin6_t *)sap;
	char *lifr_name = lifrp->lifr_name;

	bzero(lifrp, sizeof (struct lifreq));
	lnr_addr = &lifrp->lifr_nd.lnr_addr;

	if (ndp_iface != NULL) {
		(void) strlcpy(lifr_name, ndp_iface, LIFNAMSIZ);
	} else if (sin6p->sin6_scope_id != 0) {
		int zone_id = sin6p->sin6_scope_id;
		if (if_indextoname(zone_id, lifr_name) == NULL) {
			warnx("Invalid zone identifier: %d", zone_id);
			return (-1);
		}
	} else if (IN6_IS_ADDR_LINKSCOPE(&sin6p->sin6_addr)) {
		warnx("Link-scope addresses should specify an interface with "
		    "a zone ID, or with -i.");
		return (-1);
	} else {
		if (ndp_find_interface(route, sap, lifr_name, LIFNAMSIZ) != 0)
			return (-1);
	}

	(void) memcpy(lnr_addr, sap, sizeof (struct sockaddr_storage));

	return (0);
}

/*
 * Take a host identifier, find the corresponding IPv6 addresses and then pass
 * them to the specified function, along with any desired data.
 */
static int
ndp_host_enumerate(char *host, ndp_addr_f *addr_func, void *data)
{
	struct lifreq lifr;
	struct addrinfo hints, *serverinfo, *p;
	int err, attempts = 0;
	int inet6, route;

	bzero(&hints, sizeof (struct addrinfo));
	hints.ai_family = AF_INET6;
	hints.ai_protocol = IPPROTO_IPV6;

	while (attempts < MAX_ATTEMPTS) {
		err = getaddrinfo(host, NULL, &hints, &serverinfo);

		if (err == 0) {
			break;
		} else if (err == EAI_AGAIN) {
			attempts++;
		} else {
			warnx("Unable to lookup %s: %s", host,
			    gai_strerror(err));
			return (-1);
		}
	}

	if (attempts == MAX_ATTEMPTS) {
		warnx("Failed multiple times to lookup %s", host);
		return (-1);
	}

	inet6 = socket(PF_INET6, SOCK_DGRAM, 0);
	if (inet6 < 0) {
		warnx("Failed to open IPv6 socket: %s", strerror(errno));
		err = -1;
	}

	route = socket(PF_ROUTE, SOCK_RAW, 0);
	if (route < 0) {
		warnx("Failed to open routing socket: %s", strerror(errno));
		err = -1;
	}

	if (err == 0) {
		for (p = serverinfo; p != NULL; p = p->ai_next) {
			if (ndp_initialize_lifreq(route, &lifr, p->ai_addr)
			    != 0) {
				err = -1;
				continue;
			}

			if (addr_func(inet6, &lifr, data) != 0) {
				err = -1;
				continue;
			}
		}
	}

	if (close(route) != 0) {
		warnx("Failed to close routing socket: %s", strerror(errno));
		err = -1;
	}

	if (close(inet6) != 0) {
		warnx("Failed to close IPv6 socket: %s", strerror(errno));
		err = -1;
	}

	/* Clean up linked list */
	freeaddrinfo(serverinfo);

	return (err);
}

static int
ndp_display(struct lifreq *lifrp)
{
	struct sockaddr_in6 *lnr_addr;
	char ipaddr[INET6_ADDRSTRLEN];
	char *lladdr = NULL;
	char hostname[NI_MAXHOST];
	int flags, gni_flags;

	lnr_addr = (struct sockaddr_in6 *)&lifrp->lifr_nd.lnr_addr;
	flags = lifrp->lifr_nd.lnr_flags;

	if (inet_ntop(AF_INET6, &lnr_addr->sin6_addr, ipaddr,
	    sizeof (ipaddr)) == NULL) {
		warnx("Couldn't convert IPv6 address to string: %s",
		    strerror(errno));
		return (-1);
	};

	if ((lladdr = _link_ntoa((uchar_t *)lifrp->lifr_nd.lnr_hdw_addr,
	    NULL, lifrp->lifr_nd.lnr_hdw_len, IFT_ETHER)) == NULL) {
		warnx("Couldn't convert link-layer address to string: %s",
		    strerror(errno));
		return (-1);
	}

	gni_flags = ndp_noresolve ? NI_NUMERICHOST : 0;

	if (getnameinfo((struct sockaddr *)lnr_addr, sizeof (sin6_t), hostname,
	    sizeof (hostname), NULL, 0, gni_flags) != 0) {
		warnx("Unable to lookup hostname for %s", ipaddr);
		free(lladdr);
		return (-1);
	}

	(void) printf("%s (%s) at %s", ipaddr, hostname, lladdr);

	if (flags & NDF_ISROUTER_ON) {
		(void) printf(" router");
	}

	if (flags & NDF_ANYCAST_ON) {
		(void) printf(" any");
	}

	if (!(flags & NDF_STATIC)) {
		(void) printf(" temp");
	}

	if (flags & NDF_PROXY_ON) {
		(void) printf(" proxy");
	}

	(void) printf("\n");

	free(lladdr);
	return (0);
}

static int
ndp_display_missing(struct lifreq *lifrp)
{
	struct sockaddr_in6 *lnr_addr;
	char ipaddr[INET6_ADDRSTRLEN];
	char hostname[NI_MAXHOST];
	int flags = ndp_noresolve ? NI_NUMERICHOST : 0;
	lnr_addr = (struct sockaddr_in6 *)&lifrp->lifr_nd.lnr_addr;

	if (inet_ntop(AF_INET6, &lnr_addr->sin6_addr, ipaddr,
	    sizeof (ipaddr)) == NULL) {
		warnx("Couldn't convert IPv6 address to string: %s",
		    strerror(errno));
		return (-1);
	};

	if (getnameinfo((struct sockaddr *)lnr_addr, sizeof (sin6_t), hostname,
	    sizeof (hostname), NULL, 0, flags) != 0) {
		warnx("Unable to lookup hostname for %s", ipaddr);
		return (-1);
	}

	(void) printf("%s (%s) -- no entry\n", ipaddr, hostname);
	return (0);
}

static void
ndp_lifr2ip(struct lifreq *lifrp, char *ipaddr, int buflen)
{
	sin6_t *lnr_addr = (sin6_t *)&lifrp->lifr_nd.lnr_addr;
	if (inet_ntop(AF_INET6, &lnr_addr->sin6_addr, ipaddr,
	    buflen) == NULL) {
		(void) snprintf(ipaddr, buflen, "(failed to format IP)");
	};
}

/*
 * Perform a SIOCLIFGETND and print out information about it
 */
/*ARGSUSED*/
static int
ndp_get(int fd, struct lifreq *lifrp, void *unused)
{
	char ipaddr[INET6_ADDRSTRLEN];
	if (ioctl(fd, SIOCLIFGETND, lifrp) < 0) {
		if (errno == ESRCH) {
			return (ndp_display_missing(lifrp));
		} else {
			ndp_lifr2ip(lifrp, ipaddr, sizeof (ipaddr));
			warnx("Couldn't lookup %s: %s",
			    ipaddr, strerror(errno));
			return (-1);
		}
	}

	return (ndp_display(lifrp));
}

/*
 * Print out all NDP entries
 */
static void
ndp_get_all(void)
{
	(void) execl(netstat_path, "netstat",
	    (ndp_noresolve ? "-np" : "-p"),
	    "-f", "inet6", (char *)0);
	ndp_fatal("Coudn't exec %s: %s", netstat_path, strerror(errno));
}

/*
 * Perform a SIOCLIFDELND ioctl
 */
/*ARGSUSED*/
static int
ndp_delete(int fd, struct lifreq *lifrp, void *unused)
{
	char ipaddr[INET6_ADDRSTRLEN];

	if (ioctl(fd, SIOCLIFDELND, lifrp) < 0) {
		ndp_lifr2ip(lifrp, ipaddr, sizeof (ipaddr));
		if (errno == ESRCH) {
			warnx("No entry for %s", ipaddr);
			return (-1);
		} else if (errno == EPERM) {
			warnx("Permission denied, "
			    "could not delete entry for %s", ipaddr);
			return (-1);
		} else {
			warnx("Couldn't delete mapping for %s: %s",
			    ipaddr, strerror(errno));
			return (-1);
		}
	}

	return (0);
}

/*
 * Perform a SIOCLIFSETND ioctl using properties from the example structure.
 */
static int
ndp_set(int fd, struct lifreq *lifrp, void *data)
{
	char ipaddr[INET6_ADDRSTRLEN];
	const lif_nd_req_t *nd_attrs = data;

	(void) memcpy(lifrp->lifr_nd.lnr_hdw_addr, nd_attrs->lnr_hdw_addr,
	    ND_MAX_HDW_LEN);
	lifrp->lifr_nd.lnr_hdw_len = nd_attrs->lnr_hdw_len;
	lifrp->lifr_nd.lnr_flags = nd_attrs->lnr_flags;

	lifrp->lifr_nd.lnr_state_create = nd_attrs->lnr_state_create;
	lifrp->lifr_nd.lnr_state_same_lla = nd_attrs->lnr_state_same_lla;
	lifrp->lifr_nd.lnr_state_diff_lla = nd_attrs->lnr_state_diff_lla;

	if (ioctl(fd, SIOCLIFSETND, lifrp) < 0) {
		ndp_lifr2ip(lifrp, ipaddr, sizeof (ipaddr));
		if (errno == EPERM) {
			warnx("Permission denied, "
			    "could not set entry for %s", ipaddr);
			return (-1);
		} else {
			warnx("Failed to set mapping for %s: %s",
			    ipaddr, strerror(errno));
			return (-1);
		}
	}

	return (0);
}

/*
 * Given a host identifier, a link-layer address and possible options,
 * add/update the NDP mappings.
 */
static int
ndp_set_nce(char *host, char *lladdr, char *opts[], int optlen)
{
	lif_nd_req_t nd_attrs;
	uchar_t *ea;
	char *opt;
	int i;
	boolean_t temp = B_FALSE;
	boolean_t any = B_FALSE;
	boolean_t router = B_FALSE;

	bzero(&nd_attrs, sizeof (lif_nd_req_t));

	ea = _link_aton(lladdr, &nd_attrs.lnr_hdw_len);

	if (ea == NULL) {
		warnx("Unable to parse link-layer address \"%s\"", lladdr);
		return (-1);
	}

	if (nd_attrs.lnr_hdw_len > sizeof (nd_attrs.lnr_hdw_addr)) {
		warnx("The size of the link-layer address is "
		    "too large to set\n");
		free(ea);
		return (-1);
	}

	(void) memcpy(nd_attrs.lnr_hdw_addr, ea, nd_attrs.lnr_hdw_len);

	free(ea);

	nd_attrs.lnr_state_create = ND_REACHABLE;
	nd_attrs.lnr_state_same_lla = ND_UNCHANGED;
	nd_attrs.lnr_state_diff_lla = ND_STALE;

	for (i = 0; i < optlen; i++) {
		opt = opts[i];
		if (strcmp(opt, "temp") == 0) {
			temp = B_TRUE;
		} else if (strcmp(opt, "any") == 0) {
			any = B_TRUE;
		} else if (strcmp(opt, "router") == 0) {
			router = B_TRUE;
		} else if (strcmp(opt, "proxy") == 0) {
			warnx("NDP proxying is currently not supported");
			return (-1);
		} else {
			warnx("Unrecognized option \"%s\"", opt);
			return (-1);
		}
	}

	if (!temp) {
		nd_attrs.lnr_flags |= NDF_STATIC;
	}

	if (any) {
		nd_attrs.lnr_flags |= NDF_ANYCAST_ON;
	} else {
		nd_attrs.lnr_flags |= NDF_ANYCAST_OFF;
	}

	if (router) {
		nd_attrs.lnr_flags |= NDF_ISROUTER_OFF;
	} else {
		nd_attrs.lnr_flags |= NDF_ISROUTER_OFF;
	}

	return (ndp_host_enumerate(host, ndp_set, &nd_attrs));
}

/*
 * Read in a file and set the mappings from each line.
 */
static int
ndp_set_file(char *filename)
{
	char *line = NULL, *lasts = NULL, *curr;
	char *host, *lladdr;
	char *opts[MAX_OPTS];
	int optlen = 0, lineno = 0;
	size_t cap = 0;
	boolean_t failed_line = B_FALSE;
	FILE *stream = fopen(filename, "r");

	if (stream == NULL) {
		ndp_fatal("Error while opening file %s: %s",
		    filename, strerror(errno));
	}

	errno = 0;
	while (getline(&line, &cap, stream) != -1) {
		lineno++;

		if (line[0] == '#')
			continue;

		host = strtok_r(line, WORDSEPS, &lasts);
		if (host == NULL) {
			warnx("Line %d incomplete, skipping: "
			    "missing host identifier", lineno);
			failed_line = B_TRUE;
			continue;
		}

		lladdr = strtok_r(NULL, WORDSEPS, &lasts);
		if (lladdr == NULL) {
			warnx("Line %d incomplete, skipping: "
			    "missing link-layer address", lineno);
			failed_line = B_TRUE;
			continue;
		}

		for (optlen = 0; optlen < MAX_OPTS; optlen++) {
			curr = strtok_r(NULL, WORDSEPS, &lasts);
			if (curr == NULL)
				break;
			opts[optlen] = curr;
		}

		if (ndp_set_nce(host, lladdr, opts, optlen) != 0) {
			failed_line = B_TRUE;
			continue;
		}
	}

	free(line);

	if (errno != 0 || ferror(stream)) {
		ndp_fatal("Error while reading from file %s: %s", filename,
		    strerror(errno));
	}

	if (fclose(stream) != 0) {
		ndp_fatal("Error close file %s: %s", filename, strerror(errno));
	}

	return (failed_line ? -1 : 0);
}

int
main(int argc, char *argv[])
{
	char *flagarg = NULL, *lladdr = NULL;
	char **opts;
	char *endptr;
	int c, argsleft, optlen = 0, err = 0;
	long long period;
	enum ndp_action action = NDP_A_DEFAULT;

	setprogname(basename(argv[0]));

	if (argc < 2) {
		ndp_usage("No arguments given.");
	}

	while ((c = getopt(argc, argv, ":naA:d:f:i:s:")) != -1) {
		switch (c) {
		case 'n':
			ndp_noresolve = B_TRUE;
			break;
		case 'i':
			ndp_iface = optarg;
			break;
		case 's':
			if (action != NDP_A_DEFAULT)
				ndp_badflag(action);
			action = NDP_A_SET_NCE;
			flagarg = optarg;

			if ((argc - optind) < 1) {
				ndp_usage("Missing link-layer address after "
				    "the node address, \"%s\"", flagarg);
			}
			lladdr = argv[optind++];

			/*
			 * Grab any following keywords up to the next flag
			 */
			opts = argv + optind;
			while ((argc - optind) > 0) {
				if (argv[optind][0] == '-')
					ndp_usage("Encountered \"%s\" after "
					    "flag parsing is done",
					    argv[optind]);
				optind++;
				optlen++;
			}
			break;
		case 'a':
			if (action != NDP_A_DEFAULT)
				ndp_badflag(action);
			action = NDP_A_GET_ALL;
			break;
		case 'A':
			if (action != NDP_A_DEFAULT)
				ndp_badflag(action);
			action = NDP_A_GET_FOREVER;
			flagarg = optarg;
			break;
		case 'd':
			if (action != NDP_A_DEFAULT)
				ndp_badflag(action);
			action = NDP_A_DELETE;
			flagarg = optarg;
			break;
		case 'f':
			if (action != NDP_A_DEFAULT)
				ndp_badflag(action);
			action = NDP_A_SET_FILE;
			flagarg = optarg;
			break;
		case ':':
			ndp_missingarg(optopt);
			break;
		case '?':
			ndp_usage("Unrecognized flag \"-%c\"", optopt);
		default:
			ndp_usage(NULL);
		}
	}

	argsleft = argc - optind;
	ndp_pid = getpid();

	if (action != NDP_A_DEFAULT && argsleft != 0) {
		ndp_usage("Extra arguments leftover after parsing flags");
	}

	switch (action) {
	case NDP_A_DEFAULT:
	case NDP_A_GET:
		if (argsleft != 1) {
			ndp_usage("Multiple arguments given without any flags");
		}
		err = ndp_host_enumerate(argv[optind], ndp_get, NULL);
		break;
	case NDP_A_GET_ALL:
		ndp_get_all();
		/*NOTREACHED*/
		break;
	case NDP_A_GET_FOREVER:
		errno = 0;
		period = strtoll(flagarg, &endptr, 10);
		if ((period == 0 && errno != 0) ||
		    (endptr[0] != '\0') ||
		    (period < 0)) {
			ndp_usage("Given period should be a positive integer,"
			    " not \"%s\"", flagarg);
		}
		if (period > 86400) {
			ndp_usage("Given period should be shorter than a day;"
			    " given \"%s\" seconds", flagarg);
		}
		ndp_run_periodically(period, ndp_get_all);
		/*NOTREACHED*/
		break;
	case NDP_A_DELETE:
		err = ndp_host_enumerate(flagarg, ndp_delete, NULL);
		break;
	case NDP_A_SET_NCE:
		err = ndp_set_nce(flagarg, lladdr, opts, optlen);
		break;
	case NDP_A_SET_FILE:
		err = ndp_set_file(flagarg);
		break;
	}

	return (err == 0 ? 0 : 1);
}