/*	$KAME: ndp.c,v 1.104 2003/06/27 07:48:39 itojun Exp $	*/

/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/*
 * Copyright (c) 1984, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Sun Microsystems, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Based on:
 *	The Regents of the University of California.  All rights reserved.\n";
 */

/*
 * ndp - display, set, delete and flush neighbor cache
 */


#include <sys/param.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/queue.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/route.h>

#include <netinet/in.h>
#include <netinet/if_ether.h>

#include <netinet/icmp6.h>
#include <netinet6/in6_var.h>
#include <netinet6/nd6.h>

#include <arpa/inet.h>

#include <assert.h>
#include <ctype.h>
#include <netdb.h>
#include <errno.h>
#include <nlist.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <paths.h>
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <libxo/xo.h>
#include <time.h>

#include "ndp.h"

#define	NEXTADDR(w, s)					\
	if (rtm->rtm_addrs & (w)) {			\
		bcopy((char *)&s, cp, sizeof(s));	\
		cp += SA_SIZE(&s);			\
	}

static pid_t pid;
static int32_t thiszone;	/* time difference with gmt */
static int s = -1;

static char host_buf[NI_MAXHOST];	/* getnameinfo() */
static char ifix_buf[IFNAMSIZ];		/* if_indextoname() */

static int file(char *);
static int set(int, char **);
static void get(char *);
static int delete(char *);
static int dump(struct sockaddr_in6 *, int);
static struct in6_nbrinfo *getnbrinfo(struct in6_addr *, int, int);
static int ndp_ether_aton(char *, u_char *);
static void usage(void) __dead2;
static void ifinfo(char *, int, char **);
static void rtrlist(void);
static void plist(void);
static void pfx_flush(void);
static void rtr_flush(void);
static void harmonize_rtr(void);
#ifdef SIOCSDEFIFACE_IN6	/* XXX: check SIOCGDEFIFACE_IN6 as well? */
static void getdefif(void);
static void setdefif(char *);
#endif

#ifdef WITHOUT_NETLINK
static void getsocket(void);
static int rtmsg(int);
#endif

static const char *rtpref_str[] = {
	"medium",		/* 00 */
	"high",			/* 01 */
	"rsv",			/* 10 */
	"low"			/* 11 */
};

struct ndp_opts opts = {};

#define NDP_XO_VERSION	"1"

bool
valid_type(int if_type)
{
	switch (if_type) {
	case IFT_ETHER:
	case IFT_FDDI:
	case IFT_ISO88023:
	case IFT_ISO88024:
	case IFT_ISO88025:
	case IFT_L2VLAN:
	case IFT_BRIDGE:
		return (true);
		break;
	}
	return (false);
}

static int32_t
utc_offset(void)
{
	time_t t;
	struct tm *tm;

	t = time(NULL);
	tm = localtime(&t);

	assert(tm->tm_gmtoff > INT32_MIN && tm->tm_gmtoff < INT32_MAX);

	return (tm->tm_gmtoff);
}

int
main(int argc, char **argv)
{
	int ch, mode = 0;
	char *arg = NULL;
	int ret = 0;

	pid = getpid();
	thiszone = utc_offset();

	argc = xo_parse_args(argc, argv);
	if (argc < 0)
		exit(1);
	xo_set_version(NDP_XO_VERSION);
	xo_open_container("ndp");

	while ((ch = getopt(argc, argv, "acd:f:Ii:nprstA:HPR")) != -1)
		switch (ch) {
		case 'a':
		case 'c':
		case 'p':
		case 'r':
		case 'H':
		case 'P':
		case 'R':
		case 's':
		case 'I':
			if (mode) {
				usage();
				/*NOTREACHED*/
			}
			mode = ch;
			arg = NULL;
			break;
		case 'f':
			exit(file(optarg) ? 1 : 0);
		case 'd':
		case 'i':
			if (mode) {
				usage();
				/*NOTREACHED*/
			}
			mode = ch;
			arg = optarg;
			break;
		case 'n':
			opts.nflag = true;
			break;
		case 't':
			opts.tflag = true;
			break;
		case 'A':
			if (mode) {
				usage();
				/*NOTREACHED*/
			}
			mode = 'a';
			opts.repeat = atoi(optarg);
			if (opts.repeat < 0) {
				usage();
				/*NOTREACHED*/
			}
			break;
		default:
			usage();
		}

	argc -= optind;
	argv += optind;

	switch (mode) {
	case 'a':
	case 'c':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		dump(0, mode == 'c');
		break;
	case 'd':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		xo_open_list("neighbor-cache");
		ret = delete(arg);
		xo_close_list("neighbor-cache");
		break;
	case 'I':
#ifdef SIOCSDEFIFACE_IN6	/* XXX: check SIOCGDEFIFACE_IN6 as well? */
		if (argc > 1) {
			usage();
			/*NOTREACHED*/
		} else if (argc == 1) {
			if (strcmp(*argv, "delete") == 0 ||
			    if_nametoindex(*argv))
				setdefif(*argv);
			else
				xo_errx(1, "invalid interface %s", *argv);
		}
		getdefif(); /* always call it to print the result */
		break;
#else
		xo_errx(1, "not supported yet");
		/*NOTREACHED*/
#endif
	case 'p':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		plist();
		break;
	case 'i':
		ifinfo(arg, argc, argv);
		break;
	case 'r':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		rtrlist();
		break;
	case 's':
		if (argc < 2 || argc > 4)
			usage();
		exit(set(argc, argv) ? 1 : 0);
	case 'H':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		harmonize_rtr();
		break;
	case 'P':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		pfx_flush();
		break;
	case 'R':
		if (argc != 0) {
			usage();
			/*NOTREACHED*/
		}
		rtr_flush();
		break;
	case 0:
		if (argc != 1) {
			usage();
			/*NOTREACHED*/
		}
		get(argv[0]);
		break;
	}
	xo_close_container("ndp");
	if (xo_finish() < 0)
		xo_err(1, "stdout");

	return (ret);
}

/*
 * Process a file to set standard ndp entries
 */
