common.c

/*	$KAME: common.c,v 1.129 2005/09/16 11:30:13 suz Exp $	*/
/*
 * Copyright (C) 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.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/queue.h>
#include <sys/stat.h>
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include <net/if.h>
#include <netinet/in.h>
#ifdef __KAME__
#include <net/if_types.h>
#ifdef __FreeBSD__
#include <net/if_var.h>
#endif
#include <net/if_dl.h>
#endif
#ifdef __linux__
#include <linux/if_packet.h>
#endif
#include <net/if_arp.h>
#ifdef __sun__
#include <sys/sockio.h>
#include <sys/dlpi.h>
#include <stropts.h>
#include <fcntl.h>
#include <libdevinfo.h>
#endif

#ifdef __KAME__
#include <netinet6/in6_var.h>
#endif

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdarg.h>
#include <syslog.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <err.h>
#include <netdb.h>
#include <ifaddrs.h>

#include <dhcp6.h>
#include <config.h>
#include <common.h>
#include <timer.h>

#ifdef __linux__
/* from /usr/include/linux/ipv6.h */

struct in6_ifreq {
	struct in6_addr ifr6_addr;
	u_int32_t ifr6_prefixlen;
	unsigned int ifr6_ifindex;
};
#endif

#define MAXDNAME 255

int foreground;
int debug_thresh;

static int dhcp6_count_list __P((struct dhcp6_list *));
static int in6_matchflags __P((struct sockaddr *, char *, int));
static ssize_t dnsencode __P((const char *, char *, size_t));
static char *dnsdecode __P((u_char **, u_char *, char *, size_t));
static int copyout_option __P((char *, char *, struct dhcp6_listval *));
static int copyin_option __P((int, struct dhcp6opt *, struct dhcp6opt *,
    struct dhcp6_list *));
static int copy_option __P((u_int16_t, u_int16_t, void *, struct dhcp6opt **,
    struct dhcp6opt *, int *));
static ssize_t gethwid __P((char *, int, const char *, u_int16_t *));
static char *sprint_uint64 __P((char *, int, u_int64_t));
static char *sprint_auth __P((struct dhcp6_optinfo *));

int
dhcp6_copy_list(dst, src)
	struct dhcp6_list *dst, *src;
{
	struct dhcp6_listval *ent;

	for (ent = TAILQ_FIRST(src); ent; ent = TAILQ_NEXT(ent, link)) {
		if (dhcp6_add_listval(dst, ent->type,
		    &ent->uv, &ent->sublist) == NULL)
			goto fail;
	}

	return (0);

  fail:
	dhcp6_clear_list(dst);
	return (-1);
}

void
dhcp6_move_list(dst, src)
	struct dhcp6_list *dst, *src;
{
	struct dhcp6_listval *v;

	while ((v = TAILQ_FIRST(src)) != NULL) {
		TAILQ_REMOVE(src, v, link);
		TAILQ_INSERT_TAIL(dst, v, link);
	}
}

void
dhcp6_clear_list(head)
	struct dhcp6_list *head;
{
	struct dhcp6_listval *v;

	while ((v = TAILQ_FIRST(head)) != NULL) {
		TAILQ_REMOVE(head, v, link);
		dhcp6_clear_listval(v);
	}

	return;
}

static int
dhcp6_count_list(head)
	struct dhcp6_list *head;
{
	struct dhcp6_listval *v;
	int i;

	for (i = 0, v = TAILQ_FIRST(head); v; v = TAILQ_NEXT(v, link))
		i++;

	return (i);
}

void
dhcp6_clear_listval(lv)
	struct dhcp6_listval *lv;
{
	dhcp6_clear_list(&lv->sublist);
	switch (lv->type) {
	case DHCP6_LISTVAL_VBUF:
		dhcp6_vbuf_free(&lv->val_vbuf);
		break;
	default:		/* nothing to do */
		break;
	}
	free(lv);
}

/*
 * Note: this function only searches for the first entry that matches
 * VAL.  It also does not care about sublists.
 */
struct dhcp6_listval *
dhcp6_find_listval(head, type, val, option)
	struct dhcp6_list *head;
	dhcp6_listval_type_t type;
	void *val;
	int option;
{
	struct dhcp6_listval *lv;

	for (lv = TAILQ_FIRST(head); lv; lv = TAILQ_NEXT(lv, link)) {
		if (lv->type != type)
			continue;

		switch(type) {
		case DHCP6_LISTVAL_NUM:
			if (lv->val_num == *(int *)val)
				return (lv);
			break;
		case DHCP6_LISTVAL_STCODE:
			if (lv->val_num16 == *(u_int16_t *)val)
				return (lv);
			break;
		case DHCP6_LISTVAL_ADDR6:
			if (IN6_ARE_ADDR_EQUAL(&lv->val_addr6,
			    (struct in6_addr *)val)) {
				return (lv);
			}
			break;
		case DHCP6_LISTVAL_PREFIX6:
			if ((option & MATCHLIST_PREFIXLEN) &&
			    lv->val_prefix6.plen ==
			    ((struct dhcp6_prefix *)val)->plen) {
				return (lv);
			} else if (IN6_ARE_ADDR_EQUAL(&lv->val_prefix6.addr,
			    &((struct dhcp6_prefix *)val)->addr) &&
			    lv->val_prefix6.plen ==
			    ((struct dhcp6_prefix *)val)->plen) {
				return (lv);
			}
			break;
		case DHCP6_LISTVAL_STATEFULADDR6:
			if (IN6_ARE_ADDR_EQUAL(&lv->val_statefuladdr6.addr,
			    &((struct dhcp6_prefix *)val)->addr)) {
				return (lv);
			}
			break;
		case DHCP6_LISTVAL_IAPD:
		case DHCP6_LISTVAL_IANA:
			if (lv->val_ia.iaid ==
			    ((struct dhcp6_ia *)val)->iaid) {
				return (lv);
			}
			break;
		case DHCP6_LISTVAL_VBUF:
			if (dhcp6_vbuf_cmp(&lv->val_vbuf,
			    (struct dhcp6_vbuf *)val) == 0) {
				return (lv);
			}
			break;
		}
	}

	return (NULL);
}

struct dhcp6_listval *
dhcp6_add_listval(head, type, val, sublist)
	struct dhcp6_list *head, *sublist;
	dhcp6_listval_type_t type;
	void *val;
{
	struct dhcp6_listval *lv = NULL;

	if ((lv = malloc(sizeof(*lv))) == NULL) {
		dprintf(LOG_ERR, FNAME,
		    "failed to allocate memory for list entry");
		goto fail;
	}
	memset(lv, 0, sizeof(*lv));
	lv->type = type;
	TAILQ_INIT(&lv->sublist);

	switch(type) {
	case DHCP6_LISTVAL_NUM:
		lv->val_num = *(int *)val;
		break;
	case DHCP6_LISTVAL_STCODE:
		lv->val_num16 = *(u_int16_t *)val;
		break;
	case DHCP6_LISTVAL_ADDR6:
		lv->val_addr6 = *(struct in6_addr *)val;
		break;
	case DHCP6_LISTVAL_PREFIX6:
		lv->val_prefix6 = *(struct dhcp6_prefix *)val;
		break;
	case DHCP6_LISTVAL_STATEFULADDR6:
		lv->val_statefuladdr6 = *(struct dhcp6_statefuladdr *)val;
		break;
	case DHCP6_LISTVAL_IAPD:
	case DHCP6_LISTVAL_IANA:
		lv->val_ia = *(struct dhcp6_ia *)val;
		break;
	case DHCP6_LISTVAL_VBUF:
		if (dhcp6_vbuf_copy(&lv->val_vbuf, (struct dhcp6_vbuf *)val))
			goto fail;
		break;
	default:
		dprintf(LOG_ERR, FNAME,
		    "unexpected list value type (%d)", type);
		goto fail;
	}

	if (sublist && dhcp6_copy_list(&lv->sublist, sublist))
		goto fail;

	TAILQ_INSERT_TAIL(head, lv, link);

	return (lv);

  fail:
	if (lv)
		free(lv);

	return (NULL);
}

int
dhcp6_vbuf_copy(dst, src)
	struct dhcp6_vbuf *dst, *src;
{
	dst->dv_buf = malloc(src->dv_len);
	if (dst->dv_buf == NULL)
		return (-1);

	dst->dv_len = src->dv_len;
	memcpy(dst->dv_buf, src->dv_buf, dst->dv_len);

	return (0);
}

void
dhcp6_vbuf_free(vbuf)
	struct dhcp6_vbuf *vbuf;
{
	free(vbuf->dv_buf);

	vbuf->dv_len = 0;
	vbuf->dv_buf = NULL;
}

int
dhcp6_vbuf_cmp(vb1, vb2)
	struct dhcp6_vbuf *vb1, *vb2;
{
	if (vb1->dv_len != vb2->dv_len)
		return (vb1->dv_len - vb2->dv_len);

	return (memcmp(vb1->dv_buf, vb2->dv_buf, vb1->dv_len));
}

static int
dhcp6_get_addr(optlen, cp, type, list)
	int optlen;
	void *cp;
	dhcp6_listval_type_t type;
	struct dhcp6_list *list;
{
	void *val;

	if (optlen % sizeof(struct in6_addr) || optlen == 0) {
		dprintf(LOG_INFO, FNAME,
		    "malformed DHCP option: type %d, len %d", type, optlen);
		return -1;
	}
	for (val = cp; val < cp + optlen; val += sizeof(struct in6_addr)) {
		struct in6_addr valaddr;

		memcpy(&valaddr, val, sizeof(valaddr));
		if (dhcp6_find_listval(list,
		    DHCP6_LISTVAL_ADDR6, &valaddr, 0)) {
			dprintf(LOG_INFO, FNAME, "duplicated %s address (%s)",
			    dhcp6optstr(type), in6addr2str(&valaddr, 0));
			continue;
		}

		if (dhcp6_add_listval(list, DHCP6_LISTVAL_ADDR6,
		    &valaddr, NULL) == NULL) {
			dprintf(LOG_ERR, FNAME,
			    "failed to copy %s address", dhcp6optstr(type));
			return -1;
		}
	}

	return 0;
}

static int
dhcp6_set_addr(type, list, p, optep, len)
	dhcp6_listval_type_t type;
	struct dhcp6_list *list;
	struct dhcp6opt **p, *optep;
	int *len;
{
	struct in6_addr *in6;
	char *tmpbuf;
	struct dhcp6_listval *d;
	int optlen;

	if (TAILQ_EMPTY(list))
		return 0;

	tmpbuf = NULL;
	optlen = dhcp6_count_list(list) * sizeof(struct in6_addr);
	if ((tmpbuf = malloc(optlen)) == NULL) {
		dprintf(LOG_ERR, FNAME,
		    "memory allocation failed for %s options",
		    dhcp6optstr(type));
		return -1;
	}
	in6 = (struct in6_addr *)tmpbuf;
	for (d = TAILQ_FIRST(list); d; d = TAILQ_NEXT(d, link), in6++)
		memcpy(in6, &d->val_addr6, sizeof(*in6));
	if (copy_option(type, optlen, tmpbuf, p, optep, len) != 0) {
		free(tmpbuf);
		return -1;
	}

	free(tmpbuf);
	return 0;
}

static int
dhcp6_get_domain(optlen, cp, type, list)
	int optlen;
	void *cp;
	dhcp6_listval_type_t type;
	struct dhcp6_list *list;
{
	void *val;

	val = cp;
	while (val < cp + optlen) {
		struct dhcp6_vbuf vb;
		char name[MAXDNAME + 1];

		if (dnsdecode((u_char **)(void *)&val,
		    (u_char *)(cp + optlen), name, sizeof(name)) == NULL) {
			dprintf(LOG_INFO, FNAME, "failed to "
			    "decode a %s domain name",
			    dhcp6optstr(type));
			dprintf(LOG_INFO, FNAME,
			    "malformed DHCP option: type %d, len %d",
			     type, optlen);
			return -1;
		}

		vb.dv_len = strlen(name) + 1;
		vb.dv_buf = name;

		if (dhcp6_add_listval(list,
		    DHCP6_LISTVAL_VBUF, &vb, NULL) == NULL) {
			dprintf(LOG_ERR, FNAME, "failed to "
			    "copy a %s domain name", dhcp6optstr(type));
			return -1;
		}
	}

	return 0;
}

static int
dhcp6_set_domain(type, list, p, optep, len)
	dhcp6_listval_type_t type;
	struct dhcp6_list *list;
	struct dhcp6opt **p, *optep;
	int *len;
{
	int optlen = 0;
	struct dhcp6_listval *d;
	char *tmpbuf;
	char name[MAXDNAME], *cp, *ep;

	if (TAILQ_EMPTY(list))
		return 0;

	for (d = TAILQ_FIRST(list); d; d = TAILQ_NEXT(d, link))
		optlen += (d->val_vbuf.dv_len + 1);

	if (optlen == 0) {
		return 0;
	}

	tmpbuf = NULL;
	if ((tmpbuf = malloc(optlen)) == NULL) {
		dprintf(LOG_ERR, FNAME, "memory allocation failed for "
		    "%s domain options", dhcp6optstr(type));
		return -1;
	}
	cp = tmpbuf;
	ep = cp + optlen;
	for (d = TAILQ_FIRST(list); d; d = TAILQ_NEXT(d, link)) {
		int nlen;

		nlen = dnsencode((const char *)d->val_vbuf.dv_buf,
		    name, sizeof (name));
		if (nlen < 0) {
			dprintf(LOG_ERR, FNAME,
			    "failed to encode a %s domain name",
			    dhcp6optstr(type));
			free(tmpbuf);
			return -1;
		}
		if (ep - cp < nlen) {
			dprintf(LOG_ERR, FNAME,
			    "buffer length for %s domain name is too short",
			    dhcp6optstr(type));
			free(tmpbuf);
			return -1;
		}
		memcpy(cp, name, nlen);
		cp += nlen;
	}
	if (copy_option(type, cp - tmpbuf, tmpbuf, p, optep, len) != 0) {
		free(tmpbuf);
		return -1;
	}
	free(tmpbuf);

	return 0;
}

