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