Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libpcap/fad-getad.c	Lines:	0	145	0.0 %
Date:	2017-11-07	Branches:	0	92	0.0 %


/* -*- Mode: c; tab-width: 8; indent-tabs-mode: 1; c-basic-offset: 8; -*- */
/*
 * Copyright (c) 1994, 1995, 1996, 1997, 1998
 *	The Regents of the University of California.  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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the Computer Systems
 *	Engineering Group at Lawrence Berkeley Laboratory.
 * 4. Neither the name of the University nor of the Laboratory may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include <net/if.h>

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ifaddrs.h>
#include <limits.h>

#include "pcap-int.h"

static struct sockaddr *
dup_sockaddr(struct sockaddr *sa, size_t sa_length)
{
	struct sockaddr *newsa;

	if ((newsa = malloc(sa_length)) == NULL)
		return (NULL);
	return (memcpy(newsa, sa, sa_length));
}

static int
get_instance(const char *name)
{
	const char *cp, *endcp;
	int n;

	if (strcmp(name, "any") == 0) {
		/*
		 * Give the "any" device an artificially high instance
		 * number, so it shows up after all other non-loopback
		 * interfaces.
		 */
		return INT_MAX;
	}

	endcp = name + strlen(name);
	for (cp = name; cp < endcp && !isdigit((unsigned char)*cp); ++cp)
		continue;

	if (isdigit((unsigned char)*cp))
		n = atoi(cp);
	else
		n = 0;
	return (n);
}

static int
add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
    u_int flags, const char *description, char *errbuf)
{
	pcap_t *p;
	pcap_if_t *curdev, *prevdev, *nextdev;
	int this_instance;
	size_t len;

	/*
	 * Can we open this interface for live capture?
	 *
	 * We do this check so that interfaces that are supplied
	 * by the interface enumeration mechanism we're using
	 * but that don't support packet capture aren't included
	 * in the list.  An example of this is loopback interfaces
	 * on Solaris; we don't just omit loopback interfaces
	 * becaue you *can* capture on loopback interfaces on some
	 * OSes.
	 */
	p = pcap_open_live(name, 68, 0, 0, errbuf);
	if (p == NULL) {
		/*
		 * No.  Don't bother including it.
		 * Don't treat this as an error, though.
		 */
		*curdev_ret = NULL;
		return (0);
	}
	pcap_close(p);

	/*
	 * Is there already an entry in the list for this interface?
	 */
	for (curdev = *alldevs; curdev != NULL; curdev = curdev->next) {
		if (strcmp(name, curdev->name) == 0)
			break;	/* yes, we found it */
	}
	if (curdev == NULL) {
		/*
		 * No, we didn't find it.
		 * Allocate a new entry.
		 */
		curdev = calloc(1, sizeof(pcap_if_t));
		if (curdev == NULL) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "calloc: %s", pcap_strerror(errno));
			goto fail;
		}

		/*
		 * Fill in the entry.
		 */
		curdev->next = NULL;
		len = strlen(name) + 1;
		curdev->name = malloc(len);
		if (curdev->name == NULL) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "malloc: %s", pcap_strerror(errno));
			goto fail;
		}
		strlcpy(curdev->name, name, len);
		if (description != NULL) {
			/*
			 * We have a description for this interface.
			 */
			len = strlen(description) + 1;
			curdev->description = malloc(len);
			if (curdev->description == NULL) {
				(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
				    "malloc: %s", pcap_strerror(errno));
				goto fail;
			}
			strlcpy(curdev->description, description, len);
		}
		curdev->addresses = NULL;	/* list starts out as empty */
		curdev->flags = 0;
		if (ISLOOPBACK(name, flags))
			curdev->flags |= PCAP_IF_LOOPBACK;

		/*
		 * Add it to the list, in the appropriate location.
		 * First, get the instance number of this interface.
		 */
		this_instance = get_instance(name);

		/*
		 * Now look for the last interface with an instance number
		 * less than or equal to the new interface's instance
		 * number - except that non-loopback interfaces are
		 * arbitrarily treated as having interface numbers less
		 * than those of loopback interfaces, so the loopback
		 * interfaces are put at the end of the list.
		 *
		 * We start with "prevdev" being NULL, meaning we're before
		 * the first element in the list.
		 */
		prevdev = NULL;
		for (;;) {
			/*
			 * Get the interface after this one.
			 */
			if (prevdev == NULL) {
				/*
				 * The next element is the first element.
				 */
				nextdev = *alldevs;
			} else
				nextdev = prevdev->next;

			/*
			 * Are we at the end of the list?
			 */
			if (nextdev == NULL) {
				/*
				 * Yes - we have to put the new entry
				 * after "prevdev".
				 */
				break;
			}

			/*
			 * Is the new interface a non-loopback interface
			 * and the next interface a loopback interface?
			 */
			if (!(curdev->flags & PCAP_IF_LOOPBACK) &&
			    (nextdev->flags & PCAP_IF_LOOPBACK)) {
				/*
				 * Yes, we should put the new entry
				 * before "nextdev", i.e. after "prevdev".
				 */
				break;
			}

			/*
			 * Is the new interface's instance number less
			 * than the next interface's instance number,
			 * and is it the case that the new interface is a
			 * non-loopback interface or the next interface is
			 * a loopback interface?
			 *
			 * (The goal of both loopback tests is to make
			 * sure that we never put a loopback interface
			 * before any non-loopback interface and that we
			 * always put a non-loopback interface before all
			 * loopback interfaces.)
			 */
			if (this_instance < get_instance(nextdev->name) &&
			    (!(curdev->flags & PCAP_IF_LOOPBACK) ||
			       (nextdev->flags & PCAP_IF_LOOPBACK))) {
				/*
				 * Yes - we should put the new entry
				 * before "nextdev", i.e. after "prevdev".
				 */
				break;
			}

			prevdev = nextdev;
		}

		/*
		 * Insert before "nextdev".
		 */
		curdev->next = nextdev;

		/*
		 * Insert after "prevdev" - unless "prevdev" is null,
		 * in which case this is the first interface.
		 */
		if (prevdev == NULL) {
			/*
			 * This is the first interface.  Pass back a
			 * pointer to it, and put "curdev" before
			 * "nextdev".
			 */
			*alldevs = curdev;
		} else
			prevdev->next = curdev;
	}

	*curdev_ret = curdev;
	return (0);