struct dhcp6_event *
dhcp6_create_event(ifp, state)
	struct dhcp6_if *ifp;
	int state;
{
	struct dhcp6_event *ev;

	if ((ev = malloc(sizeof(*ev))) == NULL) {
		dprintf(LOG_ERR, FNAME,
		    "failed to allocate memory for an event");
		return (NULL);
	}
	memset(ev, 0, sizeof(*ev));
	ev->ifp = ifp;
	ev->state = state;
	TAILQ_INIT(&ev->data_list);

	return (ev);
}

void
dhcp6_remove_event(ev)
	struct dhcp6_event *ev;
{
	struct dhcp6_serverinfo *sp, *sp_next;

	dprintf(LOG_DEBUG, FNAME, "removing an event on %s, state=%s",
	    ev->ifp->ifname, dhcp6_event_statestr(ev));

	dhcp6_remove_evdata(ev);

	duidfree(&ev->serverid);

	if (ev->timer)
		dhcp6_remove_timer(&ev->timer);
	TAILQ_REMOVE(&ev->ifp->event_list, ev, link);

	for (sp = ev->servers; sp; sp = sp_next) {
		sp_next = sp->next;

		dprintf(LOG_DEBUG, FNAME, "removing server (ID: %s)",
		    duidstr(&sp->optinfo.serverID));
		dhcp6_clear_options(&sp->optinfo);
		if (sp->authparam != NULL)
			free(sp->authparam);
		free(sp);
	}

	if (ev->authparam != NULL)
		free(ev->authparam);

	free(ev);
}

void
dhcp6_remove_evdata(ev)
	struct dhcp6_event *ev;
{
	struct dhcp6_eventdata *evd;

	while ((evd = TAILQ_FIRST(&ev->data_list)) != NULL) {
		TAILQ_REMOVE(&ev->data_list, evd, link);
		if (evd->destructor)
			(*evd->destructor)(evd);
		free(evd);
	}
}

struct authparam *
new_authparam(proto, alg, rdm)
	int proto, alg, rdm;
{
	struct authparam *authparam;

	if ((authparam = malloc(sizeof(*authparam))) == NULL)
		return (NULL);

	memset(authparam, 0, sizeof(*authparam));

	authparam->authproto = proto;
	authparam->authalgorithm = alg;
	authparam->authrdm = rdm;
	authparam->key = NULL;
	authparam->flags |= AUTHPARAM_FLAGS_NOPREVRD;
	authparam->prevrd = 0;

	return (authparam);
}

struct authparam *
copy_authparam(authparam)
	struct authparam *authparam;
{
	struct authparam *dst;

	if ((dst = malloc(sizeof(*dst))) == NULL)
		return (NULL);

	memcpy(dst, authparam, sizeof(*dst));

	return (dst);
}

/*
 * Home-brew function of a 64-bit version of ntohl.
 * XXX: is there any standard for this?
 */
#if (BYTE_ORDER == LITTLE_ENDIAN)
static __inline u_int64_t
ntohq(u_int64_t x)
{
	return (u_int64_t)ntohl((u_int32_t)(x >> 32)) |
	    (int64_t)ntohl((u_int32_t)(x & 0xffffffff)) << 32;
}
#else	/* (BYTE_ORDER == LITTLE_ENDIAN) */
#define ntohq(x) (x)
#endif

int
dhcp6_auth_replaycheck(method, prev, current)
	int method;
	u_int64_t prev, current;
{
	char bufprev[] = "ffff ffff ffff ffff";
	char bufcurrent[] = "ffff ffff ffff ffff";

	if (method != DHCP6_AUTHRDM_MONOCOUNTER) {
		dprintf(LOG_ERR, FNAME, "unsupported replay detection "
		    "method (%d)", method);
		return (-1);
	}

	(void)sprint_uint64(bufprev, sizeof(bufprev), prev);
	(void)sprint_uint64(bufcurrent, sizeof(bufcurrent), current);
	dprintf(LOG_DEBUG, FNAME, "previous: %s, current: %s",
	    bufprev, bufcurrent);

	prev = ntohq(prev);
	current = ntohq(current);

	/*
	 * we call the singular point guilty, since we cannot guess
	 * whether the serial number is increasing or not.
	 */
        if (prev == (current ^ 0x8000000000000000ULL)) {
		dprintf(LOG_INFO, FNAME, "detected a singular point");
		return (1);
	}

	return (((int64_t)(current - prev) > 0) ? 0 : 1);
}

int
getifaddr(addr, ifnam, prefix, plen, strong, ignoreflags)
	struct in6_addr *addr;
	char *ifnam;
	struct in6_addr *prefix;
	int plen;
	int strong;		/* if strong host model is required or not */
	int ignoreflags;
{
	struct ifaddrs *ifap, *ifa;
	struct sockaddr_in6 sin6;
	int error = -1;

	if (getifaddrs(&ifap) != 0) {
		dprintf(LOG_WARNING, FNAME,
			"getifaddrs failed: %s", strerror(errno));
		return (-1);
	}

	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
		int s1, s2;

		if (strong && strcmp(ifnam, ifa->ifa_name) != 0)
			continue;

		/* in any case, ignore interfaces in different scope zones. */
		if ((s1 = in6_addrscopebyif(prefix, ifnam)) < 0 ||
		    (s2 = in6_addrscopebyif(prefix, ifa->ifa_name)) < 0 ||
		     s1 != s2)
			continue;

		if (ifa->ifa_addr->sa_family != AF_INET6)
			continue;
#ifdef HAVE_SA_LEN
		if (ifa->ifa_addr->sa_len > sizeof(sin6))
			continue;
#endif

		if (in6_matchflags(ifa->ifa_addr, ifa->ifa_name, ignoreflags))
			continue;

		memcpy(&sin6, ifa->ifa_addr, sysdep_sa_len(ifa->ifa_addr));
#ifdef __KAME__
		if (IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr)) {
			sin6.sin6_addr.s6_addr[2] = 0;
			sin6.sin6_addr.s6_addr[3] = 0;
		}
#endif
		if (plen % 8 == 0) {
			if (memcmp(&sin6.sin6_addr, prefix, plen / 8) != 0)
				continue;
		} else {
			struct in6_addr a, m;
			int i;

			memcpy(&a, &sin6.sin6_addr, sizeof(sin6.sin6_addr));
			memset(&m, 0, sizeof(m));
			memset(&m, 0xff, plen / 8);
			m.s6_addr[plen / 8] = (0xff00 >> (plen % 8)) & 0xff;
			for (i = 0; i < sizeof(a); i++)
				a.s6_addr[i] &= m.s6_addr[i];

			if (memcmp(&a, prefix, plen / 8) != 0 ||
			    a.s6_addr[plen / 8] !=
			    (prefix->s6_addr[plen / 8] & m.s6_addr[plen / 8]))
				continue;
		}
		memcpy(addr, &sin6.sin6_addr, sizeof(sin6.sin6_addr));
#ifdef __KAME__
		if (IN6_IS_ADDR_LINKLOCAL(addr))
			addr->s6_addr[2] = addr->s6_addr[3] = 0; 
#endif
		error = 0;
		break;
	}

	freeifaddrs(ifap);
	return (error);
}

int
getifidfromaddr(addr, ifidp)
	struct in6_addr *addr;
	unsigned int *ifidp;
{
	struct ifaddrs *ifap, *ifa;
	struct sockaddr_in6 *sa6;
	unsigned int ifid;
	int retval = -1;

	if (getifaddrs(&ifap) != 0) {
		dprintf(LOG_WARNING, FNAME,
			"getifaddrs failed: %s", strerror(errno));
		return (-1);
	}

	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
		if (ifa->ifa_addr->sa_family != AF_INET6)
			continue;

		sa6 = (struct sockaddr_in6 *)ifa->ifa_addr;
		if (IN6_ARE_ADDR_EQUAL(addr, &sa6->sin6_addr))
			break;
	}

	if (ifa != NULL) {
		if ((ifid = if_nametoindex(ifa->ifa_name)) == 0) {
			dprintf(LOG_ERR, FNAME,
			    "if_nametoindex failed for %s", ifa->ifa_name);
			goto end;
		}
		retval = 0;
		*ifidp = ifid;
	}

  end:
	freeifaddrs(ifap);
	return (retval);
}

int
in6_addrscopebyif(addr, ifnam)
	struct in6_addr *addr;
	char *ifnam;
{
	u_int ifindex; 

	if ((ifindex = if_nametoindex(ifnam)) == 0)
		return (-1);

	if (IN6_IS_ADDR_LINKLOCAL(addr) || IN6_IS_ADDR_MC_LINKLOCAL(addr))
		return (ifindex);

	if (IN6_IS_ADDR_SITELOCAL(addr) || IN6_IS_ADDR_MC_SITELOCAL(addr))
		return (1);	/* XXX */

	if (IN6_IS_ADDR_MC_ORGLOCAL(addr))
		return (1);	/* XXX */

	return (1);		/* treat it as global */
}

int
transmit_sa(s, sa, buf, len)
	int s;
	struct sockaddr *sa;
	char *buf;
	size_t len;
{
	int error;

	error = sendto(s, buf, len, 0, sa, sysdep_sa_len(sa));

	return (error != len) ? -1 : 0;
}

long
random_between(x, y)
	long x;
	long y;
{
	long ratio;

	ratio = 1 << 16;
	while ((y - x) * ratio < (y - x))
		ratio = ratio / 2;
	return (x + ((y - x) * (ratio - 1) / random() & (ratio - 1)));
}

int
prefix6_mask(in6, plen)
	struct in6_addr *in6;
	int plen;
{
	struct sockaddr_in6 mask6;
	int i;

	if (sa6_plen2mask(&mask6, plen))
		return (-1);

	for (i = 0; i < 16; i++)
		in6->s6_addr[i] &= mask6.sin6_addr.s6_addr[i];

	return (0);
}

int
sa6_plen2mask(sa6, plen)
	struct sockaddr_in6 *sa6;
	int plen;
{
	u_char *cp;

	if (plen < 0 || plen > 128)
		return (-1);

	memset(sa6, 0, sizeof(*sa6));
	sa6->sin6_family = AF_INET6;
#ifdef HAVE_SA_LEN
	sa6->sin6_len = sizeof(*sa6);
#endif

	for (cp = (u_char *)&sa6->sin6_addr; plen > 7; plen -= 8)
		*cp++ = 0xff;
	*cp = 0xff << (8 - plen);

	return (0);
}

char *
addr2str(sa)
	struct sockaddr *sa;
{
	static char addrbuf[8][NI_MAXHOST];
	static int round = 0;
	char *cp;

	round = (round + 1) & 7;
	cp = addrbuf[round];

	getnameinfo(sa, sysdep_sa_len(sa), cp, NI_MAXHOST,
	    NULL, 0, NI_NUMERICHOST);

	return (cp);
}

char *
in6addr2str(in6, scopeid)
	struct in6_addr *in6;
	int scopeid;
{
	struct sockaddr_in6 sa6;

	memset(&sa6, 0, sizeof(sa6));
	sa6.sin6_family = AF_INET6;
#ifdef HAVE_SA_LEN
	sa6.sin6_len = sizeof(sa6);
#endif
	sa6.sin6_addr = *in6;
	sa6.sin6_scope_id = scopeid;

	return (addr2str((struct sockaddr *)&sa6));
}

/* return IPv6 address scope type. caller assumes that smaller is narrower. */
int
in6_scope(addr)
	struct in6_addr *addr;
{
	int scope;

	if (addr->s6_addr[0] == 0xfe) {
		scope = addr->s6_addr[1] & 0xc0;

		switch (scope) {
		case 0x80:
			return (2); /* link-local */
			break;
		case 0xc0:
			return (5); /* site-local */
			break;
		default:
			return (14); /* global: just in case */
			break;
		}
	}

	/* multicast scope. just return the scope field */
	if (addr->s6_addr[0] == 0xff)
		return (addr->s6_addr[1] & 0x0f);

	if (bcmp(&in6addr_loopback, addr, sizeof(addr) - 1) == 0) {
		if (addr->s6_addr[15] == 1) /* loopback */
			return (1);
		if (addr->s6_addr[15] == 0) /* unspecified */
			return (0); /* XXX: good value? */
	}

	return (14);		/* global */
}

static int
in6_matchflags(addr, ifnam, flags)
	struct sockaddr *addr;
	char *ifnam;
	int flags;
{
#ifdef __KAME__
	int s;
	struct in6_ifreq ifr6;

	if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
		warn("in6_matchflags: socket(DGRAM6)");
		return (-1);
	}
	memset(&ifr6, 0, sizeof(ifr6));
	strncpy(ifr6.ifr_name, ifnam, sizeof(ifr6.ifr_name));
	ifr6.ifr_addr = *(struct sockaddr_in6 *)addr;

	if (ioctl(s, SIOCGIFAFLAG_IN6, &ifr6) < 0) {
		warn("in6_matchflags: ioctl(SIOCGIFAFLAG_IN6, %s)",
		     addr2str(addr));
		close(s);
		return (-1);
	}

	close(s);

	return (ifr6.ifr_ifru.ifru_flags6 & flags);