static int
file(char *name)
{
	FILE *fp;
	int i, retval;
	char line[100], arg[5][50], *args[5], *p;

	if ((fp = fopen(name, "r")) == NULL)
		xo_err(1, "cannot open %s", name);
	args[0] = &arg[0][0];
	args[1] = &arg[1][0];
	args[2] = &arg[2][0];
	args[3] = &arg[3][0];
	args[4] = &arg[4][0];
	retval = 0;
	while (fgets(line, sizeof(line), fp) != NULL) {
		if ((p = strchr(line, '#')) != NULL)
			*p = '\0';
		for (p = line; isblank(*p); p++);
		if (*p == '\n' || *p == '\0')
			continue;
		i = sscanf(line, "%49s %49s %49s %49s %49s",
		    arg[0], arg[1], arg[2], arg[3], arg[4]);
		if (i < 2) {
			xo_warnx("bad line: %s", line);
			retval = 1;
			continue;
		}
		if (set(i, args))
			retval = 1;
	}
	fclose(fp);
	return (retval);
}

static void
getsocket(void)
{
	if (s < 0) {
		s = socket(PF_ROUTE, SOCK_RAW, 0);
		if (s < 0) {
			xo_err(1, "socket");
			/* NOTREACHED */
		}
	}
}

static struct sockaddr_in6 so_mask = {
	.sin6_len = sizeof(so_mask),
	.sin6_family = AF_INET6
};
static struct sockaddr_in6 blank_sin = {
	.sin6_len = sizeof(blank_sin),
	.sin6_family = AF_INET6
};
static struct sockaddr_in6 sin_m;
static struct sockaddr_dl blank_sdl = {
	.sdl_len = sizeof(blank_sdl),
	.sdl_family = AF_LINK
};
static struct sockaddr_dl sdl_m;
#ifdef WITHOUT_NETLINK
static struct {
	struct	rt_msghdr m_rtm;
	char	m_space[512];
} m_rtmsg;
#endif

/*
 * Set an individual neighbor cache entry
 */
static int
set(int argc, char **argv)
{
	struct sockaddr_in6 *sin = &sin_m;
	int gai_error;
	u_char *ea;
	char *host = argv[0], *eaddr = argv[1];

	argc -= 2;
	argv += 2;
	sdl_m = blank_sdl;
	sin_m = blank_sin;

	gai_error = getaddr(host, sin);
	if (gai_error) {
		xo_warnx("%s: %s", host, gai_strerror(gai_error));
		return 1;
	}

	ea = (u_char *)LLADDR(&sdl_m);
	if (ndp_ether_aton(eaddr, ea) == 0)
		sdl_m.sdl_alen = 6;
	while (argc-- > 0) {
		if (strncmp(argv[0], "temp", 4) == 0) {
			struct timeval now;

			gettimeofday(&now, 0);
			opts.expire_time = now.tv_sec + 20 * 60;
		} else if (strncmp(argv[0], "proxy", 5) == 0)
			opts.flags |= RTF_ANNOUNCE;
		argv++;
	}

#ifndef WITHOUT_NETLINK
	return (set_nl(0, sin, &sdl_m, host));
#else
	struct rt_msghdr *rtm = &(m_rtmsg.m_rtm);
	struct sockaddr_dl *sdl;

	getsocket();

	if (rtmsg(RTM_GET) < 0) {
		xo_errx(1, "RTM_GET(%s) failed", host);
		/* NOTREACHED */
	}
	sin = (struct sockaddr_in6 *)(rtm + 1);
	sdl = (struct sockaddr_dl *)(ALIGN(sin->sin6_len) + (char *)sin);
	if (IN6_ARE_ADDR_EQUAL(&sin->sin6_addr, &sin_m.sin6_addr)) {
		if (sdl->sdl_family == AF_LINK &&
		    !(rtm->rtm_flags & RTF_GATEWAY)) {
			if (valid_type(sdl->sdl_type))
				goto overwrite;
		}
		xo_warnx("cannot configure a new entry");
		return 1;
	}

overwrite:
	if (sdl->sdl_family != AF_LINK) {
		xo_warnx("cannot intuit interface index and type for %s", host);
		return (1);
	}
	sdl_m.sdl_type = sdl->sdl_type;
	sdl_m.sdl_index = sdl->sdl_index;
	return (rtmsg(RTM_ADD));
#endif
}