fail:
	if (curdev != NULL) {
		free(curdev->name);
		free(curdev->description);
		free(curdev);
	}
	return (-1);
}

static int
add_addr_to_iflist(pcap_if_t **alldevs, const char *name, u_int flags,
    struct sockaddr *addr, size_t addr_size,
    struct sockaddr *netmask, size_t netmask_size,
    struct sockaddr *broadaddr, size_t broadaddr_size,
    struct sockaddr *dstaddr, size_t dstaddr_size,
    char *errbuf)
{
	pcap_if_t *curdev;
	pcap_addr_t *curaddr, *prevaddr, *nextaddr;

	if (add_or_find_if(&curdev, alldevs, name, flags, NULL, errbuf) == -1) {
		/*
		 * Error - give up.
		 */
		return (-1);
	}
	if (curdev == NULL) {
		/*
		 * Device wasn't added because it can't be opened.
		 * Not a fatal error.
		 */
		return (0);
	}

	/*
	 * "curdev" is an entry for this interface; add an entry for this
	 * address to its list of addresses.
	 *
	 * Allocate the new entry and fill it in.
	 */
	curaddr = calloc(1, sizeof(pcap_addr_t));
	if (curaddr == NULL) {
		(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
		    "calloc: %s", pcap_strerror(errno));
		goto fail;
	}

	curaddr->next = NULL;
	if (addr != NULL) {
		curaddr->addr = dup_sockaddr(addr, addr_size);
		if (curaddr->addr == NULL) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "malloc: %s", pcap_strerror(errno));
			goto fail;
		}
	}

	if (netmask != NULL) {
		curaddr->netmask = dup_sockaddr(netmask, netmask_size);
		if (curaddr->netmask == NULL) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "malloc: %s", pcap_strerror(errno));
			goto fail;
		}
	}

	if (broadaddr != NULL) {
		curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size);
		if (curaddr->broadaddr == NULL) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "malloc: %s", pcap_strerror(errno));
			goto fail;
		}
	}

	if (dstaddr != NULL) {
		curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size);
		if (curaddr->dstaddr == NULL) {
			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
			    "malloc: %s", pcap_strerror(errno));
			goto fail;
		}
	}

	/*
	 * Find the end of the list of addresses.
	 */
	for (prevaddr = curdev->addresses; prevaddr != NULL;
	    prevaddr = nextaddr) {
		nextaddr = prevaddr->next;
		if (nextaddr == NULL) {
			/*
			 * This is the end of the list.
			 */
			break;
		}
	}

	if (prevaddr == NULL) {
		/*
		 * The list was empty; this is the first member.
		 */
		curdev->addresses = curaddr;
	} else {
		/*
		 * "prevaddr" is the last member of the list; append
		 * this member to it.
		 */
		prevaddr->next = curaddr;
	}

	return (0);