#else
	return (0);
#endif
}

int
get_duid(idfile, duid)
	char *idfile;
	struct duid *duid;
{
	FILE *fp = NULL;
	u_int16_t len = 0, hwtype;
	struct dhcp6opt_duid_type1 *dp; /* we only support the type1 DUID */
	char tmpbuf[256];	/* DUID should be no more than 256 bytes */

	if ((fp = fopen(idfile, "r")) == NULL && errno != ENOENT)
		dprintf(LOG_NOTICE, FNAME, "failed to open DUID file: %s",
		    idfile);

	if (fp) {
		/* decode length */
		if (fread(&len, sizeof(len), 1, fp) != 1) {
			dprintf(LOG_ERR, FNAME, "DUID file corrupted");
			goto fail;
		}
	} else {
		int l;

		if ((l = gethwid(tmpbuf, sizeof(tmpbuf), NULL, &hwtype)) < 0) {
			dprintf(LOG_INFO, FNAME,
			    "failed to get a hardware address");
			goto fail;
		}
		len = l + sizeof(struct dhcp6opt_duid_type1);
	}

	memset(duid, 0, sizeof(*duid));
	duid->duid_len = len;
	if ((duid->duid_id = (char *)malloc(len)) == NULL) {
		dprintf(LOG_ERR, FNAME, "failed to allocate memory");
		goto fail;
	}

	/* copy (and fill) the ID */
	if (fp) {
		if (fread(duid->duid_id, len, 1, fp) != 1) {
			dprintf(LOG_ERR, FNAME, "DUID file corrupted");
			goto fail;
		}

		dprintf(LOG_DEBUG, FNAME,
		    "extracted an existing DUID from %s: %s",
		    idfile, duidstr(duid));
	} else {
		u_int64_t t64;

		dp = (struct dhcp6opt_duid_type1 *)duid->duid_id;
		dp->dh6_duid1_type = htons(1); /* type 1 */
		dp->dh6_duid1_hwtype = htons(hwtype);
		/* time is Jan 1, 2000 (UTC), modulo 2^32 */
		t64 = (u_int64_t)(time(NULL) - 946684800);
		dp->dh6_duid1_time = htonl((u_long)(t64 & 0xffffffff));
		memcpy((void *)(dp + 1), tmpbuf, (len - sizeof(*dp)));

		dprintf(LOG_DEBUG, FNAME, "generated a new DUID: %s",
		    duidstr(duid));
	}

	/* save the (new) ID to the file for next time */
	if (!fp) {
		if ((fp = fopen(idfile, "w+")) == NULL) {
			dprintf(LOG_ERR, FNAME,
			    "failed to open DUID file for save");
			goto fail;
		}
		if ((fwrite(&len, sizeof(len), 1, fp)) != 1) {
			dprintf(LOG_ERR, FNAME, "failed to save DUID");
			goto fail;
		}
		if ((fwrite(duid->duid_id, len, 1, fp)) != 1) {
			dprintf(LOG_ERR, FNAME, "failed to save DUID");
			goto fail;
		}

		dprintf(LOG_DEBUG, FNAME, "saved generated DUID to %s",
		    idfile);
	}

	if (fp)
		fclose(fp);
	return (0);

  fail:
	if (fp)
		fclose(fp);
	if (duid->duid_id) {
		free(duid->duid_id);
		duid->duid_id = NULL; /* for safety */
	}
	return (-1);
}

#ifdef __sun__
struct hwparms {
	char *buf;
	u_int16_t *hwtypep;
	ssize_t retval;
};

static ssize_t
getifhwaddr(const char *ifname, char *buf, u_int16_t *hwtypep, int ppa)
{
	int fd, flags;
	char fname[MAXPATHLEN], *cp;
	struct strbuf putctl;
	struct strbuf getctl;
	long getbuf[1024];
	dl_info_req_t dlir;
	dl_phys_addr_req_t dlpar;
	dl_phys_addr_ack_t *dlpaa;

	dprintf(LOG_DEBUG, FNAME, "trying %s ppa %d", ifname, ppa);

	if (ifname[0] == '\0')
		return (-1);
	if (ppa >= 0 && !isdigit(ifname[strlen(ifname) - 1]))
		(void) snprintf(fname, sizeof (fname), "/dev/%s%d", ifname,
		    ppa);
	else
		(void) snprintf(fname, sizeof (fname), "/dev/%s", ifname);
	getctl.maxlen = sizeof (getbuf);
	getctl.buf = (char *)getbuf;
	if ((fd = open(fname, O_RDWR)) == -1) {
		dl_attach_req_t dlar;

		cp = fname + strlen(fname) - 1;
		if (!isdigit(*cp))
			return (-1);
		while (cp > fname) {
			if (!isdigit(*cp))
				break;
			cp--;
		}
		if (cp == fname)
			return (-1);
		cp++;
		dlar.dl_ppa = atoi(cp);
		*cp = '\0';
		if ((fd = open(fname, O_RDWR)) == -1)
			return (-1);
		dlar.dl_primitive = DL_ATTACH_REQ;
		putctl.len = sizeof (dlar);
		putctl.buf = (char *)&dlar;
		if (putmsg(fd, &putctl, NULL, 0) == -1) {
			(void) close(fd);
			return (-1);
		}
		flags = 0;
		if (getmsg(fd, &getctl, NULL, &flags) == -1) {
			(void) close(fd);
			return (-1);
		}
		if (getbuf[0] != DL_OK_ACK) {
			(void) close(fd);
			return (-1);
		}
	}
	dlir.dl_primitive = DL_INFO_REQ;
	putctl.len = sizeof (dlir);
	putctl.buf = (char *)&dlir;
	if (putmsg(fd, &putctl, NULL, 0) == -1) {
		(void) close(fd);
		return (-1);
	}
	flags = 0;
	if (getmsg(fd, &getctl, NULL, &flags) == -1) {
		(void) close(fd);
		return (-1);
	}
	if (getbuf[0] != DL_INFO_ACK) {
		(void) close(fd);
		return (-1);
	}
	switch (((dl_info_ack_t *)getbuf)->dl_mac_type) {
	case DL_CSMACD:
	case DL_ETHER:
	case DL_100VG:
	case DL_ETH_CSMA:
	case DL_100BT:
		*hwtypep = ARPHRD_ETHER;
		break;
	default:
		(void) close(fd);
		return (-1);
	}
	dlpar.dl_primitive = DL_PHYS_ADDR_REQ;
	dlpar.dl_addr_type = DL_CURR_PHYS_ADDR;
	putctl.len = sizeof (dlpar);
	putctl.buf = (char *)&dlpar;
	if (putmsg(fd, &putctl, NULL, 0) == -1) {
		(void) close(fd);
		return (-1);
	}
	flags = 0;
	if (getmsg(fd, &getctl, NULL, &flags) == -1) {
		(void) close(fd);
		return (-1);
	}
	if (getbuf[0] != DL_PHYS_ADDR_ACK) {
		(void) close(fd);
		return (-1);
	}
	dlpaa = (dl_phys_addr_ack_t *)getbuf;
	if (dlpaa->dl_addr_length != 6) {
		(void) close(fd);
		return (-1);
	}
	(void) memcpy(buf, (char *)getbuf + dlpaa->dl_addr_offset,
	    dlpaa->dl_addr_length);
	return (dlpaa->dl_addr_length);
}

static int
devfs_handler(di_node_t node, di_minor_t minor, void *arg)
{
	struct hwparms *parms = arg;

	parms->retval = getifhwaddr(di_minor_name(minor), parms->buf,
	    parms->hwtypep, di_instance(node));
	return (parms->retval == -1 ? DI_WALK_CONTINUE : DI_WALK_TERMINATE);
}
#endif

static ssize_t
gethwid(buf, len, ifname, hwtypep)
	char *buf;
	int len;
	const char *ifname;
	u_int16_t *hwtypep;
{
	struct ifaddrs *ifa, *ifap;
#ifdef __KAME__
	struct sockaddr_dl *sdl;
#endif
#ifdef __linux__
	struct sockaddr_ll *sll;
#endif
	ssize_t l;

#ifdef __sun__
	if (ifname == NULL) {
		di_node_t root;
		struct hwparms parms;

		if ((root = di_init("/", DINFOSUBTREE | DINFOMINOR |
		    DINFOPROP)) == DI_NODE_NIL) {
			dprintf(LOG_INFO, FNAME, "di_init failed");
			return (-1);
		}
		parms.buf = buf;
		parms.hwtypep = hwtypep;
		parms.retval = -1;
		(void) di_walk_minor(root, DDI_NT_NET, DI_CHECK_ALIAS, &parms,
		    devfs_handler);
		di_fini(root);
		return (parms.retval);
	} else {
		return (getifhwaddr(ifname, buf, hwtypep, -1));
	}
#endif

	if (getifaddrs(&ifap) < 0)
		return (-1);

	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
		if (ifname && strcmp(ifa->ifa_name, ifname) != 0)
			continue;
		if (ifa->ifa_addr == NULL)
			continue;
#ifdef __KAME__
		if (ifa->ifa_addr->sa_family != AF_LINK)
			continue;

		sdl = (struct sockaddr_dl *)ifa->ifa_addr;
		if (len < 2 + sdl->sdl_alen)
			goto fail;
		/*
		 * translate interface type to hardware type based on
		 * http://www.iana.org/assignments/arp-parameters
		 */
		switch(sdl->sdl_type) {
		case IFT_ETHER:
#ifdef IFT_IEEE80211
		case IFT_IEEE80211:
#endif
			*hwtypep = ARPHRD_ETHER;
			break;
		default:
			continue; /* XXX */
		}
		dprintf(LOG_DEBUG, FNAME, "found an interface %s for DUID",
		    ifa->ifa_name);
		memcpy(buf, LLADDR(sdl), sdl->sdl_alen);
		l = sdl->sdl_alen; /* sdl will soon be freed */
#endif
#ifdef __linux__
		if (ifa->ifa_addr->sa_family != AF_PACKET)
			continue;

		sll = (struct sockaddr_ll *)ifa->ifa_addr;
		if (sll->sll_hatype != ARPHRD_ETHER)
			continue;
		*hwtypep = ARPHRD_ETHER;
		dprintf(LOG_DEBUG, FNAME, "found an interface %s for DUID",
		    ifa->ifa_name);
		memcpy(buf, sll->sll_addr, sll->sll_halen);
		l = sll->sll_halen; /* sll will soon be freed */
#endif
		freeifaddrs(ifap);
		return (l);
	}

  fail:
	freeifaddrs(ifap);
	return (-1);
}

void
dhcp6_init_options(optinfo)
	struct dhcp6_optinfo *optinfo;
{
	memset(optinfo, 0, sizeof(*optinfo));

	optinfo->pref = DH6OPT_PREF_UNDEF;
	optinfo->elapsed_time = DH6OPT_ELAPSED_TIME_UNDEF;
	optinfo->refreshtime = DH6OPT_REFRESHTIME_UNDEF;

	TAILQ_INIT(&optinfo->iapd_list);
	TAILQ_INIT(&optinfo->iana_list);
	TAILQ_INIT(&optinfo->reqopt_list);
	TAILQ_INIT(&optinfo->stcode_list);
	TAILQ_INIT(&optinfo->sip_list);
	TAILQ_INIT(&optinfo->sipname_list);
	TAILQ_INIT(&optinfo->dns_list);
	TAILQ_INIT(&optinfo->dnsname_list);
	TAILQ_INIT(&optinfo->ntp_list);
	TAILQ_INIT(&optinfo->prefix_list);
	TAILQ_INIT(&optinfo->nis_list);
	TAILQ_INIT(&optinfo->nisname_list);
	TAILQ_INIT(&optinfo->nisp_list);
	TAILQ_INIT(&optinfo->nispname_list);
	TAILQ_INIT(&optinfo->bcmcs_list);
	TAILQ_INIT(&optinfo->bcmcsname_list);

	optinfo->authproto = DHCP6_AUTHPROTO_UNDEF;
	optinfo->authalgorithm = DHCP6_AUTHALG_UNDEF;
	optinfo->authrdm = DHCP6_AUTHRDM_UNDEF;
}

void
dhcp6_clear_options(optinfo)
	struct dhcp6_optinfo *optinfo;
{
	switch (optinfo->authproto) {
	case DHCP6_AUTHPROTO_DELAYED:
		if (optinfo->delayedauth_realmval != NULL) {
			free(optinfo->delayedauth_realmval);
		}
		break;
	}

	duidfree(&optinfo->clientID);
	duidfree(&optinfo->serverID);

	dhcp6_clear_list(&optinfo->iapd_list);
	dhcp6_clear_list(&optinfo->iana_list);
	dhcp6_clear_list(&optinfo->reqopt_list);
	dhcp6_clear_list(&optinfo->stcode_list);
	dhcp6_clear_list(&optinfo->sip_list);
	dhcp6_clear_list(&optinfo->sipname_list);
	dhcp6_clear_list(&optinfo->dns_list);
	dhcp6_clear_list(&optinfo->dnsname_list);
	dhcp6_clear_list(&optinfo->ntp_list);
	dhcp6_clear_list(&optinfo->prefix_list);
	dhcp6_clear_list(&optinfo->nis_list);
	dhcp6_clear_list(&optinfo->nisname_list);
	dhcp6_clear_list(&optinfo->nisp_list);
	dhcp6_clear_list(&optinfo->nispname_list);
	dhcp6_clear_list(&optinfo->bcmcs_list);
	dhcp6_clear_list(&optinfo->bcmcsname_list);