int
getaddr(char *host, struct sockaddr_in6 *sin6)
{
	struct addrinfo hints = { .ai_family = AF_INET6 };
	struct addrinfo *res;

	int gai_error = getaddrinfo(host, NULL, &hints, &res);
	if (gai_error != 0)
		return (gai_error);
	sin6->sin6_family = AF_INET6;
	sin6->sin6_len = sizeof(*sin6);
	sin6->sin6_addr = ((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
	sin6->sin6_scope_id =
	    ((struct sockaddr_in6 *)res->ai_addr)->sin6_scope_id;
	return (0);
}

/*
 * Display an individual neighbor cache entry
 */
static void
get(char *host)
{
	struct sockaddr_in6 *sin = &sin_m;
	int gai_error;

	sin_m = blank_sin;

	gai_error = getaddr(host, sin);
	if (gai_error) {
		xo_warnx("%s: %s", host, gai_strerror(gai_error));
		return;
	}
	if (dump(sin, 0) == 0) {
		getnameinfo((struct sockaddr *)sin, sin->sin6_len, host_buf,
		    sizeof(host_buf), NULL ,0,
		    (opts.nflag ? NI_NUMERICHOST : 0));
		xo_errx(1, "%s (%s) -- no entry", host, host_buf);
	}
}

#ifdef WITHOUT_NETLINK
/*
 * Delete a neighbor cache entry
 */
static int
delete_rtsock(char *host)
{
	struct sockaddr_in6 *sin = &sin_m;
	register struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
	register char *cp = m_rtmsg.m_space;
	struct sockaddr_dl *sdl;
	int gai_error;

	getsocket();
	sin_m = blank_sin;

	gai_error = getaddr(host, sin);
	if (gai_error) {
		xo_warnx("%s: %s", host, gai_strerror(gai_error));
		return 1;
	}

	if (rtmsg(RTM_GET) < 0) {
		xo_errx(1, "RTM_GET(%s) failed", host);
		/* NOTREACHED */
	}
	sin = (struct sockaddr_in6 *)(rtm + 1);
	sdl = (struct sockaddr_dl *)(ALIGN(sin->sin6_len) + (char *)sin);
	if (IN6_ARE_ADDR_EQUAL(&sin->sin6_addr, &sin_m.sin6_addr)) {
		if (sdl->sdl_family == AF_LINK &&
		    !(rtm->rtm_flags & RTF_GATEWAY)) {
			goto delete;
		}
		xo_warnx("delete: cannot delete non-NDP entry");
		return 1;
	}

delete:
	if (sdl->sdl_family != AF_LINK) {
		xo_warnx("cannot locate %s", host);
		return (1);
	}
	/*
	 * need to reinit the field because it has rt_key
	 * but we want the actual address
	 */
	NEXTADDR(RTA_DST, sin_m);
	rtm->rtm_flags |= RTF_LLDATA;
	if (rtmsg(RTM_DELETE) == 0) {
		getnameinfo((struct sockaddr *)sin,
		    sin->sin6_len, host_buf,
		    sizeof(host_buf), NULL, 0,
		    (opts.nflag ? NI_NUMERICHOST : 0));
		xo_open_instance("neighbor-cache");

		char *ifname = if_indextoname(sdl->sdl_index, ifix_buf);
		if (ifname == NULL) {
			strlcpy(ifix_buf, "?", sizeof(ifix_buf));
			ifname = ifix_buf;
		}
		char abuf[INET6_ADDRSTRLEN];
		inet_ntop(AF_INET6, &sin->sin6_addr, abuf, sizeof(abuf));

		xo_emit("{:hostname/%s}{d:/ (%s) deleted\n}", host, host_buf);
		xo_emit("{e:address/%s}{e:interface/%s}", abuf, ifname);
		xo_close_instance("neighbor-cache");
	}

	return 0;
}

/*
 * Dump the entire neighbor cache
 */
static int
dump_rtsock(struct sockaddr_in6 *addr, int cflag)
{
	int mib[6];
	size_t needed;
	char *lim, *buf, *next;
	struct rt_msghdr *rtm;
	struct sockaddr_in6 *sin;
	struct sockaddr_dl *sdl;
	struct timeval now;
	time_t expire;
	int addrwidth;
	int llwidth;
	int ifwidth;
	char flgbuf[8];
	char *ifname;

	/* Print header */
	if (!opts.tflag && !cflag) {
		char xobuf[200];
		snprintf(xobuf, sizeof(xobuf),
		    "{T:/%%-%d.%ds} {T:/%%-%d.%ds} {T:/%%%d.%ds} {T:/%%-9.9s} {T:/%%1s} {T:/%%5s}\n",
		    W_ADDR, W_ADDR, W_LL, W_LL, W_IF, W_IF);
		xo_emit(xobuf, "Neighbor", "Linklayer Address", "Netif", "Expire", "S", "Flags");
	}
	xo_open_list("neighbor-cache");
again:
	mib[0] = CTL_NET;
	mib[1] = PF_ROUTE;
	mib[2] = 0;
	mib[3] = AF_INET6;
	mib[4] = NET_RT_FLAGS;
#ifdef RTF_LLINFO
	mib[5] = RTF_LLINFO;
#else
	mib[5] = 0;
#endif
	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
		xo_err(1, "sysctl(PF_ROUTE estimate)");
	if (needed > 0) {
		/*
		 * Add ~2% additional space in case some records
		 * will appear between sysctl() calls.
		 * Round it up so it can fit 4 additional messages at least.
		 */
		needed += ((needed >> 6) | (sizeof(m_rtmsg) * 4));
		if ((buf = malloc(needed)) == NULL)
			xo_err(1, "malloc");
		if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
			xo_err(1, "sysctl(PF_ROUTE, NET_RT_FLAGS)");
		lim = buf + needed;
	} else
		buf = lim = NULL;

	int count = 0;
	for (next = buf; next && next < lim; next += rtm->rtm_msglen) {
		int isrouter = 0, prbs = 0;

		rtm = (struct rt_msghdr *)next;
		sin = (struct sockaddr_in6 *)(rtm + 1);
		sdl = (struct sockaddr_dl *)((char *)sin +
		    ALIGN(sin->sin6_len));

		/*
		 * Some OSes can produce a route that has the LINK flag but
		 * has a non-AF_LINK gateway (e.g. fe80::xx%lo0 on FreeBSD
		 * and BSD/OS, where xx is not the interface identifier on
		 * lo0).  Such routes entry would annoy getnbrinfo() below,
		 * so we skip them.
		 * XXX: such routes should have the GATEWAY flag, not the
		 * LINK flag.  However, there is rotten routing software
		 * that advertises all routes that have the GATEWAY flag.
		 * Thus, KAME kernel intentionally does not set the LINK flag.
		 * What is to be fixed is not ndp, but such routing software
		 * (and the kernel workaround)...
		 */
		if (sdl->sdl_family != AF_LINK)
			continue;

		if (!(rtm->rtm_flags & RTF_HOST))
			continue;

		if (addr) {
			if (IN6_ARE_ADDR_EQUAL(&addr->sin6_addr,
			    &sin->sin6_addr) == 0 ||
			    addr->sin6_scope_id != sin->sin6_scope_id)
				continue;
		} else if (IN6_IS_ADDR_MULTICAST(&sin->sin6_addr))
			continue;
		count++;
		if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr) ||
		    IN6_IS_ADDR_MC_LINKLOCAL(&sin->sin6_addr)) {
			/* XXX: should scope id be filled in the kernel? */
			if (sin->sin6_scope_id == 0)
				sin->sin6_scope_id = sdl->sdl_index;
		}
		getnameinfo((struct sockaddr *)sin, sin->sin6_len, host_buf,
		    sizeof(host_buf), NULL, 0, (opts.nflag ? NI_NUMERICHOST : 0));
		if (cflag) {
#ifdef RTF_WASCLONED
			if (rtm->rtm_flags & RTF_WASCLONED)
				delete(host_buf);
#elif defined(RTF_CLONED)
			if (rtm->rtm_flags & RTF_CLONED)
				delete(host_buf);
#else
			if (rtm->rtm_flags & RTF_PINNED)
				continue;
			delete(host_buf);
#endif
			continue;
		}
		gettimeofday(&now, 0);
		if (opts.tflag)
			ts_print(&now);

		addrwidth = strlen(host_buf);
		if (addrwidth < W_ADDR)
			addrwidth = W_ADDR;
		llwidth = strlen(ether_str(sdl));
		if (W_ADDR + W_LL - addrwidth > llwidth)
			llwidth = W_ADDR + W_LL - addrwidth;
		ifname = if_indextoname(sdl->sdl_index, ifix_buf);
		if (ifname == NULL) {
			strlcpy(ifix_buf, "?", sizeof(ifix_buf));
			ifname = ifix_buf;
		}
		ifwidth = strlen(ifname);
		if (W_ADDR + W_LL + W_IF - addrwidth - llwidth > ifwidth)
			ifwidth = W_ADDR + W_LL + W_IF - addrwidth - llwidth;

		xo_open_instance("neighbor-cache");
		/* Compose format string for libxo, as it doesn't support *.* */
		char xobuf[200];
		snprintf(xobuf, sizeof(xobuf),
		    "{:address/%%-%d.%ds/%%s} {:mac-address/%%-%d.%ds/%%s} {:interface/%%%d.%ds/%%s}",
		    addrwidth, addrwidth, llwidth, llwidth, ifwidth, ifwidth);
		xo_emit(xobuf, host_buf, ether_str(sdl), ifname);

		/* Print neighbor discovery specific information */
		expire = rtm->rtm_rmx.rmx_expire;
		int expire_in = expire - now.tv_sec;
		if (expire > now.tv_sec)
			xo_emit("{d:/ %-9.9s}{e:expires_sec/%d}", sec2str(expire_in), expire_in);
		else if (expire == 0)
			xo_emit("{d:/ %-9.9s}{en:permanent/true}", "permanent");
		else
			xo_emit("{d:/ %-9.9s}{e:expires_sec/%d}", "expired", expire_in);

		char *lle_state = "";
		switch (rtm->rtm_rmx.rmx_state) {
		case ND6_LLINFO_NOSTATE:
			lle_state = "N";
			break;
#ifdef ND6_LLINFO_WAITDELETE
		case ND6_LLINFO_WAITDELETE:
			lle_state = "W";
			break;
#endif
		case ND6_LLINFO_INCOMPLETE:
			lle_state = "I";
			break;
		case ND6_LLINFO_REACHABLE:
			lle_state = "R";
			break;
		case ND6_LLINFO_STALE:
			lle_state = "S";
			break;
		case ND6_LLINFO_DELAY:
			lle_state = "D";
			break;
		case ND6_LLINFO_PROBE:
			lle_state = "P";
			break;
		default:
			lle_state = "?";
			break;
		}
		xo_emit(" {:neighbor-state/%s}", lle_state);

		isrouter = rtm->rtm_flags & RTF_GATEWAY;
		prbs = rtm->rtm_rmx.rmx_pksent;

		/*
		 * other flags. R: router, P: proxy, W: ??
		 */
		if ((rtm->rtm_addrs & RTA_NETMASK) == 0) {
			snprintf(flgbuf, sizeof(flgbuf), "%s%s",
			    isrouter ? "R" : "",
			    (rtm->rtm_flags & RTF_ANNOUNCE) ? "p" : "");
		} else {
#if 0			/* W and P are mystery even for us */
			sin = (struct sockaddr_in6 *)
			    (sdl->sdl_len + (char *)sdl);
			snprintf(flgbuf, sizeof(flgbuf), "%s%s%s%s",
			    isrouter ? "R" : "",
			    !IN6_IS_ADDR_UNSPECIFIED(&sin->sin6_addr) ? "P" : "",
			    (sin->sin6_len != sizeof(struct sockaddr_in6)) ? "W" : "",
			    (rtm->rtm_flags & RTF_ANNOUNCE) ? "p" : "");
#else
			snprintf(flgbuf, sizeof(flgbuf), "%s%s",
			    isrouter ? "R" : "",
			    (rtm->rtm_flags & RTF_ANNOUNCE) ? "p" : "");
#endif
		}
		xo_emit(" {:nd-flags/%s}", flgbuf);

		if (prbs)
			xo_emit("{d:/ %d}", prbs);

		xo_emit("\n");
		xo_close_instance("neighbor-cache");
	}
	if (buf != NULL)
		free(buf);

	if (opts.repeat) {
		xo_emit("\n");
		xo_flush();
		sleep(opts.repeat);
		goto again;
	}

	xo_close_list("neighbor-cache");

	return (count);
}
#endif


