inet.c revision 199201
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#ifndef lint 36static const char rcsid[] _U_ = 37 "@(#) $Header: /tcpdump/master/libpcap/inet.c,v 1.75.2.4 2008-04-20 18:19:24 guy Exp $ (LBL)"; 38#endif 39 40#ifdef HAVE_CONFIG_H 41#include "config.h" 42#endif 43 44#ifdef WIN32 45#include <pcap-stdinc.h> 46#else /* WIN32 */ 47 48#include <sys/param.h> 49#ifndef MSDOS 50#include <sys/file.h> 51#endif 52#include <sys/ioctl.h> 53#include <sys/socket.h> 54#ifdef HAVE_SYS_SOCKIO_H 55#include <sys/sockio.h> 56#endif 57 58struct mbuf; /* Squelch compiler warnings on some platforms for */ 59struct rtentry; /* declarations in <net/if.h> */ 60#include <net/if.h> 61#include <netinet/in.h> 62#endif /* WIN32 */ 63 64#include <ctype.h> 65#include <errno.h> 66#include <memory.h> 67#include <stdio.h> 68#include <stdlib.h> 69#include <string.h> 70#if !defined(WIN32) && !defined(__BORLANDC__) 71#include <unistd.h> 72#endif /* !WIN32 && !__BORLANDC__ */ 73#ifdef HAVE_LIMITS_H 74#include <limits.h> 75#else 76#define INT_MAX 2147483647 77#endif 78 79#include "pcap-int.h" 80 81#ifdef HAVE_OS_PROTO_H 82#include "os-proto.h" 83#endif 84 85/* Not all systems have IFF_LOOPBACK */ 86#ifdef IFF_LOOPBACK 87#define ISLOOPBACK(name, flags) ((flags) & IFF_LOOPBACK) 88#else 89#define ISLOOPBACK(name, flags) ((name)[0] == 'l' && (name)[1] == 'o' && \ 90 (isdigit((unsigned char)((name)[2])) || (name)[2] == '\0')) 91#endif 92 93struct sockaddr * 94dup_sockaddr(struct sockaddr *sa, size_t sa_length) 95{ 96 struct sockaddr *newsa; 97 98 if ((newsa = malloc(sa_length)) == NULL) 99 return (NULL); 100 return (memcpy(newsa, sa, sa_length)); 101} 102 103static int 104get_instance(const char *name) 105{ 106 const char *cp, *endcp; 107 int n; 108 109 if (strcmp(name, "any") == 0) { 110 /* 111 * Give the "any" device an artificially high instance 112 * number, so it shows up after all other non-loopback 113 * interfaces. 114 */ 115 return INT_MAX; 116 } 117 118 endcp = name + strlen(name); 119 for (cp = name; cp < endcp && !isdigit((unsigned char)*cp); ++cp) 120 continue; 121 122 if (isdigit((unsigned char)*cp)) 123 n = atoi(cp); 124 else 125 n = 0; 126 return (n); 127} 128 129int 130add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name, 131 u_int flags, const char *description, char *errbuf) 132{ 133 pcap_t *p; 134 pcap_if_t *curdev, *prevdev, *nextdev; 135 int this_instance; 136 137 /* 138 * Is there already an entry in the list for this interface? 139 */ 140 for (curdev = *alldevs; curdev != NULL; curdev = curdev->next) { 141 if (strcmp(name, curdev->name) == 0) 142 break; /* yes, we found it */ 143 } 144 145 if (curdev == NULL) { 146 /* 147 * No, we didn't find it. 148 * 149 * Can we open this interface for live capture? 150 * 151 * We do this check so that interfaces that are 152 * supplied by the interface enumeration mechanism 153 * we're using but that don't support packet capture 154 * aren't included in the list. Loopback interfaces 155 * on Solaris are an example of this; we don't just 156 * omit loopback interfaces on all platforms because 157 * you *can* capture on loopback interfaces on some 158 * OSes. 159 * 160 * On OS X, we don't do this check if the device 161 * name begins with "wlt"; at least some versions 162 * of OS X offer monitor mode capturing by having 163 * a separate "monitor mode" device for each wireless 164 * adapter, rather than by implementing the ioctls 165 * that {Free,Net,Open,DragonFly}BSD provide. 166 * Opening that device puts the adapter into monitor 167 * mode, which, at least for some adapters, causes 168 * them to deassociate from the network with which 169 * they're associated. 170 * 171 * Instead, we try to open the corresponding "en" 172 * device (so that we don't end up with, for users 173 * without sufficient privilege to open capture 174 * devices, a list of adapters that only includes 175 * the wlt devices). 176 */ 177#ifdef __APPLE__ 178 if (strncmp(name, "wlt", 3) == 0) { 179 char *en_name; 180 size_t en_name_len; 181 182 /* 183 * Try to allocate a buffer for the "en" 184 * device's name. 185 */ 186 en_name_len = strlen(name) - 1; 187 en_name = malloc(en_name_len + 1); 188 if (en_name == NULL) { 189 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 190 "malloc: %s", pcap_strerror(errno)); 191 return (-1); 192 } 193 strcpy(en_name, "en"); 194 strcat(en_name, name + 3); 195 p = pcap_open_live(en_name, 68, 0, 0, errbuf); 196 free(en_name); 197 } else 198#endif /* __APPLE */ 199 p = pcap_open_live(name, 68, 0, 0, errbuf); 200 if (p == NULL) { 201 /* 202 * No. Don't bother including it. 203 * Don't treat this as an error, though. 204 */ 205 *curdev_ret = NULL; 206 return (0); 207 } 208 pcap_close(p); 209 210 /* 211 * Yes, we can open it. 212 * Allocate a new entry. 213 */ 214 curdev = malloc(sizeof(pcap_if_t)); 215 if (curdev == NULL) { 216 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 217 "malloc: %s", pcap_strerror(errno)); 218 return (-1); 219 } 220 221 /* 222 * Fill in the entry. 223 */ 224 curdev->next = NULL; 225 curdev->name = strdup(name); 226 if (curdev->name == NULL) { 227 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 228 "malloc: %s", pcap_strerror(errno)); 229 free(curdev); 230 return (-1); 231 } 232 if (description != NULL) { 233 /* 234 * We have a description for this interface. 235 */ 236 curdev->description = strdup(description); 237 if (curdev->description == NULL) { 238 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 239 "malloc: %s", pcap_strerror(errno)); 240 free(curdev->name); 241 free(curdev); 242 return (-1); 243 } 244 } else { 245 /* 246 * We don't. 247 */ 248 curdev->description = NULL; 249 } 250 curdev->addresses = NULL; /* list starts out as empty */ 251 curdev->flags = 0; 252 if (ISLOOPBACK(name, flags)) 253 curdev->flags |= PCAP_IF_LOOPBACK; 254 255 /* 256 * Add it to the list, in the appropriate location. 257 * First, get the instance number of this interface. 258 */ 259 this_instance = get_instance(name); 260 261 /* 262 * Now look for the last interface with an instance number 263 * less than or equal to the new interface's instance 264 * number - except that non-loopback interfaces are 265 * arbitrarily treated as having interface numbers less 266 * than those of loopback interfaces, so the loopback 267 * interfaces are put at the end of the list. 268 * 269 * We start with "prevdev" being NULL, meaning we're before 270 * the first element in the list. 271 */ 272 prevdev = NULL; 273 for (;;) { 274 /* 275 * Get the interface after this one. 276 */ 277 if (prevdev == NULL) { 278 /* 279 * The next element is the first element. 280 */ 281 nextdev = *alldevs; 282 } else 283 nextdev = prevdev->next; 284 285 /* 286 * Are we at the end of the list? 287 */ 288 if (nextdev == NULL) { 289 /* 290 * Yes - we have to put the new entry 291 * after "prevdev". 292 */ 293 break; 294 } 295 296 /* 297 * Is the new interface a non-loopback interface 298 * and the next interface a loopback interface? 299 */ 300 if (!(curdev->flags & PCAP_IF_LOOPBACK) && 301 (nextdev->flags & PCAP_IF_LOOPBACK)) { 302 /* 303 * Yes, we should put the new entry 304 * before "nextdev", i.e. after "prevdev". 305 */ 306 break; 307 } 308 309 /* 310 * Is the new interface's instance number less 311 * than the next interface's instance number, 312 * and is it the case that the new interface is a 313 * non-loopback interface or the next interface is 314 * a loopback interface? 315 * 316 * (The goal of both loopback tests is to make 317 * sure that we never put a loopback interface 318 * before any non-loopback interface and that we 319 * always put a non-loopback interface before all 320 * loopback interfaces.) 321 */ 322 if (this_instance < get_instance(nextdev->name) && 323 (!(curdev->flags & PCAP_IF_LOOPBACK) || 324 (nextdev->flags & PCAP_IF_LOOPBACK))) { 325 /* 326 * Yes - we should put the new entry 327 * before "nextdev", i.e. after "prevdev". 328 */ 329 break; 330 } 331 332 prevdev = nextdev; 333 } 334 335 /* 336 * Insert before "nextdev". 337 */ 338 curdev->next = nextdev; 339 340 /* 341 * Insert after "prevdev" - unless "prevdev" is null, 342 * in which case this is the first interface. 343 */ 344 if (prevdev == NULL) { 345 /* 346 * This is the first interface. Pass back a 347 * pointer to it, and put "curdev" before 348 * "nextdev". 349 */ 350 *alldevs = curdev; 351 } else 352 prevdev->next = curdev; 353 } 354 355 *curdev_ret = curdev; 356 return (0); 357} 358 359/* 360 * XXX - on FreeBSDs that support it, should it get the sysctl named 361 * "dev.{adapter family name}.{adapter unit}.%desc" to get a description 362 * of the adapter? Note that "dev.an.0.%desc" is "Aironet PC4500/PC4800" 363 * with my Cisco 350 card, so the name isn't entirely descriptive. The 364 * "dev.an.0.%pnpinfo" has a better description, although one might argue 365 * that the problem is really a driver bug - if it can find out that it's 366 * a Cisco 340 or 350, rather than an old Aironet card, it should use 367 * that in the description. 368 * 369 * Do NetBSD, DragonflyBSD, or OpenBSD support this as well? OpenBSD 370 * lets you get a description, but it's not generated by the OS, it's 371 * set with another ioctl that ifconfig supports; we use that to get 372 * the description in OpenBSD. 373 * 374 * In OS X, the System Configuration framework can apparently return 375 * names in 10.4 and later; it also appears that freedesktop.org's HAL 376 * offers an "info.product" string, but the HAL specification says 377 * it "should not be used in any UI" and "subsystem/capability 378 * specific properties" should be used instead. Using that would 379 * require that libpcap applications be linked with the frameworks/ 380 * libraries in question, which would be a bit of a pain unless we 381 * offer, for example, a pkg-config: 382 * 383 * http://pkg-config.freedesktop.org/wiki/ 384 * 385 * script, so applications can just use that script to find out what 386 * libraries you need to link with when linking with libpcap. 387 * pkg-config is GPLed; I don't know whether that would prevent its 388 * use with a BSD-licensed library such as libpcap. 389 * 390 * Do any other UN*Xes, or desktop environments support getting a 391 * description? 392 */ 393int 394add_addr_to_iflist(pcap_if_t **alldevs, const char *name, u_int flags, 395 struct sockaddr *addr, size_t addr_size, 396 struct sockaddr *netmask, size_t netmask_size, 397 struct sockaddr *broadaddr, size_t broadaddr_size, 398 struct sockaddr *dstaddr, size_t dstaddr_size, 399 char *errbuf) 400{ 401 pcap_if_t *curdev; 402 char *description = NULL; 403 pcap_addr_t *curaddr, *prevaddr, *nextaddr; 404#ifdef SIOCGIFDESCR 405 struct ifreq ifrdesc; 406#ifdef __FreeBSD__ 407#define _IFDESCRSIZE 64 408 char ifdescr[_IFDESCRSIZE]; 409#else 410 char ifdescr[IFDESCRSIZE]; 411#endif 412 int s; 413 414 /* 415 * Get the description for the interface. 416 */ 417 memset(&ifrdesc, 0, sizeof ifrdesc); 418 strlcpy(ifrdesc.ifr_name, name, sizeof ifrdesc.ifr_name); 419#ifdef __FreeBSD__ 420 ifrdesc.ifr_buffer.buffer = ifdescr; 421 ifrdesc.ifr_buffer.length = _IFDESCRSIZE; 422#else 423 ifrdesc.ifr_data = (caddr_t)&ifdescr; 424#endif 425 s = socket(AF_INET, SOCK_DGRAM, 0); 426 if (s >= 0) { 427 if (ioctl(s, SIOCGIFDESCR, &ifrdesc) == 0 && 428 strlen(ifdescr) != 0) 429 description = ifdescr; 430 close(s); 431 } 432#endif 433 434 if (add_or_find_if(&curdev, alldevs, name, flags, description, 435 errbuf) == -1) { 436 /* 437 * Error - give up. 438 */ 439 return (-1); 440 } 441 if (curdev == NULL) { 442 /* 443 * Device wasn't added because it can't be opened. 444 * Not a fatal error. 445 */ 446 return (0); 447 } 448 449 /* 450 * "curdev" is an entry for this interface; add an entry for this 451 * address to its list of addresses. 452 * 453 * Allocate the new entry and fill it in. 454 */ 455 curaddr = malloc(sizeof(pcap_addr_t)); 456 if (curaddr == NULL) { 457 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 458 "malloc: %s", pcap_strerror(errno)); 459 return (-1); 460 } 461 462 curaddr->next = NULL; 463 if (addr != NULL) { 464 curaddr->addr = dup_sockaddr(addr, addr_size); 465 if (curaddr->addr == NULL) { 466 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 467 "malloc: %s", pcap_strerror(errno)); 468 free(curaddr); 469 return (-1); 470 } 471 } else 472 curaddr->addr = NULL; 473 474 if (netmask != NULL) { 475 curaddr->netmask = dup_sockaddr(netmask, netmask_size); 476 if (curaddr->netmask == NULL) { 477 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 478 "malloc: %s", pcap_strerror(errno)); 479 if (curaddr->addr != NULL) 480 free(curaddr->addr); 481 free(curaddr); 482 return (-1); 483 } 484 } else 485 curaddr->netmask = NULL; 486 487 if (broadaddr != NULL) { 488 curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size); 489 if (curaddr->broadaddr == NULL) { 490 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 491 "malloc: %s", pcap_strerror(errno)); 492 if (curaddr->netmask != NULL) 493 free(curaddr->netmask); 494 if (curaddr->addr != NULL) 495 free(curaddr->addr); 496 free(curaddr); 497 return (-1); 498 } 499 } else 500 curaddr->broadaddr = NULL; 501 502 if (dstaddr != NULL) { 503 curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size); 504 if (curaddr->dstaddr == NULL) { 505 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 506 "malloc: %s", pcap_strerror(errno)); 507 if (curaddr->broadaddr != NULL) 508 free(curaddr->broadaddr); 509 if (curaddr->netmask != NULL) 510 free(curaddr->netmask); 511 if (curaddr->addr != NULL) 512 free(curaddr->addr); 513 free(curaddr); 514 return (-1); 515 } 516 } else 517 curaddr->dstaddr = NULL; 518 519 /* 520 * Find the end of the list of addresses. 521 */ 522 for (prevaddr = curdev->addresses; prevaddr != NULL; prevaddr = nextaddr) { 523 nextaddr = prevaddr->next; 524 if (nextaddr == NULL) { 525 /* 526 * This is the end of the list. 527 */ 528 break; 529 } 530 } 531 532 if (prevaddr == NULL) { 533 /* 534 * The list was empty; this is the first member. 535 */ 536 curdev->addresses = curaddr; 537 } else { 538 /* 539 * "prevaddr" is the last member of the list; append 540 * this member to it. 541 */ 542 prevaddr->next = curaddr; 543 } 544 545 return (0); 546} 547 548int 549pcap_add_if(pcap_if_t **devlist, const char *name, u_int flags, 550 const char *description, char *errbuf) 551{ 552 pcap_if_t *curdev; 553 554 return (add_or_find_if(&curdev, devlist, name, flags, description, 555 errbuf)); 556} 557 558 559/* 560 * Free a list of interfaces. 561 */ 562void 563pcap_freealldevs(pcap_if_t *alldevs) 564{ 565 pcap_if_t *curdev, *nextdev; 566 pcap_addr_t *curaddr, *nextaddr; 567 568 for (curdev = alldevs; curdev != NULL; curdev = nextdev) { 569 nextdev = curdev->next; 570 571 /* 572 * Free all addresses. 573 */ 574 for (curaddr = curdev->addresses; curaddr != NULL; curaddr = nextaddr) { 575 nextaddr = curaddr->next; 576 if (curaddr->addr) 577 free(curaddr->addr); 578 if (curaddr->netmask) 579 free(curaddr->netmask); 580 if (curaddr->broadaddr) 581 free(curaddr->broadaddr); 582 if (curaddr->dstaddr) 583 free(curaddr->dstaddr); 584 free(curaddr); 585 } 586 587 /* 588 * Free the name string. 589 */ 590 free(curdev->name); 591 592 /* 593 * Free the description string, if any. 594 */ 595 if (curdev->description != NULL) 596 free(curdev->description); 597 598 /* 599 * Free the interface. 600 */ 601 free(curdev); 602 } 603} 604 605#if !defined(WIN32) && !defined(MSDOS) 606 607/* 608 * Return the name of a network interface attached to the system, or NULL 609 * if none can be found. The interface must be configured up; the 610 * lowest unit number is preferred; loopback is ignored. 611 */ 612char * 613pcap_lookupdev(errbuf) 614 register char *errbuf; 615{ 616 pcap_if_t *alldevs; 617/* for old BSD systems, including bsdi3 */ 618#ifndef IF_NAMESIZE 619#define IF_NAMESIZE IFNAMSIZ 620#endif 621 static char device[IF_NAMESIZE + 1]; 622 char *ret; 623 624 if (pcap_findalldevs(&alldevs, errbuf) == -1) 625 return (NULL); 626 627 if (alldevs == NULL || (alldevs->flags & PCAP_IF_LOOPBACK)) { 628 /* 629 * There are no devices on the list, or the first device 630 * on the list is a loopback device, which means there 631 * are no non-loopback devices on the list. This means 632 * we can't return any device. 633 * 634 * XXX - why not return a loopback device? If we can't 635 * capture on it, it won't be on the list, and if it's 636 * on the list, there aren't any non-loopback devices, 637 * so why not just supply it as the default device? 638 */ 639 (void)strlcpy(errbuf, "no suitable device found", 640 PCAP_ERRBUF_SIZE); 641 ret = NULL; 642 } else { 643 /* 644 * Return the name of the first device on the list. 645 */ 646 (void)strlcpy(device, alldevs->name, sizeof(device)); 647 ret = device; 648 } 649 650 pcap_freealldevs(alldevs); 651 return (ret); 652} 653 654int 655pcap_lookupnet(device, netp, maskp, errbuf) 656 register const char *device; 657 register bpf_u_int32 *netp, *maskp; 658 register char *errbuf; 659{ 660 register int fd; 661 register struct sockaddr_in *sin4; 662 struct ifreq ifr; 663 664 /* 665 * The pseudo-device "any" listens on all interfaces and therefore 666 * has the network address and -mask "0.0.0.0" therefore catching 667 * all traffic. Using NULL for the interface is the same as "any". 668 */ 669 if (!device || strcmp(device, "any") == 0 670#ifdef HAVE_DAG_API 671 || strstr(device, "dag") != NULL 672#endif 673#ifdef HAVE_SEPTEL_API 674 || strstr(device, "septel") != NULL 675#endif 676#ifdef PCAP_SUPPORT_BT 677 || strstr(device, "bluetooth") != NULL 678#endif 679#ifdef PCAP_SUPPORT_USB 680 || strstr(device, "usb") != NULL 681#endif 682 ) { 683 *netp = *maskp = 0; 684 return 0; 685 } 686 687 fd = socket(AF_INET, SOCK_DGRAM, 0); 688 if (fd < 0) { 689 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "socket: %s", 690 pcap_strerror(errno)); 691 return (-1); 692 } 693 memset(&ifr, 0, sizeof(ifr)); 694#ifdef linux 695 /* XXX Work around Linux kernel bug */ 696 ifr.ifr_addr.sa_family = AF_INET; 697#endif 698 (void)strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name)); 699 if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0) { 700 if (errno == EADDRNOTAVAIL) { 701 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 702 "%s: no IPv4 address assigned", device); 703 } else { 704 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 705 "SIOCGIFADDR: %s: %s", 706 device, pcap_strerror(errno)); 707 } 708 (void)close(fd); 709 return (-1); 710 } 711 sin4 = (struct sockaddr_in *)&ifr.ifr_addr; 712 *netp = sin4->sin_addr.s_addr; 713 if (ioctl(fd, SIOCGIFNETMASK, (char *)&ifr) < 0) { 714 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 715 "SIOCGIFNETMASK: %s: %s", device, pcap_strerror(errno)); 716 (void)close(fd); 717 return (-1); 718 } 719 (void)close(fd); 720 *maskp = sin4->sin_addr.s_addr; 721 if (*maskp == 0) { 722 if (IN_CLASSA(*netp)) 723 *maskp = IN_CLASSA_NET; 724 else if (IN_CLASSB(*netp)) 725 *maskp = IN_CLASSB_NET; 726 else if (IN_CLASSC(*netp)) 727 *maskp = IN_CLASSC_NET; 728 else { 729 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 730 "inet class for 0x%x unknown", *netp); 731 return (-1); 732 } 733 } 734 *netp &= *maskp; 735 return (0); 736} 737 738#elif defined(WIN32) 739 740/* 741 * Return the name of a network interface attached to the system, or NULL 742 * if none can be found. The interface must be configured up; the 743 * lowest unit number is preferred; loopback is ignored. 744 */ 745char * 746pcap_lookupdev(errbuf) 747 register char *errbuf; 748{ 749 DWORD dwVersion; 750 DWORD dwWindowsMajorVersion; 751 dwVersion = GetVersion(); /* get the OS version */ 752 dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion))); 753 754 if (dwVersion >= 0x80000000 && dwWindowsMajorVersion >= 4) { 755 /* 756 * Windows 95, 98, ME. 757 */ 758 ULONG NameLength = 8192; 759 static char AdaptersName[8192]; 760 761 if (PacketGetAdapterNames(AdaptersName,&NameLength) ) 762 return (AdaptersName); 763 else 764 return NULL; 765 } else { 766 /* 767 * Windows NT (NT 4.0, W2K, WXP). Convert the names to UNICODE for backward compatibility 768 */ 769 ULONG NameLength = 8192; 770 static WCHAR AdaptersName[8192]; 771 char *tAstr; 772 WCHAR *tUstr; 773 WCHAR *TAdaptersName = (WCHAR*)malloc(8192 * sizeof(WCHAR)); 774 int NAdapts = 0; 775 776 if(TAdaptersName == NULL) 777 { 778 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "memory allocation failure"); 779 return NULL; 780 } 781 782 if ( !PacketGetAdapterNames((PTSTR)TAdaptersName,&NameLength) ) 783 { 784 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, 785 "PacketGetAdapterNames: %s", 786 pcap_win32strerror()); 787 free(TAdaptersName); 788 return NULL; 789 } 790 791 792 tAstr = (char*)TAdaptersName; 793 tUstr = (WCHAR*)AdaptersName; 794 795 /* 796 * Convert and copy the device names 797 */ 798 while(sscanf(tAstr, "%S", tUstr) > 0) 799 { 800 tAstr += strlen(tAstr) + 1; 801 tUstr += wcslen(tUstr) + 1; 802 NAdapts ++; 803 } 804 805 tAstr++; 806 *tUstr = 0; 807 tUstr++; 808 809 /* 810 * Copy the descriptions 811 */ 812 while(NAdapts--) 813 { 814 strcpy((char*)tUstr, tAstr); 815 (char*)tUstr += strlen(tAstr) + 1;; 816 tAstr += strlen(tAstr) + 1; 817 } 818 819 free(TAdaptersName); 820 return (char *)(AdaptersName); 821 } 822} 823 824 825int 826pcap_lookupnet(device, netp, maskp, errbuf) 827 register const char *device; 828 register bpf_u_int32 *netp, *maskp; 829 register char *errbuf; 830{ 831 /* 832 * We need only the first IPv4 address, so we must scan the array returned by PacketGetNetInfo() 833 * in order to skip non IPv4 (i.e. IPv6 addresses) 834 */ 835 npf_if_addr if_addrs[MAX_NETWORK_ADDRESSES]; 836 LONG if_addr_size = 1; 837 struct sockaddr_in *t_addr; 838 unsigned int i; 839 840 if (!PacketGetNetInfoEx((void *)device, if_addrs, &if_addr_size)) { 841 *netp = *maskp = 0; 842 return (0); 843 } 844 845 for(i=0; i<MAX_NETWORK_ADDRESSES; i++) 846 { 847 if(if_addrs[i].IPAddress.ss_family == AF_INET) 848 { 849 t_addr = (struct sockaddr_in *) &(if_addrs[i].IPAddress); 850 *netp = t_addr->sin_addr.S_un.S_addr; 851 t_addr = (struct sockaddr_in *) &(if_addrs[i].SubnetMask); 852 *maskp = t_addr->sin_addr.S_un.S_addr; 853 854 *netp &= *maskp; 855 return (0); 856 } 857 858 } 859 860 *netp = *maskp = 0; 861 return (0); 862} 863 864#endif /* !WIN32 && !MSDOS */ 865