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#ifdef HAVE_CONFIG_H
36#include <config.h>
37#endif
38
39#include <sys/param.h>
40#include <sys/file.h>
41#include <sys/ioctl.h>
42#include <sys/socket.h>
43#ifdef HAVE_SYS_SOCKIO_H
44#include <sys/sockio.h>
45#endif
46#include <sys/time.h>				/* concession to AIX */
47
48struct mbuf;		/* Squelch compiler warnings on some platforms for */
49struct rtentry;		/* declarations in <net/if.h> */
50#include <net/if.h>
51#include <netinet/in.h>
52
53#include <ctype.h>
54#include <errno.h>
55#include <memory.h>
56#include <stdio.h>
57#include <stdlib.h>
58#include <string.h>
59#include <unistd.h>
60
61#include "pcap-int.h"
62
63#ifdef HAVE_OS_PROTO_H
64#include "os-proto.h"
65#endif
66
67/*
68 * Get a list of all interfaces that are up and that we can open.
69 * Returns -1 on error, 0 otherwise.
70 * The list, as returned through "alldevsp", may be null if no interfaces
71 * were up and could be opened.
72 *
73 * This is the implementation used on platforms that have SIOCGLIFCONF
74 * but don't have "getifaddrs()".  (Solaris 8 and later; we use
75 * SIOCGLIFCONF rather than SIOCGIFCONF in order to get IPv6 addresses.)
76 */
77int
78pcap_findalldevs_interfaces(pcap_if_list_t *devlistp, char *errbuf,
79    int (*check_usable)(const char *), get_if_flags_func get_flags_func)
80{
81	register int fd4, fd6, fd;
82	register struct lifreq *ifrp, *ifend;
83	struct lifnum ifn;
84	struct lifconf ifc;
85	char *buf = NULL;
86	unsigned buf_size;
87#ifdef HAVE_SOLARIS
88	char *p, *q;
89#endif
90	struct lifreq ifrflags, ifrnetmask, ifrbroadaddr, ifrdstaddr;
91	struct sockaddr *netmask, *broadaddr, *dstaddr;
92	int ret = 0;
93
94	/*
95	 * Create a socket from which to fetch the list of interfaces,
96	 * and from which to fetch IPv4 information.
97	 */
98	fd4 = socket(AF_INET, SOCK_DGRAM, 0);
99	if (fd4 < 0) {
100		pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
101		    errno, "socket: AF_INET");
102		return (-1);
103	}
104
105	/*
106	 * Create a socket from which to fetch IPv6 information.
107	 */
108	fd6 = socket(AF_INET6, SOCK_DGRAM, 0);
109	if (fd6 < 0) {
110		pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
111		    errno, "socket: AF_INET6");
112		(void)close(fd4);
113		return (-1);
114	}
115
116	/*
117	 * How many entries will SIOCGLIFCONF return?
118	 */
119	ifn.lifn_family = AF_UNSPEC;
120	ifn.lifn_flags = 0;
121	ifn.lifn_count = 0;
122	if (ioctl(fd4, SIOCGLIFNUM, (char *)&ifn) < 0) {
123		pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
124		    errno, "SIOCGLIFNUM");
125		(void)close(fd6);
126		(void)close(fd4);
127		return (-1);
128	}
129
130	/*
131	 * Allocate a buffer for those entries.
132	 */
133	buf_size = ifn.lifn_count * sizeof (struct lifreq);
134	buf = malloc(buf_size);
135	if (buf == NULL) {
136		pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
137		    errno, "malloc");
138		(void)close(fd6);
139		(void)close(fd4);
140		return (-1);
141	}
142
143	/*
144	 * Get the entries.
145	 */
146	ifc.lifc_len = buf_size;
147	ifc.lifc_buf = buf;
148	ifc.lifc_family = AF_UNSPEC;
149	ifc.lifc_flags = 0;
150	memset(buf, 0, buf_size);
151	if (ioctl(fd4, SIOCGLIFCONF, (char *)&ifc) < 0) {
152		pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
153		    errno, "SIOCGLIFCONF");
154		(void)close(fd6);
155		(void)close(fd4);
156		free(buf);
157		return (-1);
158	}
159
160	/*
161	 * Loop over the entries.
162	 */
163	ifrp = (struct lifreq *)buf;
164	ifend = (struct lifreq *)(buf + ifc.lifc_len);
165
166	for (; ifrp < ifend; ifrp++) {
167		/*
168		 * Skip entries that begin with "dummy".
169		 * XXX - what are these?  Is this Linux-specific?
170		 * Are there platforms on which we shouldn't do this?
171		 */
172		if (strncmp(ifrp->lifr_name, "dummy", 5) == 0)
173			continue;
174
175		/*
176		 * Can we capture on this device?
177		 */
178		if (!(*check_usable)(ifrp->lifr_name)) {
179			/*
180			 * No.
181			 */
182			continue;
183		}
184
185		/*
186		 * IPv6 or not?
187		 */
188		if (((struct sockaddr *)&ifrp->lifr_addr)->sa_family == AF_INET6)
189			fd = fd6;
190		else
191			fd = fd4;
192
193		/*
194		 * Get the flags for this interface.
195		 */
196		strncpy(ifrflags.lifr_name, ifrp->lifr_name,
197		    sizeof(ifrflags.lifr_name));
198		if (ioctl(fd, SIOCGLIFFLAGS, (char *)&ifrflags) < 0) {
199			if (errno == ENXIO)
200				continue;
201			pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
202			    errno, "SIOCGLIFFLAGS: %.*s",
203			    (int)sizeof(ifrflags.lifr_name),
204			    ifrflags.lifr_name);
205			ret = -1;
206			break;
207		}
208
209		/*
210		 * Get the netmask for this address on this interface.
211		 */
212		strncpy(ifrnetmask.lifr_name, ifrp->lifr_name,
213		    sizeof(ifrnetmask.lifr_name));
214		memcpy(&ifrnetmask.lifr_addr, &ifrp->lifr_addr,
215		    sizeof(ifrnetmask.lifr_addr));
216		if (ioctl(fd, SIOCGLIFNETMASK, (char *)&ifrnetmask) < 0) {
217			if (errno == EADDRNOTAVAIL) {
218				/*
219				 * Not available.
220				 */
221				netmask = NULL;
222			} else {
223				pcap_fmt_errmsg_for_errno(errbuf,
224				    PCAP_ERRBUF_SIZE, errno,
225				    "SIOCGLIFNETMASK: %.*s",
226				    (int)sizeof(ifrnetmask.lifr_name),
227				    ifrnetmask.lifr_name);
228				ret = -1;
229				break;
230			}
231		} else
232			netmask = (struct sockaddr *)&ifrnetmask.lifr_addr;
233
234		/*
235		 * Get the broadcast address for this address on this
236		 * interface (if any).
237		 */
238		if (ifrflags.lifr_flags & IFF_BROADCAST) {
239			strncpy(ifrbroadaddr.lifr_name, ifrp->lifr_name,
240			    sizeof(ifrbroadaddr.lifr_name));
241			memcpy(&ifrbroadaddr.lifr_addr, &ifrp->lifr_addr,
242			    sizeof(ifrbroadaddr.lifr_addr));
243			if (ioctl(fd, SIOCGLIFBRDADDR,
244			    (char *)&ifrbroadaddr) < 0) {
245				if (errno == EADDRNOTAVAIL) {
246					/*
247					 * Not available.
248					 */
249					broadaddr = NULL;
250				} else {
251					pcap_fmt_errmsg_for_errno(errbuf,
252					    PCAP_ERRBUF_SIZE, errno,
253					    "SIOCGLIFBRDADDR: %.*s",
254					    (int)sizeof(ifrbroadaddr.lifr_name),
255					    ifrbroadaddr.lifr_name);
256					ret = -1;
257					break;
258				}
259			} else
260				broadaddr = (struct sockaddr *)&ifrbroadaddr.lifr_broadaddr;
261		} else {
262			/*
263			 * Not a broadcast interface, so no broadcast
264			 * address.
265			 */
266			broadaddr = NULL;
267		}
268
269		/*
270		 * Get the destination address for this address on this
271		 * interface (if any).
272		 */
273		if (ifrflags.lifr_flags & IFF_POINTOPOINT) {
274			strncpy(ifrdstaddr.lifr_name, ifrp->lifr_name,
275			    sizeof(ifrdstaddr.lifr_name));
276			memcpy(&ifrdstaddr.lifr_addr, &ifrp->lifr_addr,
277			    sizeof(ifrdstaddr.lifr_addr));
278			if (ioctl(fd, SIOCGLIFDSTADDR,
279			    (char *)&ifrdstaddr) < 0) {
280				if (errno == EADDRNOTAVAIL) {
281					/*
282					 * Not available.
283					 */
284					dstaddr = NULL;
285				} else {
286					pcap_fmt_errmsg_for_errno(errbuf,
287					    PCAP_ERRBUF_SIZE, errno,
288					    "SIOCGLIFDSTADDR: %.*s",
289					    (int)sizeof(ifrdstaddr.lifr_name),
290					    ifrdstaddr.lifr_name);
291					ret = -1;
292					break;
293				}
294			} else
295				dstaddr = (struct sockaddr *)&ifrdstaddr.lifr_dstaddr;
296		} else
297			dstaddr = NULL;
298
299#ifdef HAVE_SOLARIS
300		/*
301		 * If this entry has a colon followed by a number at
302		 * the end, it's a logical interface.  Those are just
303		 * the way you assign multiple IP addresses to a real
304		 * interface, so an entry for a logical interface should
305		 * be treated like the entry for the real interface;
306		 * we do that by stripping off the ":" and the number.
307		 */
308		p = strchr(ifrp->lifr_name, ':');
309		if (p != NULL) {
310			/*
311			 * We have a ":"; is it followed by a number?
312			 */
313			q = p + 1;
314			while (isdigit((unsigned char)*q))
315				q++;
316			if (*q == '\0') {
317				/*
318				 * All digits after the ":" until the end.
319				 * Strip off the ":" and everything after
320				 * it.
321				 */
322				*p = '\0';
323			}
324		}
325#endif
326
327		/*
328		 * Add information for this address to the list.
329		 */
330		if (add_addr_to_if(devlistp, ifrp->lifr_name,
331		    ifrflags.lifr_flags, get_flags_func,
332		    (struct sockaddr *)&ifrp->lifr_addr,
333		    sizeof (struct sockaddr_storage),
334		    netmask, sizeof (struct sockaddr_storage),
335		    broadaddr, sizeof (struct sockaddr_storage),
336		    dstaddr, sizeof (struct sockaddr_storage), errbuf) < 0) {
337			ret = -1;
338			break;
339		}
340	}
341	free(buf);
342	(void)close(fd6);
343	(void)close(fd4);
344
345	return (ret);
346}
347