static int
delete(char *host)
{
#ifndef WITHOUT_NETLINK
	return (delete_nl(0, host, true)); /* do warn */
#else
	return (delete_rtsock(host));
#endif
}

static int
dump(struct sockaddr_in6 *addr, int cflag)
{
#ifndef WITHOUT_NETLINK
	return (print_entries_nl(0, addr, cflag));
#else
	return (dump_rtsock(addr, cflag));
#endif
}

static struct in6_nbrinfo *
getnbrinfo(struct in6_addr *addr, int ifindex, int warning)
{
	static struct in6_nbrinfo nbi;
	int sock;

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
		xo_err(1, "socket");

	bzero(&nbi, sizeof(nbi));
	if_indextoname(ifindex, nbi.ifname);
	nbi.addr = *addr;
	if (ioctl(sock, SIOCGNBRINFO_IN6, (caddr_t)&nbi) < 0) {
		if (warning)
			xo_warn("ioctl(SIOCGNBRINFO_IN6)");
		close(sock);
		return(NULL);
	}

	close(sock);
	return(&nbi);
}

char *
ether_str(struct sockaddr_dl *sdl)
{
	static char hbuf[NI_MAXHOST];

	if (sdl->sdl_alen == ETHER_ADDR_LEN) {
		strlcpy(hbuf, ether_ntoa((struct ether_addr *)LLADDR(sdl)),
		    sizeof(hbuf));
	} else if (sdl->sdl_alen) {
		int n = sdl->sdl_nlen > 0 ? sdl->sdl_nlen + 1 : 0;
		snprintf(hbuf, sizeof(hbuf), "%s", link_ntoa(sdl) + n);
	} else
		snprintf(hbuf, sizeof(hbuf), "(incomplete)");

	return(hbuf);
}

