xref: /freebsd-10-stable/contrib/ntp/lib/isc/win32/interfaceiter.c

/*
 * Copyright (C) 2004, 2007-2009  Internet Systems Consortium, Inc. ("ISC")
 * Copyright (C) 1999-2001  Internet Software Consortium.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/* $Id: interfaceiter.c,v 1.15 2009/01/18 23:48:14 tbox Exp $ */

#include <config.h>

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <gaa_compat.h>

#include <isc/interfaceiter.h>
#include <isc/mem.h>
#include <isc/result.h>
#include <isc/string.h>
#include <isc/strerror.h>
#include <isc/types.h>
#include <isc/util.h>
#include <isc/win32os.h>

void InitSockets(void);


#define IFITER_MAGIC		0x49464954U	/* IFIT. */
#define VALID_IFITER(t)		((t) != NULL && (t)->magic == IFITER_MAGIC)

struct isc_interfaceiter {
	unsigned int		magic;		/* Magic number. */
	/* common fields */
	isc_mem_t		*mctx;
	isc_interface_t		current;	/* Current interface data. */
	isc_result_t		result;		/* Last result code. */
	/* fields used if GetAdaptersAddresses is available at runtime */
	IP_ADAPTER_ADDRESSES *	ipaa;		/* GAA() result buffer */
	ULONG			ipaasize;	/* Bytes allocated */
	IP_ADAPTER_ADDRESSES *	ipaaCur;	/* enumeration position */
	IP_ADAPTER_UNICAST_ADDRESS *ipuaCur;	/* enumeration subposition */
	/* fields used for the older address enumeration ioctls */
	SOCKET			socket;
	INTERFACE_INFO		IFData;		/* Current Interface Info */
	int			numIF;		/* Current Interface count */
	int			v4IF;		/* Number of IPv4 Interfaces */
	INTERFACE_INFO		*buf4;		/* Buffer for WSAIoctl data. */
	unsigned int		buf4size;	/* Bytes allocated. */
	INTERFACE_INFO		*pos4;		/* Current offset in IF List */
	SOCKET_ADDRESS_LIST	*buf6;
	unsigned int		buf6size;	/* Bytes allocated. */
	unsigned int		pos6;		/* buf6 index, counts down */
	struct in6_addr		loop__1;	/* ::1 node-scope localhost */
	struct in6_addr		loopfe80__1;	/* fe80::1 link-scope localhost */
};

typedef ULONG (WINAPI *PGETADAPTERSADDRESSES)(
    ULONG Family,
    ULONG Flags,
    PVOID Reserved,
    PIP_ADAPTER_ADDRESSES AdapterAddresses,
    PULONG SizePointer
);

static	isc_boolean_t		use_GAA;
static	isc_boolean_t		use_GAA_determined;
static	HMODULE			hmod_iphlpapi;
static	PGETADAPTERSADDRESSES	pGAA;


/*
 * Size of buffer for SIO_GET_INTERFACE_LIST, in number of interfaces.
 * We assume no sane system will have more than than 1K of IP addresses on
 * all of its adapters.
 */
#define IFCONF_SIZE_INITIAL	  16
#define IFCONF_SIZE_INCREMENT	  64
#define IFCONF_SIZE_MAX		1040


/* Common utility functions */

/*
 * Windows always provides 255.255.255.255 as the the broadcast
 * address.  ntpd needs to know the broadcast address which will target
 * only that network interface, not all.  Reconstruct it from the
 * address and mask.
 */
static void
get_broadcastaddr(isc_netaddr_t *bcastaddr, isc_netaddr_t *addr, isc_netaddr_t *netmask) {

	isc_uint32_t *	b;
	isc_uint32_t	a, n;

	b = (isc_uint32_t *)&bcastaddr->type.in;
	a = *(isc_uint32_t *)&addr->type.in;
	n = *(isc_uint32_t *)&netmask->type.in;

	*b = a | ~n;
}