fail:
	if (curaddr != NULL) {
		free(curaddr->addr);
		free(curaddr->netmask);
		free(curaddr->broadaddr);
		free(curaddr->dstaddr);
		free(curaddr);
	}
	return (-1);
}

/*
 * Get a list of all interfaces that are up and that we can open.
 * Returns -1 on error, 0 otherwise.
 * The list, as returned through "alldevsp", may be null if no interfaces
 * were up and could be opened.
 *
 * This is the implementation used on platforms that have "getifaddrs()".
 */
int
pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf)
{
	pcap_if_t *devlist = NULL;
	struct ifaddrs *ifap, *ifa;
	struct sockaddr *addr, *netmask, *broadaddr, *dstaddr;
	size_t addr_size, broadaddr_size, dstaddr_size;
	int ret = 0;

	/*
	 * Get the list of interface addresses.
	 *
	 * Note: this won't return information about interfaces
	 * with no addresses; are there any such interfaces
	 * that would be capable of receiving packets?
	 * (Interfaces incapable of receiving packets aren't
	 * very interesting from libpcap's point of view.)
	 *
	 * LAN interfaces will probably have link-layer
	 * addresses; I don't know whether all implementations
	 * of "getifaddrs()" now, or in the future, will return
	 * those.
	 */
	if (getifaddrs(&ifap) != 0) {
		(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
		    "getifaddrs: %s", pcap_strerror(errno));
		return (-1);
	}
	for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
		/*
		 * Is this interface up?
		 */
		if (!(ifa->ifa_flags & IFF_UP)) {
			/*
			 * No, so don't add it to the list.
			 */
			continue;
		}

		/*
		 * "ifa_addr" was apparently null on at least one
		 * interface on some system.
		 *
		 * "ifa_broadaddr" may be non-null even on
		 * non-broadcast interfaces, and was null on
		 * at least one OpenBSD 3.4 system on at least
		 * one interface with IFF_BROADCAST set.
		 *
		 * "ifa_dstaddr" was, on at least one FreeBSD 4.1
		 * system, non-null on a non-point-to-point
		 * interface.
		 *
		 * Therefore, we supply the address and netmask only
		 * if "ifa_addr" is non-null (if there's no address,
		 * there's obviously no netmask), and supply the
		 * broadcast and destination addresses if the appropriate
		 * flag is set *and* the appropriate "ifa_" entry doesn't
		 * evaluate to a null pointer.
		 */
		if (ifa->ifa_addr != NULL) {
			addr = ifa->ifa_addr;
			addr_size = SA_LEN(addr);
			netmask = ifa->ifa_netmask;
		} else {
			addr = NULL;
			addr_size = 0;
			netmask = NULL;
		}
		if (ifa->ifa_flags & IFF_BROADCAST &&
		    ifa->ifa_broadaddr != NULL) {
			broadaddr = ifa->ifa_broadaddr;
			broadaddr_size = SA_LEN(broadaddr);
		} else {
			broadaddr = NULL;
			broadaddr_size = 0;
		}
		if (ifa->ifa_flags & IFF_POINTOPOINT &&
		    ifa->ifa_dstaddr != NULL) {
			dstaddr = ifa->ifa_dstaddr;
			dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
		} else {
			dstaddr = NULL;
			dstaddr_size = 0;
		}

		/*
		 * Add information for this address to the list.
		 */
		if (add_addr_to_iflist(&devlist, ifa->ifa_name,
		    ifa->ifa_flags, addr, addr_size, netmask, addr_size,
		    broadaddr, broadaddr_size, dstaddr, dstaddr_size,
		    errbuf) < 0) {
			ret = -1;
			break;
		}
	}

	freeifaddrs(ifap);

	if (ret == -1) {
		/*
		 * We had an error; free the list we've been constructing.
		 */
		if (devlist != NULL) {
			pcap_freealldevs(devlist);
			devlist = NULL;
		}
	}

	*alldevsp = devlist;
	return (ret);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* -- Mode: c; tab-width: 8; indent-tabs-mode: 1; c-basic-offset: 8; -- */