static int
ndp_ether_aton(char *a, u_char *n)
{
	int i, o[6];

	i = sscanf(a, "%x:%x:%x:%x:%x:%x", &o[0], &o[1], &o[2],
	    &o[3], &o[4], &o[5]);
	if (i != 6) {
		xo_warnx("invalid Ethernet address '%s'", a);
		return (1);
	}
	for (i = 0; i < 6; i++)
		n[i] = o[i];
	return (0);
}

static void
usage(void)
{
	xo_error("usage: ndp [-nt] hostname\n");
	xo_error("       ndp [-nt] -a | -c | -p | -r | -H | -P | -R\n");
	xo_error("       ndp [-nt] -A wait\n");
	xo_error("       ndp [-nt] -d hostname\n");
	xo_error("       ndp [-nt] -f filename\n");
	xo_error("       ndp [-nt] -i interface [flags...]\n");
#ifdef SIOCSDEFIFACE_IN6
	xo_error("       ndp [-nt] -I [interface|delete]\n");
#endif
	xo_error("       ndp [-nt] -s nodename etheraddr [temp] [proxy]\n");
	exit(1);
}

#ifdef WITHOUT_NETLINK
static int
rtmsg(int cmd)
{
	static int seq;
	int rlen;
	register struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
	register char *cp = m_rtmsg.m_space;
	register int l;

	errno = 0;
	if (cmd == RTM_DELETE)
		goto doit;
	bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
	rtm->rtm_flags = opts.flags;
	rtm->rtm_version = RTM_VERSION;

	switch (cmd) {
	default:
		xo_errx(1, "internal wrong cmd");
	case RTM_ADD:
		rtm->rtm_addrs |= RTA_GATEWAY;
		if (opts.expire_time) {
			rtm->rtm_rmx.rmx_expire = opts.expire_time;
			rtm->rtm_inits = RTV_EXPIRE;
		}
		rtm->rtm_flags |= (RTF_HOST | RTF_STATIC | RTF_LLDATA);
		/* FALLTHROUGH */
	case RTM_GET:
		rtm->rtm_addrs |= RTA_DST;
	}

	NEXTADDR(RTA_DST, sin_m);
	NEXTADDR(RTA_GATEWAY, sdl_m);

	rtm->rtm_msglen = cp - (char *)&m_rtmsg;
doit:
	l = rtm->rtm_msglen;
	rtm->rtm_seq = ++seq;
	rtm->rtm_type = cmd;
	if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
		if (errno != ESRCH || cmd != RTM_DELETE) {
			xo_err(1, "writing to routing socket");
			/* NOTREACHED */
		}
	}
	do {
		l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
	} while (l > 0 && (rtm->rtm_type != cmd || rtm->rtm_seq != seq ||
	    rtm->rtm_pid != pid));
	if (l < 0)
		xo_warn("read from routing socket");
	return (0);
}
#endif

static void
ifinfo(char *ifname, int argc, char **argv)
{
	struct in6_ndireq nd;
	int i, sock;
	u_int32_t newflags;
#ifdef IPV6CTL_USETEMPADDR
	u_int8_t nullbuf[8];
#endif

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
		xo_err(1, "socket");
		/* NOTREACHED */
	}
	bzero(&nd, sizeof(nd));
	strlcpy(nd.ifname, ifname, sizeof(nd.ifname));
	if (ioctl(sock, SIOCGIFINFO_IN6, (caddr_t)&nd) < 0) {
		xo_err(1, "ioctl(SIOCGIFINFO_IN6)");
		/* NOTREACHED */
	}
#define	ND nd.ndi
	newflags = ND.flags;
	for (i = 0; i < argc; i++) {
		int clear = 0;
		char *cp = argv[i];

		if (*cp == '-') {
			clear = 1;
			cp++;
		}

#define	SETFLAG(s, f) do {			\
	if (strcmp(cp, (s)) == 0) {		\
		if (clear)			\
			newflags &= ~(f);	\
		else				\
			newflags |= (f);	\
	}					\
} while (0)
/*
 * XXX: this macro is not 100% correct, in that it matches "nud" against
 *      "nudbogus".  But we just let it go since this is minor.
 */
#define	SETVALUE(f, v) do {						\
	char *valptr;							\
	unsigned long newval;						\
	v = 0; /* unspecified */					\
	if (strncmp(cp, f, strlen(f)) == 0) {				\
		valptr = strchr(cp, '=');				\
		if (valptr == NULL)					\
			xo_err(1, "syntax error in %s field", (f));	\
		errno = 0;						\
		newval = strtoul(++valptr, NULL, 0);			\
		if (errno)						\
			xo_err(1, "syntax error in %s's value", (f));	\
		v = newval;						\
	}								\
} while (0)

		SETFLAG("disabled", ND6_IFF_IFDISABLED);
		SETFLAG("nud", ND6_IFF_PERFORMNUD);
#ifdef ND6_IFF_ACCEPT_RTADV
		SETFLAG("accept_rtadv", ND6_IFF_ACCEPT_RTADV);
#endif
#ifdef ND6_IFF_AUTO_LINKLOCAL
		SETFLAG("auto_linklocal", ND6_IFF_AUTO_LINKLOCAL);
#endif
#ifdef ND6_IFF_NO_PREFER_IFACE
		SETFLAG("no_prefer_iface", ND6_IFF_NO_PREFER_IFACE);
#endif
#ifdef ND6_IFF_STABLEADDR
		SETFLAG("stableaddr", ND6_IFF_STABLEADDR);