	if (optinfo->relaymsg_msg != NULL)
		free(optinfo->relaymsg_msg);

	if (optinfo->ifidopt_id != NULL)
		free(optinfo->ifidopt_id);

	dhcp6_init_options(optinfo);
}

int
dhcp6_copy_options(dst, src)
	struct dhcp6_optinfo *dst, *src;
{
	if (duidcpy(&dst->clientID, &src->clientID))
		goto fail;
	if (duidcpy(&dst->serverID, &src->serverID))
		goto fail;
	dst->rapidcommit = src->rapidcommit;

	if (dhcp6_copy_list(&dst->iapd_list, &src->iapd_list))
		goto fail;
	if (dhcp6_copy_list(&dst->iana_list, &src->iana_list))
		goto fail;
	if (dhcp6_copy_list(&dst->reqopt_list, &src->reqopt_list))
		goto fail;
	if (dhcp6_copy_list(&dst->stcode_list, &src->stcode_list))
		goto fail;
	if (dhcp6_copy_list(&dst->sip_list, &src->sip_list))
		goto fail;
	if (dhcp6_copy_list(&dst->sipname_list, &src->sipname_list))
		goto fail;
	if (dhcp6_copy_list(&dst->dns_list, &src->dns_list))
		goto fail;
	if (dhcp6_copy_list(&dst->dnsname_list, &src->dnsname_list))
		goto fail;
	if (dhcp6_copy_list(&dst->ntp_list, &src->ntp_list))
		goto fail;
	if (dhcp6_copy_list(&dst->prefix_list, &src->prefix_list))
		goto fail;
	if (dhcp6_copy_list(&dst->nis_list, &src->nis_list))
		goto fail;
	if (dhcp6_copy_list(&dst->nisname_list, &src->nisname_list))
		goto fail;
	if (dhcp6_copy_list(&dst->nisp_list, &src->nisp_list))
		goto fail;
	if (dhcp6_copy_list(&dst->nispname_list, &src->nispname_list))
		goto fail;
	if (dhcp6_copy_list(&dst->bcmcs_list, &src->bcmcs_list))
		goto fail;
	if (dhcp6_copy_list(&dst->bcmcsname_list, &src->bcmcsname_list))
		goto fail;
	dst->elapsed_time = src->elapsed_time;
	dst->refreshtime = src->refreshtime;
	dst->pref = src->pref;

	if (src->relaymsg_msg != NULL) {
		if ((dst->relaymsg_msg = malloc(src->relaymsg_len)) == NULL)
			goto fail;
		dst->relaymsg_len = src->relaymsg_len;
		memcpy(dst->relaymsg_msg, src->relaymsg_msg,
		    src->relaymsg_len);
	}

	if (src->ifidopt_id != NULL) {
		if ((dst->ifidopt_id = malloc(src->ifidopt_len)) == NULL)
			goto fail;
		dst->ifidopt_len = src->ifidopt_len;
		memcpy(dst->ifidopt_id, src->ifidopt_id, src->ifidopt_len);
	}

	dst->authflags = src->authflags;
	dst->authproto = src->authproto;
	dst->authalgorithm = src->authalgorithm;
	dst->authrdm = src->authrdm;
	dst->authrd = src->authrd;

	switch (src->authproto) {
	case DHCP6_AUTHPROTO_DELAYED:
		dst->delayedauth_keyid = src->delayedauth_keyid;
		dst->delayedauth_offset = src->delayedauth_offset;
		dst->delayedauth_realmlen = src->delayedauth_realmlen;
		if (src->delayedauth_realmval != NULL) {
			if ((dst->delayedauth_realmval =
			    malloc(src->delayedauth_realmlen)) == NULL) {
				goto fail;
			}
			memcpy(dst->delayedauth_realmval,
			    src->delayedauth_realmval,
			    src->delayedauth_realmlen);
		}
		break;
	case DHCP6_AUTHPROTO_RECONFIG:
		dst->reconfigauth_type = src->reconfigauth_type;
		dst->reconfigauth_offset = src->reconfigauth_offset;
		memcpy(dst->reconfigauth_val, src->reconfigauth_val,
		    sizeof(dst->reconfigauth_val));
		break;
	}

	return (0);

  fail:
	/* cleanup temporary resources */
	dhcp6_clear_options(dst);
	return (-1);
}

int
dhcp6_get_options(p, ep, optinfo)
	struct dhcp6opt *p, *ep;
	struct dhcp6_optinfo *optinfo;
{
	struct dhcp6opt *np, opth;
	int i, opt, optlen, reqopts, num;
	u_int16_t num16;
	char *bp, *cp, *val;
	u_int16_t val16;
	u_int32_t val32;
	struct dhcp6opt_ia optia;
	struct dhcp6_ia ia;
	struct dhcp6_list sublist;
	int authinfolen;

	bp = (char *)p;
	for (; p + 1 <= ep; p = np) {
		struct duid duid0;

		/*
		 * get the option header.  XXX: since there is no guarantee
		 * about the header alignment, we need to make a local copy.
		 */
		memcpy(&opth, p, sizeof(opth));
		optlen = ntohs(opth.dh6opt_len);
		opt = ntohs(opth.dh6opt_type);

		cp = (char *)(p + 1);
		np = (struct dhcp6opt *)(cp + optlen);

		dprintf(LOG_DEBUG, FNAME, "get DHCP option %s, len %d",
		    dhcp6optstr(opt), optlen);

		/* option length field overrun */
		if (np > ep) {
			dprintf(LOG_INFO, FNAME, "malformed DHCP options");
			goto fail;
		}

		switch (opt) {
		case DH6OPT_CLIENTID:
			if (optlen == 0)
				goto malformed;
			duid0.duid_len = optlen;
			duid0.duid_id = cp;
			dprintf(LOG_DEBUG, "",
				"  DUID: %s", duidstr(&duid0));
			if (duidcpy(&optinfo->clientID, &duid0)) {
				dprintf(LOG_ERR, FNAME, "failed to copy DUID");
				goto fail;
			}
			break;
		case DH6OPT_SERVERID:
			if (optlen == 0)
				goto malformed;
			duid0.duid_len = optlen;
			duid0.duid_id = cp;
			dprintf(LOG_DEBUG, "", "  DUID: %s", duidstr(&duid0));
			if (duidcpy(&optinfo->serverID, &duid0)) {
				dprintf(LOG_ERR, FNAME, "failed to copy DUID");
				goto fail;
			}
			break;
		case DH6OPT_STATUS_CODE:
			if (optlen < sizeof(u_int16_t))
				goto malformed;
			memcpy(&val16, cp, sizeof(val16));
			num16 = ntohs(val16);
			dprintf(LOG_DEBUG, "", "  status code: %s",
			    dhcp6_stcodestr(num16));

			/* need to check duplication? */

			if (dhcp6_add_listval(&optinfo->stcode_list,
			    DHCP6_LISTVAL_STCODE, &num16, NULL) == NULL) {
				dprintf(LOG_ERR, FNAME, "failed to copy "
				    "status code");
				goto fail;
			}

			break;
		case DH6OPT_ORO:
			if ((optlen % 2) != 0 || optlen == 0)
				goto malformed;
			reqopts = optlen / 2;
			for (i = 0, val = cp; i < reqopts;
			     i++, val += sizeof(u_int16_t)) {
				u_int16_t opttype;

				memcpy(&opttype, val, sizeof(u_int16_t));
				num = (int)ntohs(opttype);

				dprintf(LOG_DEBUG, "",
					"  requested option: %s",
					dhcp6optstr(num));

				if (dhcp6_find_listval(&optinfo->reqopt_list,
				    DHCP6_LISTVAL_NUM, &num, 0)) {
					dprintf(LOG_INFO, FNAME, "duplicated "
					    "option type (%s)",
					    dhcp6optstr(opttype));
					goto nextoption;
				}

				if (dhcp6_add_listval(&optinfo->reqopt_list,
				    DHCP6_LISTVAL_NUM, &num, NULL) == NULL) {
					dprintf(LOG_ERR, FNAME,
					    "failed to copy requested option");
					goto fail;
				}
			  nextoption:
				;
			}
			break;
		case DH6OPT_PREFERENCE:
			if (optlen != 1)
				goto malformed;
			dprintf(LOG_DEBUG, "", "  preference: %d",
			    (int)*(u_char *)cp);
			if (optinfo->pref != DH6OPT_PREF_UNDEF) {
				dprintf(LOG_INFO, FNAME,
				    "duplicated preference option");
			} else
				optinfo->pref = (int)*(u_char *)cp;
			break;
		case DH6OPT_ELAPSED_TIME:
			if (optlen != 2)
				goto malformed;
			memcpy(&val16, cp, sizeof(val16));
			val16 = ntohs(val16);
			dprintf(LOG_DEBUG, "", "  elapsed time: %lu",
			    (u_int32_t)val16);
			if (optinfo->elapsed_time !=
			    DH6OPT_ELAPSED_TIME_UNDEF) {
				dprintf(LOG_INFO, FNAME,
				    "duplicated elapsed time option");
			} else
				optinfo->elapsed_time = val16;
			break;
		case DH6OPT_RELAY_MSG:
			if ((optinfo->relaymsg_msg = malloc(optlen)) == NULL)
				goto fail;
			memcpy(optinfo->relaymsg_msg, cp, optlen);
			optinfo->relaymsg_len = optlen;
			break;
		case DH6OPT_AUTH:
			if (optlen < sizeof(struct dhcp6opt_auth) - 4)
				goto malformed;

			/*
			 * Any DHCP message that includes more than one
			 * authentication option MUST be discarded.
			 * [RFC3315 Section 21.4.2]
			 */
			if (optinfo->authproto != DHCP6_AUTHPROTO_UNDEF) {
				dprintf(LOG_INFO, FNAME, "found more than one "
				    "authentication option");
				goto fail;
			}

			optinfo->authproto = *cp++;
			optinfo->authalgorithm = *cp++;
			optinfo->authrdm = *cp++;
			memcpy(&optinfo->authrd, cp, sizeof(optinfo->authrd));
			cp += sizeof(optinfo->authrd);

			dprintf(LOG_DEBUG, "", "  %s", sprint_auth(optinfo));

			authinfolen =
			    optlen - (sizeof(struct dhcp6opt_auth) - 4);
			switch (optinfo->authproto) {
			case DHCP6_AUTHPROTO_DELAYED:
				if (authinfolen == 0) {
					optinfo->authflags |=
					    DHCP6OPT_AUTHFLAG_NOINFO;
					break;
				}
				/* XXX: should we reject an empty realm? */
				if (authinfolen <
				    sizeof(optinfo->delayedauth_keyid) + 16) {
					goto malformed;
				}

				optinfo->delayedauth_realmlen = authinfolen -
				    (sizeof(optinfo->delayedauth_keyid) + 16);
				optinfo->delayedauth_realmval =
				    malloc(optinfo->delayedauth_realmlen);
				if (optinfo->delayedauth_realmval == NULL) {
					dprintf(LOG_WARNING, FNAME, "failed "
					    "allocate memory for auth realm");
					goto fail;
				}
				memcpy(optinfo->delayedauth_realmval, cp,
				    optinfo->delayedauth_realmlen);
				cp += optinfo->delayedauth_realmlen;

				memcpy(&optinfo->delayedauth_keyid, cp,
				    sizeof(optinfo->delayedauth_keyid));
				optinfo->delayedauth_keyid =
				    ntohl(optinfo->delayedauth_keyid);
				cp += sizeof(optinfo->delayedauth_keyid);

				optinfo->delayedauth_offset = cp - bp;
				cp += 16;

				dprintf(LOG_DEBUG, "", "  auth key ID: %x, "
				    "offset=%d, realmlen=%d",
				    optinfo->delayedauth_keyid,
				    optinfo->delayedauth_offset,
				    optinfo->delayedauth_realmlen);
				break;
#ifdef notyet
			case DHCP6_AUTHPROTO_RECONFIG:
				break;
#endif
			default:
				dprintf(LOG_INFO, FNAME,
				    "unsupported authentication protocol: %d",
				    *cp);
				goto fail;
			}
			break;
		case DH6OPT_RAPID_COMMIT:
			if (optlen != 0)
				goto malformed;
			optinfo->rapidcommit = 1;
			break;
		case DH6OPT_INTERFACE_ID:
			if ((optinfo->ifidopt_id = malloc(optlen)) == NULL)
				goto fail;
			memcpy(optinfo->ifidopt_id, cp, optlen);
			optinfo->ifidopt_len = optlen;
			break;
		case DH6OPT_SIP_SERVER_D:
			if (dhcp6_get_domain(optlen, cp, opt,
			    &optinfo->sipname_list) == -1)
				goto fail;
			break;
		case DH6OPT_DNSNAME:
			if (dhcp6_get_domain(optlen, cp, opt,
			    &optinfo->dnsname_list) == -1)
				goto fail;
			break;
		case DH6OPT_NIS_DOMAIN_NAME:
			if (dhcp6_get_domain(optlen, cp, opt,
			    &optinfo->nisname_list) == -1)
				goto fail;
			break;
		case DH6OPT_NISP_DOMAIN_NAME:
			if (dhcp6_get_domain(optlen, cp, opt,
			    &optinfo->nispname_list) == -1)
				goto fail;
			break;
		case DH6OPT_BCMCS_SERVER_D:
			if (dhcp6_get_domain(optlen, cp, opt,
			    &optinfo->bcmcsname_list) == -1)
				goto fail;
			break;
		case DH6OPT_SIP_SERVER_A:
			if (dhcp6_get_addr(optlen, cp, opt,
			    &optinfo->sip_list) == -1)
				goto fail;
			break;
		case DH6OPT_DNS:
			if (dhcp6_get_addr(optlen, cp, opt,
			    &optinfo->dns_list) == -1)
				goto fail;
			break;
		case DH6OPT_NIS_SERVERS:
			if (dhcp6_get_addr(optlen, cp, opt,
			    &optinfo->nis_list) == -1)
				goto fail;
			break;
		case DH6OPT_NISP_SERVERS:
			if (dhcp6_get_addr(optlen, cp, opt,
			    &optinfo->nisp_list) == -1)
				goto fail;
			break;
		case DH6OPT_BCMCS_SERVER_A:
			if (dhcp6_get_addr(optlen, cp, opt,
			    &optinfo->bcmcs_list) == -1)
				goto fail;
			break;
		case DH6OPT_NTP:
			if (dhcp6_get_addr(optlen, cp, opt,
			    &optinfo->ntp_list) == -1)
				goto fail;
			break;
		case DH6OPT_IA_PD:
			if (optlen + sizeof(struct dhcp6opt) <
			    sizeof(optia))
				goto malformed;
			memcpy(&optia, p, sizeof(optia));
			ia.iaid = ntohl(optia.dh6_ia_iaid);
			ia.t1 = ntohl(optia.dh6_ia_t1);
			ia.t2 = ntohl(optia.dh6_ia_t2);

			dprintf(LOG_DEBUG, "",
			    "  IA_PD: ID=%lu, T1=%lu, T2=%lu",
			    ia.iaid, ia.t1, ia.t2);

			/* duplication check */
			if (dhcp6_find_listval(&optinfo->iapd_list,
			    DHCP6_LISTVAL_IAPD, &ia, 0)) {
				dprintf(LOG_INFO, FNAME,
				    "duplicated IA_PD %lu", ia.iaid);
				break; /* ignore this IA_PD */
			}

			/* take care of sub-options */
			TAILQ_INIT(&sublist);
			if (copyin_option(opt,
			    (struct dhcp6opt *)((char *)p + sizeof(optia)),
			    (struct dhcp6opt *)(cp + optlen), &sublist)) {
				goto fail;
			}

			/* link this option set */
			if (dhcp6_add_listval(&optinfo->iapd_list,
			    DHCP6_LISTVAL_IAPD, &ia, &sublist) == NULL) {
				dhcp6_clear_list(&sublist);
				goto fail;
			}
			dhcp6_clear_list(&sublist);

			break;
		case DH6OPT_REFRESHTIME:
			if (optlen != 4)
				goto malformed;
			memcpy(&val32, cp, sizeof(val32));
			val32 = ntohl(val32);
			dprintf(LOG_DEBUG, "",
			    "   information refresh time: %lu", val32);
			if (val32 < DHCP6_IRT_MINIMUM) {
				/*
				 * A client MUST use the refresh time
				 * IRT_MINIMUM if it receives the option with a
				 * value less than IRT_MINIMUM.
				 * [draft-ietf-dhc-lifetime-02.txt,
				 *  Section 3.2]
				 */
				dprintf(LOG_INFO, FNAME,
				    "refresh time is too small (%d), adjusted",
				    val32);
				val32 = DHCP6_IRT_MINIMUM;
			}
			if (optinfo->refreshtime != DH6OPT_REFRESHTIME_UNDEF) {
				dprintf(LOG_INFO, FNAME,
				    "duplicated refresh time option");
			} else
				optinfo->refreshtime = (int64_t)val32;
			break;
		case DH6OPT_IA_NA:
			if (optlen + sizeof(struct dhcp6opt) <
			    sizeof(optia))
				goto malformed;
			memcpy(&optia, p, sizeof(optia));
			ia.iaid = ntohl(optia.dh6_ia_iaid);
			ia.t1 = ntohl(optia.dh6_ia_t1);
			ia.t2 = ntohl(optia.dh6_ia_t2);

			dprintf(LOG_DEBUG, "",
			    "  IA_NA: ID=%lu, T1=%lu, T2=%lu",
			    ia.iaid, ia.t1, ia.t2);

			/* duplication check */
			if (dhcp6_find_listval(&optinfo->iana_list,
			    DHCP6_LISTVAL_IANA, &ia, 0)) {
				dprintf(LOG_INFO, FNAME,
				    "duplicated IA_NA %lu", ia.iaid);
				break; /* ignore this IA_NA */
			}

			/* take care of sub-options */
			TAILQ_INIT(&sublist);
			if (copyin_option(opt,
			    (struct dhcp6opt *)((char *)p + sizeof(optia)),
			    (struct dhcp6opt *)(cp + optlen), &sublist)) {
				goto fail;
			}

			/* link this option set */
			if (dhcp6_add_listval(&optinfo->iana_list,
			    DHCP6_LISTVAL_IANA, &ia, &sublist) == NULL) {
				dhcp6_clear_list(&sublist);
				goto fail;
			}
			dhcp6_clear_list(&sublist);

			break;
		default:
			/* no option specific behavior */
			dprintf(LOG_INFO, FNAME,
			    "unknown or unexpected DHCP6 option %s, len %d",
			    dhcp6optstr(opt), optlen);
			break;
		}
	}

