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 #ifdef WIN32 40 #include <pcap-stdinc.h> 41 #else /* WIN32 */ 42 43 #include <sys/param.h> 44 #ifndef MSDOS 45 #include <sys/file.h> 46 #endif 47 #include <sys/ioctl.h> 48 #include <sys/socket.h> 49 #ifdef HAVE_SYS_SOCKIO_H 50 #include <sys/sockio.h> 51 #endif 52 53 struct mbuf; /* Squelch compiler warnings on some platforms for */ 54 struct rtentry; /* declarations in <net/if.h> */ 55 #include <net/if.h> 56 #include <netinet/in.h> 57 #endif /* WIN32 */ 58 59 #include <ctype.h> 60 #include <errno.h> 61 #include <memory.h> 62 #include <stdio.h> 63 #include <stdlib.h> 64 #include <string.h> 65 #if !defined(WIN32) && !defined(__BORLANDC__) 66 #include <unistd.h> 67 #endif /* !WIN32 && !__BORLANDC__ */ 68 #ifdef HAVE_LIMITS_H 69 #include <limits.h> 70 #else 71 #define INT_MAX 2147483647 72 #endif 73 74 #include "pcap-int.h" 75 76 #ifdef HAVE_OS_PROTO_H 77 #include "os-proto.h" 78 #endif 79 80 /* Not all systems have IFF_LOOPBACK */ 81 #ifdef IFF_LOOPBACK 82 #define ISLOOPBACK(name, flags) ((flags) & IFF_LOOPBACK) 83 #else 84 #define ISLOOPBACK(name, flags) ((name)[0] == 'l' && (name)[1] == 'o' && \ 85 (isdigit((unsigned char)((name)[2])) || (name)[2] == '\0')) 86 #endif 87 88 #ifdef IFF_UP 89 #define ISUP(flags) ((flags) & IFF_UP) 90 #else 91 #define ISUP(flags) 0 92 #endif 93 94 #ifdef IFF_RUNNING 95 #define ISRUNNING(flags) ((flags) & IFF_RUNNING) 96 #else 97 #define ISRUNNING(flags) 0 98 #endif 99 100 struct sockaddr * 101 dup_sockaddr(struct sockaddr *sa, size_t sa_length) 102 { 103 struct sockaddr *newsa; 104 105 if ((newsa = malloc(sa_length)) == NULL) 106 return (NULL); 107 return (memcpy(newsa, sa, sa_length)); 108 } 109 110 /* 111 * Construct a "figure of merit" for an interface, for use when sorting 112 * the list of interfaces, in which interfaces that are up are superior 113 * to interfaces that aren't up, interfaces that are up and running are 114 * superior to interfaces that are up but not running, and non-loopback 115 * interfaces that are up and running are superior to loopback interfaces, 116 * and interfaces with the same flags have a figure of merit that's higher 117 * the lower the instance number. 118 * 119 * The goal is to try to put the interfaces most likely to be useful for 120 * capture at the beginning of the list. 121 * 122 * The figure of merit, which is lower the "better" the interface is, 123 * has the uppermost bit set if the interface isn't running, the bit 124 * below that set if the interface isn't up, the bit below that set 125 * if the interface is a loopback interface, and the interface index 126 * in the 29 bits below that. (Yes, we assume u_int is 32 bits.) 127 */ 128 static u_int 129 get_figure_of_merit(pcap_if_t *dev) 130 { 131 const char *cp; 132 u_int n; 133 134 if (strcmp(dev->name, "any") == 0) { 135 /* 136 * Give the "any" device an artificially high instance 137 * number, so it shows up after all other non-loopback 138 * interfaces. 139 */ 140 n = 0x1FFFFFFF; /* 29 all-1 bits */ 141 } else { 142 /* 143 * A number at the end of the device name string is 144 * assumed to be a unit number. 145 */ 146 cp = dev->name + strlen(dev->name) - 1; 147 while (cp-1 >= dev->name && *(cp-1) >= '0' && *(cp-1) <= '9') 148 cp--; 149 if (*cp >= '0' && *cp <= '9') 150 n = atoi(cp); 151 else 152 n = 0; 153 } 154 if (!(dev->flags & PCAP_IF_RUNNING)) 155 n |= 0x80000000; 156 if (!(dev->flags & PCAP_IF_UP)) 157 n |= 0x40000000; 158 if (dev->flags & PCAP_IF_LOOPBACK) 159 n |= 0x20000000; 160 return (n); 161 } 162 163 /* 164 * Look for a given device in the specified list of devices. 165 * 166 * If we find it, return 0 and set *curdev_ret to point to it. 167 * 168 * If we don't find it, check whether we can open it: 169 * 170 * If that fails with PCAP_ERROR_NO_SUCH_DEVICE or 171 * PCAP_ERROR_IFACE_NOT_UP, don't attempt to add an entry for 172 * it, as that probably means it exists but doesn't support 173 * packet capture. 174 * 175 * Otherwise, attempt to add an entry for it, with the specified 176 * ifnet flags and description, and, if that succeeds, return 0 177 * and set *curdev_ret to point to the new entry, otherwise 178 * return PCAP_ERROR and set errbuf to an error message. 179 */ 180 int 181 add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name, 182 u_int flags, const char *description, char *errbuf) 183 { 184 pcap_t *p; 185 pcap_if_t *curdev, *prevdev, *nextdev; 186 u_int this_figure_of_merit, nextdev_figure_of_merit; 187 char open_errbuf[PCAP_ERRBUF_SIZE]; 188 int ret; 189 190 /* 191 * Is there already an entry in the list for this interface? 192 */ 193 for (curdev = *alldevs; curdev != NULL; curdev = curdev->next) { 194 if (strcmp(name, curdev->name) == 0) 195 break; /* yes, we found it */ 196 } 197 198 if (curdev == NULL) { 199 /* 200 * No, we didn't find it. 201 * 202 * Can we open this interface for live capture? 203 * 204 * We do this check so that interfaces that are 205 * supplied by the interface enumeration mechanism 206 * we're using but that don't support packet capture 207 * aren't included in the list. Loopback interfaces 208 * on Solaris are an example of this; we don't just 209 * omit loopback interfaces on all platforms because 210 * you *can* capture on loopback interfaces on some 211 * OSes. 212 * 213 * On OS X, we don't do this check if the device 214 * name begins with "wlt"; at least some versions 215 * of OS X offer monitor mode capturing by having 216 * a separate "monitor mode" device for each wireless 217 * adapter, rather than by implementing the ioctls 218 * that {Free,Net,Open,DragonFly}BSD provide. 219 * Opening that device puts the adapter into monitor 220 * mode, which, at least for some adapters, causes 221 * them to deassociate from the network with which 222 * they're associated. 223 * 224 * Instead, we try to open the corresponding "en" 225 * device (so that we don't end up with, for users 226 * without sufficient privilege to open capture 227 * devices, a list of adapters that only includes 228 * the wlt devices). 229 */ 230 #ifdef __APPLE__ 231 if (strncmp(name, "wlt", 3) == 0) { 232 char *en_name; 233 size_t en_name_len; 234 235 /* 236 * Try to allocate a buffer for the "en" 237 * device's name. 238 */ 239 en_name_len = strlen(name) - 1; 240 en_name = malloc(en_name_len + 1); 241 if (en_name == NULL) { 242 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 243 "malloc: %s", pcap_strerror(errno)); 244 return (-1); 245 } 246 strcpy(en_name, "en"); 247 strcat(en_name, name + 3); 248 p = pcap_create(en_name, open_errbuf); 249 free(en_name); 250 } else 251 #endif /* __APPLE */ 252 p = pcap_create(name, open_errbuf); 253 if (p == NULL) { 254 /* 255 * The attempt to create the pcap_t failed; 256 * that's probably an indication that we're 257 * out of memory. 258 * 259 * Don't bother including this interface, 260 * but don't treat it as an error. 261 */ 262 *curdev_ret = NULL; 263 return (0); 264 } 265 /* Small snaplen, so we don't try to allocate much memory. */ 266 pcap_set_snaplen(p, 68); 267 ret = pcap_activate(p); 268 pcap_close(p); 269 switch (ret) { 270 271 case PCAP_ERROR_NO_SUCH_DEVICE: 272 case PCAP_ERROR_IFACE_NOT_UP: 273 /* 274 * We expect these two errors - they're the 275 * reason we try to open the device. 276 * 277 * PCAP_ERROR_NO_SUCH_DEVICE typically means 278 * "there's no such device *known to the 279 * OS's capture mechanism*", so, even though 280 * it might be a valid network interface, you 281 * can't capture on it (e.g., the loopback 282 * device in Solaris up to Solaris 10, or 283 * the vmnet devices in OS X with VMware 284 * Fusion). We don't include those devices 285 * in our list of devices, as there's no 286 * point in doing so - they're not available 287 * for capture. 288 * 289 * PCAP_ERROR_IFACE_NOT_UP means that the 290 * OS's capture mechanism doesn't work on 291 * interfaces not marked as up; some capture 292 * mechanisms *do* support that, so we no 293 * longer reject those interfaces out of hand, 294 * but we *do* want to reject them if they 295 * can't be opened for capture. 296 */ 297 *curdev_ret = NULL; 298 return (0); 299 } 300 301 /* 302 * Yes, we can open it, or we can't, for some other 303 * reason. 304 * 305 * If we can open it, we want to offer it for 306 * capture, as you can capture on it. If we can't, 307 * we want to offer it for capture, so that, if 308 * the user tries to capture on it, they'll get 309 * an error and they'll know why they can't 310 * capture on it (e.g., insufficient permissions) 311 * or they'll report it as a problem (and then 312 * have the error message to provide as information). 313 * 314 * Allocate a new entry. 315 */ 316 curdev = malloc(sizeof(pcap_if_t)); 317 if (curdev == NULL) { 318 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 319 "malloc: %s", pcap_strerror(errno)); 320 return (-1); 321 } 322 323 /* 324 * Fill in the entry. 325 */ 326 curdev->next = NULL; 327 curdev->name = strdup(name); 328 if (curdev->name == NULL) { 329 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 330 "malloc: %s", pcap_strerror(errno)); 331 free(curdev); 332 return (-1); 333 } 334 if (description != NULL) { 335 /* 336 * We have a description for this interface. 337 */ 338 curdev->description = strdup(description); 339 if (curdev->description == NULL) { 340 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 341 "malloc: %s", pcap_strerror(errno)); 342 free(curdev->name); 343 free(curdev); 344 return (-1); 345 } 346 } else { 347 /* 348 * We don't. 349 */ 350 curdev->description = NULL; 351 } 352 curdev->addresses = NULL; /* list starts out as empty */ 353 curdev->flags = 0; 354 if (ISLOOPBACK(name, flags)) 355 curdev->flags |= PCAP_IF_LOOPBACK; 356 if (ISUP(flags)) 357 curdev->flags |= PCAP_IF_UP; 358 if (ISRUNNING(flags)) 359 curdev->flags |= PCAP_IF_RUNNING; 360 361 /* 362 * Add it to the list, in the appropriate location. 363 * First, get the "figure of merit" for this 364 * interface. 365 */ 366 this_figure_of_merit = get_figure_of_merit(curdev); 367 368 /* 369 * Now look for the last interface with an figure of merit 370 * less than or equal to the new interface's figure of 371 * merit. 372 * 373 * We start with "prevdev" being NULL, meaning we're before 374 * the first element in the list. 375 */ 376 prevdev = NULL; 377 for (;;) { 378 /* 379 * Get the interface after this one. 380 */ 381 if (prevdev == NULL) { 382 /* 383 * The next element is the first element. 384 */ 385 nextdev = *alldevs; 386 } else 387 nextdev = prevdev->next; 388 389 /* 390 * Are we at the end of the list? 391 */ 392 if (nextdev == NULL) { 393 /* 394 * Yes - we have to put the new entry 395 * after "prevdev". 396 */ 397 break; 398 } 399 400 /* 401 * Is the new interface's figure of merit less 402 * than the next interface's figure of merit, 403 * meaning that the new interface is better 404 * than the next interface? 405 */ 406 nextdev_figure_of_merit = get_figure_of_merit(nextdev); 407 if (this_figure_of_merit < nextdev_figure_of_merit) { 408 /* 409 * Yes - we should put the new entry 410 * before "nextdev", i.e. after "prevdev". 411 */ 412 break; 413 } 414 415 prevdev = nextdev; 416 } 417 418 /* 419 * Insert before "nextdev". 420 */ 421 curdev->next = nextdev; 422 423 /* 424 * Insert after "prevdev" - unless "prevdev" is null, 425 * in which case this is the first interface. 426 */ 427 if (prevdev == NULL) { 428 /* 429 * This is the first interface. Pass back a 430 * pointer to it, and put "curdev" before 431 * "nextdev". 432 */ 433 *alldevs = curdev; 434 } else 435 prevdev->next = curdev; 436 } 437 438 *curdev_ret = curdev; 439 return (0); 440 } 441 442 /* 443 * Try to get a description for a given device. 444 * Returns a mallocated description if it could and NULL if it couldn't. 445 * 446 * XXX - on FreeBSDs that support it, should it get the sysctl named 447 * "dev.{adapter family name}.{adapter unit}.%desc" to get a description 448 * of the adapter? Note that "dev.an.0.%desc" is "Aironet PC4500/PC4800" 449 * with my Cisco 350 card, so the name isn't entirely descriptive. The 450 * "dev.an.0.%pnpinfo" has a better description, although one might argue 451 * that the problem is really a driver bug - if it can find out that it's 452 * a Cisco 340 or 350, rather than an old Aironet card, it should use 453 * that in the description. 454 * 455 * Do NetBSD, DragonflyBSD, or OpenBSD support this as well? FreeBSD 456 * and OpenBSD let you get a description, but it's not generated by the OS, 457 * it's set with another ioctl that ifconfig supports; we use that to get 458 * a description in FreeBSD and OpenBSD, but if there is no such 459 * description available, it still might be nice to get some description 460 * string based on the device type or something such as that. 461 * 462 * In OS X, the System Configuration framework can apparently return 463 * names in 10.4 and later. 464 * 465 * It also appears that freedesktop.org's HAL offers an "info.product" 466 * string, but the HAL specification says it "should not be used in any 467 * UI" and "subsystem/capability specific properties" should be used 468 * instead and, in any case, I think HAL is being deprecated in 469 * favor of other stuff such as DeviceKit. DeviceKit doesn't appear 470 * to have any obvious product information for devices, but maybe 471 * I haven't looked hard enough. 472 * 473 * Using the System Configuration framework, or HAL, or DeviceKit, or 474 * whatever, would require that libpcap applications be linked with 475 * the frameworks/libraries in question. That shouldn't be a problem 476 * for programs linking with the shared version of libpcap (unless 477 * you're running on AIX - which I think is the only UN*X that doesn't 478 * support linking a shared library with other libraries on which it 479 * depends, and having an executable linked only with the first shared 480 * library automatically pick up the other libraries when started - 481 * and using HAL or whatever). Programs linked with the static 482 * version of libpcap would have to use pcap-config with the --static 483 * flag in order to get the right linker flags in order to pick up 484 * the additional libraries/frameworks; those programs need that anyway 485 * for libpcap 1.1 and beyond on Linux, as, by default, it requires 486 * -lnl. 487 * 488 * Do any other UN*Xes, or desktop environments support getting a 489 * description? 490 */ 491 static char * 492 get_if_description(const char *name) 493 { 494 #ifdef SIOCGIFDESCR 495 char *description = NULL; 496 int s; 497 struct ifreq ifrdesc; 498 #ifndef IFDESCRSIZE 499 size_t descrlen = 64; 500 #else 501 size_t descrlen = IFDESCRSIZE; 502 #endif /* IFDESCRSIZE */ 503 504 /* 505 * Get the description for the interface. 506 */ 507 memset(&ifrdesc, 0, sizeof ifrdesc); 508 strlcpy(ifrdesc.ifr_name, name, sizeof ifrdesc.ifr_name); 509 s = socket(AF_INET, SOCK_DGRAM, 0); 510 if (s >= 0) { 511 #ifdef __FreeBSD__ 512 /* 513 * On FreeBSD, if the buffer isn't big enough for the 514 * description, the ioctl succeeds, but the description 515 * isn't copied, ifr_buffer.length is set to the description 516 * length, and ifr_buffer.buffer is set to NULL. 517 */ 518 for (;;) { 519 free(description); 520 if ((description = malloc(descrlen)) != NULL) { 521 ifrdesc.ifr_buffer.buffer = description; 522 ifrdesc.ifr_buffer.length = descrlen; 523 if (ioctl(s, SIOCGIFDESCR, &ifrdesc) == 0) { 524 if (ifrdesc.ifr_buffer.buffer == 525 description) 526 break; 527 else 528 descrlen = ifrdesc.ifr_buffer.length; 529 } else { 530 /* 531 * Failed to get interface description. 532 */ 533 free(description); 534 description = NULL; 535 break; 536 } 537 } else 538 break; 539 } 540 #else /* __FreeBSD__ */ 541 /* 542 * The only other OS that currently supports 543 * SIOCGIFDESCR is OpenBSD, and it has no way 544 * to get the description length - it's clamped 545 * to a maximum of IFDESCRSIZE. 546 */ 547 if ((description = malloc(descrlen)) != NULL) { 548 ifrdesc.ifr_data = (caddr_t)description; 549 if (ioctl(s, SIOCGIFDESCR, &ifrdesc) != 0) { 550 /* 551 * Failed to get interface description. 552 */ 553 free(description); 554 description = NULL; 555 } 556 } 557 #endif /* __FreeBSD__ */ 558 close(s); 559 if (description != NULL && strlen(description) == 0) { 560 free(description); 561 description = NULL; 562 } 563 } 564 565 return (description); 566 #else /* SIOCGIFDESCR */ 567 return (NULL); 568 #endif /* SIOCGIFDESCR */ 569 } 570 571 /* 572 * Try to get a description for a given device, and then look for that 573 * device in the specified list of devices. 574 * 575 * If we find it, then, if the specified address isn't null, add it to 576 * the list of addresses for the device and return 0. 577 * 578 * If we don't find it, check whether we can open it: 579 * 580 * If that fails with PCAP_ERROR_NO_SUCH_DEVICE or 581 * PCAP_ERROR_IFACE_NOT_UP, don't attempt to add an entry for 582 * it, as that probably means it exists but doesn't support 583 * packet capture. 584 * 585 * Otherwise, attempt to add an entry for it, with the specified 586 * ifnet flags and description, and, if that succeeds, add the 587 * specified address to its list of addresses if that address is 588 * non-null, set *curdev_ret to point to the new entry, and 589 * return 0, otherwise return PCAP_ERROR and set errbuf to an 590 * error message. 591 * 592 * (We can get called with a null address because we might get a list 593 * of interface name/address combinations from the underlying OS, with 594 * the address being absent in some cases, rather than a list of 595 * interfaces with each interface having a list of addresses, so this 596 * call may be the only call made to add to the list, and we want to 597 * add interfaces even if they have no addresses.) 598 */ 599 int 600 add_addr_to_iflist(pcap_if_t **alldevs, const char *name, u_int flags, 601 struct sockaddr *addr, size_t addr_size, 602 struct sockaddr *netmask, size_t netmask_size, 603 struct sockaddr *broadaddr, size_t broadaddr_size, 604 struct sockaddr *dstaddr, size_t dstaddr_size, 605 char *errbuf) 606 { 607 char *description; 608 pcap_if_t *curdev; 609 610 description = get_if_description(name); 611 if (add_or_find_if(&curdev, alldevs, name, flags, description, 612 errbuf) == -1) { 613 free(description); 614 /* 615 * Error - give up. 616 */ 617 return (-1); 618 } 619 free(description); 620 if (curdev == NULL) { 621 /* 622 * Device wasn't added because it can't be opened. 623 * Not a fatal error. 624 */ 625 return (0); 626 } 627 628 if (addr == NULL) { 629 /* 630 * There's no address to add; this entry just meant 631 * "here's a new interface". 632 */ 633 return (0); 634 } 635 636 /* 637 * "curdev" is an entry for this interface, and we have an 638 * address for it; add an entry for that address to the 639 * interface's list of addresses. 640 * 641 * Allocate the new entry and fill it in. 642 */ 643 return (add_addr_to_dev(curdev, addr, addr_size, netmask, 644 netmask_size, broadaddr, broadaddr_size, dstaddr, 645 dstaddr_size, errbuf)); 646 } 647 648 /* 649 * Add an entry to the list of addresses for an interface. 650 * "curdev" is the entry for that interface. 651 * If this is the first IP address added to the interface, move it 652 * in the list as appropriate. 653 */ 654 int 655 add_addr_to_dev(pcap_if_t *curdev, 656 struct sockaddr *addr, size_t addr_size, 657 struct sockaddr *netmask, size_t netmask_size, 658 struct sockaddr *broadaddr, size_t broadaddr_size, 659 struct sockaddr *dstaddr, size_t dstaddr_size, 660 char *errbuf) 661 { 662 pcap_addr_t *curaddr, *prevaddr, *nextaddr; 663 664 curaddr = malloc(sizeof(pcap_addr_t)); 665 if (curaddr == NULL) { 666 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 667 "malloc: %s", pcap_strerror(errno)); 668 return (-1); 669 } 670 671 curaddr->next = NULL; 672 if (addr != NULL) { 673 curaddr->addr = dup_sockaddr(addr, addr_size); 674 if (curaddr->addr == NULL) { 675 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 676 "malloc: %s", pcap_strerror(errno)); 677 free(curaddr); 678 return (-1); 679 } 680 } else 681 curaddr->addr = NULL; 682 683 if (netmask != NULL) { 684 curaddr->netmask = dup_sockaddr(netmask, netmask_size); 685 if (curaddr->netmask == NULL) { 686 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 687 "malloc: %s", pcap_strerror(errno)); 688 if (curaddr->addr != NULL) 689 free(curaddr->addr); 690 free(curaddr); 691 return (-1); 692 } 693 } else 694 curaddr->netmask = NULL; 695 696 if (broadaddr != NULL) { 697 curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size); 698 if (curaddr->broadaddr == NULL) { 699 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 700 "malloc: %s", pcap_strerror(errno)); 701 if (curaddr->netmask != NULL) 702 free(curaddr->netmask); 703 if (curaddr->addr != NULL) 704 free(curaddr->addr); 705 free(curaddr); 706 return (-1); 707 } 708 } else 709 curaddr->broadaddr = NULL; 710 711 if (dstaddr != NULL) { 712 curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size); 713 if (curaddr->dstaddr == NULL) { 714 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 715 "malloc: %s", pcap_strerror(errno)); 716 if (curaddr->broadaddr != NULL) 717 free(curaddr->broadaddr); 718 if (curaddr->netmask != NULL) 719 free(curaddr->netmask); 720 if (curaddr->addr != NULL) 721 free(curaddr->addr); 722 free(curaddr); 723 return (-1); 724 } 725 } else 726 curaddr->dstaddr = NULL; 727 728 /* 729 * Find the end of the list of addresses. 730 */ 731 for (prevaddr = curdev->addresses; prevaddr != NULL; prevaddr = nextaddr) { 732 nextaddr = prevaddr->next; 733 if (nextaddr == NULL) { 734 /* 735 * This is the end of the list. 736 */ 737 break; 738 } 739 } 740 741 if (prevaddr == NULL) { 742 /* 743 * The list was empty; this is the first member. 744 */ 745 curdev->addresses = curaddr; 746 } else { 747 /* 748 * "prevaddr" is the last member of the list; append 749 * this member to it. 750 */ 751 prevaddr->next = curaddr; 752 } 753 754 return (0); 755 } 756 757 /* 758 * Look for a given device in the specified list of devices. 759 * 760 * If we find it, return 0. 761 * 762 * If we don't find it, check whether we can open it: 763 * 764 * If that fails with PCAP_ERROR_NO_SUCH_DEVICE or 765 * PCAP_ERROR_IFACE_NOT_UP, don't attempt to add an entry for 766 * it, as that probably means it exists but doesn't support 767 * packet capture. 768 * 769 * Otherwise, attempt to add an entry for it, with the specified 770 * ifnet flags and description, and, if that succeeds, return 0 771 * and set *curdev_ret to point to the new entry, otherwise 772 * return PCAP_ERROR and set errbuf to an error message. 773 */ 774 int 775 pcap_add_if(pcap_if_t **devlist, const char *name, u_int flags, 776 const char *description, char *errbuf) 777 { 778 pcap_if_t *curdev; 779 780 return (add_or_find_if(&curdev, devlist, name, flags, description, 781 errbuf)); 782 } 783 784 785 /* 786 * Free a list of interfaces. 787 */ 788 void 789 pcap_freealldevs(pcap_if_t *alldevs) 790 { 791 pcap_if_t *curdev, *nextdev; 792 pcap_addr_t *curaddr, *nextaddr; 793 794 for (curdev = alldevs; curdev != NULL; curdev = nextdev) { 795 nextdev = curdev->next; 796 797 /* 798 * Free all addresses. 799 */ 800 for (curaddr = curdev->addresses; curaddr != NULL; curaddr = nextaddr) { 801 nextaddr = curaddr->next; 802 if (curaddr->addr) 803 free(curaddr->addr); 804 if (curaddr->netmask) 805 free(curaddr->netmask); 806 if (curaddr->broadaddr) 807 free(curaddr->broadaddr); 808 if (curaddr->dstaddr) 809 free(curaddr->dstaddr); 810 free(curaddr); 811 } 812 813 /* 814 * Free the name string. 815 */ 816 free(curdev->name); 817 818 /* 819 * Free the description string, if any. 820 */ 821 if (curdev->description != NULL) 822 free(curdev->description); 823 824 /* 825 * Free the interface. 826 */ 827 free(curdev); 828 } 829 } 830 831 #if !defined(WIN32) && !defined(MSDOS) 832 833 /* 834 * Return the name of a network interface attached to the system, or NULL 835 * if none can be found. The interface must be configured up; the 836 * lowest unit number is preferred; loopback is ignored. 837 */ 838 char * 839 pcap_lookupdev(errbuf) 840 register char *errbuf; 841 { 842 pcap_if_t *alldevs; 843 /* for old BSD systems, including bsdi3 */ 844 #ifndef IF_NAMESIZE 845 #define IF_NAMESIZE IFNAMSIZ 846 #endif 847 static char device[IF_NAMESIZE + 1]; 848 char *ret; 849 850 if (pcap_findalldevs(&alldevs, errbuf) == -1) 851 return (NULL); 852 853 if (alldevs == NULL || (alldevs->flags & PCAP_IF_LOOPBACK)) { 854 /* 855 * There are no devices on the list, or the first device 856 * on the list is a loopback device, which means there 857 * are no non-loopback devices on the list. This means 858 * we can't return any device. 859 * 860 * XXX - why not return a loopback device? If we can't 861 * capture on it, it won't be on the list, and if it's 862 * on the list, there aren't any non-loopback devices, 863 * so why not just supply it as the default device? 864 */ 865 (void)strlcpy(errbuf, "no suitable device found", 866 PCAP_ERRBUF_SIZE); 867 ret = NULL; 868 } else { 869 /* 870 * Return the name of the first device on the list. 871 */ 872 (void)strlcpy(device, alldevs->name, sizeof(device)); 873 ret = device; 874 } 875 876 pcap_freealldevs(alldevs); 877 return (ret); 878 } 879 880 int 881 pcap_lookupnet(device, netp, maskp, errbuf) 882 register const char *device; 883 register bpf_u_int32 *netp, *maskp; 884 register char *errbuf; 885 { 886 register int fd; 887 register struct sockaddr_in *sin4; 888 struct ifreq ifr; 889 890 /* 891 * The pseudo-device "any" listens on all interfaces and therefore 892 * has the network address and -mask "0.0.0.0" therefore catching 893 * all traffic. Using NULL for the interface is the same as "any". 894 */ 895 if (!device || strcmp(device, "any") == 0 896 #ifdef HAVE_DAG_API 897 || strstr(device, "dag") != NULL 898 #endif 899 #ifdef HAVE_SEPTEL_API 900 || strstr(device, "septel") != NULL 901 #endif 902 #ifdef PCAP_SUPPORT_BT 903 || strstr(device, "bluetooth") != NULL 904 #endif 905 #ifdef PCAP_SUPPORT_USB 906 || strstr(device, "usbmon") != NULL 907 #endif 908 #ifdef HAVE_SNF_API 909 || strstr(device, "snf") != NULL 910 #endif 911 ) { 912 *netp = *maskp = 0; 913 return 0; 914 } 915 916 fd = socket(AF_INET, SOCK_DGRAM, 0); 917 if (fd < 0) { 918 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "socket: %s", 919 pcap_strerror(errno)); 920 return (-1); 921 } 922 memset(&ifr, 0, sizeof(ifr)); 923 #ifdef linux 924 /* XXX Work around Linux kernel bug */ 925 ifr.ifr_addr.sa_family = AF_INET; 926 #endif 927 (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name)); 928 if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0) { 929 if (errno == EADDRNOTAVAIL) { 930 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 931 "%s: no IPv4 address assigned", device); 932 } else { 933 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 934 "SIOCGIFADDR: %s: %s", 935 device, pcap_strerror(errno)); 936 } 937 (void)close(fd); 938 return (-1); 939 } 940 sin4 = (struct sockaddr_in *)&ifr.ifr_addr; 941 *netp = sin4->sin_addr.s_addr; 942 memset(&ifr, 0, sizeof(ifr)); 943 #ifdef linux 944 /* XXX Work around Linux kernel bug */ 945 ifr.ifr_addr.sa_family = AF_INET; 946 #endif 947 (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name)); 948 if (ioctl(fd, SIOCGIFNETMASK, (char *)&ifr) < 0) { 949 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 950 "SIOCGIFNETMASK: %s: %s", device, pcap_strerror(errno)); 951 (void)close(fd); 952 return (-1); 953 } 954 (void)close(fd); 955 *maskp = sin4->sin_addr.s_addr; 956 if (*maskp == 0) { 957 if (IN_CLASSA(*netp)) 958 *maskp = IN_CLASSA_NET; 959 else if (IN_CLASSB(*netp)) 960 *maskp = IN_CLASSB_NET; 961 else if (IN_CLASSC(*netp)) 962 *maskp = IN_CLASSC_NET; 963 else { 964 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 965 "inet class for 0x%x unknown", *netp); 966 return (-1); 967 } 968 } 969 *netp &= *maskp; 970 return (0); 971 } 972 973 #elif defined(WIN32) 974 975 /* 976 * Return the name of a network interface attached to the system, or NULL 977 * if none can be found. The interface must be configured up; the 978 * lowest unit number is preferred; loopback is ignored. 979 */ 980 char * 981 pcap_lookupdev(errbuf) 982 register char *errbuf; 983 { 984 DWORD dwVersion; 985 DWORD dwWindowsMajorVersion; 986 dwVersion = GetVersion(); /* get the OS version */ 987 dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion))); 988 989 if (dwVersion >= 0x80000000 && dwWindowsMajorVersion >= 4) { 990 /* 991 * Windows 95, 98, ME. 992 */ 993 ULONG NameLength = 8192; 994 static char AdaptersName[8192]; 995 996 if (PacketGetAdapterNames(AdaptersName,&NameLength) ) 997 return (AdaptersName); 998 else 999 return NULL; 1000 } else { 1001 /* 1002 * Windows NT (NT 4.0, W2K, WXP). Convert the names to UNICODE for backward compatibility 1003 */ 1004 ULONG NameLength = 8192; 1005 static WCHAR AdaptersName[8192]; 1006 char *tAstr; 1007 WCHAR *tUstr; 1008 WCHAR *TAdaptersName = (WCHAR*)malloc(8192 * sizeof(WCHAR)); 1009 int NAdapts = 0; 1010 1011 if(TAdaptersName == NULL) 1012 { 1013 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "memory allocation failure"); 1014 return NULL; 1015 } 1016 1017 if ( !PacketGetAdapterNames((PTSTR)TAdaptersName,&NameLength) ) 1018 { 1019 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 1020 "PacketGetAdapterNames: %s", 1021 pcap_win32strerror()); 1022 free(TAdaptersName); 1023 return NULL; 1024 } 1025 1026 1027 tAstr = (char*)TAdaptersName; 1028 tUstr = (WCHAR*)AdaptersName; 1029 1030 /* 1031 * Convert and copy the device names 1032 */ 1033 while(sscanf(tAstr, "%S", tUstr) > 0) 1034 { 1035 tAstr += strlen(tAstr) + 1; 1036 tUstr += wcslen(tUstr) + 1; 1037 NAdapts ++; 1038 } 1039 1040 tAstr++; 1041 *tUstr = 0; 1042 tUstr++; 1043 1044 /* 1045 * Copy the descriptions 1046 */ 1047 while(NAdapts--) 1048 { 1049 char* tmp = (char*)tUstr; 1050 strcpy(tmp, tAstr); 1051 tmp += strlen(tAstr) + 1; 1052 tUstr = (WCHAR*)tmp; 1053 tAstr += strlen(tAstr) + 1; 1054 } 1055 1056 free(TAdaptersName); 1057 return (char *)(AdaptersName); 1058 } 1059 } 1060 1061 1062 int 1063 pcap_lookupnet(device, netp, maskp, errbuf) 1064 register const char *device; 1065 register bpf_u_int32 *netp, *maskp; 1066 register char *errbuf; 1067 { 1068 /* 1069 * We need only the first IPv4 address, so we must scan the array returned by PacketGetNetInfo() 1070 * in order to skip non IPv4 (i.e. IPv6 addresses) 1071 */ 1072 npf_if_addr if_addrs[MAX_NETWORK_ADDRESSES]; 1073 LONG if_addr_size = 1; 1074 struct sockaddr_in *t_addr; 1075 unsigned int i; 1076 1077 if (!PacketGetNetInfoEx((void *)device, if_addrs, &if_addr_size)) { 1078 *netp = *maskp = 0; 1079 return (0); 1080 } 1081 1082 for(i=0; i<MAX_NETWORK_ADDRESSES; i++) 1083 { 1084 if(if_addrs[i].IPAddress.ss_family == AF_INET) 1085 { 1086 t_addr = (struct sockaddr_in *) &(if_addrs[i].IPAddress); 1087 *netp = t_addr->sin_addr.S_un.S_addr; 1088 t_addr = (struct sockaddr_in *) &(if_addrs[i].SubnetMask); 1089 *maskp = t_addr->sin_addr.S_un.S_addr; 1090 1091 *netp &= *maskp; 1092 return (0); 1093 } 1094 1095 } 1096 1097 *netp = *maskp = 0; 1098 return (0); 1099 } 1100 1101 #endif /* !WIN32 && !MSDOS */ 1102