#endif
		SETVALUE("basereachable", ND.basereachable);
		SETVALUE("retrans", ND.retrans);
		SETVALUE("curhlim", ND.chlim);

		ND.flags = newflags;
		if (ioctl(sock, SIOCSIFINFO_IN6, (caddr_t)&nd) < 0) {
			xo_err(1, "ioctl(SIOCSIFINFO_IN6)");
			/* NOTREACHED */
		}
#undef SETFLAG
#undef SETVALUE
	}

	if (!ND.initialized) {
		xo_errx(1, "%s: not initialized yet", ifname);
		/* NOTREACHED */
	}

	if (ioctl(sock, SIOCGIFINFO_IN6, (caddr_t)&nd) < 0) {
		xo_err(1, "ioctl(SIOCGIFINFO_IN6)");
		/* NOTREACHED */
	}
	xo_open_container("ifinfo");

	xo_emit("{e:interface/%s}", ifname);
	xo_emit("linkmtu={:linkmtu/%d}", ND.linkmtu);
	xo_emit(", maxmtu={:maxmtu/%d}", ND.maxmtu);
	xo_emit(", curhlim={:curhlim/%d}", ND.chlim);
	xo_emit("{d:/, basereachable=%ds%dms}{e:basereachable_ms/%u}",
	    ND.basereachable / 1000, ND.basereachable % 1000, ND.basereachable);
	xo_emit("{d:/, reachable=%ds}{e:reachable_ms/%u}", ND.reachable, ND.reachable * 1000);
	xo_emit("{d:/, retrans=%ds%dms}{e:retrans_ms/%u}", ND.retrans / 1000, ND.retrans % 1000,
	    ND.retrans);
#ifdef IPV6CTL_USETEMPADDR
	memset(nullbuf, 0, sizeof(nullbuf));
	if (memcmp(nullbuf, ND.randomid, sizeof(nullbuf)) != 0) {
		int j;
		u_int8_t *rbuf;

		for (i = 0; i < 3; i++) {
			const char *txt, *field;
			switch (i) {
			case 0:
				txt = "\nRandom seed(0): ";
				field = "seed_0";
				rbuf = ND.randomseed0;
				break;
			case 1:
				txt = "\nRandom seed(1): ";
				field = "seed_1";
				rbuf = ND.randomseed1;
				break;
			case 2:
				txt = "\nRandom ID:      ";
				field = "random_id";
				rbuf = ND.randomid;
				break;
			default:
				xo_errx(1, "impossible case for tempaddr display");
			}
			char abuf[20], xobuf[200];
			for (j = 0; j < 8; j++)
				snprintf(&abuf[j * 2], sizeof(abuf), "%02X", rbuf[j]);
			snprintf(xobuf, sizeof(xobuf), "%s{:%s/%%s}", txt, field);
			xo_emit(xobuf, abuf);
		}
	}
#endif /* IPV6CTL_USETEMPADDR */
	if (ND.flags) {
		xo_emit("\nFlags: {e:flags/%u}", ND.flags);
		xo_open_list("flags_pretty");
#ifdef ND6_IFF_IFDISABLED
		if ((ND.flags & ND6_IFF_IFDISABLED))
			xo_emit("{l:%s} ", "disabled");
#endif
		if ((ND.flags & ND6_IFF_PERFORMNUD))
			xo_emit("{l:%s} ", "nud");
#ifdef ND6_IFF_ACCEPT_RTADV
		if ((ND.flags & ND6_IFF_ACCEPT_RTADV))
			xo_emit("{l:%s} ", "accept_rtadv");
#endif
#ifdef ND6_IFF_AUTO_LINKLOCAL
		if ((ND.flags & ND6_IFF_AUTO_LINKLOCAL))
			xo_emit("{l:%s} ", "auto_linklocal");
#endif
#ifdef ND6_IFF_STABLEADDR
		if ((ND.flags & ND6_IFF_STABLEADDR))
			xo_emit("{l:%s} ", "stableaddr");
#endif
#ifdef ND6_IFF_NO_PREFER_IFACE
		if ((ND.flags & ND6_IFF_NO_PREFER_IFACE))
			xo_emit("{l:%s} ", "no_prefer_iface");
#endif
		xo_close_list("flags");
	}
	xo_emit("\n");
#undef ND
	xo_close_container("ifinfo");

	close(sock);
}

#ifndef ND_RA_FLAG_RTPREF_MASK	/* XXX: just for compilation on *BSD release */
#define ND_RA_FLAG_RTPREF_MASK	0x18 /* 00011000 */
#endif

static void
rtrlist(void)
{
	int mib[] = { CTL_NET, PF_INET6, IPPROTO_ICMPV6, ICMPV6CTL_ND6_DRLIST };
	char *buf;
	struct in6_defrouter *p, *ep;
	size_t l;
	struct timeval now;

	if (sysctl(mib, nitems(mib), NULL, &l, NULL, 0) < 0) {
		xo_err(1, "sysctl(ICMPV6CTL_ND6_DRLIST)");
		/*NOTREACHED*/
	}
	if (l == 0)
		return;
	buf = malloc(l);
	if (!buf) {
		xo_err(1, "malloc");
		/*NOTREACHED*/
	}
	if (sysctl(mib, nitems(mib), buf, &l, NULL, 0) < 0) {
		xo_err(1, "sysctl(ICMPV6CTL_ND6_DRLIST)");
		/*NOTREACHED*/
	}

	xo_open_list("router-list");

	ep = (struct in6_defrouter *)(buf + l);
	for (p = (struct in6_defrouter *)buf; p < ep; p++) {
		int rtpref;
		char abuf[INET6_ADDRSTRLEN], *paddr;

		if (getnameinfo((struct sockaddr *)&p->rtaddr,
		    p->rtaddr.sin6_len, host_buf, sizeof(host_buf), NULL, 0,
		    (opts.nflag ? NI_NUMERICHOST : 0)) != 0)
			strlcpy(host_buf, "?", sizeof(host_buf));
		if (opts.nflag)
			paddr = host_buf;
		else {
			inet_ntop(AF_INET6, &p->rtaddr.sin6_addr, abuf, sizeof(abuf));
			paddr = abuf;
		}

		xo_open_instance("router-list");
		xo_emit("{:hostname/%s}{e:address/%s} if={:interface/%s}",
		    host_buf, paddr,
		    if_indextoname(p->if_index, ifix_buf));
		xo_open_list("flags_pretty");
		char rflags[6] = {}, *pflags = rflags;
		if (p->flags & ND_RA_FLAG_MANAGED) {
			*pflags++ = 'M';
			xo_emit("{el:%s}", "managed");
		}
		if (p->flags & ND_RA_FLAG_OTHER) {
			*pflags++ = 'O';
			xo_emit("{el:%s}", "other");
		}
#ifdef DRAFT_IETF_6MAN_IPV6ONLY_FLAG
		if (p->flags & ND_RA_FLAG_IPV6_ONLY) {
			*pflags++ = 'S';
			xo_emit("{el:%s}", "ipv6only");
		}
#endif
		xo_close_list("flags_pretty");
		xo_emit(", flags={:flags/%s}", rflags);

		rtpref = ((p->flags & ND_RA_FLAG_RTPREF_MASK) >> 3) & 0xff;
		xo_emit(", pref={:preference/%s}", rtpref_str[rtpref]);

		gettimeofday(&now, 0);
		if (p->expire == 0)
			xo_emit(", expire=Never\n{en:permanent/true}");
		else
			xo_emit("{d:/, expire=%s\n}{e:expires_sec/%ld}",
			    sec2str(p->expire - now.tv_sec),
			    (long)p->expire - now.tv_sec);
		xo_close_instance("router-list");
	}
	free(buf);
	xo_close_list("router-list");
}