	return (0);

  malformed:
	dprintf(LOG_INFO, FNAME, "malformed DHCP option: type %d, len %d",
	    opt, optlen);
  fail:
	dhcp6_clear_options(optinfo);
	return (-1);
}

static char *
dnsdecode(sp, ep, buf, bufsiz)
	u_char **sp;
	u_char *ep;
	char *buf;
	size_t bufsiz;
{
	int i, l;
	u_char *cp;
	char tmpbuf[MAXDNAME + 1];

	cp = *sp;
	*buf = '\0';
	i = 0;			/* XXX: appease gcc */

	if (cp >= ep)
		return (NULL);
	while (cp < ep) {
		i = *cp;
		if (i == 0 || cp != *sp) {
			if (strlcat((char *)buf, ".", bufsiz) >= bufsiz)
				return (NULL);	/* result overrun */
		}
		if (i == 0)
			break;
		cp++;

		if (i > 0x3f)
			return (NULL); /* invalid label */

		if (i > ep - cp)
			return (NULL); /* source overrun */
		while (i-- > 0 && cp < ep) {
			if (!isprint(*cp)) /* we don't accept non-printables */
				return (NULL);
			l = snprintf(tmpbuf, sizeof(tmpbuf), "%c" , *cp);
			if (l >= sizeof(tmpbuf) || l < 0)
				return (NULL);
			if (strlcat(buf, tmpbuf, bufsiz) >= bufsiz)
				return (NULL); /* result overrun */
			cp++;
		}
	}
	if (i != 0)
		return (NULL);	/* not terminated */
	cp++;
	*sp = cp;
	return (buf);
}

static int
copyin_option(type, p, ep, list)
	int type;
	struct dhcp6opt *p, *ep;
	struct dhcp6_list *list;
{
	int opt, optlen;
	char *cp;
	struct dhcp6opt *np, opth;
	struct dhcp6opt_stcode opt_stcode;
	struct dhcp6opt_ia_pd_prefix opt_iapd_prefix;
	struct dhcp6_prefix iapd_prefix;
	struct dhcp6opt_ia_addr opt_ia_addr;
	struct dhcp6_prefix ia_addr;
	struct dhcp6_list sublist;

	TAILQ_INIT(&sublist);

	for (; p + 1 <= ep; p = np) {
		memcpy(&opth, p, sizeof(opth));
		optlen = ntohs(opth.dh6opt_len);
		opt = ntohs(opth.dh6opt_type);

		cp = (char *)(p + 1);
		np = (struct dhcp6opt *)(cp + optlen);

		dprintf(LOG_DEBUG, FNAME, "get DHCP option %s, len %d",
		    dhcp6optstr(opt), optlen);

		if (np > ep) {
			dprintf(LOG_INFO, FNAME, "malformed DHCP option");
			goto fail;
		}

		switch (opt) {
		case DH6OPT_IA_PD_PREFIX:
			/* check option context */
			if (type != DH6OPT_IA_PD) {
				dprintf(LOG_INFO, FNAME,
				    "%s is an invalid position for %s",
				    dhcp6optstr(type), dhcp6optstr(opt));
				goto fail;
			}
			/* check option length */
			if (optlen + sizeof(opth) < sizeof(opt_iapd_prefix))
				goto malformed;

			/* copy and convert option values */
			memcpy(&opt_iapd_prefix, p, sizeof(opt_iapd_prefix));
			if (opt_iapd_prefix.dh6_iapd_prefix_prefix_len > 128) {
				dprintf(LOG_INFO, FNAME,
				    "invalid prefix length (%d)",
				    opt_iapd_prefix.dh6_iapd_prefix_prefix_len);
				goto malformed;
			}
			iapd_prefix.pltime = ntohl(opt_iapd_prefix.dh6_iapd_prefix_preferred_time);
			iapd_prefix.vltime = ntohl(opt_iapd_prefix.dh6_iapd_prefix_valid_time);
			iapd_prefix.plen =
			    opt_iapd_prefix.dh6_iapd_prefix_prefix_len;
			memcpy(&iapd_prefix.addr,
			    &opt_iapd_prefix.dh6_iapd_prefix_prefix_addr,
			    sizeof(iapd_prefix.addr));
			/* clear padding bits in the prefix address */
			prefix6_mask(&iapd_prefix.addr, iapd_prefix.plen);

			dprintf(LOG_DEBUG, FNAME, "  IA_PD prefix: "
			    "%s/%d pltime=%lu vltime=%lu",
			    in6addr2str(&iapd_prefix.addr, 0),
			    iapd_prefix.plen,
			    iapd_prefix.pltime, iapd_prefix.vltime);

			if (dhcp6_find_listval(list, DHCP6_LISTVAL_PREFIX6,
			    &iapd_prefix, 0)) {
				dprintf(LOG_INFO, FNAME, 
				    "duplicated IA_PD prefix "
				    "%s/%d pltime=%lu vltime=%lu",
				    in6addr2str(&iapd_prefix.addr, 0),
				    iapd_prefix.plen,
				    iapd_prefix.pltime, iapd_prefix.vltime);
				goto nextoption;
			}

			/* take care of sub-options */
			TAILQ_INIT(&sublist);
			if (copyin_option(opt,
			    (struct dhcp6opt *)((char *)p +
			    sizeof(opt_iapd_prefix)), np, &sublist)) {
				goto fail;
			}

			if (dhcp6_add_listval(list, DHCP6_LISTVAL_PREFIX6,
			    &iapd_prefix, &sublist) == NULL) {
				dhcp6_clear_list(&sublist);
				goto fail;
			}
			dhcp6_clear_list(&sublist);
			break;
		case DH6OPT_IAADDR:
			/* check option context */
			if (type != DH6OPT_IA_NA) {
				dprintf(LOG_INFO, FNAME,
				    "%s is an invalid position for %s",
				    dhcp6optstr(type), dhcp6optstr(opt));
				goto fail;
			}
			/* check option length */
			if (optlen + sizeof(opth) < sizeof(opt_ia_addr))
				goto malformed;

			/* copy and convert option values */
			memcpy(&opt_ia_addr, p, sizeof(opt_ia_addr));
			ia_addr.pltime = ntohl(opt_ia_addr.dh6_ia_addr_preferred_time);
			ia_addr.vltime = ntohl(opt_ia_addr.dh6_ia_addr_valid_time);
			memcpy(&ia_addr.addr, &opt_ia_addr.dh6_ia_addr_addr,
			    sizeof(ia_addr.addr));

			dprintf(LOG_DEBUG, FNAME, "  IA_NA address: "
			    "%s pltime=%lu vltime=%lu",
			    in6addr2str(&ia_addr.addr, 0),
			    ia_addr.pltime, ia_addr.vltime);

			if (dhcp6_find_listval(list,
			    DHCP6_LISTVAL_STATEFULADDR6, &ia_addr, 0)) {
				dprintf(LOG_INFO, FNAME, 
				    "duplicated IA_NA address"
				    "%s pltime=%lu vltime=%lu",
				    in6addr2str(&ia_addr.addr, 0),
				    ia_addr.pltime, ia_addr.vltime);
				goto nextoption;
			}

			/* take care of sub-options */
			TAILQ_INIT(&sublist);
			if (copyin_option(opt,
			    (struct dhcp6opt *)((char *)p +
			    sizeof(opt_ia_addr)), np, &sublist)) {
				goto fail;
			}

			if (dhcp6_add_listval(list, DHCP6_LISTVAL_STATEFULADDR6,
			    &ia_addr, &sublist) == NULL) {
				dhcp6_clear_list(&sublist);
				goto fail;
			}
			dhcp6_clear_list(&sublist);
			break;
		case DH6OPT_STATUS_CODE:
			/* check option context */
			if (type != DH6OPT_IA_PD &&
			    type != DH6OPT_IA_PD_PREFIX &&
			    type != DH6OPT_IA_NA &&
			    type != DH6OPT_IAADDR) {
				dprintf(LOG_INFO, FNAME,
				    "%s is an invalid position for %s",
				    dhcp6optstr(type), dhcp6optstr(opt));
				goto nextoption; /* or discard the message? */
			}
			/* check option length */
			if (optlen + sizeof(opth) < sizeof(opt_stcode))
				goto malformed;

			/* copy and convert option values */
			memcpy(&opt_stcode, p, sizeof(opt_stcode));
			opt_stcode.dh6_stcode_code =
			    ntohs(opt_stcode.dh6_stcode_code);

			dprintf(LOG_DEBUG, "", "  status code: %s",
			    dhcp6_stcodestr(opt_stcode.dh6_stcode_code));

			/* duplication check */
			if (dhcp6_find_listval(list, DHCP6_LISTVAL_STCODE,
			    &opt_stcode.dh6_stcode_code, 0)) {
				dprintf(LOG_INFO, FNAME,
				    "duplicated status code (%d)",
				    opt_stcode.dh6_stcode_code);
				goto nextoption;
			}

			/* copy-in the code value */
			if (dhcp6_add_listval(list, DHCP6_LISTVAL_STCODE,
			    &opt_stcode.dh6_stcode_code, NULL) == NULL)
				goto fail;

			break;
		}
	  nextoption:
		;
	}