isc_result_t
isc_interfaceiter_create(isc_mem_t *mctx, isc_interfaceiter_t **iterp) {
	char strbuf[ISC_STRERRORSIZE];
	isc_interfaceiter_t *iter;
	isc_result_t result;
	unsigned int major;
	unsigned int minor;
	unsigned int spmajor;
	ULONG err;
	int tries;
	int error;
	unsigned long bytesReturned = 0;

	REQUIRE(mctx != NULL);
	REQUIRE(iterp != NULL);
	REQUIRE(*iterp == NULL);

	iter = isc_mem_get(mctx, sizeof(*iter));
	if (iter == NULL)
		return (ISC_R_NOMEMORY);

	InitSockets();

	iter->mctx = mctx;
	iter->ipaa = NULL;
	iter->buf4 = NULL;
	iter->buf6 = NULL;
	iter->pos4 = NULL;
	iter->ipaaCur = NULL;
	iter->ipuaCur = NULL;
	iter->ipaasize = 0;
	iter->pos6 = 0;
	iter->buf6size = 0;
	iter->buf4size = 0;
	iter->result = ISC_R_FAILURE;
	iter->numIF = 0;
	iter->v4IF = 0;

	/*
	 * Use GetAdaptersAddresses in preference to ioctls when running
	 * on Windows XP SP1 or later.  Earlier GetAdaptersAddresses do
	 * not appear to provide enough information to associate unicast
	 * addresses with their prefixes.
	 */
	if (!use_GAA_determined) {
		major = isc_win32os_majorversion();
		minor = isc_win32os_minorversion();
		spmajor = isc_win32os_servicepackmajor();
		if (major > 5 || (5 == major &&
		    (minor > 1 || (1 == minor && spmajor >= 1)))) {
			if (NULL == hmod_iphlpapi)
				hmod_iphlpapi = LoadLibrary("iphlpapi");
			if (NULL != hmod_iphlpapi)
				pGAA = (PGETADAPTERSADDRESSES)
				    GetProcAddress(
					hmod_iphlpapi,
					"GetAdaptersAddresses");
			if (NULL != pGAA)
				use_GAA = ISC_TRUE;
		}
		use_GAA_determined = ISC_TRUE;
	}

	if (!use_GAA)
		goto use_ioctls;

	iter->ipaasize = 16 * 1024;

	for (tries = 0; tries < 5; tries++) {
		iter->ipaa = isc_mem_reallocate(mctx, iter->ipaa,
						 iter->ipaasize);
		if (NULL == iter->ipaa) {
			result = ISC_R_NOMEMORY;
			goto put_iter;
		}
		err = (*pGAA)(
			AF_UNSPEC,
			GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_ANYCAST,
			NULL,
			iter->ipaa,
			&iter->ipaasize);
		if (NO_ERROR == err || ERROR_BUFFER_OVERFLOW != err)
			break;
	}

	if (NO_ERROR != err) {
		isc__strerror(err, strbuf, sizeof(strbuf));
		UNEXPECTED_ERROR(__FILE__, __LINE__,
				"GetAdaptersAddresses: %s",
				strbuf);
		result = ISC_R_UNEXPECTED;
		goto gaa_failure;
	}

	iter->ipaaCur = iter->ipaa;
	goto success;

 use_ioctls:
	/*
	 * Create an unbound datagram socket to do the
	 * SIO_GET_INTERFACE_LIST WSAIoctl on.
	 */
	if ((iter->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		error = WSAGetLastError();
		if (error == WSAEAFNOSUPPORT)
			goto inet6_only;
		isc__strerror(error, strbuf, sizeof(strbuf));
		UNEXPECTED_ERROR(__FILE__, __LINE__,
				"making interface scan socket: %s",
				strbuf);
		result = ISC_R_UNEXPECTED;
		goto put_iter;
	}

	/*
	 * Get the interface configuration, allocating more memory if
	 * necessary.
	 */
	iter->buf4size = IFCONF_SIZE_INITIAL*sizeof(INTERFACE_INFO);

	for (;;) {
		iter->buf4 = isc_mem_get(mctx, iter->buf4size);
		if (iter->buf4 == NULL) {
			result = ISC_R_NOMEMORY;
			goto alloc_failure;
		}

		if (WSAIoctl(iter->socket, SIO_GET_INTERFACE_LIST,
			     0, 0, iter->buf4, iter->buf4size,
			     &bytesReturned, 0, 0) == SOCKET_ERROR)
		{
			error = WSAGetLastError();
			if (error != WSAEFAULT && error != WSAENOBUFS) {
				errno = error;
				isc__strerror(error, strbuf, sizeof(strbuf));
				UNEXPECTED_ERROR(__FILE__, __LINE__,
						"get interface configuration: %s",
						strbuf);
				result = ISC_R_UNEXPECTED;
				goto ioctl_failure;
			}
			/*
			 * EINVAL.  Retry with a bigger buffer.
			 */
		} else {
			/*
			 * The WSAIoctl succeeded.
			 * If the number of the returned bytes is the same
			 * as the buffer size, we will grow it just in
			 * case and retry.
			 */
			if (bytesReturned > 0 &&
			    (bytesReturned < iter->buf4size))
				break;
		}
		if (iter->buf4size >= IFCONF_SIZE_MAX*sizeof(INTERFACE_INFO)) {
			UNEXPECTED_ERROR(__FILE__, __LINE__,
					 "get interface configuration: "
					 "maximum buffer size exceeded");
			result = ISC_R_UNEXPECTED;
			goto ioctl_failure;
		}
		isc_mem_put(mctx, iter->buf4, iter->buf4size);

		iter->buf4size += IFCONF_SIZE_INCREMENT *
			sizeof(INTERFACE_INFO);
	}

	/*
	 * A newly created iterator has an undefined position
	 * until isc_interfaceiter_first() is called.
	 */
	iter->v4IF = bytesReturned/sizeof(INTERFACE_INFO);

	/* We don't need the socket any more, so close it */
	closesocket(iter->socket);

 inet6_only:
	/*
	 * Create an unbound datagram socket to do the
	 * SIO_ADDRESS_LIST_QUERY WSAIoctl on.
	 */
	if ((iter->socket = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
		error = WSAGetLastError();
		if (error == WSAEAFNOSUPPORT)
			goto success;
		isc__strerror(error, strbuf, sizeof(strbuf));
		UNEXPECTED_ERROR(__FILE__, __LINE__,
				"making interface scan socket: %s",
				strbuf);
		result = ISC_R_UNEXPECTED;
		goto put_iter;
	}

	/*
	 * Get the interface configuration, allocating more memory if
	 * necessary.
	 */
	iter->buf6size = sizeof(SOCKET_ADDRESS_LIST) +
			 IFCONF_SIZE_INITIAL*sizeof(SOCKET_ADDRESS);

	for (;;) {
		iter->buf6 = isc_mem_get(mctx, iter->buf6size);
		if (iter->buf6 == NULL) {
			result = ISC_R_NOMEMORY;
			goto ioctl_failure;
		}

		if (WSAIoctl(iter->socket, SIO_ADDRESS_LIST_QUERY,
			     0, 0, iter->buf6, iter->buf6size,
			     &bytesReturned, 0, 0) == SOCKET_ERROR)
		{
			error = WSAGetLastError();
			if (error != WSAEFAULT && error != WSAENOBUFS) {
				errno = error;
				isc__strerror(error, strbuf, sizeof(strbuf));
				UNEXPECTED_ERROR(__FILE__, __LINE__,
						 "sio address list query: %s",
						 strbuf);
				result = ISC_R_UNEXPECTED;
				goto ioctl6_failure;
			}
			/*
			 * EINVAL.  Retry with a bigger buffer.
			 */
		} else
			break;

		if (iter->buf6size >= IFCONF_SIZE_MAX*sizeof(SOCKET_ADDRESS)) {
			UNEXPECTED_ERROR(__FILE__, __LINE__,
					 "get interface configuration: "
					 "maximum buffer size exceeded");
			result = ISC_R_UNEXPECTED;
			goto ioctl6_failure;
		}
		isc_mem_put(mctx, iter->buf6, iter->buf6size);

		iter->buf6size += IFCONF_SIZE_INCREMENT *
			sizeof(SOCKET_ADDRESS);
	}

	/*
	 * initialize loop__1 to [::1] and loopfe80__1 to [fe80::1].
	 * used by internal_current6().
	 */
	memset(&iter->loop__1, 0, sizeof(iter->loop__1));
	memset(&iter->loopfe80__1, 0, sizeof(iter->loopfe80__1));
	iter->loop__1.s6_addr[15] = 1;
	iter->loopfe80__1.s6_addr[15] = 1;
	iter->loopfe80__1.s6_addr[0] = 0xfe;
	iter->loopfe80__1.s6_addr[1] = 0x80;

	closesocket(iter->socket);

 success:
	iter->magic = IFITER_MAGIC;
	*iterp = iter;
	return (ISC_R_SUCCESS);

 gaa_failure:
	isc_mem_put(mctx, iter->ipaa, iter->ipaasize);
	goto put_iter;

 ioctl6_failure:
	isc_mem_put(mctx, iter->buf6, iter->buf6size);

 ioctl_failure:
	if (iter->buf4 != NULL)
		isc_mem_put(mctx, iter->buf4, iter->buf4size);

 alloc_failure:
	if (iter->socket >= 0)
		(void) closesocket(iter->socket);

 put_iter:
	isc_mem_put(mctx, iter, sizeof(*iter));
	return (result);
}

static unsigned char
GAA_find_prefix(isc_interfaceiter_t *iter) {
	IP_ADAPTER_PREFIX *	ipap;
	IP_ADAPTER_PREFIX *	ipap_match;
	int			match_len;
	int			max_len;
	isc_netaddr_t		target;
	u_short			af;
	isc_netaddr_t		pfx;
	int			pfx_len;
	size_t			nbytes;
	unsigned char		nbits;
	unsigned char *		pbits;
	unsigned int		octets;

	match_len = 0;
	ipap_match = NULL;
	isc_netaddr_fromsockaddr(&target,
	    (isc_sockaddr_t *)iter->ipuaCur->Address.lpSockaddr);
	af = (u_short)target.family;
	INSIST(AF_INET == af || AF_INET6 == af);
	max_len = (AF_INET6 == af) ? 128 : 32;
	iter->current.netmask.family = af;
	for (ipap = iter->ipaaCur->FirstPrefix;
	     ipap != NULL;
	     ipap = ipap->Next) {
		if (ipap->Address.lpSockaddr->sa_family != af)
			continue;
		isc_netaddr_fromsockaddr(&pfx,
		    (isc_sockaddr_t *)ipap->Address.lpSockaddr);
		pfx_len = ipap->PrefixLength;
		INSIST(0 <= pfx_len && pfx_len <= max_len);
		if (pfx_len > match_len && pfx_len < max_len &&
		    isc_netaddr_eqprefix(&target, &pfx, pfx_len)) {
			ipap_match = ipap;
			match_len = pfx_len;
		}
	}
	if (NULL == ipap_match) {
		/* presume all-ones mask */
		if (AF_INET6 == af)
			octets = sizeof(iter->current.netmask.type.in6);
		else
			octets = sizeof(iter->current.netmask.type.in);
		memset(&iter->current.netmask.type, 0xFF, octets);
		return (8 * (unsigned char)octets);
	}
	nbytes = match_len / 8;
	nbits = match_len % 8;
	memset(&iter->current.netmask.type.in6, 0xFF, nbytes);
	pbits = (void *)&iter->current.netmask.type.in6;
	pbits += nbytes;
	*pbits |= 0xFF << (8 - nbits);
	return ((unsigned char)match_len);
}

static isc_result_t
internal_current_GAA(isc_interfaceiter_t *iter) {
	IP_ADAPTER_ADDRESSES *adap;
	IP_ADAPTER_UNICAST_ADDRESS *addr;
	unsigned char prefix_len;

	REQUIRE(iter->ipaaCur != NULL);
	REQUIRE(iter->ipuaCur != NULL);
	adap = iter->ipaaCur;
	addr = iter->ipuaCur;
	if (IpDadStatePreferred != addr->DadState)
		return (ISC_R_IGNORE);
	memset(&iter->current, 0, sizeof(iter->current));
	iter->current.af = addr->Address.lpSockaddr->sa_family;
	isc_netaddr_fromsockaddr(&iter->current.address,
	    (isc_sockaddr_t *)addr->Address.lpSockaddr);
	if (AF_INET6 == iter->current.af)
		iter->current.ifindex = adap->Ipv6IfIndex;
	iter->current.name[0] = '\0';
	WideCharToMultiByte(
		CP_ACP,
		0,
		adap->FriendlyName,
		-1,
		iter->current.name,
		sizeof(iter->current.name),
		NULL,
		NULL);
	iter->current.name[sizeof(iter->current.name) - 1] = '\0';
	if (IfOperStatusUp == adap->OperStatus)
		iter->current.flags |= INTERFACE_F_UP;
	if (IF_TYPE_PPP == adap->IfType)
		iter->current.flags |= INTERFACE_F_POINTTOPOINT;
	else if (IF_TYPE_SOFTWARE_LOOPBACK == adap->IfType)
		iter->current.flags |= INTERFACE_F_LOOPBACK;
	if ((IP_ADAPTER_NO_MULTICAST & adap->Flags) == 0)
		iter->current.flags |= INTERFACE_F_MULTICAST;
	if (IpSuffixOriginRandom == addr->SuffixOrigin)
		iter->current.flags |= INTERFACE_F_PRIVACY;

	prefix_len = GAA_find_prefix(iter);
	/* I'm failing to see a broadcast flag via GAA */
	if (AF_INET == iter->current.af && prefix_len < 32 &&
	    (INTERFACE_F_LOOPBACK & iter->current.flags) == 0) {
		iter->current.flags |= INTERFACE_F_BROADCAST;
		get_broadcastaddr(&iter->current.broadcast,
				  &iter->current.address,
				  &iter->current.netmask);
	}
	return (ISC_R_SUCCESS);
}

/*
 * Get information about the current interface to iter->current.
 * If successful, return ISC_R_SUCCESS.
 * If the interface has an unsupported address family, or if
 * some operation on it fails, return ISC_R_IGNORE to make
 * the higher-level iterator code ignore it.
 */

static isc_result_t
internal_current(isc_interfaceiter_t *iter) {
	BOOL ifNamed = FALSE;
	unsigned long flags;

	REQUIRE(VALID_IFITER(iter));
	REQUIRE(iter->numIF >= 0);

	memset(&iter->current, 0, sizeof(iter->current));
	iter->current.af = AF_INET;

	isc_netaddr_fromsockaddr(&iter->current.address,
	    (isc_sockaddr_t *)&(iter->IFData.iiAddress));

	/*
	 * Get interface flags.
	 */

	iter->current.flags = 0;
	flags = iter->IFData.iiFlags;

	if ((flags & IFF_UP) != 0)
		iter->current.flags |= INTERFACE_F_UP;

	if ((flags & IFF_BROADCAST) != 0)
		iter->current.flags |= INTERFACE_F_BROADCAST;

	if ((flags & IFF_MULTICAST) != 0)
		iter->current.flags |= INTERFACE_F_MULTICAST;

	if ((flags & IFF_POINTTOPOINT) != 0) {
		iter->current.flags |= INTERFACE_F_POINTTOPOINT;
		snprintf(iter->current.name, sizeof(iter->current.name),
			 "PPP %d", iter->numIF);
		ifNamed = TRUE;
	}

	if ((flags & IFF_LOOPBACK) != 0) {
		iter->current.flags |= INTERFACE_F_LOOPBACK;
		snprintf(iter->current.name, sizeof(iter->current.name),
			"v4loop %d", iter->numIF);
		ifNamed = TRUE;
	}

	/*
	 * If the interface is point-to-point, get the destination address.
	 */
	if ((iter->current.flags & INTERFACE_F_POINTTOPOINT) != 0)
		isc_netaddr_fromsockaddr(&iter->current.dstaddress,
		    (isc_sockaddr_t *)&(iter->IFData.iiBroadcastAddress));

	/*
	 * Get the network mask.
	 */
	isc_netaddr_fromsockaddr(&iter->current.netmask,
	    (isc_sockaddr_t *)&(iter->IFData.iiNetmask));

	/*
	 * If the interface is broadcast, get the broadcast address,
	 * based on the unicast address and network mask.
	 */
	if ((iter->current.flags & INTERFACE_F_BROADCAST) != 0)
		get_broadcastaddr(&iter->current.broadcast,
				  &iter->current.address,
				  &iter->current.netmask);

	if (ifNamed == FALSE)
		snprintf(iter->current.name, sizeof(iter->current.name),
			"IPv4 %d", iter->numIF);

	return (ISC_R_SUCCESS);
}

static isc_result_t
internal_current6(isc_interfaceiter_t *iter) {
	BOOL ifNamed = FALSE;
	struct sockaddr_in6 *psa6;
	BOOL localhostSeen;
	int i;

	REQUIRE(VALID_IFITER(iter));
	REQUIRE(iter->pos6 >= 0);
	REQUIRE(iter->buf6 != 0);

	memset(&iter->current, 0, sizeof(iter->current));
	iter->current.af = AF_INET6;

	/*
	 * synthesize localhost ::1 before returning the rest, if ::1
	 * is not on the list.
	 */
	if (iter->pos6 >= (unsigned)iter->buf6->iAddressCount) {
		localhostSeen = FALSE;
		for (i = 0; i < iter->buf6->iAddressCount; i++) {
			psa6 = (struct sockaddr_in6 *)
			       iter->buf6->Address[i].lpSockaddr;
			if (!memcmp(&iter->loop__1, &psa6->sin6_addr,
				    sizeof(iter->loop__1))) {
				localhostSeen = TRUE;
				break;
			}
		}
		if (localhostSeen)
			iter->pos6 = iter->buf6->iAddressCount - 1;
	}

	if (iter->pos6 < (unsigned)iter->buf6->iAddressCount) {
		isc_netaddr_fromsockaddr(&iter->current.address,
		    (isc_sockaddr_t *)iter->buf6->Address[iter->pos6].lpSockaddr);
	} else {
		iter->current.address.family = AF_INET6;
		memcpy(&iter->current.address.type.in6, &iter->loop__1,
		       sizeof(iter->current.address.type.in6));
	}

	/*
	 * Get interface flags.
	 */

	iter->current.flags = INTERFACE_F_UP | INTERFACE_F_MULTICAST;

	if (!memcmp(&iter->current.address.type.in6, &iter->loop__1,
		    sizeof(iter->current.address.type.in6)) ||
	    !memcmp(&iter->current.address.type.in6, &iter->loopfe80__1,
	            sizeof(iter->current.address.type.in6))) {

		iter->current.flags |= INTERFACE_F_LOOPBACK;
		snprintf(iter->current.name, sizeof(iter->current.name),
			 "v6loop %d",
			 iter->buf6->iAddressCount - iter->pos6);
		ifNamed = TRUE;
	}

	if (ifNamed == FALSE)
		snprintf(iter->current.name, sizeof(iter->current.name),
			 "IPv6 %d",
			 iter->buf6->iAddressCount - iter->pos6);

	memset(iter->current.netmask.type.in6.s6_addr, 0xff,
	       sizeof(iter->current.netmask.type.in6.s6_addr));
	iter->current.netmask.family = AF_INET6;
	return (ISC_R_SUCCESS);
}

static isc_result_t
internal_next_GAA(isc_interfaceiter_t *iter) {
	REQUIRE(use_GAA);
	if (NULL == iter->ipaaCur)
		return (ISC_R_NOMORE);
	if (NULL == iter->ipuaCur)
		iter->ipuaCur = iter->ipaaCur->FirstUnicastAddress;
	else
		iter->ipuaCur = iter->ipuaCur->Next;
	while (NULL == iter->ipuaCur) {
		iter->ipaaCur = iter->ipaaCur->Next;
		if (NULL == iter->ipaaCur)
			return (ISC_R_NOMORE);
		iter->ipuaCur = iter->ipaaCur->FirstUnicastAddress;
	}
	return (ISC_R_SUCCESS);
}

/*
 * Step the iterator to the next interface.  Unlike
 * isc_interfaceiter_next(), this may leave the iterator
 * positioned on an interface that will ultimately
 * be ignored.  Return ISC_R_NOMORE if there are no more
 * interfaces, otherwise ISC_R_SUCCESS.
 */
static isc_result_t
internal_next(isc_interfaceiter_t *iter) {
	if (iter->numIF >= iter->v4IF)
		return (ISC_R_NOMORE);

	/*
	 * The first one needs to be set up to point to the last
	 * Element of the array.  Go to the end and back up
	 * Microsoft's implementation is peculiar for returning
	 * the list in reverse order
	 */

	if (iter->numIF == 0)
		iter->pos4 = (INTERFACE_INFO *)(iter->buf4 + (iter->v4IF));

	iter->pos4--;
	if (&(iter->pos4) < &(iter->buf4))
		return (ISC_R_NOMORE);

	memset(&(iter->IFData), 0, sizeof(INTERFACE_INFO));
	memcpy(&(iter->IFData), iter->pos4, sizeof(INTERFACE_INFO));
	iter->numIF++;

	return (ISC_R_SUCCESS);
}

static isc_result_t
internal_next6(isc_interfaceiter_t *iter) {
	if (iter->pos6 == 0)
		return (ISC_R_NOMORE);
	iter->pos6--;
	return (ISC_R_SUCCESS);
}

isc_result_t
isc_interfaceiter_current(isc_interfaceiter_t *iter,
			  isc_interface_t *ifdata) {
	REQUIRE(iter->result == ISC_R_SUCCESS);
	memcpy(ifdata, &iter->current, sizeof(*ifdata));
	return (ISC_R_SUCCESS);
}

isc_result_t
isc_interfaceiter_first(isc_interfaceiter_t *iter) {
	REQUIRE(VALID_IFITER(iter));
	REQUIRE(use_GAA_determined);
	/*
	 * SIO_ADDRESS_LIST_QUERY (used to query IPv6 addresses)
	 * intentionally omits localhost addresses [::1] and [::fe80] in
	 * some cases.  ntpd depends on enumerating [::1] to listen on
	 * it, and ntpq and ntpdc default to "localhost" as the target,
	 * so they will attempt to talk to [::1]:123 and fail. This
	 * means we need to synthesize ::1, which we will do first,
	 * hence iAddressCount + 1.  internal_next6() will decrement
	 * it before the first use as an index, and internal_current6()
	 * will treat pos6 == iAddressCount as a sign to synthesize
	 * [::1] if needed.
	 */
	if (!use_GAA && iter->buf6 != NULL)
		iter->pos6 = iter->buf6->iAddressCount + 1;
	iter->result = ISC_R_SUCCESS;
	return (isc_interfaceiter_next(iter));
}

isc_result_t
isc_interfaceiter_next(isc_interfaceiter_t *iter) {
	isc_result_t result;

	REQUIRE(VALID_IFITER(iter));
	REQUIRE(iter->result == ISC_R_SUCCESS);
	REQUIRE(use_GAA_determined);

	if (use_GAA) {
		do {
			result = internal_next_GAA(iter);
			if (ISC_R_NOMORE == result)
				goto set_result;
			result = internal_current_GAA(iter);
		} while (ISC_R_IGNORE == result);
		goto set_result;
	}

	for (;;) {
		result = internal_next(iter);
		if (result == ISC_R_NOMORE) {
			result = internal_next6(iter);
			if (result != ISC_R_SUCCESS)
				break;
			result = internal_current6(iter);
			if (result != ISC_R_IGNORE)
				break;
		} else if (result != ISC_R_SUCCESS)
			break;
		result = internal_current(iter);
		if (result != ISC_R_IGNORE)
			break;
	}
 set_result:
	iter->result = result;
	return (result);
}

void
isc_interfaceiter_destroy(isc_interfaceiter_t **iterp) {
	isc_interfaceiter_t *iter;

	REQUIRE(iterp != NULL);
	iter = *iterp;
	REQUIRE(VALID_IFITER(iter));
	REQUIRE(use_GAA_determined);

	if (use_GAA) {
		REQUIRE(NULL == iter->buf4);
		REQUIRE(NULL == iter->buf4);
		if (iter->ipaa != NULL)
			isc_mem_put(iter->mctx, iter->ipaa, iter->ipaasize);
	} else {
		REQUIRE(NULL == iter->ipaa);
		if (iter->buf4 != NULL)
			isc_mem_put(iter->mctx, iter->buf4, iter->buf4size);
		if (iter->buf6 != NULL)
			isc_mem_put(iter->mctx, iter->buf6, iter->buf6size);
	}

	iter->magic = 0;
	isc_mem_put(iter->mctx, iter, sizeof(*iter));
	*iterp = NULL;
}