git.oblomov.eu Git - wine/blob - dlls/iphlpapi/ifenum.c

   1 /* Copyright (C) 2003,2006,2011 Juan Lang
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  16  */
  17
  18 #include "config.h"
  19
  20 #include <stdarg.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28
  29 #include <sys/types.h>
  30 #ifdef HAVE_SYS_PARAM_H
  31 #include <sys/param.h>
  32 #endif
  33
  34 #ifdef HAVE_SYS_SOCKET_H
  35 #include <sys/socket.h>
  36 #endif
  37
  38 #ifdef HAVE_NETINET_IN_H
  39 #include <netinet/in.h>
  40 #endif
  41
  42 #ifdef HAVE_ARPA_INET_H
  43 #include <arpa/inet.h>
  44 #endif
  45
  46 #ifdef HAVE_NET_IF_H
  47 #include <net/if.h>
  48 #endif
  49
  50 #ifdef HAVE_NET_IF_ARP_H
  51 #include <net/if_arp.h>
  52 #endif
  53
  54 #ifdef HAVE_NET_ROUTE_H
  55 #include <net/route.h>
  56 #endif
  57
  58 #ifdef HAVE_SYS_IOCTL_H
  59 #include <sys/ioctl.h>
  60 #endif
  61
  62 #ifdef HAVE_SYS_SYSCTL_H
  63 #include <sys/sysctl.h>
  64 #endif
  65
  66 #ifdef HAVE_SYS_SOCKIO_H
  67 #include <sys/sockio.h>
  68 #endif
  69
  70 #ifdef HAVE_NET_IF_DL_H
  71 #include <net/if_dl.h>
  72 #endif
  73
  74 #ifdef HAVE_NET_IF_TYPES_H
  75 #include <net/if_types.h>
  76 #endif
  77
  78 #ifdef HAVE_IFADDRS_H
  79 #include <ifaddrs.h>
  80 #endif
  81
  82 #include "ifenum.h"
  83 #include "ws2ipdef.h"
  84
  85 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
  86 #define ifreq_len(ifr) \
  87  max(sizeof(struct ifreq), sizeof((ifr)->ifr_name)+(ifr)->ifr_addr.sa_len)
  88 #else
  89 #define ifreq_len(ifr) sizeof(struct ifreq)
  90 #endif
  91
  92 #ifndef ETH_ALEN
  93 #define ETH_ALEN 6
  94 #endif
  95
  96 #ifndef IF_NAMESIZE
  97 #define IF_NAMESIZE 16
  98 #endif
  99
 100 #ifndef INADDR_NONE
 101 #define INADDR_NONE (~0U)
 102 #endif
 103
 104 #define INITIAL_INTERFACES_ASSUMED 4
 105
 106 /* Functions */
 107
 108 static int isLoopbackInterface(int fd, const char *name)
 109 {
 110   int ret = 0;
 111
 112   if (name) {
 113     struct ifreq ifr;
 114
 115     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 116     if (ioctl(fd, SIOCGIFFLAGS, &ifr) == 0)
 117       ret = ifr.ifr_flags & IFF_LOOPBACK;
 118   }
 119   return ret;
 120 }
 121
 122 /* The comments say MAX_ADAPTER_NAME is required, but really only IF_NAMESIZE
 123  * bytes are necessary.
 124  */
 125 char *getInterfaceNameByIndex(IF_INDEX index, char *name)
 126 {
 127   return if_indextoname(index, name);
 128 }
 129
 130 DWORD getInterfaceIndexByName(const char *name, IF_INDEX *index)
 131 {
 132   DWORD ret;
 133   unsigned int idx;
 134
 135   if (!name)
 136     return ERROR_INVALID_PARAMETER;
 137   if (!index)
 138     return ERROR_INVALID_PARAMETER;
 139   idx = if_nametoindex(name);
 140   if (idx) {
 141     *index = idx;
 142     ret = NO_ERROR;
 143   }
 144   else
 145     ret = ERROR_INVALID_DATA;
 146   return ret;
 147 }
 148
 149 BOOL isIfIndexLoopback(ULONG idx)
 150 {
 151   BOOL ret = FALSE;
 152   char name[IFNAMSIZ];
 153   int fd;
 154
 155   getInterfaceNameByIndex(idx, name);
 156   fd = socket(PF_INET, SOCK_DGRAM, 0);
 157   if (fd != -1) {
 158     ret = isLoopbackInterface(fd, name);
 159     close(fd);
 160   }
 161   return ret;
 162 }
 163
 164 DWORD getNumNonLoopbackInterfaces(void)
 165 {
 166   DWORD numInterfaces;
 167   int fd = socket(PF_INET, SOCK_DGRAM, 0);
 168
 169   if (fd != -1) {
 170     struct if_nameindex *indexes = if_nameindex();
 171
 172     if (indexes) {
 173       struct if_nameindex *p;
 174
 175       for (p = indexes, numInterfaces = 0; p && p->if_name; p++)
 176         if (!isLoopbackInterface(fd, p->if_name))
 177           numInterfaces++;
 178       if_freenameindex(indexes);
 179     }
 180     else
 181       numInterfaces = 0;
 182     close(fd);
 183   }
 184   else
 185     numInterfaces = 0;
 186   return numInterfaces;
 187 }
 188
 189 DWORD getNumInterfaces(void)
 190 {
 191   DWORD numInterfaces;
 192   struct if_nameindex *indexes = if_nameindex();
 193
 194   if (indexes) {
 195     struct if_nameindex *p;
 196
 197     for (p = indexes, numInterfaces = 0; p && p->if_name; p++)
 198       numInterfaces++;
 199     if_freenameindex(indexes);
 200   }
 201   else
 202     numInterfaces = 0;
 203   return numInterfaces;
 204 }
 205
 206 InterfaceIndexTable *getInterfaceIndexTable(void)
 207 {
 208   DWORD numInterfaces;
 209   InterfaceIndexTable *ret;
 210   struct if_nameindex *indexes = if_nameindex();
 211
 212   if (indexes) {
 213     struct if_nameindex *p;
 214     DWORD size = sizeof(InterfaceIndexTable);
 215
 216     for (p = indexes, numInterfaces = 0; p && p->if_name; p++)
 217       numInterfaces++;
 218     if (numInterfaces > 1)
 219       size += (numInterfaces - 1) * sizeof(DWORD);
 220     ret = HeapAlloc(GetProcessHeap(), 0, size);
 221     if (ret) {
 222       ret->numIndexes = 0;
 223       for (p = indexes; p && p->if_name; p++)
 224         ret->indexes[ret->numIndexes++] = p->if_index;
 225     }
 226     if_freenameindex(indexes);
 227   }
 228   else
 229     ret = NULL;
 230   return ret;
 231 }
 232
 233 InterfaceIndexTable *getNonLoopbackInterfaceIndexTable(void)
 234 {
 235   DWORD numInterfaces;
 236   InterfaceIndexTable *ret;
 237   int fd = socket(PF_INET, SOCK_DGRAM, 0);
 238
 239   if (fd != -1) {
 240     struct if_nameindex *indexes = if_nameindex();
 241
 242     if (indexes) {
 243       struct if_nameindex *p;
 244       DWORD size = sizeof(InterfaceIndexTable);
 245
 246       for (p = indexes, numInterfaces = 0; p && p->if_name; p++)
 247         if (!isLoopbackInterface(fd, p->if_name))
 248           numInterfaces++;
 249       if (numInterfaces > 1)
 250         size += (numInterfaces - 1) * sizeof(DWORD);
 251       ret = HeapAlloc(GetProcessHeap(), 0, size);
 252       if (ret) {
 253         ret->numIndexes = 0;
 254         for (p = indexes; p && p->if_name; p++)
 255           if (!isLoopbackInterface(fd, p->if_name))
 256             ret->indexes[ret->numIndexes++] = p->if_index;
 257       }
 258       if_freenameindex(indexes);
 259     }
 260     else
 261       ret = NULL;
 262     close(fd);
 263   }
 264   else
 265     ret = NULL;
 266   return ret;
 267 }
 268
 269 static DWORD getInterfaceBCastAddrByName(const char *name)
 270 {
 271   DWORD ret = INADDR_ANY;
 272
 273   if (name) {
 274     int fd = socket(PF_INET, SOCK_DGRAM, 0);
 275
 276     if (fd != -1) {
 277       struct ifreq ifr;
 278
 279       lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 280       if (ioctl(fd, SIOCGIFBRDADDR, &ifr) == 0)
 281         memcpy(&ret, ifr.ifr_addr.sa_data + 2, sizeof(DWORD));
 282       close(fd);
 283     }
 284   }
 285   return ret;
 286 }
 287
 288 static DWORD getInterfaceMaskByName(const char *name)
 289 {
 290   DWORD ret = INADDR_NONE;
 291
 292   if (name) {
 293     int fd = socket(PF_INET, SOCK_DGRAM, 0);
 294
 295     if (fd != -1) {
 296       struct ifreq ifr;
 297
 298       lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 299       if (ioctl(fd, SIOCGIFNETMASK, &ifr) == 0)
 300         memcpy(&ret, ifr.ifr_addr.sa_data + 2, sizeof(DWORD));
 301       close(fd);
 302     }
 303   }
 304   return ret;
 305 }
 306
 307 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
 308 static DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
 309  PDWORD type)
 310 {
 311   DWORD ret;
 312   int fd;
 313
 314   if (!name || !len || !addr || !type)
 315     return ERROR_INVALID_PARAMETER;
 316
 317   fd = socket(PF_INET, SOCK_DGRAM, 0);
 318   if (fd != -1) {
 319     struct ifreq ifr;
 320
 321     memset(&ifr, 0, sizeof(struct ifreq));
 322     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 323     if ((ioctl(fd, SIOCGIFHWADDR, &ifr)))
 324       ret = ERROR_INVALID_DATA;
 325     else {
 326       unsigned int addrLen;
 327
 328       switch (ifr.ifr_hwaddr.sa_family)
 329       {
 330 #ifdef ARPHRD_LOOPBACK
 331         case ARPHRD_LOOPBACK:
 332           addrLen = 0;
 333           *type = MIB_IF_TYPE_LOOPBACK;
 334           break;
 335 #endif
 336 #ifdef ARPHRD_ETHER
 337         case ARPHRD_ETHER:
 338           addrLen = ETH_ALEN;
 339           *type = MIB_IF_TYPE_ETHERNET;
 340           break;
 341 #endif
 342 #ifdef ARPHRD_FDDI
 343         case ARPHRD_FDDI:
 344           addrLen = ETH_ALEN;
 345           *type = MIB_IF_TYPE_FDDI;
 346           break;
 347 #endif
 348 #ifdef ARPHRD_IEEE802
 349         case ARPHRD_IEEE802: /* 802.2 Ethernet && Token Ring, guess TR? */
 350           addrLen = ETH_ALEN;
 351           *type = MIB_IF_TYPE_TOKENRING;
 352           break;
 353 #endif
 354 #ifdef ARPHRD_IEEE802_TR
 355         case ARPHRD_IEEE802_TR: /* also Token Ring? */
 356           addrLen = ETH_ALEN;
 357           *type = MIB_IF_TYPE_TOKENRING;
 358           break;
 359 #endif
 360 #ifdef ARPHRD_SLIP
 361         case ARPHRD_SLIP:
 362           addrLen = 0;
 363           *type = MIB_IF_TYPE_SLIP;
 364           break;
 365 #endif
 366 #ifdef ARPHRD_PPP
 367         case ARPHRD_PPP:
 368           addrLen = 0;
 369           *type = MIB_IF_TYPE_PPP;
 370           break;
 371 #endif
 372         default:
 373           addrLen = min(MAX_INTERFACE_PHYSADDR, sizeof(ifr.ifr_hwaddr.sa_data));
 374           *type = MIB_IF_TYPE_OTHER;
 375       }
 376       if (addrLen > *len) {
 377         ret = ERROR_INSUFFICIENT_BUFFER;
 378         *len = addrLen;
 379       }
 380       else {
 381         if (addrLen > 0)
 382           memcpy(addr, ifr.ifr_hwaddr.sa_data, addrLen);
 383         /* zero out remaining bytes for broken implementations */
 384         memset(addr + addrLen, 0, *len - addrLen);
 385         *len = addrLen;
 386         ret = NO_ERROR;
 387       }
 388     }
 389     close(fd);
 390   }
 391   else
 392     ret = ERROR_NO_MORE_FILES;
 393   return ret;
 394 }
 395 #elif defined (SIOCGARP)
 396 static DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
 397  PDWORD type)
 398 {
 399   DWORD ret;
 400   int fd;
 401
 402   if (!name || !len || !addr || !type)
 403     return ERROR_INVALID_PARAMETER;
 404
 405   fd = socket(PF_INET, SOCK_DGRAM, 0);
 406   if (fd != -1) {
 407     if (isLoopbackInterface(fd, name)) {
 408       *type = MIB_IF_TYPE_LOOPBACK;
 409       memset(addr, 0, *len);
 410       *len = 0;
 411       ret=NOERROR;
 412     }
 413     else {
 414       struct arpreq arp;
 415       struct sockaddr_in *saddr;
 416       struct ifreq ifr;
 417
 418       /* get IP addr */
 419       lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 420       ioctl(fd, SIOCGIFADDR, &ifr);
 421       memset(&arp, 0, sizeof(struct arpreq));
 422       arp.arp_pa.sa_family = AF_INET;
 423       saddr = (struct sockaddr_in *)&arp; /* proto addr is first member */
 424       saddr->sin_family = AF_INET;
 425       memcpy(&saddr->sin_addr.s_addr, ifr.ifr_addr.sa_data + 2, sizeof(DWORD));
 426       if ((ioctl(fd, SIOCGARP, &arp)))
 427         ret = ERROR_INVALID_DATA;
 428       else {
 429         /* FIXME:  heh:  who said it was ethernet? */
 430         int addrLen = ETH_ALEN;
 431
 432         if (addrLen > *len) {
 433           ret = ERROR_INSUFFICIENT_BUFFER;
 434           *len = addrLen;
 435         }
 436         else {
 437           if (addrLen > 0)
 438             memcpy(addr, &arp.arp_ha.sa_data[0], addrLen);
 439           /* zero out remaining bytes for broken implementations */
 440           memset(addr + addrLen, 0, *len - addrLen);
 441           *len = addrLen;
 442           *type = MIB_IF_TYPE_ETHERNET;
 443           ret = NO_ERROR;
 444         }
 445       }
 446     }
 447     close(fd);
 448   }
 449     else
 450       ret = ERROR_NO_MORE_FILES;
 451
 452   return ret;
 453 }
 454 #elif defined (HAVE_SYS_SYSCTL_H) && defined (HAVE_NET_IF_DL_H)
 455 static DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
 456  PDWORD type)
 457 {
 458   DWORD ret;
 459   struct if_msghdr *ifm;
 460   struct sockaddr_dl *sdl;
 461   u_char *p, *buf;
 462   size_t mibLen;
 463   int mib[] = { CTL_NET, AF_ROUTE, 0, AF_LINK, NET_RT_IFLIST, 0 };
 464   unsigned addrLen;
 465   BOOL found = FALSE;
 466
 467   if (!name || !len || !addr || !type)
 468     return ERROR_INVALID_PARAMETER;
 469
 470   if (sysctl(mib, 6, NULL, &mibLen, NULL, 0) < 0)
 471     return ERROR_NO_MORE_FILES;
 472
 473   buf = HeapAlloc(GetProcessHeap(), 0, mibLen);
 474   if (!buf)
 475     return ERROR_NOT_ENOUGH_MEMORY;
 476
 477   if (sysctl(mib, 6, buf, &mibLen, NULL, 0) < 0) {
 478     HeapFree(GetProcessHeap(), 0, buf);
 479     return ERROR_NO_MORE_FILES;
 480   }
 481
 482   ret = ERROR_INVALID_DATA;
 483   for (p = buf; !found && p < buf + mibLen; p += ifm->ifm_msglen) {
 484     ifm = (struct if_msghdr *)p;
 485     sdl = (struct sockaddr_dl *)(ifm + 1);
 486
 487     if (ifm->ifm_type != RTM_IFINFO || (ifm->ifm_addrs & RTA_IFP) == 0)
 488       continue;
 489
 490     if (sdl->sdl_family != AF_LINK || sdl->sdl_nlen == 0 ||
 491      memcmp(sdl->sdl_data, name, max(sdl->sdl_nlen, strlen(name))) != 0)
 492       continue;
 493
 494     found = TRUE;
 495     addrLen = min(MAX_INTERFACE_PHYSADDR, sdl->sdl_alen);
 496     if (addrLen > *len) {
 497       ret = ERROR_INSUFFICIENT_BUFFER;
 498       *len = addrLen;
 499     }
 500     else {
 501       if (addrLen > 0)
 502         memcpy(addr, LLADDR(sdl), addrLen);
 503       /* zero out remaining bytes for broken implementations */
 504       memset(addr + addrLen, 0, *len - addrLen);
 505       *len = addrLen;
 506 #if defined(HAVE_NET_IF_TYPES_H)
 507       switch (sdl->sdl_type)
 508       {
 509         case IFT_ETHER:
 510           *type = MIB_IF_TYPE_ETHERNET;
 511           break;
 512         case IFT_FDDI:
 513           *type = MIB_IF_TYPE_FDDI;
 514           break;
 515         case IFT_ISO88024: /* Token Bus */
 516           *type = MIB_IF_TYPE_TOKENRING;
 517           break;
 518         case IFT_ISO88025: /* Token Ring */
 519           *type = MIB_IF_TYPE_TOKENRING;
 520           break;
 521         case IFT_PPP:
 522           *type = MIB_IF_TYPE_PPP;
 523           break;
 524         case IFT_SLIP:
 525           *type = MIB_IF_TYPE_SLIP;
 526           break;
 527         case IFT_LOOP:
 528           *type = MIB_IF_TYPE_LOOPBACK;
 529           break;
 530         default:
 531           *type = MIB_IF_TYPE_OTHER;
 532       }
 533 #else
 534       /* default if we don't know */
 535       *type = MIB_IF_TYPE_ETHERNET;
 536 #endif
 537       ret = NO_ERROR;
 538     }
 539   }
 540   HeapFree(GetProcessHeap(), 0, buf);
 541   return ret;
 542 }
 543 #endif
 544
 545 DWORD getInterfacePhysicalByIndex(IF_INDEX index, PDWORD len, PBYTE addr,
 546  PDWORD type)
 547 {
 548   char nameBuf[IF_NAMESIZE];
 549   char *name = getInterfaceNameByIndex(index, nameBuf);
 550
 551   if (name)
 552     return getInterfacePhysicalByName(name, len, addr, type);
 553   else
 554     return ERROR_INVALID_DATA;
 555 }
 556
 557 DWORD getInterfaceMtuByName(const char *name, PDWORD mtu)
 558 {
 559   DWORD ret;
 560   int fd;
 561
 562   if (!name)
 563     return ERROR_INVALID_PARAMETER;
 564   if (!mtu)
 565     return ERROR_INVALID_PARAMETER;
 566
 567   fd = socket(PF_INET, SOCK_DGRAM, 0);
 568   if (fd != -1) {
 569     struct ifreq ifr;
 570
 571     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 572     if ((ioctl(fd, SIOCGIFMTU, &ifr)))
 573       ret = ERROR_INVALID_DATA;
 574     else {
 575 #ifndef __sun
 576       *mtu = ifr.ifr_mtu;
 577 #else
 578       *mtu = ifr.ifr_metric;
 579 #endif
 580       ret = NO_ERROR;
 581     }
 582     close(fd);
 583   }
 584   else
 585     ret = ERROR_NO_MORE_FILES;
 586   return ret;
 587 }
 588
 589 DWORD getInterfaceStatusByName(const char *name, INTERNAL_IF_OPER_STATUS *status)
 590 {
 591   DWORD ret;
 592   int fd;
 593
 594   if (!name)
 595     return ERROR_INVALID_PARAMETER;
 596   if (!status)
 597     return ERROR_INVALID_PARAMETER;
 598
 599   fd = socket(PF_INET, SOCK_DGRAM, 0);
 600   if (fd != -1) {
 601     struct ifreq ifr;
 602
 603     lstrcpynA(ifr.ifr_name, name, IFNAMSIZ);
 604     if ((ioctl(fd, SIOCGIFFLAGS, &ifr)))
 605       ret = ERROR_INVALID_DATA;
 606     else {
 607       if (ifr.ifr_flags & IFF_UP)
 608         *status = MIB_IF_OPER_STATUS_OPERATIONAL;
 609       else
 610         *status = MIB_IF_OPER_STATUS_NON_OPERATIONAL;
 611       ret = NO_ERROR;
 612     }
 613     close(fd);
 614   }
 615   else
 616     ret = ERROR_NO_MORE_FILES;
 617   return ret;
 618 }
 619
 620 DWORD getInterfaceEntryByName(const char *name, PMIB_IFROW entry)
 621 {
 622   BYTE addr[MAX_INTERFACE_PHYSADDR];
 623   DWORD ret, len = sizeof(addr), type;
 624
 625   if (!name)
 626     return ERROR_INVALID_PARAMETER;
 627   if (!entry)
 628     return ERROR_INVALID_PARAMETER;
 629
 630   if (getInterfacePhysicalByName(name, &len, addr, &type) == NO_ERROR) {
 631     WCHAR *assigner;
 632     const char *walker;
 633
 634     memset(entry, 0, sizeof(MIB_IFROW));
 635     for (assigner = entry->wszName, walker = name; *walker;
 636      walker++, assigner++)
 637       *assigner = *walker;
 638     *assigner = 0;
 639     getInterfaceIndexByName(name, &entry->dwIndex);
 640     entry->dwPhysAddrLen = len;
 641     memcpy(entry->bPhysAddr, addr, len);
 642     memset(entry->bPhysAddr + len, 0, sizeof(entry->bPhysAddr) - len);
 643     entry->dwType = type;
 644     /* FIXME: how to calculate real speed? */
 645     getInterfaceMtuByName(name, &entry->dwMtu);
 646     /* lie, there's no "administratively down" here */
 647     entry->dwAdminStatus = MIB_IF_ADMIN_STATUS_UP;
 648     getInterfaceStatusByName(name, &entry->dwOperStatus);
 649     /* punt on dwLastChange? */
 650     entry->dwDescrLen = min(strlen(name), MAX_INTERFACE_DESCRIPTION - 1);
 651     memcpy(entry->bDescr, name, entry->dwDescrLen);
 652     entry->bDescr[entry->dwDescrLen] = '\0';
 653     entry->dwDescrLen++;
 654     ret = NO_ERROR;
 655   }
 656   else
 657     ret = ERROR_INVALID_DATA;
 658   return ret;
 659 }
 660
 661 static DWORD getIPAddrRowByName(PMIB_IPADDRROW ipAddrRow, const char *ifName,
 662  const struct sockaddr *sa)
 663 {
 664   DWORD ret, bcast;
 665
 666   ret = getInterfaceIndexByName(ifName, &ipAddrRow->dwIndex);
 667   memcpy(&ipAddrRow->dwAddr, sa->sa_data + 2, sizeof(DWORD));
 668   ipAddrRow->dwMask = getInterfaceMaskByName(ifName);
 669   /* the dwBCastAddr member isn't the broadcast address, it indicates whether
 670    * the interface uses the 1's broadcast address (1) or the 0's broadcast
 671    * address (0).
 672    */
 673   bcast = getInterfaceBCastAddrByName(ifName);
 674   ipAddrRow->dwBCastAddr = (bcast & ipAddrRow->dwMask) ? 1 : 0;
 675   /* FIXME: hardcoded reasm size, not sure where to get it */
 676   ipAddrRow->dwReasmSize = 65535;
 677   ipAddrRow->unused1 = 0;
 678   ipAddrRow->wType = 0;
 679   return ret;
 680 }
 681
 682 #ifdef HAVE_IFADDRS_H
 683
 684 /* Counts the IPv4 addresses in the system using the return value from
 685  * getifaddrs, returning the count.
 686  */
 687 static DWORD countIPv4Addresses(struct ifaddrs *ifa)
 688 {
 689   DWORD numAddresses = 0;
 690
 691   for (; ifa; ifa = ifa->ifa_next)
 692     if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET)
 693       numAddresses++;
 694   return numAddresses;
 695 }
 696
 697 DWORD getNumIPAddresses(void)
 698 {
 699   DWORD numAddresses = 0;
 700   struct ifaddrs *ifa;
 701
 702   if (!getifaddrs(&ifa))
 703   {
 704     numAddresses = countIPv4Addresses(ifa);
 705     freeifaddrs(ifa);
 706   }
 707   return numAddresses;
 708 }
 709
 710 DWORD getIPAddrTable(PMIB_IPADDRTABLE *ppIpAddrTable, HANDLE heap, DWORD flags)
 711 {
 712   DWORD ret;
 713
 714   if (!ppIpAddrTable)
 715     ret = ERROR_INVALID_PARAMETER;
 716   else
 717   {
 718     struct ifaddrs *ifa;
 719
 720     if (!getifaddrs(&ifa))
 721     {
 722       DWORD size = sizeof(MIB_IPADDRTABLE);
 723       DWORD numAddresses = countIPv4Addresses(ifa);
 724
 725       if (numAddresses > 1)
 726         size += (numAddresses - 1) * sizeof(MIB_IPADDRROW);
 727       *ppIpAddrTable = HeapAlloc(heap, flags, size);
 728       if (*ppIpAddrTable)
 729       {
 730         DWORD i = 0;
 731         struct ifaddrs *ifp;
 732
 733         ret = NO_ERROR;
 734         (*ppIpAddrTable)->dwNumEntries = numAddresses;
 735         for (ifp = ifa; !ret && ifp; ifp = ifp->ifa_next)
 736         {
 737           if (!ifp->ifa_addr || ifp->ifa_addr->sa_family != AF_INET)
 738             continue;
 739
 740           ret = getIPAddrRowByName(&(*ppIpAddrTable)->table[i], ifp->ifa_name,
 741            ifp->ifa_addr);
 742           i++;
 743         }
 744       }
 745       else
 746         ret = ERROR_OUTOFMEMORY;
 747       freeifaddrs(ifa);
 748     }
 749     else
 750       ret = ERROR_INVALID_PARAMETER;
 751   }
 752   return ret;
 753 }
 754
 755 ULONG v6addressesFromIndex(IF_INDEX index, SOCKET_ADDRESS **addrs, ULONG *num_addrs)
 756 {
 757   struct ifaddrs *ifa;
 758   ULONG ret;
 759
 760   if (!getifaddrs(&ifa))
 761   {
 762     struct ifaddrs *p;
 763     ULONG n;
 764     char name[IFNAMSIZ];
 765
 766     getInterfaceNameByIndex(index, name);
 767     for (p = ifa, n = 0; p; p = p->ifa_next)
 768       if (p->ifa_addr && p->ifa_addr->sa_family == AF_INET6 &&
 769           !strcmp(name, p->ifa_name))
 770         n++;
 771     if (n)
 772     {
 773       *addrs = HeapAlloc(GetProcessHeap(), 0, n * (sizeof(SOCKET_ADDRESS) +
 774                          sizeof(struct WS_sockaddr_in6)));
 775       if (*addrs)
 776       {
 777         struct WS_sockaddr_in6 *next_addr = (struct WS_sockaddr_in6 *)(
 778             (BYTE *)*addrs + n * sizeof(SOCKET_ADDRESS));
 779
 780         for (p = ifa, n = 0; p; p = p->ifa_next)
 781         {
 782           if (p->ifa_addr && p->ifa_addr->sa_family == AF_INET6 &&
 783               !strcmp(name, p->ifa_name))
 784           {
 785             struct sockaddr_in6 *addr = (struct sockaddr_in6 *)p->ifa_addr;
 786
 787             next_addr->sin6_family = WS_AF_INET6;
 788             next_addr->sin6_port = addr->sin6_port;
 789             next_addr->sin6_flowinfo = addr->sin6_flowinfo;
 790             memcpy(&next_addr->sin6_addr, &addr->sin6_addr,
 791              sizeof(next_addr->sin6_addr));
 792             next_addr->sin6_scope_id = addr->sin6_scope_id;
 793             (*addrs)[n].lpSockaddr = (LPSOCKADDR)next_addr;
 794             (*addrs)[n].iSockaddrLength = sizeof(struct WS_sockaddr_in6);
 795             next_addr++;
 796             n++;
 797           }
 798         }
 799         *num_addrs = n;
 800         ret = ERROR_SUCCESS;
 801       }
 802       else
 803         ret = ERROR_OUTOFMEMORY;
 804     }
 805     else
 806     {
 807       *addrs = NULL;
 808       *num_addrs = 0;
 809       ret = ERROR_SUCCESS;
 810     }
 811     freeifaddrs(ifa);
 812   }
 813   else
 814     ret = ERROR_NO_DATA;
 815   return ret;
 816 }
 817
 818 #else
 819
 820 /* Enumerates the IP addresses in the system using SIOCGIFCONF, returning
 821  * the count to you in *pcAddresses.  It also returns to you the struct ifconf
 822  * used by the call to ioctl, so that you may process the addresses further.
 823  * Free ifc->ifc_buf using HeapFree.
 824  * Returns NO_ERROR on success, something else on failure.
 825  */
 826 static DWORD enumIPAddresses(PDWORD pcAddresses, struct ifconf *ifc)
 827 {
 828   DWORD ret;
 829   int fd;
 830
 831   fd = socket(PF_INET, SOCK_DGRAM, 0);
 832   if (fd != -1) {
 833     int ioctlRet = 0;
 834     DWORD guessedNumAddresses = 0, numAddresses = 0;
 835     caddr_t ifPtr;
 836     int lastlen;
 837
 838     ret = NO_ERROR;
 839     ifc->ifc_len = 0;
 840     ifc->ifc_buf = NULL;
 841     /* there is no way to know the interface count beforehand,
 842        so we need to loop again and again upping our max each time
 843        until returned is constant across 2 calls */
 844     do {
 845       lastlen = ifc->ifc_len;
 846       HeapFree(GetProcessHeap(), 0, ifc->ifc_buf);
 847       if (guessedNumAddresses == 0)
 848         guessedNumAddresses = INITIAL_INTERFACES_ASSUMED;
 849       else
 850         guessedNumAddresses *= 2;
 851       ifc->ifc_len = sizeof(struct ifreq) * guessedNumAddresses;
 852       ifc->ifc_buf = HeapAlloc(GetProcessHeap(), 0, ifc->ifc_len);
 853       ioctlRet = ioctl(fd, SIOCGIFCONF, ifc);
 854     } while ((ioctlRet == 0) && (ifc->ifc_len != lastlen));
 855
 856     if (ioctlRet == 0) {
 857       ifPtr = ifc->ifc_buf;
 858       while (ifPtr && ifPtr < ifc->ifc_buf + ifc->ifc_len) {
 859         struct ifreq *ifr = (struct ifreq *)ifPtr;
 860
 861         if (ifr->ifr_addr.sa_family == AF_INET)
 862           numAddresses++;
 863
 864         ifPtr += ifreq_len((struct ifreq *)ifPtr);
 865       }
 866     }
 867     else
 868       ret = ERROR_INVALID_PARAMETER; /* FIXME: map from errno to Win32 */
 869     if (!ret)
 870       *pcAddresses = numAddresses;
 871     else
 872     {
 873       HeapFree(GetProcessHeap(), 0, ifc->ifc_buf);
 874       ifc->ifc_buf = NULL;
 875     }
 876     close(fd);
 877   }
 878   else
 879     ret = ERROR_NO_SYSTEM_RESOURCES;
 880   return ret;
 881 }
 882
 883 DWORD getNumIPAddresses(void)
 884 {
 885   DWORD numAddresses = 0;
 886   struct ifconf ifc;
 887
 888   if (!enumIPAddresses(&numAddresses, &ifc))
 889     HeapFree(GetProcessHeap(), 0, ifc.ifc_buf);
 890   return numAddresses;
 891 }
 892
 893 DWORD getIPAddrTable(PMIB_IPADDRTABLE *ppIpAddrTable, HANDLE heap, DWORD flags)
 894 {
 895   DWORD ret;
 896
 897   if (!ppIpAddrTable)
 898     ret = ERROR_INVALID_PARAMETER;
 899   else
 900   {
 901     DWORD numAddresses = 0;
 902     struct ifconf ifc;
 903
 904     ret = enumIPAddresses(&numAddresses, &ifc);
 905     if (!ret)
 906     {
 907       DWORD size = sizeof(MIB_IPADDRTABLE);
 908
 909       if (numAddresses > 1)
 910         size += (numAddresses - 1) * sizeof(MIB_IPADDRROW);
 911       *ppIpAddrTable = HeapAlloc(heap, flags, size);
 912       if (*ppIpAddrTable) {
 913         DWORD i = 0;
 914         caddr_t ifPtr;
 915
 916         ret = NO_ERROR;
 917         (*ppIpAddrTable)->dwNumEntries = numAddresses;
 918         ifPtr = ifc.ifc_buf;
 919         while (!ret && ifPtr && ifPtr < ifc.ifc_buf + ifc.ifc_len) {
 920           struct ifreq *ifr = (struct ifreq *)ifPtr;
 921
 922           ifPtr += ifreq_len(ifr);
 923
 924           if (ifr->ifr_addr.sa_family != AF_INET)
 925              continue;
 926
 927           ret = getIPAddrRowByName(&(*ppIpAddrTable)->table[i], ifr->ifr_name,
 928            &ifr->ifr_addr);
 929           i++;
 930         }
 931       }
 932       else
 933         ret = ERROR_OUTOFMEMORY;
 934       HeapFree(GetProcessHeap(), 0, ifc.ifc_buf);
 935     }
 936   }
 937   return ret;
 938 }
 939
 940 ULONG v6addressesFromIndex(IF_INDEX index, SOCKET_ADDRESS **addrs, ULONG *num_addrs)
 941 {
 942   *addrs = NULL;
 943   *num_addrs = 0;
 944   return ERROR_SUCCESS;
 945 }
 946
 947 #endif
 948
 949 char *toIPAddressString(unsigned int addr, char string[16])
 950 {
 951   if (string) {
 952     struct in_addr iAddr;
 953
 954     iAddr.s_addr = addr;
 955     /* extra-anal, just to make auditors happy */
 956     lstrcpynA(string, inet_ntoa(iAddr), 16);
 957   }
 958   return string;
 959 }