	return (0);

  malformed:
	dprintf(LOG_INFO, "", "  malformed DHCP option: type %d", opt);

  fail:
	dhcp6_clear_list(&sublist);
	return (-1);
}

static char *
sprint_uint64(buf, buflen, i64)
	char *buf;
	int buflen;
	u_int64_t i64;
{
	u_int16_t rd0, rd1, rd2, rd3;
	u_int16_t *ptr = (u_int16_t *)(void *)&i64;

	rd0 = ntohs(*ptr++);
	rd1 = ntohs(*ptr++);
	rd2 = ntohs(*ptr++);
	rd3 = ntohs(*ptr);

	snprintf(buf, buflen, "%04x %04x %04x %04x", rd0, rd1, rd2, rd3);

	return (buf);
}

static char *
sprint_auth(optinfo)
	struct dhcp6_optinfo *optinfo;
{
	static char ret[1024];	/* XXX: thread unsafe */
	char *proto, proto0[] = "unknown(255)";
	char *alg, alg0[] = "unknown(255)";
	char *rdm, rdm0[] = "unknown(255)";
	char rd[] = "ffff ffff ffff ffff";

	switch (optinfo->authproto) {
	case DHCP6_AUTHPROTO_DELAYED:
		proto = "delayed";
		break;
	case DHCP6_AUTHPROTO_RECONFIG:
		proto = "reconfig";
		break;
	default:
		snprintf(proto0, sizeof(proto0), "unknown(%d)",
		    optinfo->authproto & 0xff);
		proto = proto0;
		break;
	}

	switch (optinfo->authalgorithm) {
	case DHCP6_AUTHALG_HMACMD5:
		alg = "HMAC-MD5";
		break;
	default:
		snprintf(alg0, sizeof(alg0), "unknown(%d)",
		    optinfo->authalgorithm & 0xff);
		alg = alg0;
		break;
	}

	switch (optinfo->authrdm) {
	case DHCP6_AUTHRDM_MONOCOUNTER:
		rdm = "mono counter";
		break;
	default:
		snprintf(rdm0, sizeof(rdm0), "unknown(%d)", optinfo->authrdm);
		rdm = rdm0;
	}

	(void)sprint_uint64(rd, sizeof(rd), optinfo->authrd);

	snprintf(ret, sizeof(ret), "proto: %s, alg: %s, RDM: %s, RD: %s",
	    proto, alg, rdm, rd);

	return (ret);
}

static int
copy_option(type, len, val, optp, ep, totallenp)
	u_int16_t type, len;
	void *val;
	struct dhcp6opt **optp, *ep;
	int *totallenp;
{
	struct dhcp6opt *opt = *optp, opth;

	if ((void *)ep - (void *)optp < len + sizeof(struct dhcp6opt)) {
		dprintf(LOG_INFO, FNAME,
		    "option buffer short for %s", dhcp6optstr(type));
		return (-1);
	}
	opth.dh6opt_type = htons(type);
	opth.dh6opt_len = htons(len);
	memcpy(opt, &opth, sizeof(opth));
	if (len != 0)
		memcpy(opt + 1, val, len);

	*optp = (struct dhcp6opt *)((char *)(opt + 1) + len);
 	*totallenp += sizeof(struct dhcp6opt) + len;
	dprintf(LOG_DEBUG, FNAME, "set %s (len %d)", dhcp6optstr(type), len);

	return (0);
}

int
dhcp6_set_options(type, optbp, optep, optinfo)
	int type;
	struct dhcp6opt *optbp, *optep;
	struct dhcp6_optinfo *optinfo;
{
	struct dhcp6opt *p = optbp;
	struct dhcp6_listval *stcode, *op;
	int len = 0, optlen;
	char *tmpbuf = NULL;

	if (optinfo->clientID.duid_len) {
		if (copy_option(DH6OPT_CLIENTID, optinfo->clientID.duid_len,
		    optinfo->clientID.duid_id, &p, optep, &len) != 0) {
			goto fail;
		}
	}

	if (optinfo->serverID.duid_len) {
		if (copy_option(DH6OPT_SERVERID, optinfo->serverID.duid_len,
		    optinfo->serverID.duid_id, &p, optep, &len) != 0) {
			goto fail;
		}
	}

	for (op = TAILQ_FIRST(&optinfo->iana_list); op;
	    op = TAILQ_NEXT(op, link)) {
		int optlen;

		tmpbuf = NULL;
		if ((optlen = copyout_option(NULL, NULL, op)) < 0) {
			dprintf(LOG_INFO, FNAME,
			    "failed to count option length");
			goto fail;
		}
		if ((void *)optep - (void *)p < optlen) {
			dprintf(LOG_INFO, FNAME, "short buffer");
			goto fail;
		}
		if ((tmpbuf = malloc(optlen)) == NULL) {
			dprintf(LOG_NOTICE, FNAME,
			    "memory allocation failed for IA_NA options");
			goto fail;
		}
		if (copyout_option(tmpbuf, tmpbuf + optlen, op) < 0) {
			dprintf(LOG_ERR, FNAME,
			    "failed to construct an IA_NA option");
			goto fail;
		}
		memcpy(p, tmpbuf, optlen);
		free(tmpbuf);
		tmpbuf = NULL;
		p = (struct dhcp6opt *)((char *)p + optlen);
		len += optlen;
	}

	if (optinfo->rapidcommit) {
		if (copy_option(DH6OPT_RAPID_COMMIT, 0, NULL, &p,
		    optep, &len) != 0) {
			goto fail;
		}
	}

	if (optinfo->pref != DH6OPT_PREF_UNDEF) {
		u_int8_t p8 = (u_int8_t)optinfo->pref;

		if (copy_option(DH6OPT_PREFERENCE, sizeof(p8), &p8, &p,
		    optep, &len) != 0) {
			goto fail;
		}
	}

	if (optinfo->elapsed_time != DH6OPT_ELAPSED_TIME_UNDEF) {
		u_int16_t p16 = (u_int16_t)optinfo->elapsed_time;

		p16 = htons(p16);
		if (copy_option(DH6OPT_ELAPSED_TIME, sizeof(p16), &p16, &p,
		    optep, &len) != 0) {
			goto fail;
		}
	}

	for (stcode = TAILQ_FIRST(&optinfo->stcode_list); stcode;
	     stcode = TAILQ_NEXT(stcode, link)) {
		u_int16_t code;

		code = htons(stcode->val_num16);
		if (copy_option(DH6OPT_STATUS_CODE, sizeof(code), &code, &p,
		    optep, &len) != 0) {
			goto fail;
		}
	}

	if (!TAILQ_EMPTY(&optinfo->reqopt_list)) {
		struct dhcp6_listval *opt;
		u_int16_t *valp;
		int buflen;

		tmpbuf = NULL;
		buflen = dhcp6_count_list(&optinfo->reqopt_list) *
			sizeof(u_int16_t);
		if ((tmpbuf = malloc(buflen)) == NULL) {
			dprintf(LOG_ERR, FNAME,
			    "memory allocation failed for options");
			goto fail;
		}
		optlen = 0;
		valp = (u_int16_t *)tmpbuf;
		for (opt = TAILQ_FIRST(&optinfo->reqopt_list); opt;
		     opt = TAILQ_NEXT(opt, link)) {
			/*
			 * Information request option can only be specified
			 * in information-request messages.
			 * [draft-ietf-dhc-lifetime-02.txt, Section 3.2]
			 */
			if (opt->val_num == DH6OPT_REFRESHTIME &&
			    type != DH6_INFORM_REQ) {
				dprintf(LOG_DEBUG, FNAME,
				    "refresh time option is not requested "
				    "for %s", dhcp6msgstr(type));
			}

			*valp = htons((u_int16_t)opt->val_num);
			valp++;
			optlen += sizeof(u_int16_t);
		}
		if (optlen > 0 &&
		    copy_option(DH6OPT_ORO, optlen, tmpbuf, &p,
		    optep, &len) != 0) {
			goto fail;
		}
		free(tmpbuf);
		tmpbuf = NULL;
	}