static void
plist(void)
{
	int mib[] = { CTL_NET, PF_INET6, IPPROTO_ICMPV6, ICMPV6CTL_ND6_PRLIST };
	char *buf;
	struct in6_prefix *p, *ep, *n;
	struct sockaddr_in6 *advrtr;
	size_t l;
	struct timeval now;
	const int niflags = NI_NUMERICHOST;
	int ninflags = opts.nflag ? NI_NUMERICHOST : 0;
	char namebuf[NI_MAXHOST];

	if (sysctl(mib, nitems(mib), NULL, &l, NULL, 0) < 0) {
		xo_err(1, "sysctl(ICMPV6CTL_ND6_PRLIST)");
		/*NOTREACHED*/
	}
	buf = malloc(l);
	if (!buf) {
		xo_err(1, "malloc");
		/*NOTREACHED*/
	}
	if (sysctl(mib, nitems(mib), buf, &l, NULL, 0) < 0) {
		xo_err(1, "sysctl(ICMPV6CTL_ND6_PRLIST)");
		/*NOTREACHED*/
	}

	xo_open_list("prefix-list");

	ep = (struct in6_prefix *)(buf + l);
	for (p = (struct in6_prefix *)buf; p < ep; p = n) {
		advrtr = (struct sockaddr_in6 *)(p + 1);
		n = (struct in6_prefix *)&advrtr[p->advrtrs];

		xo_open_instance("prefix-list");
		if (getnameinfo((struct sockaddr *)&p->prefix,
		    p->prefix.sin6_len, namebuf, sizeof(namebuf),
		    NULL, 0, niflags) != 0)
			strlcpy(namebuf, "?", sizeof(namebuf));
		xo_emit("{:prefix/%s%s%d} if={:interface/%s}\n", namebuf, "/",
		    p->prefixlen, if_indextoname(p->if_index, ifix_buf));

		gettimeofday(&now, 0);
		/*
		 * meaning of fields, especially flags, is very different
		 * by origin.  notify the difference to the users.
		 */
		char flags[10] = {}, *pflags = flags;
		xo_open_list("flags_pretty");
		if (p->raflags.onlink) {
			*pflags++ = 'L';
			xo_emit("{el:%s}", "ra_onlink");
		}
		if (p->raflags.autonomous) {
			*pflags++ = 'A';
			xo_emit("{el:%s}", "ra_autonomous");
		}
		if (p->flags & NDPRF_ONLINK) {
			*pflags++ = 'O';
			xo_emit("{el:%s}", "is_onlink");
		}
		if (p->flags & NDPRF_DETACHED) {
			*pflags++ = 'D';
			xo_emit("{el:%s}", "is_detached");
		}
#ifdef NDPRF_HOME
		if (p->flags & NDPRF_HOME) {
			*pflags++ = 'H';
			xo_emit("{el:%s}", "is_home");
		}
#endif
		xo_close_list("flags_pretty");
		xo_emit("flags={:flags/%s}", flags);
		int expire_in = p->expire - now.tv_sec;

		if (p->vltime == ND6_INFINITE_LIFETIME)
			xo_emit(" vltime=infinity{e:valid-lifetime/%lu}",
			    (unsigned long)p->vltime);
		else
			xo_emit(" vltime={:valid-lifetime/%lu}",
			    (unsigned long)p->vltime);
		if (p->pltime == ND6_INFINITE_LIFETIME)
			xo_emit(", pltime=infinity{e:preferred-lifetime/%lu}",
			    (unsigned long)p->pltime);
		else
			xo_emit(", pltime={:preferred-lifetime/%lu}",
			    (unsigned long)p->pltime);
		if (p->expire == 0)
			xo_emit(", expire=Never{en:permanent/true}");
		else if (p->expire >= now.tv_sec)
			xo_emit(", expire={:expires/%s}{e:expires_sec/%d}",
			    sec2str(expire_in), expire_in);
		else
			xo_emit(", expired{e:expires_sec/%d}", expire_in);
		xo_emit(", ref={:refcount/%d}", p->refcnt);
		xo_emit("\n");
		/*
		 * "advertising router" list is meaningful only if the prefix
		 * information is from RA.
		 */
		if (p->advrtrs) {
			int j;
			struct sockaddr_in6 *sin6;

			sin6 = advrtr;
			xo_emit("  advertised by\n");
			xo_open_list("advertising-routers");
			for (j = 0; j < p->advrtrs; j++) {
				struct in6_nbrinfo *nbi;

				xo_open_instance("advertising-routers");
				if (getnameinfo((struct sockaddr *)sin6,
				    sin6->sin6_len, namebuf, sizeof(namebuf),
				    NULL, 0, ninflags) != 0)
					strlcpy(namebuf, "?", sizeof(namebuf));
				char abuf[INET6_ADDRSTRLEN];
				inet_ntop(AF_INET6, &sin6->sin6_addr, abuf,
				    sizeof(abuf));

				xo_emit("    {:hostname/%s}{e:address/%s}",
				    namebuf, abuf);

				nbi = getnbrinfo(&sin6->sin6_addr,
				    p->if_index, 0);
				const char *state = "";
				if (nbi) {
					switch (nbi->state) {
					case ND6_LLINFO_REACHABLE:
					case ND6_LLINFO_STALE:
					case ND6_LLINFO_DELAY:
					case ND6_LLINFO_PROBE:
						state = "reachable";
						break;
					default:
						state = "unreachable";
					}
				} else
					state = "no neighbor state";
				xo_emit(" ({:state/%s})\n", state);
				sin6++;
				xo_close_instance("advertising-routers");
			}
			xo_close_list("advertising-routers");
		} else
			xo_emit("  No advertising router\n");
		xo_close_instance("prefix-list");
	}
	free(buf);

	xo_close_list("prefix-list");
}

