Adding upstream version 7.94+git20230807.3be01efb1+dfsg.upstream/7.94+git20230807.3be01efb1+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1091 insertions, 0 deletions

diff --git a/libdnet-stripped/src/intf.c b/libdnet-stripped/src/intf.c
new file mode 100644
index 0000000..d4faaeb
--- /dev/null
+++ b/libdnet-stripped/src/intf.c
@@ -0,0 +1,1091 @@
+/*
+ * intf.c
+ *
+ * Copyright (c) 2001 Dug Song <dugsong@monkey.org>
+ *
+ * $Id: intf.c 616 2006-01-09 07:09:49Z dugsong $
+ */
+
+#ifdef _WIN32
+#include "dnet_winconfig.h"
+#else
+#include "config.h"
+#endif
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#ifdef HAVE_SYS_SOCKIO_H
+# include <sys/sockio.h>
+#endif
+/* XXX - AIX */
+#ifdef HAVE_GETKERNINFO
+#include <sys/ndd_var.h>
+#include <sys/kinfo.h>
+#endif
+#ifndef IP_MULTICAST
+# define IP_MULTICAST
+#endif
+#include <net/if.h>
+#ifdef HAVE_NET_IF_VAR_H
+# include <net/if_var.h>
+#endif
+#undef IP_MULTICAST
+/* XXX - IPv6 ioctls */
+#ifdef HAVE_NETINET_IN_VAR_H
+# include <netinet/in.h>
+# include <netinet/in_var.h>
+#endif
+#ifdef HAVE_NETINET_IN6_VAR_H
+# include <sys/protosw.h>
+# include <netinet/in6_var.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "dnet.h"
+
+/* XXX - Tru64 */
+#if defined(SIOCRIPMTU) && defined(SIOCSIPMTU)
+# define SIOCGIFMTU	SIOCRIPMTU
+# define SIOCSIFMTU	SIOCSIPMTU
+#endif
+
+/* XXX - HP-UX */
+#if defined(SIOCADDIFADDR) && defined(SIOCDELIFADDR)
+# define SIOCAIFADDR	SIOCADDIFADDR
+# define SIOCDIFADDR	SIOCDELIFADDR
+#endif
+
+/* XXX - HP-UX, Solaris */
+#if !defined(ifr_mtu) && defined(ifr_metric)
+# define ifr_mtu	ifr_metric
+#endif
+
+#ifdef HAVE_SOCKADDR_SA_LEN
+# define max(a, b) ((a) > (b) ? (a) : (b))
+# define NEXTIFR(i)	((struct ifreq *) \
+				max((u_char *)i + sizeof(struct ifreq), \
+				(u_char *)&i->ifr_addr + i->ifr_addr.sa_len))
+#else
+# define NEXTIFR(i)	(i + 1)
+#endif
+
+#define NEXTLIFR(i)	(i + 1)
+
+/* XXX - superset of ifreq, for portable SIOC{A,D}IFADDR */
+struct dnet_ifaliasreq {
+	char		ifra_name[IFNAMSIZ];
+	union {
+		struct sockaddr ifrau_addr;
+		int             ifrau_align;
+	} ifra_ifrau;
+#ifndef ifra_addr
+#define ifra_addr      ifra_ifrau.ifrau_addr
+#endif
+	struct sockaddr ifra_brdaddr;
+	struct sockaddr ifra_mask;
+	int		ifra_cookie;	/* XXX - IRIX!@#$ */
+};
+
+struct intf_handle {
+	int		fd;
+	int		fd6;
+	struct ifconf	ifc;
+#ifdef SIOCGLIFCONF
+	struct lifconf	lifc;
+#endif
+	u_char		ifcbuf[4192];
+};
+
+static int
+intf_flags_to_iff(u_short flags, int iff)
+{
+	if (flags & INTF_FLAG_UP)
+		iff |= IFF_UP;
+	else
+		iff &= ~IFF_UP;
+	if (flags & INTF_FLAG_NOARP)
+		iff |= IFF_NOARP;
+	else
+		iff &= ~IFF_NOARP;
+	
+	return (iff);
+}
+
+static u_int
+intf_iff_to_flags(uint64_t iff)
+{
+	u_int n = 0;
+
+	if (iff & IFF_UP)
+		n |= INTF_FLAG_UP;	
+	if (iff & IFF_LOOPBACK)
+		n |= INTF_FLAG_LOOPBACK;
+	if (iff & IFF_POINTOPOINT)
+		n |= INTF_FLAG_POINTOPOINT;
+	if (iff & IFF_NOARP)
+		n |= INTF_FLAG_NOARP;
+	if (iff & IFF_BROADCAST)
+		n |= INTF_FLAG_BROADCAST;
+	if (iff & IFF_MULTICAST)
+		n |= INTF_FLAG_MULTICAST;
+#ifdef IFF_IPMP
+	/* Unset the BROADCAST and MULTICAST flags from Solaris IPMP interfaces,
+	 * otherwise _intf_set_type will think they are INTF_TYPE_ETH. */
+	if (iff & IFF_IPMP)
+		n &= ~(INTF_FLAG_BROADCAST | INTF_FLAG_MULTICAST);
+#endif
+
+	return (n);
+}
+
+intf_t *
+intf_open(void)
+{
+	intf_t *intf;
+	int one = 1;
+	
+	if ((intf = calloc(1, sizeof(*intf))) != NULL) {
+		intf->fd = intf->fd6 = -1;
+		
+		if ((intf->fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+			return (intf_close(intf));
+
+		setsockopt(intf->fd, SOL_SOCKET, SO_BROADCAST,
+			(const char *) &one, sizeof(one));
+
+#if defined(SIOCGLIFCONF) || defined(SIOCGIFNETMASK_IN6) || defined(SIOCGIFNETMASK6)
+		if ((intf->fd6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
+#  ifdef EPROTONOSUPPORT
+			if (errno != EPROTONOSUPPORT)
+#  endif
+				return (intf_close(intf));
+		}
+#endif
+	}
+	return (intf);
+}
+
+static int
+_intf_delete_addrs(intf_t *intf, struct intf_entry *entry)
+{
+#if defined(SIOCDIFADDR)
+	struct dnet_ifaliasreq ifra;
+	
+	memset(&ifra, 0, sizeof(ifra));
+	strlcpy(ifra.ifra_name, entry->intf_name, sizeof(ifra.ifra_name));
+	if (entry->intf_addr.addr_type == ADDR_TYPE_IP) {
+		addr_ntos(&entry->intf_addr, &ifra.ifra_addr);
+		ioctl(intf->fd, SIOCDIFADDR, &ifra);
+	}
+	if (entry->intf_dst_addr.addr_type == ADDR_TYPE_IP) {
+		addr_ntos(&entry->intf_dst_addr, &ifra.ifra_addr);
+		ioctl(intf->fd, SIOCDIFADDR, &ifra);
+	}
+#elif defined(SIOCLIFREMOVEIF)
+	struct ifreq ifr;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, entry->intf_name, sizeof(ifr.ifr_name));
+	/* XXX - overloading Solaris lifreq with ifreq */
+	ioctl(intf->fd, SIOCLIFREMOVEIF, &ifr);
+#endif
+	return (0);
+}
+
+static int
+_intf_delete_aliases(intf_t *intf, struct intf_entry *entry)
+{
+	int i;
+#if defined(SIOCDIFADDR) && !defined(__linux__)	/* XXX - see Linux below */
+	struct dnet_ifaliasreq ifra;
+	
+	memset(&ifra, 0, sizeof(ifra));
+	strlcpy(ifra.ifra_name, entry->intf_name, sizeof(ifra.ifra_name));
+	
+	for (i = 0; i < (int)entry->intf_alias_num; i++) {
+		addr_ntos(&entry->intf_alias_addrs[i], &ifra.ifra_addr);
+		ioctl(intf->fd, SIOCDIFADDR, &ifra);
+	}
+#else
+	struct ifreq ifr;
+	
+	for (i = 0; i < entry->intf_alias_num; i++) {
+		snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s:%d",
+		    entry->intf_name, i + 1);
+# ifdef SIOCLIFREMOVEIF
+		/* XXX - overloading Solaris lifreq with ifreq */
+		ioctl(intf->fd, SIOCLIFREMOVEIF, &ifr);
+# else
+		/* XXX - only need to set interface down on Linux */
+		ifr.ifr_flags = 0;
+		ioctl(intf->fd, SIOCSIFFLAGS, &ifr);
+# endif
+	}
+#endif
+	return (0);
+}
+
+static int
+_intf_add_aliases(intf_t *intf, const struct intf_entry *entry)
+{
+	int i;
+#ifdef SIOCAIFADDR
+	struct dnet_ifaliasreq ifra;
+	struct addr bcast;
+	
+	memset(&ifra, 0, sizeof(ifra));
+	strlcpy(ifra.ifra_name, entry->intf_name, sizeof(ifra.ifra_name));
+	
+	for (i = 0; i < (int)entry->intf_alias_num; i++) {
+		if (entry->intf_alias_addrs[i].addr_type != ADDR_TYPE_IP)
+			continue;
+		
+		if (addr_ntos(&entry->intf_alias_addrs[i],
+		    &ifra.ifra_addr) < 0)
+			return (-1);
+		addr_bcast(&entry->intf_alias_addrs[i], &bcast);
+		addr_ntos(&bcast, &ifra.ifra_brdaddr);
+		addr_btos(entry->intf_alias_addrs[i].addr_bits,
+		    &ifra.ifra_mask);
+		
+		if (ioctl(intf->fd, SIOCAIFADDR, &ifra) < 0)
+			return (-1);
+	}
+#else
+	struct ifreq ifr;
+	int n = 1;
+	
+	for (i = 0; i < entry->intf_alias_num; i++) {
+		if (entry->intf_alias_addrs[i].addr_type != ADDR_TYPE_IP)
+			continue;
+		
+		snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s:%d",
+		    entry->intf_name, n++);
+# ifdef SIOCLIFADDIF
+		if (ioctl(intf->fd, SIOCLIFADDIF, &ifr) < 0)
+			return (-1);
+# endif
+		if (addr_ntos(&entry->intf_alias_addrs[i], &ifr.ifr_addr) < 0)
+			return (-1);
+		if (ioctl(intf->fd, SIOCSIFADDR, &ifr) < 0)
+			return (-1);
+	}
+	strlcpy(ifr.ifr_name, entry->intf_name, sizeof(ifr.ifr_name));
+#endif
+	return (0);
+}
+
+int
+intf_set(intf_t *intf, const struct intf_entry *entry)
+{
+	struct ifreq ifr;
+	struct intf_entry *orig;
+	struct addr bcast;
+	u_char buf[BUFSIZ];
+	
+	orig = (struct intf_entry *)buf;
+	orig->intf_len = sizeof(buf);
+	strcpy(orig->intf_name, entry->intf_name);
+	
+	if (intf_get(intf, orig) < 0)
+		return (-1);
+	
+	/* Delete any existing aliases. */
+	if (_intf_delete_aliases(intf, orig) < 0)
+		return (-1);
+
+	/* Delete any existing addrs. */
+	if (_intf_delete_addrs(intf, orig) < 0)
+		return (-1);
+	
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, entry->intf_name, sizeof(ifr.ifr_name));
+	
+	/* Set interface MTU. */
+	if (entry->intf_mtu != 0) {
+		ifr.ifr_mtu = entry->intf_mtu;
+#ifdef SIOCSIFMTU
+		if (ioctl(intf->fd, SIOCSIFMTU, &ifr) < 0)
+#endif
+			return (-1);
+	}
+	/* Set interface address. */
+	if (entry->intf_addr.addr_type == ADDR_TYPE_IP) {
+#if defined(BSD) && !defined(__OPENBSD__)
+		/* XXX - why must this happen before SIOCSIFADDR? */
+		if (addr_btos(entry->intf_addr.addr_bits,
+		    &ifr.ifr_addr) == 0) {
+			if (ioctl(intf->fd, SIOCSIFNETMASK, &ifr) < 0)
+				return (-1);
+		}
+#endif
+		if (addr_ntos(&entry->intf_addr, &ifr.ifr_addr) < 0)
+			return (-1);
+		if (ioctl(intf->fd, SIOCSIFADDR, &ifr) < 0 && errno != EEXIST)
+			return (-1);
+		
+		if (addr_btos(entry->intf_addr.addr_bits, &ifr.ifr_addr) == 0
+#ifdef __linux__
+		    && entry->intf_addr.addr_ip != 0
+#endif
+		    ) {
+			if (ioctl(intf->fd, SIOCSIFNETMASK, &ifr) < 0)
+				return (-1);
+		}
+		if (addr_bcast(&entry->intf_addr, &bcast) == 0) {
+			if (addr_ntos(&bcast, &ifr.ifr_broadaddr) == 0) {
+				/* XXX - ignore error from non-broadcast ifs */
+				ioctl(intf->fd, SIOCSIFBRDADDR, &ifr);
+			}
+		}
+	}
+	/* Set link-level address. */
+	if (entry->intf_link_addr.addr_type == ADDR_TYPE_ETH &&
+	    addr_cmp(&entry->intf_link_addr, &orig->intf_link_addr) != 0) {
+#if defined(SIOCSIFHWADDR)
+		if (addr_ntos(&entry->intf_link_addr, &ifr.ifr_hwaddr) < 0)
+			return (-1);
+		if (ioctl(intf->fd, SIOCSIFHWADDR, &ifr) < 0)
+			return (-1);
+#elif defined (SIOCSIFLLADDR)
+		memcpy(ifr.ifr_addr.sa_data, &entry->intf_link_addr.addr_eth,
+		    ETH_ADDR_LEN);
+		ifr.ifr_addr.sa_len = ETH_ADDR_LEN;
+		if (ioctl(intf->fd, SIOCSIFLLADDR, &ifr) < 0)
+			return (-1);
+#else
+		eth_t *eth;
+
+		if ((eth = eth_open(entry->intf_name)) == NULL)
+			return (-1);
+		if (eth_set(eth, &entry->intf_link_addr.addr_eth) < 0) {
+			eth_close(eth);
+			return (-1);
+		}
+		eth_close(eth);
+#endif
+	}
+	/* Set point-to-point destination. */
+	if (entry->intf_dst_addr.addr_type == ADDR_TYPE_IP) {
+		if (addr_ntos(&entry->intf_dst_addr, &ifr.ifr_dstaddr) < 0)
+			return (-1);
+		if (ioctl(intf->fd, SIOCSIFDSTADDR, &ifr) < 0 &&
+		    errno != EEXIST)
+			return (-1);
+	}
+	/* Add aliases. */
+	if (_intf_add_aliases(intf, entry) < 0)
+		return (-1);
+	
+	/* Set interface flags. */
+	if (ioctl(intf->fd, SIOCGIFFLAGS, &ifr) < 0)
+		return (-1);
+	
+	ifr.ifr_flags = intf_flags_to_iff(entry->intf_flags, ifr.ifr_flags);
+	
+	if (ioctl(intf->fd, SIOCSIFFLAGS, &ifr) < 0)
+		return (-1);
+	
+	return (0);
+}
+
+/* XXX - this is total crap. how to do this without walking ifnet? */
+static void
+_intf_set_type(struct intf_entry *entry)
+{
+	if ((entry->intf_flags & INTF_FLAG_LOOPBACK) != 0)
+		entry->intf_type = INTF_TYPE_LOOPBACK;
+	else if ((entry->intf_flags & INTF_FLAG_BROADCAST) != 0)
+		entry->intf_type = INTF_TYPE_ETH;
+	else if ((entry->intf_flags & INTF_FLAG_POINTOPOINT) != 0)
+		entry->intf_type = INTF_TYPE_TUN;
+	else
+		entry->intf_type = INTF_TYPE_OTHER;
+}
+
+#ifdef SIOCGLIFCONF
+int
+_intf_get_noalias(intf_t *intf, struct intf_entry *entry)
+{
+	struct lifreq lifr;
+	int fd;
+
+	/* Get interface index. */
+	entry->intf_index = if_nametoindex(entry->intf_name);
+	if (entry->intf_index == 0)
+		return (-1);
+
+	strlcpy(lifr.lifr_name, entry->intf_name, sizeof(lifr.lifr_name));
+
+	/* Get interface flags. Here he also check whether we need to use fd or
+	 * fd6 in the rest of the function. Using the wrong address family in
+	 * the ioctls gives ENXIO on Solaris. */
+	if (ioctl(intf->fd, SIOCGLIFFLAGS, &lifr) >= 0)
+		fd = intf->fd;
+	else if (intf->fd6 != -1 && ioctl(intf->fd6, SIOCGLIFFLAGS, &lifr) >= 0)
+		fd = intf->fd6;
+	else
+		return (-1);
+	
+	entry->intf_flags = intf_iff_to_flags(lifr.lifr_flags);
+	_intf_set_type(entry);
+	
+	/* Get interface MTU. */
+#ifdef SIOCGLIFMTU
+	if (ioctl(fd, SIOCGLIFMTU, &lifr) < 0)
+#endif
+		return (-1);
+	entry->intf_mtu = lifr.lifr_mtu;
+
+	entry->intf_addr.addr_type = entry->intf_dst_addr.addr_type =
+	    entry->intf_link_addr.addr_type = ADDR_TYPE_NONE;
+	
+	/* Get primary interface address. */
+	if (ioctl(fd, SIOCGLIFADDR, &lifr) == 0) {
+		addr_ston((struct sockaddr *)&lifr.lifr_addr, &entry->intf_addr);
+		if (ioctl(fd, SIOCGLIFNETMASK, &lifr) < 0)
+			return (-1);
+		addr_stob((struct sockaddr *)&lifr.lifr_addr, &entry->intf_addr.addr_bits);
+	}
+	/* Get other addresses. */
+	if (entry->intf_type == INTF_TYPE_TUN) {
+		if (ioctl(fd, SIOCGLIFDSTADDR, &lifr) == 0) {
+			if (addr_ston((struct sockaddr *)&lifr.lifr_addr,
+			    &entry->intf_dst_addr) < 0)
+				return (-1);
+		}
+	} else if (entry->intf_type == INTF_TYPE_ETH) {
+		eth_t *eth;
+		
+		if ((eth = eth_open(entry->intf_name)) != NULL) {
+			if (!eth_get(eth, &entry->intf_link_addr.addr_eth)) {
+				entry->intf_link_addr.addr_type =
+				    ADDR_TYPE_ETH;
+				entry->intf_link_addr.addr_bits =
+				    ETH_ADDR_BITS;
+			}
+			eth_close(eth);
+		}
+	}
+	return (0);
+}
+#else
+static int
+_intf_get_noalias(intf_t *intf, struct intf_entry *entry)
+{
+	struct ifreq ifr;
+#ifdef HAVE_GETKERNINFO
+  int size;
+  struct kinfo_ndd *nddp;
+  void *end;
+#endif
+
+	/* Get interface index. */
+	entry->intf_index = if_nametoindex(entry->intf_name);
+	if (entry->intf_index == 0)
+		return (-1);
+
+	strlcpy(ifr.ifr_name, entry->intf_name, sizeof(ifr.ifr_name));
+
+	/* Get interface flags. */
+	if (ioctl(intf->fd, SIOCGIFFLAGS, &ifr) < 0)
+		return (-1);
+	
+	entry->intf_flags = intf_iff_to_flags(ifr.ifr_flags);
+	_intf_set_type(entry);
+	
+	/* Get interface MTU. */
+#ifdef SIOCGIFMTU
+	if (ioctl(intf->fd, SIOCGIFMTU, &ifr) < 0)
+#endif
+		return (-1);
+	entry->intf_mtu = ifr.ifr_mtu;
+
+	entry->intf_addr.addr_type = entry->intf_dst_addr.addr_type =
+	    entry->intf_link_addr.addr_type = ADDR_TYPE_NONE;
+	
+	/* Get primary interface address. */
+	if (ioctl(intf->fd, SIOCGIFADDR, &ifr) == 0) {
+		addr_ston(&ifr.ifr_addr, &entry->intf_addr);
+		if (ioctl(intf->fd, SIOCGIFNETMASK, &ifr) < 0)
+			return (-1);
+		addr_stob(&ifr.ifr_addr, &entry->intf_addr.addr_bits);
+	}
+	/* Get other addresses. */
+	if (entry->intf_type == INTF_TYPE_TUN) {
+		if (ioctl(intf->fd, SIOCGIFDSTADDR, &ifr) == 0) {
+			if (addr_ston(&ifr.ifr_addr,
+			    &entry->intf_dst_addr) < 0)
+				return (-1);
+		}
+	} else if (entry->intf_type == INTF_TYPE_ETH) {
+#if defined(HAVE_GETKERNINFO)
+	  /* AIX also defines SIOCGIFHWADDR, but it fails silently?
+	   * This is the method IBM recommends here:
+	   * http://www-01.ibm.com/support/knowledgecenter/ssw_aix_53/com.ibm.aix.progcomm/doc/progcomc/skt_sndother_ex.htm%23ssqinc2joyc?lang=en
+	   */
+	  /* How many bytes will be returned? */
+    size = getkerninfo(KINFO_NDD, 0, 0, 0);
+    if (size <= 0) {
+      return -1;
+    }
+    nddp = (struct kinfo_ndd *)malloc(size);
+
+    if (!nddp) {
+      return -1;
+    }
+    /* Get all Network Device Driver (NDD) info */
+    if (getkerninfo(KINFO_NDD, nddp, &size, 0) < 0) {
+      free(nddp);
+      return -1;
+    }
+    /* Loop over the returned values until we find a match */
+    end = (void *)nddp + size;
+    while ((void *)nddp < end) {
+      if (!strcmp(nddp->ndd_alias, entry->intf_name) ||
+          !strcmp(nddp->ndd_name, entry->intf_name)) {
+        addr_pack(&entry->intf_link_addr, ADDR_TYPE_ETH, ETH_ADDR_BITS,
+            nddp->ndd_addr, ETH_ADDR_LEN);
+        break;
+      } else
+        nddp++;
+    }
+    free(nddp);
+#elif defined(SIOCGIFHWADDR)
+		if (ioctl(intf->fd, SIOCGIFHWADDR, &ifr) < 0)
+			return (-1);
+		if (addr_ston(&ifr.ifr_addr, &entry->intf_link_addr) < 0) {
+		  /* Likely we got an unsupported address type. Just use NONE for now. */
+		  entry->intf_link_addr.addr_type = ADDR_TYPE_NONE;
+		  entry->intf_link_addr.addr_bits = 0;
+    }
+#elif defined(SIOCRPHYSADDR)
+		/* Tru64 */
+		struct ifdevea *ifd = (struct ifdevea *)&ifr; /* XXX */
+		
+		if (ioctl(intf->fd, SIOCRPHYSADDR, ifd) < 0)
+			return (-1);
+		addr_pack(&entry->intf_link_addr, ADDR_TYPE_ETH, ETH_ADDR_BITS,
+		    ifd->current_pa, ETH_ADDR_LEN);
+#else
+		eth_t *eth;
+		
+		if ((eth = eth_open(entry->intf_name)) != NULL) {
+			if (!eth_get(eth, &entry->intf_link_addr.addr_eth)) {
+				entry->intf_link_addr.addr_type =
+				    ADDR_TYPE_ETH;
+				entry->intf_link_addr.addr_bits =
+				    ETH_ADDR_BITS;
+			}
+			eth_close(eth);
+		}
+#endif
+	}
+	return (0);
+}
+#endif
+
+#ifdef SIOCLIFADDR
+/* XXX - aliases on IRIX don't show up in SIOCGIFCONF */
+static int
+_intf_get_aliases(intf_t *intf, struct intf_entry *entry)
+{
+	struct dnet_ifaliasreq ifra;
+	struct addr *ap, *lap;
+	
+	strlcpy(ifra.ifra_name, entry->intf_name, sizeof(ifra.ifra_name));
+	addr_ntos(&entry->intf_addr, &ifra.ifra_addr);
+	addr_btos(entry->intf_addr.addr_bits, &ifra.ifra_mask);
+	memset(&ifra.ifra_brdaddr, 0, sizeof(ifra.ifra_brdaddr));
+	ifra.ifra_cookie = 1;
+
+	ap = entry->intf_alias_addrs;
+	lap = (struct addr *)((u_char *)entry + entry->intf_len);
+	
+	while (ioctl(intf->fd, SIOCLIFADDR, &ifra) == 0 &&
+	    ifra.ifra_cookie > 0 && (ap + 1) < lap) {
+		if (addr_ston(&ifra.ifra_addr, ap) < 0)
+			break;
+		ap++, entry->intf_alias_num++;
+	}
+	entry->intf_len = (u_char *)ap - (u_char *)entry;
+	
+	return (0);
+}
+#elif defined(SIOCGLIFCONF)
+static int
+_intf_get_aliases(intf_t *intf, struct intf_entry *entry)
+{
+	struct lifreq *lifr, *llifr;
+	struct lifreq tmplifr;
+	struct addr *ap, *lap;
+	char *p;
+	
+	if (intf->lifc.lifc_len < (int)sizeof(*lifr)) {
+		errno = EINVAL;
+		return (-1);
+	}
+	entry->intf_alias_num = 0;
+	ap = entry->intf_alias_addrs;
+	llifr = (struct lifreq *)intf->lifc.lifc_buf + 
+	    (intf->lifc.lifc_len / sizeof(*llifr));
+	lap = (struct addr *)((u_char *)entry + entry->intf_len);
+	
+	/* Get addresses for this interface. */
+	for (lifr = intf->lifc.lifc_req; lifr < llifr && (ap + 1) < lap;
+	    lifr = NEXTLIFR(lifr)) {
+		/* XXX - Linux, Solaris ifaliases */
+		if ((p = strchr(lifr->lifr_name, ':')) != NULL)
+			*p = '\0';
+		
+		if (strcmp(lifr->lifr_name, entry->intf_name) != 0) {
+			if (p) *p = ':';
+			continue;
+		}
+		
+		/* Fix the name back up */
+		if (p) *p = ':';
+
+		if (addr_ston((struct sockaddr *)&lifr->lifr_addr, ap) < 0)
+			continue;
+		
+		/* XXX */
+		if (ap->addr_type == ADDR_TYPE_ETH) {
+			memcpy(&entry->intf_link_addr, ap, sizeof(*ap));
+			continue;
+		} else if (ap->addr_type == ADDR_TYPE_IP) {
+			if (ap->addr_ip == entry->intf_addr.addr_ip ||
+			    ap->addr_ip == entry->intf_dst_addr.addr_ip)
+				continue;
+			strlcpy(tmplifr.lifr_name, lifr->lifr_name, sizeof(tmplifr.lifr_name));
+			if (ioctl(intf->fd, SIOCGIFNETMASK, &tmplifr) == 0)
+				addr_stob((struct sockaddr *)&tmplifr.lifr_addr, &ap->addr_bits);
+		} else if (ap->addr_type == ADDR_TYPE_IP6 && intf->fd6 != -1) {
+			if (memcmp(&ap->addr_ip6, &entry->intf_addr.addr_ip6, IP6_ADDR_LEN) == 0 ||
+			    memcmp(&ap->addr_ip6, &entry->intf_dst_addr.addr_ip6, IP6_ADDR_LEN) == 0)
+				continue;
+			strlcpy(tmplifr.lifr_name, lifr->lifr_name, sizeof(tmplifr.lifr_name));
+			if (ioctl(intf->fd6, SIOCGLIFNETMASK, &tmplifr) == 0) {
+				addr_stob((struct sockaddr *)&tmplifr.lifr_addr,
+				    &ap->addr_bits);
+			}
+			else perror("SIOCGLIFNETMASK");
+		}
+		ap++, entry->intf_alias_num++;
+	}
+	entry->intf_len = (u_char *)ap - (u_char *)entry;
+	
+	return (0);
+}
+#else
+static int
+_intf_get_aliases(intf_t *intf, struct intf_entry *entry)
+{
+	struct ifreq *ifr, *lifr;
+	struct ifreq tmpifr;
+	struct addr *ap, *lap;
+	char *p;
+	
+	if (intf->ifc.ifc_len < (int)sizeof(*ifr) && intf->ifc.ifc_len != 0) {
+		errno = EINVAL;
+		return (-1);
+	}
+	entry->intf_alias_num = 0;
+	ap = entry->intf_alias_addrs;
+	lifr = (struct ifreq *)intf->ifc.ifc_buf + 
+	    (intf->ifc.ifc_len / sizeof(*lifr));
+	lap = (struct addr *)((u_char *)entry + entry->intf_len);
+	
+	/* Get addresses for this interface. */
+	for (ifr = intf->ifc.ifc_req; ifr < lifr && (ap + 1) < lap;
+	    ifr = NEXTIFR(ifr)) {
+		/* XXX - Linux, Solaris ifaliases */
+		if ((p = strchr(ifr->ifr_name, ':')) != NULL)
+			*p = '\0';
+		
+		if (strcmp(ifr->ifr_name, entry->intf_name) != 0) {
+			if (p) *p = ':';
+			continue;
+		}
+		
+		/* Fix the name back up */
+		if (p) *p = ':';
+
+		if (addr_ston(&ifr->ifr_addr, ap) < 0)
+			continue;
+		
+		/* XXX */
+		if (ap->addr_type == ADDR_TYPE_ETH) {
+			memcpy(&entry->intf_link_addr, ap, sizeof(*ap));
+			continue;
+		} else if (ap->addr_type == ADDR_TYPE_IP) {
+			if (ap->addr_ip == entry->intf_addr.addr_ip ||
+			    ap->addr_ip == entry->intf_dst_addr.addr_ip)
+				continue;
+			strlcpy(tmpifr.ifr_name, ifr->ifr_name, sizeof(tmpifr.ifr_name));
+			if (ioctl(intf->fd, SIOCGIFNETMASK, &tmpifr) == 0)
+				addr_stob(&tmpifr.ifr_addr, &ap->addr_bits);
+		}
+#ifdef SIOCGIFNETMASK_IN6
+		else if (ap->addr_type == ADDR_TYPE_IP6 && intf->fd6 != -1) {
+			struct in6_ifreq ifr6;
+
+			/* XXX - sizeof(ifr) < sizeof(ifr6) */
+			memcpy(&ifr6, ifr, sizeof(ifr6));
+			
+			if (ioctl(intf->fd6, SIOCGIFNETMASK_IN6, &ifr6) == 0) {
+				addr_stob((struct sockaddr *)&ifr6.ifr_addr,
+				    &ap->addr_bits);
+			}
+			else perror("SIOCGIFNETMASK_IN6");
+		}
+#else
+#ifdef SIOCGIFNETMASK6
+		else if (ap->addr_type == ADDR_TYPE_IP6 && intf->fd6 != -1) {
+			struct in6_ifreq ifr6;
+
+			/* XXX - sizeof(ifr) < sizeof(ifr6) */
+			memcpy(&ifr6, ifr, sizeof(ifr6));
+			
+			if (ioctl(intf->fd6, SIOCGIFNETMASK6, &ifr6) == 0) {
+				/* For some reason this is 0 after the ioctl. */
+				ifr6.ifr_Addr.sin6_family = AF_INET6;
+				addr_stob((struct sockaddr *)&ifr6.ifr_Addr,
+				    &ap->addr_bits);
+			}
+			else perror("SIOCGIFNETMASK6");
+		}
+#endif
+#endif
+		ap++, entry->intf_alias_num++;
+	}
+#ifdef HAVE_LINUX_PROCFS
+#define PROC_INET6_FILE	"/proc/net/if_inet6"
+	{
+		FILE *f;
+		char buf[256], s[8][5], name[INTF_NAME_LEN];
+		u_int idx, bits, scope, flags;
+		
+		if ((f = fopen(PROC_INET6_FILE, "r")) != NULL) {
+			while (ap < lap &&
+			       fgets(buf, sizeof(buf), f) != NULL) {
+				/* scan up to INTF_NAME_LEN-1 bytes to reserve space for null terminator */
+				sscanf(buf, "%04s%04s%04s%04s%04s%04s%04s%04s %x %02x %02x %02x %15s\n",
+				    s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
+				    &idx, &bits, &scope, &flags, name);
+				if (strcmp(name, entry->intf_name) == 0) {
+					snprintf(buf, sizeof(buf), "%s:%s:%s:%s:%s:%s:%s:%s/%d",
+					    s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], bits);
+					addr_aton(buf, ap);
+					ap++, entry->intf_alias_num++;
+				}
+			}
+			fclose(f);
+		}
+	}
+#endif
+	entry->intf_len = (u_char *)ap - (u_char *)entry;
+	
+	return (0);
+}
+#endif /* SIOCLIFADDR */
+
+int
+intf_get(intf_t *intf, struct intf_entry *entry)
+{
+	if (_intf_get_noalias(intf, entry) < 0)
+		return (-1);
+#ifndef SIOCLIFADDR
+	intf->ifc.ifc_buf = (caddr_t)intf->ifcbuf;
+	intf->ifc.ifc_len = sizeof(intf->ifcbuf);
+	
+	if (ioctl(intf->fd, SIOCGIFCONF, &intf->ifc) < 0)
+		return (-1);
+#endif
+	return (_intf_get_aliases(intf, entry));
+}
+
+/* Look up an interface from an index, such as a sockaddr_in6.sin6_scope_id. */
+int
+intf_get_index(intf_t *intf, struct intf_entry *entry, int af, unsigned int index)
+{
+	char namebuf[IFNAMSIZ];
+	char *devname;
+
+	/* af is ignored; only used in intf-win32.c. */
+	devname = if_indextoname(index, namebuf);
+	if (devname == NULL)
+		return (-1);
+	strlcpy(entry->intf_name, devname, sizeof(entry->intf_name));
+	return intf_get(intf, entry);
+}
+
+static int
+_match_intf_src(const struct intf_entry *entry, void *arg)
+{
+	struct intf_entry *save = (struct intf_entry *)arg;
+	int matched = 0, cnt;
+	
+	if (entry->intf_addr.addr_type == ADDR_TYPE_IP &&
+	    entry->intf_addr.addr_ip == save->intf_addr.addr_ip)
+		matched = 1;
+
+	for (cnt = 0; !matched && cnt < (int) entry->intf_alias_num; cnt++) {
+		if (entry->intf_alias_addrs[cnt].addr_type != ADDR_TYPE_IP)
+			continue;
+		if (entry->intf_alias_addrs[cnt].addr_ip == save->intf_addr.addr_ip)
+			matched = 1;
+	}
+
+	if (matched) {
+		/* XXX - truncated result if entry is too small. */
+		if (save->intf_len < entry->intf_len)
+			memcpy(save, entry, save->intf_len);
+		else
+			memcpy(save, entry, entry->intf_len);
+		return (1);
+	}
+	return (0);
+}
+
+int
+intf_get_src(intf_t *intf, struct intf_entry *entry, struct addr *src)
+{
+	memcpy(&entry->intf_addr, src, sizeof(*src));
+	
+	if (intf_loop(intf, _match_intf_src, entry) != 1) {
+		errno = ENXIO;
+		return (-1);
+	}
+	return (0);
+}
+
+int
+intf_get_dst(intf_t *intf, struct intf_entry *entry, struct addr *dst)
+{
+	struct sockaddr_in sin;
+	socklen_t n;
+	
+	if (dst->addr_type != ADDR_TYPE_IP) {
+		errno = EINVAL;
+		return (-1);
+	}
+	addr_ntos(dst, (struct sockaddr *)&sin);
+	sin.sin_port = htons(666);
+	
+	if (connect(intf->fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
+		return (-1);
+	
+	n = sizeof(sin);
+	if (getsockname(intf->fd, (struct sockaddr *)&sin, &n) < 0)
+		return (-1);
+	
+	addr_ston((struct sockaddr *)&sin, &entry->intf_addr);
+	
+	if (intf_loop(intf, _match_intf_src, entry) != 1)
+		return (-1);
+	
+	return (0);
+}
+
+#ifdef HAVE_LINUX_PROCFS
+#define PROC_DEV_FILE	"/proc/net/dev"
+
+int
+intf_loop(intf_t *intf, intf_handler callback, void *arg)
+{
+	FILE *fp;
+	struct intf_entry *entry;
+	char *p, buf[BUFSIZ], ebuf[BUFSIZ];
+	int ret;
+
+	entry = (struct intf_entry *)ebuf;
+	
+	if ((fp = fopen(PROC_DEV_FILE, "r")) == NULL)
+		return (-1);
+	
+	intf->ifc.ifc_buf = (caddr_t)intf->ifcbuf;
+	intf->ifc.ifc_len = sizeof(intf->ifcbuf);
+	
+	if (ioctl(intf->fd, SIOCGIFCONF, &intf->ifc) < 0) {
+		fclose(fp);
+		return (-1);
+	}
+
+	ret = 0;
+	while (fgets(buf, sizeof(buf), fp) != NULL) {
+		if ((p = strchr(buf, ':')) == NULL)
+			continue;
+		*p = '\0';
+		for (p = buf; *p == ' '; p++)
+			;
+
+		memset(ebuf, 0, sizeof(ebuf));
+		strlcpy(entry->intf_name, p, sizeof(entry->intf_name));
+		entry->intf_len = sizeof(ebuf);
+		
+		if (_intf_get_noalias(intf, entry) < 0) {
+			ret = -1;
+			break;
+		}
+		if (_intf_get_aliases(intf, entry) < 0) {
+			ret = -1;
+			break;
+		}
+		if ((ret = (*callback)(entry, arg)) != 0)
+			break;
+	}
+	if (ferror(fp))
+		ret = -1;
+	
+	fclose(fp);
+	
+	return (ret);
+}
+#elif defined(SIOCGLIFCONF)
+int
+intf_loop(intf_t *intf, intf_handler callback, void *arg)
+{
+	struct intf_entry *entry;
+	struct lifreq *lifr, *llifr, *plifr;
+	char *p, ebuf[BUFSIZ];
+	int ret;
+	struct lifreq lifrflags;
+	memset(&lifrflags, 0, sizeof(struct lifreq));
+
+	entry = (struct intf_entry *)ebuf;
+
+	/* http://www.unix.com/man-page/opensolaris/7p/if_tcp */
+	intf->lifc.lifc_family = AF_UNSPEC;
+	intf->lifc.lifc_flags = 0;
+#ifdef LIFC_UNDER_IPMP
+	intf->lifc.lifc_flags |= LIFC_UNDER_IPMP;
+#endif
+	intf->lifc.lifc_buf = (caddr_t)intf->ifcbuf;
+	intf->lifc.lifc_len = sizeof(intf->ifcbuf);
+	
+	if (ioctl(intf->fd, SIOCGLIFCONF, &intf->lifc) < 0)
+		return (-1);
+
+	llifr = (struct lifreq *)&intf->lifc.lifc_buf[intf->lifc.lifc_len];
+	
+	for (lifr = intf->lifc.lifc_req; lifr < llifr; lifr = NEXTLIFR(lifr)) {
+		/* XXX - Linux, Solaris ifaliases */
+		if ((p = strchr(lifr->lifr_name, ':')) != NULL)
+			*p = '\0';
+		
+		for (plifr = intf->lifc.lifc_req; plifr < lifr; plifr = NEXTLIFR(lifr)) {
+			if (strcmp(lifr->lifr_name, plifr->lifr_name) == 0)
+				break;
+		}
+		if (lifr > intf->lifc.lifc_req && plifr < lifr)
+			continue;
+
+		memset(ebuf, 0, sizeof(ebuf));
+		strlcpy(entry->intf_name, lifr->lifr_name,
+		    sizeof(entry->intf_name));
+		entry->intf_len = sizeof(ebuf);
+
+		/* Repair the alias name back up */
+		if (p) *p = ':';
+
+		/* Ignore IPMP interfaces. These are virtual interfaces made up
+		 * of physical interfaces. IPMP interfaces do not support things
+		 * like packet sniffing; it is necessary to use one of the
+		 * underlying physical interfaces instead. This works as long as
+		 * the physical interface's test address is on the same subnet
+		 * as the IPMP interface's address. */
+		strlcpy(lifrflags.lifr_name, lifr->lifr_name, sizeof(lifrflags.lifr_name));
+		if (ioctl(intf->fd, SIOCGLIFFLAGS, &lifrflags) >= 0)
+			;
+		else if (intf->fd6 != -1 && ioctl(intf->fd6, SIOCGLIFFLAGS, &lifrflags) >= 0)
+			;
+		else
+			return (-1);
+#ifdef IFF_IPMP
+		if (lifrflags.lifr_flags & IFF_IPMP) {
+			continue;
+		}
+#endif
+		
+		if (_intf_get_noalias(intf, entry) < 0)
+			return (-1);
+		if (_intf_get_aliases(intf, entry) < 0)
+			return (-1);
+		
+		if ((ret = (*callback)(entry, arg)) != 0)
+			return (ret);
+	}
+	return (0);
+}
+#else
+int
+intf_loop(intf_t *intf, intf_handler callback, void *arg)
+{
+	struct intf_entry *entry;
+	struct ifreq *ifr, *lifr, *pifr;
+	char *p, ebuf[BUFSIZ];
+	int ret;
+
+	entry = (struct intf_entry *)ebuf;
+
+	intf->ifc.ifc_buf = (caddr_t)intf->ifcbuf;
+	intf->ifc.ifc_len = sizeof(intf->ifcbuf);
+	
+	if (ioctl(intf->fd, SIOCGIFCONF, &intf->ifc) < 0)
+		return (-1);
+
+	pifr = NULL;
+	lifr = (struct ifreq *)&intf->ifc.ifc_buf[intf->ifc.ifc_len];
+	
+	for (ifr = intf->ifc.ifc_req; ifr < lifr; ifr = NEXTIFR(ifr)) {
+		/* XXX - Linux, Solaris ifaliases */
+		if ((p = strchr(ifr->ifr_name, ':')) != NULL)
+			*p = '\0';
+		
+		if (pifr != NULL && strcmp(ifr->ifr_name, pifr->ifr_name) == 0) {
+			if (p) *p = ':';
+			continue;
+		}
+
+		memset(ebuf, 0, sizeof(ebuf));
+		strlcpy(entry->intf_name, ifr->ifr_name,
+		    sizeof(entry->intf_name));
+		entry->intf_len = sizeof(ebuf);
+
+		/* Repair the alias name back up */
+		if (p) *p = ':';
+		
+		if (_intf_get_noalias(intf, entry) < 0)
+			return (-1);
+		if (_intf_get_aliases(intf, entry) < 0)
+			return (-1);
+		
+		if ((ret = (*callback)(entry, arg)) != 0)
+			return (ret);
+
+		pifr = ifr;
+	}
+	return (0);
+}
+#endif /* !HAVE_LINUX_PROCFS */
+
+intf_t *
+intf_close(intf_t *intf)
+{
+	if (intf != NULL) {
+		if (intf->fd >= 0)
+			close(intf->fd);
+		if (intf->fd6 >= 0)
+			close(intf->fd6);
+		free(intf);
+	}
+	return (NULL);
+}