	if (dhcp6_set_domain(DH6OPT_SIP_SERVER_D, &optinfo->sipname_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_addr(DH6OPT_SIP_SERVER_A, &optinfo->sip_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_addr(DH6OPT_DNS, &optinfo->dns_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_domain(DH6OPT_DNSNAME, &optinfo->dnsname_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_addr(DH6OPT_NIS_SERVERS, &optinfo->nis_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_addr(DH6OPT_NISP_SERVERS, &optinfo->nisp_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_domain(DH6OPT_NIS_DOMAIN_NAME, &optinfo->nisname_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_domain(DH6OPT_NISP_DOMAIN_NAME, &optinfo->nispname_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_addr(DH6OPT_NTP, &optinfo->ntp_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_domain(DH6OPT_BCMCS_SERVER_D, &optinfo->bcmcsname_list,
	    &p, optep, &len) != 0)
		goto fail;

	if (dhcp6_set_addr(DH6OPT_BCMCS_SERVER_A, &optinfo->bcmcs_list,
	    &p, optep, &len) != 0)
		goto fail;

	for (op = TAILQ_FIRST(&optinfo->iapd_list); op;
	    op = TAILQ_NEXT(op, link)) {
		int optlen;

		tmpbuf = NULL;
		if ((optlen = copyout_option(NULL, NULL, op)) < 0) {
			dprintf(LOG_INFO, FNAME,
			    "failed to count option length");
			goto fail;
		}
		if ((void *)optep - (void *)p < optlen) {
			dprintf(LOG_INFO, FNAME, "short buffer");
			goto fail;
		}
		if ((tmpbuf = malloc(optlen)) == NULL) {
			dprintf(LOG_NOTICE, FNAME,
			    "memory allocation failed for IA_PD options");
			goto fail;
		}
		if (copyout_option(tmpbuf, tmpbuf + optlen, op) < 0) {
			dprintf(LOG_ERR, FNAME,
			    "failed to construct an IA_PD option");
			goto fail;
		}
		memcpy(p, tmpbuf, optlen);
		free(tmpbuf);
		tmpbuf = NULL;
		p = (struct dhcp6opt *)((char *)p + optlen);
		len += optlen;
	}

	if (optinfo->relaymsg_len) {
		if (copy_option(DH6OPT_RELAY_MSG, optinfo->relaymsg_len,
		    optinfo->relaymsg_msg, &p, optep, &len) != 0) {
			goto fail;
		}
	}

	if (optinfo->ifidopt_id) {
		if (copy_option(DH6OPT_INTERFACE_ID, optinfo->ifidopt_len,
		    optinfo->ifidopt_id, &p, optep, &len) != 0) {
			goto fail;
		}
	}

	if (optinfo->refreshtime != DH6OPT_REFRESHTIME_UNDEF) {
		u_int32_t p32 = (u_int32_t)optinfo->refreshtime;

		p32 = htonl(p32);
		if (copy_option(DH6OPT_REFRESHTIME, sizeof(p32), &p32, &p,
		    optep, &len) != 0) {
			goto fail;
		}
	}

	if (optinfo->authproto != DHCP6_AUTHPROTO_UNDEF) {
		struct dhcp6opt_auth *auth;
		int authlen;
		char *authinfo;

		authlen = sizeof(*auth);
		if (!(optinfo->authflags & DHCP6OPT_AUTHFLAG_NOINFO)) {
			switch (optinfo->authproto) {
			case DHCP6_AUTHPROTO_DELAYED:
				/* Realm + key ID + HMAC-MD5 */
				authlen += optinfo->delayedauth_realmlen +
				    sizeof(optinfo->delayedauth_keyid) + 16;
				break;
#ifdef notyet
			case DHCP6_AUTHPROTO_RECONFIG:
				/* type + key-or-HAMC */
				authlen += 17;
				break;
#endif
			default:
				dprintf(LOG_ERR, FNAME,
				    "unexpected authentication protocol");
				goto fail;
			}
		}
		if ((auth = malloc(authlen)) == NULL) {
			dprintf(LOG_WARNING, FNAME, "failed to allocate "
			    "memory for authentication information");
			goto fail;
		}

		memset(auth, 0, authlen);
		/* copy_option will take care of type and len later */
		auth->dh6_auth_proto = (u_int8_t)optinfo->authproto;
		auth->dh6_auth_alg = (u_int8_t)optinfo->authalgorithm;
		auth->dh6_auth_rdm = (u_int8_t)optinfo->authrdm;
		memcpy(auth->dh6_auth_rdinfo, &optinfo->authrd,
		    sizeof(auth->dh6_auth_rdinfo));

		if (!(optinfo->authflags & DHCP6OPT_AUTHFLAG_NOINFO)) {
			u_int32_t p32;

			switch (optinfo->authproto) {
			case DHCP6_AUTHPROTO_DELAYED:
				authinfo = (char *)(auth + 1);

				/* copy realm */
				memcpy(authinfo, optinfo->delayedauth_realmval,
				    optinfo->delayedauth_realmlen);
				authinfo += optinfo->delayedauth_realmlen;

				/* copy key ID (need memcpy for alignment) */
				p32 = htonl(optinfo->delayedauth_keyid);
				memcpy(authinfo, &p32, sizeof(p32));

				/*
				 * Set the offset so that the caller can
				 * calculate the HMAC.
				 */
				optinfo->delayedauth_offset =
				    ((char *)p - (char *)optbp) + authlen - 16;

				dprintf(LOG_DEBUG, FNAME,
				    "key ID %x, offset %d",
				    optinfo->delayedauth_keyid,
				    optinfo->delayedauth_offset); 
				break;
#ifdef notyet
			case DHCP6_AUTHPROTO_RECONFIG:
#endif
			default:
				dprintf(LOG_ERR, FNAME,
				    "unexpected authentication protocol");
				free(auth);
				goto fail;
			}
		}

		if (copy_option(DH6OPT_AUTH, authlen - 4,
		    &auth->dh6_auth_proto, &p, optep, &len) != 0) {
			goto fail;
		}
		free(auth);
	}

	return (len);

  fail:
	if (tmpbuf)
		free(tmpbuf);
	return (-1);
}
#undef COPY_OPTION

static ssize_t
dnsencode(name, buf, buflen)
	const char *name;
	char *buf;
	size_t buflen;
{
	char *cp, *ep;
	const char *p, *q;
	int i;
	int namelen = strlen(name);

	cp = buf;
	ep = cp + buflen;

	/* if not certain about my name, return an empty buffer */
	if (namelen == 0)
		return (0);

	p = name;
	while (cp < ep && p < name + namelen) {
		i = 0;
		for (q = p; q < name + namelen && *q && *q != '.'; q++)
			i++;
		/* result does not fit into buf */
		if (cp + i + 1 >= ep)
			goto fail;
		/*
		 * DNS label length restriction, RFC1035 page 8.
		 * "i == 0" case is included here to avoid returning
		 * 0-length label on "foo..bar".
		 */
		if (i <= 0 || i >= 64)
			goto fail;
		*cp++ = i;
		if (!isalpha(p[0]) || !isalnum(p[i - 1]))
			goto fail;
		while (i > 0) {
			if (!isalnum(*p) && *p != '-')
				goto fail;
			if (isupper(*p))
				*cp++ = tolower(*p++);
			else
				*cp++ = *p++;
			i--;
		}
		p = q;
		if (p < name + namelen && *p == '.')
			p++;
	}
	/* termination */
	if (cp + 1 >= ep)
		goto fail;
	*cp++ = '\0';
	return (cp - buf);

 fail:
	return (-1);
}

/*
 * Construct a DHCPv6 option along with sub-options in the wire format.
 * If the packet buffer is NULL, just calculate the length of the option
 * (and sub-options) so that the caller can allocate a buffer to store the
 * option(s).
 * This function basically assumes that the caller prepares enough buffer to
 * store all the options.  However, it also takes the buffer end and checks
 * the possibility of overrun for safety.
 */
static int
copyout_option(p, ep, optval)
	char *p, *ep;
	struct dhcp6_listval *optval;
{
	struct dhcp6opt *opt;
	struct dhcp6opt_stcode stcodeopt;
	struct dhcp6opt_ia ia;
	struct dhcp6opt_ia_pd_prefix pd_prefix;
	struct dhcp6opt_ia_addr ia_addr;
	char *subp;
	struct dhcp6_listval *subov;
	int optlen, headlen, sublen, opttype;

	/* check invariant for safety */
	if (p && ep <= p)
		return (-1);

	/* first, detect the length of the option head */
	switch(optval->type) {
	case DHCP6_LISTVAL_IAPD:
		memset(&ia, 0, sizeof(ia));
		headlen = sizeof(ia);
		opttype = DH6OPT_IA_PD;
		opt = (struct dhcp6opt *)(void *)&ia;
		break;
	case DHCP6_LISTVAL_IANA:
		memset(&ia, 0, sizeof(ia));
		headlen = sizeof(ia);
		opttype = DH6OPT_IA_NA;
		opt = (struct dhcp6opt *)(void *)&ia;
		break;
	case DHCP6_LISTVAL_ADDR6:
		memset(&pd_prefix, 0, sizeof(pd_prefix));
		headlen = sizeof(pd_prefix);
		opttype = DH6OPT_IA_PD_PREFIX;
		opt = (struct dhcp6opt *)&pd_prefix;
		break;
	case DHCP6_LISTVAL_PREFIX6:
		memset(&pd_prefix, 0, sizeof(pd_prefix));
		headlen = sizeof(pd_prefix);
		opttype = DH6OPT_IA_PD_PREFIX;
		opt = (struct dhcp6opt *)&pd_prefix;
		break;
	case DHCP6_LISTVAL_STATEFULADDR6:
		memset(&ia_addr, 0, sizeof(ia_addr));
		headlen = sizeof(ia_addr);
		opttype = DH6OPT_IAADDR;
		opt = (struct dhcp6opt *)&ia_addr;
		break;
	case DHCP6_LISTVAL_STCODE:
		memset(&stcodeopt, 0, sizeof(stcodeopt));
		headlen = sizeof(stcodeopt);
		opttype = DH6OPT_STATUS_CODE;
		opt = (struct dhcp6opt *)(void *)&stcodeopt;
		break;
	default:
		/*
		 * we encounter an unknown option.  this should be an internal
		 * error.
		 */
		dprintf(LOG_ERR, FNAME, "unknown option: code %d",
		    optval->type);
		return (-1);
	}

	/* then, calculate the length of and/or fill in the sub-options */
	subp = NULL;
	sublen = 0;
	if (p)
		subp = p + headlen;
	for (subov = TAILQ_FIRST(&optval->sublist); subov;
	    subov = TAILQ_NEXT(subov, link)) {
		int s;

		if ((s = copyout_option(subp, ep, subov)) < 0)
			return (-1);
		if (p)
			subp += s;
		sublen += s;
	}

	/* finally, deal with the head part again */
	optlen = headlen + sublen;
	if (!p)
		return(optlen);

	dprintf(LOG_DEBUG, FNAME, "set %s", dhcp6optstr(opttype));
	if (ep - p < headlen) /* check it just in case */
		return (-1);

	/* fill in the common part */
	opt->dh6opt_type = htons(opttype);
	opt->dh6opt_len = htons(optlen - sizeof(struct dhcp6opt));

	/* fill in type specific fields */
	switch(optval->type) {
	case DHCP6_LISTVAL_IAPD:
		ia.dh6_ia_iaid = htonl(optval->val_ia.iaid);
		ia.dh6_ia_t1 = htonl(optval->val_ia.t1);
		ia.dh6_ia_t2 = htonl(optval->val_ia.t2);
		break;
	case DHCP6_LISTVAL_IANA:
		ia.dh6_ia_iaid = htonl(optval->val_ia.iaid);
		ia.dh6_ia_t1 = htonl(optval->val_ia.t1);
		ia.dh6_ia_t2 = htonl(optval->val_ia.t2);
		break;
	case DHCP6_LISTVAL_PREFIX6:
		pd_prefix.dh6_iapd_prefix_preferred_time =
		    htonl(optval->val_prefix6.pltime);
		pd_prefix.dh6_iapd_prefix_valid_time =
		    htonl(optval->val_prefix6.vltime);
		pd_prefix.dh6_iapd_prefix_prefix_len =
		    optval->val_prefix6.plen;
		/* XXX: prefix_addr is badly aligned, so we need memcpy */
		memcpy(&pd_prefix.dh6_iapd_prefix_prefix_addr,
		    &optval->val_prefix6.addr, sizeof(struct in6_addr));
		break;
	case DHCP6_LISTVAL_STATEFULADDR6:
		ia_addr.dh6_ia_addr_preferred_time =
		    htonl(optval->val_statefuladdr6.pltime);
		ia_addr.dh6_ia_addr_valid_time =
		    htonl(optval->val_statefuladdr6.vltime);
		ia_addr.dh6_ia_addr_addr = optval->val_statefuladdr6.addr;
		break;
	case DHCP6_LISTVAL_STCODE:
		stcodeopt.dh6_stcode_code = htons(optval->val_num16);
		break;
	default:
		/*
		 * XXX: this case should be rejected at the beginning of this
		 * function.
		 */
		return (-1);
	}

	/* copyout the data (p must be non NULL at this point) */
	memcpy(p, opt, headlen);
	return (optlen);
}

void
dhcp6_set_timeoparam(ev)
	struct dhcp6_event *ev;
{
	ev->retrans = 0;
	ev->init_retrans = 0;
	ev->max_retrans_cnt = 0;
	ev->max_retrans_dur = 0;
	ev->max_retrans_time = 0;

	switch(ev->state) {
	case DHCP6S_SOLICIT:
		ev->init_retrans = SOL_TIMEOUT;
		ev->max_retrans_time = SOL_MAX_RT;
		break;
	case DHCP6S_INFOREQ:
		ev->init_retrans = INF_TIMEOUT;
		ev->max_retrans_time = INF_MAX_RT;
		break;
	case DHCP6S_REQUEST:
		ev->init_retrans = REQ_TIMEOUT;
		ev->max_retrans_time = REQ_MAX_RT;
		ev->max_retrans_cnt = REQ_MAX_RC;
		break;
	case DHCP6S_RENEW:
		ev->init_retrans = REN_TIMEOUT;
		ev->max_retrans_time = REN_MAX_RT;
		break;
	case DHCP6S_REBIND:
		ev->init_retrans = REB_TIMEOUT;
		ev->max_retrans_time = REB_MAX_RT;
		break;
	case DHCP6S_RELEASE:
		ev->init_retrans = REL_TIMEOUT;
		ev->max_retrans_cnt = REL_MAX_RC;
		break;
	default:
		dprintf(LOG_ERR, FNAME, "unexpected event state %d on %s",
		    ev->state, ev->ifp->ifname);
		exit(1);
	}
}

void
dhcp6_reset_timer(ev)
	struct dhcp6_event *ev;
{
	double n, r;
	char *statestr;
	struct timeval interval;

	switch(ev->state) {
	case DHCP6S_INIT:
		/*
		 * The first Solicit message from the client on the interface
		 * MUST be delayed by a random amount of time between
		 * 0 and SOL_MAX_DELAY.
		 * [RFC3315 17.1.2]
		 * XXX: a random delay is also necessary before the first
		 * information-request message.  Fortunately, the parameters
		 * and the algorithm for these two cases are the same.
		 * [RFC3315 18.1.5]
		 */
		ev->retrans = (random() % (SOL_MAX_DELAY));
		break;
	default:
		if (ev->state == DHCP6S_SOLICIT && ev->timeouts == 0) {
			/*
			 * The first RT MUST be selected to be strictly
			 * greater than IRT by choosing RAND to be strictly
			 * greater than 0.
			 * [RFC3315 17.1.2]
			 */
			r = (double)((random() % 1000) + 1) / 10000;
			n = ev->init_retrans + r * ev->init_retrans;
		} else {
			r = (double)((random() % 2000) - 1000) / 10000;

			if (ev->timeouts == 0) {
				n = ev->init_retrans + r * ev->init_retrans;
			} else
				n = 2 * ev->retrans + r * ev->retrans;
		}
		if (ev->max_retrans_time && n > ev->max_retrans_time)
			n = ev->max_retrans_time + r * ev->max_retrans_time;
		ev->retrans = (long)n;
		break;
	}

	interval.tv_sec = (ev->retrans * 1000) / 1000000;
	interval.tv_usec = (ev->retrans * 1000) % 1000000;
	dhcp6_set_timer(&interval, ev->timer);

	statestr = dhcp6_event_statestr(ev);

	dprintf(LOG_DEBUG, FNAME, "reset a timer on %s, "
		"state=%s, timeo=%d, retrans=%d",
		ev->ifp->ifname, statestr, ev->timeouts, ev->retrans);
}

int
duidcpy(dd, ds)
	struct duid *dd, *ds;
{
	dd->duid_len = ds->duid_len;
	if ((dd->duid_id = malloc(dd->duid_len)) == NULL) {
		dprintf(LOG_ERR, FNAME, "memory allocation failed");
		return (-1);
	}
	memcpy(dd->duid_id, ds->duid_id, dd->duid_len);

	return (0);
}

int
duidcmp(d1, d2)
	struct duid *d1, *d2;
{
	if (d1->duid_len == d2->duid_len) {
		return (memcmp(d1->duid_id, d2->duid_id, d1->duid_len));
	} else
		return (-1);
}

void
duidfree(duid)
	struct duid *duid;
{
	if (duid->duid_id)
		free(duid->duid_id);
	duid->duid_id = NULL;
	duid->duid_len = 0;
}

/*
 * Provide an NTP-format timestamp as a replay detection counter
 * as mentioned in RFC3315.
 */
#define JAN_1970        2208988800UL        /* 1970 - 1900 in seconds */
int
get_rdvalue(rdm, rdvalue, rdsize)
	int rdm;
	void *rdvalue;
	size_t rdsize;
{
#if defined(HAVE_CLOCK_GETTIME)
	struct timespec tp;
	double nsec;
#else
	struct timeval tv;
#endif
	u_int32_t u32, l32;

	if (rdm != DHCP6_AUTHRDM_MONOCOUNTER) {
		dprintf(LOG_INFO, FNAME, "unsupported RDM (%d)", rdm);
		return (-1);
	}
	if (rdsize != sizeof(u_int64_t)) {
		dprintf(LOG_INFO, FNAME, "unsupported RD size (%d)", rdsize);
		return (-1);
	}

#if defined(HAVE_CLOCK_GETTIME)
	if (clock_gettime(CLOCK_REALTIME, &tp)) {
		dprintf(LOG_WARNING, FNAME, "clock_gettime failed: %s",
		    strerror(errno));
		return (-1);
	}

	u32 = (u_int32_t)tp.tv_sec;
	u32 += JAN_1970;

	nsec = (double)tp.tv_nsec / 1e9 * 0x100000000ULL;
	/* nsec should be smaller than 2^32 */
	l32 = (u_int32_t)nsec;
#else
	if (gettimeofday(&tv, NULL) != 0) {
		dprintf(LOG_WARNING, FNAME, "gettimeofday failed: %s",
		    strerror(errno));
		return (-1);
	}
	u32 = (u_int32_t)tv.tv_sec;
	u32 += JAN_1970;
	l32 = (u_int32_t)tv.tv_usec;
#endif /* HAVE_CLOCK_GETTIME */

	u32 = htonl(u32);
	l32 = htonl(l32);

	memcpy(rdvalue, &u32, sizeof(u32));
	memcpy((char *)rdvalue + sizeof(u32), &l32, sizeof(l32));

	return (0);
}

char *
dhcp6optstr(type)
	int type;
{
	static char genstr[sizeof("opt_65535") + 1]; /* XXX thread unsafe */

	if (type > 65535)
		return ("INVALID option");

	switch(type) {
	case DH6OPT_CLIENTID:
		return ("client ID");
	case DH6OPT_SERVERID:
		return ("server ID");
	case DH6OPT_IA_NA:
		return ("identity association");
	case DH6OPT_IA_TA:
		return ("IA for temporary");
	case DH6OPT_IAADDR:
		return ("IA address");
	case DH6OPT_ORO:
		return ("option request");
	case DH6OPT_PREFERENCE:
		return ("preference");
	case DH6OPT_ELAPSED_TIME:
		return ("elapsed time");
	case DH6OPT_RELAY_MSG:
		return ("relay message");
	case DH6OPT_AUTH:
		return ("authentication");
	case DH6OPT_UNICAST:
		return ("server unicast");
	case DH6OPT_STATUS_CODE:
		return ("status code");
	case DH6OPT_RAPID_COMMIT:
		return ("rapid commit");
	case DH6OPT_USER_CLASS:
		return ("user class");
	case DH6OPT_VENDOR_CLASS:
		return ("vendor class");
	case DH6OPT_VENDOR_OPTS:
		return ("vendor specific info");
	case DH6OPT_INTERFACE_ID:
		return ("interface ID");
	case DH6OPT_RECONF_MSG:
		return ("reconfigure message");
	case DH6OPT_SIP_SERVER_D:
		return ("SIP domain name");
	case DH6OPT_SIP_SERVER_A:
		return ("SIP server address");
	case DH6OPT_DNS:
		return ("DNS");
	case DH6OPT_DNSNAME:
		return ("domain search list");
	case DH6OPT_NTP:
		return ("NTP server");
	case DH6OPT_IA_PD:
		return ("IA_PD");
	case DH6OPT_IA_PD_PREFIX:
		return ("IA_PD prefix");
	case DH6OPT_REFRESHTIME:
		return ("information refresh time");
	case DH6OPT_NIS_SERVERS:
		return ("NIS servers");
	case DH6OPT_NISP_SERVERS:
		return ("NIS+ servers");
	case DH6OPT_NIS_DOMAIN_NAME:
		return ("NIS domain name");
	case DH6OPT_NISP_DOMAIN_NAME:
		return ("NIS+ domain name");
	case DH6OPT_BCMCS_SERVER_D:
		return ("BCMCS domain name");
	case DH6OPT_BCMCS_SERVER_A:
		return ("BCMCS server address");
	case DH6OPT_GEOCONF_CIVIC:
		return ("Geoconf Civic");
	case DH6OPT_REMOTE_ID:
		return ("remote ID");
	case DH6OPT_SUBSCRIBER_ID:
		return ("subscriber ID");
	case DH6OPT_CLIENT_FQDN:
		return ("client FQDN");
	default:
		snprintf(genstr, sizeof(genstr), "opt_%d", type);
		return (genstr);
	}
}

char *
dhcp6msgstr(type)
	int type;
{
	static char genstr[sizeof("msg255") + 1]; /* XXX thread unsafe */

	if (type > 255)
		return ("INVALID msg");

	switch(type) {
	case DH6_SOLICIT:
		return ("solicit");
	case DH6_ADVERTISE:
		return ("advertise");
	case DH6_REQUEST:
		return ("request");
	case DH6_CONFIRM:
		return ("confirm");
	case DH6_RENEW:
		return ("renew");
	case DH6_REBIND:
		return ("rebind");
	case DH6_REPLY:
		return ("reply");
	case DH6_RELEASE:
		return ("release");
	case DH6_DECLINE:
		return ("decline");
	case DH6_RECONFIGURE:
		return ("reconfigure");
	case DH6_INFORM_REQ:
		return ("information request");
	case DH6_RELAY_FORW:
		return ("relay-forward");
	case DH6_RELAY_REPLY:
		return ("relay-reply");
	default:
		snprintf(genstr, sizeof(genstr), "msg%d", type);
		return (genstr);
	}
}

char *
dhcp6_stcodestr(code)
	u_int16_t code;
{
	static char genstr[sizeof("code255") + 1]; /* XXX thread unsafe */

	if (code > 255)
		return ("INVALID code");

	switch(code) {
	case DH6OPT_STCODE_SUCCESS:
		return ("success");
	case DH6OPT_STCODE_UNSPECFAIL:
		return ("unspec failure");
	case DH6OPT_STCODE_NOADDRSAVAIL:
		return ("no addresses");
	case DH6OPT_STCODE_NOBINDING:
		return ("no binding");
	case DH6OPT_STCODE_NOTONLINK:
		return ("not on-link");
	case DH6OPT_STCODE_USEMULTICAST:
		return ("use multicast");
	case DH6OPT_STCODE_NOPREFIXAVAIL:
		return ("no prefixes");
	default:
		snprintf(genstr, sizeof(genstr), "code%d", code);
		return (genstr);
	}
}

char *
duidstr(duid)
	struct duid *duid;
{
	int i, n;
	char *cp, *ep;
	static char duidstr[sizeof("xx:") * 128 + sizeof("...")];

	cp = duidstr;
	ep = duidstr + sizeof(duidstr);
	for (i = 0; i < duid->duid_len && i <= 128; i++) {
		n = snprintf(cp, ep - cp, "%s%02x", i == 0 ? "" : ":",
		    duid->duid_id[i] & 0xff);
		if (n < 0)
			return NULL;
		cp += n;
	}
	if (i < duid->duid_len)
		snprintf(cp, ep - cp, "%s", "...");

	return (duidstr);
}

char *dhcp6_event_statestr(ev)
	struct dhcp6_event *ev;
{
	switch(ev->state) {
	case DHCP6S_INIT:
		return ("INIT");
	case DHCP6S_SOLICIT:
		return ("SOLICIT");
	case DHCP6S_INFOREQ:
		return ("INFOREQ");
	case DHCP6S_REQUEST:
		return ("REQUEST");
	case DHCP6S_RENEW:
		return ("RENEW");
	case DHCP6S_REBIND:
		return ("REBIND");
	case DHCP6S_RELEASE:
		return ("RELEASE");
	case DHCP6S_IDLE:
		return ("IDLE");
	default:
		return ("???"); /* XXX */
	}
}

void
setloglevel(debuglevel)
	int debuglevel;
{
	if (foreground) {
		switch(debuglevel) {
		case 0:
			debug_thresh = LOG_ERR;
			break;
		case 1:
			debug_thresh = LOG_INFO;
			break;
		default:
			debug_thresh = LOG_DEBUG;
			break;
		}
	} else {
		switch(debuglevel) {
		case 0:
			setlogmask(LOG_UPTO(LOG_ERR));
			break;
		case 1:
			setlogmask(LOG_UPTO(LOG_INFO));
			break;
		}
	}
}

void
dprintf(int level, const char *fname, const char *fmt, ...)
{
	va_list ap;
	char logbuf[LINE_MAX];
	int printfname = 1;

	va_start(ap, fmt);
	vsnprintf(logbuf, sizeof(logbuf), fmt, ap);

	if (*fname == '\0')
		printfname = 0;

	if (foreground && debug_thresh >= level) {
		time_t now;
		struct tm *tm_now;
		const char *month[] = {
			"Jan", "Feb", "Mar", "Apr", "May", "Jun",
			"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
		};

		if ((now = time(NULL)) < 0)
			exit(1); /* XXX */
		tm_now = localtime(&now);
		fprintf(stderr, "%3s/%02d/%04d %02d:%02d:%02d: %s%s%s\n",
		    month[tm_now->tm_mon], tm_now->tm_mday,
		    tm_now->tm_year + 1900,
		    tm_now->tm_hour, tm_now->tm_min, tm_now->tm_sec,
		    fname, printfname ? ": " : "",
		    logbuf);
	} else
		syslog(level, "%s%s%s", fname, printfname ? ": " : "", logbuf);
}

int
ifaddrconf(cmd, ifname, addr, plen, pltime, vltime)
	ifaddrconf_cmd_t cmd;
	char *ifname;
	struct sockaddr_in6 *addr;
	int plen;
	int pltime;
	int vltime;
{
#ifdef __KAME__
	struct in6_aliasreq req;
#endif
#ifdef __linux__
	struct in6_ifreq req;
	struct ifreq ifr;
#endif
#ifdef __sun__
	struct lifreq req;
#endif
	unsigned long ioctl_cmd;
	char *cmdstr;
	int s;			/* XXX overhead */

	switch(cmd) {
	case IFADDRCONF_ADD:
		cmdstr = "add";
#ifdef __KAME__
		ioctl_cmd = SIOCAIFADDR_IN6;
#endif
#ifdef __linux__
		ioctl_cmd = SIOCSIFADDR;
#endif
#ifdef __sun__
		ioctl_cmd = SIOCLIFADDIF;
#endif
		break;
	case IFADDRCONF_REMOVE:
		cmdstr = "remove";
#ifdef __KAME__
		ioctl_cmd = SIOCDIFADDR_IN6;
#endif
#ifdef __linux__
		ioctl_cmd = SIOCDIFADDR;
#endif
#ifdef __sun__
		ioctl_cmd = SIOCLIFREMOVEIF;
#endif
		break;
	default:
		return (-1);
	}

	if ((s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
		dprintf(LOG_ERR, FNAME, "can't open a temporary socket: %s",
		    strerror(errno));
		return (-1);
	}

	memset(&req, 0, sizeof(req));
#ifdef __KAME__
	req.ifra_addr = *addr;
	memcpy(req.ifra_name, ifname, sizeof(req.ifra_name));
	(void)sa6_plen2mask(&req.ifra_prefixmask, plen);
	/* XXX: should lifetimes be calculated based on the lease duration? */
	req.ifra_lifetime.ia6t_vltime = vltime;
	req.ifra_lifetime.ia6t_pltime = pltime;
#endif
#ifdef __linux__
	memset(&ifr, 0, sizeof(ifr));
	strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
	if (ioctl(s, SIOGIFINDEX, &ifr) < 0) {
		dprintf(LOG_NOTICE, FNAME, "failed to get the index of %s: %s",
		    ifname, strerror(errno));
		close(s); 
		return (-1); 
	}
	memcpy(&req.ifr6_addr, &addr->sin6_addr, sizeof(struct in6_addr));
	req.ifr6_prefixlen = plen;
	req.ifr6_ifindex = ifr.ifr_ifindex;
#endif
#ifdef __sun__
	strncpy(req.lifr_name, ifname, sizeof (req.lifr_name));
#endif

	if (ioctl(s, ioctl_cmd, &req)) {
		dprintf(LOG_NOTICE, FNAME, "failed to %s an address on %s: %s",
		    cmdstr, ifname, strerror(errno));
		close(s);
		return (-1);
	}

#ifdef __sun__
	memcpy(&req.lifr_addr, addr, sizeof (*addr));
	if (ioctl(s, SIOCSLIFADDR, &req) == -1) {
		dprintf(LOG_NOTICE, FNAME, "failed to %s new address on %s: %s",
		    cmdstr, ifname, strerror(errno));
		close(s);
		return (-1);
	}
#endif

	dprintf(LOG_DEBUG, FNAME, "%s an address %s/%d on %s", cmdstr,
	    addr2str((struct sockaddr *)addr), plen, ifname);

	close(s);
	return (0);
}

int
safefile(path)
	const char *path;
{
	struct stat s;
	uid_t myuid;

	/* no setuid */
	if (getuid() != geteuid()) {
		dprintf(LOG_NOTICE, FNAME,
		    "setuid'ed execution not allowed");
		return (-1);
	}

	if (lstat(path, &s) != 0) {
		dprintf(LOG_NOTICE, FNAME, "lstat failed: %s",
		    strerror(errno));
		return (-1);
	}

	/* the file must be owned by the running uid */
	myuid = getuid();
	if (s.st_uid != myuid) {
		dprintf(LOG_NOTICE, FNAME, "%s has invalid owner uid", path);
		return (-1);
	}

	switch (s.st_mode & S_IFMT) {
	case S_IFREG:
		break;
	default:
		dprintf(LOG_NOTICE, FNAME, "%s is an invalid file type 0x%o",
		    path, (s.st_mode & S_IFMT));
		return (-1);
	}

	return (0);
}