static void
pfx_flush(void)
{
	char dummyif[IFNAMSIZ+8];
	int sock;

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
		xo_err(1, "socket");
	strlcpy(dummyif, "lo0", sizeof(dummyif)); /* dummy */
	if (ioctl(sock, SIOCSPFXFLUSH_IN6, (caddr_t)&dummyif) < 0)
		xo_err(1, "ioctl(SIOCSPFXFLUSH_IN6)");

	close(sock);
}

static void
rtr_flush(void)
{
	char dummyif[IFNAMSIZ+8];
	int sock;

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
		xo_err(1, "socket");
	strlcpy(dummyif, "lo0", sizeof(dummyif)); /* dummy */
	if (ioctl(sock, SIOCSRTRFLUSH_IN6, (caddr_t)&dummyif) < 0)
		xo_err(1, "ioctl(SIOCSRTRFLUSH_IN6)");

	close(sock);
}

static void
harmonize_rtr(void)
{
	char dummyif[IFNAMSIZ+8];
	int sock;

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
		xo_err(1, "socket");
	strlcpy(dummyif, "lo0", sizeof(dummyif)); /* dummy */
	if (ioctl(sock, SIOCSNDFLUSH_IN6, (caddr_t)&dummyif) < 0)
		xo_err(1, "ioctl(SIOCSNDFLUSH_IN6)");

	close(sock);
}

#ifdef SIOCSDEFIFACE_IN6	/* XXX: check SIOCGDEFIFACE_IN6 as well? */
static void
setdefif(char *ifname)
{
	struct in6_ndifreq ndifreq;
	unsigned int ifindex;
	int sock;

	if (strcasecmp(ifname, "delete") == 0)
		ifindex = 0;
	else {
		if ((ifindex = if_nametoindex(ifname)) == 0)
			xo_err(1, "failed to resolve i/f index for %s", ifname);
	}

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
		xo_err(1, "socket");

	strlcpy(ndifreq.ifname, "lo0", sizeof(ndifreq.ifname)); /* dummy */
	ndifreq.ifindex = ifindex;

	if (ioctl(sock, SIOCSDEFIFACE_IN6, (caddr_t)&ndifreq) < 0)
		xo_err(1, "ioctl(SIOCSDEFIFACE_IN6)");

	close(sock);
}

static void
getdefif(void)
{
	struct in6_ndifreq ndifreq;
	char ifname[IFNAMSIZ+8];
	int sock;

	if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
		xo_err(1, "socket");

	memset(&ndifreq, 0, sizeof(ndifreq));
	strlcpy(ndifreq.ifname, "lo0", sizeof(ndifreq.ifname)); /* dummy */

	if (ioctl(sock, SIOCGDEFIFACE_IN6, (caddr_t)&ndifreq) < 0)
		xo_err(1, "ioctl(SIOCGDEFIFACE_IN6)");

	if (ndifreq.ifindex == 0)
		xo_emit("No default interface.\n");
	else {
		if ((if_indextoname(ndifreq.ifindex, ifname)) == NULL)
			xo_err(1, "failed to resolve ifname for index %lu",
			    ndifreq.ifindex);
		xo_emit("ND default interface = {:default-interface/%s}\n", ifname);
	}

	close(sock);
}
#endif /* SIOCSDEFIFACE_IN6 */

char *
sec2str(time_t total)
{
	static char result[256];
	int days, hours, mins, secs;
	int first = 1;
	char *p = result;
	char *ep = &result[sizeof(result)];
	int n;

	days = total / 3600 / 24;
	hours = (total / 3600) % 24;
	mins = (total / 60) % 60;
	secs = total % 60;

	if (days) {
		first = 0;
		n = snprintf(p, ep - p, "%dd", days);
		if (n < 0 || n >= ep - p)
			return "?";
		p += n;
	}
	if (!first || hours) {
		first = 0;
		n = snprintf(p, ep - p, "%dh", hours);
		if (n < 0 || n >= ep - p)
			return "?";
		p += n;
	}
	if (!first || mins) {
		first = 0;
		n = snprintf(p, ep - p, "%dm", mins);
		if (n < 0 || n >= ep - p)
			return "?";
		p += n;
	}
	snprintf(p, ep - p, "%ds", secs);

	return(result);
}

/*
 * Print the timestamp
 * from tcpdump/util.c
 */
void
ts_print(const struct timeval *tvp)
{
	int sec;

	/* Default */
	sec = (tvp->tv_sec + thiszone) % 86400;
	xo_emit("{e:tv_sec/%lld}{e:tv_usec/%lld}{d:/%02d:%02d:%02d.%06u} ",
	    tvp->tv_sec, tvp->tv_usec,
	    sec / 3600, (sec % 3600) / 60, sec % 60, (u_int32_t)tvp->tv_usec);
}

#undef NEXTADDR