2			/*
3			* Copyright (c) 1994, 1995, 1996, 1997, 1998
4			* The Regents of the University of California. All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions
8			* are met:
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			* 2. Redistributions in binary form must reproduce the above copyright
12			* notice, this list of conditions and the following disclaimer in the
13			* documentation and/or other materials provided with the distribution.
14			* 3. All advertising materials mentioning features or use of this software
15			* must display the following acknowledgement:
16			* This product includes software developed by the Computer Systems
17			* Engineering Group at Lawrence Berkeley Laboratory.
18			* 4. Neither the name of the University nor of the Laboratory may be used
19			* to endorse or promote products derived from this software without
20			* specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32			* SUCH DAMAGE.
33			*/
34
35			#include <sys/types.h>
36			#include <sys/socket.h>
37			#include <netinet/in.h>
38
39			#include <net/if.h>
40
41			#include <ctype.h>
42			#include <errno.h>
43			#include <stdio.h>
44			#include <stdlib.h>
45			#include <string.h>
46			#include <ifaddrs.h>
47			#include <limits.h>
48
49			#include "pcap-int.h"
50
51			static struct sockaddr *
52			dup_sockaddr(struct sockaddr *sa, size_t sa_length)
53			{
54			struct sockaddr *newsa;
55
56			if ((newsa = malloc(sa_length)) == NULL)
57			return (NULL);
58			return (memcpy(newsa, sa, sa_length));
59			}
60
61			static int
62			get_instance(const char *name)
63			{
64			const char cp, endcp;
65			int n;
66
67			if (strcmp(name, "any") == 0) {
68			/*
69			* Give the "any" device an artificially high instance
70			* number, so it shows up after all other non-loopback
71			* interfaces.
72			*/
73			return INT_MAX;
74			}
75
76			endcp = name + strlen(name);
77			for (cp = name; cp < endcp && !isdigit((unsigned char)*cp); ++cp)
78			continue;
79
80			if (isdigit((unsigned char)*cp))
81			n = atoi(cp);
82			else
83			n = 0;
84			return (n);
85			}
86
87			static int
88			add_or_find_if(pcap_if_t curdev_ret, pcap_if_t alldevs, const char *name,
89			u_int flags, const char description, char errbuf)
90			{
91			pcap_t *p;
92			pcap_if_t curdev, prevdev, *nextdev;
93			int this_instance;
94			size_t len;
95
96			/*
97			* Can we open this interface for live capture?
98			*
99			* We do this check so that interfaces that are supplied
100			* by the interface enumeration mechanism we're using
101			* but that don't support packet capture aren't included
102			* in the list. An example of this is loopback interfaces
103			* on Solaris; we don't just omit loopback interfaces
104			* becaue you can capture on loopback interfaces on some
105			* OSes.
106			*/
107			p = pcap_open_live(name, 68, 0, 0, errbuf);
108			if (p == NULL) {
109			/*
110			* No. Don't bother including it.
111			* Don't treat this as an error, though.
112			*/
113			*curdev_ret = NULL;
114			return (0);
115			}
116			pcap_close(p);
117
118			/*
119			* Is there already an entry in the list for this interface?
120			*/
121			for (curdev = *alldevs; curdev != NULL; curdev = curdev->next) {
122			if (strcmp(name, curdev->name) == 0)
123			break; /* yes, we found it */
124			}
125			if (curdev == NULL) {
126			/*
127			* No, we didn't find it.
128			* Allocate a new entry.
129			*/
130			curdev = calloc(1, sizeof(pcap_if_t));
131			if (curdev == NULL) {
132			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
133			"calloc: %s", pcap_strerror(errno));
134			goto fail;
135			}
136
137			/*
138			* Fill in the entry.
139			*/
140			curdev->next = NULL;
141			len = strlen(name) + 1;
142			curdev->name = malloc(len);
143			if (curdev->name == NULL) {
144			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
145			"malloc: %s", pcap_strerror(errno));
146			goto fail;
147			}
148			strlcpy(curdev->name, name, len);
149			if (description != NULL) {
150			/*
151			* We have a description for this interface.
152			*/
153			len = strlen(description) + 1;
154			curdev->description = malloc(len);
155			if (curdev->description == NULL) {
156			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
157			"malloc: %s", pcap_strerror(errno));
158			goto fail;
159			}
160			strlcpy(curdev->description, description, len);
161			}
162			curdev->addresses = NULL; /* list starts out as empty */
163			curdev->flags = 0;
164			if (ISLOOPBACK(name, flags))
165			curdev->flags \|= PCAP_IF_LOOPBACK;
166
167			/*
168			* Add it to the list, in the appropriate location.
169			* First, get the instance number of this interface.
170			*/
171			this_instance = get_instance(name);
172
173			/*
174			* Now look for the last interface with an instance number
175			* less than or equal to the new interface's instance
176			* number - except that non-loopback interfaces are
177			* arbitrarily treated as having interface numbers less
178			* than those of loopback interfaces, so the loopback
179			* interfaces are put at the end of the list.
180			*
181			* We start with "prevdev" being NULL, meaning we're before
182			* the first element in the list.
183			*/
184			prevdev = NULL;
185			for (;;) {
186			/*
187			* Get the interface after this one.
188			*/
189			if (prevdev == NULL) {
190			/*
191			* The next element is the first element.
192			*/
193			nextdev = *alldevs;
194			} else
195			nextdev = prevdev->next;
196
197			/*
198			* Are we at the end of the list?
199			*/
200			if (nextdev == NULL) {
201			/*
202			* Yes - we have to put the new entry
203			* after "prevdev".
204			*/
205			break;
206			}
207
208			/*
209			* Is the new interface a non-loopback interface
210			* and the next interface a loopback interface?
211			*/
212			if (!(curdev->flags & PCAP_IF_LOOPBACK) &&
213			(nextdev->flags & PCAP_IF_LOOPBACK)) {
214			/*
215			* Yes, we should put the new entry
216			* before "nextdev", i.e. after "prevdev".
217			*/
218			break;
219			}
220
221			/*
222			* Is the new interface's instance number less
223			* than the next interface's instance number,
224			* and is it the case that the new interface is a
225			* non-loopback interface or the next interface is
226			* a loopback interface?
227			*
228			* (The goal of both loopback tests is to make
229			* sure that we never put a loopback interface
230			* before any non-loopback interface and that we
231			* always put a non-loopback interface before all
232			* loopback interfaces.)
233			*/
234			if (this_instance < get_instance(nextdev->name) &&
235			(!(curdev->flags & PCAP_IF_LOOPBACK) \|\|
236			(nextdev->flags & PCAP_IF_LOOPBACK))) {
237			/*
238			* Yes - we should put the new entry
239			* before "nextdev", i.e. after "prevdev".
240			*/
241			break;
242			}
243
244			prevdev = nextdev;
245			}
246
247			/*
248			* Insert before "nextdev".
249			*/
250			curdev->next = nextdev;
251
252			/*
253			* Insert after "prevdev" - unless "prevdev" is null,
254			* in which case this is the first interface.
255			*/
256			if (prevdev == NULL) {
257			/*
258			* This is the first interface. Pass back a
259			* pointer to it, and put "curdev" before
260			* "nextdev".
261			*/
262			*alldevs = curdev;
263			} else
264			prevdev->next = curdev;
265			}
266
267			*curdev_ret = curdev;
268			return (0);
269
270			fail:
271			if (curdev != NULL) {
272			free(curdev->name);
273			free(curdev->description);
274			free(curdev);
275			}
276			return (-1);
277			}
278
279			static int
280			add_addr_to_iflist(pcap_if_t *alldevs, const char name, u_int flags,
281			struct sockaddr *addr, size_t addr_size,
282			struct sockaddr *netmask, size_t netmask_size,
283			struct sockaddr *broadaddr, size_t broadaddr_size,
284			struct sockaddr *dstaddr, size_t dstaddr_size,
285			char *errbuf)
286			{
287			pcap_if_t *curdev;
288			pcap_addr_t curaddr, prevaddr, *nextaddr;
289
290			if (add_or_find_if(&curdev, alldevs, name, flags, NULL, errbuf) == -1) {
291			/*
292			* Error - give up.
293			*/
294			return (-1);
295			}
296			if (curdev == NULL) {
297			/*
298			* Device wasn't added because it can't be opened.
299			* Not a fatal error.
300			*/
301			return (0);
302			}
303
304			/*
305			* "curdev" is an entry for this interface; add an entry for this
306			* address to its list of addresses.
307			*
308			* Allocate the new entry and fill it in.
309			*/
310			curaddr = calloc(1, sizeof(pcap_addr_t));
311			if (curaddr == NULL) {
312			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
313			"calloc: %s", pcap_strerror(errno));
314			goto fail;
315			}
316
317			curaddr->next = NULL;
318			if (addr != NULL) {
319			curaddr->addr = dup_sockaddr(addr, addr_size);
320			if (curaddr->addr == NULL) {
321			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
322			"malloc: %s", pcap_strerror(errno));
323			goto fail;
324			}
325			}
326
327			if (netmask != NULL) {
328			curaddr->netmask = dup_sockaddr(netmask, netmask_size);
329			if (curaddr->netmask == NULL) {
330			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
331			"malloc: %s", pcap_strerror(errno));
332			goto fail;
333			}
334			}
335
336			if (broadaddr != NULL) {
337			curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size);
338			if (curaddr->broadaddr == NULL) {
339			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
340			"malloc: %s", pcap_strerror(errno));
341			goto fail;
342			}
343			}
344
345			if (dstaddr != NULL) {
346			curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size);
347			if (curaddr->dstaddr == NULL) {
348			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
349			"malloc: %s", pcap_strerror(errno));
350			goto fail;
351			}
352			}
353
354			/*
355			* Find the end of the list of addresses.
356			*/
357			for (prevaddr = curdev->addresses; prevaddr != NULL;
358			prevaddr = nextaddr) {
359			nextaddr = prevaddr->next;
360			if (nextaddr == NULL) {
361			/*
362			* This is the end of the list.
363			*/
364			break;
365			}
366			}
367
368			if (prevaddr == NULL) {
369			/*
370			* The list was empty; this is the first member.
371			*/
372			curdev->addresses = curaddr;
373			} else {
374			/*
375			* "prevaddr" is the last member of the list; append
376			* this member to it.
377			*/
378			prevaddr->next = curaddr;
379			}
380
381			return (0);
382
383			fail:
384			if (curaddr != NULL) {
385			free(curaddr->addr);
386			free(curaddr->netmask);
387			free(curaddr->broadaddr);
388			free(curaddr->dstaddr);
389			free(curaddr);
390			}
391			return (-1);
392			}
393
394			/*
395			* Get a list of all interfaces that are up and that we can open.
396			* Returns -1 on error, 0 otherwise.
397			* The list, as returned through "alldevsp", may be null if no interfaces
398			* were up and could be opened.
399			*
400			* This is the implementation used on platforms that have "getifaddrs()".
401			*/
402			int
403			pcap_findalldevs(pcap_if_t *alldevsp, char errbuf)
404			{
405			pcap_if_t *devlist = NULL;
406			struct ifaddrs ifap, ifa;
407			struct sockaddr addr, netmask, broadaddr, dstaddr;
408			size_t addr_size, broadaddr_size, dstaddr_size;
409			int ret = 0;
410
411			/*
412			* Get the list of interface addresses.
413			*
414			* Note: this won't return information about interfaces
415			* with no addresses; are there any such interfaces
416			* that would be capable of receiving packets?
417			* (Interfaces incapable of receiving packets aren't
418			* very interesting from libpcap's point of view.)
419			*
420			* LAN interfaces will probably have link-layer
421			* addresses; I don't know whether all implementations
422			* of "getifaddrs()" now, or in the future, will return
423			* those.
424			*/
425			if (getifaddrs(&ifap) != 0) {
426			(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
427			"getifaddrs: %s", pcap_strerror(errno));
428			return (-1);
429			}
430			for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
431			/*
432			* Is this interface up?
433			*/
434			if (!(ifa->ifa_flags & IFF_UP)) {
435			/*
436			* No, so don't add it to the list.
437			*/
438			continue;
439			}
440
441			/*
442			* "ifa_addr" was apparently null on at least one
443			* interface on some system.
444			*
445			* "ifa_broadaddr" may be non-null even on
446			* non-broadcast interfaces, and was null on
447			* at least one OpenBSD 3.4 system on at least
448			* one interface with IFF_BROADCAST set.
449			*
450			* "ifa_dstaddr" was, on at least one FreeBSD 4.1
451			* system, non-null on a non-point-to-point
452			* interface.
453			*
454			* Therefore, we supply the address and netmask only
455			* if "ifa_addr" is non-null (if there's no address,
456			* there's obviously no netmask), and supply the
457			* broadcast and destination addresses if the appropriate
458			* flag is set and the appropriate "ifa_" entry doesn't
459			* evaluate to a null pointer.
460			*/
461			if (ifa->ifa_addr != NULL) {
462			addr = ifa->ifa_addr;
463			addr_size = SA_LEN(addr);
464			netmask = ifa->ifa_netmask;
465			} else {
466			addr = NULL;
467			addr_size = 0;
468			netmask = NULL;
469			}
470			if (ifa->ifa_flags & IFF_BROADCAST &&
471			ifa->ifa_broadaddr != NULL) {
472			broadaddr = ifa->ifa_broadaddr;
473			broadaddr_size = SA_LEN(broadaddr);
474			} else {
475			broadaddr = NULL;
476			broadaddr_size = 0;
477			}
478			if (ifa->ifa_flags & IFF_POINTOPOINT &&
479			ifa->ifa_dstaddr != NULL) {
480			dstaddr = ifa->ifa_dstaddr;
481			dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
482			} else {
483			dstaddr = NULL;
484			dstaddr_size = 0;
485			}
486
487			/*
488			* Add information for this address to the list.
489			*/
490			if (add_addr_to_iflist(&devlist, ifa->ifa_name,
491			ifa->ifa_flags, addr, addr_size, netmask, addr_size,
492			broadaddr, broadaddr_size, dstaddr, dstaddr_size,
493			errbuf) < 0) {
494			ret = -1;
495			break;
496			}
497			}
498
499			freeifaddrs(ifap);
500
501			if (ret == -1) {
502			/*
503			* We had an error; free the list we've been constructing.
504			*/
505			if (devlist != NULL) {
506			pcap_freealldevs(devlist);
507			devlist = NULL;
508			}
509			}
510
511			*alldevsp = devlist;
512			return (ret);
513			}